Introducing a new way to review your PRs.

Read the announcement

twentyhq / twenty

The open alternative to Salesforce, designed for AI.

View on GitHub

22 documents · Updated Nov 20, 2026

docs / ai-applications

AI features and application extensibility

Twenty connects workspace data, AI chat, agent work, and installable applications. Members can ask an assistant to inspect records, draft changes, or work with a team in a shared thread. Applications can add agents, workflows, server logic, connections, messaging, MCP access, and user-interface extensions within the same workspace access rules. See Automation and AI capabilities, Workflow execution, Installed applications, and Extension integrations.

AI capability model

AI has two linked uses. Chat gives a member a live workspace conversation. Agents and applications make repeatable AI work available to workflows, server logic, and outside assistants.

CapabilityPurposeMain relationship
AI chatGive members a workspace-aware conversationUses page context, files, mentions, skills, tools, and an allowed model
Inbox threadGroup and triage shared AI workSupports recipients, channels, assignment, follow state, and personal filters
Direct messageGive two members a private chatUses a stable member pair rather than a stored title
Model modeGive chat a simple speed or quality choiceResolves to a model that meets workspace data policy
AgentDefine a repeatable AI taskReturns text or structured data
SDK generationLet application logic request text or structured dataUses application identity and an optional data scope
SkillGive an agent task guidanceGuides a task without running the action
Pending requestPause work for input or approvalResumes the same turn after a reply
Tool viewShow a tool result as records or an application viewUses an installed view or the standard presentation
MCP serverLet an outside assistant use governed workspace toolsExposes authenticated tools rather than database access
ApplicationPackage AI and other extensionsOwns identity, permissions, logic, and UI

AI uses workspace and application boundaries instead of a separate data store. Agents and tools read workspace data through the caller's permitted role.

Chat workspace

The AI client turns a member message into saved conversation history. It can stream a reply, wait for a member, and recover from a broken connection while shared work stays visible to the right people.

Conversation threads

An AI conversation is a thread that can carry text, files, page context, record links, mentions, recipients, and an assistant reply choice. A new thread stays local until its first message creates the saved thread.

The client supports more than one chat surface at the same time. Each surface has an instance identity and a selected thread. The shared runtime tracks the open threads, loads their history, and keeps one live stream for each distinct thread. This lets a member move between a full page, a side panel, and an inbox without mixing their drafts or responses.

The client treats recent threads, preset filters, and channel views as separate list sources. It keeps each source's page state and cursor, merges new records with local records, loads favorites outside the recent page, refreshes permissions, and rejects stale responses before changing the selected view.

The inbox is a shared work queue over these threads. Members can mark work done, snooze it, assign it, follow it, move it between channels, or reopen it. Direct messages use a member pair and do not use the shared-thread context or model controls.

The client keeps a draft for each thread. A failed first send keeps enough text and file state for a retry. Opening a visible thread updates read state. Typing presence, message receipts, reactions, unread boundaries, and sender identity help members understand shared work without changing access rules.

References: packages/…/AiChatInstance.tsx• L10-40 packages/…/AiChatProvider.tsx• L8-21 packages/…/AiChatRuntimeEffects.tsx• L9-28 packages/…/AiChatPageThreadLoadEffect.tsx• L10-44 packages/…/useSwitchToNewAiChat.ts• L12-48

Conversation context

The chat surface ties a message to the page that a member sees. A record page can provide a record target. A list can provide its view and filters. A settings page can provide its path. Members can add files, records, skills, mentions, recipients, and quoted messages through the composer.

The composer checks the message before send. It needs text and finished uploads. A new shared thread also needs a valid member, assistant, mention, or channel target. A direct message has a smaller contract and does not use page context, model choice, files, skills, or member mentions.

New shared threads can suggest the assistant, workspace members, and accessible channels as recipients. This turns a new chat into a shared work thread when the member selects people or a channel. The same recipient state controls send validation and the participants added to the saved thread.

References: packages/…/AiChatEditorSection.tsx• L144-189 packages/…/AiChatEditorSection.tsx• L247-270 packages/…/AiChatNewThreadRecipientField.tsx• L57-105 packages/…/useAiChatNewThreadRecipientSuggestions.ts• L22-110 packages/…/useAiChat.ts• L388-582 packages/…/serializeAiChatEditorDraft.ts• L6-16

Message parts and tool views

