@agent-native/core 0.219.0 → 0.220.0-nightly-20261023212848

package/dist/action.d.ts

@@ -106,6 +106,20 @@ export interface FailOptions {
     details?: Record<string, unknown>;
 }
 export declare function fail(message: string, options?: FailOptions): never;
+/**
+ * A rejection raised before the action's first write: a missing target, an
+ * edit that matches nothing, a patch identical to what is saved. A caller may
+ * then retry with corrected arguments instead of treating the call as
+ * possibly applied. The framework accepts the claim only for the call that
+ * raised it, and only when no write action nested in that call entered its
+ * handler; otherwise it reads as any other failure. It cannot see the
+ * handler's own database or provider writes, so throw it before the first.
+ */
+export declare class NoWriteError extends ActionContractError {
+    readonly noWrite = true;
+    constructor(message: string, options?: FailOptions);
+}
+export declare function isNoWriteError(error: unknown): error is NoWriteError;
 export type { ActionMcpOutputContract } from "./action-output-contract.js";
 /** What a call that broke its output contract already did. `run` returned
  *  before the check, so a non-read-only call's changes are applied. */
@@ -136,8 +150,9 @@ export declare function isActionOutputContractError(error: unknown): error is Ac
 /**
  * What a failed call had already done, when its failure came after `run`
  * returned: an output-contract error, or a stop or connection signal raised
- * while its result was checked. `undefined` when the failure carries no such
- * evidence, so the caller must not assume the call changed nothing.
+ * while its result was checked; or a verified `NoWriteError`. `undefined`
+ * when the failure carries no such evidence, so the caller must not assume
+ * the call changed nothing.
  */
 export declare function actionFailureEffect(error: unknown): ActionOutputEffect | undefined;
 /** What a dispatched call did, and whether other sessions must refresh. */
@@ -167,10 +182,15 @@ export declare function invocationEffect(entry: {
     receipt?: {
         changed: boolean;
     };
-    /** It failed, with what it threw; `lost` when its result never came. */
+    /**
+     * It failed, with what it threw; `lost` when its result never came;
+     * `reported` when it returned an error result instead, such as an MCP
+     * tool's `isError`, which says the tool did not do its work.
+     */
     failed?: {
         error?: unknown;
         lost?: boolean;
+        reported?: boolean;
     };
 }): InvocationEffect;
 /** Whether a failed call must publish an action change. */

package/dist/action.js

@@ -76,6 +76,32 @@ export function fail(message, options = {}) {
         ...(options.details === undefined ? {} : { details: options.details }),
     });
 }
