@agent-native/core 0.131.5 → 0.131.7

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

@@ -174,7 +174,8 @@ const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 //   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)
+// < RUN_NO_PROGRESS_HARD_TIMEOUT_MS              (150s, run-manager.ts)
+// < BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS            (210s, 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:
@@ -184,7 +185,7 @@ const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 // 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;
+export const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 210_000;
 
 // Per-TURN follow budgets. BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS above is a
 // per-idle-WINDOW bound and resets every time a successor run appears, so a
@@ -1773,6 +1774,11 @@ export function createAgentChatAdapter(
       let lastAutoContinueReason: string | null = null;
       let lastRecoverableRunError: AgentAutoContinueErrorInfo | null = null;
       let lastActivityTrail: AgentActivityTrailEntry[] = [];
+      let backgroundFollowNoProgressDetaches = 0;
+      let backgroundFollowConsecutiveNoProgressDetaches = 0;
+      let backgroundFollowLastDetachReason: string | null = null;
+      let backgroundFollowLastDetachWasClientWatchdog: boolean | null = null;
+      let backgroundFollowLastServerProgressAt: number | null = null;
       const attemptedRunIds: string[] = [];
       let authRecoveryAttempted = false;
       let continuationToolCallCounter = 0;
@@ -1828,6 +1834,21 @@ export function createAgentChatAdapter(
             ? `activity_trail: ${formatActivityTrail(lastActivityTrail)}`
             : "",
           `total_transient_continuations: ${totalTransientContinuationAttempts}`,
+          `background_follow_no_progress_detaches: ${backgroundFollowNoProgressDetaches}`,
+          `background_follow_consecutive_no_progress_detaches: ${backgroundFollowConsecutiveNoProgressDetaches}`,
+          backgroundFollowLastDetachReason
+            ? `background_follow_last_detach_reason: ${backgroundFollowLastDetachReason}`
+            : "",
+          backgroundFollowLastDetachWasClientWatchdog !== null
+            ? `background_follow_last_detach_source: ${
+                backgroundFollowLastDetachWasClientWatchdog
+                  ? "client_watchdog"
+                  : "server"
+              }`
+            : "",
+          backgroundFollowLastServerProgressAt !== null
+            ? `background_follow_last_server_progress_at: ${backgroundFollowLastServerProgressAt}`
+            : "",
         ]
           .filter(Boolean)
           .join("\n");
@@ -2451,6 +2472,8 @@ export function createAgentChatAdapter(
         > {
           if (!runId) return "gone";
           let attached = false;
+          backgroundFollowLastDetachReason = null;
+          backgroundFollowLastDetachWasClientWatchdog = null;
           try {
             const eventsRes = await fetch(
               `${apiUrl}/runs/${encodeURIComponent(runId)}/events?after=${lastSeq + 1}`,
@@ -2488,6 +2511,9 @@ export function createAgentChatAdapter(
             }
             if (attachErr instanceof AgentAutoContinueSignal) {
               lastAutoContinueReason = attachErr.reason;
+              backgroundFollowLastDetachReason = attachErr.reason;
+              backgroundFollowLastDetachWasClientWatchdog =
+                attachErr.clientWatchdog;
               if (attachErr.activityTrail.length > 0) {
                 lastActivityTrail = [...attachErr.activityTrail];
               }
@@ -2641,6 +2667,9 @@ export function createAgentChatAdapter(
 
           let idleSince: number | null = null;
           let lastSeenActive: Record<string, unknown> | null = null;
+          let lastObservedActiveRunId = runId;
+          let lastObservedServerProgressAt: number | null = null;
+          let noProgressPollAttempts = 0;
           // Terminal runs already replayed once. A recoverable terminal error
           // event replays as an auto-continue signal (isAutoRecoverableError),
           // which used to re-drive a POST in foreground mode. In follow mode
@@ -2826,6 +2855,25 @@ export function createAgentChatAdapter(
                 });
                 return "completed";
               }
+              const activeProgressAt =
+                typeof active?.lastProgressAt === "number" &&
+                Number.isFinite(active.lastProgressAt)
+                  ? active.lastProgressAt
+                  : null;
+              const runChanged = activeRunId !== lastObservedActiveRunId;
+              const serverProgressAdvanced =
+                activeProgressAt !== null &&
+                lastObservedServerProgressAt !== null &&
+                activeProgressAt > lastObservedServerProgressAt;
+              lastObservedActiveRunId = activeRunId;
+              if (activeProgressAt !== null) {
+                lastObservedServerProgressAt =
+                  lastObservedServerProgressAt === null || runChanged
+                    ? activeProgressAt
+                    : Math.max(lastObservedServerProgressAt, activeProgressAt);
+                backgroundFollowLastServerProgressAt =
+                  lastObservedServerProgressAt;
+              }
               // Server-authoritative "silently deferred, recovery in
               // progress" signal (see `awaitingRedispatch` on
               // `getActiveRunForThreadAsync`, run-manager.ts): a
@@ -2839,19 +2887,29 @@ export function createAgentChatAdapter(
               // 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), or the server told us recovery is
-                // in-flight — the run demonstrably exists; keep following
-                // with a fresh idle window.
+              const madeProgress = runChanged || serverProgressAdvanced;
+              if (madeProgress || awaitingRedispatch) {
+                // Only server-authoritative progress resets the idle window:
+                // a successor run or a newer lastProgressAt timestamp. Raw
+                // sequence advancement is not enough — keepalives and retry
+                // `clear` events are sequenced too, but the run manager
+                // deliberately excludes both from lastProgressAt because they
+                // do not move the user's task forward.
                 idleSince = null;
+                noProgressPollAttempts = 0;
+                backgroundFollowConsecutiveNoProgressDetaches = 0;
               } else {
-                // "gone": /runs/active reported the run but its event stream
-                // 404s (reaped row / cross-isolate lag). Let the idle window
-                // ACCUMULATE instead of resetting, so a persistently
-                // inconsistent state still terminates loudly instead of
-                // hot-looping for the whole reconnect window.
+                // An absent stream and an attached stream with no newer
+                // server-authoritative progress are the same no-progress
+                // observation. Keep accumulating one idle window and back off
+                // repeat attaches so a broken SQL tail cannot become a
+                // reconnect storm.
                 if (idleSince === null) idleSince = Date.now();
+                noProgressPollAttempts += 1;
+                if (attach === "detached") {
+                  backgroundFollowNoProgressDetaches += 1;
+                  backgroundFollowConsecutiveNoProgressDetaches += 1;
+                }
                 if (
                   Date.now() - idleSince >=
                   BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS
@@ -2889,7 +2947,27 @@ export function createAgentChatAdapter(
                 return "completed";
               }
             }
-            await delay(BACKGROUND_FOLLOW_POLL_INTERVAL_MS, abortSignal);
+            const backedOffPollDelayMs =
+              noProgressPollAttempts > 0
+                ? Math.min(
+                    BACKGROUND_FOLLOW_POLL_INTERVAL_MS *
+                      2 ** Math.min(noProgressPollAttempts - 1, 3),
+                    5_000,
+                  )
+                : BACKGROUND_FOLLOW_POLL_INTERVAL_MS;
+            const idleRemainingMs =
+              idleSince === null
+                ? Number.POSITIVE_INFINITY
+                : Math.max(
+                    0,
+                    BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS -
+                      (Date.now() - idleSince),
+                  );
+            const nextPollDelayMs = Math.min(
+              backedOffPollDelayMs,
+              idleRemainingMs,
+            );
+            await delay(nextPollDelayMs, abortSignal);
             if (abortSignal.aborted) {
               clearActiveRun();
               return "completed";

package/src/client/resources/McpIntegrationDialog.tsx

@@ -762,14 +762,16 @@ export function McpIntegrationDialog({
               </div>
             </div>
             <div className="flex shrink-0 items-center justify-between gap-2 border-t border-border px-7 py-4">
-              <button
-                type="button"
-                onClick={runTest}
-                disabled={!url.trim() || busy}
-                className="rounded-md border border-border bg-background px-3 py-1.5 text-[12px] font-medium text-foreground hover:bg-accent disabled:pointer-events-none disabled:opacity-40"
-              >
-                {t("mcpIntegrations.test")}
-              </button>
+              {!selectedRequiresSetup && (
+                <button
+                  type="button"
+                  onClick={runTest}
+                  disabled={!url.trim() || busy}
+                  className="rounded-md border border-border bg-background px-3 py-1.5 text-[12px] font-medium text-foreground hover:bg-accent disabled:pointer-events-none disabled:opacity-40"
+                >
+                  {t("mcpIntegrations.test")}
+                </button>
+              )}
               {!selected ? (
                 <button
                   type="button"
@@ -790,7 +792,7 @@ export function McpIntegrationDialog({
                     href={selected.docsUrl}
                     target="_blank"
                     rel="noopener noreferrer"
-                    className="inline-flex min-w-[92px] items-center justify-center gap-1.5 rounded-md bg-primary px-3 py-1.5 text-[12px] font-medium text-primary-foreground hover:bg-primary/90"
+                    className="ms-auto inline-flex min-w-[92px] items-center justify-center gap-1.5 rounded-md bg-primary px-3 py-1.5 text-[12px] font-medium text-primary-foreground hover:bg-primary/90"
                   >
                     {t("mcpIntegrations.viewSetup")}
                     <IconExternalLink className="h-3 w-3" />

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

@@ -233,7 +233,12 @@ export function sseInFlightWorkDelta(ev: SSEEvent): number {
   if (ev.type === "tool_done") return -1;
   if (ev.type === "agent_call") {
     if (ev.status === "start") return 1;
-    if (ev.status === "done" || ev.status === "error") return -1;
+    if (
+      ev.status === "done" ||
+      ev.status === "pending" ||
+      ev.status === "error"
+    )
+      return -1;
   }
   return 0;
 }
@@ -1455,7 +1460,11 @@ export function processEvent(
         args: {},
         activity: true,
       });
-    } else if (ev.status === "done" || ev.status === "error") {
+    } else if (
+      ev.status === "done" ||
+      ev.status === "pending" ||
+      ev.status === "error"
+    ) {
       for (let i = content.length - 1; i >= 0; i--) {
         const part = content[i];
         if (
@@ -1464,7 +1473,12 @@ export function processEvent(
           (!ev.agentCallId || part.toolCallId === ev.agentCallId) &&
           part.result === undefined
         ) {
-          part.result = ev.status === "error" ? "Error calling agent" : "Done";
+          part.result =
+            ev.status === "error"
+              ? "Error calling agent"
+              : ev.status === "pending"
+                ? "Remote agent task is still pending"
+                : "Done";
           part.structuredMeta = {
             ...part.structuredMeta,
             ...(ev.durationMs != null

package/src/db/client.ts

@@ -652,6 +652,7 @@ function sqlAndArgs(sql: DbExecStatement): {
 }
 
 const POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS = 250;
+const POSTGRES_STATEMENT_TIMEOUT_RESET_MS = 5_000;
 const POSTGRES_MAX_INT = 2_147_483_647;
 
 function hasExplicitDbTimeout(statement: DbExecStatement): boolean {
@@ -1225,22 +1226,15 @@ async function createDbExecInternal(
     // with CONNECT_TIMEOUT. The serverless Pool handles wake-up transparently
     // and keeps the same `pg`-compatible query(...) interface we need here.
     if (isNeonUrl(url)) {
-      const { Pool, neonConfig } = await import("@neondatabase/serverless");
-      // In the durable background-function worker, route pool queries over Neon's
-      // stateless HTTP transport instead of a long-lived WebSocket. A frozen/thawed
-      // bg-fn instance can leave the pool's WebSocket connections half-dead, so
-      // queries after the first burst stall on connect()/query() — observed: the
-      // analytics worker stalls right after model resolution and never claims.
-      // HTTP-per-query (poolQueryViaFetch) has no persistent socket to die; the
-      // foreground keeps the WebSocket pool. See the bg-fn execute branch below.
+      const { Pool, neon } = await import("@neondatabase/serverless");
+      // A frozen/thawed background function can retain half-dead WebSocket
+      // connections, so its direct executions use stateless Neon HTTP instead.
+      // The foreground and transaction surface keep the WebSocket pool.
       const bgHttp = isBackgroundFunctionPoolContext();
-      if (bgHttp) {
-        (neonConfig as { poolQueryViaFetch?: boolean }).poolQueryViaFetch =
-          true;
-      }
       const pool = new Pool({ connectionString: url, max: neonPoolMax() });
       attachNeonPoolErrorLogger(pool);
       if (trackSingletonResources) _neonPool = pool;
+      const httpSql = bgHttp ? neon(url, { fullResults: true }) : null;
       async function queryNeonClient(
         client: any,
         sql: Parameters<DbExec["execute"]>[0],
@@ -1282,7 +1276,7 @@ async function createDbExecInternal(
             await queryNeonClient(
               client,
               "RESET statement_timeout",
-              remainingMs(),
+              Math.max(remainingMs(), POSTGRES_STATEMENT_TIMEOUT_RESET_MS),
             );
           } catch (err) {
             markClientForDiscard();
@@ -1293,17 +1287,63 @@ async function createDbExecInternal(
           }
         }
       }
+      async function queryNeonHttp(sql: Parameters<DbExec["execute"]>[0]) {
+        if (!httpSql) {
+          throw new Error("Neon HTTP query used outside a background function");
+        }
+        const { rawSql, args } = sqlAndArgs(sql);
+        const { timeoutMs } = dbExecQueryBudget(sql);
+        const pgSql = sqliteToPostgresParams(rawSql);
+        const controller = new AbortController();
+        const run = async () => {
+          if (!hasExplicitDbTimeout(sql)) {
+            return httpSql.query(pgSql, args as any[], {
+              fetchOptions: { signal: controller.signal },
+            });
+          }
+          const statementDeadlineMs =
+            Date.now() + postgresStatementTimeoutMs(timeoutMs);
+          const results = await httpSql.transaction(
+            [
+              httpSql.query(
+                `SELECT set_config(
+                  'statement_timeout',
+                  GREATEST(
+                    1,
+                    $1::bigint -
+                      FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint
+                  )::text,
+                  true
+                )`,
+                [statementDeadlineMs],
+              ),
+              httpSql.query(pgSql, args as any[]),
+            ],
+            { fetchOptions: { signal: controller.signal } },
+          );
+          return results[1];
+        };
+        const result = await withDbTimeout("query", run, timeoutMs, () =>
+          controller.abort(),
+        );
+        return {
+          rows: result.rows,
+          rowsAffected: result.rowCount ?? 0,
+        };
+      }
       return {
         async execute(sql) {
           const { timeoutMs, maxAttempts } = dbExecQueryBudget(sql);
           if (bgHttp) {
-            // HTTP-per-query path (poolQueryViaFetch=true): no pool.connect(), no
-            // persistent socket to stall. queryNeonClient calls pool.query(),
-            // which the driver routes over HTTP when poolQueryViaFetch is set.
+            // HTTP-per-query path: no pool.connect() and no persistent socket
+            // to survive a background-function freeze. Explicitly budgeted
+            // statements run with SET LOCAL inside the same HTTP transaction,
+            // so the server cancels the SQL before the fetch deadline without
+            // leaking session state into Neon's pooled backends.
             return retryOnConnectionError<{
               rows: unknown[];
               rowsAffected: number;
-            }>(() => queryNeonClient(pool, sql), maxAttempts);
+            }>(() => queryNeonHttp(sql), maxAttempts);
           }
           const result = await retryOnConnectionError<{
             rows: unknown[];

package/src/guards/no-env-credentials.ts

@@ -65,6 +65,8 @@ const ALLOWLIST_EXACT = new Set([
   "PORT",
   "HOST",
   "SECRETS_ENCRYPTION_KEY",
+  "WORKSPACE_SECRETS_ENCRYPTION_KEY",
+  "WORKSPACE_SECRETS_ENCRYPTION_KEY_PREVIOUS",
 ]);
 
 const ALLOWLIST_PREFIX = [

package/src/integrations/adapters/slack.ts

@@ -2067,7 +2067,9 @@ function createSlackRunProgress(
             ? "in_progress"
             : event.status === "done"
               ? "complete"
-              : "error";
+              : event.status === "pending"
+                ? "in_progress"
+                : "error";
         const title = delegatedTaskTitle(event.agent);
         tasks.set(id, { title, status });
         await append({
@@ -2075,9 +2077,12 @@ function createSlackRunProgress(
           id,
           title,
           status,
-          ...(event.status === "start"
+          ...(event.status === "start" || event.status === "pending"
             ? {
-                details: `I’m contacting ${shortTaskTitle(event.agent)} for an answer.`,
+                details:
+                  event.status === "pending"
+                    ? `${shortTaskTitle(event.agent)} is still working and will need another status check.`
+                    : `I’m contacting ${shortTaskTitle(event.agent)} for an answer.`,
               }
             : {}),
         });

package/src/localization/default-messages.ts

@@ -316,6 +316,50 @@ const messages = {
       unknownPlatform: "unknown",
       attemptsCount: "{{count}} attempts",
       noErrorMessage: "(no error message)",
+      threadDebugInspectFailure: "Inspect failed run",
+      threadDebugFailureCode: "Failure code",
+      threadDebugTerminalReason: "Terminal reason",
+      threadDebugDispatchMode: "Dispatch mode",
+      threadDebugLastStage: "Last stage",
+      threadDebugDuration: "Duration",
+      threadDebugLastProgress: "Last progress",
+      threadDebugTitle: "Thread Debug",
+      threadDebugDescription:
+        "Inspect failed agent runs, persisted threads, run events, and AI internals.",
+      threadDebugFailedRuns: "Failed runs",
+      threadDebugThreads: "Threads",
+      threadDebugSource: "Source",
+      threadDebugAllSources: "All sources",
+      threadDebugOwner: "Owner email",
+      threadDebugStatus: "Status",
+      threadDebugAllStatuses: "All statuses",
+      threadDebugErrored: "Errored",
+      threadDebugAborted: "Aborted",
+      threadDebugTruncated: "Truncated",
+      threadDebugRange: "Time range",
+      threadDebugRange24h: "Last 24 hours",
+      threadDebugRange7d: "Last 7 days",
+      threadDebugRange30d: "Last 30 days",
+      threadDebugFailureResults: "failed runs",
+      threadDebugCurrentScope: "current scope",
+      threadDebugPartialResults: "Partial results",
+      threadDebugUnavailableSources: "Unavailable sources:",
+      threadDebugDisconnected: "disconnected",
+      threadDebugUnsupported: "unsupported",
+      threadDebugUnavailable: "unavailable",
+      threadDebugRefreshFailures: "Refresh failed runs",
+      threadDebugNoFailures: "No failed runs found.",
+      threadDebugCurrentDatabase: "Current Dispatch DB",
+      threadDebugSearchPlaceholder: "Search title, preview, messages, tools",
+      threadDebugSearch: "Search",
+      threadDebugLookupPlaceholder: "Paste thread or request/run ID",
+      threadDebugInspect: "Inspect",
+      threadDebugAdminScope: "admin scope",
+      threadDebugOwnScope: "own scope",
+      threadDebugResults: "results",
+      threadDebugRefreshThreads: "Refresh threads",
+      threadDebugNoThreads: "No threads found.",
+      threadDebugSelectPrompt: "Select a failed run or thread to inspect.",
       browserChatUnavailableTitle: "Browser chat session unavailable",
       browserChatUnavailableDescription:
         "Reconnect from the Agent-Native browser extension.",

package/src/observability/traces.ts

@@ -1,4 +1,7 @@
-import type { AgentLoopUsage } from "../agent/production-agent.js";
+import type {
+  AgentLoopOutcome,
+  AgentLoopUsage,
+} from "../agent/production-agent.js";
 import type { AgentChatEvent, AgentToolInput } from "../agent/types.js";
 import { type AgentSpan, endAgentSpan, startAgentSpan } from "./tracing.js";
 import { trackingIdentityProperties } from "./tracking-identity.js";
@@ -100,6 +103,7 @@ function emitLlmGenerationTrackingEvent(args: {
   failedTools: number;
   tools: GenerationToolCall[];
   toolsTruncated: boolean;
+  terminalOutcome?: AgentLoopOutcome;
   delegation?: {
     protocol: "a2a" | "mcp";
     callerApp?: string;
@@ -149,6 +153,16 @@ function emitLlmGenerationTrackingEvent(args: {
     failed_tools: args.failedTools,
     tools: args.tools,
     tools_truncated: args.toolsTruncated,
+    terminal_state: args.terminalOutcome?.state,
+    terminal_code:
+      args.terminalOutcome?.state === "failed" ||
+      args.terminalOutcome?.state === "input_required"
+        ? args.terminalOutcome.code
+        : undefined,
+    terminal_retryable:
+      args.terminalOutcome?.state === "failed"
+        ? args.terminalOutcome.retryable
+        : undefined,
     delegated: args.delegation ? true : undefined,
     delegation_protocol: args.delegation?.protocol,
     caller_app: args.delegation?.callerApp,
@@ -269,6 +283,7 @@ export async function instrumentAgentLoop(opts: {
     send: (event: AgentChatEvent) => void;
     signal: AbortSignal;
     onUsage?: (usage: AgentLoopUsage) => void;
+    onOutcome?: (outcome: AgentLoopOutcome) => void;
     providerOptions?: any;
     runId?: string;
   }) => Promise<AgentLoopUsage>;
@@ -282,6 +297,7 @@ export async function instrumentAgentLoop(opts: {
     send: (event: AgentChatEvent) => void;
     signal: AbortSignal;
     onUsage?: (usage: AgentLoopUsage) => void;
+    onOutcome?: (outcome: AgentLoopOutcome) => void;
     providerOptions?: any;
     runId?: string;
   };
@@ -381,9 +397,62 @@ export async function instrumentAgentLoop(opts: {
   // Track in-flight OTel tool spans so they're all ended even if the loop
   // throws before a matching `tool_done` arrives.
   const openOtelToolSpans = new Set<AgentSpan>();
+  let usage: AgentLoopUsage | undefined;
+  let runStatus: "success" | "error" = "success";
+  let errorMessage: string | null = null;
+  let runMetadata: Record<string, unknown> | null = opts.metadata ?? null;
+  let terminalOutcome: AgentLoopOutcome | undefined;
+
+  const instrumentedOutcome = (outcome: AgentLoopOutcome): void => {
+    terminalOutcome = outcome;
+    if (outcome.state === "completed") {
+      runStatus = "success";
+      errorMessage = null;
+    } else {
+      runStatus = "error";
+      errorMessage =
+        outcome.state === "canceled"
+          ? (outcome.message ?? "Agent run was canceled.")
+          : outcome.message;
+    }
+    runMetadata = {
+      ...(runMetadata ?? {}),
+      terminal_state: outcome.state,
+      ...("code" in outcome ? { terminal_code: outcome.code } : {}),
+      ...(outcome.state === "failed"
+        ? { terminal_retryable: outcome.retryable }
+        : {}),
+    };
+    try {
+      loopOpts.onOutcome?.(outcome);
+    } catch {
+      // Observability adapters cannot alter the agent run.
+    }
+  };
 
   const instrumentedSend = (event: AgentChatEvent): void => {
     try {
+      // Some guardrails intentionally stop the loop by emitting a terminal
+      // event and returning usage instead of throwing. Preserve that terminal
+      // state in telemetry so a tripwire/loop-limit/provider error cannot be
+      // counted as a successful delegated generation. A later clear/done means
+      // the wrapper recovered and finished cleanly, so reset in that case.
+      if (event.type === "clear" || event.type === "done") {
+        runStatus = "success";
+        errorMessage = null;
+      } else if (event.type === "error") {
+        runStatus = "error";
+        errorMessage = event.error;
+      } else if (event.type === "tripwire") {
+        runStatus = "error";
+        errorMessage = event.reason;
+      } else if (event.type === "loop_limit") {
+        runStatus = "error";
+        errorMessage = "Agent stopped at the loop limit";
+      } else if (event.type === "missing_api_key") {
+        runStatus = "error";
+        errorMessage = "Missing API key";
+      }
       if (event.type === "tool_start") {
         const counter = toolInvocationCounter++;
         const sid = spanId();
@@ -554,15 +623,12 @@ export async function instrumentAgentLoop(opts: {
     loopOpts.send(event);
   };
 
-  let usage: AgentLoopUsage | undefined;
-  let runStatus: "success" | "error" = "success";
-  let errorMessage: string | null = null;
-  let runMetadata: Record<string, unknown> | null = opts.metadata ?? null;
   try {
     usage = await runAgentLoop({
       ...loopOpts,
       runId,
       send: instrumentedSend,
+      onOutcome: instrumentedOutcome,
     });
   } catch (err: any) {
     const classification = opts.classifyError?.(err) ?? null;
@@ -727,6 +793,7 @@ export async function instrumentAgentLoop(opts: {
           .map(([, detail]) => detail),
         toolsTruncated:
           toolInvocationCounter > MAX_TRACKED_GENERATION_TOOL_CALLS,
+        terminalOutcome,
         delegation: opts.delegation,
         createdAt: runStart,
         experimentAssignments: opts.experimentAssignments,
@@ -811,6 +878,12 @@ export async function instrumentAgentLoop(opts: {
           "agent.input_tokens": usage?.inputTokens ?? 0,
           "agent.output_tokens": usage?.outputTokens ?? 0,
           "agent.cost_cents_x100": costCentsX100,
+          "agent.terminal_state": terminalOutcome?.state,
+          "agent.terminal_code":
+            terminalOutcome?.state === "failed" ||
+            terminalOutcome?.state === "input_required"
+              ? terminalOutcome.code
+              : undefined,
         },
       });
     } catch {