Assistant output is a set of typed message parts. Text and status parts form the reply. Reasoning and tool work form a compact group. Other parts can show records, code output, files, sources, or an application-owned view.

The client exposes questions, forms, and proposed actions as active requests. A member can review a record action one card at a time, skip selected records, deny one action, or approve the remaining actions. Once an action starts, its review is read-only.

Email actions have a focused review flow. A member can edit recipients, subject, and rich body content before choosing to send or save a draft when the proposed tools allow both actions. The server validates the email document, connected account, recipients, permissions, and attachments before it performs the action.

An installed application can supply a front component for a tool. Chat passes the tool name, status, input, output, and error to that component. Without a usable component, the standard tool view remains the fallback. The same component can edit tool arguments during approval when the host permits it.

References: packages/…/AiChatMessage.tsx• L219-237 packages/…/AiChatPendingAskGate.tsx• L36-57 packages/…/AiChatRecordApprovalDeck.tsx• L49-83 packages/…/AiChatToolCallApprovalArgumentsCard.tsx• L22-131 packages/…/AiChatToolCallApprovalEmailCard.tsx• L49-151 packages/…/AiChatToolFrontComponent.tsx• L21-48 packages/…/email-composer.service.ts• L357-457

Stream recovery

Chat streaming is a live view over saved history. The client orders stream events, reloads saved messages after a reconnect, and clears cached data when access is denied so late events cannot restore content that the member can no longer read.

The client watches keepalive events and retries a quiet stream a limited number of times. Record, participant, reaction, and thread events refresh the affected chat state. A stream can end before all saved parts are visible, so history remains the source for catch-up.

This diagram shows how a sent message reaches the live view and then becomes saved history.

flowchart LR
  A[Member message] --> B[Saved chat request]
  B --> C[Live stream events]
  C --> D[Displayed message parts]
  C --> E[Saved history]
  D --> F{Stream ends or reconnects}
  F -->|Catch up| E
  E --> D

References: packages/…/AiChatRuntimeEffects.tsx• L19-27 packages/…/AiChatStreamSubscriptionEffect.tsx• L24-85 packages/…/AiChatMessagesFetchEffect.tsx• L68-145 packages/…/useAiChatSubscription.ts• L227-269 packages/…/useAiChatSubscription.ts• L355-484

Model and usage boundary

Models connect Twenty's AI features to outside providers. A model catalog describes input support, context size, reasoning, cost, quality, and data residency. Workspace policy filters this catalog before chat or agent work can select a model.

Model modes

Chat presents speed and quality choices instead of exposing provider names as part of the chat contract. Automatic tiers choose a compliant model for the workspace's data residency and zero-data-retention settings. A workspace can instead pin a model for a tier.

The selected model must support the requested input and be available through a configured provider. Native capabilities such as web search or X search are separate model features. If no compliant model exists, the tier stays unavailable.

References: packages/…/useAiChatModelId.ts• L1-80 packages/…/AiModelTierDropdown.tsx• L1-100 packages/…/AiChatEditorSection.tsx• L186-188 packages/…/useAiChat.ts• L489-496

Context and credits

The client shows context-window use and credit use so a member can see the cost boundary of a turn. Workspace and user credit limits apply to chat and agent runs.

The system checks credits before work and during multi-step work. If credits end, later model steps stop and the turn records a failure instead of returning incomplete output as a success.

References: packages/…/AiChatContextUsageButton.tsx• L1-100 packages/…/AiChatUserCreditsExhaustedBanner.tsx• L1-80 packages/…/useAiChatSubscription.ts• L320-347 packages/…/ai-chat-usage.resolver.ts• L19-59

Agent and application model

An agent is a named AI capability with instructions, a model choice, a role, and an output shape. An application can own an agent and call it from server logic, a workflow, or an external client.

Agent definitions

An agent can return text or structured data. Structured output gives workflows and applications named fields that they can use in later steps. Agents follow the ownership and access rules of their workspace or application.

Agents can start from scheduled work or record events. Record-event settings can select an object, action, watched fields, a condition, and batch mode. The SDK validates these settings and still accepts the older database-event form while applications move to the record-event form. A trigger has a stable identity and a bounded instruction size.

Agent model settings can enable supported native capabilities such as web search and Twitter search. The SDK rejects unknown or malformed capability settings before an application reaches a workspace.

References: packages/…/define-agent.ts• L22-211 packages/…/get-record-event-trigger-settings-errors.ts• L19-102 packages/…/get-database-event-trigger-settings-errors.ts• L5-34

