@agent-native/core 0.92.12 → 0.94.0

package/corpus/core/src/client/MultiTabAssistantChat.tsx

@@ -17,8 +17,9 @@ import React, {
 
 import { DEFAULT_MODEL } from "../agent/default-model.js";
 import {
-  getReasoningEffortOptionsForModel,
+  DEFAULT_REASONING_EFFORT,
   isReasoningEffort,
+  resolveReasoningEffortSelection,
   type ReasoningEffort,
 } from "../shared/reasoning-effort.js";
 import {
@@ -62,6 +63,7 @@ import { isTrustedFrameMessage } from "./frame.js";
 import { KeepTabOpenNotice } from "./KeepTabOpenNotice.js";
 import { RunStuckBanner } from "./RunStuckBanner.js";
 import { callAction } from "./use-action.js";
+import { useChangeVersion } from "./use-change-version.js";
 import {
   useChatThreads,
   type ChatThreadScope,
@@ -128,7 +130,10 @@ function readStoredModelSelection(key: string): ModelSelection | undefined {
     }
     const selection: ModelSelection = {
       model: parsed.model,
-      effort: isReasoningEffort(parsed.effort) ? parsed.effort : "auto",
+      effort: resolveReasoningEffortSelection(
+        parsed.model,
+        isReasoningEffort(parsed.effort) ? parsed.effort : undefined,
+      ),
     };
     if (typeof parsed.engine === "string") selection.engine = parsed.engine;
     return selection;
@@ -150,14 +155,12 @@ function resolveModelSelection(
 ): ModelSelection | undefined {
   if (!selection?.model) return undefined;
   if (groups.length === 0) {
-    const requestedEffort = selection.effort ?? "auto";
-    const effortOptions = getReasoningEffortOptionsForModel(selection.model);
     return {
       model: selection.model,
-      effort:
-        requestedEffort === "auto" || effortOptions.includes(requestedEffort)
-          ? requestedEffort
-          : "auto",
+      effort: resolveReasoningEffortSelection(
+        selection.model,
+        selection.effort,
+      ),
     };
   }
   const preferredGroup = groups.find(
@@ -175,12 +178,10 @@ function resolveModelSelection(
     preferredGroup?.engine ?? fallbackGroup?.engine ?? selection.engine;
   if (!engine && groups.length > 0) return undefined;
 
-  const requestedEffort = selection.effort ?? "auto";
-  const effortOptions = getReasoningEffortOptionsForModel(selection.model);
-  const effort =
-    requestedEffort === "auto" || effortOptions.includes(requestedEffort)
-      ? requestedEffort
-      : "auto";
+  const effort = resolveReasoningEffortSelection(
+    selection.model,
+    selection.effort,
+  );
   const resolved: ModelSelection = { model: selection.model, effort };
   if (engine) resolved.engine = engine;
   return resolved;
@@ -1199,12 +1200,7 @@ export function MultiTabAssistantChat({
       const threadId = activeThreadIdRef.current;
       if (!threadId) return;
       const existing = threadModelRef.current.get(threadId);
-      const existingEffort = existing?.effort ?? "auto";
-      const effortOptions = getReasoningEffortOptionsForModel(model);
-      const effort =
-        existingEffort === "auto" || effortOptions.includes(existingEffort)
-          ? existingEffort
-          : "auto";
+      const effort = resolveReasoningEffortSelection(model, existing?.effort);
       const selection = { model, engine, effort };
       threadModelRef.current.set(threadId, selection);
       persistModelSelection(selection);
@@ -1818,13 +1814,10 @@ export function MultiTabAssistantChat({
             g.models.includes(model),
           );
           if (matchedGroup) {
-            const requestedEffort = isReasoningEffort(effort) ? effort : "auto";
-            const effortOptions = getReasoningEffortOptionsForModel(model);
-            const selectedEffort =
-              requestedEffort === "auto" ||
-              effortOptions.includes(requestedEffort)
-                ? requestedEffort
-                : "auto";
+            const selectedEffort = resolveReasoningEffortSelection(
+              model,
+              isReasoningEffort(effort) ? effort : undefined,
+            );
             threadModelRef.current.set(threadId, {
               model,
               engine: matchedGroup.engine,
@@ -2246,13 +2239,15 @@ export function MultiTabAssistantChat({
     }
   }, []);
 
-  // Watch for agent-issued chat-command in application-state
+  // Watch for agent-issued chat-command in application-state. The shared
+  // DB-sync transport advances this key-specific version, so the command gets
+  // one initial read and one read per actual write instead of a 2s loop.
   const lastChatCommandRef = useRef(0);
+  const chatCommandVersion = useChangeVersion("app-state:chat-command");
   useEffect(() => {
     let stopped = false;
-    let timer: ReturnType<typeof setTimeout> | null = null;
 
-    async function pollChatCommand() {
+    async function readChatCommand() {
       if (stopped) return;
       try {
         const res = await fetch(
@@ -2268,9 +2263,9 @@ export function MultiTabAssistantChat({
             lastChatCommandRef.current = data.value.timestamp;
             const threadId = data.value.threadId as string;
             // Open the thread as a tab and focus it
-            if (!openTabIds.includes(threadId)) {
-              setOpenTabIds((prev) => [...prev, threadId]);
-            }
+            setOpenTabIds((prev) =>
+              prev.includes(threadId) ? prev : [...prev, threadId],
+            );
             switchThread(threadId);
             // Clear the command
             fetch(
@@ -2283,17 +2278,13 @@ export function MultiTabAssistantChat({
           }
         }
       } catch {}
-      if (!stopped) {
-        timer = setTimeout(pollChatCommand, 2000);
-      }
     }
 
-    pollChatCommand();
+    void readChatCommand();
     return () => {
       stopped = true;
-      if (timer) clearTimeout(timer);
     };
-  }, [openTabIds, switchThread]);
+  }, [chatCommandVersion, switchThread]);
 
   const handleGenerateTitle = useCallback(
     (threadId: string, message: string) => {
@@ -2728,6 +2719,9 @@ export function MultiTabAssistantChat({
                   apiUrl={apiUrl}
                   autoRetry
                   autoRetryOwnerId={browserTabId}
+                  hasInFlightWork={() =>
+                    chatRefs.current.get(tabId)?.hasInFlightWork() ?? false
+                  }
                   onRetry={() => {
                     const handle = chatRefs.current.get(tabId);
                     handle?.sendRecoveryMessage(
@@ -2772,7 +2766,9 @@ export function MultiTabAssistantChat({
                   onSlashCommand={handleSlashCommand}
                   selectedModel={modelSelection?.model}
                   selectedEngine={modelSelection?.engine}
-                  selectedEffort={modelSelection?.effort ?? "auto"}
+                  selectedEffort={
+                    modelSelection?.effort ?? DEFAULT_REASONING_EFFORT
+                  }
                   composerSlot={composerSlot}
                   defaultModel={defaultModel}
                   availableModels={availableModels}

package/corpus/core/src/client/RunStuckBanner.tsx

@@ -39,6 +39,19 @@ export interface RunStuckBannerProps {
    * itself only handles aborting the prior run.
    */
   onRetry?: (runId: string) => void;
+  /**
+   * Returns true when the run has a tool call or sub-agent (A2A) call that
+   * hasn't returned a result yet — typically backed by
+   * `chatHandle.hasInFlightWork()`. "No progress" for a stretch of time does
+   * not mean the run is dead: a long provider query or a cross-app `call
+   * agent` can legitimately emit nothing for minutes. When this returns
+   * true, Retry (which aborts the run) is hidden — aborting would destroy
+   * real in-flight work and re-execute the same long call from scratch.
+   * Only Cancel, an explicit destructive choice, remains available. Checked
+   * fresh on every render; omit to keep the unconditional Retry/Cancel
+   * behavior.
+   */
+  hasInFlightWork?: () => boolean;
   /**
    * Called whenever the stuck state transitions. Useful for surfacing
    * observability events (Sentry, PostHog) at the call site.
@@ -158,6 +171,7 @@ export function RunStuckBanner({
   onStuckStateChange,
   autoRetry = false,
   autoRetryOwnerId,
+  hasInFlightWork,
   className,
 }: RunStuckBannerProps) {
   const state = useRunStuckDetection({
@@ -175,6 +189,23 @@ export function RunStuckBanner({
   }
   const ownerId = autoRetryOwnerId ?? generatedOwnerIdRef.current;
   const backgroundWorkerStillAlive = isFreshBackgroundWorker(state);
+  // A live tool call or sub-agent (A2A) call means "no progress" is not the
+  // same as "dead" — the process is genuinely still doing the user's work.
+  // Retry aborts the run, so it must not be offered as the (implicitly
+  // safe-looking) primary action while real work is in flight; see the
+  // `hasInFlightWork` prop doc comment. Re-checked on every render (the
+  // underlying source mutates in place as tool/agent-call events stream in),
+  // which is why this is a function prop rather than a plain boolean.
+  //
+  // Two sources, combined disjunctively (either knowing = in flight): the
+  // SERVER-authoritative `state.hasInFlightWork` from /runs/active (the
+  // `in_flight_since` marker, correct even when the client's message list is
+  // stale after a reconnect/reader-mode replay) and the client-side proxy
+  // prop (unresolved tool-call parts in the local messages). Destroying live
+  // work is the failure we guard against, so we err toward "in flight" if
+  // either signal says so.
+  const inFlightWork =
+    state.hasInFlightWork === true || (hasInFlightWork?.() ?? false);
   // Server-continued runs are recovered by the SERVER (chained continuation
   // chunks + lost-handoff sweep); an automatic client abort would kill a live
   // server-chained run. Auto-retry is therefore disabled unconditionally for
@@ -229,6 +260,9 @@ export function RunStuckBanner({
       // comment on isServerContinuedDispatch above).
       isServerContinuedDispatch ||
       backgroundWorkerStillAlive ||
+      // A live tool/A2A call in flight — never auto-abort real work (see
+      // `inFlightWork` comment above).
+      inFlightWork ||
       !state.isStuck ||
       !state.runId ||
       busy.type !== "none" ||
@@ -264,6 +298,7 @@ export function RunStuckBanner({
     autoRetry,
     backgroundWorkerStillAlive,
     busy,
+    inFlightWork,
     isServerContinuedDispatch,
     onRetry,
     ownerId,
@@ -288,7 +323,10 @@ export function RunStuckBanner({
   };
 
   const handleRetry = async () => {
-    if (!state.runId || busy.type !== "none") return;
+    // Defense in depth: the button is hidden while `inFlightWork` is true
+    // (see render below), but guard the handler itself too so an abort can
+    // never be triggered against live work through this path.
+    if (!state.runId || busy.type !== "none" || inFlightWork) return;
     const runId = state.runId;
     setBusy({ type: "retry", runId });
     trackEvent("agent_chat_stuck_retry", {
@@ -305,6 +343,8 @@ export function RunStuckBanner({
   const stuckSeconds =
     state.stuckSinceMs != null ? Math.floor(state.stuckSinceMs / 1000) : null;
 
+  const stillWorking = backgroundWorkerStillAlive || inFlightWork;
+
   return (
     <div
       role="status"
@@ -322,41 +362,50 @@ export function RunStuckBanner({
       <div className="flex min-w-0 flex-1 flex-col gap-1.5">
         <div className="leading-snug">
           <span className="font-medium">
-            {backgroundWorkerStillAlive
+            {stillWorking
               ? "The agent is still working."
               : "This chat looks stuck."}
           </span>{" "}
           <span className="text-muted-foreground">
             No progress
             {stuckSeconds != null ? ` for ${stuckSeconds}s` : ""}.{" "}
-            {backgroundWorkerStillAlive
-              ? "The background worker is still alive; large updates can take a few minutes."
-              : "The agent may have hit a server timeout or lost its connection."}
+            {inFlightWork
+              ? "It's waiting on a call to another app or a long tool — canceling will stop that work."
+              : backgroundWorkerStillAlive
+                ? "The background worker is still alive; large updates can take a few minutes."
+                : "The agent may have hit a server timeout or lost its connection."}
             {autoRetry && busyType === "retry"
               ? " Retrying automatically now."
               : ""}
           </span>
         </div>
         <div className="flex flex-wrap items-center gap-2">
-          <button
-            type="button"
-            onClick={handleRetry}
-            disabled={busyType !== "none"}
-            className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md bg-foreground px-2.5 text-[11px] font-medium text-background transition-colors hover:bg-foreground/90 disabled:cursor-not-allowed disabled:opacity-60"
-          >
-            {busyType === "retry" ? (
-              <IconLoader2
-                size={12}
-                className="animate-spin"
-                aria-hidden="true"
-              />
-            ) : null}
-            Retry
-          </button>
+          {inFlightWork ? null : (
+            <button
+              type="button"
+              onClick={handleRetry}
+              disabled={busyType !== "none"}
+              className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md bg-foreground px-2.5 text-[11px] font-medium text-background transition-colors hover:bg-foreground/90 disabled:cursor-not-allowed disabled:opacity-60"
+            >
+              {busyType === "retry" ? (
+                <IconLoader2
+                  size={12}
+                  className="animate-spin"
+                  aria-hidden="true"
+                />
+              ) : null}
+              Retry
+            </button>
+          )}
           <button
             type="button"
             onClick={handleCancel}
             disabled={busyType !== "none"}
+            title={
+              inFlightWork
+                ? "Stop the in-progress run. Work that hasn't finished will be lost."
+                : undefined
+            }
             className="inline-flex h-7 cursor-pointer items-center gap-1.5 rounded-md border border-border bg-background px-2.5 text-[11px] font-medium text-foreground transition-colors hover:bg-accent disabled:cursor-not-allowed disabled:opacity-60"
           >
             {busyType === "cancel" ? (

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -38,7 +38,9 @@ export type AgentChatSurfaceKind =
    */
   | "app"
   /** Chat rendered by the outer local dev frame, outside the app iframe. */
-  | "dev-frame";
+  | "dev-frame"
+  /** Chat hosted by Desktop for a local app with explicit code access. */
+  | "desktop";
 
 type AdapterHistoryMessage = {
   role: "user" | "assistant";
@@ -154,7 +156,27 @@ const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 // the 25s grace plus sweep/DB latency. This stays below the background
 // reconnect stuck threshold, but gives the server-owned recovery brain time to
 // surface the successor or terminal errored run before the client reports idle.
-const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150_000;
+//
+// THREE-SITE INVARIANT (keep in lockstep with run-store.ts and
+// agent-chat-plugin.ts — see `UNCLAIMED_BACKGROUND_RUN_FAST_SWEEP_MS`'s doc
+// comment in run-store.ts for the full derivation): a `chainServerDrivenContinuation`
+// deferral (server/production-agent.ts) leaves a successor row `running` with
+// no live worker until a sweep redispatches it. The budget is a derived
+// chain, each bound comfortably inside the next:
+//   UNCLAIMED_BACKGROUND_RUN_GRACE_MS            (25s)
+// + UNCLAIMED_BACKGROUND_RUN_FAST_SWEEP_MS       (20s)
+// = ~45-65s worst-case time-to-first-redispatch-attempt
+// < BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS            (150s, this constant)
+// < UNCLAIMED_BACKGROUND_RUN_REDISPATCH_BOUND_MS (300s, run-store.ts)
+// On top of that margin, the follow loop below never counts a tick against
+// this timeout at all while `/runs/active` reports `awaitingRedispatch:
+// true` — a server-authoritative "known deferred, recovery in progress"
+// signal, not a guess — so this timeout is a backstop for a genuinely lost
+// run, not the primary mechanism racing the sweep. Do NOT raise this value to
+// paper over a slow sweep; fix the sweep timing (run-store.ts /
+// agent-chat-plugin.ts) instead, and keep this comment's inequality chain
+// accurate if any of the four numbers change.
+export const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150_000;
 
 /**
  * User-facing copy for the server's background terminal reasons
@@ -2455,10 +2477,24 @@ export function createAgentChatAdapter(
               if (isTerminal) {
                 replayedTerminalRunIds.add(activeRunId);
               }
-              if (attach === "detached") {
+              // Server-authoritative "silently deferred, recovery in
+              // progress" signal (see `awaitingRedispatch` on
+              // `getActiveRunForThreadAsync`, run-manager.ts): a
+              // `chainServerDrivenContinuation` successor still inside
+              // `UNCLAIMED_BACKGROUND_RUN_REDISPATCH_BOUND_MS`, being
+              // redispatched by the server's fast/slow sweeps. This is known
+              // to demonstrably exist — same as a "detached" attach — so
+              // treat it identically and never accumulate idle time against
+              // it. Once the server's own bound is exceeded (or the row is
+              // claimed/terminal) this flips false and normal idle accounting
+              // resumes, so a truly stuck deferral still fails loud via the
+              // existing timeout below.
+              const awaitingRedispatch = active?.awaitingRedispatch === true;
+              if (attach === "detached" || awaitingRedispatch) {
                 // We really attached to a live stream (chunk boundary or
-                // transport blip) — the run demonstrably exists; keep
-                // following with a fresh idle window.
+                // transport blip), or the server told us recovery is
+                // in-flight — the run demonstrably exists; keep following
+                // with a fresh idle window.
                 idleSince = null;
               } else {
                 // "gone": /runs/active reported the run but its event stream
@@ -2903,7 +2939,20 @@ export function createAgentChatAdapter(
                     recoverable: true,
                     runId: activeRunId,
                   };
+                  // This is a terminal outcome for the attempted turn. Settle
+                  // both real in-flight calls and activity-only placeholders
+                  // before yielding the error; otherwise a prior "Preparing
+                  // run-code" event remains an unresolved tool card and the UI
+                  // keeps showing a spinner beside an already-terminal error.
+                  settleInterruptedToolCalls(content, undefined, {
+                    includeActivity: true,
+                  });
                   if (typeof window !== "undefined") {
+                    window.dispatchEvent(
+                      new CustomEvent("agent-chat:activity-clear", {
+                        detail: { tabId },
+                      }),
+                    );
                     window.dispatchEvent(
                       new CustomEvent("agent-chat:run-error", {
                         detail: { ...runError, tabId },

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

@@ -2,6 +2,7 @@ import { useQuery } from "@tanstack/react-query";
 import { useEffect, useSyncExternalStore } from "react";
 
 import { agentNativePath } from "./api-path.js";
+import { useChangeVersion } from "./use-change-version.js";
 
 export const APPEARANCE_PRESETS = [
   { id: "default", label: "Default", swatch: "hsl(220 10% 30%)" },
@@ -96,8 +97,10 @@ export function useAppearance(): AppearancePresetId {
 }
 
 /**
- * Polls `application_state.appearance` and applies the server-side preset on
- * the client. Use once near the root of the app (e.g. in your `AppLayout`).
+ * Reads `application_state.appearance` and applies the server-side preset on
+ * the client. The shared DB-sync transport advances the key-specific version
+ * after a write, so this performs one initial read and then only refetches when
+ * appearance actually changes.
  *
  * The agent's `change-appearance` action writes to `application_state.appearance`
  * server-side; this hook surfaces that write into the DOM `data-appearance`
@@ -105,8 +108,9 @@ export function useAppearance(): AppearancePresetId {
  * choice persists across reloads.
  */
 export function useAppearanceSync(): void {
+  const appearanceVersion = useChangeVersion("app-state:appearance");
   const { data } = useQuery({
-    queryKey: ["agent-native", "appearance"],
+    queryKey: ["agent-native", "appearance", appearanceVersion],
     queryFn: async () => {
       const res = await fetch(
         agentNativePath("/_agent-native/application-state/appearance"),
@@ -115,8 +119,7 @@ export function useAppearanceSync(): void {
       if (!res.ok) return null;
       return (await res.json()) as { preset?: string } | null;
     },
-    refetchInterval: 4_000,
-    staleTime: 2_000,
+    staleTime: Infinity,
   });
   const serverPreset = data?.preset;
   useEffect(() => {

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

@@ -0,0 +1,22 @@
+import type { AutomationInvocationResult } from "../automation/index.js";
+import { callAction } from "./use-action.js";
+
+export interface InvokeConfiguredAutomationWorkflowInput {
+  readonly workflowId: string;
+  readonly input: Record<string, unknown>;
+  readonly idempotencyKey?: string;
+}
+
+/**
+ * Invoke an app-registered automation action without hand-writing a browser
+ * request. Apps may choose a custom action name when registering the runtime.
+ */
+export async function invokeConfiguredAutomationWorkflow(
+  input: InvokeConfiguredAutomationWorkflowInput,
+  options: { readonly actionName?: string } = {},
+): Promise<AutomationInvocationResult> {
+  return callAction<AutomationInvocationResult>(
+    options.actionName ?? "invoke-automation-workflow",
+    input,
+  );
+}