@agent-native/core 0.108.0 → 0.109.0

package/corpus/core/src/client/chat/tool-call-display.tsx

@@ -63,6 +63,8 @@ import {
 
 // Exported so AssistantChatInner can provide a context value.
 export const ChatRunningContext = React.createContext(false);
+export const ChatRunDurationContext = React.createContext<number | null>(null);
+export const ASSISTANT_VISIBLE_TOOL_CALL_LIMIT = 3;
 
 /**
  * Human-in-the-loop approval bridge. `AssistantChatInner` provides a value that
@@ -898,6 +900,7 @@ export function ReconnectStreamMessage({
   content: ContentPart[];
 }) {
   const chatRunning = React.useContext(ChatRunningContext);
+  const toolSummary = getReconnectToolSummaryInfo(content);
   const latestReasoningPartIndex = content.reduce(
     (latestIndex, part, index) =>
       part.type === "reasoning" ? index : latestIndex,
@@ -908,61 +911,148 @@ export function ReconnectStreamMessage({
   const streamingReasoningPartIndex =
     content.at(-1)?.type === "reasoning" ? content.length - 1 : -1;
 
+  const renderPart = (part: ContentPart, i: number) => {
+    if (part.type === "text") {
+      const partStreaming = chatRunning && i === streamingTextPartIndex;
+      return (
+        <SmoothMarkdownText
+          key={`reconnect-text-${i}`}
+          text={part.text}
+          streaming={partStreaming}
+          resetKey={`reconnect-text-${i}`}
+          statusType={partStreaming ? "running" : "complete"}
+        />
+      );
+    }
+    if (part.type === "reasoning") {
+      return (
+        <ReasoningCell
+          key={`reconnect-reasoning-${i}`}
+          text={part.text}
+          isStreaming={chatRunning && i === streamingReasoningPartIndex}
+          resetKey={`reconnect-reasoning-${i}`}
+          defaultOpen={i === latestReasoningPartIndex}
+          collapseWhenReplaced={i < latestReasoningPartIndex}
+        />
+      );
+    }
+    return (
+      <ToolCallDisplay
+        key={`reconnect-tool-${i}`}
+        toolName={part.toolName}
+        argsText={part.argsText}
+        args={part.args}
+        result={part.result}
+        mcpApp={part.mcpApp}
+        chatUI={part.chatUI}
+        structuredMeta={part.structuredMeta}
+        isRunning={
+          part.result === undefined && (chatRunning || part.activity === true)
+        }
+        approval={part.approval}
+        repeatCount={part.repeatCount}
+      />
+    );
+  };
+
+  const renderedParts: React.ReactNode[] = [];
+  let summaryStartIndex = -1;
+  let summaryToolCount = 0;
+  const flushSummary = (endIndex: number) => {
+    if (summaryStartIndex < 0) return;
+    renderedParts.push(
+      <RanToolsSummary
+        key={`reconnect-tool-summary-${summaryStartIndex}`}
+        toolCount={summaryToolCount}
+      >
+        {content
+          .slice(summaryStartIndex, endIndex)
+          .map((part, offset) => renderPart(part, summaryStartIndex + offset))}
+      </RanToolsSummary>,
+    );
+    summaryStartIndex = -1;
+    summaryToolCount = 0;
+  };
+
+  for (let i = 0; i < content.length; i++) {
+    const part = content[i]!;
+    const isOlderToolWork =
+      toolSummary.startIndex >= 0 &&
+      i < toolSummary.startIndex &&
+      isReconnectToolSummaryPart(content, i, toolSummary.startIndex);
+    if (isOlderToolWork) {
+      summaryStartIndex = summaryStartIndex < 0 ? i : summaryStartIndex;
+      if (part.type === "tool-call") summaryToolCount++;
+      continue;
+    }
+    flushSummary(i);
+    renderedParts.push(renderPart(part, i));
+  }
+  flushSummary(content.length);
+
   return (
     <div className="flex justify-start">
       <div className="w-full max-w-[95%] text-sm leading-relaxed text-foreground space-y-1">
-        {content.map((part, i) => {
-          if (part.type === "text") {
-            const partStreaming = chatRunning && i === streamingTextPartIndex;
-            return (
-              <SmoothMarkdownText
-                key={`reconnect-text-${i}`}
-                text={part.text}
-                streaming={partStreaming}
-                resetKey={`reconnect-text-${i}`}
-                statusType={partStreaming ? "running" : "complete"}
-              />
-            );
-          }
-          if (part.type === "reasoning") {
-            return (
-              <ReasoningCell
-                key={`reconnect-reasoning-${i}`}
-                text={part.text}
-                isStreaming={chatRunning && i === streamingReasoningPartIndex}
-                resetKey={`reconnect-reasoning-${i}`}
-                defaultOpen={i === latestReasoningPartIndex}
-                collapseWhenReplaced={i < latestReasoningPartIndex}
-              />
-            );
-          }
-          if (part.type === "tool-call") {
-            return (
-              <ToolCallDisplay
-                key={`reconnect-tool-${i}`}
-                toolName={part.toolName}
-                argsText={part.argsText}
-                args={part.args}
-                result={part.result}
-                mcpApp={part.mcpApp}
-                chatUI={part.chatUI}
-                structuredMeta={part.structuredMeta}
-                isRunning={
-                  part.result === undefined &&
-                  (chatRunning || part.activity === true)
-                }
-                approval={part.approval}
-                repeatCount={part.repeatCount}
-              />
-            );
-          }
-          return null;
-        })}
+        {renderedParts}
       </div>
     </div>
   );
 }
 
+function getReconnectToolSummaryInfo(content: readonly ContentPart[]) {
+  const toolCallIndices = content.reduce<number[]>((indices, part, index) => {
+    if (part.type === "tool-call" && isReconnectSummarizablePart(part)) {
+      indices.push(index);
+    }
+    return indices;
+  }, []);
+  if (toolCallIndices.length <= ASSISTANT_VISIBLE_TOOL_CALL_LIMIT) {
+    return { startIndex: -1 };
+  }
+  return {
+    startIndex:
+      toolCallIndices[
+        toolCallIndices.length - ASSISTANT_VISIBLE_TOOL_CALL_LIMIT
+      ]!,
+  };
+}
+
+function isReconnectSummarizablePart(part: ContentPart): boolean {
+  return (
+    part.type === "reasoning" ||
+    (part.type === "tool-call" && part.toolName !== "connect-builder")
+  );
+}
+
+function isReconnectToolSummaryPart(
+  content: readonly ContentPart[],
+  index: number,
+  startIndex: number,
+): boolean {
+  if (startIndex < 0 || index >= startIndex) return false;
+  if (!isReconnectSummarizablePart(content[index]!)) return false;
+
+  let segmentStart = index;
+  while (
+    segmentStart > 0 &&
+    isReconnectSummarizablePart(content[segmentStart - 1]!)
+  ) {
+    segmentStart--;
+  }
+
+  let segmentEnd = index + 1;
+  while (
+    segmentEnd < startIndex &&
+    isReconnectSummarizablePart(content[segmentEnd]!)
+  ) {
+    segmentEnd++;
+  }
+
+  return content
+    .slice(segmentStart, segmentEnd)
+    .some((candidate) => candidate.type === "tool-call");
+}
+
 // ─── Reasoning / Thinking cell ────────────────────────────────────────────────
 
 /**
@@ -1141,6 +1231,39 @@ export function WorkedForSummary({
   );
 }
 
+export function RanToolsSummary({
+  toolCount,
+  children,
+}: {
+  toolCount: number;
+  children: React.ReactNode;
+}) {
+  const [open, setOpen] = useState(false);
+  const label = `Ran ${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
+
+  return (
+    <div className="my-1 w-full">
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        aria-expanded={open}
+        className="flex items-center gap-1.5 py-0.5 text-[13px] text-muted-foreground transition-colors hover:text-foreground"
+      >
+        <span>{label}</span>
+        <IconChevronRight
+          className={cn(
+            "size-3.5 shrink-0 transition-transform",
+            open && "rotate-90",
+          )}
+        />
+      </button>
+      <AnimatedCollapse open={open}>
+        <div className="pt-1">{children}</div>
+      </AnimatedCollapse>
+    </div>
+  );
+}
+
 // ─── Re-export for AssistantMessage ───────────────────────────────────────────
 // AssistantMessage in AssistantChat.tsx uses FilesChangedSummary directly, so
 // re-export it so AssistantChat.tsx can import from one place.

package/corpus/core/src/client/chat/use-agent-chat-lifecycle-tracking.ts

@@ -0,0 +1,74 @@
+import { useCallback, useEffect } from "react";
+
+import {
+  ACTIVE_RUN_STATE_EVENT,
+  getActiveRun,
+  type ActiveRunState,
+} from "../active-run-state.js";
+import { trackAgentChatLifecycle } from "../analytics.js";
+
+export interface AgentChatLifecycleTrackingOptions {
+  surface: string;
+  threadId?: string;
+  tabId?: string;
+  onActiveRunChange?: (active: boolean) => void;
+}
+
+export function useAgentChatLifecycleTracking({
+  surface,
+  threadId,
+  tabId,
+  onActiveRunChange,
+}: AgentChatLifecycleTrackingOptions): (runId?: string) => void {
+  useEffect(() => {
+    trackAgentChatLifecycle({
+      phase: "surface-mounted",
+      surface,
+      ...(threadId ? { threadId } : {}),
+      ...(tabId ? { tabId } : {}),
+    });
+  }, [surface, tabId, threadId]);
+
+  useEffect(() => {
+    const sync = (state = getActiveRun()) => {
+      const active = Boolean(
+        threadId && state?.threadId === threadId && state.runId,
+      );
+      onActiveRunChange?.(active);
+      if (!active || !state) return;
+      trackAgentChatLifecycle({
+        phase: "run-observed",
+        surface,
+        threadId: state.threadId,
+        runId: state.runId,
+        ...(tabId ? { tabId } : {}),
+      });
+    };
+    sync();
+    const activeRunHandler = (event: Event) => {
+      const state = (event as CustomEvent<{ state?: ActiveRunState | null }>)
+        .detail?.state;
+      sync(state ?? null);
+    };
+    const storageHandler = () => sync();
+    window.addEventListener(ACTIVE_RUN_STATE_EVENT, activeRunHandler);
+    window.addEventListener("storage", storageHandler);
+    return () => {
+      window.removeEventListener(ACTIVE_RUN_STATE_EVENT, activeRunHandler);
+      window.removeEventListener("storage", storageHandler);
+    };
+  }, [onActiveRunChange, surface, tabId, threadId]);
+
+  return useCallback(
+    (runId?: string) => {
+      trackAgentChatLifecycle({
+        phase: "run-stopped",
+        surface,
+        ...(threadId ? { threadId } : {}),
+        ...(runId ? { runId } : {}),
+        ...(tabId ? { tabId } : {}),
+      });
+    },
+    [surface, tabId, threadId],
+  );
+}

package/corpus/core/src/client/chat-thread-url.ts

@@ -0,0 +1,11 @@
+export function hasChatThreadDeepLink(): boolean {
+  if (typeof window === "undefined") return false;
+  try {
+    const params = new URLSearchParams(window.location.search);
+    return Boolean(
+      params.get("thread")?.trim() || params.get("threadId")?.trim(),
+    );
+  } catch {
+    return false;
+  }
+}

package/corpus/core/src/client/error-capture.ts

@@ -355,6 +355,18 @@ function shouldIgnoreAutoCapturedError(normalized: {
     return true;
   }
 
+  // Route-chunk recovery reloads the current page after stale lazy chunks or
+  // module scripts fail. Browser-level failures have no useful stack, so do
+  // not retain the transient loader noise as an application issue.
+  if (
+    !stack &&
+    /^(?:Importing a module script failed\.?|(?:Failed to fetch|error loading) dynamically imported module(?::.*)?)$/i.test(
+      message,
+    )
+  ) {
+    return true;
+  }
+
   if (
     normalized.type === "InvalidStateError" &&
     /^Transition was aborted because of invalid state$/i.test(message)

package/corpus/core/src/client/extensions/ExtensionSlot.tsx

@@ -1,6 +1,6 @@
 import { IconPlus } from "@tabler/icons-react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import { sendToAgentChat } from "../agent-chat.js";
 import { agentNativePath } from "../api-path.js";
@@ -49,6 +49,8 @@ export interface ExtensionSlotProps {
   className?: string;
   /** Optional className applied to each EmbeddedExtension. */
   toolClassName?: string;
+  /** Fires once when the slot query and all installed extensions are ready. */
+  onReady?: () => void;
 }
 
 /**
@@ -70,8 +72,11 @@ export function ExtensionSlot({
   showEmptyAffordance,
   className,
   toolClassName,
+  onReady,
 }: ExtensionSlotProps) {
   const t = useT();
+  const readyInstallIds = useRef(new Set<string>());
+  const readyNotified = useRef(false);
   const installsQuery = useQuery<SlotInstall[]>({
     queryKey: ["slot-installs", id],
     queryFn: async () => {
@@ -87,6 +92,35 @@ export function ExtensionSlot({
   });
   const installs = installsQuery.data ?? [];
 
+  useEffect(() => {
+    readyInstallIds.current.clear();
+    readyNotified.current = false;
+  }, [id]);
+
+  useEffect(() => {
+    if (readyNotified.current || installsQuery.isLoading) return;
+    if (
+      installsQuery.isError ||
+      installs.length === 0 ||
+      readyInstallIds.current.size >= installs.length
+    ) {
+      readyNotified.current = true;
+      onReady?.();
+    }
+  }, [installs, installsQuery.isError, installsQuery.isLoading, onReady]);
+
+  const markInstallReady = (installId: string) => {
+    readyInstallIds.current.add(installId);
+    if (
+      !readyNotified.current &&
+      !installsQuery.isLoading &&
+      readyInstallIds.current.size >= installs.length
+    ) {
+      readyNotified.current = true;
+      onReady?.();
+    }
+  };
+
   if (installsQuery.isLoading) {
     return null;
   }
@@ -121,6 +155,8 @@ export function ExtensionSlot({
           slotId={id}
           context={context}
           className={toolClassName}
+          onReady={() => markInstallReady(install.installId)}
+          onUnavailable={() => markInstallReady(install.installId)}
         />
       ))}
     </div>

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

@@ -787,6 +787,7 @@ export {
 export { AgentTerminal, type AgentTerminalProps } from "./terminal/index.js";
 export {
   trackEvent,
+  trackAgentChatLifecycle,
   trackSessionStatus,
   configureTracking,
   setTrackingContentCaptureEnabled,
@@ -811,6 +812,7 @@ export {
   type CaptureExceptionContext,
   type CapturedExceptionEvent,
   type ClientCaptureContext,
+  type AgentChatLifecycleEvent,
   type ConfigureTrackingOptions,
   type ErrorCaptureConfigOptions,
   type ExceptionBreadcrumb,

package/corpus/core/src/client/route-chunk-recovery.ts

@@ -201,6 +201,17 @@ function recoverToIntendedNavigation(
   return true;
 }
 
+function recoverFromDynamicImportFailure(
+  win: Window,
+  state: RouteChunkRecoveryState,
+  message: string,
+): boolean {
+  if (!isDynamicImportFailureMessage(message)) return false;
+  state.routeModuleFailureAt = Date.now();
+  if (recoverToIntendedNavigation(win, state)) return true;
+  return reloadForStaleChunk(win);
+}
+
 function patchHistoryMethod(
   win: Window,
   state: RouteChunkRecoveryState,
@@ -290,16 +301,17 @@ export function installRouteChunkRecovery(
   win.addEventListener("unhandledrejection", (event) => {
     const reason = (event as PromiseRejectionEvent).reason;
     const message = String(reason?.message || reason || "");
-    if (!isDynamicImportFailureMessage(message)) return;
-    state.routeModuleFailureAt = Date.now();
-    if (recoverToIntendedNavigation(win, state)) {
+    if (recoverFromDynamicImportFailure(win, state, message)) {
       event.preventDefault();
-      return;
     }
-    // No fresh cross-route target — the current route's own chunk went stale.
-    // Reload once (guarded) to fetch fresh assets instead of leaving the user
-    // on a broken view.
-    if (reloadForStaleChunk(win)) {
+  });
+
+  win.addEventListener("error", (event) => {
+    const errorEvent = event as ErrorEvent;
+    const message = String(
+      errorEvent.error?.message || errorEvent.message || "",
+    );
+    if (recoverFromDynamicImportFailure(win, state, message)) {
       event.preventDefault();
     }
   });

package/corpus/core/src/client/session-replay.ts

@@ -390,6 +390,8 @@ const SESSION_REPLAY_CLAIM_TIMEOUT_MS = 150;
 export const SESSION_REPLAY_CONSOLE_EVENT_TAG = "agent-native.console";
 /** rrweb custom-event tag for captured fetch/XHR request summaries. */
 export const SESSION_REPLAY_NETWORK_EVENT_TAG = "agent-native.network";
