@agent-native/core 0.128.3 → 0.129.0

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",

package/corpus/core/src/client/client-status-requests.ts

@@ -0,0 +1,161 @@
+import { agentNativePath } from "./api-path.js";
+
+export type ClientStatusResult<T> =
+  | { state: "available"; value: T }
+  | { state: "unavailable"; status?: number };
+
+type CacheEntry = {
+  expiresAt: number;
+  result: ClientStatusResult<unknown>;
+};
+
+const RESULT_TTL_MS = 500;
+const REQUEST_TIMEOUT_MS = 15_000;
+const cache = new Map<string, CacheEntry>();
+const requests = new Map<string, Promise<ClientStatusResult<unknown>>>();
+const requestControllers = new Map<string, AbortController>();
+const requestGenerations = new Map<string, number>();
+let invalidationListenersInstalled = false;
+let generation = 0;
+
+function expireClientStatusCache(): void {
+  generation += 1;
+  cache.clear();
+}
+
+function installInvalidationListeners(): void {
+  if (
+    invalidationListenersInstalled ||
+    typeof window === "undefined" ||
+    typeof document === "undefined"
+  ) {
+    return;
+  }
+  invalidationListenersInstalled = true;
+
+  if (typeof window.addEventListener === "function") {
+    window.addEventListener("focus", expireClientStatusCache);
+    window.addEventListener(
+      "agent-engine:configured-changed",
+      invalidateClientStatusRequests,
+    );
+  }
+  if (typeof document.addEventListener === "function") {
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") {
+        expireClientStatusCache();
+      }
+    });
+  }
+}
+
+async function fetchClientStatus<T>(
+  path: string,
+): Promise<ClientStatusResult<T>> {
+  installInvalidationListeners();
+  const url = agentNativePath(path);
+  const cached = cache.get(url);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.result as ClientStatusResult<T>;
+  }
+  cache.delete(url);
+
+  const pending = requests.get(url);
+  if (pending) return pending as Promise<ClientStatusResult<T>>;
+
+  const requestGeneration = generation;
+  const requestUrlGeneration = requestGenerations.get(url) ?? 0;
+  const controller =
+    typeof AbortController === "undefined" ? null : new AbortController();
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<ClientStatusResult<unknown>>((resolve) => {
+    timeoutId = setTimeout(() => {
+      controller?.abort();
+      resolve({ state: "unavailable" });
+    }, REQUEST_TIMEOUT_MS);
+  });
+  const transport = fetch(url, {
+    cache: "no-store",
+    credentials: "same-origin",
+    ...(controller ? { signal: controller.signal } : {}),
+  })
+    .then(async (response): Promise<ClientStatusResult<unknown>> => {
+      if (!response.ok) {
+        return { state: "unavailable", status: response.status };
+      }
+      try {
+        return { state: "available", value: await response.json() };
+      } catch {
+        return { state: "unavailable", status: response.status };
+      }
+    })
+    .catch((): ClientStatusResult<unknown> => ({ state: "unavailable" }));
+  const request = Promise.race([transport, timeout])
+    .then((result) => {
+      if (
+        generation === requestGeneration &&
+        (requestGenerations.get(url) ?? 0) === requestUrlGeneration &&
+        result.state === "available"
+      ) {
+        cache.set(url, {
+          expiresAt: Date.now() + RESULT_TTL_MS,
+          result,
+        });
+      }
+      return result;
+    })
+    .finally(() => {
+      if (timeoutId !== undefined) clearTimeout(timeoutId);
+      if (requests.get(url) === request) requests.delete(url);
+      if (requestControllers.get(url) === controller) {
+        requestControllers.delete(url);
+      }
+    });
+
+  requests.set(url, request);
+  if (controller) requestControllers.set(url, controller);
+  return request as Promise<ClientStatusResult<T>>;
+}
+
+export function invalidateClientStatusRequest(path: string): void {
+  const url = agentNativePath(path);
+  requestGenerations.set(url, (requestGenerations.get(url) ?? 0) + 1);
+  cache.delete(url);
+  requestControllers.get(url)?.abort();
+  requestControllers.delete(url);
+  requests.delete(url);
+}
+
+export function invalidateClientStatusRequests(): void {
+  generation += 1;
+  cache.clear();
+  for (const controller of requestControllers.values()) {
+    controller.abort();
+  }
+  requestControllers.clear();
+  requests.clear();
+}
+
+export function fetchAgentEngineStatus<T = unknown>(): Promise<
+  ClientStatusResult<T>
+> {
+  return fetchClientStatus<T>("/_agent-native/agent-engine/status");
+}
+
+export function fetchEnvironmentStatus<T = unknown>(): Promise<
+  ClientStatusResult<T>
+> {
+  return fetchClientStatus<T>("/_agent-native/env-status");
+}
+
+export function fetchBuilderStatus<T = unknown>(): Promise<
+  ClientStatusResult<T>
+> {
+  return fetchClientStatus<T>("/_agent-native/builder/status");
+}
+
+export function fetchAuthSessionStatus<T = unknown>(): Promise<
+  ClientStatusResult<T>
+> {
+  return fetchClientStatus<T>("/_agent-native/auth/session");
+}

