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

package/src/app/chat/MultiTabAssistantChat.tsx

@@ -86,6 +86,7 @@ import type {
   AssistantChatHandle,
   AssistantChatSendOptions,
 } from "./chat/surface-types.js";
+import { fallbackChatTitle } from "./fallback-chat-title.js";
 
 type AgentActionScope = NonNullable<AgentChatMessage["actionScope"]>;
 
@@ -2725,15 +2726,14 @@ export function MultiTabAssistantChat({
       selection: { engine?: string; model?: string },
     ) => {
       void generateTitle(threadId, message, selection).then((title) => {
-        if (title) {
-          // Persist the generated title to the server
-          void saveThreadData(threadId, {
-            threadData: "",
-            title,
-            preview: message.slice(0, 120),
-            titleSource: "generated",
-          });
-        }
+        const resolvedTitle = title ?? fallbackChatTitle(message);
+        if (!resolvedTitle) return;
+        void saveThreadData(threadId, {
+          threadData: "",
+          title: resolvedTitle,
+          preview: message.slice(0, 120),
+          titleSource: title ? "generated" : "fallback",
+        });
       });
     },
     [generateTitle, saveThreadData],
@@ -2747,6 +2747,7 @@ export function MultiTabAssistantChat({
         title: string;
         preview: string;
         messageCount: number;
+        titleSource?: "fallback";
       },
     ) => {
       void saveThreadData(threadId, {

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

@@ -1,5 +1,6 @@
 // @vitest-environment happy-dom
 
+import type { RunStuckState } from "@agent-native/core/client/agent-chat";
 import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -8,20 +9,42 @@ import { RunStuckBanner } from "./RunStuckBanner.js";
 
 const trackEventMock = vi.hoisted(() => vi.fn());
 
+const STUCK_STATE: RunStuckState = {
+  isStuck: true,
+  runId: "run-1",
+  status: "running",
+  lastProgressAt: 0,
+  stuckSinceMs: 90_000,
+  lastProgressSeq: 1,
+  heartbeatAt: null,
+  heartbeatSinceMs: null,
+  dispatchMode: null,
+  hasInFlightWork: false,
+  serverSettled: false,
+  statusUnreadable: false,
+};
+
+const SETTLED_STATE: RunStuckState = {
+  ...STUCK_STATE,
+  isStuck: false,
+  status: "idle",
+  stuckSinceMs: null,
+  serverSettled: true,
+};
+
+const hookState = vi.hoisted(() => ({
+  current: null as RunStuckState | null,
+  awaitingResponse: undefined as boolean | undefined,
+}));
+
+const abortRunMock = vi.hoisted(() => vi.fn(async () => null));
+
 vi.mock("@agent-native/core/client/agent-chat", () => ({
-  useRunStuckDetection: () => ({
-    isStuck: true,
-    runId: "run-1",
-    status: "running",
-    lastProgressAt: 0,
-    stuckSinceMs: 90_000,
-    lastProgressSeq: 1,
-    heartbeatAt: null,
-    heartbeatSinceMs: null,
-    dispatchMode: null,
-    hasInFlightWork: false,
-  }),
-  useAbortRun: () => vi.fn(),
+  useRunStuckDetection: (options: { awaitingResponse?: boolean }) => {
+    hookState.awaitingResponse = options.awaitingResponse;
+    return hookState.current;
+  },
+  useAbortRun: () => abortRunMock,
 }));
 
 vi.mock("@agent-native/core/client/analytics", () => ({
@@ -38,28 +61,246 @@ describe("RunStuckBanner", () => {
 
   beforeEach(() => {
     vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    vi.useFakeTimers({ toFake: ["Date"] });
+    vi.setSystemTime(1_000_000);
+    trackEventMock.mockClear();
+    abortRunMock.mockClear();
+    window.localStorage.clear();
+    hookState.current = STUCK_STATE;
     container = document.createElement("div");
     document.body.appendChild(container);
+    root = createRoot(container);
   });
 
   afterEach(() => {
+    act(() => root.unmount());
     container.remove();
+    vi.useRealTimers();
     vi.unstubAllGlobals();
   });
 
+  async function render(props: Parameters<typeof RunStuckBanner>[0]) {
+    await act(async () => {
+      root.render(<RunStuckBanner {...props} />);
+    });
+  }
+
   it("reports a stuck run once, even when the chat view remounts", async () => {
     for (let mount = 0; mount < 2; mount += 1) {
-      root = createRoot(container);
+      const remounted = createRoot(document.createElement("div"));
       await act(async () => {
-        root.render(<RunStuckBanner threadId="thread-1" />);
+        remounted.render(<RunStuckBanner threadId="thread-1" />);
       });
-      await act(async () => root.unmount());
+      await act(async () => remounted.unmount());
     }
 
     expect(trackEventMock).toHaveBeenCalledTimes(1);
     expect(trackEventMock).toHaveBeenCalledWith(
       "agent_chat_stuck_detected",
-      expect.objectContaining({ runId: "run-1", threadId: "thread-1" }),
+      expect.objectContaining({
+        runId: "run-1",
+        threadId: "thread-1",
+        reason: "no_progress",
+        dispatchMode: null,
+        hasInFlightWork: false,
+      }),
+    );
+  });
+
+  const isAwaitingResponse = () => true;
+
+  describe("when the server stops tracking a run the chat shows as running", () => {
+    beforeEach(() => {
+      hookState.current = SETTLED_STATE;
+    });
+
+    it("reloads the thread once and says nothing when that settles the chat", async () => {
+      const onServerSettled = vi.fn(async () => "settled" as const);
+
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+
+      expect(onServerSettled).toHaveBeenCalledTimes(1);
+      expect(container.textContent).toBe("");
+    });
+
+    it("does not reconcile a host that cannot say whether the chat is waiting", async () => {
+      const onServerSettled = vi.fn(async () => "settled" as const);
+
+      await render({ threadId: "thread-1", onServerSettled });
+
+      expect(onServerSettled).not.toHaveBeenCalled();
+    });
+
+    it("does nothing for a chat that is not waiting on a response", async () => {
+      const onServerSettled = vi.fn(async () => "settled" as const);
+
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse: () => false,
+      });
+
+      expect(onServerSettled).not.toHaveBeenCalled();
+      expect(container.textContent).toBe("");
+    });
+
+    it("tells the user when the reload could not settle the chat, and retries at a bounded pace", async () => {
+      const onServerSettled = vi.fn(async () => "still_running" as const);
+
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+      expect(container.textContent).toContain(
+        "agentChat.recovery.statusMismatch",
+      );
+      expect(container.textContent).toContain("agentChat.recovery.reload");
+      expect(container.textContent).not.toContain("recovery.stuckTitle");
+
+      // Every poll hands the banner a fresh state object.
+      vi.setSystemTime(1_015_000);
+      hookState.current = { ...SETTLED_STATE };
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+      expect(onServerSettled).toHaveBeenCalledTimes(1);
+
+      vi.setSystemTime(1_031_000);
+      hookState.current = { ...SETTLED_STATE };
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+      expect(onServerSettled).toHaveBeenCalledTimes(2);
+    });
+
+    it("tells the detector whether the chat is waiting, so a settle predating the wait is dropped", async () => {
+      await render({ threadId: "thread-1", isAwaitingResponse: () => true });
+      expect(hookState.awaitingResponse).toBe(true);
+
+      await render({ threadId: "thread-1", isAwaitingResponse: () => false });
+      expect(hookState.awaitingResponse).toBe(false);
+
+      await render({ threadId: "thread-1" });
+      expect(hookState.awaitingResponse).toBeUndefined();
+    });
+
+    it("ignores a reload that finishes after the server started a run again", async () => {
+      let finishReload: (outcome: "still_running") => void = () => {};
+      const onServerSettled = vi.fn(
+        () =>
+          new Promise<"still_running">((resolve) => {
+            finishReload = resolve;
+          }),
+      );
+
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+      expect(onServerSettled).toHaveBeenCalledTimes(1);
+
+      hookState.current = {
+        ...STUCK_STATE,
+        isStuck: false,
+        serverSettled: false,
+      };
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+      await act(async () => finishReload("still_running"));
+
+      expect(container.textContent).toBe("");
+    });
+
+    it("shows an unreadable status, not a finished chat, when the reload itself fails", async () => {
+      const onServerSettled = vi.fn(async () => {
+        throw new Error("thread unavailable");
+      });
+
+      await render({
+        threadId: "thread-1",
+        onServerSettled,
+        isAwaitingResponse,
+      });
+
+      expect(container.textContent).toContain(
+        "agentChat.recovery.statusUnreadable",
+      );
+      expect(container.textContent).not.toContain(
+        "agentChat.recovery.statusMismatch",
+      );
+    });
+  });
+
+  it("shows an unreadable status when the run's status cannot be fetched", async () => {
+    hookState.current = {
+      ...STUCK_STATE,
+      isStuck: false,
+      stuckSinceMs: null,
+      statusUnreadable: true,
+    };
+
+    await render({ threadId: "thread-1" });
+    expect(container.textContent).toContain(
+      "agentChat.recovery.statusUnreadable",
+    );
+    expect(container.textContent).not.toContain("recovery.stuckTitle");
+    expect(container.textContent).not.toContain("agentChat.recovery.reload");
+
+    await render({ threadId: "thread-1", isAwaitingResponse: () => false });
+    expect(container.textContent).toBe("");
+
+    // A host that cannot say whether the chat waits only doubts a run it saw.
+    hookState.current = { ...hookState.current!, status: "idle", runId: null };
+    await render({ threadId: "thread-1" });
+    expect(container.textContent).toBe("");
+  });
+
+  it("shows the unreadable status, not a stuck banner, when the status is unreadable", async () => {
+    hookState.current = { ...STUCK_STATE, statusUnreadable: true };
+
+    await render({ threadId: "thread-1" });
+
+    expect(container.textContent).toContain(
+      "agentChat.recovery.statusUnreadable",
     );
+    expect(container.textContent).not.toContain(
+      "agentChat.recovery.stuckTitle",
+    );
+    expect(container.querySelectorAll("button")).toHaveLength(0);
+  });
+
+  it("does not auto-abort a run on a stuck verdict it cannot confirm", async () => {
+    const props = {
+      threadId: "thread-auto-retry",
+      autoRetry: true,
+      autoRetryOwnerId: "owner-1",
+    };
+    hookState.current = { ...STUCK_STATE, statusUnreadable: true };
+
+    await render(props);
+    expect(abortRunMock).not.toHaveBeenCalled();
+
+    hookState.current = { ...STUCK_STATE };
+    await render(props);
+    await act(async () => {});
+    expect(abortRunMock).toHaveBeenCalledWith("run-1", "auto_stuck_retry");
   });
 });

package/src/app/chat/RunStuckBanner.tsx

@@ -18,11 +18,20 @@ export interface RunStuckBannerProps {
   hasInFlightWork?: () => boolean;
   isAwaitingResponse?: () => boolean;
   onStuckStateChange?: (state: RunStuckState) => void;
+  /**
+   * The server has stopped tracking a run this chat still shows as running.
+   * Resolves `settled` once the chat no longer shows it running; rejects when
+   * the thread could not be refreshed.
+   */
+  onServerSettled?: () => Promise<RunReconcileOutcome>;
   autoRetry?: boolean;
   autoRetryOwnerId?: string;
   className?: string;
 }
 
+export type RunReconcileOutcome = "settled" | "still_running";
+
+const RECONCILE_RETRY_MS = 30_000;
 const AUTO_RETRY_CLAIM_TTL_MS = 5 * 60 * 1000;
 const BACKGROUND_WORKER_FRESH_HEARTBEAT_MS = 30_000;
 
@@ -123,6 +132,7 @@ export function RunStuckBanner({
   stuckThresholdMs,
   onRetry,
   onStuckStateChange,
+  onServerSettled,
   autoRetry = false,
   autoRetryOwnerId,
   hasInFlightWork,
@@ -130,9 +140,11 @@ export function RunStuckBanner({
   className,
 }: RunStuckBannerProps) {
   const t = useT();
+  const chatAwaiting = isAwaitingResponse?.();
   const state = useRunStuckDetection({
     threadId,
     enabled,
+    awaitingResponse: chatAwaiting,
     stuckThresholdMs,
     apiUrl,
   });
@@ -148,9 +160,13 @@ export function RunStuckBanner({
   const backgroundWorkerStillAlive = isFreshBackgroundWorker(state);
   const inFlightWork =
     state.hasInFlightWork === true || (hasInFlightWork?.() ?? false);
-  const awaitingResponse = isAwaitingResponse?.() ?? true;
+  const awaitingResponse = chatAwaiting ?? true;
+  // While the status is unreadable `isStuck` is the last answer carried forward
+  // by the clock, not a fresh one: only the unreadable notice may speak, and
+  // nothing may abort a run on it.
+  const isStuck = state.isStuck && !state.statusUnreadable;
   const showsStuckBanner =
-    state.isStuck &&
+    isStuck &&
     !!state.runId &&
     !backgroundWorkerStillAlive &&
     !inFlightWork &&
@@ -159,6 +175,50 @@ export function RunStuckBanner({
     state.dispatchMode === "foreground-self-chain" ||
     state.dispatchMode?.startsWith("background") === true;
 
+  // Only a host that says when the chat is waiting can tell a lost ending from
+  // an idle chat, so reconciling needs `isAwaitingResponse`.
+  const chatShowsRunning = isAwaitingResponse != null && awaitingResponse;
+  const settledWhileRunning = chatShowsRunning && state.serverSettled;
+  const [reconcile, setReconcile] = useState<"idle" | "failed" | "unsettled">(
+    "idle",
+  );
+  const lastReconcileAtRef = useRef(0);
+  const reconcileEpochRef = useRef(0);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  // `state` changes on every poll, so a reconcile that did not settle the chat
+  // is retried at most once per RECONCILE_RETRY_MS, never in a loop.
+  useEffect(() => {
+    if (!settledWhileRunning || !onServerSettled) {
+      // A reload still in flight answers a chat that has since moved on.
+      reconcileEpochRef.current += 1;
+      lastReconcileAtRef.current = 0;
+      setReconcile("idle");
+      return;
+    }
+    const now = Date.now();
+    if (now - lastReconcileAtRef.current < RECONCILE_RETRY_MS) return;
+    lastReconcileAtRef.current = now;
+    const epoch = reconcileEpochRef.current;
+    const current = () =>
+      mountedRef.current && epoch === reconcileEpochRef.current;
+    onServerSettled().then(
+      (outcome) => {
+        if (current()) {
+          setReconcile(outcome === "settled" ? "idle" : "unsettled");
+        }
+      },
+      () => {
+        if (current()) setReconcile("failed");
+      },
+    );
+  }, [onServerSettled, settledWhileRunning, state]);
+
   const lastReportedRef = useRef<{
     isStuck: boolean;
     runId: string | null;
@@ -185,6 +245,13 @@ export function RunStuckBanner({
           ? Math.floor(state.stuckSinceMs / 1000)
           : null,
       runStatus: state.status,
+      reason: "no_progress",
+      dispatchMode: state.dispatchMode,
+      hasInFlightWork: state.hasInFlightWork,
+      heartbeatSinceSec:
+        state.heartbeatSinceMs != null
+          ? Math.floor(state.heartbeatSinceMs / 1000)
+          : null,
     });
   }, [showsStuckBanner, state, threadId]);
 
@@ -204,7 +271,7 @@ export function RunStuckBanner({
       backgroundWorkerStillAlive ||
       inFlightWork ||
       !awaitingResponse ||
-      !state.isStuck ||
+      !isStuck ||
       !state.runId ||
       busy.type !== "none" ||
       autoRetriedRunIdsRef.current.has(state.runId)
@@ -239,9 +306,9 @@ export function RunStuckBanner({
     busy,
     inFlightWork,
     isServerContinuedDispatch,
+    isStuck,
     onRetry,
     ownerId,
-    state.isStuck,
     state.runId,
     state.stuckSinceMs,
     threadId,
@@ -249,7 +316,42 @@ export function RunStuckBanner({
   ]);
 
   if (!showsStuckBanner) {
-    return null;
+    const notice =
+      reconcile === "unsettled"
+        ? "agentChat.recovery.statusMismatch"
+        : (isAwaitingResponse
+              ? awaitingResponse
+              : state.status === "running") &&
+            (state.statusUnreadable || reconcile === "failed")
+          ? "agentChat.recovery.statusUnreadable"
+          : null;
+    if (!notice) return null;
+    return (
+      <div
+        role="status"
+        aria-live="polite"
+        className={cn(
+          "mx-3 mt-2 flex items-center gap-2.5 rounded-md border border-amber-500/40 bg-amber-500/10 px-3 py-2.5 text-xs text-foreground",
+          className,
+        )}
+      >
+        <IconAlertTriangle
+          size={16}
+          className="shrink-0 text-amber-500"
+          aria-hidden="true"
+        />
+        <span className="min-w-0 flex-1 leading-snug">{t(notice)}</span>
+        {reconcile === "unsettled" ? (
+          <button
+            type="button"
+            onClick={() => window.location.reload()}
+            className="inline-flex h-7 shrink-0 cursor-pointer items-center rounded-md bg-foreground px-2.5 text-[11px] font-medium text-background transition-colors hover:bg-foreground/90"
+          >
+            {t("agentChat.recovery.reload")}
+          </button>
+        ) : null}
+      </div>
+    );
   }
 
   const handleCancel = async () => {

package/src/app/chat/chat/run-recovery.tsx

@@ -523,9 +523,12 @@ export function RunErrorRecoveryCard({
   onFork,
   onDismiss,
   onProviderConnected,
+  continueError,
 }: {
   info: RunErrorInfo;
-  onContinue: () => void;
+  /** Absent when the stopped run can no longer be continued. */
+  onContinue?: () => void;
+  continueError?: string | null;
   onRetry: () => void;
   retryHasUnavailableAttachment?: boolean;
   onFork?: () => void | boolean | Promise<void | boolean>;
@@ -801,7 +804,7 @@ export function RunErrorRecoveryCard({
             </button>
           </DeferredBuilderConnectPopover>
         )}
-        {canRecover && (
+        {canRecover && onContinue && (
           <button
             type="button"
             onClick={onContinue}
@@ -902,6 +905,11 @@ export function RunErrorRecoveryCard({
       {forkError && (
         <p className="mt-2 text-xs leading-relaxed text-red-500">{forkError}</p>
       )}
+      {continueError && (
+        <p className="mt-2 text-xs leading-relaxed text-destructive">
+          {continueError}
+        </p>
+      )}
     </div>
   );
 }

package/src/app/chat/chat/surface-types.ts

@@ -232,6 +232,7 @@ export interface AssistantChatProps {
       title: string;
       preview: string;
       messageCount: number;
+      titleSource?: "fallback";
     },
   ) => void;
   /** Callback to generate a title from the first user message, on the model it was sent with */

package/src/app/chat/fallback-chat-title.ts

@@ -0,0 +1,10 @@
+export function fallbackChatTitle(message: string): string {
+  return message
+    .replace(/<context\b[^>]*>[\s\S]*?<\/context>\n?/gi, "")
+    .replace(/<context\b[^>]*>[\s\S]*$/gi, "")
+    .replace(/<\/context>/gi, "")
+    .replace(/@\[([^\]|]+)\|[^\]]*\]/g, "@$1")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 80);
+}

package/src/app/chat/feedback-report.spec.ts

@@ -0,0 +1,45 @@
+// @vitest-environment happy-dom
+
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { formatFeedbackReport } from "./feedback-report.js";
+
+describe("formatFeedbackReport", () => {
+  beforeEach(() => {
+    sessionStorage.clear();
+    window.history.replaceState(null, "", "/");
+  });
+
+  it("names the run, thread link, message and note so a pasted report opens the exact run", () => {
+    const lines = formatFeedbackReport({
+      threadId: "thr_1",
+      runId: "run_1",
+      messageId: "msg_1",
+      note: "Said done,\nbut wasn't.  Wrong numbers",
+    }).split("\n");
+
+    expect(lines).toEqual(
+      expect.arrayContaining([
+        "Agent-Native failure report",
+        `thread: ${window.location.origin}/?thread=thr_1`,
+        "run: run_1",
+        'inspect: get-agent-thread-debug {"runId":"run_1"}',
+        "message: msg_1",
+        "note: Said done, but wasn't. Wrong numbers",
+      ]),
+    );
+    expect(lines.some((line) => line.startsWith("build: "))).toBe(true);
+  });
+
+  it("omits the note line and the run when there are none", () => {
+    const text = formatFeedbackReport({
+      threadId: "thr_2",
+      messageId: "msg_2",
+      note: "  ",
+    });
+
+    expect(text).not.toContain("note:");
+    expect(text).not.toContain("run:");
+    expect(text).toContain("message: msg_2");
+  });
+});

package/src/app/chat/feedback-report.ts

@@ -0,0 +1,27 @@
+import { formatClientFailureReport } from "@agent-native/core/client/failure-report";
+
+const MAX_NOTE_CHARS = 600;
+
+/**
+ * "Copy details" for a thumbs-down: the same packet an error card copies, so a
+ * pasted report opens the exact thread and run, plus the message and the
+ * reader's note flattened to one line.
+ */
+export function formatFeedbackReport(input: {
+  threadId: string;
+  runId?: string;
+  messageId: string;
+  note: string;
+}): string {
+  const note = input.note.replace(/\s+/g, " ").trim().slice(0, MAX_NOTE_CHARS);
+  return [
+    formatClientFailureReport({
+      threadId: input.threadId,
+      ...(input.runId ? { runId: input.runId } : {}),
+    }),
+    `message: ${input.messageId}`,
+    note ? `note: ${note}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}