@agent-native/core 0.210.1-nightly-20261020124228 → 0.210.2

package/dist/a2a/server.js

@@ -8,6 +8,7 @@ import { redactArgsToJson } from "../audit/redact.js";
 import { extractBearerToken, verifyInternalToken, } from "../integrations/internal-token.js";
 import { parseServiceIdentityEmail } from "../org/service-identity.js";
 import { assertServicePrincipalMayRun, recordServicePrincipalDenial, ServicePrincipalRefusedError, } from "../org/service-principal-guard.js";
+import { getConfiguredAppBasePath } from "../server/app-base-path.js";
 import { readDeployCredentialEnv } from "../server/credential-provider.js";
 import { getH3App } from "../server/framework-request-handler.js";
 import { publicFrameworkPath } from "../server/framework-route-prefix.js";
@@ -107,7 +108,7 @@ function expectedJwtAudience(event, options) {
         process.env.URL ||
         process.env.DEPLOY_URL ||
         process.env.BETTER_AUTH_URL;
-    const receiverBasePath = process.env.APP_BASE_PATH;
+    const receiverBasePath = getConfiguredAppBasePath() || undefined;
     if (fromEnv) {
         return audienceForRoute(canonicalA2AAudience(String(fromEnv), receiverBasePath), options);
     }

package/dist/agent/contain-principal.js

@@ -5,9 +5,8 @@
  * before the suspend keeps spending its tool budget until it ends. Containment
  * aborts those runs so "suspended" means stopped, not "stops eventually".
  *
- * A run's owner is its chat thread's `owner_email`. `abortRunDurably` logs and
- * swallows a failed SQL write, so the outcome is re-read from `agent_runs`:
- * only a confirmed `aborted` status counts as aborted.
+ * A run's owner is its chat thread's `owner_email`. A run counts as contained
+ * only after its durable status is confirmed as `aborted`.
  */
 import { ensureChatThreadTables } from "../chat-threads/store.js";
 import { getDbExec } from "../db/client.js";

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

@@ -13,6 +13,7 @@ import { clampThinkingBudgetTokens, resolveMaxOutputTokensForEngine, } from "./o
 import { createProviderToolNameMap } from "./tool-name.js";
 import { engineToolsToAISDK, engineMessagesToAISDK, aiSdkPartToEngineEvents, aiSdkStepToAssistantContent, } from "./translate-ai-sdk.js";
 import { createStreamedToolInputState, finalizeStreamedToolInputs, observeStreamedToolInput, } from "./translate-anthropic.js";
+import { startModelDispatch } from "./types.js";
 const PROVIDER_CAPABILITIES = {
     anthropic: {
         thinking: true,
@@ -385,27 +386,35 @@ class AISDKEngine {
         let assistantContent = [];
         const firstEventAbort = createFirstEventAbortController(opts.abortSignal);
         const toolInputs = createStreamedToolInputState();
+        const dispatch = await startModelDispatch(opts, () => streamText({
+            model: providerModel,
+            system: opts.systemPrompt,
+            messages,
+            tools: aiSdkTools,
+            ...(this.omitMaxOutputTokens
+                ? {}
+                : { maxOutputTokens: resolvedMaxOutputTokens }),
+            maxRetries: 1,
+            ...(samplingAllowed && opts.temperature !== undefined
+                ? { temperature: opts.temperature }
+                : {}),
+            abortSignal: firstEventAbort.signal,
+            onStepFinish: (step) => {
+                assistantContent = aiSdkStepToAssistantContent(step, toolNameMap);
+            },
+            ...(Object.keys(providerOpts).length > 0
+                ? { providerOptions: providerOpts }
+                : {}),
+        })).catch((error) => {
+            firstEventAbort.cleanup();
+            throw error;
+        });
+        if (!dispatch.started) {
+            firstEventAbort.cleanup();
+            return;
+        }
+        const result = dispatch.value;
         try {
-            const result = streamText({
-                model: providerModel,
-                system: opts.systemPrompt,
-                messages,
-                tools: aiSdkTools,
-                ...(this.omitMaxOutputTokens
-                    ? {}
-                    : { maxOutputTokens: resolvedMaxOutputTokens }),
-                maxRetries: 1,
-                ...(samplingAllowed && opts.temperature !== undefined
-                    ? { temperature: opts.temperature }
-                    : {}),
-                abortSignal: firstEventAbort.signal,
-                onStepFinish: (step) => {
-                    assistantContent = aiSdkStepToAssistantContent(step, toolNameMap);
-                },
-                ...(Object.keys(providerOpts).length > 0
-                    ? { providerOptions: providerOpts }
-                    : {}),
-            });
             let bufferedStop;
             let sawFirstEvent = false;
             let credentialFailureRecorded = false;

package/dist/agent/engine/anthropic-engine.js

@@ -10,6 +10,7 @@ import { clampThinkingBudgetTokens, resolveMaxOutputTokensForEngine, } from "./o
 import { splitSystemPromptForCache, stablePrefixCacheControl, } from "./prompt-cache.js";
 import { createProviderToolNameMap } from "./tool-name.js";
 import { engineToolsToAnthropic, engineMessagesToAnthropic, anthropicContentToEngine, anthropicChunkToEngineEvents, createAnthropicChunkStreamState, createStreamedToolInputState, finalizeStreamedToolInputs, observeStreamedToolInput, } from "./translate-anthropic.js";
+import { startModelDispatch } from "./types.js";
 export const ANTHROPIC_CAPABILITIES = {
     thinking: true,
     promptCaching: true,
@@ -126,9 +127,17 @@ class AnthropicEngine {
         if (!requestParams.tools)
             delete requestParams.tools;
         const firstEventAbort = createFirstEventAbortController(opts.abortSignal);
-        const apiStream = client.messages.stream(requestParams, {
+        const dispatch = await startModelDispatch(opts, () => client.messages.stream(requestParams, {
             signal: firstEventAbort.signal,
+        })).catch((error) => {
+            firstEventAbort.cleanup();
+            throw error;
         });
+        if (!dispatch.started) {
+            firstEventAbort.cleanup();
+            return;
+        }
+        const apiStream = dispatch.value;
         const chunkState = createAnthropicChunkStreamState();
         const toolInputs = createStreamedToolInputState();
         try {

package/dist/agent/engine/builder-engine.js

@@ -17,6 +17,7 @@ import { resolveMaxOutputTokensForEngine } from "./output-tokens.js";
 import { splitSystemPromptForCache, stablePrefixCacheControl, } from "./prompt-cache.js";
 import { createProviderToolNameMap, toEngineToolName, } from "./tool-name.js";
 import { createStreamedToolInputState, engineMessagesToBuilderGatewayAnthropic, engineToolsToAnthropic, finalizeStreamedToolInputs, observeStreamedToolInput, } from "./translate-anthropic.js";
+import { startModelDispatch } from "./types.js";
 export const BUILDER_CAPABILITIES = {
     thinking: true,
     promptCaching: true,
@@ -243,22 +244,35 @@ class BuilderEngine {
         const gatewayTimeoutMs = getBuilderGatewayTimeoutMs();
         const gatewayAbort = createGatewayAbortSignal(opts.abortSignal, gatewayTimeoutMs);
         try {
+            const dispatch = await startModelDispatch(opts, () => {
+                try {
+                    return fetch(gatewayUrl.toString(), {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            Authorization: authHeader,
+                            ...(spaceId && !oauthAccess
+                                ? { "x-builder-api-key": spaceId }
+                                : {}),
+                            ...getBuilderGatewayRequestHeaders(),
+                            ...(builderUserId ? { "x-builder-user-id": builderUserId } : {}),
+                        },
+                        body: payload,
+                        signal: gatewayAbort.signal,
+                    }).then((response) => ({ status: "fulfilled", response }), (error) => ({ status: "rejected", error }));
+                }
+                catch (error) {
+                    return Promise.resolve({ status: "rejected", error });
+                }
+            });
+            if (!dispatch.started)
+                return;
             let response;
             try {
-                response = await fetch(gatewayUrl.toString(), {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Authorization: authHeader,
-                        ...(spaceId && !oauthAccess
-                            ? { "x-builder-api-key": spaceId }
-                            : {}),
-                        ...getBuilderGatewayRequestHeaders(),
-                        ...(builderUserId ? { "x-builder-user-id": builderUserId } : {}),
-                    },
-                    body: payload,
-                    signal: gatewayAbort.signal,
-                });
+                const result = await dispatch.value;
+                if (result.status === "rejected")
+                    throw result.error;
+                response = result.response;
             }
             catch (err) {
                 const timedOut = gatewayAbort.didTimeout();

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

@@ -165,6 +165,14 @@ export interface EngineCapabilities {
     computerUse: boolean;
     parallelToolCalls: boolean;
 }
+export type ModelDispatchDecision<T> = {
+    started: true;
+    value: T;
+} | {
+    started: false;
+};
+/** Runs the synchronous request start while the caller's coordination lock is held. */
+export type BeforeModelDispatch = <T>(dispatch: () => T) => Promise<ModelDispatchDecision<T>>;
 export interface EngineStreamOptions {
     model: string;
     systemPrompt: string;
@@ -174,6 +182,8 @@ export interface EngineStreamOptions {
     maxOutputTokens?: number;
     temperature?: number;
     reasoningEffort?: ReasoningEffort;
+    beforeModelDispatch?: BeforeModelDispatch;
+    onModelDispatchStarted?: () => void;
     providerOptions?: {
         anthropic?: {
             thinking?: {
@@ -190,6 +200,7 @@ export interface EngineStreamOptions {
         [provider: string]: Record<string, unknown> | undefined;
     };
 }
+export declare function startModelDispatch<T>(options: Pick<EngineStreamOptions, "beforeModelDispatch" | "onModelDispatchStarted">, dispatch: () => T): Promise<ModelDispatchDecision<T>>;
 export interface AgentEngine {
     readonly name: string;
     readonly label: string;

package/dist/agent/engine/types.js

@@ -20,3 +20,11 @@ export class EngineError extends Error {
         this.retryAfterMs = opts?.retryAfterMs;
     }
 }
+export async function startModelDispatch(options, dispatch) {
+    const result = options.beforeModelDispatch
+        ? await options.beforeModelDispatch(dispatch)
+        : { started: true, value: dispatch() };
+    if (result.started)
+        options.onModelDispatchStarted?.();
+    return result;
+}

package/dist/agent/execution-fence.d.ts

@@ -16,6 +16,11 @@ export declare class MissingExecutionFenceError extends ExecutionFenceError {
     constructor();
 }
 export declare function currentExecutionFence(): ExecutionFence | undefined;
+export declare function currentExecutionFenceForScope(scope: {
+    runId?: string;
+    threadId?: string;
+    turnId?: string;
+}): ExecutionFence | undefined;
 export declare function withExecutionLeaseRequested<T>(work: () => T): T;
 export declare function withExecutionFence<T>(fence: ExecutionFence, work: () => T): T;
 export declare function lockAndAssertCurrentExecutionFences(tx: DbExec): Promise<void>;

package/dist/agent/execution-fence.js

@@ -27,6 +27,21 @@ export function currentExecutionFence() {
     }
     return fence;
 }
+export function currentExecutionFenceForScope(scope) {
+    const context = executionFenceStorage.getStore();
+    const fence = context?.fences.find((candidate) => (!scope.runId || scope.runId === candidate.runId) &&
+        (!scope.threadId || scope.threadId === candidate.threadId) &&
+        (!scope.turnId || scope.turnId === candidate.turnId));
+    if (fence)
+        return fence;
+    if (context?.executionLeaseRequested) {
+        const activeFence = context.fences.at(-1);
+        if (!activeFence)
+            throw new MissingExecutionFenceError();
+        throw new StaleExecutionFenceError(activeFence);
+    }
+    return undefined;
+}
 export function withExecutionLeaseRequested(work) {
     const current = executionFenceStorage.getStore();
     return executionFenceStorage.run({

package/dist/agent/harness/background.js

@@ -1,5 +1,5 @@
 import { redactArgsToValue, redactTextToSummary } from "../../audit/redact.js";
-import { abortRun } from "../run-manager.js";
+import { abortRunDurably } from "../run-manager.js";
 import { getRunEventsSince } from "../run-store.js";
 import { resolveAgentHarnessApproval, sendAgentHarnessFollowUp, stopLiveAgentHarnessSession, } from "./lifecycle.js";
 import { getAgentHarnessSessionByRunId, listAgentHarnessSessions, markAgentHarnessSessionStopped, } from "./store.js";
@@ -63,14 +63,35 @@ export async function stopAgentHarnessBackgroundRun(runId, options = {
         (options.orgId !== undefined && session.orgId !== options.orgId)) {
         return missingHarnessRunResult(runId);
     }
+    const failures = [];
     if (session.runId) {
-        abortRun(session.runId, "user");
+        try {
+            await abortRunDurably(session.runId, "user", { allowNotStarted: true });
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    try {
+        await stopLiveAgentHarnessSession({
+            sessionId: session.id,
+            scope: options,
+        });
+    }
+    catch (error) {
+        failures.push(error);
+    }
+    try {
+        await markAgentHarnessSessionStopped(session.id, failures.length > 0 ? "errored" : "stopped");
+    }
+    catch (error) {
+        failures.push(error);
+    }
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length > 1) {
+        throw new AggregateError(failures, "Agent Harness background stop failed.");
     }
-    await stopLiveAgentHarnessSession({
-        sessionId: session.id,
-        scope: options,
-    });
-    await markAgentHarnessSessionStopped(session.id, "stopped");
     return {
         ok: true,
         runId,

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

@@ -18,9 +18,9 @@ import { type ReasoningEffort } from "../shared/reasoning-effort.js";
 import type { TrackingMeta } from "../tracking/registry.js";
 import { type ResolveEngineConfig } from "./engine/index.js";
 import { PROVIDER_TO_ENV } from "./engine/provider-env-vars.js";
-import type { AgentEngine, EngineTool, EngineMessage, EngineContentPart, EngineImagePart } from "./engine/types.js";
+import type { AgentEngine, EngineTool, EngineMessage, EngineContentPart, EngineImagePart, BeforeModelDispatch } from "./engine/types.js";
 import { type Processor } from "./processors.js";
-import { subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably } from "./run-manager.js";
+import { subscribeToRun, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably } from "./run-manager.js";
 import type { ActiveRun } from "./run-manager.js";
 import { type AgentTurnInitiator, insertRun, isTurnAborted, markRunAborted, updateRunHeartbeat, updateRunStatusIfRunning, updateRunTerminalStateIfRunning, setRunError, setRunTerminalReason, claimBackgroundRun, readBackgroundRunClaim, recordRunDiagnostic, countRunsForTurn } from "./run-store.js";
 import { type AgentActionScope, ActionTool, AgentChatAttachment, AgentChatEvent, AgentFileMutationProof, AgentChatReference, AgentChatStructuredMessage } from "./types.js";
@@ -731,6 +731,7 @@ export declare function runAgentLoop(opts: {
     send: (event: AgentChatEvent) => void | Promise<void>;
     signal: AbortSignal;
     beforeWrite?: () => Promise<void>;
+    beforeModelDispatch?: BeforeModelDispatch;
     unknownWriteToolNames?: Set<string>;
     /** The request's unknown outcomes, which each of its loops feeds and holds by. */
     unknownOutcomes?: UnknownOutcomes;
@@ -992,4 +993,4 @@ export declare function resolveAgentModelSelection(options: {
     source: AgentModelSelectionSource;
 };
 export declare function createProductionAgentHandler(options: ProductionAgentOptions): H3EventHandler;
-export { getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, };
+export { getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, };

package/dist/agent/production-agent.js

@@ -85,7 +85,7 @@ import { getContextWindowForModel, resolveFallbackModel, } from "./model-config.
 import { maybeCompactThread, buildObservationalContext, hasObservationalMemory, serializeObservationalMemoryBlock, } from "./observational-memory/index.js";
 import { ProcessorChain, TripWire, toolCallsFromContent, } from "./processors.js";
 import { applyUncheckedDefaultModelReplacement } from "./provider-model-selection.js";
-import { startRun, subscribeToRun, replayCompletedTurn, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, getSlotHoldingRunId, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, endsAfterToolResultWithoutAssistantFinal, endsDuringActionPreparation, } from "./run-manager.js";
+import { startRun, subscribeToRun, replayCompletedTurn, getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, getSlotHoldingRunId, tryClaimRunSlot, isHostedRuntime, resolveRunSoftTimeoutMs, resolveRunToolTimeoutCeilingMs, endsAfterToolResultWithoutAssistantFinal, endsDuringActionPreparation, } from "./run-manager.js";
 import { writeLedgerEntry, readLedgerEntry, beginAgentExecutionStep, completeAgentExecutionStep, markAgentExecutionStepDispatched, markAgentExecutionStepUnknown, recordLateAgentExecutionStepOutcome, clearLedgerForThread, AgentTurnInitiatorMismatchError, AgentTurnInitiatorUnavailableError, insertRun, insertRunEvent, isTurnAborted, markRunAborted, updateRunHeartbeat, updateRunStatusIfRunning, updateRunTerminalStateIfRunning, 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 { claimSetupResume, setupResumeRefusedRunId, } from "./setup-resume-claim.js";
@@ -5002,11 +5002,21 @@ export async function runAgentLoop(opts) {
                     reasoningEffort: completingFollowUpSuggestions
                         ? "none"
                         : effectiveReasoningEffort,
+                    beforeModelDispatch: opts.beforeModelDispatch,
+                    onModelDispatchStarted: () => {
+                        usage.llmCalls = (usage.llmCalls ?? 0) + 1;
+                    },
                     providerOptions,
                 };
                 opts.onModelSettings?.(model, effectiveReasoningEffort);
-                usage.llmCalls = (usage.llmCalls ?? 0) + 1;
                 notifyModelInputObserver(opts.onModelInput, engineMessages);
+                if (signal.aborted) {
+                    reportOutcome({
+                        state: "canceled",
+                        message: "Agent run was aborted.",
+                    });
+                    return usage;
+                }
                 const eventStream = engine.stream(streamOpts);
                 let thinkingBuffer = "";
                 const toolInputNames = new Map();
@@ -5303,6 +5313,13 @@ export async function runAgentLoop(opts) {
                         await requestEventIteratorReturn(eventIterator, !eventIteratorReturnRequested);
                     }
                 }
+                if (signal.aborted) {
+                    reportOutcome({
+                        state: "canceled",
+                        message: "Agent run was aborted.",
+                    });
+                    return usage;
+                }
                 if (endedForNoProgress) {
                     if (completingFollowUpSuggestions)
                         break;
@@ -11220,4 +11237,4 @@ export function createProductionAgentHandler(options) {
         return stream;
     });
 }
-export { getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, };
+export { getActiveRunForThread, getActiveRunForThreadAsync, getRun, abortRun, abortRunDurably, abortRunAndTurnDurably, abortRunAtSafeBoundaryDurably, abortTurnByRefDurably, abortTurnDurably, subscribeToRun, };

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

@@ -14,6 +14,7 @@ export interface ActiveRun {
     nextEventSeq?: number;
     pendingAbortEvent?: RunEvent;
     flushEvents?: () => Promise<void>;
+    waitForPersistence?: () => Promise<void>;
     abortReason?: string;
     continuationTerminalEvent?: Extract<AgentChatEvent, {
         type: "auto_continue";
@@ -159,9 +160,15 @@ export declare function abortRun(runId: string, reason?: string): boolean;
  * must use this path; otherwise the recovery POST can race the old row while
  * it is still marked running.
  */
-export declare function abortRunDurably(runId: string, reason?: string): Promise<boolean>;
+export declare function abortRunDurably(runId: string, reason?: string, options?: {
+    allowNotStarted?: boolean;
+}): Promise<boolean>;
 /** Abort after the durable run store confirms no model or tool work is in flight. */
 export declare function abortRunAtSafeBoundaryDurably(runId: string, reason?: string): Promise<boolean>;
 export declare function abortTurnByRefDurably(threadId: string, turnId: string, reason?: string): Promise<"aborted" | "already_terminal">;
 export declare function abortTurnDurably(runId: string, reason?: string): Promise<"aborted" | "already_terminal">;
+/** Persist a Stop's turn marker even when a terminal event flush must be reported. */
+export declare function abortRunAndTurnDurably(runId: string, reason?: string, options?: {
+    safeBoundary?: boolean;
+}): Promise<boolean>;
 export { getSlotHoldingRunId, tryClaimRunSlot } from "./run-store.js";