@agent-native/core 0.208.0 → 0.209.0-nightly-20261014070126

package/dist/agent/run-manager.js

@@ -10,7 +10,7 @@ import { classifyTerminalErrorCode, describeErrorWithCauses, isProviderConnectio
 import { runErrorTelemetryProperties } from "./engine/error-telemetry.js";
 import { getAgentEngineEntry } from "./engine/registry.js";
 import { EngineError } from "./engine/types.js";
-import { insertRun, insertRunEvent, updateRunStatusIfRunning, markRunAborted, getRunAbortState, getRunStatus, getRunEventsSince, getCurrentTurnRunEventsForThread, getRunById, getRunByThread, getRunTurnRef, markTurnAborted, cleanupOldRuns, updateRunHeartbeat, bumpRunProgress, setRunInFlightMarker, reapIfStale, reapUnclaimedBackgroundRun, shouldRedispatchUnclaimedBackgroundRun, reconcileTerminalRunFromEvents, ensureTerminalRunEvent, getLastTerminalRunEvent, resolveErroredRunTerminalEvent, setRunError, setRunTerminalReason, persistRunCheckpointEvent, recordRunDiagnostic, RUN_DIAG_STAGE, terminalEventForAbortReason, RUN_RECORD_MISSING_ERROR_EVENT, RUN_RECORD_MISSING_GRACE_MS, RUN_TERMINAL_LOOKUP_FAILED_ERROR_EVENT, UNKNOWN_RUN_STATUS_ERROR_EVENT, } from "./run-store.js";
+import { insertRun, insertRunEvent, insertRunEvents, updateRunStatusIfRunning, markRunAborted, getRunAbortState, getRunStatus, getRunEventsSince, getCurrentTurnRunEventsForThread, getRunById, getRunByThread, getRunTurnRef, markTurnAborted, cleanupOldRuns, updateRunHeartbeat, bumpRunProgress, setRunInFlightMarker, reapIfStale, reapUnclaimedBackgroundRun, shouldRedispatchUnclaimedBackgroundRun, reconcileTerminalRunFromEvents, ensureTerminalRunEvent, getLastTerminalRunEvent, resolveErroredRunTerminalEvent, setRunError, setRunTerminalReason, persistRunCheckpointEvent, recordRunDiagnostic, RUN_DIAG_STAGE, terminalEventForAbortReason, RUN_RECORD_MISSING_ERROR_EVENT, RUN_RECORD_MISSING_GRACE_MS, RUN_TERMINAL_LOOKUP_FAILED_ERROR_EVENT, UNKNOWN_RUN_STATUS_ERROR_EVENT, } from "./run-store.js";
 import { isContinuationTerminalReason } from "./types.js";
 const activeRuns = new Map();
 const threadToRun = new Map();
@@ -232,6 +232,11 @@ function isTerminalRunEvent(event) {
         event.type === "loop_limit" ||
         event.type === "auto_continue");
 }
