@agent-native/core 0.214.0 → 0.217.0

package/dist/action.js

@@ -205,6 +205,50 @@ export function ranCallEmitsChange(entry, outcome, args, fallbackReadOnly) {
     const readOnly = actionCallReadOnly(entry, args) ?? fallbackReadOnly;
     return invocationEffect(entry, outcome, { readOnly }).changed;
 }
+/**
+ * PostgreSQL breaks a deadlock (40P01) or a serializable conflict (40001) by
+ * rolling back one whole transaction. Drivers and Drizzle surface that as an
+ * untyped "Failed query", which reads as a bug and hides the rollback, so an
+ * action reports it as a typed conflict. The message must not claim nothing
+ * was saved: an action can commit an earlier transaction or an external write
+ * before the one that rolled back.
+ */
+const TRANSACTION_CONFLICT_SQLSTATES = new Set(["40P01", "40001"]);
+/** What a run that threw `error` throws: a transaction conflict as typed. */
+function typedTransactionConflict(error) {
+    let sqlState;
+    try {
+        sqlState = transactionConflictSqlState(error);
+    }
+    catch {
+        // Any read of a thrown value may throw. That value goes on as thrown,
+        // so readableFailure reports it as unreadable instead of the read's own
+        // error replacing it.
+        return error;
+    }
+    if (!sqlState)
+        return error;
+    return new ActionContractError("The database rolled back this action's transaction because it conflicted with another transaction running at the same time. Anything the action saved outside that transaction stays saved, so read the current state and redo only what is missing.", {
+        errorCode: "transaction_conflict",
+        statusCode: 409,
+        details: { sqlState },
+    });
+}
+function transactionConflictSqlState(error) {
+    if (isActionContractError(error))
+        return null;
+    let cause = error;
+    for (let depth = 0; depth < 5; depth += 1) {
+        if (!cause || typeof cause !== "object")
+            return null;
+        const code = cause.code;
+        if (typeof code === "string" && TRANSACTION_CONFLICT_SQLSTATES.has(code)) {
+            return code;
+        }
+        cause = cause.cause;
+    }
+    return null;
+}
 export class AgentActionStopError extends Error {
     agentNativeStop = true;
     errorCode;
@@ -360,9 +404,18 @@ export function defineAction(options) {
         }
         return options.run(args, ctx);
     };
-    const guardedRun = typeof options.authorize === "function" || options.access
+    const accessCheckedRun = typeof options.authorize === "function" || options.access
         ? wrapRunWithAccess(handlerRun, options.access, options.authorize)
         : handlerRun;
