@agent-native/core 0.128.4 → 0.129.0

package/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/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/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/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/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/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/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();

package/src/db/client.ts

@@ -638,6 +638,27 @@ function sqlAndArgs(sql: DbExecStatement): {
     : { rawSql: sql.sql, args: sql.args || [] };
 }
 
+const POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS = 250;
+const POSTGRES_MAX_INT = 2_147_483_647;
+
+function hasExplicitDbTimeout(statement: DbExecStatement): boolean {
+  if (typeof statement === "string") return false;
+  const timeoutMs = Number(statement.timeoutMs);
+  return Number.isFinite(timeoutMs) && timeoutMs > 0;
+}
+
+function postgresStatementTimeoutMs(clientTimeoutMs: number): number {
+  const safeTimeoutMs = Math.max(
+    1,
+    Math.min(POSTGRES_MAX_INT, Math.floor(clientTimeoutMs)),
+  );
+  const headroomMs = Math.min(
+    POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS,
+    Math.max(1, Math.floor(safeTimeoutMs * 0.1)),
+  );
+  return Math.max(1, safeTimeoutMs - headroomMs);
+}
+
 export function dbExecQueryBudget(statement: DbExecStatement): {
   timeoutMs: number;
   maxAttempts: number;
@@ -1229,6 +1250,36 @@ async function createDbExecInternal(
           rowsAffected: result.rowCount ?? 0,
         };
       }
+      async function queryNeonClientWithStatementTimeout(
+        client: any,
+        sql: Parameters<DbExec["execute"]>[0],
+        remainingMs: () => number,
+        markClientForDiscard: () => void,
+      ) {
+        const statementTimeoutMs = postgresStatementTimeoutMs(remainingMs());
+        await queryNeonClient(
+          client,
+          `SET statement_timeout = ${statementTimeoutMs}`,
+          remainingMs(),
+        );
+        try {
+          return await queryNeonClient(client, sql, remainingMs());
+        } finally {
+          try {
+            await queryNeonClient(
+              client,
+              "RESET statement_timeout",
+              remainingMs(),
+            );
+          } catch (err) {
+            markClientForDiscard();
+            console.warn(
+              "[db/neon] statement timeout reset failed; discarding connection:",
+              err instanceof Error ? err.message : err,
+            );
+          }
+        }
+      }
       return {
         async execute(sql) {
           const { timeoutMs, maxAttempts } = dbExecQueryBudget(sql);
@@ -1276,17 +1327,25 @@ async function createDbExecInternal(
               released = true;
               client.release(err);
             };
+            let discardClient = false;
 
             try {
-              const result = await queryNeonClient(
-                client,
-                sql,
-                remainingAttemptMs(),
-              );
-              releaseClient();
+              const result = hasExplicitDbTimeout(sql)
+                ? await queryNeonClientWithStatementTimeout(
+                    client,
+                    sql,
+                    remainingAttemptMs,
+                    () => {
+                      discardClient = true;
+                    },
+                  )
+                : await queryNeonClient(client, sql, remainingAttemptMs());
+              releaseClient(discardClient ? true : undefined);
               return result;
             } catch (err) {
-              releaseClient(isConnectionError(err) ? true : undefined);
+              releaseClient(
+                discardClient || isConnectionError(err) ? true : undefined,
+              );
               throw err;
             }
           }, maxAttempts);
@@ -1317,7 +1376,23 @@ async function createDbExecInternal(
               client.release(err);
             };
             const tx: DbExec = {
-              execute: (sql) => queryNeonClient(client, sql),
+              execute: async (sql) => {
+                if (!hasExplicitDbTimeout(sql)) {
+                  return queryNeonClient(client, sql);
+                }
+                const { timeoutMs } = dbExecQueryBudget(sql);
+                const startedAt = Date.now();
+                const remainingMs = () =>
+                  Math.max(1, timeoutMs - (Date.now() - startedAt));
+                const statementTimeoutMs =
+                  postgresStatementTimeoutMs(remainingMs());
+                await queryNeonClient(
+                  client,
+                  `SET LOCAL statement_timeout = ${statementTimeoutMs}`,
+                  remainingMs(),
+                );
+                return queryNeonClient(client, sql, remainingMs());
+              },
             };
             try {
               await queryNeonClient(client, "BEGIN");