@agent-native/core 0.171.3 → 0.172.0

package/dist/agent/actions/set-tool-approval-policy.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("../../action.js").ActionDefinition<{
+    toolName: string;
+    enabled?: boolean;
+}, {
+    toolName: string;
+    enabled: boolean;
+}>;
+export default _default;

package/dist/agent/actions/set-tool-approval-policy.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { defineAction } from "../../action.js";
+import { setAgentToolApprovalPolicy } from "../tool-approval-store.js";
+export default defineAction({
+    description: "Enable or disable future approval prompts for one action type for the signed-in user.",
+    schema: z.object({
+        toolName: z.string().trim().min(1).max(128),
+        enabled: z.boolean().default(true),
+    }),
+    http: { method: "POST" },
+    agentTool: false,
+    run: async (args, context) => {
+        const ownerEmail = context?.userEmail?.trim().toLowerCase();
+        if (!ownerEmail)
+            throw new Error("Sign in to manage approval preferences.");
+        await setAgentToolApprovalPolicy({
+            binding: {
+                ownerEmail,
+                orgId: context?.orgId?.trim() || null,
+                toolName: args.toolName,
+            },
+            enabled: args.enabled,
+        });
+        return { toolName: args.toolName, enabled: args.enabled };
+    },
+});

package/dist/agent/harness/migrations.js

@@ -57,4 +57,12 @@ export const AGENT_HARNESS_SESSION_MIGRATIONS = [
             sqlite: "",
         },
     },
+    {
+        version: 4,
+        name: "agent-harness-sessions-generation",
+        sql: {
+            postgres: "ALTER TABLE agent_harness_sessions ADD COLUMN IF NOT EXISTS generation BIGINT NOT NULL DEFAULT 0",
+            sqlite: "ALTER TABLE agent_harness_sessions ADD COLUMN generation INTEGER NOT NULL DEFAULT 0",
+        },
+    },
 ];

package/dist/agent/harness/runner.js

@@ -1,12 +1,19 @@
 import { startRun } from "../run-manager.js";
 import { registerLiveAgentHarnessSession, releaseLiveAgentHarnessSession, } from "./lifecycle.js";