Agent runs

An agent run is one caller's turn in a conversation. The runner queues work, records the caller identity, rebuilds the access context for each continuation, and returns one outcome for the complete run.

An application can continue a conversation with a stable thread key. A run can pause for an answer, time, or an event. A queued continuation then resumes the same conversation and publishes a settled result. Tool access is limited by the caller's application boundary and the agent's granted role.

This diagram shows a caller moving through a queued run that can pause and resume.

flowchart LR
  A[Application or workflow] --> B[Queued agent run]
  B --> C[Role-scoped tools and model]
  C --> D{Needs answer or wait?}
  D -->|No| E[Completed or failed result]
  D -->|Yes| F[Pending wake-up]
  F --> G[Answer, time, or event]
  G --> H[Queued continuation]
  H --> B
  E --> I[Caller outcome and thread history]
  B --> I

References: packages/…/run-agent.ts• L10-42 packages/…/agent-run.service.ts• L93-305 packages/…/agent-run-caller-context.service.ts• L31-78

SDK AI calls

The SDK exposes two application paths. runAgent starts an owned agent run and returns its thread, run, status, and result. ai.generate makes a one-off request with instructions, a model, an optional response shape, and an optional data scope.

Applications can read saved messages with listConversationMessages and follow live events with streamConversation. Both use the agent identity and the application's stable thread key. If a stream ends early, the application can read history and stream again to catch up.

The same runtime surface also lets application logic work with connections, message channels, inbox threads, jobs, timeline activity, key-value data, and HTTP responses. These calls keep outside actions inside the application's identity and permission boundary.

References: packages/…/index.ts• L45-114 packages/…/index.ts• L117-141 packages/…/ai.ts• L36-47 packages/…/stream-conversation.ts• L14-28

Tool availability

The tool registry is the shared catalog used to expose callable actions to AI clients, workflows, and other callers. It filters tools by workspace feature flags and caller access policy, publishes their descriptions and input schemas, and checks the same conditions again before execution.

This boundary keeps a tool that is visible in one context from becoming available in another context by accident. Invalid arguments return a tool error before the tool runs.

References: packages/…/defined-tool-registry.service.ts• L50-102 packages/…/defined-tool-registry.service.ts• L104-139 packages/…/is-snake-case-tool-name.util.ts• L1-40

Workflow agents and MCP tools

Workflows use an agent as one step in a fixed process. Trigger values and earlier step results become agent input. The agent's text or declared fields become input for later steps.

Workflows can also call a tool from an active MCP server. The workflow resolves the server and tool in the workspace, checks that the run application can reach the target application, resolves dynamic input, and returns either a tool result or a step error. This gives workflows access to outside services without bypassing application ownership.

References: packages/…/ai-agent.workflow-action.ts• L56-222 packages/…/mcp-tool.workflow-action.ts• L26-87 packages/…/ai-agent-action-settings-schema.ts• L4-12

MCP assistant access

MCP, or Model Context Protocol, gives an outside AI assistant a governed way to work with a Twenty workspace. The assistant discovers and calls tools through an authenticated server. It does not receive direct database access.

Authenticated tool access

Each MCP request is tied to a workspace and a signed-in user or API key. The server resolves the caller's role before it builds the available tools. Discovery and execution therefore show only the objects, skills, and actions available to that caller.

References: packages/…/mcp-core.controller.ts• L34-113 packages/…/mcp-protocol.service.ts• L101-147 packages/…/mcp-protocol.service.ts• L194-277

External assistant setup

The MCP server is advertised as a streamable HTTP endpoint with an authorization header. Cloud workspaces can use OAuth discovery. Static API-key authentication is also supported.

References: packages/…/build-mcp-server-card.util.ts• L8-39 packages/…/SettingsAiOverviewTab.tsx• L118-129

Remote MCP servers

Workspace administrators can register a remote MCP server so agents and workflows can use tools hosted outside Twenty. The settings flow stores a label, a stable snake-case name, and an HTTP(S) endpoint, then syncs the tools offered by that endpoint.

The synced catalog is a workspace connection point rather than a bypass of access control. The server must be enabled and the caller must have permission to manage it before the settings surface exposes it.

References: packages/…/SettingsMcpServersSection.tsx• L14-43 packages/…/mcpServerFormSchema.ts• L7-36 packages/…/useSyncMcpServerTools.ts• L11-48

Application extension model

