@runtypelabs/persona 4.20.0 → 4.21.1

package/src/client.test.ts

@@ -911,6 +911,60 @@ describe('AgentWidgetClient - Agent Payload Building', () => {
     });
   });
 
+  it('proves the exact recovery visitor on durable client-token chat', async () => {
+    let capturedHeaders: Record<string, string> | undefined;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, options: RequestInit) => {
+      capturedHeaders = options.headers as Record<string, string>;
+      const encoder = new TextEncoder();
+      return {
+        ok: true,
+        body: new ReadableStream({
+          start(controller) {
+            controller.enqueue(encoder.encode(sseEvent('agent_complete', {
+              executionId: 'exec_1',
+              agentId: 'agent_123',
+              success: true,
+              iterations: 1,
+              completedAt: new Date().toISOString(),
+              seq: 1,
+            })));
+            controller.close();
+          },
+        }),
+      };
+    });
+
+    const client = new AgentWidgetClient({
+      apiUrl: 'https://api.runtype.com',
+      clientToken: 'ct_live_demo',
+      agentId: 'agent_123',
+    });
+    (client as unknown as {
+      clientSession: {
+        sessionId: string;
+        expiresAt: Date;
+        durableRecovery: { enabled: boolean };
+      };
+    }).clientSession = {
+      sessionId: 'sess_durable',
+      expiresAt: new Date(Date.now() + 10 * 60_000),
+      durableRecovery: { enabled: true },
+    };
+    (client as unknown as { readVisitorToken: () => Promise<string> }).readVisitorToken =
+      async () => 'cvt_owner';
+
+    await client.dispatch({
+      messages: [{
+        id: 'usr_1',
+        role: 'user',
+        content: 'Hello durable agent',
+        createdAt: '2025-01-01T00:00:00.000Z',
+      }],
+    }, () => {});
+
+    expect(capturedHeaders?.['X-Visitor-Token']).toBe('cvt_owner');
+  });
+
   it('should build agent payload with agent config', async () => {
     let capturedPayload: any = null;
     global.fetch = vi.fn().mockImplementation(async (_url: string, options: any) => {
@@ -3011,7 +3065,7 @@ describe('AgentWidgetClient.resumeFlow', () => {
     expect(capturedUrl).toBe('http://localhost:43111/api/chat/dispatch/resume');
   });
 
-  it('routes to /v1/client/resume with sessionId in client-token mode (core#3889)', async () => {
+  it('routes durable client-token resume with the live session, visitor proof, and cursor', async () => {
     let capturedUrl: string | undefined;
     let capturedBody: Record<string, unknown> | undefined;
     let capturedHeaders: Record<string, string> | undefined;
@@ -3027,12 +3081,21 @@ describe('AgentWidgetClient.resumeFlow', () => {
       apiUrl: 'https://api.runtype.com',
     });
     // Simulate an initialized client session (resumeFlow reads sessionId off it).
-    (client as unknown as { clientSession: { sessionId: string; expiresAt: Date } }).clientSession = {
+    (client as unknown as {
+      clientSession: {
+        sessionId: string;
+        expiresAt: Date;
+        durableRecovery: { enabled: boolean };
+      };
+    }).clientSession = {
       sessionId: 'cs_123',
       expiresAt: new Date(Date.now() + 60_000),
+      durableRecovery: { enabled: true },
     };
+    (client as unknown as { readVisitorToken: () => Promise<string> }).readVisitorToken =
+      async () => 'cvt_resume';
 
-    await client.resumeFlow('exec_xyz', { toolu_A: { ok: true } });
+    await client.resumeFlow('exec_xyz', { toolu_A: { ok: true } }, { after: '18' });
 
     // Session-authed sibling of /v1/client/chat: no Bearer key, sessionId in body.
     expect(capturedUrl).toBe('https://api.runtype.com/v1/client/resume');
@@ -3041,8 +3104,10 @@ describe('AgentWidgetClient.resumeFlow', () => {
       toolOutputs: { toolu_A: { ok: true } },
       streamResponse: true,
       sessionId: 'cs_123',
+      after: '18',
     });
     expect(capturedHeaders!['Authorization']).toBeUndefined();
+    expect(capturedHeaders!['X-Visitor-Token']).toBe('cvt_resume');
   });
 
   it('strips a trailing /v1/dispatch from apiUrl when building the client resume URL', async () => {
@@ -4611,3 +4676,76 @@ describe('AgentWidgetClient - mention context', () => {
     expect(get().context).toBeUndefined();
   });
 });
+
+describe('AgentWidgetClient - agent text runs through the configured stream parser', () => {
+  // Regression: agent-mode text_delta used to append the raw delta straight onto
+  // `content`, bypassing `streamParser` entirely. Demos that pin a server-side
+  // agent AND reply with a JSON envelope (the page-context / smart-dom-reader
+  // demo) therefore rendered the raw `{"text": ...}` in the bubble, and never
+  // populated `rawContent`, so the action manager saw nothing to dispatch.
+  const envelopeStream = (execId: string, chunks: string[]) => [
+    sseEvent('execution_start', { kind: 'agent', executionId: execId, agentId: 'virtual', agentName: 'Test', maxTurns: 1, startedAt: new Date().toISOString(), seq: 1 }),
+    sseEvent('turn_start', { executionId: execId, id: 'turn_1', iteration: 1, role: 'assistant', seq: 2 }),
+    sseEvent('text_start', { executionId: execId, id: 'text_1', role: 'assistant', seq: 3 }),
+    ...chunks.map((delta, i) =>
+      sseEvent('text_delta', { executionId: execId, id: 'text_1', delta, seq: 4 + i })
+    ),
+    sseEvent('text_complete', { executionId: execId, id: 'text_1', seq: 90 }),
+    sseEvent('turn_complete', { executionId: execId, id: 'turn_1', iteration: 1, role: 'assistant', completedAt: new Date().toISOString(), seq: 91 }),
+    sseEvent('execution_complete', { kind: 'agent', executionId: execId, success: true, completedAt: new Date().toISOString(), seq: 92 }),
+  ];
+
+  const lastAssistant = (events: AgentWidgetEvent[]): AgentWidgetMessage | null => {
+    for (let i = events.length - 1; i >= 0; i--) {
+      const e = events[i];
+      if (e.type === 'message' && e.message.role === 'assistant') return e.message;
+    }
+    return null;
+  };
+
+  const runAgent = async (
+    chunks: string[],
+    config: Record<string, unknown> = {}
+  ): Promise<AgentWidgetMessage | null> => {
+    global.fetch = createRawStreamFetch(envelopeStream('exec_env', chunks));
+    const events: AgentWidgetEvent[] = [];
+    const client = new AgentWidgetClient({
+      apiUrl: 'http://localhost:8000',
+      agent: { name: 'Test', model: 'openai:gpt-4o-mini', systemPrompt: 'test' },
+      ...config,
+    } as any);
+    await client.dispatch(
+      { messages: [{ id: 'u1', role: 'user', content: 'Hi', createdAt: new Date().toISOString() }] },
+      (e) => events.push(e)
+    );
+    return lastAssistant(events);
+  };
+
+  it('extracts `text` from a JSON envelope streamed across agent text_delta chunks', async () => {
+    const msg = await runAgent(
+      ['{"text": "In the ', '**Featured drop**', ', we have 2 items."}'],
+      { streamParser: () => createJsonStreamParser() }
+    );
+
+    expect(msg?.content).toBe('In the **Featured drop**, we have 2 items.');
+    // The bubble must not show the envelope itself.
+    expect(msg?.content).not.toContain('{"text"');
+  });
+
+  it('keeps the raw envelope on rawContent so the action manager can dispatch it', async () => {
+    const envelope = '{"action": "add_to_cart", "product": "headphones", "text": "Added it!"}';
+    const msg = await runAgent([envelope], {
+      streamParser: () => createJsonStreamParser(),
+    });
+
+    expect(msg?.content).toBe('Added it!');
+    expect(msg?.rawContent).toBe(envelope);
+  });
+
+  it('still plain-appends agent prose when no custom parser is configured', async () => {
+    const msg = await runAgent(['Hello', ' World']);
+
+    expect(msg?.content).toBe('Hello World');
+    expect(msg?.rawContent).toBeUndefined();
+  });
+});

package/src/client.ts

@@ -566,6 +566,54 @@ export class AgentWidgetClient {
     return this.clientSession;
   }
 
+  /** Persona's built-in reconnect transport for client-token sessions. */
+  public async reconnectClientTokenStream(ctx: {
+    executionId: string;
+    after: string;
+    signal: AbortSignal;
+  }): Promise<Response> {
+    let session = await this.initSession();
+    let recovered = false;
+
+    for (;;) {
+      const conversationId = session.conversationId;
+      const visitorToken = await this.readVisitorToken();
+      if (session.durableRecovery?.enabled !== true || !conversationId || !visitorToken) {
+        throw new HistoryClientError(
+          'visitor_token_missing',
+          'Durable recovery is not enabled for this client session'
+        );
+      }
+      const path =
+        `${this.clientApiBase()}/v1/client/conversations/` +
+        `${encodeURIComponent(conversationId)}/executions/` +
+        `${encodeURIComponent(ctx.executionId)}/events`;
+      const query = new URLSearchParams({
+        sessionId: session.sessionId,
+        after: ctx.after,
+      });
+      const response = await fetch(`${path}?${query}`, {
+        method: 'GET',
+        headers: {
+          'X-Persona-Version': VERSION,
+          'X-Visitor-Token': visitorToken,
+        },
+        signal: ctx.signal,
+      });
+      if (response.status === 401 && !recovered) {
+        recovered = true;
+        session = await this.recoverFromUnauthorized(
+          await this.readErrorCode(response),
+          null,
+          true
+        );
+        continue;
+      }
+      if (!response.ok) throw await this.historyErrorFor(response, true);
+      return response;
+    }
+  }
+
   /**
    * Initialize session for client token mode.
    * Called automatically on first message if not already initialized.
@@ -709,13 +757,18 @@ export class AgentWidgetClient {
    */
   private async createClientSession(opts: {
     conversationId?: string;
+    durableResume?: boolean;
     identityProof?: string | null;
     storedSessionId?: string | null;
     omitVisitorFields?: boolean;
   }): Promise<ClientSession> {
     const historyCapable = this.isHistoryCapable() && !opts.omitVisitorFields;
+    // Recovery is negotiated independently from the history UI. New servers
+    // return an explicit capability bit; old strict servers reject the
+    // additive request field, which the fallback below handles once.
+    const durableRecoveryRequested = !opts.omitVisitorFields;
     let visitorToken: string | null = null;
-    if (historyCapable) {
+    if (historyCapable || durableRecoveryRequested) {
       // Never read persisted state before the controller's stored-state gate.
       await this.historyInternals.historyBootstrapReady;
       visitorToken = await this.readVisitorToken();
@@ -723,12 +776,16 @@ export class AgentWidgetClient {
 
     const routed = this.routing();
     const sessionTargetId = routed.agentId ?? routed.flowId;
-    const resumeConversationId = historyCapable ? opts.conversationId : undefined;
+    const resumeConversationId =
+      historyCapable || opts.durableResume ? opts.conversationId : undefined;
     const requestBody: Record<string, unknown> = {
       token: this.config.clientToken,
       ...(sessionTargetId && { flowId: sessionTargetId }),
       ...(historyCapable && { visitorHistory: true }),
-      ...(historyCapable && visitorToken ? { visitorToken } : {}),
+      ...(durableRecoveryRequested && { durableRecovery: true }),
+      ...((historyCapable || durableRecoveryRequested) && visitorToken
+        ? { visitorToken }
+        : {}),
       // Independent of the strict conversationId/sessionId union: a proof also
       // binds the visitor on an ordinary init.
       ...(historyCapable && opts.identityProof
@@ -741,7 +798,7 @@ export class AgentWidgetClient {
           : {}),
     };
 
-    const response = await fetch(this.getClientApiUrl('init'), {
+    let response = await fetch(this.getClientApiUrl('init'), {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
@@ -750,6 +807,22 @@ export class AgentWidgetClient {
       body: JSON.stringify(requestBody),
     });
 
+    // Rolling/self-hosted compatibility: pre-recovery servers use a strict
+    // init schema and answer 400 to the additive field. Retry once without it;
+    // the absent response capability keeps Persona on ordinary streaming.
+    if (response.status === 400 && durableRecoveryRequested) {
+      const fallbackBody = { ...requestBody };
+      delete fallbackBody.durableRecovery;
+      response = await fetch(this.getClientApiUrl('init'), {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Persona-Version': VERSION,
+        },
+        body: JSON.stringify(fallbackBody),
+      });
+    }
+
     if (!response.ok) {
       const error = await response.json().catch(() => ({ error: 'Session initialization failed' }));
       if (historyCapable && response.status === 403 && error.error === 'visitor_history_disabled') {
@@ -763,7 +836,17 @@ export class AgentWidgetClient {
         }
         return this.createClientSession({ ...opts, omitVisitorFields: true });
       }
-      if (historyCapable && response.status === 401 && error.error === 'visitor_required') {
+      if (response.status === 403 && error.error === 'durable_recovery_disabled') {
+        throw new HistoryClientError(
+          'history_disabled',
+          'Durable recovery is disabled for this surface'
+        );
+      }
+      if (
+        (historyCapable || opts.durableResume) &&
+        response.status === 401 &&
+        error.error === 'visitor_required'
+      ) {
         throw new HistoryClientError('visitor_required', 'Visitor credential no longer resolves');
       }
       if (resumeConversationId && response.status === 404) {
@@ -797,6 +880,7 @@ export class AgentWidgetClient {
       ...(data.conversationRevision
         ? { conversationRevision: data.conversationRevision }
         : {}),
+      ...(data.durableRecovery ? { durableRecovery: data.durableRecovery } : {}),
       ...(data.visitor ? { visitor: data.visitor } : {}),
       config: {
         welcomeMessage: data.config.welcomeMessage,
@@ -807,15 +891,13 @@ export class AgentWidgetClient {
   }
 
   private async _doInitSession(): Promise<ClientSession> {
-    if (!this.isHistoryCapable()) {
-      const storedSessionId = this.config.getStoredSessionId?.() || null;
-      const session = await this.createClientSession({ storedSessionId });
-      this.config.setStoredSessionId?.(session.sessionId);
-      return session;
-    }
-
     await this.historyInternals.historyBootstrapReady;
     const previousConversationId = this.config.getStoredConversationId?.() || null;
+    const durableResume =
+      this.historyInternals.shouldResumeDurableConversation?.() === true;
+    if (!this.isHistoryCapable() && !durableResume) {
+      return this.ordinaryInit(previousConversationId, false);
+    }
     const storedToken = await this.readVisitorToken();
 
     // Boot resume: reopening the record beats replaying a possibly idle-expired
@@ -824,15 +906,23 @@ export class AgentWidgetClient {
       try {
         const resumed = await this.createClientSession({
           conversationId: previousConversationId,
+          durableResume,
         });
+        if (durableResume && resumed.durableRecovery?.enabled !== true) {
+          this.historyInternals.setStoredResumableHandle?.(null);
+        }
         return this.finishInit(resumed, previousConversationId, false);
       } catch (error) {
         if (
           !isHistoryClientError(error, 'not_found') &&
-          !isHistoryClientError(error, 'visitor_required')
+          !isHistoryClientError(error, 'visitor_required') &&
+          !isHistoryClientError(error, 'history_disabled')
         ) {
           throw error;
         }
+        if (durableResume) {
+          this.historyInternals.setStoredResumableHandle?.(null);
+        }
         // Record gone or credential dead: exactly one ordinary fallback, never a loop.
         return this.ordinaryInit(previousConversationId, true);
       }
@@ -851,7 +941,7 @@ export class AgentWidgetClient {
     continuityBroken: boolean
   ): Promise<ClientSession> {
     const store = this.historyInternals.visitorStore;
-    if (store && this.isHistoryCapable() && !(await this.readVisitorToken())) {
+    if (store && !(await this.readVisitorToken())) {
       return store.withFirstInitLock(() =>
         this.doOrdinaryInit(previousConversationId, continuityBroken)
       );
@@ -893,7 +983,11 @@ export class AgentWidgetClient {
    * unowned; one immediate re-init with `{visitorToken, sessionId}` claims it.
    */
   private async claimFirstConversation(first: ClientSession): Promise<ClientSession> {
-    if (!first.visitor?.token || this.claimInFlight || !this.isHistoryCapable()) {
+    if (
+      !first.visitor?.token ||
+      this.claimInFlight ||
+      (!this.isHistoryCapable() && first.durableRecovery?.enabled !== true)
+    ) {
       return first;
     }
     this.claimInFlight = true;
@@ -1754,6 +1848,10 @@ export class AgentWidgetClient {
 
       // Build the standard payload to get context/metadata from middleware
       const basePayload = await this.buildPayload(options.messages);
+      const recoveryVisitorToken =
+        session.durableRecovery?.enabled === true
+          ? await this.readVisitorToken()
+          : null;
 
       // Build the chat request payload with message IDs for feedback tracking
       // Filter out sessionId from metadata if present (it's only for local storage)
@@ -1813,6 +1911,9 @@ export class AgentWidgetClient {
             headers: {
               'Content-Type': 'application/json',
               'X-Persona-Version': VERSION,
+              ...(recoveryVisitorToken
+                ? { 'X-Visitor-Token': recoveryVisitorToken }
+                : {}),
             },
             body: JSON.stringify(chatRequest),
             signal: options.signal,
@@ -2221,7 +2322,7 @@ export class AgentWidgetClient {
   public async resumeFlow(
     executionId: string,
     toolOutputs: Record<string, unknown>,
-    options?: { streamResponse?: boolean; signal?: AbortSignal }
+    options?: { streamResponse?: boolean; signal?: AbortSignal; after?: string }
   ): Promise<Response> {
     const isClientToken = this.isClientTokenMode();
     const url = isClientToken
@@ -2236,12 +2337,18 @@ export class AgentWidgetClient {
     // trusting the possibly-stale `this.clientSession`. (core#3889; BugBot
     // PR #214 r3367875360.)
     let resumeSessionId: string | undefined;
+    let resumeVisitorToken: string | null = null;
     if (isClientToken) {
-      resumeSessionId = (await this.initSession()).sessionId;
+      const session = await this.initSession();
+      resumeSessionId = session.sessionId;
+      if (session.durableRecovery?.enabled === true) {
+        resumeVisitorToken = await this.readVisitorToken();
+      }
     }
 
     let headers: Record<string, string> = {
       'Content-Type': 'application/json',
+      ...(resumeVisitorToken ? { 'X-Visitor-Token': resumeVisitorToken } : {}),
       ...this.headers
     };
     if (this.getHeaders) {
@@ -2252,6 +2359,7 @@ export class AgentWidgetClient {
       executionId,
       toolOutputs,
       streamResponse: options?.streamResponse ?? true,
+      ...(options?.after ? { after: options.after } : {}),
     };
     // Thread the (refreshed) sessionId through like `/v1/client/chat` does.
     if (resumeSessionId) {
@@ -2737,9 +2845,10 @@ export class AgentWidgetClient {
     // bubble-id segmentation on the wire in place of the legacy `partId`:
     // a new block id means a new bubble, sealed at `text_complete`/tool boundaries.
     let currentTextBlockId: string | null = null;
-    // Raw text accumulated for the open flow block before its bubble is
-    // materialized — lets a whitespace-only block resolve without a stray bubble.
-    let pendingFlowRaw = "";
+    // Raw text accumulated for the open text block, on both the flow and agent
+    // paths — lets a whitespace-only flow block resolve without a stray bubble,
+    // and gives the structured-content parser the whole block on either path.
+    let pendingTextRaw = "";
     // Nested flow-as-tool attribution (PR #4602): a text/reasoning block whose
     // `parentToolCallId` matches a `tool_start.toolCallId` belongs to a flow
     // running as that tool. Keyed by the wire block id, these route the block's
@@ -3134,20 +3243,20 @@ export class AgentWidgetClient {
       finalizeCleanup();
     };
 
-    // === Unified flow text channel ===
-    // Flow prompt-step text streams as `text_delta` blocks (segmented by
-    // `text_start`/`text_complete`) and can be structured JSON, so each block
-    // runs through the per-bubble structured-content parser — agent text stays
-    // plain. This is the legacy step_delta parser core, re-keyed from `partId`
-    // to the wire block-id bubble. The caller materializes the bubble lazily
-    // (whitespace-only blocks around tool boundaries never leave a stray bubble)
-    // and `step_complete.result.response` reconciles the authoritative final.
+    // === Unified text channel ===
+    // Prompt-step and agent text both stream as `text_delta` blocks (segmented by
+    // `text_start`/`text_complete`) and can be structured JSON, so each block runs
+    // through the per-bubble structured-content parser. This is the legacy
+    // step_delta parser core, re-keyed from `partId` to the wire block-id bubble.
+    // The caller materializes the bubble lazily (whitespace-only blocks around
+    // tool boundaries never leave a stray bubble) and `step_complete.result.response`
+    // reconciles the authoritative final.
     let lastSealedFlowBubble: AgentWidgetMessage | null = null;
 
-    // Stream one accumulated chunk of flow block text through the parser, setting
+    // Stream one accumulated chunk of block text through the parser, setting
     // display `content` (extracted) + `rawContent` (raw) and emitting. Mirrors the
     // legacy step_delta chunk path; plain text bypasses the structured parser.
-    const applyFlowTextChunk = (
+    const applyTextChunk = (
       assistant: AgentWidgetMessage,
       accumulatedRaw: string,
       chunk: string,
@@ -3773,7 +3882,7 @@ export class AgentWidgetClient {
           }
           currentTextBlockId =
             typeof payload.id === "string" ? payload.id : currentTextBlockId;
-          pendingFlowRaw = "";
+          pendingTextRaw = "";
         } else if (payloadType === "text_delta") {
           // Nested flow-as-tool text: route to the parent tool's row, through the
           // same structured-content parser, never the top-level assistant channel.
@@ -3793,7 +3902,7 @@ export class AgentWidgetClient {
               executionId: payload.executionId,
               parentToolId: nestedParent,
             };
-            applyFlowTextChunk(nested, nestedRaw, nestedDelta, undefined);
+            applyTextChunk(nested, nestedRaw, nestedDelta, undefined);
             continue;
           }
           currentTextBlockId =
@@ -3804,27 +3913,36 @@ export class AgentWidgetClient {
             // block-id bubble. Materialize lazily so a whitespace-only block
             // (newlines around a tool boundary) never leaves a stray bubble.
             const delta = typeof payload.delta === "string" ? payload.delta : "";
-            pendingFlowRaw += delta;
-            if (pendingFlowRaw.trim() === "") continue;
+            pendingTextRaw += delta;
+            if (pendingTextRaw.trim() === "") continue;
             const assistant = ensureAssistantMessage();
             assistant.agentMetadata = {
               executionId: payload.executionId,
               iteration: payload.iteration,
             };
-            applyFlowTextChunk(assistant, pendingFlowRaw, delta, undefined);
+            applyTextChunk(assistant, pendingTextRaw, delta, undefined);
             lastAssistantInTurn = assistant;
             continue;
           }
+          // Agent text can be structured JSON too, whenever the host configures a
+          // custom `streamParser` (e.g. the page-context demo's `{"text": ...}` /
+          // `{"action": "add_to_cart", ...}` envelope). Accumulate the open block's
+          // raw text and run it through the same structured-content path the flow
+          // branch uses, so the parser sees the whole block and `rawContent` stays
+          // populated for the action manager. With the default plain-text parser
+          // this is byte-identical to appending the delta, so agent demos that
+          // stream prose are unaffected.
+          const agentDelta = typeof payload.delta === "string" ? payload.delta : "";
+          pendingTextRaw += agentDelta;
           const assistant = ensureAssistantMessage();
-          assistant.content += payload.delta ?? '';
           assistant.agentMetadata = {
             executionId: payload.executionId,
             iteration: payload.iteration,
             turnId: openTurnId ?? undefined,
             agentName: agentExecution?.agentName
           };
+          applyTextChunk(assistant, pendingTextRaw, agentDelta, undefined);
           lastAssistantInTurn = assistant;
-          emitMessage(assistant);
         } else if (payloadType === "text_complete") {
           // Nested flow-as-tool text block close: seal its parent-tool-row message.
           const completeBlockId = typeof payload.id === "string" ? payload.id : null;
@@ -3857,7 +3975,7 @@ export class AgentWidgetClient {
             assistantMessage = null;
           }
           currentTextBlockId = null;
-          pendingFlowRaw = "";
+          pendingTextRaw = "";
         } else if (payloadType === "step_complete") {
           // Only process completions for prompt steps, not tool/context steps
           const stepType = (payload as any).stepType;
@@ -4201,7 +4319,7 @@ export class AgentWidgetClient {
             assistantMessage = null;
           }
           currentTextBlockId = null;
-          pendingFlowRaw = "";
+          pendingTextRaw = "";
           lastSealedFlowBubble = null;
 
           // `terminal: true` marks this as a graceful finish (not a drop). The

package/src/generated/runtype-openapi-contract.ts

@@ -58,8 +58,10 @@ export type RuntypeExecutionStreamEvent = ({
   message: string;
 };
   executionId: string;
+  finalOutput?: string;
   kind: "agent" | "flow";
   seq: number;
+  stopReason?: string;
   type: "execution_error";
   upgradeUrl?: string;
 }) | ({