@agent-native/core 0.161.1 → 0.161.4

package/dist/agent/engine/types.d.ts

@@ -26,6 +26,8 @@ export declare class EngineError extends Error {
     readonly statusCode?: number;
     /** Whether the provider explicitly marked this error as retryable. */
     readonly providerRetryable?: boolean;
+    /** Upstream request id, when the provider/gateway supplied one. */
+    readonly requestId?: string;
     /**
      * Whether the request exceeded the model's context window. Set by engines that
      * classified the provider's own reply, because the delivered message may not
@@ -34,12 +36,16 @@ export declare class EngineError extends Error {
      * one-shot trim-and-retry recovery.
      */
     readonly contextOverflow?: boolean;
+    /** Sizes and counts of the failed request; see {@link EngineRequestShape}. */
+    readonly requestShape?: EngineRequestShape;
     constructor(message: string, opts?: {
         errorCode?: string;
         upgradeUrl?: string;
         statusCode?: number;
         providerRetryable?: boolean;
+        requestId?: string;
         contextOverflow?: boolean;
+        requestShape?: EngineRequestShape;
     });
 }
 /**
@@ -196,6 +202,13 @@ export type EngineEvent = {
      * should retry even if status code / message patterns don't match.
      */
     providerRetryable?: boolean;
+    /**
+     * Upstream request id, when the provider/gateway supplies one. This is
+     * the only key that ties a user-facing error back to the upstream log,
+     * so it must survive to the capture even when the error also carries a
+     * message — an opaque message is not a diagnostic.
+     */
+    requestId?: string;
     /**
      * The request exceeded the model's context window. Carried structurally
      * for the same reason as `providerRetryable`: `error` is visitor copy on a
@@ -203,7 +216,23 @@ export type EngineEvent = {
      * the time the agent decides whether to trim and retry.
      */
     contextOverflow?: boolean;
+    /**
+     * Sizes and counts of the request that failed. Never prompt or user
+     * content — the point is to make "what did we send" answerable from a
+     * capture, which an opaque gateway 500 otherwise leaves unanswerable.
+     */
+    requestShape?: EngineRequestShape;
 };
+/**
+ * Shape-only description of what an engine put on the wire. Every field is a
+ * size, a count, or a model id, so it is safe to attach to an error capture.
+ */
+export interface EngineRequestShape {
+    model: string;
+    payloadBytes: number;
+    toolCount: number;
+    messageCount: number;
+}
 export interface EngineCapabilities {
     /** Extended / adaptive thinking support */
     thinking: boolean;

package/dist/agent/engine/types.js

@@ -25,6 +25,8 @@ export class EngineError extends Error {
     statusCode;
     /** Whether the provider explicitly marked this error as retryable. */
     providerRetryable;
+    /** Upstream request id, when the provider/gateway supplied one. */
+    requestId;
     /**
      * Whether the request exceeded the model's context window. Set by engines that
      * classified the provider's own reply, because the delivered message may not
@@ -33,6 +35,8 @@ export class EngineError extends Error {
      * one-shot trim-and-retry recovery.
      */
     contextOverflow;
+    /** Sizes and counts of the failed request; see {@link EngineRequestShape}. */
+    requestShape;
     constructor(message, opts) {
         super(message);
         this.name = "EngineError";
@@ -40,6 +44,8 @@ export class EngineError extends Error {
         this.upgradeUrl = opts?.upgradeUrl;
         this.statusCode = opts?.statusCode;
         this.providerRetryable = opts?.providerRetryable;
+        this.requestId = opts?.requestId;
         this.contextOverflow = opts?.contextOverflow;
+        this.requestShape = opts?.requestShape;
     }
 }

package/dist/agent/production-agent.js

@@ -3752,6 +3752,8 @@ export async function runAgentLoop(opts) {
                                     statusCode: event.statusCode,
                                     providerRetryable: event.providerRetryable,
                                     contextOverflow: event.contextOverflow,
+                                    requestId: event.requestId,
+                                    requestShape: event.requestShape,
                                 });
                             }
                         }