An application is the installable boundary for reusable Twenty extensions. It can package data definitions, permissions, server logic, agents, skills, workflows, MCP servers, connection providers, messaging providers, pages, navigation, front components, validation rules, health checks, and translations. Installation adds these capabilities to a workspace as one unit.

Server integration points

Logic functions are the main server extension point. They can run from routes, schedules, record events, workflows, health checks, and application lifecycle events. The runtime gives them application identity and a caller context when one exists.

Connection providers hold the credential boundary for outside services. They support OAuth, OAuth discovery, custom authorization, and API-key flows. Messaging providers connect outside conversations to Twenty through stable external message IDs. Message attachments and read state stay part of that provider boundary.

Installed applications can expose a health check that reports whether their current variables and outside connections work. The settings surface runs the check after load and after a successful variable save. A newer check replaces an older result so stale health status does not overwrite the current one.

The SDK validates the provider and trigger contract before installation. A provider needs a stable identity and valid references to application-owned logic functions. A logic function needs one handler and one stable identity. It must use either the current record-event settings or the legacy database-event settings, not both.

References: packages/…/define-logic-function.ts• L10-85 packages/…/define-connection-provider.ts• L12-175 packages/…/define-messaging-provider.ts• L11-78 packages/…/SettingsApplicationHealthCheckEffect.tsx• L5-23 packages/…/useRunApplicationHealthCheck.ts• L22-70 packages/…/useSaveApplicationVariablesAndRecheckHealth.ts• L4-26

User-interface extensions

Front components let an application add React experiences inside Twenty. The host passes approved context and actions instead of unrestricted client access. Context can include the current user, selected records, object metadata, timeline data, locale, navigation, panels, notifications, file upload, and progress.

The host bridge supports navigation, panels, confirmation, notifications, progress, file upload, clipboard access, and limited component storage. A renderer prepares the component for the host runtime. A tool component can show a custom form or result inside chat while the standard tool view remains available as a fallback.

References: packages/…/index.ts• L1-81 packages/…/FrontComponentExecutionContext.ts• L8-30 packages/…/frontComponentHostCommunicationApi.ts• L11-193 packages/…/AiChatToolFrontComponent.tsx• L21-48

AI component authoring

The AI component builder lets an authorized member describe a dashboard or record-page widget in chat. The system creates a temporary draft, compiles it, checks its fields and sample records against the member's access, and returns a preview.

The preview is not a saved application component. Saving requires explicit approval of the exact draft revision in the original chat. A successful save adds the component to the Workspace app and its allowed widget surface. It does not place the widget on a page.

AI tools can also create a dashboard with a layout, tab, and widgets. The tool accepts object and field names, resolves them in the caller's permission context, and reports partial widget errors with the dashboard result. A record-table widget uses a dedicated view so its filters and columns do not alter an index view.

References: packages/…/preview-front-component.tool.ts• L8-30 packages/…/publish-front-component.tool.ts• L8-36 packages/…/AiChatFrontComponentPreviewEffect.tsx• L11-43 packages/…/create-complete-dashboard.tool.ts• L79-135 packages/…/create-complete-dashboard.tool.ts• L174-255

Application declarations and access

The SDK declaration surface gives application authors stable identities for agents, skills, workflows, MCP servers, objects, fields, roles, logic functions, providers, pages, navigation, views, validation rules, health checks, and UI components. Stable identities let installed resources survive package updates.

Application roles define which application resources and workspace data a caller can use. Row-level rules can narrow record access. Agents and one-off generation use the application role as an upper limit rather than a way to gain access.

The public SDK separates declarations, logic functions, front components, billing, utilities, and rendering. The logic-function entry point exposes only types and calls that may reach the runtime. Build-time declaration factories stay outside that runtime boundary.

References: packages/…/loose-shared-types.type.ts• L19-96 packages/…/role-config.ts• L1-3 packages/…/index.ts• L1-10 packages/…/package.json• L26-61

AI history and review

AI history gives chat, agent execution, usage, and review one workspace view. It records threads, turns, messages, message parts, model usage, and outcomes so streamed work remains visible after the live connection ends.

Workspace history

The history boundary lets chat and agent callers use the same conversation model. It restores file access, hides model-only context parts from the member, and keeps failed turns out of active conversation while preserving their error for retry.

A thread also carries ownership, participants, assignee, status, pending requests, activity, and usage totals. Readers return only messages allowed for the current viewer. The viewer can be a member or an application that created the thread.

