@agent-native/toolkit 0.221.0-same-host-mcp-20261027-20261027081850 → 0.221.0

package/src/app/agentkit/react/voice-transcripts.spec.tsx

@@ -12,6 +12,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   realtimeVoiceTranscriptRegistry,
   type RealtimeVoiceTranscriptMessage,
+  type RealtimeVoiceWorkUpdate,
 } from "../../../composer/realtime-voice-transcript.js";
 import { ComposerRuntimeAdaptersProvider } from "../../../composer/runtime-adapters.js";
 import { AgentKitChat } from "./components.js";
@@ -25,8 +26,16 @@ afterEach(async () => {
   vi.unstubAllGlobals();
 });
 
-async function mountChat(threadId: string) {
+async function mountChat(
+  threadId: string,
+  stored: Partial<AgentThreadSnapshot> = {},
+  { loadBeforeMount = true } = {},
+) {
   const saved: AgentThreadSnapshot[] = [];
+  let releaseSnapshot = () => {};
+  const snapshotReleased = loadBeforeMount
+    ? Promise.resolve()
+    : new Promise<void>((resolve) => (releaseSnapshot = resolve));
   const transport: AgentTransport = {
     async startRun() {
       return { runId: "unused" };
@@ -34,7 +43,14 @@ async function mountChat(threadId: string) {
     async *subscribeToRun() {},
     async cancelRun() {},
     async getThreadSnapshot() {
-      return { id: threadId, createdAt: AT, updatedAt: AT, messages: [] };
+      await snapshotReleased;
+      return {
+        id: threadId,
+        createdAt: AT,
+        updatedAt: AT,
+        messages: [],
+        ...stored,
+      };
     },
     async persistThreadSnapshot({ snapshot }) {
       saved.push(snapshot);
@@ -45,7 +61,8 @@ async function mountChat(threadId: string) {
     aiSetupReadiness: "not-applicable",
     reconnect: { attempts: 0, delayMs: 0 },
   });
-  await client.loadThread(threadId);
+  const loaded = client.loadThread(threadId);
+  if (loadBeforeMount) await loaded;
   vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
   const container = document.createElement("div");
   document.body.appendChild(container);
@@ -65,7 +82,14 @@ async function mountChat(threadId: string) {
     await client.shutdown();
     container.remove();
   });
-  return { container, client, saved };
+  const finishLoading = async () => {
+    await act(async () => {
+      releaseSnapshot();
+      await loaded;
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  };
+  return { container, client, saved, finishLoading };
 }
 
 async function publish(
@@ -193,4 +217,215 @@ describe("voice chat transcripts in AgentKitChat", () => {
 
     expect(messages(container)).toEqual([]);
   });
+
+  it("waits for running work to finish before saving a final turn", async () => {
+    const threadId = "thread-voice-open-work";
+    const { saved } = await mountChat(threadId);
+    const call = {
+      id: "call-edit",
+      name: "edit-design",
+      startedAt: "2026-10-24T00:00:02.000Z",
+    };
+    const publishWork = async (update: RealtimeVoiceWorkUpdate) => {
+      await act(async () => {
+        realtimeVoiceTranscriptRegistry.publishWork(update);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+    };
+
+    await publishWork({
+      id: "call-edit",
+      threadId,
+      calls: [{ ...call, status: "running" }],
+    });
+    await publish(threadId, {
+      id: `${threadId}:user-2`,
+      role: "user",
+      text: "Make it blue too.",
+      createdAt: "2026-10-24T00:00:03.000Z",
+    });
+    expect(saved).toEqual([]);
+
+    await publishWork({
+      id: "call-edit",
+      threadId,
+      calls: [
+        {
+          ...call,
+          status: "completed",
+          output: "{}",
+          completedAt: "2026-10-24T00:00:04.000Z",
+        },
+      ],
+      completedAt: "2026-10-24T00:00:04.000Z",
+    });
+    expect(saved.at(-1)?.runs).toEqual([
+      expect.objectContaining({ id: "voice:call-edit", status: "completed" }),
+    ]);
+    expect(saved.at(-1)?.messages.map((message) => message.id)).toContain(
+      `${threadId}:user-2`,
+    );
+  });
+
+  it.each([
+    ["before", true],
+    ["after", false],
+  ])(
+    "closes voice work a reload left running when the thread loads %s the chat mounts",
+    async (_when, loadBeforeMount) => {
+      const threadId = `thread-voice-orphan-${String(loadBeforeMount)}`;
+      const runId = "voice:call-edit";
+      const started = "2026-10-24T00:00:02.000Z";
+      const { client, saved, finishLoading } = await mountChat(
+        threadId,
+        {
+          events: [
+            {
+              id: `${runId}:call-edit:tool-started`,
+              threadId,
+              runId,
+              sequence: 1,
+              occurredAt: started,
+              type: "tool.started",
+              toolCall: {
+                id: "call-edit",
+                name: "edit-design",
+                status: "running",
+                runId,
+              },
+            },
+          ],
+          runs: [{ id: runId, threadId, status: "running", lastSequence: 1 }],
+        },
+        { loadBeforeMount },
+      );
+      await finishLoading();
+
+      expect(
+        client
+          .getThread(threadId)
+          .events.filter((event) => event.runId === runId)
+          .map((event) =>
+            event.type === "tool.updated"
+              ? `${event.type}:${event.toolCall.status}`
+              : event.type,
+          ),
+      ).toEqual([
+        "tool.started",
+        "activity.started",
+        "tool.updated:cancelled",
+        "activity.completed",
+        "run.completed",
+      ]);
+
+      await publish(threadId, {
+        id: `${threadId}:user-1`,
+        role: "user",
+        text: "Try again.",
+      });
+      expect(saved.at(-1)?.messages.map((message) => message.id)).toEqual([
+        `${threadId}:user-1`,
+      ]);
+    },
+  );
+
+  it("shows a reply's tool calls as one work item between the turns and saves it", async () => {
+    const threadId = "thread-voice-work";
+    const { container, client, saved } = await mountChat(threadId);
+    const search = {
+      id: "call-search",
+      name: "web-search",
+      input: { query: "cats" },
+      startedAt: "2026-10-24T00:00:02.000Z",
+    };
+    const read = {
+      id: "call-read",
+      name: "web-request",
+      input: { url: "https://example.com/cats" },
+      startedAt: "2026-10-24T00:00:03.000Z",
+    };
+    const publishWork = async (update: RealtimeVoiceWorkUpdate) => {
+      await act(async () => {
+        realtimeVoiceTranscriptRegistry.publishWork(update);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+    };
+    const reply = { id: "call-search", threadId };
+
+    await publish(threadId, {
+      id: `${threadId}:user-1`,
+      role: "user",
+      text: "Search the web for cats.",
+    });
+    await publish(threadId, {
+      id: `${threadId}:assistant-1`,
+      role: "assistant",
+      text: "On it, searching now.",
+      createdAt: "2026-10-24T00:00:01.000Z",
+    });
+    await publishWork({ ...reply, calls: [{ ...search, status: "running" }] });
+
+    const running = container.textContent ?? "";
+    expect(running.indexOf("Searched 1 query")).toBeGreaterThan(
+      running.indexOf("On it, searching now."),
+    );
+    // The local run never holds the composer the way a server run does.
+    expect(client.getThread(threadId).activeRunIds).toEqual([]);
+    // It still shows what it is doing now.
+    const liveStep = () =>
+      container.querySelector('[data-agentkit-current-activity="true"]')
+        ?.textContent;
+    expect(liveStep()).toBeTruthy();
+
+    const finishedSearch = {
+      ...search,
+      status: "completed" as const,
+      output: "{}",
+      completedAt: "2026-10-24T00:00:02.500Z",
+    };
+    await publishWork({
+      ...reply,
+      calls: [finishedSearch, { ...read, status: "running" }],
+    });
+    await publishWork({
+      ...reply,
+      calls: [
+        finishedSearch,
+        {
+          ...read,
+          status: "completed",
+          output: "<html>",
+          completedAt: "2026-10-24T00:00:04.000Z",
+        },
+      ],
+      completedAt: "2026-10-24T00:00:04.000Z",
+    });
+    await publish(threadId, {
+      id: `${threadId}:assistant-2`,
+      role: "assistant",
+      text: "Cats are great.",
+      createdAt: "2026-10-24T00:00:05.000Z",
+    });
+
+    const done = container.textContent ?? "";
+    expect(liveStep()).toBeUndefined();
+    expect(done.match(/Worked/g)).toHaveLength(1);
+    const row = done.indexOf("Worked");
+    expect(row).toBeGreaterThan(done.indexOf("On it, searching now."));
+    expect(row).toBeLessThan(done.indexOf("Cats are great."));
+    expect(saved.at(-1)?.events?.map((event) => event.type)).toEqual([
+      "tool.started",
+      "activity.started",
+      "tool.updated",
+      "activity.completed",
+      "tool.started",
+      "activity.started",
+      "tool.updated",
+      "activity.completed",
+      "run.completed",
+    ]);
+    expect(saved.at(-1)?.runs).toEqual([
+      expect.objectContaining({ id: "voice:call-search", status: "completed" }),
+    ]);
+  });
 });

package/src/app/agentkit/react/voice-transcripts.ts

@@ -2,16 +2,26 @@ import {
   hasActiveAgentRuns,
   type AgentKitController,
 } from "@agent-native/agentkit/client";
-import type { AgentMessage } from "@agent-native/agentkit/protocol";
+import {
+  inferAgentActivityKind,
+  type AgentActivity,
+  type AgentEvent,
+  type AgentMessage,
+  type AgentToolCall,
+} from "@agent-native/agentkit/protocol";
 import { useEffect } from "react";
 
 import {
+  realtimeVoiceToolLabel,
   realtimeVoiceTranscriptRegistry,
   type RealtimeVoiceTranscriptMessage,
+  type RealtimeVoiceWorkCall,
+  type RealtimeVoiceWorkUpdate,
 } from "../../../composer/realtime-voice-transcript.js";
 import { isChatThreadViewed } from "./viewed-threads.js";
 
 const REALTIME_VOICE_MESSAGE_SOURCE = "realtime-voice";
+const VOICE_RUN_PREFIX = "voice:";
 
 function realtimeVoiceTranscriptMessage(
   transcript: RealtimeVoiceTranscriptMessage,
@@ -29,6 +39,175 @@ function realtimeVoiceTranscriptMessage(
   };
 }
 
+/**
+ * The events a voice reply's work still needs in its thread, as one local
+ * run. The run never starts on the server, so it never counts as an active
+ * run that would hold the composer or the transcript. `existingIds` and
+ * `lastSequence` describe the run as the thread already has it.
+ */
+export function realtimeVoiceWorkEvents(
+  update: RealtimeVoiceWorkUpdate,
+  existingIds: ReadonlySet<string> = new Set(),
+  lastSequence = 0,
+): AgentEvent[] {
+  const runId = `${VOICE_RUN_PREFIX}${update.id}`;
+  const base = (id: string, occurredAt: string) => ({
+    id: `${runId}:${id}`,
+    threadId: update.threadId,
+    runId,
+    // Numbered below, once the events this run already has are left out.
+    sequence: 0,
+    occurredAt,
+  });
+  const steps: { at: string; event: AgentEvent }[] = [];
+  for (const call of update.calls) {
+    const toolCall: AgentToolCall = {
+      id: call.id,
+      name: call.name,
+      status: "running",
+      runId,
+      ...(call.input ? { input: call.input } : {}),
+    };
+    const activity: AgentActivity = {
+      id: call.id,
+      kind: inferAgentActivityKind(call.name),
+      label: realtimeVoiceToolLabel(call.name),
+      status: "running",
+      runId,
+      startedAt: call.startedAt,
+    };
+    steps.push(
+      {
+        at: call.startedAt,
+        event: {
+          ...base(`${call.id}:tool-started`, call.startedAt),
+          type: "tool.started",
+          toolCall,
+        },
+      },
+      {
+        at: call.startedAt,
+        event: {
+          ...base(`${call.id}:activity-started`, call.startedAt),
+          type: "activity.started",
+          activity,
+        },
+      },
+    );
+    const { completedAt } = call;
+    if (!completedAt || call.status === "running") continue;
+    steps.push(
+      {
+        at: completedAt,
+        event: {
+          ...base(`${call.id}:tool-ended`, completedAt),
+          type: "tool.updated",
+          toolCall: {
+            ...toolCall,
+            status: call.status,
+            ...(call.output !== undefined ? { output: call.output } : {}),
+          },
+        },
+      },
+      {
+        at: completedAt,
+        event: {
+          ...base(`${call.id}:activity-ended`, completedAt),
+          type: "activity.completed",
+          activity: { ...activity, status: call.status, completedAt },
+        },
+      },
+    );
+  }
+  // Stable: a call's start keeps its place before its end at the same time.
+  steps.sort((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  if (update.completedAt) {
+    steps.push({
+      at: update.completedAt,
+      event: {
+        ...base("completed", update.completedAt),
+        type: "run.completed",
+      },
+    });
+  }
+  let sequence = lastSequence;
+  return steps
+    .filter(({ event }) => !existingIds.has(event.id))
+    .map(({ event }) => ({ ...event, sequence: ++sequence }));
+}
+
+/**
+ * Voice work this page is still running, by thread. Saved work that is not
+ * here can never finish, so it is closed instead of waited on.
+ */
+const runningVoiceWork = new Map<string, Set<string>>();
+
+interface VoiceRunThread {
+  events: readonly AgentEvent[];
+  runs: Readonly<Record<string, { lastSequence: number }>>;
+}
+
+function voiceRunPosition(thread: VoiceRunThread, runId: string) {
+  return {
+    existingIds: new Set(
+      thread.events
+        .filter((event) => event.runId === runId)
+        .map((event) => event.id),
+    ),
+    lastSequence:
+      new Map(Object.entries(thread.runs)).get(runId)?.lastSequence ?? 0,
+  };
+}
+
+/**
+ * The events that end, as cancelled, every voice run in `thread` with no
+ * terminal event. A snapshot saved while a call ran keeps such a run after a
+ * reload, and nothing is left to finish it.
+ */
+export function orphanedVoiceWorkEvents(
+  thread: VoiceRunThread,
+  threadId: string,
+  completedAt = new Date().toISOString(),
+): AgentEvent[] {
+  const runs = new Map<
+    string,
+    { calls: RealtimeVoiceWorkCall[]; completed: boolean }
+  >();
+  for (const event of thread.events) {
+    if (!event.runId.startsWith(VOICE_RUN_PREFIX)) continue;
+    const run = runs.get(event.runId) ?? { calls: [], completed: false };
+    runs.set(event.runId, run);
+    if (event.type === "run.completed") run.completed = true;
+    if (event.type !== "tool.started") continue;
+    const { input } = event.toolCall;
+    run.calls.push({
+      id: event.toolCall.id,
+      name: event.toolCall.name,
+      status: "cancelled",
+      startedAt: event.occurredAt,
+      completedAt,
+      ...(input && typeof input === "object" && !Array.isArray(input)
+        ? { input: input as Record<string, unknown> }
+        : {}),
+    });
+  }
+  return [...runs]
+    .filter(([, run]) => !run.completed)
+    .flatMap(([runId, run]) => {
+      const { existingIds, lastSequence } = voiceRunPosition(thread, runId);
+      return realtimeVoiceWorkEvents(
+        {
+          id: runId.slice(VOICE_RUN_PREFIX.length),
+          threadId,
+          calls: run.calls,
+          completedAt,
+        },
+        existingIds,
+        lastSequence,
+      );
+    });
+}
+
 /** A voice chat turn still being spoken; hosts must not save it. */
 export function isStreamingVoiceMessage(message: AgentMessage): boolean {
   const custom = message.metadata?.custom as { source?: unknown } | undefined;
@@ -51,23 +230,81 @@ export function useRealtimeVoiceTranscripts(
   useEffect(() => {
     if (!threadId || !controller.upsertLocalMessages) return;
     const upsert = controller.upsertLocalMessages.bind(controller);
-    return realtimeVoiceTranscriptRegistry.register({
+    const appendEvents = controller.appendLocalEvents?.bind(controller);
+    /** False when the thread could not be checked yet. */
+    const closeOrphanedWork = (): boolean => {
+      if (!appendEvents || runningVoiceWork.get(threadId)?.size) return false;
+      const thread = controller.getThread(threadId);
+      if (hasActiveAgentRuns(thread)) return false;
+      const events = orphanedVoiceWorkEvents(thread, threadId);
+      if (events.length > 0) appendEvents(threadId, events);
+      return true;
+    };
+    const persist = () => {
+      // The work's completion saves the thread, this turn included.
+      if (runningVoiceWork.get(threadId)?.size) return;
+      closeOrphanedWork();
+      const messages = controller
+        .getThread(threadId)
+        .messages.filter((message) => !isStreamingVoiceMessage(message));
+      // A failed save surfaces through the controller's connection error;
+      // a host without transport persistence saves the thread itself.
+      void controller.persistThreadSnapshotWithResult?.(threadId, messages);
+    };
+    // The thread's snapshot can land after this mounts, so check each time
+    // its events change rather than once.
+    let checkedEventCount = -1;
+    const closeOrphanedWorkOnChange = () => {
+      const { length } = controller.getThread(threadId).events;
+      if (length === checkedEventCount) return;
+      if (closeOrphanedWork()) checkedEventCount = length;
+    };
+    closeOrphanedWorkOnChange();
+    const unsubscribe = controller.subscribe(closeOrphanedWorkOnChange);
+    const unregister = realtimeVoiceTranscriptRegistry.register({
       threadId,
       active: () => isChatThreadViewed(threadId),
+      ...(appendEvents
+        ? {
+            appendWork: (update: RealtimeVoiceWorkUpdate) => {
+              if (hasActiveAgentRuns(controller.getThread(threadId))) {
+                return false;
+              }
+              const runId = `${VOICE_RUN_PREFIX}${update.id}`;
+              const { existingIds, lastSequence } = voiceRunPosition(
+                controller.getThread(threadId),
+                runId,
+              );
+              const running = runningVoiceWork.get(threadId) ?? new Set();
+              runningVoiceWork.set(threadId, running);
+              // Marked before the append notifies, so its own events never
+              // read as orphaned.
+              if (!update.completedAt) running.add(runId);
+              appendEvents(
+                threadId,
+                realtimeVoiceWorkEvents(update, existingIds, lastSequence),
+              );
+              if (update.completedAt) {
+                running.delete(runId);
+                persist();
+              }
+              return true;
+            },
+          }
+        : {}),
       append: (transcript) => {
         // A run owns the thread snapshot while it streams; the turn waits in
         // the registry and lands when this sink re-registers after the run.
         if (hasActiveAgentRuns(controller.getThread(threadId))) return false;
         upsert(threadId, [realtimeVoiceTranscriptMessage(transcript)]);
         if (transcript.status === "streaming") return true;
-        const messages = controller
-          .getThread(threadId)
-          .messages.filter((message) => !isStreamingVoiceMessage(message));
-        // A failed save surfaces through the controller's connection error;
-        // a host without transport persistence saves the thread itself.
-        void controller.persistThreadSnapshotWithResult?.(threadId, messages);
+        persist();
         return true;
       },
     });
+    return () => {
+      unsubscribe();
+      unregister();
+    };
   }, [controller, threadId, running]);
 }

package/src/app/chat/AgentKitAssistantChat.spec.tsx

@@ -76,6 +76,7 @@ const chatMocks = vi.hoisted(() => ({
     activeRunIds: [] as string[],
     runs: {} as Record<string, any>,
     approvals: {} as Record<string, any>,
+    connectionRequests: {} as Record<string, any>,
     suggestions: [] as any[],
     tools: {} as Record<string, unknown>,
     activities: {} as Record<string, unknown>,
@@ -1060,6 +1061,7 @@ beforeEach(() => {
     activeRunIds: [],
     runs: {},
     approvals: {},
+    connectionRequests: {},
     suggestions: [],
     tools: {},
     activities: {},
@@ -3040,22 +3042,19 @@ describe("AgentKitAssistantChat host behavior", () => {
     }
   });
 
-  it("keeps the real editor editable while AI setup is missing", async () => {
+  it("closes the real editor to typing while AI setup is missing", async () => {
     chatMocks.useRealChat = true;
     chatMocks.readiness = { canChat: false, missing: true, state: "missing" };
     await useRealComposer();
     await mount(baseProps({ showModelSelector: false }));
 
-    const editor = container.querySelector<HTMLElement>(
-      '[contenteditable="true"]',
-    );
-    expect(editor).not.toBeNull();
-    expect(chatMocks.composerProps.disabled).toBe(false);
-
-    await act(async () =>
-      chatMocks.composerProps.composerRef.current.setText("Draft before setup"),
-    );
-    expect(editor?.textContent).toBe("Draft before setup");
+    expect(container.querySelector('[contenteditable="false"]')).not.toBeNull();
+    expect(container.querySelector('[contenteditable="true"]')).toBeNull();
+    expect(
+      container
+        .querySelector('[role="textbox"]')
+        ?.getAttribute("aria-disabled"),
+    ).toBe("true");
   });
 
   it("keeps the real editor editable while a submission is in flight", async () => {
@@ -9365,6 +9364,55 @@ describe("AgentKitAssistantChat host behavior", () => {
     });
   });
 
+  it("keeps a host-owned setup route open until the server confirms setup is missing", async () => {
+    chatMocks.readiness = { canChat: false, missing: false, state: "unknown" };
+    const props = baseProps({ setupCardOwner: "host" });
+    await mount(props);
+    await act(async () =>
+      chatMocks.composerProps.onModelConnectionRequiredChange(true),
+    );
+    await flush();
+
+    expect(chatMocks.composerProps.setupCardVisible).toBe(false);
+
+    chatMocks.readiness = { canChat: false, missing: true, state: "missing" };
+    await act(async () => root.render(<AgentKitAssistantChat {...props} />));
+    await flush();
+
+    expect(chatMocks.composerProps.setupCardVisible).toBe(true);
+  });
+
+  it("does not replay a refused prompt when only the model list guessed setup was missing", async () => {
+    chatMocks.readiness = { canChat: false, missing: false, state: "unknown" };
+    chatMocks.failureError = {
+      code: "missing_credentials",
+      message: "No LLM provider is connected.",
+    };
+    chatMocks.thread.messages = [
+      {
+        id: "user-refused",
+        role: "user",
+        parts: [{ type: "text", text: "Old prompt" }],
+      },
+    ];
+    const props = baseProps({});
+    await mount(props);
+    await act(async () =>
+      chatMocks.composerProps.onModelConnectionRequiredChange(true),
+    );
+    await flush();
+
+    chatMocks.readiness = {
+      canChat: true,
+      missing: false,
+      state: "configured",
+    };
+    await act(async () => root.render(<AgentKitAssistantChat {...props} />));
+    await flush();
+
+    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
+  });
+
   it("does not replay a refused prompt when the thread reopens already connected", async () => {
     chatMocks.readiness = { canChat: false, missing: false, state: "unknown" };
     chatMocks.failureError = {