package/corpus/core/src/client/settings/VoiceTranscriptionSection.tsx

@@ -627,8 +627,8 @@ export function VoiceTranscriptionSection() {
               id="openai"
               selected={transcriptionMode === "batch" && provider === "openai"}
               onSelect={() => chooseBatchProvider("openai")}
-              title="OpenAI Whisper"
-              subtitle="Batch Whisper provider. Requires an OpenAI API key."
+              title="OpenAI Transcribe"
+              subtitle="Batch transcription provider. Requires an OpenAI API key."
               rightSlot={
                 openAiConfigured === null ? null : openAiConfigured ? (
                   <span className="flex items-center gap-1 text-[10px] text-green-500">

package/corpus/core/src/client/sse-event-processor.ts

@@ -34,6 +34,13 @@ export type ContentPart =
       args: Record<string, string>;
       result?: string;
       isError?: boolean;
+      /**
+       * Set when the stream ended while this tool was still in flight. We know
+       * it started and NOT whether its side effect landed, so it is deliberately
+       * separate from `isError` — an email that WAS delivered must never render
+       * as a failure just because the transport dropped before `tool_done`.
+       */
+      outcome?: "unknown";
       completedSideEffect?: boolean;
       mcpApp?: AgentMcpAppPayload;
       chatUI?: ActionChatUIConfig;
@@ -155,7 +162,10 @@ export function settleInterruptedToolCalls(
         part.activity === true
           ? (options?.activityResult ?? INTERRUPTED_ACTIVITY_RESULT)
           : result;
-      part.isError = true;
+      // Interrupted is not failed: the side effect may well have landed. Never
+      // set `isError` here — that is reserved for a result the server told us
+      // failed.
+      part.outcome = "unknown";
       changed = true;
     }
   }
@@ -1029,7 +1039,8 @@ function completedToolNamesAfterLastAssistantText(
       part.type === "tool-call" &&
       part.activity !== true &&
       part.result !== undefined &&
-      part.isError !== true
+      part.isError !== true &&
+      part.outcome !== "unknown"
     ) {
       names.add(part.toolName);
     }
@@ -1053,7 +1064,8 @@ function hasCompletedCustomUi(content: ContentPart[]): boolean {
       part?.type !== "tool-call" ||
       part.activity === true ||
       part.result === undefined ||
-      part.isError === true
+      part.isError === true ||
+      part.outcome === "unknown"
     ) {
       continue;
     }

package/corpus/core/src/client/use-agent-engine-configured.ts

@@ -1,7 +1,13 @@
 import { useEffect, useState } from "react";
 
 import { PROVIDER_ENV_VARS } from "../agent/engine/provider-env-vars.js";
-import { agentNativePath } from "./api-path.js";
+import {
+  fetchAgentEngineStatus,
+  fetchBuilderStatus,
+  fetchEnvironmentStatus,
+  invalidateClientStatusRequest,
+  type ClientStatusResult,
+} from "./client-status-requests.js";
 
 const PROVIDER_ENV_VAR_SET = new Set(PROVIDER_ENV_VARS);
 
@@ -39,43 +45,32 @@ export interface UseAgentEngineConfiguredOptions {
   threadId?: string | null;
 }
 
-// Abort ceiling for a hung request, NOT a deadline the probes race against.
-// `/agent-engine/status` resolves session, org context, a scoped secret and a
-// settings row — several DB round-trips that measured ~4.7s on a warm local
-// dev server, so any budget short enough to "feel fast" just manufactures a
-// fake answer. Losing this ceiling is treated as "don't know", never "missing".
-const DEFAULT_STATUS_CHECK_TIMEOUT_MS = 15000;
 const RETRY_BASE_MS = 2000;
 const RETRY_MAX_MS = 30000;
 
-async function fetchStatusJson(
+async function waitForStatus<T>(
+  request: Promise<ClientStatusResult<T>>,
   path: string,
-  timeoutMs: number,
-): Promise<unknown | null> {
-  const controller =
-    typeof AbortController !== "undefined" ? new AbortController() : null;
+  timeoutMs: number | undefined,
+): Promise<ClientStatusResult<T>> {
+  if (timeoutMs === undefined) return request;
+
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<null>((resolve) => {
+  const timeout = new Promise<ClientStatusResult<T>>((resolve) => {
     timeoutId = setTimeout(() => {
-      controller?.abort();
-      resolve(null);
+      // A request that loses this race may never settle. Evict and abort the
+      // shared probe so the scheduled retry starts a genuinely new request.
+      invalidateClientStatusRequest(path);
+      resolve({ state: "unavailable" });
     }, timeoutMs);
   });
-
-  // Never serve a stale status from the HTTP cache: this is re-fetched right
-  // after a provider connects, and a cached "missing" would keep the composer
-  // gate and error banner pinned even though a provider is now configured.
-  const request = fetch(agentNativePath(path), {
-    cache: "no-store",
-    ...(controller ? { signal: controller.signal } : {}),
-  })
-    .then((r) => (r.ok ? r.json() : null))
-    .catch(() => null)
-    .finally(() => {
-      if (timeoutId !== undefined) clearTimeout(timeoutId);
-    });
-
-  return Promise.race([request, timeout]);
+  try {
+    return await Promise.race([request, timeout]);
+  } finally {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+  }
 }
 
 function hasConfiguredFlag(value: unknown): value is { configured: boolean } {
@@ -117,22 +112,38 @@ export async function fetchAgentEngineConfiguredState(
   const timeoutMs =
     typeof options?.timeoutMs === "number" && options.timeoutMs > 0
       ? options.timeoutMs
-      : DEFAULT_STATUS_CHECK_TIMEOUT_MS;
-  const [envKeys, builderStatus, engineStatus] = await Promise.all([
-    fetchStatusJson("/_agent-native/env-status", timeoutMs),
-    fetchStatusJson("/_agent-native/builder/status", timeoutMs),
-    fetchStatusJson("/_agent-native/agent-engine/status", timeoutMs),
-  ]);
-
-  // All three failed — surface a retryable unavailable state instead of
-  // leaving the composer in an infinite checking loop.
-  if (envKeys == null && builderStatus == null && engineStatus == null) {
-    return "unavailable";
+      : undefined;
+  const engineResult = await waitForStatus(
+    fetchAgentEngineStatus(),
+    "/_agent-native/agent-engine/status",
+    timeoutMs,
+  );
+  if (
+    engineResult.state === "available" &&
+    hasConfiguredFlag(engineResult.value)
+  ) {
+    return engineResult.value.configured ? "configured" : "missing";
   }
 
+  // Older hosts may not expose the canonical route. Only then pay for the two
+  // legacy probes; current hosts answer readiness with one request.
+  const [envResult, builderResult] = await Promise.all([
+    waitForStatus(
+      fetchEnvironmentStatus(),
+      "/_agent-native/env-status",
+      timeoutMs,
+    ),
+    waitForStatus(
+      fetchBuilderStatus(),
+      "/_agent-native/builder/status",
+      timeoutMs,
+    ),
+  ]);
+  const envKeys = envResult.state === "available" ? envResult.value : undefined;
+  const builderStatus =
+    builderResult.state === "available" ? builderResult.value : undefined;
   const envKeysKnown = Array.isArray(envKeys);
   const builderStatusKnown = hasConfiguredFlag(builderStatus);
-  const engineStatusKnown = hasConfiguredFlag(engineStatus);
   const keys = envKeysKnown
     ? (envKeys as Array<{
         key: string;
@@ -142,16 +153,9 @@ export async function fetchAgentEngineConfiguredState(
   const llmKeys = keys.filter((k) => PROVIDER_ENV_VAR_SET.has(k.key));
   const anyConfigured =
     llmKeys.some((k) => k.configured) ||
-    (builderStatusKnown && builderStatus.configured) ||
-    (engineStatusKnown && engineStatus.configured);
+    (builderStatusKnown && builderStatus.configured);
   if (anyConfigured) return "configured";
 
-  // The engine status route is the canonical readiness check: it resolves
-  // Builder, scoped BYOK secrets, deployment credentials, and custom engines.
-  // Once it has answered `configured: false`, a slow legacy env/Builder status
-  // request must not leave the composer permissively stuck in `unknown`.
-  if (engineStatusKnown) return "missing";
-
   // Compatibility fallback for older hosts without the canonical route.
   return envKeysKnown && builderStatusKnown ? "missing" : "unavailable";
 }

package/corpus/core/src/client/use-chat-models.ts

@@ -7,11 +7,14 @@ import {
   resolveReasoningEffortSelection,
   type ReasoningEffort,
 } from "../shared/reasoning-effort.js";
-import { agentNativePath } from "./api-path.js";
 import {
   buildChatModelGroups,
   type EngineModelGroup,
 } from "./chat-model-groups.js";
+import {
+  fetchBuilderStatus,
+  fetchEnvironmentStatus,
+} from "./client-status-requests.js";
 import { callAction } from "./use-action.js";
 
 export type { EngineModelGroup } from "./chat-model-groups.js";
@@ -192,14 +195,10 @@ export function useChatModels({
       callAction("manage-agent-engine" as any, { action: "list" } as any).catch(
         () => null,
       ),
-      fetch(agentNativePath("/_agent-native/env-status"))
-        .then((r) => (r.ok ? r.json() : []))
-        .catch(() => []),
-      fetch(agentNativePath("/_agent-native/builder/status"))
-        .then((r) => (r.ok ? r.json() : null))
-        .catch(() => null),
+      fetchEnvironmentStatus<Array<{ key: string; configured: boolean }>>(),
+      fetchBuilderStatus<{ configured?: boolean }>(),
     ])
-      .then(([enginesData, envKeys, builderStatus]) => {
+      .then(([enginesData, envResult, builderResult]) => {
         if (!enginesData?.engines) {
           // Without a catalog the picker keeps an unvalidated DEFAULT_MODEL,
           // which is indistinguishable from a real selection unless we say so.
@@ -208,10 +207,16 @@ export function useChatModels({
           );
           return;
         }
+        if (
+          envResult.state !== "available" ||
+          builderResult.state !== "available"
+        ) {
+          return;
+        }
+        const envKeys = envResult.value;
+        const builderStatus = builderResult.value;
         const configuredKeys = new Set(
-          (envKeys as Array<{ key: string; configured: boolean }>)
-            .filter((k) => k.configured)
-            .map((k) => k.key),
+          envKeys.filter((k) => k.configured).map((k) => k.key),
         );
         const builderConnected = builderStatus?.configured === true;
         const currentEngineName: string | undefined =

package/corpus/core/src/client/use-chat-threads.ts

@@ -78,6 +78,35 @@ const ACTIVE_THREAD_KEY = "agent-chat-active-thread";
 const THREADS_UPDATED_EVENT = "agent-chat:threads-updated";
 const THREADS_PAGE_SIZE = 50;
 
+const sharedThreadListRequests = new Map<
+  string,
+  Promise<ChatThreadSummary[] | undefined>
+>();
+
+async function fetchSharedThreadListPage(
+  apiUrl: string,
+  offset: number,
+): Promise<ChatThreadSummary[] | undefined> {
+  const requestKey = `${apiUrl}\n${offset}`;
+  const pending = sharedThreadListRequests.get(requestKey);
+  if (pending) return pending;
+
+  const request = fetch(
+    offset > 0 ? `${apiUrl}/threads?offset=${offset}` : `${apiUrl}/threads`,
+  )
+    .then(async (res) => {
+      if (!res.ok) return undefined;
+      const data = await res.json();
+      const threads = (data.threads ?? []) as ChatThreadSummary[];
+      return threads;
+    })
+    .finally(() => {
+      sharedThreadListRequests.delete(requestKey);
+    });
+  sharedThreadListRequests.set(requestKey, request);
+  return request;
+}
+
 function emitThreadsUpdated() {
   if (typeof window === "undefined") return;
   window.dispatchEvent(new CustomEvent(THREADS_UPDATED_EVENT));
@@ -441,20 +470,14 @@ export function useChatThreads(
     async (options?: { append?: boolean }) => {
       try {
         const offset = options?.append ? nextThreadsOffsetRef.current : 0;
-        const res = await fetch(
-          offset > 0
-            ? `${apiUrl}/threads?offset=${offset}`
-            : `${apiUrl}/threads`,
-        );
-        if (!res.ok) {
+        const loaded = await fetchSharedThreadListPage(apiUrl, offset);
+        if (!loaded) {
           if (!options?.append) {
             setThreadsLoadError("Could not load chat history.");
           }
           return;
         }
-        const data = await res.json();
         setThreadsLoadError(null);
-        const loaded = (data.threads ?? []) as ChatThreadSummary[];
         if (!options?.append) {
           nextThreadsOffsetRef.current = loaded.length;
         } else {
@@ -526,7 +549,7 @@ export function useChatThreads(
           }
           return [...optimisticOnly, ...merged];
         });
-        return data.threads as ChatThreadSummary[];
+        return loaded;
       } catch {
         if (!options?.append) {
           setThreadsLoadError("Could not load chat history.");

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

@@ -2,7 +2,7 @@ import { useEffect, useState } from "react";
 
 import type { AuthSession } from "../server/auth.js";
 import { setSentryUser, trackSessionStatus } from "./analytics.js";
-import { agentNativePath } from "./api-path.js";
+import { fetchAuthSessionStatus } from "./client-status-requests.js";
 
 export type { AuthSession };
 
@@ -51,10 +51,9 @@ function fetchSharedSession(): Promise<AuthSession | null | undefined> {
 
   sessionRequest = (async () => {
     try {
-      const res = await fetch(agentNativePath("/_agent-native/auth/session"));
-      if (!res.ok) return undefined;
-
-      const data = await res.json();
+      const result = await fetchAuthSessionStatus();
+      if (result.state === "unavailable") return undefined;
+      const data = result.value as AuthSession & { error?: unknown };
       const session = data.error ? null : (data as AuthSession);
       cachedSession = session;
       cachedSessionAt = Date.now();