@agent-native/core 0.108.0 → 0.109.0

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -753,10 +753,15 @@ export function MultiTabAssistantChat({
   const [urlThreadId, setUrlThreadId] = useState<string | null>(() =>
     threadUrlSyncEnabled
       ? threadRouteControlsActiveThread
-        ? (routeThreadId ?? null)
+        ? (routeThreadId ?? readUrlThreadId(threadUrlParamName))
         : readUrlThreadId(threadUrlParamName)
       : null,
   );
+  const [deepLinkedThreadId] = useState<string | null>(() =>
+    threadUrlSyncEnabled ? null : readUrlThreadId(DEFAULT_THREAD_URL_PARAM),
+  );
+  const [activeDeepLinkedThreadId, setActiveDeepLinkedThreadId] =
+    useState(deepLinkedThreadId);
   const urlThreadIdRef = useRef(urlThreadId);
   urlThreadIdRef.current = urlThreadId;
 
@@ -780,8 +785,28 @@ export function MultiTabAssistantChat({
 
   useEffect(() => {
     if (!threadUrlSyncEnabled || !threadRouteControlsActiveThread) return;
-    setUrlThreadId(routeThreadId ?? null);
-  }, [routeThreadId, threadRouteControlsActiveThread, threadUrlSyncEnabled]);
+    setUrlThreadId(routeThreadId ?? readUrlThreadId(threadUrlParamName));
+  }, [
+    routeThreadId,
+    threadRouteControlsActiveThread,
+    threadUrlParamName,
+    threadUrlSyncEnabled,
+  ]);
+
+  useEffect(() => {
+    if (threadUrlSyncEnabled) return;
+    const update = () =>
+      setActiveDeepLinkedThreadId(readUrlThreadId(DEFAULT_THREAD_URL_PARAM));
+    const uninstallHistoryPatch = installHistoryThreadUrlPatch();
+    update();
+    window.addEventListener("popstate", update);
+    window.addEventListener(THREAD_URL_CHANGED_EVENT, update);
+    return () => {
+      uninstallHistoryPatch();
+      window.removeEventListener("popstate", update);
+      window.removeEventListener(THREAD_URL_CHANGED_EVENT, update);
+    };
+  }, [threadUrlSyncEnabled]);
 
   const writeThreadUrl = useCallback(
     (threadId: string | null, options: { replace?: boolean } = {}): void => {
@@ -856,7 +881,9 @@ export function MultiTabAssistantChat({
     renameThread,
   } = useChatThreads(apiUrl, storageKey, null, {
     restoreActiveThread,
-    routeThreadId: threadUrlSyncEnabled ? urlThreadId : undefined,
+    routeThreadId: threadUrlSyncEnabled
+      ? urlThreadId
+      : (activeDeepLinkedThreadId ?? undefined),
   });
 
   const switchThread = useCallback(

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -1875,6 +1875,10 @@ export function createAgentChatAdapter(
         }
       };
 
+      const canAttachRun = (candidateRunId: string, candidateTurnId: string) =>
+        attemptedRunIds.includes(candidateRunId) ||
+        (candidateTurnId.length > 0 && candidateTurnId === turnId);
+
       const preparingActionStateForRun = (
         id: string | null,
       ): PreparingActionState | undefined => {
@@ -2097,15 +2101,13 @@ export function createAgentChatAdapter(
               }
               const active = await activeRes.json();
               if (active?.active && active.runId) {
-                updateCurrentRunDispatchMode(active.dispatchMode);
-                const activeStatus =
-                  typeof active.status === "string" ? active.status : "";
+                const activeRunId = String(active.runId);
                 const activeTurnId =
                   typeof active.turnId === "string" ? active.turnId : "";
-                if (activeStatus !== "running" && activeTurnId !== turnId) {
+                if (!canAttachRun(activeRunId, activeTurnId)) {
                   return false;
                 }
-                const activeRunId = String(active.runId);
+                updateCurrentRunDispatchMode(active.dispatchMode);
                 const previousRunId = runId;
                 runId = activeRunId;
                 if (!attemptedRunIds.includes(activeRunId)) {
@@ -2172,17 +2174,17 @@ export function createAgentChatAdapter(
                   typeof active.dispatchMode === "string"
                     ? active.dispatchMode
                     : "";
+                const activeTurnId =
+                  typeof active.turnId === "string" ? active.turnId : "";
+                if (!canAttachRun(activeRunId, activeTurnId)) return false;
                 updateCurrentRunDispatchMode(dispatchMode);
                 if (activeRunId === interruptedRunId) {
                   if (dispatchMode.startsWith("background")) continue;
                   return false;
                 }
-                const activeTurnId =
-                  typeof active.turnId === "string" ? active.turnId : "";
                 const activeStatus =
                   typeof active.status === "string" ? active.status : "";
                 if (!dispatchMode.startsWith("background")) return false;
-                if (activeTurnId && activeTurnId !== turnId) return false;
                 if (activeStatus !== "running" && activeStatus !== "starting") {
                   return false;
                 }
@@ -2548,10 +2550,7 @@ export function createAgentChatAdapter(
             // Only follow runs belonging to THIS turn (server-chained
             // successors reuse the turnId) or runs we already attached to.
             const isOurRun =
-              activeRunId !== null &&
-              (attemptedRunIds.includes(activeRunId) ||
-                !activeTurnId ||
-                activeTurnId === turnId);
+              activeRunId !== null && canAttachRun(activeRunId, activeTurnId);
 
             if (activeRunId && isOurRun) {
               lastSeenActive = active;
@@ -3100,12 +3099,19 @@ export function createAgentChatAdapter(
                 // active run is one this adapter already consumed, reconnecting
                 // to it replays the terminal auto_continue and exits instead of
                 // posting the continuation. Wait for stale/previous active runs
-                // to clear and retry THIS prompt. A genuinely newer background
-                // run still falls through to the reconnect path below.
-                const shouldRetryConflictingActiveRun =
+                // to clear and retry THIS prompt. An unknown run reported to an
+                // internal continuation is only adoptable after /runs/active
+                // proves it carries this turnId; a bare 409 run id is not
+                // enough ownership evidence.
+                if (
                   activeRunId !== null &&
-                  (!internalContinuationRequest ||
-                    attemptedRunIds.includes(activeRunId));
+                  internalContinuationRequest &&
+                  !attemptedRunIds.includes(activeRunId)
+                ) {
+                  const reconnected = yield* reconnectActiveRunForThread();
+                  if (reconnected) return;
+                }
+                const shouldRetryConflictingActiveRun = activeRunId !== null;
                 if (shouldRetryConflictingActiveRun) {
                   queuedConflictRetries += 1;
                   if (queuedConflictRetries <= MAX_QUEUED_CONFLICT_RETRIES) {
@@ -3157,26 +3163,6 @@ export function createAgentChatAdapter(
                   clearActiveRun();
                   return;
                 }
-                if (activeRunId) {
-                  try {
-                    const previousRunId = runId;
-                    runId = activeRunId;
-                    if (!attemptedRunIds.includes(runId)) {
-                      attemptedRunIds.push(runId);
-                    }
-                    reconnectCursorForRun(activeRunId, previousRunId);
-                    if (threadId) {
-                      setActiveRun({ threadId, runId, lastSeq });
-                    }
-                    const reconnected = yield* reconnectCurrentRun();
-                    if (reconnected) return;
-                    await delay(1000, abortSignal);
-                    if (abortSignal.aborted) return;
-                    continue;
-                  } catch {
-                    // Fall through to the generic response handling below.
-                  }
-                }
               }
 
               if (res.status === 401 || res.status === 403) {

package/corpus/core/src/client/agent-sidebar-state.ts

@@ -2,6 +2,9 @@ import {
   AGENT_SIDEBAR_QUERY_PARAM,
   AGENT_SIDEBAR_QUERY_VALUE_CLOSED,
 } from "../shared/agent-sidebar-url.js";
+import { hasChatThreadDeepLink } from "./chat-thread-url.js";
+
+export { hasChatThreadDeepLink } from "./chat-thread-url.js";
 
 export const SIDEBAR_OPEN_KEY = "agent-native-sidebar-open";
 export const SIDEBAR_STATE_CHANGE_EVENT = "agent-panel:state-change";
@@ -139,6 +142,7 @@ export function getInitialAgentSidebarOpen(
 ): boolean {
   const urlOverride = getAgentSidebarUrlOpenOverride();
   if (urlOverride !== null) return urlOverride;
+  if (hasChatThreadDeepLink()) return true;
 
   // On mobile viewports the sidebar would cover most of the screen, so
   // always start closed regardless of any persisted desktop preference.

package/corpus/core/src/client/analytics.ts

@@ -64,6 +64,10 @@ type PageviewTrackingState = {
   lastPageviewKey: string | null;
 };
 
+type AgentChatTrackingState = {
+  seen: Map<string, number>;
+};
+
 /**
  * First-party, Sentry-style error capture configuration. Pass `true`/`false`
  * to force on/off, or an options object to tune it. When omitted, error
@@ -173,6 +177,11 @@ export const AGENT_NATIVE_EXCEPTION_EVENT_NAME = "$exception";
 const PAGEVIEW_TRACKING_STATE_KEY = Symbol.for(
   "agent-native.client.pageviewTracking",
 );
+const AGENT_CHAT_TRACKING_STATE_KEY = Symbol.for(
+  "agent-native.client.agentChatTracking",
+);
+const AGENT_CHAT_LIFECYCLE_DEDUPE_TTL_MS = 10 * 60 * 1_000;
+const MAX_AGENT_CHAT_LIFECYCLE_DEDUPE_KEYS = 1_000;
 
 const LLM_CONNECTION_STORAGE_KEY = "agent-native.llm_connection_status";
 const LLM_CONNECTION_CACHE_TTL_MS = 5 * 60 * 1000;
@@ -1045,6 +1054,81 @@ function getPageviewTrackingState(): PageviewTrackingState {
   return g[PAGEVIEW_TRACKING_STATE_KEY];
 }
 
+function getAgentChatTrackingState(): AgentChatTrackingState {
+  const g = globalThis as typeof globalThis & {
+    [AGENT_CHAT_TRACKING_STATE_KEY]?: AgentChatTrackingState;
+  };
+  if (!g[AGENT_CHAT_TRACKING_STATE_KEY]) {
+    g[AGENT_CHAT_TRACKING_STATE_KEY] = { seen: new Map() };
+  }
+  return g[AGENT_CHAT_TRACKING_STATE_KEY];
+}
+
+export type AgentChatLifecycleEvent = {
+  phase: "surface-mounted" | "run-observed" | "run-stopped";
+  surface?: string;
+  threadId?: string;
+  runId?: string;
+  tabId?: string;
+};
+
+/**
+ * Record a content-free, browser-session-linked chat lifecycle marker and add
+ * the same marker to session replay when replay is configured. The bounded
+ * global de-dupe survives React Strict Mode remounts without retaining keys
+ * forever.
+ */
+export function trackAgentChatLifecycle(input: AgentChatLifecycleEvent): void {
+  if (typeof window === "undefined") return;
+  const surface = input.surface?.trim() || "app";
+  const dedupeKey = [
+    input.phase,
+    surface,
+    input.threadId ?? "",
+    input.runId ?? "",
+    input.tabId ?? "",
+  ].join(":");
+  const state = getAgentChatTrackingState();
+  const now = Date.now();
+  for (const [key, seenAt] of state.seen) {
+    if (now - seenAt >= AGENT_CHAT_LIFECYCLE_DEDUPE_TTL_MS) {
+      state.seen.delete(key);
+    }
+  }
+  if (state.seen.has(dedupeKey)) return;
+  state.seen.set(dedupeKey, now);
+  while (state.seen.size > MAX_AGENT_CHAT_LIFECYCLE_DEDUPE_KEYS) {
+    const oldestKey = state.seen.keys().next().value;
+    if (oldestKey === undefined) break;
+    state.seen.delete(oldestKey);
+  }
+
+  void (async () => {
+    const replayResult =
+      _sessionReplayOptions && _trackingContentCaptureEnabled
+        ? await startConfiguredSessionReplay(_sessionReplayOptions)
+        : null;
+    const properties = {
+      phase: input.phase,
+      chat_surface: surface,
+      ...(input.threadId ? { thread_id: input.threadId } : {}),
+      ...(input.runId ? { run_id: input.runId } : {}),
+      ...(input.tabId ? { chat_tab_id: input.tabId } : {}),
+      replay_status: replayResult?.started
+        ? "active"
+        : (replayResult?.reason ?? "not-configured"),
+    };
+    trackEvent("agent_chat_lifecycle", properties);
+    _sessionReplayModuleForCapture?.emitSessionReplayAgentChatEvent?.({
+      phase: input.phase,
+      surface,
+      ...(input.threadId ? { threadId: input.threadId } : {}),
+      ...(input.runId ? { runId: input.runId } : {}),
+      ...(input.tabId ? { tabId: input.tabId } : {}),
+    });
+  })();
+}
+
 export function configureTracking(options: ConfigureTrackingOptions): void {
   const publicKey = options.key || options.publicKey;
   if (publicKey) {

package/corpus/core/src/client/chat/message-components.tsx

@@ -72,7 +72,10 @@ import {
 import {
   ToolCallFallback,
   FilesChangedSummary,
+  ASSISTANT_VISIBLE_TOOL_CALL_LIMIT,
   ChatRunningContext,
+  ChatRunDurationContext,
+  RanToolsSummary,
   ReasoningCell,
   WorkedForSummary,
 } from "./tool-call-display.js";
@@ -820,7 +823,7 @@ function assistantMessageStatusIsTerminal(message: {
   return statusType === "complete" || statusType === "incomplete";
 }
 
-function messageTextFromContent(content: unknown): string {
+export function messageTextFromContent(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content
@@ -829,14 +832,10 @@ function messageTextFromContent(content: unknown): string {
       const record = part as {
         type?: unknown;
         text?: unknown;
-        result?: unknown;
       };
-      const values: string[] = [];
-      if (typeof record.text === "string") values.push(record.text);
-      if (record.type === "tool-call" && typeof record.result === "string") {
-        values.push(record.result);
-      }
-      return values;
+      return record.type === "text" && typeof record.text === "string"
+        ? [record.text]
+        : [];
     })
     .join("\n");
 }
@@ -874,10 +873,10 @@ export function shouldShowAssistantMessageFooter({
   hasUnresolvedTool?: boolean;
 }): boolean {
   if (!hasRenderableContent) return false;
-  if (chatRunning) return false;
   if (!isLast) return true;
+  if (chatRunning) return false;
   if (hasUnresolvedTool) return false;
-  return !chatRunning && statusIsTerminal;
+  return statusIsTerminal;
 }
 
 export function shouldShowAssistantWorkSummary({
@@ -954,16 +953,77 @@ export function isCollapsibleAssistantWorkPart(part: {
   );
 }
 
-function groupAssistantWorkParts(part: {
-  type?: string;
-  toolName?: string;
-}): ["group-work"] | null {
+export function getAssistantToolSummaryInfo(
+  parts: readonly { type?: string; toolName?: string }[],
+): { startIndex: number; hiddenToolCount: number } {
+  const toolCallIndices = parts.reduce<number[]>((indices, part, index) => {
+    if (part.type === "tool-call" && isCollapsibleAssistantWorkPart(part)) {
+      indices.push(index);
+    }
+    return indices;
+  }, []);
+
+  if (toolCallIndices.length <= ASSISTANT_VISIBLE_TOOL_CALL_LIMIT) {
+    return { startIndex: -1, hiddenToolCount: 0 };
+  }
+
+  const startIndex =
+    toolCallIndices[
+      toolCallIndices.length - ASSISTANT_VISIBLE_TOOL_CALL_LIMIT
+    ]!;
+  return {
+    startIndex,
+    hiddenToolCount: toolCallIndices.length - ASSISTANT_VISIBLE_TOOL_CALL_LIMIT,
+  };
+}
+
+function groupAssistantWorkParts(
+  part: {
+    type?: string;
+    toolName?: string;
+  },
+  index: number,
+  parts: readonly { type?: string; toolName?: string }[],
+): ["group-work"] | ["group-work", "group-ran-tools"] | null {
   if (isCollapsibleAssistantWorkPart(part)) {
+    const { startIndex } = getAssistantToolSummaryInfo(parts);
+    if (isAssistantToolSummaryPart(parts, index, startIndex)) {
+      return ["group-work", "group-ran-tools"];
+    }
     return ["group-work"];
   }
   return null;
 }
 
+function isAssistantToolSummaryPart(
+  parts: readonly { type?: string; toolName?: string }[],
+  index: number,
+  startIndex: number,
+): boolean {
+  if (startIndex < 0 || index >= startIndex) return false;
+  if (!isCollapsibleAssistantWorkPart(parts[index]!)) return false;
+
+  let segmentStart = index;
+  while (
+    segmentStart > 0 &&
+    isCollapsibleAssistantWorkPart(parts[segmentStart - 1]!)
+  ) {
+    segmentStart--;
+  }
+
+  let segmentEnd = index + 1;
+  while (
+    segmentEnd < startIndex &&
+    isCollapsibleAssistantWorkPart(parts[segmentEnd]!)
+  ) {
+    segmentEnd++;
+  }
+
+  return parts
+    .slice(segmentStart, segmentEnd)
+    .some((candidate) => candidate.type === "tool-call");
+}
+
 export function AssistantMessage() {
   const [restoreState, setRestoreState] = useState<
     "idle" | "confirming" | "restoring"
@@ -971,6 +1031,7 @@ export function AssistantMessage() {
   const messageRuntime = useMessageRuntime();
   const thread = useThread();
   const chatRunning = React.useContext(ChatRunningContext);
+  const lastRunDurationMs = React.useContext(ChatRunDurationContext);
   const msg = messageRuntime.getState();
   const timestamp = formatMessageTimestamp(msg.createdAt);
   const isLast =
@@ -1001,16 +1062,17 @@ export function AssistantMessage() {
       }
       return;
     }
-    if (
-      !chatRunning &&
-      isLast &&
-      runStartedAtRef.current != null &&
-      capturedDurationMs == null
-    ) {
-      setCapturedDurationMs(Date.now() - runStartedAtRef.current);
+    if (!chatRunning && isLast && capturedDurationMs == null) {
+      const durationMs =
+        lastRunDurationMs ??
+        (runStartedAtRef.current == null
+          ? null
+          : Date.now() - runStartedAtRef.current);
+      if (durationMs == null) return;
+      setCapturedDurationMs(durationMs);
       runStartedAtRef.current = null;
     }
-  }, [chatRunning, isLast, capturedDurationMs]);
+  }, [chatRunning, isLast, capturedDurationMs, lastRunDurationMs]);
 
   // Animate collapse only when this message just finished running in-session.
   const wasRunningRef = useRef(false);
@@ -1124,6 +1186,16 @@ export function AssistantMessage() {
                   </WorkedForSummary>
                 );
               }
+              case "group-ran-tools": {
+                const toolCount = part.indices.filter(
+                  (index) => msgContent?.[index]?.type === "tool-call",
+                ).length;
+                return (
+                  <RanToolsSummary toolCount={toolCount}>
+                    {children}
+                  </RanToolsSummary>
+                );
+              }
               case "text":
                 return <MarkdownText />;
               case "reasoning":