@agent-native/core 0.128.4 → 0.129.0

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

@@ -1,5 +1,5 @@
-import * as amplitude from "@amplitude/analytics-browser";
-import * as Sentry from "@sentry/browser";
+import type * as amplitude from "@amplitude/analytics-browser";
+import type * as Sentry from "@sentry/browser";
 
 import {
   llmConnectionTrackingProperties,
@@ -9,7 +9,10 @@ import {
   getOrCreateAnalyticsAnonymousId,
   getOrCreateAnalyticsSessionId,
 } from "./analytics-session.js";
-import { agentNativePath } from "./api-path.js";
+import {
+  fetchAgentEngineStatus,
+  fetchAuthSessionStatus,
+} from "./client-status-requests.js";
 import {
   installErrorCapture,
   type CapturedExceptionEvent,
@@ -149,7 +152,17 @@ let _getDefaultProps: GetDefaultProps | null = null;
 let _agentNativeAnalyticsPublicKey: string | null = null;
 let _agentNativeAnalyticsEndpoint: string | null = null;
 let _amplitudeInitialized = false;
+let _amplitudeModule: typeof amplitude | null = null;
+let _amplitudeLoadPromise: Promise<typeof amplitude | null> | null = null;
+let _amplitudeApiKey: string | null = null;
+let _pendingAmplitudeEvents: Array<[string, Record<string, unknown>]> = [];
 let _sentryInitialized = false;
+let _sentryModule: typeof Sentry | null = null;
+let _sentryLoadPromise: Promise<typeof Sentry | null> | null = null;
+let _pendingSentryCaptures: Array<{
+  error: unknown;
+  context: ClientCaptureContext;
+}> = [];
 let _llmConnectionStatus: LlmConnectionStatus | null = null;
 let _llmConnectionRefresh: Promise<void> | null = null;
 let _llmConnectionRefreshInstalled = false;
@@ -301,20 +314,12 @@ function refreshLlmConnectionStatus(): Promise<void> {
     return Promise.resolve();
   }
   if (_llmConnectionRefresh) return _llmConnectionRefresh;
-  let request: Promise<Response>;
-  try {
-    request = fetch(agentNativePath("/_agent-native/agent-engine/status"));
-  } catch {
-    return Promise.resolve();
-  }
-  _llmConnectionRefresh = request
-    .then((res) => (res.ok ? res.json() : null))
-    .then((data) => {
-      _llmConnectionStatus = normalizeAgentEngineStatus(data);
-      cacheLlmConnectionStatus(_llmConnectionStatus);
-    })
-    .catch(() => {
-      if (!_llmConnectionStatus) {
+  _llmConnectionRefresh = fetchAgentEngineStatus()
+    .then((result) => {
+      if (result.state === "available") {
+        _llmConnectionStatus = normalizeAgentEngineStatus(result.value);
+        cacheLlmConnectionStatus(_llmConnectionStatus);
+      } else if (!_llmConnectionStatus) {
         _llmConnectionStatus = readCachedLlmConnectionStatus();
       }
     })
@@ -396,15 +401,11 @@ function refreshTrackingAuthSession(): Promise<void> {
     return Promise.resolve();
   }
   if (_trackingSessionRefresh) return _trackingSessionRefresh;
-  _trackingSessionRefresh = fetch(
-    agentNativePath("/_agent-native/auth/session"),
-  )
-    .then((res) => (res.ok ? res.json() : null))
-    .then((data) => {
-      setTrackingIdentityFromSession(data);
-    })
-    .catch(() => {
-      clearTrackingIdentity();
+  _trackingSessionRefresh = fetchAuthSessionStatus()
+    .then((result) => {
+      if (result.state === "available") {
+        setTrackingIdentityFromSession(result.value);
+      }
     })
     .finally(() => {
       _trackingIdentityResolved = true;
@@ -616,12 +617,31 @@ function ensureAmplitude(): boolean {
   const key = (import.meta.env as Record<string, string | undefined>)
     ?.VITE_AMPLITUDE_API_KEY;
   if (!key) return false;
-  // Standard pageviews and explicit events are emitted below. Keep SDK-level
-  // DOM/network autocapture off so rendered user content is never collected as
-  // an implicit analytics side effect.
-  amplitude.init(key, { autocapture: false });
-  _amplitudeInitialized = true;
-  return true;
+  _amplitudeApiKey = key;
+  if (_amplitudeLoadPromise) return false;
+
+  _amplitudeLoadPromise = import("@amplitude/analytics-browser")
+    .then((module) => {
+      // Standard pageviews and explicit events are emitted below. Keep SDK-level
+      // DOM/network autocapture off so rendered user content is never collected as
+      // an implicit analytics side effect.
+      module.init(key, { autocapture: false });
+      _amplitudeModule = module;
+      _amplitudeInitialized = true;
+      for (const [name, properties] of _pendingAmplitudeEvents) {
+        module.track(name, properties);
+      }
+      _pendingAmplitudeEvents = [];
+      return module;
+    })
+    .catch(() => {
+      _pendingAmplitudeEvents = [];
+      return null;
+    })
+    .finally(() => {
+      _amplitudeLoadPromise = null;
+    });
+  return false;
 }
 
 function hasOnlySourcelessFrames(value: {
@@ -881,58 +901,103 @@ function getClientSentryDsn(): string | undefined {
   );
 }
 
-function ensureSentry(): void {
-  if (_sentryInitialized) return;
-  const dsn = getClientSentryDsn();
-  if (!dsn) return;
-  Sentry.init({
-    dsn,
-    environment:
-      window.__AGENT_NATIVE_CONFIG__?.sentryEnvironment ||
-      (import.meta.env as Record<string, string | undefined>)?.MODE ||
-      "production",
-    beforeSend(event) {
-      if (shouldDropBrowserSentryNoise(event)) {
-        return null;
+function captureWithSentry(
+  module: typeof Sentry,
+  error: unknown,
+  context: ClientCaptureContext,
+): string | undefined {
+  return module.withScope((scope) => {
+    if (context.tags) {
+      for (const [k, v] of Object.entries(context.tags)) {
+        if (typeof v === "string") scope.setTag(k, v);
       }
-      // Strip sensitive query params from the request URL. React Router
-      // history can include share tokens, ?signin=1, password reset codes,
-      // public-share password params (audit F-07), etc.
-      if (event.request?.url) {
-        event.request.url = scrubUrl(event.request.url);
+    }
+    if (context.extra) {
+      for (const [k, v] of Object.entries(context.extra)) {
+        if (v !== undefined) scope.setExtra(k, v);
       }
-      // Clean the same params from breadcrumb URLs (Sentry captures
-      // history.pushState breadcrumbs by default).
-      if (Array.isArray(event.breadcrumbs)) {
-        for (const crumb of event.breadcrumbs) {
-          if (crumb && typeof crumb === "object" && "data" in crumb) {
-            const data = crumb.data as Record<string, unknown> | undefined;
-            if (data && typeof data.url === "string") {
-              data.url = scrubUrl(data.url);
-            }
-            if (data && typeof data.from === "string") {
-              data.from = scrubUrl(data.from);
-            }
-            if (data && typeof data.to === "string") {
-              data.to = scrubUrl(data.to);
+    }
+    if (context.contexts) {
+      for (const [k, v] of Object.entries(context.contexts)) {
+        scope.setContext(k, v);
+      }
+    }
+    return module.captureException(error);
+  });
+}
+
+function ensureSentry(loadWithoutDsn = false): void {
+  if (_sentryInitialized || _sentryLoadPromise) return;
+  const dsn = getClientSentryDsn();
+  if (!dsn && !loadWithoutDsn) return;
+  _sentryLoadPromise = import("@sentry/browser")
+    .then((module) => {
+      _sentryModule = module;
+      if (!dsn) {
+        for (const pending of _pendingSentryCaptures) {
+          captureWithSentry(module, pending.error, pending.context);
+        }
+        _pendingSentryCaptures = [];
+        return module;
+      }
+      module.init({
+        dsn,
+        environment:
+          window.__AGENT_NATIVE_CONFIG__?.sentryEnvironment ||
+          (import.meta.env as Record<string, string | undefined>)?.MODE ||
+          "production",
+        beforeSend(event) {
+          if (shouldDropBrowserSentryNoise(event)) {
+            return null;
+          }
+          // Strip sensitive query params from the request URL. React Router
+          // history can include share tokens, ?signin=1, password reset codes,
+          // public-share password params (audit F-07), etc.
+          if (event.request?.url) {
+            event.request.url = scrubUrl(event.request.url);
+          }
+          // Clean the same params from breadcrumb URLs (Sentry captures
+          // history.pushState breadcrumbs by default).
+          if (Array.isArray(event.breadcrumbs)) {
+            for (const crumb of event.breadcrumbs) {
+              if (crumb && typeof crumb === "object" && "data" in crumb) {
+                const data = crumb.data as Record<string, unknown> | undefined;
+                if (data && typeof data.url === "string") {
+                  data.url = scrubUrl(data.url);
+                }
+                if (data && typeof data.from === "string") {
+                  data.from = scrubUrl(data.from);
+                }
+                if (data && typeof data.to === "string") {
+                  data.to = scrubUrl(data.to);
+                }
+              }
             }
           }
-        }
+          return event;
+        },
+      });
+      module.setTag("runtime", "browser");
+      _sentryInitialized = true;
+      // Flush any user/tag that was set before init.
+      if (_pendingSentryUser !== undefined) {
+        module.setUser(_pendingSentryUser);
+        _pendingSentryUser = undefined;
       }
-      return event;
-    },
-  });
-  Sentry.setTag("runtime", "browser");
-  _sentryInitialized = true;
-  // Flush any user/tag that was set before init.
-  if (_pendingSentryUser !== undefined) {
-    Sentry.setUser(_pendingSentryUser);
-    _pendingSentryUser = undefined;
-  }
-  if (_pendingSentryOrgId !== undefined) {
-    Sentry.setTag("orgId", _pendingSentryOrgId);
-    _pendingSentryOrgId = undefined;
-  }
+      if (_pendingSentryOrgId !== undefined) {
+        module.setTag("orgId", _pendingSentryOrgId);
+        _pendingSentryOrgId = undefined;
+      }
+      for (const pending of _pendingSentryCaptures) {
+        captureWithSentry(module, pending.error, pending.context);
+      }
+      _pendingSentryCaptures = [];
+      return module;
+    })
+    .catch(() => null)
+    .finally(() => {
+      _sentryLoadPromise = null;
+    });
 }
 
 /**
@@ -972,10 +1037,10 @@ export function setSentryUser(
   ) {
     void startConfiguredSessionReplay(_sessionReplayOptions);
   }
-  if (_sentryInitialized) {
-    Sentry.setUser(user);
+  if (_sentryInitialized && _sentryModule) {
+    _sentryModule.setUser(user);
     if (orgId !== undefined) {
-      Sentry.setTag("orgId", orgId ?? null);
+      _sentryModule.setTag("orgId", orgId ?? null);
     }
     return;
   }
@@ -1024,25 +1089,12 @@ export function captureClientException(
 ): string | undefined {
   if (typeof window === "undefined") return undefined;
   try {
-    ensureSentry();
-    return Sentry.withScope((scope) => {
-      if (context.tags) {
-        for (const [k, v] of Object.entries(context.tags)) {
-          if (typeof v === "string") scope.setTag(k, v);
-        }
-      }
-      if (context.extra) {
-        for (const [k, v] of Object.entries(context.extra)) {
-          if (v !== undefined) scope.setExtra(k, v);
-        }
-      }
-      if (context.contexts) {
-        for (const [k, v] of Object.entries(context.contexts)) {
-          scope.setContext(k, v);
-        }
-      }
-      return Sentry.captureException(error);
-    });
+    ensureSentry(true);
+    if (_sentryModule) return captureWithSentry(_sentryModule, error, context);
+    if (_pendingSentryCaptures.length < 50) {
+      _pendingSentryCaptures.push({ error, context });
+    }
+    return undefined;
   } catch {
     return undefined;
   }
@@ -1647,6 +1699,7 @@ function pageviewProperties(reason: string): Record<string, unknown> {
 }
 
 function emitPageview(reason: string): void {
+  if (typeof window === "undefined") return;
   if (isLocalAnalyticsHostname(window.location.hostname)) return;
   const state = getPageviewTrackingState();
   const key = pageviewKey();
@@ -1767,7 +1820,11 @@ export function trackEvent(
   const props = resolveProps(name, params);
   window.gtag?.("event", name.replace(/\s+/g, "_"), props);
   if (ensureAmplitude()) {
-    amplitude.track(name, props);
+    _amplitudeModule?.track(name, props);
+  } else if (_amplitudeApiKey) {
+    if (_pendingAmplitudeEvents.length < 100) {
+      _pendingAmplitudeEvents.push([name, props]);
+    }
   }
   sendAgentNativeAnalytics(name, props);
 }

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

@@ -948,6 +948,7 @@ export function assistantMessageHasCompletedCustomUi(
       type?: unknown;
       result?: unknown;
       isError?: unknown;
+      outcome?: unknown;
       activity?: unknown;
       chatUI?: unknown;
       mcpApp?: unknown;
@@ -956,7 +957,8 @@ export function assistantMessageHasCompletedCustomUi(
       record.type !== "tool-call" ||
       record.activity === true ||
       record.result === undefined ||
-      record.isError === true
+      record.isError === true ||
+      record.outcome === "unknown"
     ) {
       continue;
     }
@@ -1085,13 +1087,20 @@ export function shouldShowAssistantWorkSummary({
   isComplete,
   hasCollapsibleWork,
   hasUnresolvedTool,
+  chatRunning,
 }: {
   isLast: boolean;
   isComplete: boolean;
   hasCollapsibleWork: boolean;
   hasUnresolvedTool: boolean;
+  chatRunning: boolean;
 }): boolean {
-  if (!hasCollapsibleWork || hasUnresolvedTool) return false;
+  if (!hasCollapsibleWork) return false;
+
+  // An unresolved tool means "still working" only while the turn is actually
+  // running. On a stalled or interrupted turn it used to hide the summary
+  // forever, so the longest turns showed no "Worked for Xm Ys" at all.
+  if (hasUnresolvedTool) return !(isLast && chatRunning);
 
   // Keep completed historical work wrapped while a later turn is running.
   // Removing the wrapper exposes/remounts ReasoningCell and resets its
@@ -1447,6 +1456,7 @@ export function AssistantMessage() {
                   isComplete,
                   hasCollapsibleWork,
                   hasUnresolvedTool,
+                  chatRunning,
                 });
                 if (!showSummary) return <>{children}</>;
                 return (
@@ -1510,9 +1520,6 @@ export function AssistantMessage() {
             variant="response"
           />
         )}
-        {isLast && hasUnresolvedTool && !chatRunning && (
-          <RunningActivityStatus label="Thinking" />
-        )}
       </div>
       {isComplete && (
         <div className="mt-1 flex items-center justify-between">

package/corpus/core/src/client/chat/runtime.ts

@@ -1656,7 +1656,7 @@ function applyRuntimeEventToContent(
   }
   if (typed.type === "error") {
     const normalized = normalizeChatError(typed.error, typed.code);
-    settleInterruptedToolCalls(content);
+    settleInterruptedToolCalls(content, undefined, { includeActivity: true });
     content.push({
       type: "text",
       text: formatChatErrorText(typed.error, undefined, typed.code),
@@ -1677,6 +1677,7 @@ function applyRuntimeEventToContent(
     } as ChatModelRunResult;
   }
   if (typed.type === "done") {
+    settleInterruptedToolCalls(content, undefined, { includeActivity: true });
     return {
       content: [...content],
       status:

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

@@ -4,6 +4,7 @@
 import type { ToolCallMessagePartProps } from "@assistant-ui/react";
 import {
   IconLoader2,
+  IconAlertTriangle,
   IconCircleX,
   IconCheck,
   IconChevronRight,
@@ -583,6 +584,7 @@ export function ToolCallDisplay({
   mcpApp,
   chatUI,
   isRunning,
+  outcome,
   structuredMeta,
   approval,
   repeatCount,
@@ -596,6 +598,8 @@ export function ToolCallDisplay({
   mcpApp?: AgentMcpAppPayload;
   chatUI?: ActionChatUIConfig;
   isRunning: boolean;
+  /** "unknown": the stream ended mid-flight, so the side effect may have landed. */
+  outcome?: "unknown";
   structuredMeta?: Record<string, unknown>;
   approval?: { approvalKey: string; dismissed?: boolean };
   repeatCount?: number;
@@ -661,6 +665,7 @@ export function ToolCallDisplay({
       mcpApp={mcpApp}
       chatUI={chatUI}
       isRunning={isRunning}
+      outcome={outcome}
       isActiveTail={showActiveTail}
       structuredMeta={structuredMeta}
       approval={approval}
@@ -677,6 +682,7 @@ function ToolCallDisplayGeneric({
   mcpApp,
   chatUI,
   isRunning,
+  outcome,
   isActiveTail,
   structuredMeta,
   approval,
@@ -689,6 +695,7 @@ function ToolCallDisplayGeneric({
   mcpApp?: AgentMcpAppPayload;
   chatUI?: ActionChatUIConfig;
   isRunning: boolean;
+  outcome?: "unknown";
   isActiveTail: boolean;
   structuredMeta?: Record<string, unknown>;
   approval?: { approvalKey: string; dismissed?: boolean };
@@ -704,6 +711,7 @@ function ToolCallDisplayGeneric({
       ? args.agent
       : null;
   const isAgentError = isAgentCall && result === "Error calling agent";
+  const isUnknownOutcome = !isRunning && outcome === "unknown";
   const agentStreamText = isRawCallAgent
     ? (result ?? "")
     : isAgentCall
@@ -865,6 +873,8 @@ function ToolCallDisplayGeneric({
             <IconLoader2 className="size-3.5 animate-spin" />
           ) : isAgentError ? (
             <IconCircleX className="size-3.5 text-destructive" />
+          ) : isUnknownOutcome ? (
+            <IconAlertTriangle className="size-3.5 text-muted-foreground" />
           ) : (
             <>
               <ToolIcon
@@ -929,6 +939,12 @@ function ToolCallDisplayGeneric({
           )}
         </div>
       </AnimatedCollapse>
+      {isUnknownOutcome && (
+        <p role="status" className="ps-5 text-xs text-muted-foreground">
+          Interrupted before this finished reporting — it may or may not have
+          completed. Check before retrying.
+        </p>
+      )}
       {approval && (
         <ApprovalAffordance toolName={toolName} approval={approval} />
       )}
@@ -1149,14 +1165,19 @@ export function ToolCallFallback({
   chatUI?: ActionChatUIConfig;
   structuredMeta?: Record<string, unknown>;
   activity?: boolean;
+  outcome?: "unknown";
   approval?: { approvalKey: string; dismissed?: boolean };
   repeatCount?: number;
   isLatestRunning?: boolean;
   isActiveTail?: boolean;
 }) {
   const chatRunning = React.useContext(ChatRunningContext);
-  const isRunning =
-    result === undefined && (chatRunning || rest.activity === true);
+  // A spinner is a claim that something is running right now, so it needs an
+  // actually-running chat. `chatRunning` already stays true across
+  // auto-continuation gaps and server-active runs (resolveAssistantChatRunningState),
+  // so an activity placeholder alone must never resurrect one on rehydrated
+  // history.
+  const isRunning = result === undefined && chatRunning;
   return (
     <ToolCallDisplay
       toolName={toolName}
@@ -1173,6 +1194,7 @@ export function ToolCallFallback({
       chatUI={rest.chatUI}
       structuredMeta={rest.structuredMeta}
       isRunning={isRunning}
+      outcome={rest.outcome}
       isActiveTail={rest.isActiveTail}
       isLatestRunning={rest.isLatestRunning}
       approval={rest.approval}
@@ -1247,6 +1269,7 @@ export function ReconnectStreamMessage({
         mcpApp={part.mcpApp}
         chatUI={part.chatUI}
         structuredMeta={part.structuredMeta}
+        outcome={part.outcome}
         isRunning={
           part.result === undefined && (chatRunning || part.activity === true)
         }

package/corpus/core/src/client/chat-model-groups.ts

@@ -40,6 +40,9 @@ function addCurrentModel(
   return next;
 }
 
+// Cheapest → most expensive. The composer mirrors these tokens for the `$`
+// cost labels on picker rows (packages/toolkit/src/composer/TiptapComposer.tsx);
+// the toolkit cannot import core, so a new family must be added in both lists.
 const MODEL_COST_ORDER = [
   "luna",
   "terra",