@agent-native/core 0.161.2 → 0.161.6

package/dist/agent/run-store.js

@@ -2357,6 +2357,8 @@ const RUN_OUTCOME_DAY_MS = 86_400_000;
  * every run id a user pasted into a bug report was gone before anyone looked.
  */
 const UNSUCCESSFUL_STATUS_SQL_LIST = `('errored', 'aborted', 'truncated')`;
+const RUN_OUTCOME_PRUNE_BATCH_LIMIT = 200;
+const RUN_OUTCOME_PRUNE_LOCK_KEY = "agent-native:run-outcome-prune";
 /**
  * Fold the terminal outcomes of the rows `cleanupOldRuns` is about to delete
  * into `agent_run_outcome_daily`, so success/failure RATES survive pruning even
@@ -2364,29 +2366,46 @@ const UNSUCCESSFUL_STATUS_SQL_LIST = `('errored', 'aborted', 'truncated')`;
  * covers exactly the unpruned ones, so a rate over any window is
  * `getRunOutcomeCounters()` plus the live rows — no gap, no double count.
  *
- * The DELETE ... RETURNING is the claim: concurrent cleanup calls can both
- * observe a row, but only the caller that deletes it receives it to roll up.
- * Grouping the returned rows in TypeScript avoids dialect-specific date SQL.
+ * Postgres callers take a transaction-scoped advisory lease before the claim.
+ * The bounded DELETE ... RETURNING is still the source of truth for which rows
+ * this invocation owns. Grouping the returned rows in TypeScript avoids
+ * dialect-specific date SQL.
  * Counter upserts run in the same transaction as the delete; a failed upsert
  * rolls back the claim so the source rows remain available for a retry.
  */
 async function pruneAndRollUpPrunedRunOutcomes(client, cutoff, erroredCutoff) {
     const prune = async (tx) => {
-        await tx.execute({
-            sql: `DELETE FROM agent_run_events WHERE run_id IN (
-        SELECT id FROM agent_runs
-        WHERE (status = 'completed' AND completed_at < ?)
-           OR (status IN ${UNSUCCESSFUL_STATUS_SQL_LIST} AND completed_at < ?)
-      )`,
-            args: [cutoff, erroredCutoff],
-        });
+        if (isPostgres()) {
+            const lockResult = await tx.execute({
+                sql: "SELECT pg_try_advisory_xact_lock(hashtextextended(?, 0::bigint)) AS acquired",
+                args: [RUN_OUTCOME_PRUNE_LOCK_KEY],
+            });
+            const acquired = lockResult.rows[0]?.acquired;
+            if (acquired !== true && acquired !== "t")
+                return;
+        }
         const { rows } = await tx.execute({
             sql: `DELETE FROM agent_runs
-            WHERE (status = 'completed' AND completed_at < ?)
-               OR (status IN ${UNSUCCESSFUL_STATUS_SQL_LIST} AND completed_at < ?)
-            RETURNING status, completed_at, terminal_reason`,
+            WHERE id IN (
+              SELECT id FROM agent_runs
+              WHERE (status = 'completed' AND completed_at < ?)
+                 OR (status IN ${UNSUCCESSFUL_STATUS_SQL_LIST} AND completed_at < ?)
+              ORDER BY completed_at ASC, id ASC
+              LIMIT ${RUN_OUTCOME_PRUNE_BATCH_LIMIT}
+            )
+            RETURNING id, status, completed_at, terminal_reason`,
             args: [cutoff, erroredCutoff],
         });
+        const runIds = rows
+            .map((row) => row.id)
+            .filter((id) => typeof id === "string");
+        if (runIds.length > 0) {
+            const placeholders = runIds.map(() => "?").join(", ");
+            await tx.execute({
+                sql: `DELETE FROM agent_run_events WHERE run_id IN (${placeholders})`,
+                args: runIds,
+            });
+        }
         const groups = new Map();
         for (const row of rows) {
             const outcome = row;
@@ -2470,7 +2489,8 @@ export async function getRunOutcomeCounters(options) {
  *  pruned at `olderThanMs`; errored/aborted/truncated runs are kept until
  *  `erroredOlderThanMs` (a longer window, falling back to `olderThanMs`) so
  *  their event log survives for cut-off pattern analysis via listErroredRuns. */
-export async function cleanupOldRuns(olderThanMs, erroredOlderThanMs) {
+let cleanupOldRunsInFlight;
+async function cleanupOldRunsInternal(olderThanMs, erroredOlderThanMs) {
     await ensureRunTables();
     const client = getDbExec();
     const cutoff = Date.now() - olderThanMs;
@@ -2567,6 +2587,23 @@ export async function cleanupOldRuns(olderThanMs, erroredOlderThanMs) {
     // counting the same source rows.
     await pruneAndRollUpPrunedRunOutcomes(client, cutoff, erroredCutoff);
 }
+/**
+ * Run cleanup is scheduled after every completed run, including completions
+ * from several concurrent requests in one isolate. Share one sweep locally;
+ * Postgres additionally serializes the durable prune across isolates.
+ */
+export function cleanupOldRuns(olderThanMs, erroredOlderThanMs) {
+    if (cleanupOldRunsInFlight)
+        return cleanupOldRunsInFlight;
+    const current = cleanupOldRunsInternal(olderThanMs, erroredOlderThanMs);
+    let settled;
+    settled = current.finally(() => {
+        if (cleanupOldRunsInFlight === settled)
+            cleanupOldRunsInFlight = undefined;
+    });
+    cleanupOldRunsInFlight = settled;
+    return settled;
+}
 /**
  * List recent unsuccessful runs (errored, aborted, and truncated) for cut-off
  * pattern analysis. Read-only, bounded, and ordered newest-first. Surfaced via

package/dist/agent/thread-data-builder.js

@@ -9,6 +9,13 @@ function isInternalContinuationError(event) {
     const msg = event.error.toLowerCase();
     if (code === "builder_gateway_error")
         return false;
+    // An explicit `recoverable: false` outranks the code and message inference
+    // below, matching `isRecoverableContinuationError`. The background
+    // no-progress breaker stops a turn while PRESERVING the underlying transient
+    // code, so reading the code instead of the flag drops the one error the user
+    // was supposed to see out of the persisted turn.
+    if (event.recoverable === false)
+        return false;
     return (event.recoverable === true ||
         code === "builder_gateway_timeout" ||
         // Carries what `msg.includes("stream ended")` below used to: a

package/dist/agent/types.d.ts

@@ -175,6 +175,16 @@ export interface AgentChatRequest {
          * boundary and refuses to chain past `MAX_BACKGROUND_RUN_CONTINUATIONS`.
          */
         continuationCount?: number;
+        /**
+         * Terminal error code the previous chunk failed with, plus how many chunks
+         * in a row have now ended on that same code having emitted no assistant
+         * text and no tool activity. Carried on the marker because each chunk is a
+         * separate invocation with no memory of the last one — without it the
+         * no-progress circuit breaker in `shouldChainBackgroundContinuation`
+         * cannot see a repeat at all.
+         */
+        noProgressErrorCode?: string;
+        noProgressCount?: number;
         /**
          * True when the dispatcher expects the self-POST to land in a real
          * Netlify `-background` function rather than the ~60s synchronous function.

package/dist/cli/code-agent-connector.js

@@ -163,6 +163,9 @@ class RemoteCodeAgentConnector {
                 ok: false,
                 error: err instanceof Error ? err.message : String(err),
             }));
+            if (result.ok === false) {
+                this.output.write(`Remote command ${command.id} failed: ${typeof result.error === "string" ? result.error : "Unknown connector error."}\n`);
+            }
             await this.postCommandResult(command, result);
         }
     }
@@ -334,7 +337,9 @@ class RemoteCodeAgentConnector {
                     commandId: command.id,
                     deviceId: this.config.deviceId,
                     relayUrl: this.relayUrl,
-                    ...(portalWorkspace ? { remoteRunId: run.id } : {}),
+                    ...(portalWorkspace && requestedRunId
+                        ? { remoteRunId: requestedRunId }
+                        : {}),
                 },
                 ...(portalWorkspace
                     ? {

package/dist/client/AssistantChat.d.ts

@@ -14,6 +14,7 @@ import { type ContentPart } from "./sse-event-processor.js";
 import type { ChatThreadScope, ChatThreadSnapshot } from "./use-chat-threads.js";
 export { AssistantMessageListErrorBoundary, AssistantUiStaleIndexErrorBoundary, assistantUiRecoverableRenderErrorKind, isAssistantUiRecoverableRenderError, isAssistantUiStaleIndexError, } from "./assistant-ui-recovery.js";
 export { displayableUserMessageText } from "./chat/message-components.js";
+export declare function shouldSuppressUnauthenticatedDesktopThreadRestore(surface: AgentChatSurfaceKind, status: number): boolean;
 type AssistantUiMessageResourceShape = {
     id: string;
     content: readonly unknown[];

package/dist/client/AssistantChat.js

@@ -44,6 +44,11 @@ import { useRunStuckDetection } from "./use-run-stuck-detection.js";
 import { cn } from "./utils.js";
 export { AssistantMessageListErrorBoundary, AssistantUiStaleIndexErrorBoundary, assistantUiRecoverableRenderErrorKind, isAssistantUiRecoverableRenderError, isAssistantUiStaleIndexError, } from "./assistant-ui-recovery.js";
 export { displayableUserMessageText } from "./chat/message-components.js";
+// Desktop chat mounts beside the parent identity gate, so an unauthenticated
+// relay is an expected empty state until that gate establishes a session.
+export function shouldSuppressUnauthenticatedDesktopThreadRestore(surface, status) {
+    return surface === "desktop" && (status === 401 || status === 403);
+}
 const useBrowserLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
 export function assistantUiMessageListStructureKey(messages) {
     return JSON.stringify(messages.map((message) => [
@@ -2654,7 +2659,11 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                     const res = await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}`);
                     if (!res.ok) {
                         if (!cancelled) {
-                            setThreadRestoreError(res.status === 404 ? "not-found" : "unavailable");
+                            setThreadRestoreError(shouldSuppressUnauthenticatedDesktopThreadRestore(agentChatSurface, res.status)
+                                ? null
+                                : res.status === 404
+                                    ? "not-found"
+                                    : "unavailable");
                         }
                         return;
                     }

package/dist/client/MultiTabAssistantChat.js

@@ -789,7 +789,11 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
         catch { }
     }, [subAgentNames, SUB_AGENT_NAMES_KEY]);
     // Open tabs — persisted to localStorage so they survive refresh.
-    const OPEN_TABS_KEY = `agent-chat-open-tabs${keyPrefix}`;
+    // Per-scope, for the same reason the active thread is: the tab list must
+    // follow the resource in view, so one resource's tabs never stay mounted
+    // (and rebroadcasting their run state) while another resource is open.
+    const scopeKeyPart = scope ? `:scope:${scope.type}:${scope.id}` : "";
+    const OPEN_TABS_KEY = `agent-chat-open-tabs${keyPrefix}${scopeKeyPart}`;
     const [openTabIds, setOpenTabIds] = useState(() => {
         if (!restoreActiveThread && activeThreadId) {
             for (const id of [activeThreadId])
@@ -814,7 +818,35 @@ export function MultiTabAssistantChat({ showTabBar = true, renderHeader, renderO
     const openTabIdsRef = useRef(openTabIds);
     openTabIdsRef.current = openTabIds;
     const initializedRef = useRef(false);
+    // Rehydrate open tabs when the scope flips. Read the new key before the
+    // persistence effect can write the current (now-wrong) tab list under it.
     const openTabsKeyRef = useRef(OPEN_TABS_KEY);
+    useEffect(() => {
+        if (openTabsKeyRef.current === OPEN_TABS_KEY)
+            return;
+        openTabsKeyRef.current = OPEN_TABS_KEY;
+        initializedRef.current = false;
+        if (!restoreActiveThread) {
+            setOpenTabIds(activeThreadId ? [activeThreadId] : []);
+            return;
+        }
+        try {
+            const saved = localStorage.getItem(OPEN_TABS_KEY);
+            if (saved) {
+                const parsed = JSON.parse(saved);
+                if (Array.isArray(parsed)) {
+                    for (const id of parsed)
+                        mountedTabsRef.current.add(id);
+                    setOpenTabIds(parsed);
+                    return;
+                }
+            }
+        }
+        catch {
+            // coercion-ok: malformed persisted tab data is an absent tab list.
+        }
+        setOpenTabIds([]);
+    }, [OPEN_TABS_KEY, activeThreadId, restoreActiveThread]);
     useBrowserLayoutEffect(() => {
         const nextScope = scope;
         if (!nextScope)

package/dist/client/sse-event-processor.js

@@ -473,6 +473,17 @@ async function readChunkWithProgressTimeout(reader, lastMeaningfulEventAt, noPro
 function isAutoRecoverableError(ev, errMsg) {
     const code = String(ev.errorCode ?? "").toLowerCase();
     const msg = errMsg.toLowerCase();
+    // An explicit `recoverable: false` outranks EVERY inference below — the code
+    // list as well as the message sniff — matching the server's own precedence in
+    // `isRecoverableContinuationError`. The repeat guards stop a turn with a
+    // message that names the looping tool, so a stop on
+    // `list-workspace-connections` matched the "connection" sniff and
+    // auto-continued the very loop it was emitted to break; the background
+    // no-progress breaker stops one while PRESERVING the underlying transient
+    // code (so the failure stays diagnosable), so reading the code instead of the
+    // flag re-POSTs the exact chain the server just refused to continue.
+    if (ev.recoverable === false)
+        return false;
     if (code === "context_length_exceeded" ||
         code === "input_too_long" ||
         code.startsWith("credits-limit") ||
@@ -548,13 +559,6 @@ function isAutoRecoverableError(ev, errMsg) {
     }
     if (ev.recoverable === true)
         return true;
-    // An explicit flag outranks the message sniff below, which exists only for
-    // events that carry no flag at all. The repeat guards stop a turn with
-    // `recoverable: false` and a message that names the looping tool, so a stop
-    // on `list-workspace-connections` matched the "connection" sniff and
-    // auto-continued the very loop it was emitted to break.
-    if (ev.recoverable === false)
-        return false;
     if (msg.includes("daily gateway request cap"))
         return false;
     // The engine's structural verdict, checked after every terminal code above so

package/dist/client/use-chat-threads.js

@@ -467,9 +467,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     //   it; the server hasn't seen it yet because there's no POST anymore,
     //   the row gets written when the user sends a message.
     // - savedId is set but not on the current page → look it up directly. A
-    //   found thread stays active. An unavailable lookup keeps the saved id so
-    //   the detail surface can preserve cached state and offer recovery instead
-    //   of replacing a shared/reopened conversation with a blank local tab.
+    //   found thread stays active. An unavailable lookup keeps the saved id for
+    //   list-only readers and explicit routes, while a normal home surface drops
+    //   a dead local pointer instead of opening with a restore error.
     // - No savedId → synthesize a fresh local id (no POST; server creates the
     //   row on first message). The server may contain chats from another
     //   branch, preview, or project that shares the same user/database, so
@@ -511,12 +511,12 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const restoredIsUnavailable = restoredThread === null && lookupRestored && !restoredOnPage;
             const restoredBelongsElsewhere = Boolean(restoredThread &&
                 !threadCanStayVisibleInScope(restoredThread.scope ?? null, scopeRef.current));
-            // Keep the saved id when the direct lookup says 404. AssistantChat owns
-            // the detail restore and can show a retryable error while preserving any
-            // cached transcript or composer draft. Replacing the id here silently
-            // turns a shared/reopened conversation into a new blank chat after the
-            // slower lookup finishes.
-            const restoredNeedsReplacement = restoredBelongsElsewhere;
+            // A missing saved id is stale local UI state on a normal home surface,
+            // not a reason to show an error above a fresh composer. Preserve it for
+            // explicit routes and list-only readers, where the caller still owns
+            // recovery for a deliberately selected thread.
+            const restoredNeedsReplacement = restoredBelongsElsewhere ||
+                (restoredIsUnavailable && autoCreate && !routeControlsActiveThread);
             if (restoredNeedsReplacement)
                 setActiveThreadId(null);
             const savedId = restoredNeedsReplacement ? null : restoredId;

package/dist/db/client.js

@@ -1258,7 +1258,12 @@ async function createDbExecInternal(config = {}, trackSingletonResources = false
                 const { rawSql, args } = sqlAndArgs(sql);
                 const { timeoutMs } = dbExecQueryBudget(sql);
                 const pgSql = sqliteToPostgresParams(rawSql);
-                const result = await withDbTimeout("query", () => client.query(pgSql, args), timeoutOverrideMs ?? timeoutMs);
+                // Neon only accepts multiple SQL commands through its simple protocol;
+                // the transaction start has no parameters, so use that overload.
+                const runQuery = () => args.length === 0 && rawSql.includes(";")
+                    ? client.query(pgSql)
+                    : client.query(pgSql, args);
+                const result = await withDbTimeout("query", () => runQuery(), timeoutOverrideMs ?? timeoutMs);
                 return {
                     rows: result.rows,
                     rowsAffected: result.rowCount ?? 0,
@@ -1404,7 +1409,10 @@ async function createDbExecInternal(config = {}, trackSingletonResources = false
                             },
                         };
                         try {
-                            await queryNeonClient(client, "BEGIN");
+                            // Send the transaction start and idle reaper together. Neon
+                            // transaction pooling can ignore startup parameters, and a
+                            // worker can die between separate BEGIN and SET LOCAL calls.
+                            await queryNeonClient(client, "BEGIN; SET LOCAL idle_in_transaction_session_timeout = 30000");
                             const result = await fn(tx);
                             await queryNeonClient(client, "COMMIT");
                             releaseClient();

package/dist/db/create-get-db.js

@@ -40,6 +40,43 @@ function getNeonServerlessDrizzle() {
 export function isSqlRead(sql) {
     return /^\s*(SELECT|WITH\s)/i.test(sql);
 }
+const NEON_IDLE_IN_TRANSACTION_TIMEOUT_SQL = "SET LOCAL idle_in_transaction_session_timeout = 30000";
+function queryText(sql) {
+    if (typeof sql === "string")
+        return sql;
+    if (sql && typeof sql === "object" && "text" in sql) {
+        const text = sql.text;
+        return typeof text === "string" ? text : "";
+    }
+    return "";
+}
+function isBeginQuery(sql) {
+    return /^\s*BEGIN(?:\s|$)/i.test(queryText(sql));
+}
+/**
+ * Drizzle sends BEGIN through the client returned by pool.connect(), so a
+ * pool startup parameter alone is not enough protection when Neon routes the
+ * connection through a transaction pooler. Put the idle timeout in the same
+ * simple-protocol message as BEGIN; a worker killed before its next query
+ * still leaves a backend that will reap itself.
+ */
+function guardNeonTransactionClient(client) {
+    return new Proxy(client, {
+        get(target, prop) {
+            if (prop !== "query") {
+                const value = target[prop];
+                return typeof value === "function" ? value.bind(target) : value;
+            }
+            return (...args) => {
+                const sql = args[0];
+                if (!isBeginQuery(sql))
+                    return target.query(...args);
+                const text = queryText(sql).replace(/;\s*$/, "");
+                return target.query(`${text}; ${NEON_IDLE_IN_TRANSACTION_TIMEOUT_SQL}`);
+            };
+        },
+    });
+}
 /**
  * Wraps a @neondatabase/serverless Pool so every query goes through
  * the same withDbTimeout + retryOnConnectionError resilience that the
@@ -129,6 +166,11 @@ export function buildResilientNeonPool(pool) {
         get(target, prop) {
             if (prop === "query")
                 return resilientQuery;
+            if (prop === "connect") {
+                return (...args) => target
+                    .connect(...args)
+                    .then((client) => guardNeonTransactionClient(client));
+            }
             const val = target[prop];
             return typeof val === "function" ? val.bind(target) : val;
         },

package/dist/observability/routes.d.ts

@@ -42,22 +42,22 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     avgEvalScore: number;
 } | {
     error?: undefined;
+    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-    ok?: undefined;
 } | {
     error?: undefined;
+    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-    ok?: undefined;
 } | {
+    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
-    ok?: undefined;
 } | {
     error?: undefined;
     summary?: undefined;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/resources/handlers.d.ts

@@ -48,8 +48,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -34,37 +34,37 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;