+    // Access checks query the database too, so they convert the same way.
+    const guardedRun = async (args, ctx, gateArgs) => {
+        try {
+            return await accessCheckedRun(args, ctx, gateArgs);
+        }
+        catch (error) {
+            throw typedTransactionConflict(error);
+        }
+    };
     const uiOnlyGuardedRun = options.uiOnly === true
         ? async (args, ctx, gateArgs) => {
             if (ctx?.caller !== "frontend") {

package/dist/agent/actions/disconnect-chatgpt-subscription.js

@@ -13,6 +13,11 @@ export default defineAction({
             .optional()
             .describe("Remove the user's unusable credential from the older experimental ChatGPT flow."),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: true,
+    },
     run: async (_args, ctx) => {
         const email = ctx?.userEmail;
         if (!email)

package/dist/agent/actions/get-agentkit-capabilities.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
 import { listAgentKitCapabilities, } from "../../agentkit/capabilities.js";
 export default defineAction({
-    description: "Read the signed-in user's AgentKit context-source and integration capabilities for Design or Slides. Returns only supported, connected capability labels and availability; never returns credentials or connection details.",
+    description: "Read the signed-in user's AgentKit context-source and integration capabilities for Design, Slides, or Slides 2. Returns only supported, connected capability labels and availability; never returns credentials or connection details.",
     schema: z.object({}),
     http: { method: "GET" },
     readOnly: true,
@@ -10,8 +10,8 @@ export default defineAction({
     toolCallable: false,
     run: async (_args, ctx) => {
         const appId = ctx?.appId;
-        if (appId !== "design" && appId !== "slides") {
-            fail("AgentKit capabilities are only available in Design and Slides.", {
+        if (appId !== "design" && appId !== "slides" && appId !== "slides-2") {
+            fail("AgentKit capabilities are only available in Design, Slides, and Slides 2.", {
                 errorCode: "agentkit_capabilities_unsupported_app",
                 statusCode: 400,
             });

package/dist/agent/actions/manage-builder-connection.js

@@ -30,6 +30,11 @@ export default defineAction({
     },
     // disconnectBuilderConnectionAtScope records the disconnect at its scope.
     audit: { enabled: false },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: true,
+    },
     run: async (args, ctx) => {
         const email = ctx?.userEmail?.trim().toLowerCase();
         if (!email) {

package/dist/agent/actions/manage-provider-key-policy.js

@@ -52,6 +52,11 @@ export default defineAction({
     },
     // Only real changes (and refused ones) are recorded, below.
     audit: { enabled: false },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const email = ctx?.userEmail?.trim().toLowerCase();
         const orgId = ctx?.orgId?.trim();

package/dist/agent/actions/manage-provider-models.js

@@ -40,6 +40,11 @@ export default defineAction({
                 : `Set ${scope} ${args.provider} models (${args.models?.length ?? 0})`;
         },
     },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         if (!ctx?.userEmail)
             fail("Not authenticated.", { statusCode: 401 });

package/dist/agent/actions/manage-service-providers.js

@@ -134,6 +134,11 @@ export default defineAction({
     toolCallable: false,
     // Only real changes (and refused ones) are recorded, below.
     audit: { enabled: false },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const email = ctx?.userEmail?.trim().toLowerCase();
         const orgId = ctx?.orgId?.trim();

package/dist/agent/actions/select-chatgpt-subscription-account.js

@@ -6,6 +6,11 @@ export default defineAction({
     schema: z.object({
         accountId: z.string().min(1).max(80),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const email = ctx?.userEmail;
         if (!email)

package/dist/agent/context-xray/actions/context-evict.js

@@ -10,6 +10,11 @@ export default defineAction({
         threadId: z.string(),
         segmentId: z.string(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args) => {
         const ownerEmail = getRequestUserEmail();
         if (!ownerEmail)

package/dist/agent/context-xray/actions/context-pin.js

@@ -10,6 +10,11 @@ export default defineAction({
         threadId: z.string(),
         segmentId: z.string(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args) => {
         const ownerEmail = getRequestUserEmail();
         if (!ownerEmail)

package/dist/agent/context-xray/actions/context-report.js

@@ -21,6 +21,11 @@ export default defineAction({
         model: z.string().optional(),
         segments: z.array(reportedSegmentSchema).default([]),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args) => {
         const ownerEmail = getRequestUserEmail();
         if (!ownerEmail)

package/dist/agent/context-xray/actions/context-restore.js

@@ -10,6 +10,11 @@ export default defineAction({
         threadId: z.string(),
         segmentId: z.string(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args) => {
         const ownerEmail = getRequestUserEmail();
         if (!ownerEmail)

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

@@ -23,6 +23,7 @@ export declare function currentExecutionFenceForScope(scope: {
 }): ExecutionFence | undefined;
 export declare function withExecutionLeaseRequested<T>(work: () => T): T;
 export declare function withExecutionFence<T>(fence: ExecutionFence, work: () => T): T;
+export declare function runWithoutExecutionFence<T>(work: () => T): T;
 export declare function lockAndAssertCurrentExecutionFences(tx: DbExec): Promise<void>;
 export declare function withFencedExecutionWrite<T>(write: (tx: DbExec) => Promise<T>, scope?: {
     runId?: string;

package/dist/agent/execution-fence.js

@@ -61,6 +61,11 @@ export function withExecutionFence(fence, work) {
         executionLeaseRequested: true,
     }, work);
 }
+export function runWithoutExecutionFence(work) {
+    // A follow-up turn scheduled by a completed run must not inherit that run's
+    // now-expired lease through AsyncLocalStorage.
+    return executionFenceStorage.run({ fences: [], executionLeaseRequested: false }, work);
+}
 export async function lockAndAssertCurrentExecutionFences(tx) {
     const fences = executionFenceStorage.getStore()?.fences ?? [];
     for (const activeFence of fences) {

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

@@ -1,4 +1,4 @@
-import { type AgentSubmissionPayload } from "@agent-native/agentkit/protocol";
+import { type AgentRunOptions, type AgentSubmissionReference, type AgentSubmissionPayload } from "@agent-native/agentkit/protocol";
 import type { EventHandler as H3EventHandler } from "h3";
 import "../authorization/check-action.js";
 import type { Task } from "../a2a/types.js";
@@ -23,7 +23,7 @@ import type { AgentEngine, EngineTool, EngineMessage, EngineContentPart, EngineI
 import { type Processor } from "./processors.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 AgentTurnInitiator, insertRun, isRunAborted, 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";
 import { type ToolWriteReceipt } from "./write-receipts.js";
 export { PROVIDER_TO_ENV };
@@ -719,6 +719,19 @@ export declare function shouldGuardRepeatedSourceSweep(opts: {
     message: string;
 } | null;
 type ModelInputObserver = (messages: readonly unknown[]) => void | Promise<void>;
+export type QueuedRunInterruptBoundaryResult = "none" | "aborted" | "pending";
+export declare function createRunSafeBoundaryGuards(input: {
+    signal: AbortSignal;
+    flushEvents: () => Promise<void>;
+    interruptRequestedAtBoundary: () => Promise<QueuedRunInterruptBoundaryResult>;
+}): {
+    beforeModelDispatch: BeforeModelDispatch;
+    beforeWrite: () => Promise<void>;
+};
+export declare function confirmQueuedRunInterrupt(input: {
+    abort: () => Promise<boolean>;
+    defer: () => Promise<unknown>;
+}): Promise<Exclude<QueuedRunInterruptBoundaryResult, "none">>;
 export declare function runAgentLoop(opts: {
     engine: AgentEngine;
     model: string;
@@ -915,6 +928,25 @@ export declare function resolvePriorContinuationState(backgroundRunMarker: Recor
 };
 export declare function resolvePriorContinuationReason(backgroundRunMarker: Record<string, unknown> | null | undefined, body: Record<string, unknown>): string | undefined;
 declare function readTurnStartedAt(threadId: string, turnId: string): Promise<number | null>;
+interface AdmittedQueuedMessagePromotion {
+    id: string;
+    text: string;
+    attachments?: unknown[];
+    requestAttachments?: Record<string, unknown>[];
+    references?: AgentSubmissionReference[];
+    metadata?: Record<string, unknown>;
+    options?: AgentRunOptions;
+}
+/** @internal exported for unit tests only */
+export declare function readAdmittedQueuedMessagePromotion(opts: {
+    ownerEmail: string | null;
+    orgId: string | null;
+    threadId?: string;
+    messageId: unknown;
+    claimId: unknown;
+    message: string;
+    continuationRequested: boolean;
+}): Promise<AdmittedQueuedMessagePromotion | null>;
 /** @internal exported for unit tests only */
 export declare function queuedPromotionAttachments(attachments: unknown[], requestAttachments?: Record<string, unknown>[]): AgentChatAttachment[];
 declare function emitRunText(run: ActiveRun, text: string): Promise<void>;
@@ -933,6 +965,7 @@ export interface ChainServerDrivenContinuationDeps {
     setRunError?: typeof setRunError;
     recordRunDiagnostic?: typeof recordRunDiagnostic;
     markBackgroundContinuationChunkTerminal?: typeof markBackgroundContinuationChunkTerminal;
+    isRunAborted?: typeof isRunAborted;
     generateRunId?: typeof generateRunId;
     sleep?: (ms: number) => Promise<void>;
 }