@agent-native/core 0.209.0 → 0.209.1-nightly-20261015093558

package/dist/a2a/task-store.d.ts

@@ -6,6 +6,7 @@ export interface A2ATaskListCursor {
     createdAt: number;
     id: string;
 }
+export declare const a2aTasksStore: import("../db/store-registry.js").Store;
 export declare function ensureTable(): Promise<void>;
 export interface A2AApprovalRecord {
     id: string;

package/dist/a2a/task-store.js

@@ -1,9 +1,8 @@
 import crypto from "crypto";
 import { getDbExec } from "../db/client.js";
 import { ensureTableExists, ensureColumnExists, ensureIndexExists, } from "../db/ddl-guard.js";
-import { retainRequestDbPoolScope } from "../db/request-pool-context.js";
+import { defineStore } from "../db/store-registry.js";
 import { assertA2APersistablePayload } from "./persistence-safety.js";
-let _initPromise;
 export const MAX_A2A_IDEMPOTENCY_KEY_CHARS = 128;
 const A2A_IDEMPOTENCY_INDEX = "idx_a2a_tasks_owner_scope_idempotency";
 const A2A_ORG_IDEMPOTENCY_INDEX = "idx_a2a_tasks_org_scope_idempotency";
@@ -11,66 +10,68 @@ const A2A_RECOVERY_INDEX = "idx_a2a_tasks_recovery_created";
 export const A2A_PERSONAL_OWNER_SCOPE = "__personal__";
 export const A2A_ORG_ID_OWNER_SCOPE_PREFIX = "__a2a_org_id__:";
 const MAX_TASK_LIST_PAGE_SIZE = 100;
-export async function ensureTable() {
-    if (!_initPromise) {
-        const _initPromiseWithRequestDbPoolScope = (async () => {
-            const createSql = `
-        CREATE TABLE IF NOT EXISTS a2a_tasks (
-          id TEXT PRIMARY KEY,
-          context_id TEXT,
-          status_state TEXT NOT NULL DEFAULT 'submitted',
-          status_message TEXT,
-          status_timestamp TEXT NOT NULL,
-          history TEXT NOT NULL DEFAULT '[]',
-          artifacts TEXT NOT NULL DEFAULT '[]',
-          metadata TEXT,
-          owner_email TEXT,
-          owner_scope TEXT NOT NULL DEFAULT '',
-          idempotency_key TEXT,
-          created_at BIGINT NOT NULL,
-          updated_at BIGINT NOT NULL
-        )
-      `;
-            const createIdempotencyIndexSql = `CREATE UNIQUE INDEX IF NOT EXISTS ${A2A_IDEMPOTENCY_INDEX} ` +
-                `ON a2a_tasks(owner_email, owner_scope, idempotency_key)`;
-            const createOrgIdempotencyIndexSql = `CREATE UNIQUE INDEX IF NOT EXISTS ${A2A_ORG_IDEMPOTENCY_INDEX} ` +
-                "ON a2a_tasks(owner_scope, idempotency_key) " +
-                "WHERE owner_email IS NULL AND idempotency_key IS NOT NULL";
-            const createRecoveryIndexSql = `CREATE INDEX IF NOT EXISTS ${A2A_RECOVERY_INDEX} ` +
-                "ON a2a_tasks(created_at) " +
-                "WHERE status_state IN ('submitted', 'working', 'processing')";
-            const createApprovalsSql = `
-        CREATE TABLE IF NOT EXISTS a2a_approvals (
-          id TEXT PRIMARY KEY,
-          task_id TEXT NOT NULL UNIQUE,
-          owner_email TEXT NOT NULL,
-          org_id TEXT,
-          tool_name TEXT NOT NULL,
-          tool_input TEXT NOT NULL,
-          approval_key TEXT NOT NULL,
-          call_id TEXT NOT NULL,
-          status TEXT NOT NULL DEFAULT 'pending',
-          result TEXT,
-          expires_at BIGINT NOT NULL,
-          created_at BIGINT NOT NULL,
-          updated_at BIGINT NOT NULL
-        )
-      `;
-            await ensureTableExists("a2a_tasks", createSql);
-            await ensureColumnExists("a2a_tasks", "owner_email", `ALTER TABLE a2a_tasks ADD COLUMN IF NOT EXISTS owner_email TEXT`);
-            await ensureColumnExists("a2a_tasks", "owner_scope", `ALTER TABLE a2a_tasks ADD COLUMN IF NOT EXISTS owner_scope TEXT NOT NULL DEFAULT ''`);
-            await ensureColumnExists("a2a_tasks", "idempotency_key", `ALTER TABLE a2a_tasks ADD COLUMN IF NOT EXISTS idempotency_key TEXT`);
-            await ensureIndexExists(A2A_IDEMPOTENCY_INDEX, createIdempotencyIndexSql);
-            await ensureIndexExists(A2A_ORG_IDEMPOTENCY_INDEX, createOrgIdempotencyIndexSql);
-            await ensureIndexExists(A2A_RECOVERY_INDEX, createRecoveryIndexSql);
-            await ensureTableExists("a2a_approvals", createApprovalsSql);
-        })().catch((err) => {
-            _initPromise = undefined;
-            throw err;
-        });
-        _initPromise = retainRequestDbPoolScope(_initPromiseWithRequestDbPoolScope);
-    }
-    return _initPromise;
+export const a2aTasksStore = defineStore({
+    id: "a2a_tasks",
+    migrations: [
+        {
+            name: "baseline",
+            run: async () => {
+                const createSql = `
+          CREATE TABLE IF NOT EXISTS a2a_tasks (
+            id TEXT PRIMARY KEY,
+            context_id TEXT,
+            status_state TEXT NOT NULL DEFAULT 'submitted',
+            status_message TEXT,
+            status_timestamp TEXT NOT NULL,
+            history TEXT NOT NULL DEFAULT '[]',
+            artifacts TEXT NOT NULL DEFAULT '[]',
+            metadata TEXT,
+            owner_email TEXT,
+            owner_scope TEXT NOT NULL DEFAULT '',
+            idempotency_key TEXT,
+            created_at BIGINT NOT NULL,
+            updated_at BIGINT NOT NULL
+          )
+        `;
+                const createIdempotencyIndexSql = `CREATE UNIQUE INDEX IF NOT EXISTS ${A2A_IDEMPOTENCY_INDEX} ` +
+                    `ON a2a_tasks(owner_email, owner_scope, idempotency_key)`;
+                const createOrgIdempotencyIndexSql = `CREATE UNIQUE INDEX IF NOT EXISTS ${A2A_ORG_IDEMPOTENCY_INDEX} ` +
+                    "ON a2a_tasks(owner_scope, idempotency_key) " +
+                    "WHERE owner_email IS NULL AND idempotency_key IS NOT NULL";
+                const createRecoveryIndexSql = `CREATE INDEX IF NOT EXISTS ${A2A_RECOVERY_INDEX} ` +
+                    "ON a2a_tasks(created_at) " +
+                    "WHERE status_state IN ('submitted', 'working', 'processing')";
+                const createApprovalsSql = `
+          CREATE TABLE IF NOT EXISTS a2a_approvals (
+            id TEXT PRIMARY KEY,
+            task_id TEXT NOT NULL UNIQUE,
+            owner_email TEXT NOT NULL,
+            org_id TEXT,
+            tool_name TEXT NOT NULL,
+            tool_input TEXT NOT NULL,
+            approval_key TEXT NOT NULL,
+            call_id TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            result TEXT,
+            expires_at BIGINT NOT NULL,
+            created_at BIGINT NOT NULL,
+            updated_at BIGINT NOT NULL
+          )
+        `;
+                await ensureTableExists("a2a_tasks", createSql);
+                await ensureColumnExists("a2a_tasks", "owner_email", `ALTER TABLE a2a_tasks ADD COLUMN IF NOT EXISTS owner_email TEXT`);
+                await ensureColumnExists("a2a_tasks", "owner_scope", `ALTER TABLE a2a_tasks ADD COLUMN IF NOT EXISTS owner_scope TEXT NOT NULL DEFAULT ''`);
+                await ensureColumnExists("a2a_tasks", "idempotency_key", `ALTER TABLE a2a_tasks ADD COLUMN IF NOT EXISTS idempotency_key TEXT`);
+                await ensureIndexExists(A2A_IDEMPOTENCY_INDEX, createIdempotencyIndexSql);
+                await ensureIndexExists(A2A_ORG_IDEMPOTENCY_INDEX, createOrgIdempotencyIndexSql);
+                await ensureIndexExists(A2A_RECOVERY_INDEX, createRecoveryIndexSql);
+                await ensureTableExists("a2a_approvals", createApprovalsSql);
+            },
+        },
+    ],
+});
+export function ensureTable() {
+    return a2aTasksStore.ready();
 }
 async function withDbTransaction(client, fn) {
     if (client.transaction)

package/dist/action-call-classification.d.ts

@@ -1,8 +1,23 @@
 import type { ActionChangeResource, ActionPlanModeConfig } from "./action.js";
+import type { ActionTool } from "./agent/types.js";
 export declare function actionCallIsReadOnly(entry: {
     readOnly?: boolean;
     planMode?: ActionPlanModeConfig<any>;
 }, params: unknown, fallback: boolean): boolean;
+/**
+ * Whether re-running this call after an error or a lost result is safe. An
+ * action opts in with `retrySafe`; an undeclared action is not, so an
+ * ambiguous write keeps blocking the run. A predicate sees the arguments after
+ * the same gateway-string repair schema validation applies (`"true"` already
+ * `true`), never the raw model input a stringified flag could slip past a
+ * strict comparison in.
+ */
+export declare function actionCallIsRetrySafe(entry: {
+    retrySafe?: boolean | ((input: any) => boolean);
+    tool?: {
+        parameters?: ActionTool["parameters"];
+    };
+}, params: unknown): boolean;
 /**
  * Whether a successful call should publish an `action` change event.
  *

package/dist/action-call-classification.js

@@ -1,3 +1,4 @@
+import { coerceGatewayStringifiedArgs } from "./action-input-coercion.js";
 export function actionCallIsReadOnly(entry, params, fallback) {
     const effect = entry.planMode?.effect;
     if (typeof effect === "string")
@@ -15,6 +16,29 @@ export function actionCallIsReadOnly(entry, params, fallback) {
         return entry.readOnly;
     return fallback;
 }
+/**
+ * Whether re-running this call after an error or a lost result is safe. An
+ * action opts in with `retrySafe`; an undeclared action is not, so an
+ * ambiguous write keeps blocking the run. A predicate sees the arguments after
+ * the same gateway-string repair schema validation applies (`"true"` already
+ * `true`), never the raw model input a stringified flag could slip past a
+ * strict comparison in.
+ */
+export function actionCallIsRetrySafe(entry, params) {
+    const { retrySafe } = entry;
+    if (typeof retrySafe === "boolean")
+        return retrySafe;
+    if (typeof retrySafe !== "function")
+        return false;
+    try {
+        return (retrySafe(coerceGatewayStringifiedArgs(params, entry.tool?.parameters)) === true);
+    }
+    catch {
+        // coercion-ok: a throwing predicate declares nothing, so the call stays
+        // conservative (blocked) rather than being treated as safe to replay.
+        return false;
+    }
+}
 /**
  * Whether a successful call should publish an `action` change event.
  *

package/dist/action-input-coercion.d.ts

@@ -0,0 +1,10 @@
+import type { ActionTool } from "./agent/types.js";
+/**
+ * The repair a tool call's arguments get before schema validation: a gateway
+ * that stringifies `true`, `3`, or a JSON array/object is undone per the
+ * declared parameter type. Anything that reads a call's input to decide what
+ * the handler will do (`retrySafe`) must see this form, not the raw model
+ * input, or a stringified flag passes a strict comparison and still runs as
+ * `true`.
+ */
+export declare function coerceGatewayStringifiedArgs(args: unknown, parameters?: ActionTool["parameters"]): unknown;

package/dist/action-input-coercion.js

@@ -0,0 +1,77 @@
+const NO_COERCE = Symbol("no-coerce");
+function coerceStringToSchemaType(raw, types) {
+    const trimmed = raw.trim();
+    if (types.includes("boolean")) {
+        if (trimmed === "true")
+            return true;
+        if (trimmed === "false")
+            return false;
+    }
+    if ((types.includes("array") &&
+        trimmed.startsWith("[") &&
+        trimmed.endsWith("]")) ||
+        (types.includes("object") &&
+            trimmed.startsWith("{") &&
+            trimmed.endsWith("}"))) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (types.includes("array") && Array.isArray(parsed))
+                return parsed;
+            if (types.includes("object") &&
+                parsed &&
+                typeof parsed === "object" &&
+                !Array.isArray(parsed)) {
+                return parsed;
+            }
+            // coercion-ok: unparseable text stays a string and schema validation rejects it
+        }
+        catch {
+            // fall through — leave the original so validation reports the real error
+        }
+    }
+    if ((types.includes("number") || types.includes("integer")) &&
+        trimmed !== "" &&
+        Number.isFinite(Number(trimmed))) {
+        const n = Number(trimmed);
+        if (types.includes("number") || Number.isInteger(n))
+            return n;
+    }
+    return NO_COERCE;
+}
+/**
+ * The repair a tool call's arguments get before schema validation: a gateway
+ * that stringifies `true`, `3`, or a JSON array/object is undone per the
+ * declared parameter type. Anything that reads a call's input to decide what
+ * the handler will do (`retrySafe`) must see this form, not the raw model
+ * input, or a stringified flag passes a strict comparison and still runs as
+ * `true`.
+ */
+export function coerceGatewayStringifiedArgs(args, parameters) {
+    const properties = parameters?.properties;
+    if (!properties)
+        return args;
+    if (!args || typeof args !== "object" || Array.isArray(args))
+        return args;
+    let out = null;
+    for (const [key, raw] of Object.entries(args)) {
+        if (typeof raw !== "string")
+            continue;
+        const spec = properties[key];
+        if (!spec)
+            continue;
+        const types = Array.isArray(spec.type)
+            ? spec.type
+            : spec.type
+                ? [spec.type]
+                : [];
+        if (types.length === 0 || types.includes("string"))
+            continue;
+        const coerced = coerceStringToSchemaType(raw, types);
+        if (coerced === NO_COERCE)
+            continue;
+        if (!out)
+            out = { ...args };
+        out[key] = coerced;
+    }
+    return out ?? args;
+}

package/dist/action.d.ts

@@ -3,6 +3,11 @@ import { type ActionChatUIConfig } from "./action-ui.js";
 import type { ActionTool, AgentChatAttachment, AgentChatEvent } from "./agent/types.js";
 import type { ActionAuditConfig } from "./audit/types.js";
 import { type ActionAccessConfig } from "./authorization/action-access-runtime.js";
+/**
+ * Carries an action's execution-frame key across `{ ...entry, run }` wrappers
+ * and the registry rebuilds that copy named fields (`preserveActionFlags`).
+ */
+export declare const ACTION_EXECUTION_KEY: unique symbol;
 export type ActionCaller = "tool" | "http" | "frontend" | "mcp-widget" | "mcp-widget-write" | "cli" | "mcp" | "webmcp" | "a2a" | "automation";
 export interface ActionAutomationContext {
     triggerId: string;
@@ -308,6 +313,16 @@ interface DefineActionWithSchema<TSchema extends StandardSchemaV1, TReturn = any
      *  names); return `null` when the call touches no resource or changed nothing. */
     changeResource?: (input: StandardSchemaV1.InferInput<TSchema>, result: TReturn) => ActionChangeResource | null | undefined;
     parallelSafe?: boolean;
+    /**
+     * Re-running this write after an error or a lost result cannot duplicate or
+     * corrupt data: it validates before it writes, or it sets an end state
+     * (replace-by-id, search-and-replace that fails loudly on a second run). The
+     * agent loop then lets the model correct its arguments and retry instead of
+     * ending the run as `write_tool_outcome_unknown`. Pass a predicate when only
+     * some inputs qualify. Do not set it on an action that appends, sends, or
+     * charges.
+     */
+    retrySafe?: boolean | ((input: StandardSchemaV1.InferInput<TSchema>) => boolean);
     endsTurn?: boolean;
     dedupe?: boolean;
     toolCallable?: boolean;
@@ -373,6 +388,8 @@ interface DefineActionWithParams<TParams extends Record<string, ParameterSchema>
     persistInBrowser?: boolean;
     changeResource?: (input: InferParams<TParams>, result: TReturn) => ActionChangeResource | null | undefined;
     parallelSafe?: boolean;
+    /** See `ActionDefinition.retrySafe`. */
+    retrySafe?: boolean | ((input: InferParams<TParams>) => boolean);
     endsTurn?: boolean;
     dedupe?: boolean;
     toolCallable?: boolean;
@@ -409,6 +426,7 @@ export interface ActionDefinition<TInput, TReturn> {
     readonly persistInBrowser?: boolean;
     readonly changeResource?: (input: TInput, result: TReturn) => ActionChangeResource | null | undefined;
     readonly parallelSafe?: boolean;
+    readonly retrySafe?: boolean | ((input: TInput) => boolean);
     readonly endsTurn?: boolean;
     readonly dedupe?: boolean;
     readonly toolCallable?: boolean;
@@ -449,6 +467,6 @@ type ActionExecutionRun = (args: any, ctx?: ActionRunContext) => Promise<any>;
 /** @internal Observe one public action invocation without transferring child refusals. */
 export declare function runActionWithExecutionOutcome(run: ActionExecutionRun, args: unknown, ctx: ActionRunContext | undefined, outcome: {
     refused: boolean;
-}): Promise<any>;
+}, entry?: object): Promise<any>;
 export declare function validateActionArgs(schema: StandardSchemaV1, args: unknown, toolParameters?: ActionTool["parameters"], ctx?: object): Promise<any>;
 export {};