+/** Content-free agent-chat lifecycle markers for replay incident forensics. */
+export const SESSION_REPLAY_AGENT_CHAT_EVENT_TAG = "agent-native.chat";
 
 const DEFAULT_MAX_CONSOLE_EVENTS = 1000;
 const DEFAULT_MAX_NETWORK_EVENTS = 2000;
@@ -3384,3 +3386,32 @@ export function emitSessionReplayException(input: {
     ...(input.url ? { url: input.url } : {}),
   });
 }
+
+export type SessionReplayAgentChatEvent = {
+  phase: "surface-mounted" | "run-observed" | "run-stopped";
+  surface: string;
+  threadId?: string;
+  runId?: string;
+  tabId?: string;
+};
+
+/**
+ * Add a content-free chat lifecycle marker to the active replay. The payload
+ * deliberately accepts only ids and low-cardinality state; prompt/response
+ * content must never enter replay diagnostics through this path.
+ */
+export function emitSessionReplayAgentChatEvent(
+  input: SessionReplayAgentChatEvent,
+): void {
+  const state = getState();
+  if (!state.active || !state.addCustomEvent) return;
+  const bounded = (value: string | undefined, max = 160) =>
+    value?.trim().slice(0, max) || undefined;
+  emitReplayCustomEvent(state, SESSION_REPLAY_AGENT_CHAT_EVENT_TAG, {
+    phase: input.phase,
+    surface: bounded(input.surface, 80) ?? "app",
+    ...(bounded(input.threadId) ? { threadId: bounded(input.threadId) } : {}),
+    ...(bounded(input.runId) ? { runId: bounded(input.runId) } : {}),
+    ...(bounded(input.tabId) ? { tabId: bounded(input.tabId) } : {}),
+  });
+}