-import { getAgentHarnessSession, markAgentHarnessSessionStopped, saveAgentHarnessSession, updateAgentHarnessSession, } from "./store.js";
+import { getAgentHarnessSession, isAgentHarnessSessionConflictError, markAgentHarnessSessionStopped, saveAgentHarnessSession, updateAgentHarnessSession, } from "./store.js";
 import { agentHarnessEventToAgentChatEvents } from "./translate.js";
 export function startAgentHarnessRun(opts) {
     let harnessSession = opts.session;
     const detachOnComplete = opts.detachOnComplete !== false;
-    return startRun(opts.runId, opts.threadId, async (send, signal) => {
+    return startRun(opts.runId, opts.threadId, async (send, signal, control) => {
+        const runControl = control ?? {
+            turnSignal: signal,
+            chunkSignal: signal,
+            chunkBoundaryReason: () => null,
+            beginChunk: () => signal,
+        };
         let storedSessionId;
+        let harnessSessionRegistered = false;
         let keepLiveSession = false;
         try {
             send({
@@ -20,7 +27,7 @@ export function startAgentHarnessRun(opts) {
                 runId: opts.runId,
                 ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
                 orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
-                signal,
+                signal: runControl.turnSignal,
             });
             storedSessionId = opts.createSession?.sessionId ?? harnessSession.id;
             await saveAgentHarnessSession({
@@ -42,50 +49,93 @@ export function startAgentHarnessRun(opts) {
                 ownerEmail: opts.ownerEmail ?? opts.createSession?.ownerEmail ?? null,
                 orgId: opts.orgId ?? opts.createSession?.orgId ?? null,
             });
+            harnessSessionRegistered = true;
             const input = {
                 ...opts.input,
-                abortSignal: signal,
+                abortSignal: runControl.chunkSignal,
             };
+            let firstStream = true;
             let pendingApproval = null;
-            for await (const event of harnessSession.streamTurn(input)) {
-                if (signal.aborted)
-                    break;
-                await opts.onHarnessEvent?.(event);
-                if (event.type === "approval-request") {
-                    pendingApproval = event;
-                    await updateAgentHarnessSession(storedSessionId, {
-                        status: "idle",
-                        pendingApproval: event,
+            while (true) {
+                pendingApproval = null;
+                const events = firstStream
+                    ? harnessSession.streamTurn(input)
+                    : harnessSession.continueTurn({
+                        abortSignal: runControl.chunkSignal,
                     });
+                firstStream = false;
+                try {
+                    for await (const event of events) {
+                        if (runControl.turnSignal.aborted)
+                            break;
+                        await opts.onHarnessEvent?.(event);
+                        if (event.type === "approval-request") {
+                            pendingApproval = event;
+                            await updateAgentHarnessSession(storedSessionId, {
+                                status: "idle",
+                                pendingApproval: event,
+                            });
+                        }
+                        if (event.type === "error") {
+                            throw new Error(event.error);
+                        }
+                        for (const chatEvent of agentHarnessEventToAgentChatEvents(event)) {
+                            send(chatEvent);
+                        }
+                    }
+                }
+                catch (error) {
+                    if (runControl.turnSignal.aborted ||
+                        !runControl.chunkBoundaryReason()) {
+                        throw error;
+                    }
+                }
+                if (runControl.turnSignal.aborted) {
+                    await stopHarnessSession(harnessSession);
+                    releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+                    await markAgentHarnessSessionStopped(storedSessionId, "stopped");
+                    return;
+                }
+                if (pendingApproval) {
+                    const stored = await getAgentHarnessSession(storedSessionId);
+                    const stillPending = stored?.pendingApproval &&
+                        typeof stored.pendingApproval === "object" &&
+                        "id" in stored.pendingApproval &&
+                        stored.pendingApproval.id === pendingApproval.id;
+                    if (stillPending) {
+                        keepLiveSession = true;
+                        await updateAgentHarnessSession(storedSessionId, {
+                            status: "idle",
+                            pendingApproval,
+                        });
+                        return;
+                    }
                 }
-                if (event.type === "error") {
-                    throw new Error(event.error);
+                if (!runControl.chunkBoundaryReason())
+                    break;
+                if (!harnessSession.continueTurn) {
+                    await saveHarnessCheckpoint(storedSessionId, harnessSession, opts.createSession?.resumeState, detachOnComplete);
+                    if (detachOnComplete) {
+                        releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+                    }
+                    else {
+                        keepLiveSession = true;
+                    }
+                    return;
                 }
-                for (const chatEvent of agentHarnessEventToAgentChatEvents(event)) {
-                    send(chatEvent);
+                if (runControl.beginChunk().aborted) {
+                    await stopHarnessSession(harnessSession);
+                    releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+                    await markAgentHarnessSessionStopped(storedSessionId, "stopped");
+                    return;
                 }
             }
-            if (signal.aborted) {
+            if (runControl.turnSignal.aborted) {
                 await stopHarnessSession(harnessSession);
                 releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
                 await markAgentHarnessSessionStopped(storedSessionId, "stopped");
                 return;
             }
-            if (pendingApproval) {
-                const stored = await getAgentHarnessSession(storedSessionId);
-                const stillPending = stored?.pendingApproval &&
-                    typeof stored.pendingApproval === "object" &&
-                    "id" in stored.pendingApproval &&
-                    stored.pendingApproval.id === pendingApproval.id;
-                if (stillPending) {
-                    keepLiveSession = true;
-                    await updateAgentHarnessSession(storedSessionId, {
-                        status: "idle",
-                        pendingApproval,
-                    });
-                    return;
-                }
-            }
             let resumeState = opts.createSession?.resumeState;
             if (detachOnComplete && harnessSession.detach) {
                 resumeState = await harnessSession.detach();
@@ -98,6 +148,24 @@ export function startAgentHarnessRun(opts) {
             });
         }
         catch (error) {
+            if (isAgentHarnessSessionConflictError(error)) {
+                if (!harnessSessionRegistered) {
+                    await stopHarnessSession(harnessSession);
+                    return;
+                }
+                keepLiveSession = true;
+                const latest = storedSessionId
+                    ? await getAgentHarnessSession(storedSessionId)
+                    : null;
+                const terminal = latest?.status === "stopped" ||
+                    latest?.status === "errored" ||
+                    latest?.status === "destroyed";
+                keepLiveSession = !terminal;
+                if (terminal && storedSessionId) {
+                    releaseLiveAgentHarnessSession(storedSessionId, harnessSession);
+                }
+                return;
+            }
             if (harnessSession && !keepLiveSession) {
                 await stopHarnessSession(harnessSession).catch(() => undefined);
             }
@@ -118,6 +186,8 @@ export function startAgentHarnessRun(opts) {
     }, opts.onRunComplete, {
         ...(opts.runOptions ?? {}),
         turnId: opts.turnId ?? opts.runOptions?.turnId,
+        recoverChunkBoundaries: opts.runOptions?.recoverChunkBoundaries ?? true,
+        useHostedSoftTimeoutDefault: opts.runOptions?.useHostedSoftTimeoutDefault ?? true,
         // A harness adapter (e.g. Claude Code, Codex) owns its own model
         // selection internally and does not expose it here, so `model` is
         // left for the caller to supply via `runOptions` if it knows one.
@@ -125,6 +195,17 @@ export function startAgentHarnessRun(opts) {
         engineName: opts.runOptions?.engineName ?? opts.adapter.name,
     });
 }
+async function saveHarnessCheckpoint(sessionId, session, resumeState, detachOnComplete) {
+    let nextResumeState = resumeState;
+    if (detachOnComplete && session.detach) {
+        nextResumeState = await session.detach();
+    }
+    await updateAgentHarnessSession(sessionId, {
+        status: "idle",
+        resumeState: nextResumeState,
+        pendingApproval: null,
+    });
+}
 async function stopHarnessSession(session) {
     if (!session)
         return;

package/dist/agent/harness/store.d.ts

@@ -1,4 +1,8 @@
 export type AgentHarnessSessionStatus = "running" | "idle" | "stopped" | "errored" | "destroyed";
+export declare class AgentHarnessSessionConflictError extends Error {
+    constructor(sessionId: string);
+}
+export declare function isAgentHarnessSessionConflictError(error: unknown): error is AgentHarnessSessionConflictError;
 export interface StoredAgentHarnessSession {
     id: string;
     harnessName: string;
@@ -12,6 +16,7 @@ export interface StoredAgentHarnessSession {
     resolvedApprovalIds?: string[];
     ownerEmail?: string | null;
     orgId?: string | null;
+    generation: number;
     createdAt: number;
     updatedAt: number;
     stoppedAt?: number | null;
@@ -30,6 +35,10 @@ export interface SaveAgentHarnessSessionInput {
     ownerEmail?: string | null;
     orgId?: string | null;
     stoppedAt?: number | null;
+    /** Internal optimistic-concurrency token used by updateAgentHarnessSession. */
+    expectedGeneration?: number;
+    /** Snapshot used by updateAgentHarnessSession so merge and CAS share a read. */
+    existingSession?: StoredAgentHarnessSession | null;
 }
 export declare function ensureAgentHarnessSessionTables(): Promise<void>;
 export declare function saveAgentHarnessSession(input: SaveAgentHarnessSessionInput): Promise<StoredAgentHarnessSession>;

package/dist/agent/harness/store.js

@@ -1,5 +1,16 @@
 import { getDbExec, intType, isPostgres } from "../../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../../db/ddl-guard.js";
+export class AgentHarnessSessionConflictError extends Error {
+    constructor(sessionId) {
+        super(`Harness session ${sessionId} changed concurrently; retry the operation.`);
+        this.name = "AgentHarnessSessionConflictError";
+    }
+}
+export function isAgentHarnessSessionConflictError(error) {
+    return (error instanceof AgentHarnessSessionConflictError ||
+        (error instanceof Error &&
+            error.name === "AgentHarnessSessionConflictError"));
+}
 let initPromise;
 export async function ensureAgentHarnessSessionTables() {
     if (!initPromise) {
@@ -19,6 +30,7 @@ export async function ensureAgentHarnessSessionTables() {
           resolved_approval_ids TEXT,
           owner_email TEXT,
           org_id TEXT,
+          generation ${intType()} NOT NULL DEFAULT 0,
           created_at ${intType()} NOT NULL,
           updated_at ${intType()} NOT NULL,
           stopped_at ${intType()}
@@ -41,6 +53,7 @@ export async function ensureAgentHarnessSessionTables() {
                     await ensureColumnExists("agent_harness_sessions", col, `ALTER TABLE agent_harness_sessions ADD COLUMN IF NOT EXISTS ${col} TEXT`);
                 }
                 await ensureColumnExists("agent_harness_sessions", "stopped_at", `ALTER TABLE agent_harness_sessions ADD COLUMN IF NOT EXISTS stopped_at ${intType()}`);
+                await ensureColumnExists("agent_harness_sessions", "generation", `ALTER TABLE agent_harness_sessions ADD COLUMN IF NOT EXISTS generation ${intType()} NOT NULL DEFAULT 0`);
                 await ensureIndexExists("idx_agent_harness_sessions_thread", `CREATE INDEX IF NOT EXISTS idx_agent_harness_sessions_thread ON agent_harness_sessions(thread_id, updated_at)`);
                 await ensureIndexExists("idx_agent_harness_sessions_status", `CREATE INDEX IF NOT EXISTS idx_agent_harness_sessions_status ON agent_harness_sessions(status, updated_at)`);
                 await ensureIndexExists("idx_agent_harness_sessions_owner", `CREATE INDEX IF NOT EXISTS idx_agent_harness_sessions_owner ON agent_harness_sessions(owner_email, updated_at)`);
@@ -48,6 +61,13 @@ export async function ensureAgentHarnessSessionTables() {
             }
             // SQLite (local dev): no lock problem — keep the original behaviour.
             await client.execute(createSql);
+            try {
+                await client.execute(`ALTER TABLE agent_harness_sessions ADD COLUMN generation ${intType()} NOT NULL DEFAULT 0`);
+            }
+            catch (error) {
+                if (!isDuplicateColumnError(error))
+                    throw error;
+            }
             for (const col of [
                 "run_id",
                 "provider_session_id",
@@ -99,7 +119,9 @@ export async function ensureAgentHarnessSessionTables() {
 export async function saveAgentHarnessSession(input) {
     await ensureAgentHarnessSessionTables();
     const now = Date.now();
-    const existing = await getAgentHarnessSession(input.id);
+    const existing = input.existingSession === undefined
+        ? await getAgentHarnessSession(input.id)
+        : input.existingSession;
     const record = {
         id: input.id,
         harnessName: input.harnessName,
@@ -117,33 +139,60 @@ export async function saveAgentHarnessSession(input) {
         resolvedApprovalIds: input.resolvedApprovalIds ?? existing?.resolvedApprovalIds ?? [],
         ownerEmail: input.ownerEmail ?? existing?.ownerEmail ?? null,
         orgId: input.orgId ?? existing?.orgId ?? null,
+        generation: (input.expectedGeneration ?? existing?.generation ?? 0) + 1,
         createdAt: existing?.createdAt ?? now,
         updatedAt: now,
         stoppedAt: input.stoppedAt ?? existing?.stoppedAt ?? null,
     };
     const client = getDbExec();
-    await client.execute({
-        sql: `INSERT INTO agent_harness_sessions (
-            id, harness_name, thread_id, run_id, provider_session_id, status,
-            resume_state, workspace_ref, pending_approval, resolved_approval_ids,
-            owner_email, org_id, created_at, updated_at, stopped_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-          ON CONFLICT(id) DO UPDATE SET
-            harness_name = excluded.harness_name,
-            thread_id = excluded.thread_id,
-            run_id = excluded.run_id,
-            provider_session_id = excluded.provider_session_id,
-            status = excluded.status,
-            resume_state = excluded.resume_state,
-            workspace_ref = excluded.workspace_ref,
-            pending_approval = excluded.pending_approval,
-            resolved_approval_ids = excluded.resolved_approval_ids,
-            owner_email = excluded.owner_email,
-            org_id = excluded.org_id,
-            updated_at = excluded.updated_at,
-            stopped_at = excluded.stopped_at`,
+    const values = [
+        record.id,
+        record.harnessName,
+        record.threadId,
+        record.runId ?? null,
+        record.providerSessionId ?? null,
+        record.status,
+        serializeJson(record.resumeState),
+        record.workspaceRef ?? null,
+        serializeJson(record.pendingApproval),
+        serializeJson(record.resolvedApprovalIds),
+        record.ownerEmail ?? null,
+        record.orgId ?? null,
+        record.generation,
+        record.createdAt,
+        record.updatedAt,
+        record.stoppedAt ?? null,
+    ];
+    if (!existing) {
+        const inserted = await client.execute({
+            sql: `INSERT INTO agent_harness_sessions (
+              id, harness_name, thread_id, run_id, provider_session_id, status,
+              resume_state, workspace_ref, pending_approval, resolved_approval_ids,
+              owner_email, org_id, generation, created_at, updated_at, stopped_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO NOTHING`,
+            args: values,
+        });
+        if (inserted.rowsAffected === 1)
+            return record;
+        const current = await getAgentHarnessSession(input.id);
+        if (!current)
+            throw new Error("Harness session insert did not persist.");
+        return saveAgentHarnessSession({
+            ...input,
+            expectedGeneration: undefined,
+            existingSession: undefined,
+        });
+    }
+    const expectedGeneration = input.expectedGeneration ?? existing.generation;
+    const updated = await client.execute({
+        sql: `UPDATE agent_harness_sessions SET
+            harness_name = ?, thread_id = ?, run_id = ?, provider_session_id = ?,
+            status = ?, resume_state = ?, workspace_ref = ?, pending_approval = ?,
+            resolved_approval_ids = ?, owner_email = ?, org_id = ?, generation = ?,
+            updated_at = ?, stopped_at = ?
+          WHERE id = ? AND generation = ?`,
         args: [
-            record.id,
             record.harnessName,
             record.threadId,
             record.runId ?? null,
@@ -155,11 +204,16 @@ export async function saveAgentHarnessSession(input) {
             serializeJson(record.resolvedApprovalIds),
             record.ownerEmail ?? null,
             record.orgId ?? null,
-            record.createdAt,
+            record.generation,
             record.updatedAt,
             record.stoppedAt ?? null,
+            record.id,
+            expectedGeneration,
         ],
     });
+    if (updated.rowsAffected !== 1) {
+        throw new AgentHarnessSessionConflictError(record.id);
+    }
     return record;
 }
 export async function updateAgentHarnessSession(id, patch) {
@@ -184,6 +238,8 @@ export async function updateAgentHarnessSession(id, patch) {
         ownerEmail: patch.ownerEmail ?? existing.ownerEmail ?? null,
         orgId: patch.orgId ?? existing.orgId ?? null,
         stoppedAt: patch.stoppedAt ?? existing.stoppedAt ?? null,
+        expectedGeneration: existing.generation,
+        existingSession: existing,
     });
 }
 export async function getAgentHarnessSession(id) {
@@ -298,6 +354,7 @@ function rowToHarnessSession(row) {
         resolvedApprovalIds: stringArray(record.resolved_approval_ids),
         ownerEmail: stringOrNull(record.owner_email),
         orgId: stringOrNull(record.org_id),
+        generation: numberValue(record.generation),
         createdAt: numberValue(record.created_at),
         updatedAt: numberValue(record.updated_at),
         stoppedAt: record.stopped_at === null || record.stopped_at === undefined
@@ -344,3 +401,10 @@ function stringOrNull(value) {
 function numberValue(value) {
     return typeof value === "number" ? value : Number(value ?? 0);
 }
+function isDuplicateColumnError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const message = error.message;
+    return (typeof message === "string" &&
+        /duplicate column name|column .* already exists/i.test(message));
+}

package/dist/agent/production-agent.d.ts

@@ -730,6 +730,7 @@ export interface ExecuteAgentToolCallOptions {
     approvedToolCalls?: string[];
     onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
+    isToolAlwaysAllowed?: (binding: AgentApprovalBinding) => Promise<boolean>;
     send?: (event: AgentChatEvent) => void;
 }
 export interface AgentApprovalBinding {
@@ -915,6 +916,8 @@ export declare function runAgentLoop(opts: {
      */
     onApprovalRequired?: (binding: AgentApprovalBinding) => Promise<string | void>;
     consumeApproval?: (binding: AgentApprovalBinding) => Promise<boolean>;
+    /** User-scoped action-type policy, checked only after needsApproval. */
+    isToolAlwaysAllowed?: (binding: AgentApprovalBinding) => Promise<boolean>;
     /**
      * In-loop processor seam (see `processors.ts`). Each processor can observe
      * streamed chunks, observe model responses around tool execution, and

package/dist/agent/production-agent.js

@@ -43,7 +43,7 @@ import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js
 import { startRun, subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortTurnDurably, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, endsAfterCompletedToolWithoutAssistantFinal, } from "./run-manager.js";
 import { writeLedgerEntry, readLedgerEntry, clearLedgerForThread, insertRun, insertRunEvent, isTurnAborted, markRunAborted, updateRunHeartbeat, updateRunStatusIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn, RUN_DIAG_STAGE, UNCLAIMED_BACKGROUND_RUN_GRACE_MS, turnRunLedgerExhausted, } from "./run-store.js";
 import { buildCurrentTimeUserContext } from "./runtime-context.js";
-import { consumeAgentToolApproval, createAgentToolApproval, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
+import { consumeAgentToolApproval, createAgentToolApproval, isAgentToolAlwaysAllowed, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
 import { findCompletedJournalEntry, } from "./tool-call-journal.js";
 import { redactSensitiveFields, sanitizeToolErrorText, sanitizeToolErrorValue, } from "./tool-error-redaction.js";
 import { describeToolResultImages, extractAgentImagesFromActionResult, } from "./tool-result-images.js";
@@ -2274,6 +2274,7 @@ export async function executeAgentToolCall(options) {
             approvedToolCalls: options.approvedToolCalls,
             onApprovalRequired: options.onApprovalRequired,
             consumeApproval: options.consumeApproval,
+            isToolAlwaysAllowed: options.isToolAlwaysAllowed,
         });
     }
     catch (error) {
@@ -4359,6 +4360,16 @@ export async function runAgentLoop(opts) {
                     // than silently running a high-consequence action.
                     mustApprove = true;
                 }
+                if (mustApprove && opts.isToolAlwaysAllowed) {
+                    try {
+                        mustApprove = !(await opts.isToolAlwaysAllowed(approvalBinding));
+                    }
+                    catch {
+                        // Fail closed: an unreadable policy must leave the approval gate in
+                        // place instead of turning a storage outage into authorization.
+                        mustApprove = true;
+                    }
+                }
                 if (mustApprove) {
                     // `askId` identifies THIS gate hit, distinct from any earlier ask
                     // for the same approvalKey/toolCallId. A failed resume (expired
@@ -7226,6 +7237,15 @@ export function createProductionAgentHandler(options) {
                     return false;
                 return consumeAgentToolApproval(approvalStoreBinding(binding));
             },
+            isToolAlwaysAllowed: async (binding) => {
+                if (!ownerEmail)
+                    return false;
+                return isAgentToolAlwaysAllowed({
+                    ownerEmail,
+                    orgId: getRequestOrgId() ?? null,
+                    toolName: binding.toolName,
+                });
+            },
         };
         const approvedToolCallsForExecution = requestedApprovedToolCalls;
         if (isBackgroundWorker &&
@@ -8074,6 +8094,7 @@ export function createProductionAgentHandler(options) {
                     : {}),
                 onApprovalRequired: approvalHooks.onApprovalRequired,
                 consumeApproval: approvalHooks.consumeApproval,
+                isToolAlwaysAllowed: approvalHooks.isToolAlwaysAllowed,
                 // A worker PROVEN to be running inside the real 15-min Netlify
                 // `-background` function (`runsInBackgroundFunction`) has minutes of
                 // budget left on THIS invocation. Let it catch a recoverable
@@ -8119,6 +8140,7 @@ export function createProductionAgentHandler(options) {
                         approvedToolCalls: approvedToolCallsForExecution,
                         onApprovalRequired: approvalHooks.onApprovalRequired,
                         consumeApproval: approvalHooks.consumeApproval,
+                        isToolAlwaysAllowed: approvalHooks.isToolAlwaysAllowed,
                         send,
                     });
                     return;

package/dist/agent/run-manager.js

@@ -663,6 +663,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         ? new AbortController()
         : null;
     let chunkBoundaryReason = null;
+    let chunkSoftTimeoutTimer = null;
+    let armChunkSoftTimeout = () => { };
+    let recoverableRunDeadlineAt = null;
     let recoveredChunkBoundaries = 0;
     /** A boundary that has been reached but not yet proven recovered. */
     let pendingBoundary = null;
@@ -706,7 +709,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 return abort.signal;
             settleBoundary(true);
             chunkBoundaryReason = null;
+            if (chunkSoftTimeoutTimer)
+                clearTimeout(chunkSoftTimeoutTimer);
             chunkAbort = new AbortController();
+            armChunkSoftTimeout();
             // The boundary is behind us; the silence clock restarts with the chunk,
             // or the backstop fires again on the elapsed time of the chunk it just
             // ended and every recovery round dies instantly.
@@ -1079,8 +1085,12 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     const reachRunBoundary = (reason, diagnostic = {}) => {
         if (run.status !== "running" || abort.signal.aborted)
             return;
-        if (chunkAbort) {
-            if (chunkAbort.signal.aborted)
+        const activeChunkAbort = chunkAbort;
+        const canRecoverChunk = activeChunkAbort !== null &&
+            (recoverableRunDeadlineAt === null ||
+                Date.now() < recoverableRunDeadlineAt);
+        if (canRecoverChunk) {
+            if (activeChunkAbort.signal.aborted)
                 return;
             recoveredChunkBoundaries += 1;
             console.warn(`[run-manager] chunk boundary (${reason}) — recovering in-invocation`, runId, diagnostic);
@@ -1092,9 +1102,11 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             // direction that hides the failure.
             pendingBoundary = { reason, diagnostic, index: recoveredChunkBoundaries };
             chunkBoundaryReason = reason;
-            chunkAbort.abort(reason);
+            activeChunkAbort.abort(reason);
             return;
         }
+        if (chunkAbort)
+            chunkBoundaryReason = reason;
         // Mirror the soft-timeout semantics exactly: the chunk completes (not
         // aborts) at an auto_continue boundary, so the continuation machinery —
         // server-chained for background workers, client-driven for foreground —
@@ -1277,12 +1289,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         overrideMs: options?.noProgressTimeoutMs,
         backgroundOverrideMs: options?.backgroundNoProgressTimeoutMs,
     });
-    // Not armed for a runFn that recovers boundaries in this invocation. That
-    // runFn already races the SAME wall with its own per-round timer, budgeted
-    // against cumulative elapsed time — so this timer fires at the moment the
-    // wrapper has nothing left to continue with, producing a boundary that is
-    // recoverable in name only and burning the tail of the budget on nothing.
-    // One wall, one clock; the caller's hard abort still backstops it.
+    // A recoverable run uses the cumulative timer below instead of this one-shot
+    // timer. Each successor chunk gets only the remaining invocation budget, so
+    // recovery cannot extend the hosted wall. The caller's hard abort still
+    // backstops both timer paths.
     const softTimeoutTimer = softTimeoutMs > 0 && !recoverChunkBoundaries
         ? setTimeout(() => {
             reachRunBoundary("run_timeout", {
@@ -1290,6 +1300,25 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             });
         }, softTimeoutMs)
         : null;
+    if (recoverChunkBoundaries && softTimeoutMs > 0) {
+        const runDeadlineAt = Date.now() + softTimeoutMs;
+        recoverableRunDeadlineAt = runDeadlineAt;
+        armChunkSoftTimeout = () => {
+            if (chunkSoftTimeoutTimer)
+                clearTimeout(chunkSoftTimeoutTimer);
+            if (abort.signal.aborted || run.status !== "running")
+                return;
+            chunkSoftTimeoutTimer = setTimeout(() => {
+                chunkSoftTimeoutTimer = null;
+                reachRunBoundary("run_timeout", {
+                    lastEventType: run.events.at(-1)?.event.type,
+                });
+            }, Math.max(0, runDeadlineAt - Date.now()));
+        };
+        // Boundary recovery disables the ordinary one-shot timer, so arm the
+        // cumulative invocation deadline on the initial chunk and each successor.
+        armChunkSoftTimeout();
+    }
     let pendingTerminalEvent = null;
     const captureRunError = (error, phase) => {
         const errorCode = getRunErrorCode(error);
@@ -1638,6 +1667,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         clearInterval(heartbeatTimer);
         if (softTimeoutTimer)
             clearTimeout(softTimeoutTimer);
+        if (chunkSoftTimeoutTimer)
+            clearTimeout(chunkSoftTimeoutTimer);
         if (progressWriteTimer)
             clearTimeout(progressWriteTimer);
         progressWriteTimer = null;