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

package/src/app/agentkit/react/lifecycle.spec.tsx

@@ -1152,8 +1152,14 @@ describe("AgentChat lifecycle", () => {
       revision: 2,
     });
     await flush();
-    expect(tree.container.querySelector(".agentkit-activities")).toBeNull();
-    expect(tree.container.textContent).not.toContain("Worked for");
+    // The saved reply kept no reasoning, so only the turn's time is left, and
+    // with no model or usage recorded it has nothing to open to.
+    const settled = tree.container.querySelectorAll<HTMLElement>(
+      ".agentkit-activities",
+    );
+    expect(settled).toHaveLength(1);
+    expect(settled[0]?.dataset.expandable).toBe("false");
+    expect(settled[0]?.textContent).toBe("Worked for 4s");
     expect(
       tree.container
         .querySelector('[data-message-id="assistant-1"]')

package/src/app/agentkit/react/message-actions.spec.tsx

@@ -1,11 +1,15 @@
 // @vitest-environment happy-dom
 
 import { AgentKitClient } from "@agent-native/agentkit/client";
-import type {
-  AgentEvent,
-  AgentMessage,
-  AgentToolCall,
-  AgentTransport,
+import {
+  createAgentKitProtocolVersionOffer,
+  createCapabilityUnavailableError,
+  negotiateAgentKitProtocolVersion,
+  parseAgentCapabilitiesDiscovery,
+  type AgentEvent,
+  type AgentMessage,
+  type AgentToolCall,
+  type AgentTransport,
 } from "@agent-native/agentkit/protocol";
 import { act, type ReactNode } from "react";
 import { createRoot } from "react-dom/client";
@@ -284,6 +288,111 @@ describe("assistant reply toolbar", () => {
     expect(labelsOf(set(older, "secondary"))).toEqual(["Fork from here"]);
   });
 
+  it("names each icon-only action in a tooltip on hover", async () => {
+    const { container, toolbar } = await renderChat();
+    const latest = toolbar("assistant-latest");
+    const user = container.querySelector<HTMLElement>(
+      '[data-message-id="user-2"] .agentkit-message-actions',
+    )!;
+    const hoverName = async (button: HTMLButtonElement) => {
+      vi.useFakeTimers();
+      try {
+        await act(async () => {
+          button.dispatchEvent(
+            new PointerEvent("pointermove", {
+              bubbles: true,
+              pointerType: "mouse",
+            }),
+          );
+          vi.advanceTimersByTime(1000);
+        });
+        const name = document.querySelector('[role="tooltip"]')?.textContent;
+        await act(async () => {
+          button.dispatchEvent(
+            new PointerEvent("pointerleave", {
+              bubbles: true,
+              pointerType: "mouse",
+            }),
+          );
+          vi.advanceTimersByTime(1000);
+        });
+        return name;
+      } finally {
+        vi.useRealTimers();
+      }
+    };
+
+    const names: Array<string | null | undefined> = [];
+    const hoverAll = async (scope: HTMLElement) => {
+      for (const button of Array.from(scope.querySelectorAll("button"))) {
+        // The idle set is inert, so only the open set's actions can be hovered.
+        if (!button.closest("[inert]")) names.push(await hoverName(button));
+      }
+    };
+    await hoverAll(latest);
+    await press(toggle(latest));
+    await hoverAll(set(latest, "secondary")!);
+    await hoverAll(user);
+    expect(names).toEqual([
+      "Copy message",
+      "Good response",
+      "Bad response",
+      "More actions",
+      "Retry",
+      "Fork from here",
+      "Copy request ID",
+      "Copy message",
+    ]);
+  });
+
+  it("shows a degraded action's reason in its tooltip, not a second native title", async () => {
+    const reason = "Feedback is queued and may take a minute to record.";
+    const { toolbar } = await renderChat({
+      transport: {
+        async discoverCapabilities() {
+          return parseAgentCapabilitiesDiscovery({
+            protocol: negotiateAgentKitProtocolVersion(
+              createAgentKitProtocolVersionOffer(),
+            ),
+            discoveredAt: "2026-10-23T00:00:00.000Z",
+            capabilities: [
+              { id: "threadForking", state: "available" },
+              {
+                id: "feedback",
+                state: "degraded",
+                error: createCapabilityUnavailableError("feedback", {
+                  message: reason,
+                  retryable: true,
+                }),
+              },
+            ],
+          });
+        },
+      },
+    });
+    const good = thumb(toolbar("assistant-latest"), "positive");
+
+    expect(good.disabled).toBe(false);
+    expect(good.hasAttribute("title")).toBe(false);
+    vi.useFakeTimers();
+    try {
+      await act(async () => {
+        good.dispatchEvent(
+          new PointerEvent("pointermove", {
+            bubbles: true,
+            pointerType: "mouse",
+          }),
+        );
+        vi.advanceTimersByTime(1000);
+      });
+    } finally {
+      vi.useRealTimers();
+    }
+    expect(document.querySelector('[role="tooltip"]')?.textContent).toBe(
+      `Good response${reason}`,
+    );
+  });
+
   it("shows More as pressed while its actions are open, past its hover fill", async () => {
     const { toolbar } = await renderChat();
     const more = toggle(toolbar("assistant-latest"));
@@ -618,6 +727,53 @@ describe("Worked for run details", () => {
       ).toBe("1");
     }
 
+    const charged = await renderChat({
+      loadRunUsage: async () => ({
+        durationMs: null,
+        billing: {
+          providerCostUsd: 0.02,
+          providerCostSource: "reported" as const,
+          builderCredits: 0,
+          builderCreditsSource: "estimated" as const,
+          incomplete: false,
+        },
+      }),
+      events: runEvents("run-latest", [...toolWork], latestAnswer),
+    });
+    await press(
+      charged.container.querySelector(".agentkit-activities-summary"),
+    );
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+    const charge = charged.container.querySelector('[data-detail="credits"]');
+    expect(charge?.querySelector("dt")?.textContent).toBe("Cost");
+    expect(charge?.querySelector("dd")?.textContent).toBe("$0.02");
+
+    // Auto names no model, so with no steps the zero is the only detail left
+    // and still shows.
+    const alone = await renderChat({
+      followUpModel: "auto",
+      loadRunUsage: async () => ({
+        durationMs: null,
+        billing: {
+          providerCostUsd: 0,
+          providerCostSource: "reported" as const,
+          builderCredits: 0,
+          builderCreditsSource: "estimated" as const,
+          incomplete: false,
+        },
+      }),
+      events: runEvents("run-latest", [], latestAnswer),
+    });
+    await press(alone.container.querySelector(".agentkit-activities-summary"));
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+    expect(
+      alone.container.querySelector('[data-detail="credits"] dd')?.textContent,
+    ).toMatch(/^0\.0\b/);
+
     const unrecorded = await renderChat({
       loadRunUsage: async () => ({ durationMs: null, billing: null }),
       events: runEvents("run-latest", [...toolWork], latestAnswer),

package/src/app/agentkit/react/saved-reply-reload.spec.tsx

@@ -0,0 +1,206 @@
+// @vitest-environment happy-dom
+
+import { AgentKitClient } from "@agent-native/agentkit/client";
+import { createAgentNativeAgentKitTransport } from "@agent-native/core/client/agentkit-chat/transport";
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { AgentKitChat } from "./components.js";
+import { AgentKitProvider } from "./context.js";
+
+const threadId = "thread-saved-reply-reload";
+const runId = "run-saved-reply-reload";
+const turnId = "turn-saved-reply-reload";
+const promptId = "message-prompt";
+const streamedId = "message-streamed-reply";
+const startedAt = Date.parse("2026-10-26T21:43:54.411Z");
+const completedAt = startedAt + 19_193;
+const streamedAnswer = "Here are the main answers so you can pick.";
+const savedAnswer = "Here are the main answers, so you can pick your own.";
+
+function iso(ms: number): string {
+  return new Date(ms).toISOString();
+}
+
+function event(sequence: number, occurredAt: number, body: object) {
+  return {
+    id: `${runId}:${sequence}`,
+    threadId,
+    runId,
+    sequence,
+    occurredAt: iso(occurredAt),
+    ...body,
+  };
+}
+
+const activity = {
+  id: "activity-read",
+  kind: "read",
+  label: "Read the brief",
+};
+
+// The thread as the server saves it: its own copy of the reply under its own
+// id, beside the chat's copy under the id the run's events use.
+const storedThread = {
+  id: threadId,
+  threadData: JSON.stringify({
+    messages: [
+      {
+        message: {
+          id: `server-user-${runId}`,
+          role: "user",
+          content: [{ type: "text", text: "Compare them" }],
+          metadata: {
+            custom: {
+              submittedRunId: runId,
+              submittedTurnId: turnId,
+              agentKitMessageId: promptId,
+            },
+          },
+        },
+        parentId: null,
+      },
+      {
+        message: {
+          id: `server-${runId}`,
+          role: "assistant",
+          status: { type: "complete", reason: "stop" },
+          content: [{ type: "text", text: savedAnswer }],
+          metadata: {
+            runId,
+            custom: {
+              turnId,
+              foldedRunIds: [runId],
+              agentNativeRunDurationMs: 19_027,
+            },
+          },
+        },
+        parentId: `server-user-${runId}`,
+      },
+    ],
+    agentKit: {
+      messages: [
+        {
+          id: promptId,
+          role: "user",
+          parts: [{ type: "text", text: "Compare them" }],
+        },
+        {
+          id: streamedId,
+          role: "assistant",
+          status: "complete",
+          parts: [{ type: "text", text: streamedAnswer }],
+        },
+      ],
+      events: [
+        event(1, startedAt, { type: "run.started" }),
+        event(2, startedAt + 200, {
+          type: "activity.started",
+          activity: { ...activity, status: "running" },
+        }),
+        event(3, startedAt + 1_200, {
+          type: "activity.completed",
+          activity: { ...activity, status: "completed" },
+        }),
+        event(4, completedAt, {
+          type: "message.completed",
+          message: {
+            id: streamedId,
+            role: "assistant",
+            status: "complete",
+            parts: [{ type: "text", text: streamedAnswer }],
+          },
+        }),
+        event(5, completedAt, { type: "run.completed" }),
+      ],
+      runs: [
+        {
+          id: runId,
+          threadId,
+          status: "completed",
+          startedAt: iso(startedAt),
+          completedAt: iso(completedAt),
+          lastSequence: 5,
+          activeMessageId: streamedId,
+        },
+      ],
+      activeRunIds: [],
+      suggestions: [],
+    },
+  }),
+  runLifecycles: {
+    queriedRunIds: [runId],
+    runs: [
+      {
+        id: runId,
+        status: "completed",
+        startedAt,
+        completedAt,
+        errorCode: null,
+        abortReason: null,
+        terminalReason: "done",
+      },
+    ],
+  },
+};
+
+function json(value: unknown): Response {
+  return new Response(JSON.stringify(value), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+let client: AgentKitClient | undefined;
+let container: HTMLDivElement;
+let root: Root;
+
+beforeEach(() => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  container = document.createElement("div");
+  document.body.append(container);
+  root = createRoot(container);
+});
+
+afterEach(async () => {
+  await act(async () => root.unmount());
+  client?.dispose();
+  client = undefined;
+  container.remove();
+  vi.unstubAllGlobals();
+});
+
+describe("reloading a thread whose saved reply differs from the stream", () => {
+  it("shows the saved reply with its Worked for row", async () => {
+    const transport = createAgentNativeAgentKitTransport({
+      fetch: vi.fn(async (input: string | URL | Request) =>
+        String(input).includes("/runs/active")
+          ? json({ active: false, status: "completed", runId })
+          : json(storedThread),
+      ) as typeof fetch,
+    });
+    client = new AgentKitClient({ transport });
+    await client.loadThread(threadId);
+    await act(async () =>
+      root.render(
+        <AgentKitProvider controller={client!} threadId={threadId}>
+          <AgentKitChat composer={false} />
+        </AgentKitProvider>,
+      ),
+    );
+
+    const transcript = container.querySelector(".agentkit-transcript")!;
+    const replies = transcript.querySelectorAll(
+      '[data-message-id][data-role="assistant"]',
+    );
+    expect(
+      [...replies].map((reply) => reply.getAttribute("data-message-id")),
+    ).toEqual([streamedId]);
+    expect(replies[0]?.textContent).toContain(savedAnswer);
+    expect(transcript.textContent).not.toContain(streamedAnswer);
+    expect(
+      transcript.querySelector(".agentkit-activities-label")?.textContent,
+    ).toBe("Worked for 19s");
+  });
+});