References: packages/…/agent-conversation-reader.service.ts• L73-127 packages/…/agent-chat-thread.workspace-entity.ts• L10-41 packages/…/AiChatMessage.tsx• L180-355

Evaluation and review

An evaluation asks typed questions about input state. The answer must match the question contract before a workflow uses it. Authorized users can review an agent turn for task completion, tool use, answer quality, and error handling. Review data stays beside the turn in workspace history.

References: packages/…/ai-evaluation.service.ts• L18-71 packages/…/agent-turn.resolver.ts• L28-124 packages/…/agent-turn-grader.service.ts• L16-198

Integration boundaries

AI features cross boundaries between the client, workspace access, models, tools, application runtime, and outside services. These boundaries explain why one change can affect chat, workflows, MCP, and installed applications.

BoundaryConnectsWhy it matters
Model policyWorkspace settings, providers, chat, and agentsPrevents a model choice from breaking data rules
Usage boundaryChat, agents, model calls, and creditsKeeps work and accounting aligned
Tool registryChat, workflows, MCP, and application logicGives each caller current permitted actions
Pending requestAgent tools, cards, streams, and historyResumes paused work with the right answer
Agent callerApplications, workflows, continuations, and threadsCarries identity across pauses
Conversation identityMembers, applications, threads, and unread statePrevents duplicate or mislabelled conversations
Application declarationSDK resources and workspace metadataPreserves resource identity and ownership
Connection and message channelOutside credentials, messages, and threadsControls how outside data enters the workspace
Workflow outputAgent or MCP result and later stepsMakes AI work usable in fixed automation
Host bridgeFront components, tool calls, and the clientLimits extension UI to approved actions
Component draftChat, preview, approval, and publicationPrevents an unreviewed UI revision from being saved

When an AI feature changes, first ask which boundary it crosses. A new tool can affect approval, role checks, MCP discovery, widget choice, and workflow output. An application resource can affect its declaration, install state, generated client, translations, and host UI.

Change checklist

When these files or sections are changed, remember to consider these:

  • Keep chat instance identity aligned across page and side-panel surfaces, selected thread state, drafts, send events, runtime subscriptions, and thread-change callbacks.
  • Keep chat thread identity aligned across new-thread state, displayed-thread state, URL state, drafts, quotes, participants, direct-message conversion, and saved history.
  • Keep live chat state aligned across stream sequence, displayed parts, fetched history, queued messages, reaction revisions, reconnect catch-up, and access removal.
  • Keep new shared-thread recipients aligned across assistant participation, member recipients, channel selection, mentions, send validation, server-added participants, and the next-thread reset.
  • Keep approval requests aligned across grouped tool calls, skipped records, editable email drafts, active cards, destructive actions, optimistic rejected output, the original thread, and the final tool-call response.
  • Keep model choices aligned across catalog entries, workspace data policy, data residency, retention, native capabilities, context limits, usage display, and credit checks.
  • Keep agent triggers aligned across current record-event settings, legacy database-event settings, object and field identifiers, action values, conditions, batch mode, trigger limits, and migration validation.
  • Keep application declarations aligned across stable identities, role references, provider-owned logic functions, connection and messaging provider contracts, public SDK exports, health checks, and the minimum Twenty server version.
  • Keep MCP connections aligned across endpoint validation, stable names, synced tool catalogs, server status, workflow lookup, target application ownership, and caller access.
  • Keep front-component contracts aligned across execution context, tool-call data, host bridge actions, renderer exports, conditional availability, and standard fallback rendering.
  • Keep AI component drafts aligned across chat ownership, preview revision, sample-record permissions, checksum, explicit approval, publication state, and widget placement.
  • Keep email tool contracts aligned across the shared body document format, recipient parsing, connected-account capability, attachment limits, approval edits, send or draft choice, and message threading.

Important failure modes