package/corpus/core/src/extensions/actions.ts

@@ -727,20 +727,8 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
           !coerceBoolean(args?.allowFullReplacement)
         ) {
           const message =
-            "Full extension-body replacement was blocked to preserve the existing visual design. Read the current extension and use focused patches/edits for a data-only repair. Only retry with allowFullReplacement=true when the user explicitly requested a broad visual rewrite or supplied a complete replacement body.";
-          throw new AgentActionStopError(message, {
-            errorCode: "extension_full_replacement_requires_explicit_intent",
-            toolResult: JSON.stringify(
-              {
-                error: "extension_full_replacement_requires_explicit_intent",
-                message,
-                recoverable: false,
-                next: "Call get-extension once, then update-extension with patches or edits that change only the data-loading code. Use allowFullReplacement=true only for an explicitly requested visual rewrite.",
-              },
-              null,
-              2,
-            ),
-          });
+            "Full extension-body replacement requires allowFullReplacement=true. No changes were applied. If the user's request includes a broad visual rewrite such as changing layout, compactness, visible sections, naming, or padding, retry once with allowFullReplacement=true; otherwise read the current extension and use focused patches/edits for a data-only repair. Do not retry unchanged arguments.";
+          throw new ExtensionContentEditError(message);
         }
 
         // Full-replacement content can come inline (`content`) or by reference