+function isBatchableRunEvent(event) {
+    return (event.type !== "tool_start" &&
+        event.type !== "tool_done" &&
+        !isTerminalRunEvent(event));
+}
 /**
  * A tool result with no later assistant text is an unfinished turn, not a
  * successful terminal response. Keep this predicate beside the run-manager's
@@ -256,6 +261,8 @@ export function endsAfterToolResultWithoutAssistantFinal(run) {
             continue;
         }
         if (event.type === "tool_done") {
+            if (event.approvalPause === true)
+                return false;
             toolResultAfterLastAssistantText =
                 event.isError === true ||
                     (event.chatUI === undefined && event.mcpApp === undefined);
@@ -570,6 +577,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             throw error;
     });
     let persistenceChain = Promise.resolve();
+    // Streamed deltas arrive hundreds per tool call, and a write tool waits for
+    // every queued event to persist first; one round trip per event put tens of
+    // seconds between the model finishing and the tool starting.
+    let openEventBatch = null;
     const PROGRESS_BUMP_INTERVAL_MS = 1_000;
     let lastProgressBumpAt = 0;
     let progressWriteInFlight = null;
@@ -1029,18 +1040,20 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             },
         });
     };
-    const persistRunEvent = async (runEvent, eventData) => {
+    const persistEventHook = options?.persistEvent;
+    const persistRunEvent = async (runEvent, eventData, eventAt) => {
         if (runEvent.event.type === "tool_start")
             await insertRunPromise;
         const write = () => runEvent.event.type === "tool_start" ||
             runEvent.event.type === "tool_done"
             ? insertRunEvent(runId, runEvent.seq, eventData, {
+                eventAt,
                 toolInputSource: "execution",
                 ...(runEvent.event.type === "tool_start"
                     ? { requireInserted: true }
                     : {}),
             })
-            : insertRunEvent(runId, runEvent.seq, eventData);
+            : insertRunEvent(runId, runEvent.seq, eventData, { eventAt });
         return options?.persistEvent
             ? options.persistEvent(write, {
                 terminal: isTerminalRunEvent(runEvent.event),
@@ -1052,6 +1065,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     };
     const emitRunEvent = (runEvent, options) => {
         const eventData = JSON.stringify(runEvent.event);
+        const eventAt = Date.now();
         run.events.push(runEvent);
         for (const subscriber of run.subscribers) {
             try {
@@ -1066,9 +1080,9 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             lastRealProgressAt = Date.now();
             bumpProgressIfDue();
         }
-        const thisInsert = persistenceChain.then(async () => {
+        const retryOnce = async (write) => {
             try {
-                await persistRunEvent(runEvent, eventData);
+                await write();
             }
             catch (error) {
                 if (!eventPersistenceErrorCaptured) {
@@ -1078,11 +1092,36 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                         eventType: runEvent.event.type,
                     });
                 }
-                await persistRunEvent(runEvent, eventData);
+                await write();
             }
-        });
-        persistenceChain = thisInsert;
-        const persistence = thisInsert;
+        };
+        let persistence;
+        if (isBatchableRunEvent(runEvent.event) && !persistEventHook) {
+            if (!openEventBatch) {
+                const batch = {
+                    events: [],
+                    write: persistenceChain.then(() => {
+                        if (openEventBatch === batch)
+                            openEventBatch = null;
+                        return retryOnce(() => insertRunEvents(runId, batch.events));
+                    }),
+                };
+                openEventBatch = batch;
+                persistenceChain = batch.write;
+            }
+            openEventBatch.events.push({
+                seq: runEvent.seq,
+                eventAt,
+                eventData,
+            });
+            persistence = openEventBatch.write;
+        }
+        else {
+            // Anything emitted after this event must not persist before it.
+            openEventBatch = null;
+            persistence = persistenceChain.then(() => retryOnce(() => persistRunEvent(runEvent, eventData, eventAt)));
+            persistenceChain = persistence;
+        }
         if (!options?.surfacePersistenceError) {
             persistence.catch(() => { });
         }
@@ -1092,7 +1131,14 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     const send = (event) => {
         if (run.status === "aborted" && abort.signal.aborted)
             return;
-        const runEvent = { seq: run.events.length, event };
+        // Explicit false distinguishes current completions from legacy pauses.
+        const normalizedEvent = event.type === "tool_done" && event.approvalPause === undefined
+            ? { ...event, approvalPause: false }
+            : event;
+        const runEvent = {
+            seq: run.events.length,
+            event: normalizedEvent,
+        };
         if (isTerminalRunEvent(event)) {
             pendingTerminalEvent = runEvent;
             return;
@@ -1275,7 +1321,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     console.error("[run-manager] terminal event persistence error:", err instanceof Error ? err.message : err);
                     if (!eventPersistenceError) {
                         try {
-                            await persistRunEvent(terminal, JSON.stringify(terminal.event));
+                            await persistRunEvent(terminal, JSON.stringify(terminal.event), Date.now());
                             terminalPersistenceError = null;
                         }
                         catch (retryError) {

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

@@ -285,7 +285,17 @@ export declare class AgentRunEventNotPersistedError extends Error {
 export declare function insertRunEvent(runId: string, seq: number, eventData: string, options?: {
     toolInputSource?: "execution";
     requireInserted?: boolean;
+    eventAt?: number;
 }): Promise<void>;
+/**
+ * Same guarantees as `insertRunEvent` without execution-input fingerprints,
+ * so tool_start/tool_done must keep going through `insertRunEvent`.
+ */
+export declare function insertRunEvents(runId: string, events: ReadonlyArray<{
+    seq: number;
+    eventAt: number;
+    eventData: string;
+}>): Promise<void>;
 export declare const CHECKPOINT_TERMINAL_EVENT_SEQ = 1000000000;
 export declare function persistRunCheckpointEvent(runId: string, event: AgentChatEvent, terminalReason: string): Promise<void>;
 export declare function getRunEventsSince(runId: string, fromSeq: number, opts?: {

package/dist/agent/run-store.js

@@ -9,10 +9,11 @@ import { lockAndAssertServicePrincipalMayStartRun, prepareServicePrincipalRunSta
 import { captureError } from "../server/capture-error.js";
 import { assertNoInlineImageBytes, stripInlineBytes, stripInlineBytesFromJson, } from "../shared/inline-bytes.js";
 import { isRequestedStopAbortReason } from "./abort-reasons.js";
+import { approvalKeyForHistory } from "./approval-key.js";
 import { admitAutoContinue, admitManualContinue, } from "./auto-continue.js";
 import { AGENT_CHAT_RECOVERY_OF_RUN_FIELD } from "./durable-background.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./engine/credential-errors.js";
-import { isConsistentToolCallInputFingerprint, isRedactedToolCallInput, toolCallInputFingerprint, } from "./tool-call-journal.js";
+import { isConsistentToolCallInputFingerprint, isUnavailableToolCallInput, toolCallInputFingerprint, } from "./tool-call-journal.js";
 import { CONTINUATION_REASONS, isContinuationTerminalReason } from "./types.js";
 let _initPromise;
 export const RUN_STALE_MS = 15_000;
@@ -1864,9 +1865,15 @@ export async function getRunAbortState(runId) {
 }
 function persistedRunEventData(eventData, inputSource) {
     const stripped = stripInlineBytesFromJson(eventData, "placeholder");
+    const original = JSON.parse(eventData);
+    if (original.type === "approval_required") {
+        return JSON.stringify({
+            ...JSON.parse(stripped),
+            approvalKey: approvalKeyForHistory(original.approvalKey),
+        });
+    }
     if (stripped === eventData && inputSource !== "execution")
         return eventData;
-    const original = JSON.parse(eventData);
     if ((original.type !== "tool_start" && original.type !== "tool_done") ||
         original.input === undefined ||
         inputSource !== "execution" ||
@@ -1910,7 +1917,7 @@ export async function insertRunEvent(runId, seq, eventData, options) {
         args: [
             runId,
             seq,
-            Date.now(),
+            options?.eventAt ?? Date.now(),
             storedEventData,
             ...(options?.requireInserted ? [] : [runId]),
         ],
@@ -1918,6 +1925,42 @@ export async function insertRunEvent(runId, seq, eventData, options) {
     if (options?.requireInserted && rowsAffected !== 1)
         throw new AgentRunEventNotPersistedError(runId, seq);
 }
+// Stays well under PostgreSQL's 65,535 bind-parameter limit at 4 per row.
+const RUN_EVENT_BATCH_ROWS = 500;
+/**
+ * Same guarantees as `insertRunEvent` without execution-input fingerprints,
+ * so tool_start/tool_done must keep going through `insertRunEvent`.
+ */
+export async function insertRunEvents(runId, events) {
+    if (events.length === 0)
+        return;
+    await ensureRunTables();
+    const client = getDbExec();
+    for (let start = 0; start < events.length; start += RUN_EVENT_BATCH_ROWS) {
+        const chunk = events.slice(start, start + RUN_EVENT_BATCH_ROWS);
+        await client.execute({
+            sql: `INSERT INTO agent_run_events (run_id, seq, event_at, event_data)
+        SELECT v.run_id, v.seq, v.event_at, v.event_data
+        FROM (VALUES ${chunk
+                .map(() => "(CAST(? AS TEXT), CAST(? AS BIGINT), CAST(? AS BIGINT), CAST(? AS TEXT))")
+                .join(", ")}) AS v(run_id, seq, event_at, event_data)
+        WHERE NOT EXISTS (
+          SELECT 1 FROM agent_runs
+          WHERE id = ? AND status <> 'running'
+        )
+        ON CONFLICT (run_id, seq) DO NOTHING`,
+            args: [
+                ...chunk.flatMap(({ seq, eventAt, eventData }) => [
+                    runId,
+                    seq,
+                    eventAt,
+                    persistedRunEventData(eventData),
+                ]),
+                runId,
+            ],
+        });
+    }
+}
 export const CHECKPOINT_TERMINAL_EVENT_SEQ = 1_000_000_000;
 export async function persistRunCheckpointEvent(runId, event, terminalReason) {
     await insertRunEvent(runId, CHECKPOINT_TERMINAL_EVENT_SEQ, JSON.stringify(event));
@@ -2219,11 +2262,13 @@ function isReadableJournalEvent(value) {
                     (typeof value.inputStoredFingerprint === "string" &&
                         /^[a-f0-9]{64}$/.test(value.inputStoredFingerprint))) &&
                 isConsistentToolCallInputFingerprint(value.input, value.inputFingerprint, value.inputStoredFingerprint) &&
-                (!isRedactedToolCallInput(value.input) ||
+                (!isUnavailableToolCallInput(value.input) ||
                     value.inputFingerprint !== undefined) &&
                 (type === "tool_start"
                     ? Object.hasOwn(value, "input")
                     : ["isError", "completedSideEffect", "replayed"].every((field) => value[field] === undefined || typeof value[field] === "boolean") &&
+                        (value.approvalPause === undefined ||
+                            typeof value.approvalPause === "boolean") &&
                         (value.outcomeUnknown === undefined ||
                             value.outcomeUnknown === true)));
         case "suggestions":

package/dist/agent/thread-data-builder.d.ts

@@ -15,6 +15,8 @@ interface ContentPart {
     args?: Record<string, unknown>;
     result?: string;
     isError?: boolean;
+    approvalPause?: true;
+    approvalAskId?: string;
     outcome?: "unknown";
     completedSideEffect?: boolean;
     artifacts?: ArtifactReceipt[];