package/dist/action.js

@@ -1,9 +1,15 @@
+import { coerceGatewayStringifiedArgs } from "./action-input-coercion.js";
 import { normalizeActionChatUIConfig, } from "./action-ui.js";
 import { normalizeAuditConfig, resolveAuditAttach } from "./audit/config.js";
 import { assertRegisteredActionAccess, } from "./authorization/action-access-runtime.js";
 import { parseServiceIdentityEmail } from "./org/service-identity.js";
 import { getAsyncLocalStorageCtor } from "./shared/optional-node-builtins.js";
 import { wrapRunWithActionTracking } from "./tracking/action-lifecycle.js";
+/**
+ * Carries an action's execution-frame key across `{ ...entry, run }` wrappers
+ * and the registry rebuilds that copy named fields (`preserveActionFlags`).
+ */
+export const ACTION_EXECUTION_KEY = Symbol.for("agent-native.action.executionKey");
 export class ActionContractError extends Error {
     actionContractError = true;
     errorCode;
@@ -175,6 +181,10 @@ export function defineAction(options) {
     const parallelSafe = typeof options.parallelSafe === "boolean"
         ? options.parallelSafe
         : undefined;
+    const retrySafe = typeof options.retrySafe === "boolean" ||
+        typeof options.retrySafe === "function"
+        ? options.retrySafe
+        : undefined;
     const endsTurn = typeof options.endsTurn === "boolean" ? options.endsTurn : undefined;
     const dedupe = typeof options.dedupe === "boolean" ? options.dedupe : undefined;
     const publicAgent = options.publicAgent &&
@@ -204,7 +214,7 @@ export function defineAction(options) {
         return undefined;
     })();
     const chatUI = normalizeActionChatUIConfig(options.chatUI);
-    return {
+    const entry = {
         tool: {
             ...(typeof options.title === "string" && options.title.trim()
                 ? { title: options.title.trim() }
@@ -252,6 +262,7 @@ export function defineAction(options) {
             ? { changeResource: options.changeResource }
             : {}),
         ...(typeof parallelSafe === "boolean" ? { parallelSafe } : {}),
+        ...(retrySafe !== undefined ? { retrySafe } : {}),
         ...(typeof endsTurn === "boolean" ? { endsTurn } : {}),
         ...(typeof dedupe === "boolean" ? { dedupe } : {}),
         ...(typeof toolCallable === "boolean" ? { toolCallable } : {}),
@@ -288,6 +299,15 @@ export function defineAction(options) {
         ...(auditConfig ? { audit: auditConfig } : {}),
         ...(options.access ? { access: options.access } : {}),
     };
+    // Enumerable on purpose: an app that wraps `run` with `{ ...entry, run }`
+    // keeps the key, so the loop can still tell a pre-handler refusal from a
+    // handler failure. Without it the wrapper's own frame never becomes the
+    // action's frame and every validation error reads as an unknown write.
+    Object.defineProperty(entry, ACTION_EXECUTION_KEY, {
+        value: executionKey,
+        enumerable: true,
+    });
+    return entry;
 }
 export function isActionExposedToExternalAgents(entry) {
     if (entry.uiOnly === true)
@@ -671,74 +691,6 @@ function zodDefToJsonSchema(def) {
     }
     return { type: "string" };
 }
-const NO_COERCE = Symbol("no-coerce");
-function coerceStringToSchemaType(raw, types) {
-    const trimmed = raw.trim();
-    if (types.includes("boolean")) {
-        if (trimmed === "true")
-            return true;
-        if (trimmed === "false")
-            return false;
-    }
-    if ((types.includes("array") &&
-        trimmed.startsWith("[") &&
-        trimmed.endsWith("]")) ||
-        (types.includes("object") &&
-            trimmed.startsWith("{") &&
-            trimmed.endsWith("}"))) {
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (types.includes("array") && Array.isArray(parsed))
-                return parsed;
-            if (types.includes("object") &&
-                parsed &&
-                typeof parsed === "object" &&
-                !Array.isArray(parsed)) {
-                return parsed;
-            }
-        }
-        catch {
-            // fall through — leave the original so validation reports the real error
-        }
-    }
-    if ((types.includes("number") || types.includes("integer")) &&
-        trimmed !== "" &&
-        Number.isFinite(Number(trimmed))) {
-        const n = Number(trimmed);
-        if (types.includes("number") || Number.isInteger(n))
-            return n;
-    }
-    return NO_COERCE;
-}
-function coerceGatewayStringifiedArgs(args, parameters) {
-    const properties = parameters?.properties;
-    if (!properties)
-        return args;
-    if (!args || typeof args !== "object" || Array.isArray(args))
-        return args;
-    let out = null;
-    for (const [key, raw] of Object.entries(args)) {
-        if (typeof raw !== "string")
-            continue;
-        const spec = properties[key];
-        if (!spec)
-            continue;
-        const types = Array.isArray(spec.type)
-            ? spec.type
-            : spec.type
-                ? [spec.type]
-                : [];
-        if (types.length === 0 || types.includes("string"))
-            continue;
-        const coerced = coerceStringToSchemaType(raw, types);
-        if (coerced === NO_COERCE)
-            continue;
-        if (!out)
-            out = { ...args };
-        out[key] = coerced;
-    }
-    return out ?? args;
-}
 const MAX_SIGNATURE_DEPTH = 4;
 const MAX_SIGNATURE_LENGTH = 1200;
 function describeSchemaType(spec, depth) {
@@ -799,7 +751,8 @@ function wrapRunWithExecutionBoundary(run, key) {
         if (!actionExecutionStorage)
             return run(args, ctx);
         const parent = actionExecutionStorage.getStore();
-        const frame = parent?.frame?.boundaryPending && parent.frame.run === boundaryRun
+        const frame = parent?.frame?.boundaryPending &&
+            (parent.frame.run === boundaryRun || parent.frame.key === key)
             ? parent.frame
             : {
                 key,
@@ -830,14 +783,19 @@ function wrapRunWithExecutionBoundary(run, key) {
     return boundaryRun;
 }
 /** @internal Observe one public action invocation without transferring child refusals. */
-export async function runActionWithExecutionOutcome(run, args, ctx, outcome) {
+export async function runActionWithExecutionOutcome(run, args, ctx, outcome, entry) {
     outcome.refused = false;
     // A mutable async stack cannot safely attribute overlapping invocations.
     if (!actionExecutionStorage)
         return run(args, ctx);
     const parent = actionExecutionStorage.getStore();
+    const entryKey = entry
+        ? entry[ACTION_EXECUTION_KEY]
+        : undefined;
     const frame = {
-        key: {},
+        // The entry's own key lets its boundary adopt this frame when an app has
+        // wrapped `run`; an unkeyed entry gets a placeholder nothing can match.
+        key: entryKey !== null && typeof entryKey === "object" ? entryKey : {},
         run,
         parent: parent?.frame,
         handlerEntered: true,
@@ -857,10 +815,15 @@ export async function runActionWithExecutionOutcome(run, args, ctx, outcome) {
                 ? state.failures.get(error)
                 : undefined;
             // Error types cannot prove non-execution once the handler has entered.
+            // A keyed entry whose boundary was never entered threw in an app
+            // wrapper around `run`, before any handler could start.
             outcome.refused =
                 !frame.descendantWriteEntered &&
-                    !frame.handlerEntered &&
-                    failure === frame;
+                    ((!frame.handlerEntered && failure === frame) ||
+                        (frame.key !== undefined &&
+                            frame.boundaryPending === true &&
+                            entryKey !== null &&
+                            typeof entryKey === "object"));
             throw error;
         }
     });

package/dist/agent/engine/ai-sdk-engine.js

@@ -1,6 +1,6 @@
 import { ssrfSafeFetch } from "../../extensions/url-safety.js";
 import { clearProviderCredentialAuthFailure, readDeployCredentialEnv, recordProviderCredentialAuthFailure, } from "../../server/credential-provider.js";
-import { allowsSamplingParams, anthropicManualThinkingBudget, normalizeReasoningEffortForModel, supportsClaudeAdaptiveThinking, } from "../../shared/reasoning-effort.js";
+import { allowsSamplingParams, anthropicManualThinkingBudget, isGPTReasoningModel, normalizeReasoningEffortForModel, supportsClaudeAdaptiveThinking, } from "../../shared/reasoning-effort.js";
 import { isNodeRuntime } from "../../shared/runtime.js";
 import { AI_SDK_MODEL_CONFIG } from "../model-config.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./credential-errors.js";
@@ -364,6 +364,18 @@ class AISDKEngine {
                 };
             }
         }
+        // @ai-sdk/openai infers reasoning models from its own id prefixes, which
+        // miss gpt-6-*. Without forceReasoning, Chat Completions sends max_tokens,
+        // which OpenAI rejects for reasoning models. isGPTReasoningModel also
+        // matches gpt-5-chat-*, which is not a reasoning model.
+        if (this.usesOpenAiChatCompletions() &&
+            isGPTReasoningModel(opts.model) &&
+            !/^(openai\/)?gpt-5-chat/i.test(opts.model)) {
+            providerOpts.openai = {
+                ...(providerOpts.openai ?? {}),
+                forceReasoning: true,
+            };
+        }
         const samplingAllowed = allowsSamplingParams({
             model: opts.model,
             thinkingEnabled: this.provider === "anthropic" &&
@@ -482,6 +494,13 @@ class AISDKEngine {
             firstEventAbort.cleanup();
         }
     }
+    // Provider construction and the OpenAI reasoning options must agree on the
+    // endpoint shape, so both read this one decision.
+    usesOpenAiChatCompletions() {
+        return (this.provider === "openai" &&
+            !this.forceResponses &&
+            isCustomOpenAiBaseUrl(this.baseUrl));
+    }
     async createProviderModel(model) {
         const pkg = PROVIDER_PACKAGES[this.provider];
         let providerModule;
@@ -511,9 +530,7 @@ class AISDKEngine {
                 config.appUrl = this.appUrl;
         }
         const provider = createFn(config);
-        return this.provider === "openai" &&
-            !this.forceResponses &&
-            isCustomOpenAiBaseUrl(this.baseUrl)
+        return this.usesOpenAiChatCompletions()
             ? provider.chat(model)
             : provider(model);
     }

package/dist/agent/engine/continuation-dispatch-retry.d.ts

@@ -12,6 +12,9 @@ export declare function attemptContinuationDispatch(params: {
     isLoopProtectionDispatchError: (err: unknown) => boolean;
     maxNestedSelfDispatchDepth: number;
     deps: ContinuationDispatchRetryDeps;
+    random?: () => number;
+    /** Wall clock for the overload budget; injectable so specs need no timers. */
+    now?: () => number;
 }): Promise<{
     dispatched: boolean;
     lastDispatchErr: unknown;