package/corpus/core/src/extensions/store.ts

@@ -1192,7 +1192,7 @@ export async function updateExtensionContent(
 
   if (opts.content !== undefined && opts.allowFullReplacement !== true) {
     throw new ExtensionContentEditError(
-      "Full extension-body replacement requires explicit allowFullReplacement=true. Use patches or edits for a targeted data-only repair so the existing design is preserved.",
+      "Full extension-body replacement requires allowFullReplacement=true. No changes were applied. Use patches or edits for a targeted data-only repair, or set allowFullReplacement=true for a user-requested broad visual rewrite.",
     );
   }
 

package/corpus/core/src/localization/default-messages.ts

@@ -129,6 +129,9 @@ const messages = {
         'Apps in the "{{workspace}}" workspace. Each app gets its own route under this workspace and shares its database, auth, and agent chat.',
       appsInWorkspace: "Apps in {{workspace}}",
       workspaceApps: "Workspace apps",
+      otherApps: "Other apps",
+      otherAppsDescription: "Open other apps available to you.",
+      availableCount: "{{count}} available",
       activeCount: "{{count}} active",
       hiddenCount: "{{count}} hidden",
       createApp: "Create app",

package/corpus/core/src/mcp/build-server.ts

@@ -345,7 +345,7 @@ function warnFullCatalogServed(toolCount: number): void {
   );
 }
 
-function isAuthenticatedReadAction(entry: ActionEntry): boolean {
+export function isAuthenticatedReadAction(entry: ActionEntry): boolean {
   return (
     entry.http !== false &&
     entry.http?.method === "GET" &&
@@ -404,7 +404,7 @@ const AUTO_READ_EXCLUDED_ACTION_PATTERNS: RegExp[] = [
   /browser-session/,
 ];
 
-function isAutoReadExcludedActionName(name: string): boolean {
+export function isAutoReadExcludedActionName(name: string): boolean {
   return (
     AUTO_READ_EXCLUDED_ACTION_NAMES.has(name) ||
     AUTO_READ_EXCLUDED_ACTION_PATTERNS.some((pattern) => pattern.test(name))

package/corpus/core/src/progress/actions.ts

@@ -35,6 +35,7 @@ Use for non-trivial work with multiple real steps (not single-action lookups). D
 - Exactly one task in progress at a time; never batch-complete steps after the fact — update as you go.
 - Always transition pending → in_progress before completing a step.
 - If the task pivots (scope change, unexpected blocker), update the current step to reflect it before continuing.
+- Only include fields for the selected action; do not send empty placeholder fields.
 - End every run with "complete" (succeeded / failed / cancelled). Never leave a run open indefinitely.
 
 Actions:
@@ -78,8 +79,9 @@ Actions:
             },
             status: {
               type: "string",
-              enum: ["succeeded", "failed", "cancelled"],
-              description: "[complete] Terminal status for the run.",
+              enum: ["", "succeeded", "failed", "cancelled"],
+              description:
+                '[complete] Terminal status for the run. Omit it for "start" and "update".',
             },
             active: {
               type: "boolean",