@agent-native/core 0.107.2 → 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>