@agent-native/toolkit 0.205.0 → 0.206.0-nightly-20261009011246

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/toolkit",
-  "version": "0.205.0",
+  "version": "0.206.0-nightly-20261009011246",
   "description": "Reusable app-building UI and helpers for Agent-Native apps.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -673,7 +673,7 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.205.0"
+    "@agent-native/agentkit": "^0.206.0-nightly-20261009011246"
   },
   "devDependencies": {
     "@excalidraw/excalidraw": "0.18.1",
@@ -697,10 +697,10 @@
     "typescript-7": "npm:typescript@^7.0.2",
     "vite": "8.1.0",
     "vitest": "^4.1.5",
-    "@agent-native/core": "^0.205.0"
+    "@agent-native/core": "^0.206.0-nightly-20261009011246"
   },
   "peerDependencies": {
-    "@agent-native/core": ">=0.196.0",
+    "@agent-native/core": "0.206.0-nightly-20261009011246",
     "@excalidraw/excalidraw": ">=0.18",
     "@excalidraw/mermaid-to-excalidraw": ">=2",
     "@tanstack/react-query": "^5.99.2",

package/src/app/agentkit/react/components.interaction.spec.tsx

@@ -45,11 +45,152 @@ vi.mock("../../../design-system/index.js", async (importOriginal) => {
 
 import { AgentKitClient } from "@agent-native/agentkit/client";
 import type { AgentTransport } from "@agent-native/agentkit/protocol";
+import {
+  SESSION_REPLAY_BLOCK_ATTRIBUTE,
+  SESSION_REPLAY_MASK_ATTRIBUTE,
+} from "@agent-native/core/client/session-replay-privacy";
 
 import { getComposerDraftKey } from "../../../composer/draft-key.js";
-import { AgentKitChat, AgentMessageActions } from "./components.js";
+import {
+  AgentActivityItem,
+  AgentInteractionItem,
+  AgentKitChat,
+  AgentMessageActions,
+} from "./components.js";
 import { AgentKitProvider } from "./context.js";
 
+describe("AgentActivityItem replay privacy", () => {
+  it.each(["failed", "completed"] as const)(
+    "hides only failed activity diagnostics (%s)",
+    async (status) => {
+      const client = new AgentKitClient({
+        transport: {
+          async startRun() {
+            return { runId: "run-example" };
+          },
+          async *subscribeToRun() {},
+          async cancelRun() {},
+        },
+      });
+      const container = document.createElement("div");
+      document.body.appendChild(container);
+      const root = createRoot(container);
+      vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+      try {
+        await act(async () =>
+          root.render(
+            <AgentKitProvider controller={client} threadId="thread-example">
+              <AgentActivityItem
+                value={{
+                  id: "activity-example",
+                  kind: "tool",
+                  label: "Example tool",
+                  status,
+                  detail: "Example Person's example notes.",
+                  summary: [
+                    { type: "text", text: "Example Document diagnostics." },
+                    {
+                      type: "citation",
+                      title: "Example report",
+                      url: "https://example.test/report?person=example",
+                    },
+                  ],
+                }}
+                threadId="thread-example"
+              />
+            </AgentKitProvider>,
+          ),
+        );
+        const disclosure = container.querySelector<HTMLButtonElement>(
+          "button[aria-expanded]",
+        )!;
+        expect(
+          disclosure.closest(`[${SESSION_REPLAY_MASK_ATTRIBUTE}]`),
+        ).toBeNull();
+        expect(
+          container
+            .querySelector(".agentkit-activity-label")
+            ?.closest(`[${SESSION_REPLAY_MASK_ATTRIBUTE}]`),
+        ).toBeNull();
+        const detail = container.querySelector(".agentkit-activity-detail");
+        expect(detail?.hasAttribute(SESSION_REPLAY_MASK_ATTRIBUTE)).toBe(
+          status === "failed",
+        );
+        expect(detail?.hasAttribute("title")).toBe(status !== "failed");
+        await act(async () => disclosure.click());
+        const summary = container.querySelector(".agentkit-activity-summary");
+        expect(summary?.textContent).toContain("Example Document diagnostics.");
+        expect(
+          summary
+            ?.querySelector('a[href^="https://example.test/report"]')
+            ?.closest(`[${SESSION_REPLAY_BLOCK_ATTRIBUTE}]`) !== null,
+        ).toBe(status === "failed");
+      } finally {
+        await act(async () => root.unmount());
+        await client.shutdown();
+        container.remove();
+        vi.unstubAllGlobals();
+      }
+    },
+  );
+});
+
+describe("AgentInteractionItem replay privacy", () => {
+  it.each(["failed", "completed"] as const)(
+    "masks only failed interaction details (%s)",
+    async (kind) => {
+      const client = new AgentKitClient({
+        transport: {
+          async startRun() {
+            return { runId: "run-example" };
+          },
+          async *subscribeToRun() {},
+          async cancelRun() {},
+        },
+      });
+      const container = document.createElement("div");
+      document.body.appendChild(container);
+      const root = createRoot(container);
+      vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+      try {
+        await act(async () =>
+          root.render(
+            <AgentKitProvider controller={client} threadId="thread-example">
+              <AgentInteractionItem
+                value={{
+                  id: "interaction-example",
+                  kind,
+                  agentId: "agent-example",
+                  detail: "Example Person's example notes",
+                }}
+                threadId="thread-example"
+              />
+            </AgentKitProvider>,
+          ),
+        );
+        const detail = container.querySelector(
+          ".agentkit-agent-interaction-detail",
+        );
+        expect(detail?.textContent).toBe("Example Person's example notes");
+        expect(detail?.hasAttribute(SESSION_REPLAY_MASK_ATTRIBUTE)).toBe(
+          kind === "failed",
+        );
+        expect(detail?.hasAttribute("title")).toBe(kind !== "failed");
+        expect(
+          container
+            .querySelector(".agentkit-agent-interaction-label")
+            ?.closest(`[${SESSION_REPLAY_MASK_ATTRIBUTE}]`),
+        ).toBeNull();
+      } finally {
+        await act(async () => root.unmount());
+        await client.shutdown();
+        container.remove();
+        vi.unstubAllGlobals();
+      }
+    },
+  );
+});
+
 describe("AgentKitChat interactions", () => {
   it("preserves host submission disablement", async () => {
     const client = new AgentKitClient({
@@ -1045,6 +1186,93 @@ describe("AgentKitChat interactions", () => {
     }
   });
 
+  it("masks the default composer's send and attachment errors", async () => {
+    const transport: AgentTransport = {
+      capabilities: { uploads: true },
+      async startRun() {
+        throw new Error("Jane Doe's notes are locked");
+      },
+      async *subscribeToRun() {},
+      async cancelRun() {},
+    };
+    const client = new AgentKitClient({ transport });
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    const actEnvironment = globalThis as typeof globalThis & {
+      IS_REACT_ACT_ENVIRONMENT?: boolean;
+    };
+    const previousActEnvironment = actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+    const composerError = (text: string) =>
+      [...container.querySelectorAll(".agentkit-composer-error span")].find(
+        (span) => span.textContent?.includes(text),
+      );
+
+    try {
+      await act(async () => {
+        root.render(
+          <AgentKitProvider controller={client} threadId="thread-errors">
+            <AgentKitChat
+              composerProps={{
+                initialText: "Summarize my notes",
+                modelStatusChecksEnabled: false,
+              }}
+            />
+          </AgentKitProvider>,
+        );
+        await Promise.resolve();
+      });
+
+      const drop = new Event("drop", { bubbles: true, cancelable: true });
+      Object.defineProperty(drop, "dataTransfer", {
+        value: {
+          types: ["Files"],
+          files: [
+            new File(["zip"], "Jane Doe taxes.zip", {
+              type: "application/zip",
+            }),
+          ],
+          dropEffect: "none",
+        },
+      });
+      await act(async () => {
+        container.querySelector(".agentkit-chat")?.dispatchEvent(drop);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+      expect(
+        composerError("Jane Doe taxes.zip")?.hasAttribute(
+          SESSION_REPLAY_MASK_ATTRIBUTE,
+        ),
+      ).toBe(true);
+
+      await act(async () => {
+        container
+          .querySelector<HTMLButtonElement>(
+            '[data-agent-composer-slot="send-button"]',
+          )
+          ?.click();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+      expect(
+        composerError("Jane Doe's notes are locked")?.hasAttribute(
+          SESSION_REPLAY_MASK_ATTRIBUTE,
+        ),
+      ).toBe(true);
+    } finally {
+      await act(async () => {
+        root.unmount();
+        await Promise.resolve();
+      });
+      container.remove();
+      if (previousActEnvironment === undefined) {
+        delete actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+      } else {
+        actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+      }
+    }
+  });
+
   it("disables transcript file drops when the host disables uploads", async () => {
     const transport: AgentTransport = {
       capabilities: { uploads: true },

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

@@ -17,6 +17,7 @@ import {
 import { ToolkitProvider } from "../../../provider.js";
 import { AgentChat } from "./chat.js";
 import {
+  AgentConnectionErrorView,
   AgentKitComposer,
   AgentKitChat,
   type AgentKitComposerProps,
@@ -32,6 +33,43 @@ import {
 } from "./context.js";
 import { AgentKitRoot } from "./root.js";
 
+describe("AgentConnectionErrorView replay privacy", () => {
+  it("masks connection and recovery messages while preserving the headline and reconnect control", () => {
+    const client = new AgentKitClient({
+      transport: {
+        async startRun() {
+          return { runId: "run-example" };
+        },
+        async *subscribeToRun() {},
+        async cancelRun() {},
+      },
+    });
+    const html = renderToStaticMarkup(
+      <AgentKitProvider controller={client} threadId="thread-example">
+        <AgentConnectionErrorView
+          error={{
+            code: "runtime_error",
+            message: "Example Person's connection failed.",
+            retryable: true,
+          }}
+          threadId="thread-example"
+          recover={async () => {}}
+          recovering={false}
+          recoveryError={new Error("Example Document recovery failed.")}
+        />
+      </AgentKitProvider>,
+    );
+    expect(html).toContain(
+      '<span data-an-mask="">Example Person&#x27;s connection failed.</span>',
+    );
+    expect(html).toContain(
+      '<span data-an-mask="" class="agentkit-command-error">Example Document recovery failed.</span>',
+    );
+    expect(html).toContain("<strong>Something went wrong</strong>");
+    expect(html).toContain("Reconnect");
+  });
+});
+
 describe("AgentMessageActions request IDs", () => {
   it("prefers an explicit request ID and never uses the local message ID", () => {
     expect(
@@ -1782,7 +1820,10 @@ describe("AgentKitChat", () => {
     expect(defaultHtml.match(/class="agentkit-run-failure"/g)).toHaveLength(1);
     expect(defaultHtml).toContain('data-run-id="run-failure"');
     expect(defaultHtml).toContain('data-error-code="tool_timeout"');
-    expect(defaultHtml).toContain("The dashboard check timed out.");
+    expect(defaultHtml).toContain(
+      '<span data-an-mask="">The dashboard check timed out.</span>',
+    );
+    expect(defaultHtml).toContain("<strong>Run failed</strong>");
 
     const slotCalls: AgentRunFailureRenderProps[] = [];
     const RunFailure = (props: AgentRunFailureRenderProps) => {

package/src/app/agentkit/react/components.tsx

@@ -138,6 +138,11 @@ import {
 } from "./context.js";
 import { AgentStreamingText } from "./streaming-text.js";
 
+// AgentKit React installs without @agent-native/core, so it repeats core's
+// replay markers. Its specs assert core's attribute names.
+const SESSION_REPLAY_MASK_PROPS = { "data-an-mask": "" } as const;
+const SESSION_REPLAY_BLOCK_PROPS = { "data-an-block": "" } as const;
+
 export interface AgentKitErrorBoundaryProps {
   children: ReactNode;
   resetKey?: string | number;
@@ -920,7 +925,12 @@ export function AgentInteractionItem({
       {object ? (
         <ObjectRenderer value={object} threadId={threadId} />
       ) : detail ? (
-        <span className="agentkit-agent-interaction-detail" title={detail}>
+        <span
+          {...(interaction.kind === "failed"
+            ? SESSION_REPLAY_MASK_PROPS
+            : { title: detail })}
+          className="agentkit-agent-interaction-detail"
+        >
           {detail}
         </span>
       ) : null}
@@ -987,7 +997,13 @@ export function AgentActivityItem({
         </span>
         {object ? <ObjectRenderer value={object} threadId={threadId} /> : null}
         {detail ? (
-          <span className="agentkit-activity-detail" title={detail}>
+          // Replays mask text but record attributes, so failure text gets no title.
+          <span
+            {...(activity.status === "failed"
+              ? SESSION_REPLAY_MASK_PROPS
+              : { title: detail })}
+            className="agentkit-activity-detail"
+          >
             {detail}
           </span>
         ) : null}
@@ -1008,7 +1024,11 @@ export function AgentActivityItem({
         ) : null}
       </div>
       {open ? (
-        <div className="agentkit-activity-summary">
+        // Summary parts can render links, and replays keep their attributes.
+        <div
+          {...(activity.status === "failed" ? SESSION_REPLAY_BLOCK_PROPS : {})}
+          className="agentkit-activity-summary"
+        >
           {activity.summary?.map((part, index) => {
             const safePart =
               part.type === "text"
@@ -2331,7 +2351,11 @@ export function AgentApprovalPrompt({
         )}
       </div>
       {resolution.error ? (
-        <p className="agentkit-command-error" role="alert">
+        <p
+          {...SESSION_REPLAY_MASK_PROPS}
+          className="agentkit-command-error"
+          role="alert"
+        >
           {resolution.error.message}
         </p>
       ) : null}
@@ -2452,7 +2476,7 @@ export function AgentConnectionRequestCard({
       {resolution.error ? (
         <div className="agentkit-command-error" role="alert">
           <IconAlertCircle aria-hidden="true" className="agentkit-icon" />
-          <span>{resolution.error.message}</span>
+          <span {...SESSION_REPLAY_MASK_PROPS}>{resolution.error.message}</span>
         </div>
       ) : null}
     </Surface>
@@ -2501,7 +2525,11 @@ function AgentWidgetActionButton({
         {action.label}
       </ActionButton>
       {invocation.error ? (
-        <span className="agentkit-command-error" role="alert">
+        <span
+          {...SESSION_REPLAY_MASK_PROPS}
+          className="agentkit-command-error"
+          role="alert"
+        >
           {invocation.error.message}
         </span>
       ) : null}
@@ -3724,7 +3752,11 @@ export function AgentMessageActions({
         </>
       )}
       {actionError ? (
-        <span className="agentkit-command-error" role="alert">
+        <span
+          {...SESSION_REPLAY_MASK_PROPS}
+          className="agentkit-command-error"
+          role="alert"
+        >
           {actionError.message}
         </span>
       ) : null}
@@ -3880,7 +3912,7 @@ export function AgentRunFailure({
       <IconAlertCircle aria-hidden="true" className="agentkit-icon" />
       <div className="agentkit-run-failure-copy">
         <strong>{labels.runFailed}</strong>
-        <span>{error.message}</span>
+        <span {...SESSION_REPLAY_MASK_PROPS}>{error.message}</span>
         {canContinue ? (
           <div className="agentkit-error-actions">
             <ActionButton
@@ -3919,7 +3951,7 @@ export function AgentConnectionErrorView({
       role="alert"
     >
       <strong>{labels.error}</strong>
-      <span>{error.message}</span>
+      <span {...SESSION_REPLAY_MASK_PROPS}>{error.message}</span>
       {error.retryable ? (
         <div className="agentkit-error-actions">
           <ActionButton
@@ -3933,7 +3965,9 @@ export function AgentConnectionErrorView({
         </div>
       ) : null}
       {recoveryError ? (
-        <span className="agentkit-command-error">{recoveryError.message}</span>
+        <span {...SESSION_REPLAY_MASK_PROPS} className="agentkit-command-error">
+          {recoveryError.message}
+        </span>
       ) : null}
     </div>
   );
@@ -4691,13 +4725,13 @@ export function AgentKitComposer({
       {command.error ? (
         <div className="agentkit-composer-error" role="alert">
           <IconAlertCircle aria-hidden="true" className="agentkit-icon" />
-          <span>{command.error.message}</span>
+          <span {...SESSION_REPLAY_MASK_PROPS}>{command.error.message}</span>
         </div>
       ) : null}
       {attachmentError ? (
         <div className="agentkit-composer-error" role="alert">
           <IconAlertCircle aria-hidden="true" className="agentkit-icon" />
-          <span>{attachmentError}</span>
+          <span {...SESSION_REPLAY_MASK_PROPS}>{attachmentError}</span>
         </div>
       ) : null}
     </div>

package/src/app/auth/AuthPage.tsx

@@ -204,9 +204,22 @@ async function requestJson(
   url: string,
   init: RequestInit = {},
 ): Promise<AuthRequestResult> {
+  const headers = new Headers(init.headers);
+  if (typeof window !== "undefined") {
+    const requestUrl = new URL(url, window.location.href);
+    const sessionId = getAnalyticsSessionId();
+    if (
+      requestUrl.origin === window.location.origin &&
+      sessionId &&
+      /^[!-~]{1,127}$/.test(sessionId)
+    ) {
+      headers.set("X-Agent-Native-Session-Id", sessionId);
+    }
+  }
   const response = await fetch(url, {
     credentials: "include",
     ...init,
+    headers,
   });
   let data: Record<string, unknown> = {};
   let readable = false;

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

@@ -1,7 +1,10 @@
 // @vitest-environment happy-dom
 
 import { AgentKitClient } from "@agent-native/agentkit/client";
-import type { AgentTransport } from "@agent-native/agentkit/protocol";
+import type {
+  AgentMessage,
+  AgentTransport,
+} from "@agent-native/agentkit/protocol";
 import React, { act, createRef } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -639,6 +642,7 @@ import {
 import { AgentKitActionWidget } from "./agentkit-chat/action-widget.js";
 import {
   AgentKitAssistantChat,
+  agentMessageTextFromParts,
   type AgentKitAssistantChatProps,
 } from "./AgentKitAssistantChat.js";
 import type {
@@ -859,7 +863,10 @@ describe("AgentKitAssistantChat host behavior", () => {
       parts: [
         {
           type: "text",
-          text: 'Summarize @[the sprint|resource:123]\n<context data-agentkit-context-encoding="entities-v1">Private context</context>',
+          text: appendAgentChatContextToMessage(
+            "Summarize @[the sprint|resource:123] <context>",
+            "Private context",
+          ),
         },
       ],
     };
@@ -902,7 +909,81 @@ describe("AgentKitAssistantChat host behavior", () => {
 
     expect(savedSnapshots).toHaveBeenCalledWith(
       chatMocks.threadId,
-      expect.objectContaining({ title: "Summarize @the sprint" }),
+      expect.objectContaining({
+        title: "Summarize @the sprint <context>",
+        preview: "Summarize @[the sprint|resource:123] <context>",
+      }),
+    );
+  });
+
+  it("strips ambiguous text between legacy blocks across raw message parts", async () => {
+    const savedSnapshots = vi.fn();
+    const messageParts: AgentMessage["parts"] = [
+      {
+        type: "text",
+        text: "Summarize sprint <context>private first</context>ambiguous private",
+      },
+      {
+        type: "text",
+        text: " gap<context>private second</context> visible continuation",
+      },
+    ];
+    const message = {
+      id: "message-user-legacy-context",
+      role: "user",
+      status: "complete",
+      createdAt: "2026-10-07T12:00:00.000Z",
+      parts: messageParts,
+    };
+    chatMocks.thread = {
+      ...chatMocks.thread,
+      thread: {
+        id: chatMocks.threadId,
+        title: "",
+        createdAt: message.createdAt,
+        updatedAt: message.createdAt,
+      },
+      messages: [message],
+      events: [],
+      activeRunIds: [],
+      runs: {},
+      approvals: {},
+      approvalRunIds: {},
+      connectionRequests: {},
+      connectionRequestRunIds: {},
+      tools: {},
+      activities: {},
+      queuedMessages: [],
+      tasks: {},
+      taskGroups: {},
+      widgets: {},
+      widgetMessageIds: {},
+      annotations: {},
+      annotationMessageIds: {},
+      agents: {},
+      agentInteractions: [],
+      artifacts: [],
+    };
+
+    const props = baseProps({
+      onSaveThread: savedSnapshots,
+      runtime: {} as never,
+    });
+    await mount(props);
+    await act(async () => root.render(null));
+
+    expect(agentMessageTextFromParts(messageParts)).toBe(
+      "Summarize sprint  visible continuation",
+    );
+    expect(savedSnapshots).toHaveBeenCalledWith(
+      chatMocks.threadId,
+      expect.objectContaining({
+        title: "Summarize sprint visible continuation",
+        preview: "Summarize sprint  visible continuation",
+      }),
+    );
+    expect(savedSnapshots.mock.calls[0]?.[1].preview).not.toContain(
+      "ambiguous private",
     );
   });
 
@@ -4511,6 +4592,29 @@ describe("AgentKitAssistantChat host behavior", () => {
     window.removeEventListener("agent-chat:missing-api-key", onBlocked);
   });
 
+  it("masks a connection failure message without masking recovery controls", async () => {
+    chatMocks.connectionError = {
+      code: "runtime_error",
+      message: "Example Person's example document is locked.",
+      retryable: true,
+    };
+    await mount(baseProps());
+    const message = Array.from(container.querySelectorAll("span")).find(
+      (element) =>
+        element.textContent === `Error: ${chatMocks.connectionError.message}`,
+    );
+    expect(message?.hasAttribute("data-an-mask")).toBe(true);
+    expect(
+      message?.closest('[role="alert"]')?.hasAttribute("data-an-mask"),
+    ).toBe(false);
+    expect(
+      message
+        ?.closest('[role="alert"]')
+        ?.querySelector("button")
+        ?.closest("[data-an-mask]"),
+    ).toBeNull();
+  });
+
   it("does not repeat the composer setup card in a missing-key run failure", async () => {
     chatMocks.readiness = {
       canChat: false,
@@ -5078,8 +5182,15 @@ describe("AgentKitAssistantChat host behavior", () => {
         chatMocks.composerProps.stopButton.props.onClick();
         await Promise.resolve();
       });
-      expect(container.querySelector('[role="alert"]')?.textContent).toContain(
-        "Stop unavailable",
+      const alert = container.querySelector('[role="alert"]');
+      expect(alert?.textContent).toContain("Stop unavailable");
+      const message = Array.from(alert?.querySelectorAll("span") ?? []).find(
+        (element) => element.textContent === "Stop unavailable",
+      );
+      expect(message?.hasAttribute("data-an-mask")).toBe(true);
+      expect(alert?.hasAttribute("data-an-mask")).toBe(false);
+      expect(alert?.querySelector("button")?.closest("[data-an-mask]")).toBe(
+        null,
       );
       await act(async () => {
         chatMocks.composerProps.stopButton.props.onClick();