@datalayer/agent-runtimes 1.0.29 → 1.3.11

package/lib/types/chat.d.ts

@@ -11,6 +11,19 @@ import type { Protocol, ProtocolConfig } from './protocol';
 import type { McpServerSelection } from './inference';
 import type { MCPServerTool } from './mcp';
 import type { AgentRuntimeConfig } from './config';
+import type { ContextSnapshotData } from './context';
+import type { InputPromptVariant } from '../chat/prompt/InputPromptBase';
+import type { MentionableAgent } from '../chat/prompt/plugins/AgentMentionPlugin';
+import type { Icon } from '@primer/octicons-react';
+/** One agent a chat may address, as its controls need it. */
+export interface FooterAgent {
+    id: string;
+    name: string;
+    description?: string;
+    emoji?: string;
+    /** The octicon its agentspec asked for, resolved by whoever built the list. */
+    icon?: Icon;
+}
 import type { SandboxWsStatus } from './sandbox';
 import type { FrontendToolDefinition } from './tools';
 import type { PoweredByTagProps } from '../chat/display/PoweredByTag';
@@ -50,9 +63,10 @@ export interface ToolCallCompleteContext {
  * View mode for the chat component.
  * - 'floating': Full-height floating panel (pinned to the right edge with offset)
  * - 'floating-small': Standard floating popup
- * - 'sidebar': Docked sidebar panel
+ * - 'floating-draggable': The popup with a handle, movable anywhere in the viewport
+ * - 'sidebar': Docked sidebar panel — offered only where the host has a mount point for it
  */
-export type ChatViewMode = 'floating' | 'floating-small' | 'sidebar';
+export type ChatViewMode = 'floating' | 'floating-small' | 'floating-draggable' | 'sidebar';
 /**
  * Companion "ephemeral surface" shown next to the chat.
  * - 'none': chat only, no companion surface
@@ -87,6 +101,23 @@ export interface ToolCallRenderContext {
     status: DisplayToolCallStatus;
     /** Error message if status is 'error' */
     error?: string;
+    /**
+     * What the chat would have drawn for this tool call by itself.
+     *
+     * Supplying `renderToolResult` replaces the default row outright, and
+     * returning nothing from it draws nothing at all — so a caller who only
+     * wanted to *add* something under one tool had to either reimplement the
+     * row or lose it, and lose every other tool's row along with it.
+     *
+     * Render it to compose:
+     *
+     * ```tsx
+     * renderToolResult={({ name, defaultUI }) =>
+     *   name === 'my_tool' ? <>{defaultUI}<MyPanel /></> : defaultUI
+     * }
+     * ```
+     */
+    defaultUI?: ReactNode;
     /**
      * Callback to send response back to the agent (human-in-the-loop).
      * Only available when status is 'executing'.
@@ -133,6 +164,15 @@ export interface Suggestion {
     title: string;
     /** Message to send when clicked */
     message: string;
+    /**
+     * A heading this opener is offered under, where a surface draws headings.
+     *
+     * Ungrouped openers come first, as one row; each group follows as a block
+     * of its own with its name on it. A team's openers are the first kind and
+     * the addressed member's own are the second, so a person sees what the
+     * team can be asked and, under it, what this member in particular can.
+     */
+    group?: string;
 }
 /**
  * Avatar configuration
@@ -182,6 +222,24 @@ export interface EmptyStateConfig {
     subtitle?: string;
     /** Custom empty state renderer */
     render?: () => ReactNode;
+    /**
+     * The empty state in levels, each with its own openers.
+     *
+     * A workspace running a team introduces two things, not one: the team —
+     * its name, what it is for, what it can be asked — and, under it, the
+     * member being addressed with what that member in particular offers. Each
+     * level is a section; the openers whose `group` is the section's are drawn
+     * under it. Given, this replaces `icon`, `title` and `subtitle`.
+     */
+    sections?: EmptyStateSection[];
+}
+/** One level of an empty state: a heading, and the openers grouped under it. */
+export interface EmptyStateSection {
+    /** The `group` of the suggestions this section draws. */
+    group: string;
+    icon?: ReactNode;
+    title: string;
+    subtitle?: string;
 }
 /**
  * Model configuration
@@ -191,6 +249,15 @@ export interface ModelConfig {
     name: string;
     builtinTools?: string[];
     isAvailable?: boolean;
+    /**
+     * Why this model cannot be picked, when it cannot.
+     *
+     * The menu used to say "Missing API key" under every unavailable row, which
+     * is right for a provider whose key is not set and wrong for a model this
+     * deployment is not entitled to — that one sends the reader off to find a
+     * key that would change nothing.
+     */
+    unavailableReason?: string;
 }
 /**
  * MCP Server configuration from backend
@@ -252,6 +319,49 @@ export interface ChatCommonProps {
     showInput?: boolean;
     /** Keep input visible but disabled */
     disableInputPrompt?: boolean;