TriggerConsequenceGuard
A live event arrives after a newer message snapshotOld content can replace newer chat stateSequence events and use saved history for catch-up
A member loses access during a streamCached content or late chunks could remain visibleEnd the stream and clear displayed, fetched, and queued conversation data
A chat instance is used without its instance contextThe chat cannot identify its thread or route send eventsRequire each chat surface to run inside an instance boundary
A new shared thread has no recipient, assistant, mention, or channelThe message is refusedSend validation requires at least one valid target
A direct message receives shared-chat context or filesPrivate-chat rules can be brokenDirect-message conversion and composer checks remove those inputs
A proposed record changes before approvalThe action does not runCheck the proposal again before execution
An email approval has no recipient or an invalid bodySend or draft is refusedEdit the review card and validate the canonical email document before execution
A connected email account lacks the required capabilityThe email action fails without changing the mailboxSelect an account that supports the requested send or draft operation
No model meets the workspace data policyChat or a model tier stays unavailableFilter models before tier selection
Credits end during a multi-step runLater model steps stop and the turn failsCheck credits before and during execution
An agent trigger uses invalid object, field, action, or legacy settingsThe application cannot be safely installedSDK validation checks the trigger shape and rejects conflicting forms
A structured agent result misses its declared fieldsA workflow or application cannot use the resultValidate the response format before later steps receive it
A tool is hidden by access policy or feature flagsDiscovery omits it or execution returns unavailableApply caller checks during both catalog build and execution
An MCP server is inactive or no longer offers the selected toolThe workflow step failsResolve the server and tool immediately before the call
A workflow application cannot reach the MCP server's applicationThe tool call is forbiddenCheck target application ownership and access
A remote MCP endpoint is invalid or its tool sync failsAgents cannot use the remote toolsValidate the HTTP(S) endpoint and surface the sync error
A component is approved outside its original chat or its revision changesThe UI is not savedPublish only the original thread's exact approved revision
A front component cannot renderThe application view cannot appearUse the standard tool view as the fallback
An application health check returns after a newer checkOld status can replace current statusAccept a result only when its run identity is still current
A provider uses an invalid logic-function or connection referenceInstallation rejects the providerValidate stable identities and application ownership in the SDK
A message is delivered twice with the same external IDA conversation can be duplicatedIngest messages with stable external IDs

Key files

FileWhy to read it
packages/…/AiChatProvider.tsxShows the shared client runtime boundary.
packages/…/AiChatInstance.tsxShows how each chat surface owns a thread and sends scoped events.
packages/…/AiChatRuntimeEffects.tsxShows how open chat instances share history loading and live subscriptions.
packages/…/useAiChat.tsShows message send rules, page context, files, recipients, direct messages, model choice, optimistic state, and retry.
packages/…/AiChatEditorSection.tsxShows the member-facing composer, context controls, usage limits, and read-only boundary.
packages/…/AiChatNewThreadRecipientField.tsxShows shared-thread recipients, channels, and assistant participation.
packages/…/useAiChatSubscription.tsShows stream events, reconnect behavior, access revocation, and catch-up.
packages/…/AiChatPendingAskGate.tsxShows how questions, forms, and approvals pause a turn until member input.
packages/…/AiChatRecordApprovalDeck.tsxShows grouped record approvals and the member decision boundary.
packages/…/AiChatToolCallApprovalEmailCard.tsxShows editable email approval and the send-versus-draft choice.
packages/…/AiChatToolFrontComponent.tsxShows custom application views inside chat and the standard fallback.
packages/…/define-agent.tsShows the application agent contract and trigger validation.
packages/…/define-logic-function.tsShows the server extension trigger contract.
packages/…/define-connection-provider.tsShows credential-provider types and application-owned logic references.
packages/…/define-messaging-provider.tsShows how an application connects outside conversations to Twenty.
packages/…/index.tsShows the application runtime surface for agents, AI generation, messaging, and conversation history.
packages/…/defined-tool-registry.service.tsShows tool discovery, access checks, schema validation, and execution checks.
packages/…/email-composer.service.tsShows the shared validation boundary for email send and draft actions.
packages/…/mcp-tool.workflow-action.tsShows governed MCP tool use from workflows.
packages/…/SettingsMcpServersSection.tsxShows the workspace entry point for remote MCP servers.
packages/…/useSyncMcpServerTools.tsShows remote tool catalog synchronization and failure reporting.
packages/…/create-complete-dashboard.tool.tsShows how AI creates a dashboard and reports partial widget failures.
packages/…/preview-front-component.tool.tsShows the preview side of AI-created application UI.
packages/…/publish-front-component.tool.tsShows the explicit approval and publication boundary.
packages/…/frontComponentHostCommunicationApi.tsShows the controlled host bridge available to installed UI.
packages/…/useRunApplicationHealthCheck.tsShows application health-check freshness and result handling.
packages/…/agent-run.service.tsShows queued runs, caller identity, pauses, continuations, and settled results.
packages/…/agent-conversation-reader.service.tsShows permission-aware history and failed-turn filtering.