+/**
+ * A rejection raised before the action's first write: a missing target, an
+ * edit that matches nothing, a patch identical to what is saved. A caller may
+ * then retry with corrected arguments instead of treating the call as
+ * possibly applied. The framework accepts the claim only for the call that
+ * raised it, and only when no write action nested in that call entered its
+ * handler; otherwise it reads as any other failure. It cannot see the
+ * handler's own database or provider writes, so throw it before the first.
+ */
+export class NoWriteError extends ActionContractError {
+    noWrite = true;
+    constructor(message, options = {}) {
+        super(message, {
+            errorCode: options.errorCode ?? "action_failed",
+            statusCode: options.statusCode ?? 400,
+            ...(options.details === undefined ? {} : { details: options.details }),
+        });
+        this.name = "NoWriteError";
+    }
+}
+export function isNoWriteError(error) {
+    return (isActionContractError(error) &&
+        error.noWrite === true);
+}
+/** Each `NoWriteError` the call that raised it was verified to have written nothing in. */
+const verifiedNoWrites = new WeakSet();
 const MAX_REPORTED_OUTPUT_ISSUES = 5;
 const MAX_DETAILED_OUTPUT_ISSUES = 50;
 function actionSubject(actionName) {
@@ -126,10 +152,16 @@ export function isActionOutputContractError(error) {
 /**
  * What a failed call had already done, when its failure came after `run`
  * returned: an output-contract error, or a stop or connection signal raised
- * while its result was checked. `undefined` when the failure carries no such
- * evidence, so the caller must not assume the call changed nothing.
+ * while its result was checked; or a verified `NoWriteError`. `undefined`
+ * when the failure carries no such evidence, so the caller must not assume
+ * the call changed nothing.
  */
 export function actionFailureEffect(error) {
+    if (error !== null &&
+        typeof error === "object" &&
+        verifiedNoWrites.has(error)) {
+        return "none";
+    }
     if (isActionOutputContractError(error))
         return error.effect;
     if (!isAgentActionStopError(error))
@@ -170,6 +202,10 @@ export function invocationEffect(entry, outcome, settled) {
         return { effect: "none", changed: false };
     if (outcome.keyed && !record)
         return { effect: "unknown", changed: true };
+    // The report speaks for the tool, not for a write nested in the call.
+    if (failed?.reported && !failed.lost && !evidence?.nestedWriteEntered) {
+        return { effect: "none", changed: false };
+    }
     // A typed effect speaks for the call that raised it, not for one it passed
     // through. Untracked, nothing names that call, so it stands.
     const typed = failed && !failed.lost && (!evidence || evidence.raised === failed.error)
@@ -183,7 +219,7 @@ export function invocationEffect(entry, outcome, settled) {
     }
     const wrote = record ? record.evidence.writeEntered : readOnly !== true;
     const changed = record
-        ? record.evidence.changeEntered
+        ? record.evidence.changeEntered && !(failed && typed === "none")
         : entry.changeEvents !== false && (failed ? typed === "committed" : wrote);
     const effect = !failed
         ? (settled.receipt?.changed ?? wrote)
@@ -346,6 +382,14 @@ function postRunSignal(signal, failure) {
 function withCommittedEffect(error) {
     if (actionFailureEffect(error) !== "none")
         return error;
+    // Its claim holds only for the call that raised it.
+    if (isNoWriteError(error)) {
+        return new ActionContractError(error.message, {
+            errorCode: error.errorCode,
+            statusCode: error.statusCode,
+            ...(error.details === undefined ? {} : { details: error.details }),
+        });
+    }
     if (isActionOutputContractError(error)) {
         return new ActionOutputContractError({
             actionName: error.actionName,
@@ -507,6 +551,17 @@ export function defineAction(options) {
         }
         catch (thrown) {
             const error = readableFailure(thrown);
+            // Raised by this handler, not passed up through a nested call's
+            // boundary, with no nested write entered.
+            if (!ran &&
+                frame &&
+                isNoWriteError(error) &&
+                !frame.nestedWriteEntered &&
+                actionExecutionStorage?.getStore()?.failures.get(error) === undefined) {
+                verifiedNoWrites.add(error);
+                frame.raised = error;
+                throw error;
+            }
             if (!ran && effect() !== "committed")
                 throw error;
             const raised = ran ? error : withCommittedEffect(error);

package/dist/agent/abort-reasons.d.ts

@@ -1,4 +1,10 @@
 export declare const SERVER_OWNED_ABORT_REASONS: Set<string>;
+/**
+ * Finalization skips the terminal write for this reason because the worker's
+ * fence is already stale; an abort for lost ownership spelled any other way
+ * makes finalization attempt a fenced write that must fail.
+ */
+export declare const EXECUTION_LEASE_LOST_ABORT_REASON = "execution_lease_lost";
 /** A person (or a newer run they started) asked this run to stop. */
 export declare function isRequestedStopAbortReason(reason: string): boolean;
 export declare function clientAbortReason(raw: unknown): string;

package/dist/agent/abort-reasons.js

@@ -3,6 +3,12 @@ export const SERVER_OWNED_ABORT_REASONS = new Set([
     "run_timeout",
     "background_automation_hard_timeout",
 ]);
+/**
+ * Finalization skips the terminal write for this reason because the worker's
+ * fence is already stale; an abort for lost ownership spelled any other way
+ * makes finalization attempt a fenced write that must fail.
+ */
+export const EXECUTION_LEASE_LOST_ABORT_REASON = "execution_lease_lost";
 /** A person (or a newer run they started) asked this run to stop. */
 export function isRequestedStopAbortReason(reason) {
     return (reason === "user" ||

package/dist/agent/execution-fence.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { getDbExec } from "../db/client.js";
+import { getDbExec, getScopedTransactionDbExec, } from "../db/client.js";
 export class ExecutionFenceError extends Error {
     code;
     constructor(code, message) {
@@ -106,6 +106,10 @@ export async function withFencedExecutionWrite(write, scope) {
     if (!scopedFence) {
         throw new StaleExecutionFenceError(fence);
     }
+    if (getScopedTransactionDbExec() === client) {
+        await lockAndAssertCurrentExecutionFences(client);
+        return write(client);
+    }
     if (!client.transaction) {
         throw new Error("Fenced execution writes require transaction support");
     }

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

@@ -384,7 +384,7 @@ export interface ProductionAgentOptions {
     runSoftTimeoutMs?: number;
     runNoProgressTimeoutMs?: number;
     durableBackgroundRuns?: boolean;
-    onRunStart?: (send: (event: AgentChatEvent) => void, threadId: string, runId: string) => void | Promise<void>;
+    onRunStart?: (send: (event: AgentChatEvent) => void, threadId: string, runId: string, turnId: string) => void | Promise<void>;
     /**
      * Called when the run's engine, model, and effort resolve, and again before
      * each model call, because a call can run on a rate-limit fallback model or
@@ -579,18 +579,34 @@ export interface TerminalActionStop {
     transcriptMessage?: string;
     errorCode?: string;
     details?: string;
+    /** For `write_tool_outcome_unknown`: the call held back, and why. */
+    blockedTool?: string;
+    blockedBy?: UnknownOutcomeCause;
 }
 /**
- * Earlier calls whose outcome is unknown, counted by tool and by the exact
- * arguments each was prepared with. Any of them holds back every later write
- * of its tool, whatever its arguments; a read only when it is prepared
- * exactly as one of them was, which a call recorded without an identity
- * never is.
+ * Earlier calls whose outcome is unknown, counted by tool, by the exact
+ * arguments each was prepared with, by the arguments the model sent, and by
+ * tool again for those recorded without an identity. A call prepared exactly
+ * as one of them was stops the turn: running it again could apply it twice.
+ * So does a write sent with the same arguments, which a default can prepare
+ * differently, and any write of a tool with an unidentified one, which it may
+ * repeat. A write of the tool with other arguments is declined, and the turn
+ * goes on.
  */
 interface UnknownOutcomes {
     tools: Map<string, number>;
     calls: Map<string, number>;
+    inputs: Map<string, number>;
+    unidentified: Map<string, number>;
+    /** By tool, what made the latest one unknown. */
+    causes: Map<string, UnknownOutcomeCause>;
 }
+/**
+ * `rejection`: the call failed and said so, but nothing showed it wrote
+ * nothing. `interruption`: its result never came (a timeout, a stop, a
+ * continuation boundary or a lost process).
+ */
+type UnknownOutcomeCause = "rejection" | "interruption";
 export declare function actionsToEngineTools(actions: Record<string, ActionEntry>): EngineTool[];
 export type AgentToolCallExecutionResult = {
     status: "completed";