+    /**
+     * Which editor the prompt uses — `'text'` (default) or `'lexical'`.
+     *
+     * There is one prompt component; this picks the editor inside it. Lexical
+     * is the one with the `@` menu, so a chat offering agents to address needs
+     * it.
+     */
+    promptVariant?: InputPromptVariant;
+    /** Agents the prompt may address by typing `@`. Lexical only. */
+    mentionableAgents?: MentionableAgent[];
+    /**
+     * Whether the prompt offers a chooser for who answers.
+     *
+     * True by default, and shown for a single agent as much as for several: the
+     * control is a label before it is a switch, and in a chat with one agent
+     * nothing else on screen says which one.
+     */
+    showAgentsMenu?: boolean;
+    /** Who may answer. Defaults to the agent this chat is talking to. */
+    agents?: FooterAgent[];
+    /** Who is answering now. */
+    selectedAgentId?: string;
+    /** Address somebody else. */
+    onSelectAgent?: (agentId: string) => void;
+    /**
+     * Whether the chat can be used at all.
+     *
+     * Different from `launching`, which says "not yet": this says "not here".
+     * A sandbox with no agent behind it — code running in the browser, or an
+     * anonymous Jupyter server — has nothing to chat with, and the honest answer
+     * is to show the chat as it will look and say why it is off, rather than
+     * hide it and leave the person wondering where it went.
+     *
+     * The input and the selectors go dead; the header stays readable.
+     */
+    disabled?: boolean;
+    /**
+     * Why the chat is off, in the person's terms — "No agent in browser mode".
+     *
+     * Shown in the header beside the title, because that is where someone looks
+     * when a control does not respond. Ignored unless `disabled` is true.
+     */
+    disableReason?: string;
     /**
      * Whether the underlying agent runtime is still launching. When true, the
      * chat shell is rendered with the input and controls disabled and a spinner
@@ -316,6 +426,13 @@ export interface ChatCommonProps {
      * @default true
      */
     showTokenUsage?: boolean;
+    /**
+     * Whether the usage bar draws its context ring.
+     *
+     * False by default: the ring earns its place where a person is likely to
+     * fill a context window, not in every chat that reports usage.
+     */
+    showContextRing?: boolean;
     /** Indicate tools are accessed via Codemode meta-tools */
     codemodeEnabled?: boolean;
     /**
@@ -448,6 +565,11 @@ export interface ChatCommonProps {
     chatViewMode?: ChatViewMode;
     /** Callback when user switches chat view mode */
     onChatViewModeChange?: (mode: ChatViewMode) => void;
+    /**
+     * Modes the toggle shows but does not let anyone pick — the sidebar, on a
+     * page that has no mount point for one. See `chat/viewModes`.
+     */
+    disabledViewModes?: readonly ChatViewMode[];
     /** External context snapshot data for the token usage bar */
     contextSnapshot?: import('./context').ContextSnapshotData;
     /** External MCP toolsets status data */
