@runtypelabs/persona 4.22.0 → 4.23.0

package/dist/index.d.cts

@@ -1734,6 +1734,11 @@ type RuntypeExecutionStreamEvent = ({
     iteration?: number;
     role: "user" | "assistant" | "system";
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     turnIndex?: number;
     type: "turn_start";
 }) | ({
@@ -1768,12 +1773,61 @@ type RuntypeExecutionStreamEvent = ({
     role: "user" | "assistant" | "system";
     seq: number;
     stopReason?: "end_turn" | "max_tool_calls" | "length" | "content_filter" | "error" | "unknown";
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     tokens?: {
         input: number;
         output: number;
     };
     type: "turn_complete";
 }) | {
+    executionId: string;
+    id: string;
+    iteration?: number;
+    model?: string;
+    ordinal: number;
+    provider?: string;
+    seq: number;
+    startedAt?: string;
+    stepId?: string;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
+    turnId?: string;
+    type: "model_call_start";
+} | {
+    completedAt?: string;
+    cost?: number;
+    durationMs?: number;
+    executionId: string;
+    finishReason?: string;
+    id: string;
+    iteration?: number;
+    model?: string;
+    ordinal: number;
+    provider?: string;
+    responseModel?: string;
+    seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
+    success?: boolean;
+    tokens?: {
+        cacheRead?: number;
+        cacheWrite?: number;
+        input: number;
+        output: number;
+    };
+    turnId?: string;
+    type: "model_call_complete";
+} | {
     executionId: string;
     id: string;
     index?: number;
@@ -1782,6 +1836,11 @@ type RuntypeExecutionStreamEvent = ({
     seq: number;
     startedAt?: string;
     stepType?: string;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     totalSteps?: number;
     type: "step_start";
 } | ({
@@ -1809,6 +1868,11 @@ type RuntypeExecutionStreamEvent = ({
     seq: number;
     stepType?: string;
     stopReason?: "end_turn" | "max_tool_calls" | "length" | "content_filter" | "error" | "unknown";
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     success?: boolean;
     tokensUsed?: number;
     type: "step_complete";
@@ -1831,6 +1895,11 @@ type RuntypeExecutionStreamEvent = ({
     role?: "user" | "assistant" | "system";
     seq: number;
     stepId?: string;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     turnId?: string;
     type: "text_start";
 }) | {
@@ -1838,11 +1907,21 @@ type RuntypeExecutionStreamEvent = ({
     executionId: string;
     id: string;
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     type: "text_delta";
 } | {
     executionId: string;
     id: string;
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     text?: string;
     type: "text_complete";
 } | ({
@@ -1851,18 +1930,33 @@ type RuntypeExecutionStreamEvent = ({
     parentToolCallId?: string;
     scope?: "turn" | "loop";
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     type: "reasoning_start";
 }) | {
     delta: string;
     executionId: string;
     id: string;
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     type: "reasoning_delta";
 } | ({
     executionId: string;
     id: string;
     scope?: "turn" | "loop";
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     text?: string;
     type: "reasoning_complete";
 }) | ({
@@ -1955,6 +2049,11 @@ type RuntypeExecutionStreamEvent = ({
     seq: number;
     startedAt?: string;
     stepId?: string;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     toolCallId: string;
     toolName: string;
     toolType: string;
@@ -1963,6 +2062,11 @@ type RuntypeExecutionStreamEvent = ({
     delta: string;
     executionId: string;
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     toolCallId: string;
     type: "tool_input_delta";
 } | {
@@ -1970,6 +2074,11 @@ type RuntypeExecutionStreamEvent = ({
     hiddenParameterNames?: Array<string>;
     parameters: Record<string, unknown>;
     seq: number;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     toolCallId: string;
     toolName?: string;
     type: "tool_input_complete";
@@ -1987,6 +2096,11 @@ type RuntypeExecutionStreamEvent = ({
     result?: unknown;
     seq: number;
     stepId?: string;
+    subagent?: {
+        agentName?: string;
+        parentToolCallId?: string;
+        toolName: string;
+    };
     success: boolean;
     toolCallId: string;
     toolCost?: number;
@@ -2066,6 +2180,19 @@ type RuntypeExecutionStreamEvent = ({
     recoverable?: boolean;
     seq: number;
     type: "error";
+}) | ({
+    epoch: number;
+    executionId: string;
+    kind: "compaction";
+    outcome?: "ok" | "failed" | "gap" | "skipped";
+    phase: "start" | "complete";
+    reason: "threshold" | "overflow" | "manual" | "surface_policy" | "provider_mismatch";
+    seq: number;
+    strategy: "provider_native" | "summary";
+    tier: number;
+    tokensAfter?: number;
+    tokensBefore?: number;
+    type: "context_notice";
 }) | {
     executionId: string;
     seq: number;
@@ -2129,6 +2256,7 @@ type RuntypeClientInitResponse = {
     conversationRevision: string;
     durableRecovery?: {
         enabled: boolean;
+        join?: boolean;
     };
     expiresAt: string;
     flow?: {
@@ -2189,7 +2317,7 @@ type RuntypeClientChatRequest = {
     }>;
     metadata?: Record<string, unknown>;
     sessionId: string;
-    submitMode?: "normal" | "interrupt";
+    submitMode?: "normal" | "interrupt" | "join";
     turnId?: string;
 };
 type RuntypeClientChatStreamEvent = RuntypeExecutionStreamEvent;
@@ -3342,15 +3470,15 @@ type AgentMessageMetadata = {
      */
     parentStepId?: string;
     /**
-     * Set to `true` on a tool-variant message produced from a `step_await`
+     * Set to `true` on a tool-variant message produced from an `await`
      * event (`awaitReason: "local_tool_required"`). Signals to UI code that
      * the tool call is a LOCAL tool and the server is paused waiting for a
      * `POST /v1/dispatch/resume` with the user's answer keyed by tool name.
      */
     awaitingLocalTool?: boolean;
     /**
-     * The provider per-call id (`toolu_…`) carried on the `step_await` /
-     * `flow_await` events for a LOCAL tool (core#3878). Present only when the
+     * The provider per-call id (`toolu_…`) carried on the `await`
+     * event for a LOCAL tool (core#3878). Present only when the
      * server emits it. Two PARALLEL calls to the same tool in one turn share a
      * `toolName` (and a collapsed `toolId`) but get DISTINCT `webMcpToolCallId`s,
      * so this is the key the widget batches a single `/resume` on: preferred
@@ -5648,7 +5776,7 @@ type EventStreamConfig = {
     /**
      * Custom badge color mappings by event type prefix or exact type.
      * Keys are matched as exact match first, then prefix match (keys ending with "_").
-     * @example { "flow_": { bg: "#dcfce7", text: "#166534" }, "error": { bg: "#fecaca", text: "#991b1b" } }
+     * @example { "execution_": { bg: "#dcfce7", text: "#166534" }, "error": { bg: "#fecaca", text: "#991b1b" } }
      */
     badgeColors?: Record<string, EventStreamBadgeColor>;
     /**
@@ -7126,9 +7254,13 @@ interface VoiceProvider {
      * `isFinal=false` is a live interim update (user partials, or assistant deltas
      * on providers that stream them); `isFinal=true` finalizes that role's text.
      * On the realtime `runtype` path, interim updates fire for the `user` only and
-     * the `assistant` arrives as a single final.
+     * the `assistant` arrives as a single final. Providers with overlapping turns
+     * must include the same turnId on user and assistant finals; without IDs,
+     * providers must discard cancelled output before emitting the next user final.
      */
-    onTranscript?(callback: (role: 'user' | 'assistant', text: string, isFinal: boolean) => void): void;
+    onTranscript?(callback: (role: 'user' | 'assistant', text: string, isFinal: boolean, metadata?: {
+        turnId?: string;
+    }) => void): void;
     /** Register a callback for per-turn latency metrics (realtime path). */
     onMetrics?(callback: (metrics: VoiceMetrics) => void): void;
     /**
@@ -9601,16 +9733,16 @@ type AgentWidgetConfig = {
      *
      * @example
      * ```typescript
-     * // For Runtype API format
+     * // For a custom backend (Runtype unified events are handled natively)
      * config: {
      *   parseSSEEvent: (data) => {
-     *     if ((data.type === 'step_delta' || data.type === 'step_chunk') && (data.delta || data.chunk)) {
-     *       return { text: data.delta ?? data.chunk };
+     *     if (data.type === 'token' && typeof data.value === 'string') {
+     *       return { text: data.value };
      *     }
-     *     if (data.type === 'flow_complete') {
+     *     if (data.type === 'done') {
      *       return { done: true };
      *     }
-     *     if (data.type === 'step_error') {
+     *     if (data.type === 'failure') {
      *       return { error: data.error };
      *     }
      *     return null; // Ignore other events
@@ -9812,7 +9944,7 @@ type AgentWidgetReasoning = {
     /**
      * Reasoning channel scope (wire spec). `"turn"` is ordinary per-turn
      * thinking; `"loop"` is a cross-iteration agent reflection (the fold that
-     * replaced the legacy `agent_reflection` event). Absent for legacy streams.
+     * replaced the legacy `agent_reflection` event). Optional when the stream does not specify a scope.
      */
     scope?: "turn" | "loop";
     startedAt?: number;
@@ -9826,6 +9958,9 @@ type AgentWidgetToolCall = {
     args?: unknown;
     chunks?: string[];
     result?: unknown;
+    /** Whether the tool succeeded; failure does not necessarily end the execution. */
+    success?: boolean;
+    error?: string;
     duration?: number;
     startedAt?: number;
     completedAt?: number;
@@ -9856,7 +9991,7 @@ type AgentWidgetApproval = {
 type AgentWidgetMessageVariant = "assistant" | "reasoning" | "tool" | "approval";
 /**
  * Per-turn / per-step stop reason emitted by the runtime on
- * `agent_turn_complete` and `step_complete` SSE events. The vocabulary is
+ * `turn_complete` and `step_complete` SSE events. The vocabulary is
  * owned by the upstream Runtype API: do not extend without coordination.
  *
  * - `end_turn`: natural completion (no affordance needed)
@@ -9987,7 +10122,7 @@ type AgentWidgetMessage = {
      */
     agentMetadata?: AgentMessageMetadata;
     /**
-     * Per-turn stop reason reported by the runtime on `agent_turn_complete`
+     * Per-turn stop reason reported by the runtime on `turn_complete`
      * (agent-loop path) or the last `step_complete` for a prompt step
      * (dispatch / flow path). Absent when the API did not report a value.
      *
@@ -10786,7 +10921,7 @@ declare class AgentWidgetClient {
      * Returns the raw Response so the caller can pipe its SSE body through
      * `connectStream()`.
      *
-     * @param executionId - The paused execution id carried on `step_await`.
+     * @param executionId - The paused execution id carried on `await`.
      * @param toolOutputs - Map keyed by per-call `toolCallId` (core#3878),
      *   falling back to tool name for legacy servers → the tool's result value.
      */
@@ -11102,6 +11237,8 @@ declare class AgentWidgetSession {
     deactivateBargeIn(): Promise<void>;
     private pendingVoiceUserMessageId;
     private pendingVoiceAssistantMessageId;
+    private voiceTurns;
+    private voiceDisconnectPromise;
     private ttsSpokenMessageIds;
     private readAloud;
     /**
@@ -11130,6 +11267,8 @@ declare class AgentWidgetSession {
      * Cleanup voice resources
      */
     cleanupVoice(): void;
+    private disconnectVoice;
+    private settlePendingVoiceTurn;
     /**
      * Extract voice configuration from widget config
      */
@@ -11624,7 +11763,7 @@ declare class AgentWidgetSession {
     /**
      * Resolve a paused `ask_user_question` LOCAL tool call.
      *
-     * When the server emits `step_await` for `ask_user_question`, the widget
+     * When the server emits `await` for `ask_user_question`, the widget
      * renders the answer-pill sheet and calls this method once the user
      * picks. Steps:
      *   1. POST the answer to `/resume` via `client.resumeFlow`.
@@ -11653,10 +11792,10 @@ declare class AgentWidgetSession {
     markAskUserQuestionResolved(toolMessage: AgentWidgetMessage, answers?: Record<string, string | string[]>): void;
     resolveAskUserQuestion(toolMessage: AgentWidgetMessage, answer: string | Record<string, string | string[]>): Promise<void>;
     /**
-     * Collect an auto-resolving LOCAL-tool `step_await` (`webmcp:*` page tools
+     * Collect an auto-resolving LOCAL-tool `await` (`webmcp:*` page tools
      * and the built-in `suggest_replies`) into a per-executionId batch
      * and schedule a single deferred flush. Parallel calls (core#3878) emit
-     * several `step_await`s for ONE paused execution within the same stream tick;
+     * several `await`s for ONE paused execution within the same stream tick;
      * buffering them and flushing once lets us post ONE `/resume` keyed by the
      * per-call `webMcpToolCallId` rather than racing N name-keyed resumes on the
      * same execution (which 404'd on the second and hung the turn).
@@ -11674,7 +11813,7 @@ declare class AgentWidgetSession {
     /**
      * Flush every buffered local-tool await batch, one `/resume` per executionId.
      * Called once a stream ends (`status: idle` / `error`): by then all parallel
-     * `step_await`s the stream carried have been collected, even if split across
+     * `await`s the stream carried have been collected, even if split across
      * SSE chunks. Deferred via `queueMicrotask` (epoch-guarded) so the idle
      * handler returns first and the stream's end-of-stream teardown (streaming /
      * abortController) settles before a resolve grabs them: the same ordering the
@@ -11695,7 +11834,7 @@ declare class AgentWidgetSession {
      * Persisted-resolution guard for `suggest_replies`. The in-memory dedupe
      * sets (`webMcpInflightKeys` / `webMcpResolvedKeys`) are cleared by
      * hydrateMessages/clearMessages/cancel, but `suggestRepliesResolved`
-     * survives on the stored message, so a stale `step_await` re-emit after a
+     * survives on the stored message, so a stale `await` re-emit after a
      * hydration must not re-POST `/resume` for an already-resolved call (the
      * historical double-resume failure mode the batching work exists to avoid).
      * Checks the LIVE message first; the handleEvent snapshot is a fresh wire
@@ -11729,12 +11868,12 @@ declare class AgentWidgetSession {
      * resumes with a canned "shown" result (the chips render from the message
      * list, not from this resolve).
      *
-     * Triggered automatically from `handleEvent` when a `step_await`-derived
+     * Triggered automatically from `handleEvent` when an `await`-derived
      * message arrives for such a tool: the user does not click a pill; the
      * bridge's confirm-bubble gate (WebMCP only) is the only interactive
      * surface.
      *
-     * Idempotent on the message's `toolCall.id`: re-emits of the same step_await
+     * Idempotent on the message's `toolCall.id`: re-emits of the same await
      * (e.g. from message coalescing) won't double-fire `tool.execute`. Failure
      * modes, declined, timed out, throw, unknown tool, all resolve into a
      * `{ isError: true, content: [...] }` payload that resumes the dispatch
@@ -11813,7 +11952,7 @@ declare class AgentWidgetSession {
     private trackCursor;
     /**
      * The drop gate: is this stream-end a dropped connection we should reconnect,
-     * rather than a graceful finish or an intentional `step_await` pause? ALL must
+     * rather than a graceful finish or an intentional `await` pause? ALL must
      * hold (see plan §Design overview keystone 3).
      */
     private isDurableDrop;
@@ -12239,6 +12378,12 @@ type Controller = {
     resetHistoryIdentity: () => Promise<{
         remoteRevocationConfirmed: boolean;
     }>;
+    /**
+     * Read the current browser visitor credential for a trusted voice integration.
+     * Returns null before minting, outside client-token mode, or after teardown.
+     * Never put this bearer credential in logs, URLs, or model context.
+     */
+    getVisitorToken: () => Promise<string | null>;
     /** Latest sanitized identity state; carries no token, proof, or identity id. */
     getHistoryIdentityStatus: () => HistoryIdentityStatus;
     /** `focus: false` keeps focus where it is (programmatic/preview opens). */
@@ -12375,7 +12520,7 @@ declare const removeAskUserQuestionSheet: (overlay: HTMLElement | null | undefin
  * `clientTools[]` (set `features.askUserQuestion.expose: true`): the same
  * wire surface WebMCP page tools ride. The server registers it as a LOCAL
  * tool under its bare name (`origin: 'sdk'` tools are not `webmcp:`-prefixed),
- * so when the model calls it the execution pauses with a `step_await`, the
+ * so when the model calls it the execution pauses with an `await`, the
  * widget's answer-pill sheet renders, and `session.resolveAskUserQuestion()`
  * resumes the execution with the structured answers. The public await frame
  * for a local-tool pause carries no `awaitReason`; that discriminator is
@@ -12477,7 +12622,7 @@ declare const builtInClientToolsForDispatch: (config: AgentWidgetConfig | undefi
  * The widget can advertise this tool to the agent on every dispatch via
  * `clientTools[]` (set `suggestions.followUps.expose: true`): the same
  * wire surface as `ask_user_question` and WebMCP page tools. When the model
- * calls it, the execution pauses with a `step_await` (a local-tool pause
+ * calls it, the execution pauses with an `await` (a local-tool pause
  * carries no `awaitReason`; that discriminator is internal). Unlike
  * `ask_user_question`, the widget resolves it FIRE-AND-FORGET: it renders the
  * configured follow-up surface and immediately resumes the execution with a
@@ -12662,7 +12807,7 @@ type WebMcpPolyfillModule = {
 declare const stripWebMcpPrefix: (name: string) => string;
 /**
  * `true` when `wireToolName` carries the `webmcp:` prefix. Used by `client.ts`
- * to route `step_await` events.
+ * to route `await` events.
  */
 declare const isWebMcpToolName: (name: string) => boolean;