@agent-native/toolkit 0.204.0 → 0.204.1-nightly-20261008034100

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

@@ -28,7 +28,17 @@ vi.mock("../../../design-system/index.js", async (importOriginal) => {
         "div",
         { className, onClick: () => onOpenChange?.(!open) },
         trigger,
-        open ? children : null,
+        // Clicks inside an open popover never toggle it, as in the real one.
+        open
+          ? createElement(
+              "div",
+              {
+                onClick: (event: { stopPropagation: () => void }) =>
+                  event.stopPropagation(),
+              },
+              children,
+            )
+          : null,
       ),
   };
 });
@@ -719,6 +729,103 @@ describe("AgentKitChat interactions", () => {
     }
   });
 
+  it.each([
+    ["resumes the stopped run's turn", true],
+    ["says so when the run can no longer be continued", false],
+  ])("Continue on a stopped run %s", async (_, accepted) => {
+    const continueRun = vi.fn(
+      async (
+        _input: Parameters<NonNullable<AgentTransport["continueRun"]>>[0],
+      ) => {
+        if (!accepted) throw new Error("This turn can no longer be continued.");
+        return { runId: "run-continued" };
+      },
+    );
+    const transport: AgentTransport = {
+      async startRun() {
+        return { runId: "run-crashed" };
+      },
+      async *subscribeToRun(input) {
+        if (input.runId !== "run-crashed") return;
+        const base = {
+          threadId: "thread-continue",
+          runId: "run-crashed",
+          occurredAt: "2026-10-05T00:00:00.000Z",
+        };
+        yield { ...base, id: "e1", sequence: 1, type: "run.started" };
+        yield {
+          ...base,
+          id: "e2",
+          sequence: 2,
+          type: "run.failed",
+          error: {
+            code: "stale_run",
+            message: "The agent stopped before it could finish.",
+            retryable: true,
+          },
+        };
+      },
+      continueRun,
+      async cancelRun() {},
+    };
+    const client = new AgentKitClient({ transport });
+    const run = await client.sendMessage({
+      threadId: "thread-continue",
+      text: "Bill Ana and email her the invoice",
+    });
+    await run.completed.catch(() => undefined);
+    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 continueButton = () =>
+      [
+        ...container.querySelectorAll<HTMLButtonElement>(
+          ".agentkit-run-failure button",
+        ),
+      ].find((button) => button.textContent === "Continue");
+
+    try {
+      await act(async () => {
+        root.render(
+          <AgentKitProvider controller={client} threadId="thread-continue">
+            <AgentKitChat composer={false} />
+          </AgentKitProvider>,
+        );
+        await Promise.resolve();
+      });
+      expect(continueButton()).toBeDefined();
+
+      await act(async () => {
+        continueButton()?.click();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+
+      expect(continueRun).toHaveBeenCalledWith(
+        { threadId: "thread-continue", runId: "run-crashed" },
+        expect.anything(),
+      );
+      expect(container.textContent?.includes("can't be continued")).toBe(
+        !accepted,
+      );
+    } 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("renders the default plus control and routes chat-wide file drops to the composer", async () => {
     const transport: AgentTransport = {
       capabilities: { uploads: true },
@@ -1190,6 +1297,209 @@ describe("AgentKitChat interactions", () => {
     }
   });
 
+  it("fills the thumbs-down reason from chips and copies a report with the run, thread and note", async () => {
+    const assistantMessage = {
+      id: "assistant-report",
+      role: "assistant" as const,
+      status: "complete" as const,
+      createdAt: "2026-09-26T00:00:00.000Z",
+      parts: [{ type: "text" as const, text: "All done" }],
+    };
+    const transport: AgentTransport = {
+      capabilities: { feedback: true },
+      async submitFeedback() {},
+      async startRun() {
+        return { runId: "run-report" };
+      },
+      async *subscribeToRun() {},
+      async cancelRun() {},
+      async getThreadSnapshot(threadId) {
+        return {
+          id: threadId,
+          createdAt: "2026-09-26T00:00:00.000Z",
+          updatedAt: "2026-09-26T00:00:00.000Z",
+          messages: [assistantMessage],
+          events: [
+            {
+              id: "event-report",
+              threadId,
+              runId: "run-report",
+              sequence: 1,
+              occurredAt: "2026-09-26T00:00:00.000Z",
+              type: "message.completed",
+              message: assistantMessage,
+            },
+          ],
+        };
+      },
+    };
+    const client = new AgentKitClient({ transport });
+    await client.loadThread("thread-report");
+    const buildFeedbackReport = vi.fn(
+      ({ runId, note }: { runId?: string; note: string }) =>
+        `report run=${runId} note=${note}`,
+    );
+    const writeText = vi.fn(async () => undefined);
+    const clipboardDescriptor = Object.getOwnPropertyDescriptor(
+      navigator,
+      "clipboard",
+    );
+    Object.defineProperty(navigator, "clipboard", {
+      configurable: true,
+      value: { writeText },
+    });
+    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 buttonByText = (text: string) =>
+      Array.from(
+        document.body.querySelectorAll<HTMLButtonElement>("button"),
+      ).find((button) => button.textContent?.includes(text));
+
+    try {
+      await act(async () => {
+        root.render(
+          <AgentKitProvider
+            controller={client}
+            threadId="thread-report"
+            buildFeedbackReport={buildFeedbackReport}
+          >
+            <AgentKitChat composer={false} />
+          </AgentKitProvider>,
+        );
+        await Promise.resolve();
+      });
+      await act(async () => {
+        container
+          .querySelector<HTMLButtonElement>('button[aria-label="Not helpful"]')
+          ?.click();
+        await Promise.resolve();
+      });
+
+      // They sit inside the feedback form, so none may submit it.
+      expect(buttonByText("Misread my ask")?.type).toBe("button");
+      expect(buttonByText("Copy details")?.type).toBe("button");
+      await act(async () => {
+        buttonByText("Misread my ask")?.click();
+        buttonByText("Wrong numbers")?.click();
+        buttonByText("Misread my ask")?.click();
+      });
+      const textarea = document.body.querySelector<HTMLTextAreaElement>(
+        ".agentkit-feedback-popover textarea",
+      );
+      expect(textarea?.value).toBe("Misread my ask. Wrong numbers");
+
+      await act(async () => {
+        buttonByText("Copy details")?.click();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+      });
+      expect(buildFeedbackReport).toHaveBeenCalledWith({
+        threadId: "thread-report",
+        runId: "run-report",
+        messageId: "assistant-report",
+        note: "Misread my ask. Wrong numbers",
+      });
+      expect(writeText).toHaveBeenCalledWith(
+        "report run=run-report note=Misread my ask. Wrong numbers",
+      );
+      expect(buttonByText("Copied")).toBeDefined();
+    } finally {
+      await act(async () => {
+        root.unmount();
+        await Promise.resolve();
+      });
+      await client.shutdown();
+      container.remove();
+      if (clipboardDescriptor) {
+        Object.defineProperty(navigator, "clipboard", clipboardDescriptor);
+      } else {
+        Reflect.deleteProperty(navigator, "clipboard");
+      }
+      if (previousActEnvironment === undefined) {
+        delete actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+      } else {
+        actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+      }
+    }
+  });
+
+  it("offers no Copy details without a report builder", async () => {
+    const assistantMessage = {
+      id: "assistant-no-report",
+      role: "assistant" as const,
+      status: "complete" as const,
+      createdAt: "2026-09-26T00:00:00.000Z",
+      parts: [{ type: "text" as const, text: "Answer" }],
+    };
+    const client = new AgentKitClient({
+      transport: {
+        capabilities: { feedback: true },
+        async submitFeedback() {},
+        async startRun() {
+          return { runId: "run-no-report" };
+        },
+        async *subscribeToRun() {},
+        async cancelRun() {},
+        async getThreadSnapshot(threadId) {
+          return {
+            id: threadId,
+            createdAt: "2026-09-26T00:00:00.000Z",
+            updatedAt: "2026-09-26T00:00:00.000Z",
+            messages: [assistantMessage],
+          };
+        },
+      },
+    });
+    await client.loadThread("thread-no-report");
+    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;
+
+    try {
+      await act(async () => {
+        root.render(
+          <AgentKitProvider controller={client} threadId="thread-no-report">
+            <AgentKitChat composer={false} />
+          </AgentKitProvider>,
+        );
+        await Promise.resolve();
+      });
+      await act(async () => {
+        container
+          .querySelector<HTMLButtonElement>('button[aria-label="Not helpful"]')
+          ?.click();
+        await Promise.resolve();
+      });
+
+      expect(
+        document.body.querySelector(".agentkit-feedback-popover"),
+      ).not.toBeNull();
+      expect(document.body.textContent).not.toContain("Copy details");
+    } finally {
+      await act(async () => {
+        root.unmount();
+        await Promise.resolve();
+      });
+      await client.shutdown();
+      container.remove();
+      if (previousActEnvironment === undefined) {
+        delete actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+      } else {
+        actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+      }
+    }
+  });
+
   it("falls back to plain-text clipboard copy when the host declines handling", async () => {
     const message = {
       id: "assistant-copy-fallback",

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

@@ -971,7 +971,7 @@ describe("AgentKitChat", () => {
                 },
                 {
                   type: "text",
-                  text: "Also tell @Steve.",
+                  text: "Also tell @Steve about any @builder.io booking.",
                 },
                 {
                   type: "file",
@@ -1050,7 +1050,12 @@ describe("AgentKitChat", () => {
 
     expect(htmlWithComposer).toContain('aria-label="Edit message"');
     expect(htmlWithComposer).toContain('data-mention-label="latest run"');
-    expect(htmlWithComposer).toContain('data-mention-label="Steve"');
+    // Plain "@word" text is not a reference, so it stays literal text.
+    expect(htmlWithComposer).not.toContain('data-mention-label="Steve"');
+    expect(htmlWithComposer).not.toContain('data-mention-label="builder"');
+    expect(htmlWithComposer).toContain(
+      "Also tell @Steve about any @builder.io booking.",
+    );
     expect(htmlWithComposer).toContain('aria-label="Preview latest-run.png"');
     expect(htmlWithComposer).toContain("Pasted text");
     expect(htmlWithComposer).toContain("agentkit-file--pasted-text");
@@ -1801,4 +1806,103 @@ describe("AgentKitChat", () => {
       { error: failure, runId: "run-failure", threadId: "thread-1" },
     ]);
   });
+
+  it.each([
+    { label: "with no work", work: false },
+    { label: "after its last work", work: true },
+  ])(
+    "keeps a failed run's card in its own turn, above a newer turn ($label)",
+    async ({ work }) => {
+      const transport: AgentTransport = {
+        async startRun(input) {
+          return {
+            runId: input.messages.length === 1 ? "run-failed" : "run-next",
+          };
+        },
+        async *subscribeToRun({ runId }) {
+          const base = {
+            threadId: "thread-1",
+            runId,
+            occurredAt:
+              runId === "run-failed"
+                ? "2026-10-05T17:01:00.000Z"
+                : "2026-10-05T17:11:00.000Z",
+          };
+          yield { ...base, id: `${runId}-1`, sequence: 1, type: "run.started" };
+          if (runId === "run-failed") {
+            let sequence = 1;
+            if (work) {
+              yield {
+                ...base,
+                id: `${runId}-work`,
+                sequence: ++sequence,
+                type: "activity.started",
+                activity: {
+                  id: "activity-1",
+                  kind: "tool",
+                  label: "Charging the card",
+                  status: "running",
+                },
+              };
+            }
+            yield {
+              ...base,
+              id: `${runId}-failed`,
+              sequence: ++sequence,
+              type: "run.failed",
+              error: {
+                code: "stale_run",
+                message: "The agent stopped before it could finish.",
+                retryable: true,
+              },
+            };
+            return;
+          }
+          yield {
+            ...base,
+            id: `${runId}-reply`,
+            sequence: 2,
+            type: "message.completed",
+            message: {
+              id: "assistant-next",
+              role: "assistant",
+              parts: [{ type: "text", text: "Newer answer" }],
+            },
+          };
+          yield {
+            ...base,
+            id: `${runId}-done`,
+            sequence: 3,
+            type: "run.completed",
+          };
+        },
+        async cancelRun() {},
+      };
+      let clock = "2026-10-05T17:00:00.000Z";
+      const client = new AgentKitClient({ transport, now: () => clock });
+      await (
+        await client.sendMessage({ threadId: "thread-1", text: "First turn" })
+      ).completed;
+      clock = "2026-10-05T17:10:00.000Z";
+      await (
+        await client.sendMessage({ threadId: "thread-1", text: "Next turn" })
+      ).completed;
+
+      const html = renderToStaticMarkup(
+        <AgentKitProvider controller={client} threadId="thread-1">
+          <AgentKitChat composer={false} />
+        </AgentKitProvider>,
+      );
+
+      const order = [
+        "First turn",
+        ...(work ? ["Charging the card"] : []),
+        'data-run-id="run-failed"',
+        "Next turn",
+        "Newer answer",
+      ].map((text) => html.indexOf(text));
+      expect(order.every((index) => index >= 0)).toBe(true);
+      expect(order).toEqual([...order].sort((left, right) => left - right));
+    },
+  );
 });