package/dist/agent/run-manager.d.ts

@@ -1,3 +1,4 @@
+import type { EngineRequestShape } from "./engine/types.js";
 import type { AgentChatEvent, RunEvent, RunStatus } from "./types.js";
 export interface ActiveRun {
     runId: string;
@@ -233,6 +234,11 @@ export declare function resolveSqlSubscriptionPollMs(now: number, activePollUnti
  */
 export declare function nextSqlSubscriptionEmptyPolls(current: number, hadEvents: boolean, now: number, activePollUntil: number): number;
 export declare function resolveSqlSubscriptionRetryMs(consecutiveFailures: number): number;
+/**
+ * Sentry tags are strings, and an absent shape must stay absent: a run that
+ * failed before the request was built did not send a zero-byte payload.
+ */
+export declare function engineRequestShapeTags(shape: EngineRequestShape | undefined): Record<string, string>;
 export interface StartRunOptions {
     /** Keep a request-scoped serverless invocation alive for this run. */
     waitUntil?: (promise: Promise<unknown>) => void;

package/dist/agent/run-manager.js

@@ -299,6 +299,20 @@ function getRunErrorCode(err) {
     // only when the run row is persisted.
     return classifyTerminalErrorCode(describeErrorWithCauses(err));
 }
+/**
+ * Sentry tags are strings, and an absent shape must stay absent: a run that
+ * failed before the request was built did not send a zero-byte payload.
+ */
+export function engineRequestShapeTags(shape) {
+    if (!shape)
+        return {};
+    return {
+        engineModel: shape.model,
+        enginePayloadBytes: String(shape.payloadBytes),
+        engineToolCount: String(shape.toolCount),
+        engineMessageCount: String(shape.messageCount),
+    };
+}
 function getEngineRunErrorDetails(err) {
     if (err.statusCode === 429)
         return err.message;
@@ -1060,6 +1074,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     let pendingTerminalEvent = null;
     const captureRunError = (error, phase) => {
         const errorCode = getRunErrorCode(error);
+        // A gateway error often arrives as one opaque user-facing sentence, so the
+        // structured fields EngineError already carries are the whole diagnostic.
+        // Dropping them here left operators with an error id and nothing to join on.
+        const engineError = error instanceof EngineError ? error : null;
         captureError(error, {
             route: "/_agent-native/agent-chat",
             aiTraceId: runId,
@@ -1070,6 +1088,15 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 softTimedOut: softTimedOut ? "true" : "false",
                 abortReason: run.abortReason,
                 errorCode,
+                gatewayRequestId: engineError?.requestId,
+                statusCode: engineError?.statusCode != null
+                    ? String(engineError.statusCode)
+                    : undefined,
+                // What we sent, in sizes and counts only. A gateway rejection describes
+                // nothing about the request behind it, so without these an oversized
+                // payload and an upstream outage produce the same capture — which is
+                // how one gateway 500 cost a night of guessing.
+                ...engineRequestShapeTags(engineError?.requestShape),
             },
             extra: {
                 runId,

package/dist/agent/run-store.d.ts

@@ -715,11 +715,11 @@ export declare function getRunOutcomeCounters(options?: {
     terminalReason: string;
     count: number;
 }>>;
-/** Delete old runs and expire stale "running" rows that haven't had activity
- *  (e.g. worker crashed before updating status). Genuinely completed runs are
- *  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. */
+/**
+ * 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 declare function cleanupOldRuns(olderThanMs: number, erroredOlderThanMs?: number): Promise<void>;
 /**
  * List recent unsuccessful runs (errored, aborted, and truncated) for cut-off

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/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/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

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

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    id?: undefined;
     message?: undefined;
+    id?: undefined;
     deleted?: undefined;
     providers: {
         id: string;
@@ -93,9 +93,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     registered?: undefined;
     label?: undefined;
 } | {
-    id?: undefined;
     message?: undefined;
     count?: undefined;
+    id?: undefined;
     deleted?: undefined;
     providers?: undefined;
     found: 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<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
-    error?: undefined;
 }>>;
 export {};