@@ -515,6 +637,39 @@ export interface ChatCommonProps {
  * ChatBase props
  */
 export interface ChatBaseProps {
+    /**
+     * Hands an imperative send function to the host, once the chat is able to
+     * send.
+     *
+     * `pendingPrompt` deliberately sends a given text only once, which makes it
+     * unusable as a live input channel: a user asking the same question twice
+     * would be ignored the second time. A host that owns the input box — the LOOP
+     * workspace, whose prompt is the shell — needs a channel with no such memory.
+     *
+     * Called again with `null` when the chat can no longer send.
+     */
+    onSendReady?: (controls: {
+        send: (message: string) => void;
+        stop: () => void;
+        /** Start the conversation over — what the header's + does. */
+        newChat: () => void;
+    } | null) => void;
+    /**
+     * Reports whether the chat is streaming a reply, so a host that owns the
+     * input box can show the spinner and the stop button where the user is
+     * actually looking.
+     */
+    onLoadingChange?: (isLoading: boolean) => void;
+    /**
+     * What the context window is holding, as this chat last accounted for it.
+     *
+     * For a host that draws its own prompt and therefore its own usage bar. The
+     * chat is the one thing that sees every source — a snapshot pushed over the
+     * socket by a server-side runtime, and the totals an in-page harness reports
+     * as it finishes a turn — so it hands on the answer rather than making every
+     * host reassemble it.
+     */
+    onContextSnapshot?: (usage: ContextSnapshotData | undefined) => void;
     /** Chat title */
     title?: string;
     /** Chat subtitle (rendered under the title in the header) */
@@ -528,6 +683,13 @@ export interface ChatBaseProps {
      * @default true
      */
     showTokenUsage?: boolean;
+    /**
+     * Whether the usage bar draws its context ring.
+     *
+     * False by default: the ring earns its place where a person is likely to
+     * fill a context window, not in every chat that reports usage.
+     */
+    showContextRing?: boolean;
     /**
      * External context snapshot data for the token usage bar.
      * When provided, this overrides the built-in useContextSnapshot hook
@@ -561,6 +723,39 @@ export interface ChatBaseProps {
     showInput?: boolean;
     /** Keep input visible but disabled */
     disableInputPrompt?: boolean;
+    /**
+     * Which editor the prompt uses — `'text'` (default) or `'lexical'`.
+     *
+     * There is one prompt component; this picks the editor inside it. Lexical
+     * is the one with the `@` menu, so a chat offering agents to address needs
+     * it.
+     */
+    promptVariant?: InputPromptVariant;
+    /** Agents the prompt may address by typing `@`. Lexical only. */
+    mentionableAgents?: MentionableAgent[];
+    /**
+     * Whether the prompt offers a chooser for who answers.
+     *
+     * True by default, and shown for a single agent as much as for several: the
+     * control is a label before it is a switch, and in a chat with one agent
+     * nothing else on screen says which one.
+     */
+    showAgentsMenu?: boolean;
+    /** Who may answer. Defaults to the agent this chat is talking to. */
+    agents?: FooterAgent[];
+    /** Who is answering now. */
+    selectedAgentId?: string;
+    /** Address somebody else. */
+    onSelectAgent?: (agentId: string) => void;
+    /**
+     * Whether the chat can be used at all — see `ChatCommonProps.disabled`.
+     *
+     * `launching` says "not yet"; this says "not here". A sandbox with no agent
+     * behind it has nothing to chat with.
+     */
+    disabled?: boolean;
+    /** Why the chat is off, shown in the header. Ignored unless `disabled`. */
+    disableReason?: string;
     /**
      * Whether the underlying agent runtime is still launching. When true, the
      * chat shell renders with input and controls disabled and a spinner overlay.
@@ -643,13 +838,19 @@ export interface ChatBaseProps {
     /**
      * Current chat view mode.
      * When provided, a segmented view-mode toggle is rendered in the header
-     * with icons for each mode: floating (popup), floating-small (compact), sidebar (docked).
+     * with icons for each mode: floating (popup), floating-small (compact),
+     * floating-draggable (movable popup), sidebar (docked).
      */
     chatViewMode?: ChatViewMode;
     /**
      * Callback when the user clicks a different view mode in the header toggle.
      */
     onChatViewModeChange?: (mode: ChatViewMode) => void;
+    /**
+     * Modes the toggle shows but does not let anyone pick — the sidebar, on a
+     * page that has no mount point for one. See `chat/viewModes`.
+     */
+    disabledViewModes?: readonly ChatViewMode[];
     /**
      * Use Zustand store for state management.
      * When true, uses the shared store. When false with protocol, uses protocol mode.
@@ -711,6 +912,35 @@ export interface ChatBaseProps {
     emptyState?: EmptyStateConfig;
     /** Tool result renderer for tool calls */
     renderToolResult?: RenderToolResult;
+    /**
+     * Draw the chat's title bar from these fully assembled props.
+     *
+     * Called instead of the built-in `ChatBaseHeader` whenever `showHeader` is
+     * true — with everything the built-in would have received: title, kernel
+     * indicator, runtime status, the actions row. The loop's chat-header
+     * plugin hangs off this: the bar then arrives as a plugin without this
+     * component giving up any of what only it knows.
+     */
+    renderHeader?: (props: import('../chat/header/ChatHeaderBase').ChatBaseHeaderProps) => ReactNode;
+    /**
+     * Whether each turn closes with its accounting row.
+     *
+     * True by default: a quiet `ctx · turn ▲▼` line after every exchange —
+     * live while the turn streams, frozen with copy/remove actions once it is
+     * over. False for a host that wants the transcript bare.
+     */
+    showTurnFooter?: boolean;
+    /**
+     * Show notebook tool results as read-only surfaces in the transcript,
+     * addressed to this notebook document id.
+     *
+     * For a chat whose agent works a notebook the reader cannot see. A cell
+     * that was inserted, updated or run appears under its tool row — source
+     * first, then its outputs streaming from the live model; `executeCodeInNotebook`
+     * shows only what came back. Ignored when `renderToolResult` is given:
+     * a host that writes its own renderer owns the whole surface.
+     */
+    notebookToolSurfacesId?: string;
     /** Custom footer content (rendered above input) */
     footerContent?: ReactNode;
     /**
@@ -747,6 +977,24 @@ export interface ChatBaseProps {
     onClear?: () => void;
     /** Callback when messages change (for tracking message count) */
     onMessagesChange?: (messages: ChatMessage[]) => void;
+    /**
+     * Called on *every* change to the conversation, streaming included.
+     *
+     * `onMessagesChange` fires when the number of messages changes, which is
+     * right for counting and wrong for following a reply as it arrives — the
+     * assistant's message exists from its first token and only grows. This is
+     * the streaming-aware sibling: same messages, every change.
+     */
+    onItemsChange?: (messages: ChatMessage[]) => void;
+    /**
+     * Every change to the transcript, tool calls included, streaming included.
+     *
+     * `onItemsChange` reports the messages; this reports everything the
+     * transcript holds — the tool calls the agent is making, with their status
+     * — for a caller that wants to say what the agent is *doing*, not only what
+     * it has said.
+     */
+    onDisplayItemsChange?: (items: Array<ChatMessage | ToolCallMessage>) => void;
     /** Auto-focus the input on mount */
     autoFocus?: boolean;
     /**

package/lib/types/checkpoints.d.ts

@@ -30,3 +30,23 @@ export interface ConversationCheckpoint {
     /** Additional metadata */
     metadata: Record<string, unknown>;
 }
+/** When an agent takes a conversation checkpoint on its own. */
+export type ConversationCheckpointFrequency = 'every_turn' | 'every_tool' | 'manual_only';
+/**
+ * An agent's conversation checkpoints as the local server reports them:
+ * whether it checkpoints at all, how, where the conversation stands, and
+ * the checkpoints it has, newest first.
+ */
+export interface ConversationCheckpointsState {
+    agentId: string;
+    /** False for an agent whose spec asked for no checkpoints. */
+    enabled: boolean;
+    frequency?: ConversationCheckpointFrequency;
+    /** Rolling window: the oldest checkpoint goes when this is exceeded. */
+    maxCheckpoints?: number;
+    /** `in_memory` or `file`. */
+    store?: string;
+    /** Turns the agent has run so far. */
+    turn: number;
+    checkpoints: ConversationCheckpoint[];
+}

package/lib/types/config.d.ts

@@ -3,6 +3,7 @@ import { MCPServerConfig, ModelConfig } from './chat';
 import type { Protocol } from './protocol';
 import type { AgentValidationConfig } from './execution';
 import { BuiltinTool } from './models';
+import type { AgentSuggestion } from './agentspecs';
 /**
  * Default agent configuration values.
  */
@@ -48,8 +49,19 @@ export interface RemoteConfig {
     defaultModel?: string;
     builtinTools: BuiltinTool[];
     mcpServers?: MCPServerConfig[];
-    suggestions?: string[];
+    /**
+     * What the server offers as openers.
+     *
+     * Either shape: a running agent may be older than the catalogue it was built
+     * from, and a string is a suggestion with no marks.
+     */
+    suggestions?: (string | AgentSuggestion)[];
     welcomeMessage?: string;
+    /**
+     * What has been sent to this agent so far, oldest first — the runtime's
+     * memory of it, for the composer's arrow keys to walk back through.
+     */
+    promptHistory?: string[];
 }
 /**
  * Configuration for connecting to an agent runtime.

package/lib/types/connection.d.ts

@@ -9,7 +9,7 @@ export type ConnectionState = 'connected' | 'connecting' | 'disconnected' | 'err
  */
 export interface AgentConnection {
     /** Runtime pod name (unique identifier). */
-    podName: string;
+    runtimeName: string;
     /** Environment name. */
     environmentName: string;
     /** Base URL for the Jupyter server. */

package/lib/types/evals.d.ts

@@ -16,6 +16,8 @@ export interface EvalSpec {
     evaluator_type: 'case' | 'report';
     /** Pydantic evaluator class name */
     pydantic_class: string;
+    /** Whether the platform can run this evaluator today; shown, never offered, when false. */
+    executable: boolean;
     /** Primary output shape */
     output_kind: 'boolean' | 'boolean_with_reason' | 'score' | 'score_and_assertion' | 'report_table' | 'report_curve';
     /** Cost tier for running this evaluator */

package/lib/types/messages.d.ts

@@ -45,6 +45,30 @@ export interface ActivityContentPart {
     data: unknown;
 }
 export type ContentPart = TextContentPart | ImageContentPart | ToolCallContentPart | ToolResultContentPart | ActivityContentPart;
+/**
+ * Who said a message, when a chat holds more than one non-user voice — a
+ * team's supervisor and its members, not just "the assistant".
+ *
+ * Attaching one to a message is what tells `ChatMessageList` to draw a named,
+ * coloured header instead of the single generic assistant look; a message
+ * with no `speaker` renders exactly as it always has.
+ */
+export interface MessageSpeaker {
+    /** Stable id, e.g. an agent id — not shown, but keeps two same-named speakers apart. */
+    id: string;
+    name: string;
+    /** A short label under the name, e.g. "supervisor" or a capability. */
+    role?: string;
+    /**
+     * The Primer colour family this speaker is drawn in — `'accent'`,
+     * `'success'`, `'attention'`, `'severe'`, `'sponsors'`, `'neutral'`, or any
+     * other family `sx` resolves as `<tone>.emphasis` / `.subtle` / `.muted` /
+     * `.fg`. Omitted or `'neutral'` falls back to the chat's neutral tones.
+     */
+    tone?: string;
+    /** Up to two letters shown in the avatar in place of the default icon. */
+    initials?: string;
+}
 /**
  * Core message interface
  */
@@ -59,6 +83,42 @@ export interface ChatMessage {
     createdAt: Date;
     /** Optional agent name for multi-agent scenarios */
     agentName?: string;
+    /**
+     * Who said this message, when the chat has more than one voice. See
+     * {@link MessageSpeaker}.
+     */
+    speaker?: MessageSpeaker;
+    /**
+     * Who this message is addressed to — one agent hanging another its brief,
+     * or a person steering an agent already at work. Shown in the header as
+     * "<speaker> asks/steers <directedTo>"; ignored without `speaker`.
+     */
+    directedTo?: MessageSpeaker;
+    /**
+     * `true` for a person's instruction to an agent already working, `false`
+     * (or omitted) for a delegation. Only meaningful with `directedTo`, where
+     * it chooses "steers" over "asks".
+     */
+    steer?: boolean;
+    /**
+     * Short labels for tools this message's turn called, shown as small chips
+     * above the text — lighter than a full tool-call card, for a turn already
+     * known to have finished rather than one awaiting approval.
+     */
+    toolChips?: string[];
+    /**
+     * Still being written: the speaker is working and this message is not its
+     * settled content yet. With no text yet, `ChatMessageList` shows a typing
+     * indicator in its place.
+     */
+    live?: boolean;
+    /**
+     * Renders this message as a distinct aside — centred, pill-shaped, no
+     * avatar or side — rather than as a speech bubble. For a wait, a failure or
+     * a stop: something that happened to a part of the conversation, not
+     * something a speaker said.
+     */
+    note?: 'waiting' | 'failed' | 'stopped';
     /** Optional metadata */
     metadata?: Record<string, unknown>;
     /** Tool calls for assistant messages */

package/lib/types/models.d.ts

@@ -15,6 +15,15 @@ export interface AIModel {
     provider: string;
     /** Whether this is the default model */
     default: boolean;
+    /**
+     * Whether this model is offered to a person choosing one.
+     *
+     * The catalogue is what the platform knows how to talk to; this says what
+     * is worth offering today. Without the distinction a picker lists every
+     * model ever added, most of them superseded, and choosing becomes a chore
+     * rather than a help.
+     */
+    available: boolean;
     /** Required environment variable names */
     requiredEnvVars: string[];
     /**
@@ -22,6 +31,21 @@ export interface AIModel {
      * (maps to pydantic-ai output_tokens_limit).
      */
     tokensLimit?: number;
+    /**
+     * Whether the model runs on the user's own machine (Ollama, LM Studio,
+     * vLLM, llama.cpp). A local model needs no API key, and choosing one moves
+     * execution to a local sandbox so the code stays where the tokens do.
+     */
+    local?: boolean;
+    /** OpenAI-compatible base URL, for local and self-hosted endpoints. */
+    baseUrl?: string;
+    /** Environment variable holding an API key, when the endpoint wants one. */
+    apiKeyEnv?: string;
+    /**
+     * What the model can be trusted with: 'tools', 'codemode', 'vision',
+     * 'thinking'. Empty means unstated rather than incapable.
+     */
+    capabilities?: string[];
 }
 /**
  * Configuration for an AI model runtime (as returned by the server).
@@ -57,6 +81,8 @@ export interface FrontendConfig {
     builtinTools: BuiltinTool[];
     /** Configured MCP servers */
     mcpServers: MCPServer[];
+    /** What has been sent to the agent so far, oldest first. */
+    promptHistory?: string[];
 }
 /**
  * Model configuration for an agent spec.

package/lib/types/notifications.d.ts

@@ -39,12 +39,21 @@ export interface NotificationChannelSpec {
 /**
  * Notification configuration for an agent spec.
  */
+/**
+ * One channel in an agentspec's `notifications` section: a target string,
+ * an on/off flag, or the two spelled out.
+ */
+export type AgentNotificationChannelConfig = string | boolean | {
+    enabled?: boolean;
+    target?: string | null;
+};
 export interface AgentNotificationConfig {
-    email?: string;
-    slack?: string;
-    teams?: string;
-    webhook?: string;
-    [key: string]: string | number | boolean | undefined;
+    'in-app'?: AgentNotificationChannelConfig;
+    email?: AgentNotificationChannelConfig;
+    slack?: AgentNotificationChannelConfig;
+    teams?: AgentNotificationChannelConfig;
+    webhook?: AgentNotificationChannelConfig;
+    [key: string]: AgentNotificationChannelConfig | number | undefined;
 }
 export interface AgentNotification {
     /** Unique notification ID */
@@ -52,7 +61,7 @@ export interface AgentNotification {
     /** Agent that generated the notification */
     agentId: string;
     /** Pod running the agent */
-    podName: string;
+    runtimeName: string;
     /** Notification severity */
     level: NotificationLevel;
     /** Notification title */

package/lib/types/outputs.d.ts

@@ -12,6 +12,8 @@ export interface OutputSpec {
     description: string;
     /** Icon identifier */
     icon: string;
+    /** Whether the platform offers this output today; off unless the spec says so */
+    enabled: boolean;
     /** Whether this format supports templates */
     supports_template: boolean;
     /** Whether this format supports storage paths */

package/lib/types/protocol.d.ts

@@ -8,9 +8,14 @@ import { AgentCard } from './a2a';
 import type { ChatMessage } from './messages';
 import type { ToolDefinition, ToolCallRequest, ToolExecutionResult } from './tools';
 /**
- * Supported protocol (communication protocols with agent backends)
+ * Supported protocol (communication protocols with agent backends).
+ *
+ * `browser-vercel-ai` is the odd one: there is no backend and no wire. It runs
+ * the loop in the page with the Vercel AI SDK and reports it through the same
+ * interface, so a chat component does not have to know the difference. See
+ * {@link ../protocols/BrowserAgentAdapter}.
  */
-export type Protocol = 'ag-ui' | 'a2a' | 'acp' | 'vercel-ai' | 'vercel-ai-jupyter';
+export type Protocol = 'ag-ui' | 'a2a' | 'acp' | 'vercel-ai' | 'vercel-ai-jupyter' | 'browser-vercel-ai';
 /**
  * Protocol connection state
  */