@agent-native/core 0.225.0 → 0.225.2-nightly-20261106152255

package/dist/agent/harness/lifecycle.js

@@ -571,6 +571,8 @@ export async function sendAgentHarnessFollowUp(input) {
         let providerDispatchStarted = false;
         const hasFollowUpProviderDispatchStarted = () => providerDispatchStarted;
         let activeRun;
+        let finalizedRejected = false;
+        const hasFinalizedRejection = () => finalizedRejected;
         try {
             const dispatchIntent = await markAgentHarnessSessionFollowUpDispatched(session.id, claimed.generation, claimId);
             if (!dispatchIntent) {
@@ -801,7 +803,10 @@ export async function sendAgentHarnessFollowUp(input) {
                                     rejectFirstDispatch(runFailure ??
                                         new Error("The AgentHarness follow-up run ended before provider dispatch."));
                                 }
-                            }, rejectFirstDispatch);
+                            }, (error) => {
+                                finalizedRejected = true;
+                                rejectFirstDispatch(error);
+                            });
                             if (followUpAbort.signal.aborted)
                                 abortActiveRun();
                             return firstDispatch;
@@ -819,7 +824,13 @@ export async function sendAgentHarnessFollowUp(input) {
                     refreshLiveAgentHarnessSessionGeneration(session.id, acquired.live.session, dispatch.session.generation);
                     if (isAbortRequested(followUpAbort.signal))
                         abortActiveRun();
-                    await activeRun.finalized;
+                    try {
+                        await activeRun.finalized;
+                    }
+                    catch (error) {
+                        finalizedRejected = true;
+                        throw error;
+                    }
                 }
                 finally {
                     followUpAbort.signal.removeEventListener("abort", abortActiveRun);
@@ -994,13 +1005,22 @@ export async function sendAgentHarnessFollowUp(input) {
             if (isAbortRequested(followUpAbort.signal)) {
                 const reason = followUpAbort.signal.reason;
                 if (isAgentHarnessSessionConflictError(reason)) {
-                    const latest = await getAgentHarnessSessionByRunId(input.runId);
                     const cleanupErrors = [];
-                    if (!latest ||
-                        (latest.status === "idle" && latest.followUpClaimId == null) ||
-                        latest.status === "stopped" ||
-                        latest.status === "errored" ||
-                        latest.status === "destroyed") {
+                    let lookupFailed = false;
+                    let latest;
+                    try {
+                        latest = await getAgentHarnessSessionByRunId(input.runId);
+                    }
+                    catch (lookupError) {
+                        lookupFailed = true;
+                        cleanupErrors.push(lookupError);
+                    }
+                    if (latest !== undefined &&
+                        (!latest ||
+                            (latest.status === "idle" && latest.followUpClaimId == null) ||
+                            latest.status === "stopped" ||
+                            latest.status === "errored" ||
+                            latest.status === "destroyed")) {
                         try {
                             await stopAcquiredHarnessSession(session.id, acquired.live.session);
                         }
@@ -1016,12 +1036,26 @@ export async function sendAgentHarnessFollowUp(input) {
                             cleanupErrors.push(closeError);
                         }
                     }
+                    if (lookupFailed &&
+                        !hasFinalizedRejection() &&
+                        cleanupErrors.length === 1) {
+                        throw cleanupErrors[0];
+                    }
                     if (cleanupErrors.length > 0) {
-                        throw new AggregateError([reason, ...cleanupErrors], "Harness follow-up was interrupted and stream cleanup was incomplete.");
+                        throw new AggregateError([
+                            reason,
+                            ...(hasFinalizedRejection() ? [error] : []),
+                            ...cleanupErrors,
+                        ], "Harness follow-up was interrupted and stream cleanup was incomplete.");
                     }
+                    if (hasFinalizedRejection())
+                        throw error;
                     return failure(input.runId, latest ?? session, "unavailable", "The harness follow-up was interrupted because its session claim changed or stopped.");
                 }
-                const failures = [reason ?? error];
+                const failures = [
+                    reason ?? error,
+                    ...(hasFinalizedRejection() ? [error] : []),
+                ];
                 let failedSession = null;
                 try {
                     failedSession = await markOwnedFollowUpErrored(session.id, claimId, acquired.live.session, hasFollowUpProviderDispatchStarted() ? "unknown" : "not_dispatched");
@@ -1046,7 +1080,9 @@ export async function sendAgentHarnessFollowUp(input) {
                     }
                 }
                 if (failures.length > 1) {
-                    throw new AggregateError(failures, "Harness follow-up claim monitoring failed and cleanup was incomplete.");
+                    throw new AggregateError(failures, hasFinalizedRejection()
+                        ? "Harness follow-up claim monitoring failed and finalization or cleanup was incomplete."
+                        : "Harness follow-up claim monitoring failed and cleanup was incomplete.");
                 }
                 const latest = failedSession ?? (await getAgentHarnessSessionByRunId(input.runId));
                 return failure(input.runId, latest ?? session, "unavailable", "The harness follow-up was stopped because its session claim could not be verified.");

package/dist/agent/optional-placeholders.js

@@ -83,14 +83,14 @@ function resolveObjectSchemaBranch(schema, value) {
     const index = discriminatedBranchIndex(branches, value);
     return index >= 0 ? branches[index] : undefined;
 }
-function stripOptionalToolPlaceholders(schema, value, emptyValues) {
+function stripOptionalToolPlaceholders(schema, value, emptyValues, depth = 0) {
     if (!schema)
         return { value, changed: false };
     if (Array.isArray(value)) {
         const itemSchema = leafBranches(schema).find((branch) => branch.items)?.items;
         if (!itemSchema)
             return { value, changed: false };
-        const results = value.map((item) => stripOptionalToolPlaceholders(itemSchema, item, emptyValues));
+        const results = value.map((item) => stripOptionalToolPlaceholders(itemSchema, item, emptyValues, depth + 1));
         return results.some((result) => result.changed)
             ? { value: results.map((result) => result.value), changed: true }
             : { value, changed: false };
@@ -119,6 +119,14 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues) {
             }
             continue;
         }
+        // Top-level only: a nested null may be a deliberate clear.
+        if (emptyValues.stripNull &&
+            depth === 0 &&
+            entry === null &&
+            !required.has(key)) {
+            placeholders.push(key);
+            continue;
+        }
         if (!required.has(key) && isStructurallyEmptyToolValue(entry)) {
             if (schemaRejectsToolValue(propertySchema, entry)) {
                 if (emptyValues.nullOnly && entry !== null)
@@ -128,9 +136,12 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues) {
                 continue;
             }
             // A valid `false` sets a value, and `[]` on an action that says an empty
-            // list erases nothing is padding. Elsewhere `[]` could wipe a stored
+            // list erases nothing is padding. `null` on an optional field is absent:
+            // models fill every unused field with it, so it never marks a call as
+            // clearing data. Elsewhere `[]` could wipe a stored
             // list. An empty equal to the schema's own default changes nothing.
             if (entry !== false &&
+                entry !== null &&
                 !(emptyValues.listsEraseNothing &&
                     Array.isArray(entry) &&
                     entry.length === 0) &&
@@ -139,7 +150,7 @@ function stripOptionalToolPlaceholders(schema, value, emptyValues) {
                     JSON.stringify(propertySchema.default) === JSON.stringify(entry)))
                 emptyValues.valid = true;
         }
-        const nested = stripOptionalToolPlaceholders(propertySchema, entry, emptyValues);
+        const nested = stripOptionalToolPlaceholders(propertySchema, entry, emptyValues, depth + 1);
         if (nested.changed) {
             normalized ??= { ...record };
             normalized[key] = nested.value;
@@ -175,7 +186,15 @@ export function normalizeOptionalToolPlaceholders(schema, input, entry, { nullOn
         nullOnly,
         listsEraseNothing: entry.emptyListsEraseNothing === true,
     };
-    const result = stripOptionalToolPlaceholders(schema, input, emptyValues);
+    let result = stripOptionalToolPlaceholders(schema, input, emptyValues);
+    // A padded call means its nulls are padding too, including on nullable
+    // fields where a lone null would be a deliberate clear.
+    if (emptyValues.invalid && !emptyValues.valid) {
+        result = stripOptionalToolPlaceholders(schema, input, {
+            ...emptyValues,
+            stripNull: true,
+        });
+    }
     // Only a declared read is exempt: a dynamic plan-mode effect classifies the
     // raw input, which defaults can turn into a write.
     if (emptyValues.valid &&

package/dist/agent/production-agent.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY, AGENT_NATIVE_SUBMISSION_TTL_MS_METADATA_KEY, MAX_AGENT_REQUEST_ATTACHMENT_DATA_CHARS, parseQueueMessageInput, persistableFilePart, fingerprintAgentSubmissionAttachment, submissionAttachmentsMatch, } from "@agent-native/agentkit/protocol";
+import { AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY, AGENT_NATIVE_SUBMISSION_TTL_MS_METADATA_KEY, MAX_AGENT_REQUEST_ATTACHMENT_DATA_CHARS, parseQueueMessageInput, persistableFilePart, fingerprintAgentSubmissionAttachment, isPersistableAttachmentUrl, submissionAttachmentsMatch, } from "@agent-native/agentkit/protocol";
 import Ajv from "ajv";
 import Ajv2020 from "ajv/dist/2020.js";
 import { defineEventHandler, getHeader, setResponseHeader, setResponseStatus, getMethod, } from "h3";
@@ -1412,23 +1412,6 @@ export { DurableAttachmentReferenceRequiredError };
 function isDataUrlReference(value) {
     return typeof value === "string" && /^\s*data:/i.test(value);
 }
-function hasDurableAttachmentUrl(value) {
-    if (typeof value !== "string")
-        return false;
-    const normalized = value.trim();
-    if (!normalized ||
-        isDataUrlReference(normalized) ||
-        isRawBase64Payload(normalized) ||
-        !URL.canParse(normalized)) {
-        return false;
-    }
-    const url = new URL(normalized);
-    return (url.protocol === "https:" &&
-        !url.username &&
-        !url.password &&
-        !url.search &&
-        !url.hash);
-}
 const OMIT_DURABLE_DISPATCH_VALUE = Symbol("omit-durable-dispatch-value");
 const DURABLE_ATTACHMENT_PAYLOAD_FIELDS = /^(?:base64|bytes|body|data|dataurl|image|payload)$/i;
 const DURABLE_ATTACHMENT_REFERENCE_FIELDS = /^(?:preview|referenceUrl|src|thumbnail|url)$/i;
@@ -1516,7 +1499,7 @@ function sanitizeDurableAttachment(value, attachmentContext = false, requiredAtt
             (attachmentReferenceField &&
                 typeof value === "string" &&
                 (isInlineBase64Payload(value) ||
-                    (value.trim().length > 0 && !hasDurableAttachmentUrl(value)))))) {
+                    (value.trim().length > 0 && !isPersistableAttachmentUrl(value)))))) {
         return OMIT_DURABLE_DISPATCH_VALUE;
     }
     if (Array.isArray(value)) {
@@ -1537,12 +1520,12 @@ function sanitizeDurableAttachment(value, attachmentContext = false, requiredAtt
     const isAttachment = attachmentContext || typedAttachment;
     const hasInlinePayload = isAttachment && containsDurableAttachmentPayload(item, true);
     const hasDurableReference = item.type === "image"
-        ? hasDurableAttachmentUrl(item.url)
-        : hasDurableAttachmentUrl(item.url) ||
-            hasDurableAttachmentUrl(item.referenceUrl);
+        ? isPersistableAttachmentUrl(item.url)
+        : isPersistableAttachmentUrl(item.url) ||
+            isPersistableAttachmentUrl(item.referenceUrl);
     const hasInlineReference = [item.url, item.referenceUrl].some((reference) => typeof reference === "string" &&
         reference.trim().length > 0 &&
-        !hasDurableAttachmentUrl(reference));
+        !isPersistableAttachmentUrl(reference));
     if ((requiredAttachment || typedAttachment) &&
         (hasInlinePayload || hasInlineReference) &&
         !hasDurableReference) {
@@ -9040,11 +9023,12 @@ async function queueableAttachments(attachments, ownerEmail, requestAttachmentIn
                     ? { fileId: record.id }
                     : {}),
         });
-        if (!part.fileId &&
-            inlineData &&
+        let uploadAttempted = false;
+        if (inlineData &&
             (!part.url || !record.uploadProvider || record.storageUploadFailed)) {
             const parsedData = parseBase64DataUrl(inlineData);
             if (parsedData) {
+                uploadAttempted = true;
                 const uploaded = await uploadFile({
                     data: new Uint8Array(Buffer.from(parsedData.data, "base64")),
                     filename: attachment.name,
@@ -9059,15 +9043,16 @@ async function queueableAttachments(attachments, ownerEmail, requestAttachmentIn
                         name: attachment.name,
                         ...(mediaType ? { mediaType } : {}),
                         url: uploaded.url,
+                        ...(part.fileId ? { fileId: part.fileId } : {}),
                     });
                 }
             }
         }
         if (requestAttachmentIndexes.has(index)) {
-            if (!part.url || !hasDurableAttachmentUrl(part.url))
+            if (!part.url || !isPersistableAttachmentUrl(part.url))
                 return null;
             const referenceUrl = attachment.referenceUrl;
-            if (referenceUrl && !hasDurableAttachmentUrl(referenceUrl))
+            if (referenceUrl && !isPersistableAttachmentUrl(referenceUrl))
                 return null;
             requestFiles.push({
                 type: "image",
@@ -9078,8 +9063,13 @@ async function queueableAttachments(attachments, ownerEmail, requestAttachmentIn
             });
             continue;
         }
-        if (!part.url && !part.fileId)
-            return null;
+        if (!part.url) {
+            // A failed upload is transient (null -> retryable); an id with no
+            // uploadable bytes can never become a reference.
+            if (uploadAttempted)
+                return null;
+            throw new DurableAttachmentReferenceRequiredError();
+        }
         files.push(part);
     }
     return { attachments: files, requestAttachments: requestFiles };
@@ -9128,12 +9118,12 @@ function validateQueuedPromotionRequestAttachments(value) {
                 return null;
             }
         }
-        if ((typeof url === "string" && !hasDurableAttachmentUrl(url)) ||
+        if ((typeof url === "string" && !isPersistableAttachmentUrl(url)) ||
             (typeof attachment.referenceUrl === "string" &&
-                !hasDurableAttachmentUrl(attachment.referenceUrl)) ||
+                !isPersistableAttachmentUrl(attachment.referenceUrl)) ||
             (typeof data !== "string" &&
-                !hasDurableAttachmentUrl(url) &&
-                !hasDurableAttachmentUrl(attachment.referenceUrl))) {
+                !isPersistableAttachmentUrl(url) &&
+                !isPersistableAttachmentUrl(attachment.referenceUrl))) {
             return null;
         }
         attachments.push(attachment);
@@ -10339,7 +10329,21 @@ export function createProductionAgentHandler(options) {
                 setResponseStatus(event, 404);
                 return { error: "Thread not found" };
             }
-            const attachmentsForQueue = await queueableAttachments(requestAttachments, ownerEmail, submissionRequestAttachmentIndexes);
+            let attachmentsForQueue;
+            try {
+                attachmentsForQueue = await queueableAttachments(requestAttachments, ownerEmail, submissionRequestAttachmentIndexes);
+            }
+            catch (error) {
+                if (!(error instanceof DurableAttachmentReferenceRequiredError)) {
+                    throw error;
+                }
+                setResponseStatus(event, 503);
+                return {
+                    error: error.message,
+                    code: error.code,
+                    retryable: false,
+                };
+            }
             if (!attachmentsForQueue) {
                 if (requestAttachments.some((attachment) => attachment.displayOnly !== true &&
                     (attachment.type === "image" ||

package/dist/agent/run-manager.js

@@ -741,6 +741,12 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
     let persistenceFailure;
     let persistenceFailureBlocked = false;
     const flushEventWrites = (retryAfterFailure) => {
+        if (persistenceFailure instanceof AgentRunEventNotPersistedError &&
+            persistenceFailure.terminalRun) {
+            const failed = Promise.reject(persistenceFailure);
+            persistenceChain = failed;
+            return failed;
+        }
         if (persistenceDrain) {
             const activeDrain = persistenceDrain;
             const settledDrain = retryAfterFailure
@@ -779,8 +785,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 catch (error) {
                     const terminalRun = error instanceof AgentRunEventNotPersistedError &&
                         error.terminalRun;
-                    persistenceFailure = terminalRun ? undefined : error;
-                    persistenceFailureBlocked = !terminalRun;
+                    persistenceFailure = error;
+                    persistenceFailureBlocked = true;
                     for (const queued of pendingEventWrites) {
                         for (const publication of queued.publications) {
                             if (publication.settled)
@@ -1527,6 +1533,14 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         return publication;
     };
     const emitRunEvent = (runEvent, options) => {
+        if (persistenceFailure instanceof AgentRunEventNotPersistedError &&
+            persistenceFailure.terminalRun) {
+            const publication = Promise.reject(persistenceFailure);
+            if (!options?.surfacePersistenceError)
+                publication.catch(() => { });
+            void checkSqlAbort();
+            return publication;
+        }
         if (privateTurn && runEvent.event.omitFromPersistedHistory !== true) {
             runEvent = {
                 ...runEvent,
@@ -1722,7 +1736,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         completionInProgress = true;
         let completionError = null;
         let terminalPersistenceError = null;
-        let eventPersistenceError = null;
+        let eventPersistenceFailure = null;
         let runTerminalErrorCode;
         let runTerminalBlockedTool;
         let runTerminalBlockedBy;
@@ -1731,21 +1745,26 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         let suppressContinuationEvent = false;
         try {
             await persistenceChain;
+        }
+        catch (error) {
+            eventPersistenceFailure = { error };
+        }
+        try {
             await run.abortPersistencePromise;
         }
         catch (error) {
-            eventPersistenceError = error;
-            if (run.status !== "aborted") {
-                run.status = "errored";
-                pendingTerminalEvent = {
-                    seq: allocateRunEventSeq(run),
-                    event: {
-                        type: "error",
-                        error: "Agent run ended unexpectedly",
-                        errorCode: "run_event_persistence_failed",
-                    },
-                };
-            }
+            eventPersistenceFailure ??= { error };
+        }
+        if (eventPersistenceFailure && run.status !== "aborted") {
+            run.status = "errored";
+            pendingTerminalEvent = {
+                seq: allocateRunEventSeq(run),
+                event: {
+                    type: "error",
+                    error: "Agent run ended unexpectedly",
+                    errorCode: "run_event_persistence_failed",
+                },
+            };
         }
         if (checkpointStatusReadFailed || checkpointUnknownStatus !== null) {
             const event = checkpointStatusReadFailed
@@ -1754,7 +1773,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             const abortAlreadyWon = run.status === "aborted" && run.abortReason !== undefined;
             if (!abortAlreadyWon) {
                 run.status = "errored";
-                if (!eventPersistenceError) {
+                if (!eventPersistenceFailure) {
                     pendingTerminalEvent = {
                         seq: peekRunEventSeq(run),
                         event: { ...event },
@@ -1768,7 +1787,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         const resolveTerminalEventForCompletion = () => {
             if (run.status === "aborted" && run.abortReason !== undefined)
                 return null;
-            if (eventPersistenceError) {
+            if (eventPersistenceFailure) {
                 return pendingTerminalEvent
                     ? { ...pendingTerminalEvent, seq: run.events.length }
                     : null;
@@ -1886,7 +1905,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         if (unfinishedTurnContinuationEvent) {
             terminalEvent = unfinishedTurnContinuationEvent;
         }
-        const terminalReason = eventPersistenceError && finalStatus !== "aborted"
+        const terminalReason = eventPersistenceFailure && finalStatus !== "aborted"
             ? "error:run_event_persistence_failed"
             : privateTurn && terminalEvent?.type === "error"
                 ? "error:private_content_omitted"
@@ -1989,7 +2008,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     : error);
         };
         if (finalStatus === "completed" || finalStatus === "errored") {
-            const terminalEventToEmit = eventPersistenceError
+            const terminalEventToEmit = eventPersistenceFailure
                 ? {
                     type: "error",
                     error: "Agent run ended unexpectedly",
@@ -2048,7 +2067,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                         ? { ...terminalEventToEmit, omitFromPersistedHistory: true }
                         : terminalEventToEmit,
                 };
-                if (eventPersistenceError) {
+                if (eventPersistenceFailure) {
                     volatileTerminalEvent = terminal;
                 }
                 else {
@@ -2100,8 +2119,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 terminalPersistenceEstablished = false;
             }
             else {
+                let abortStatusAttempted = false;
                 try {
                     await insertRunPromise;
+                    abortStatusAttempted = true;
                     const persistAtomicAbort = () => markRunAborted(runId, run.abortReason ?? "execution-lease-claim-failed");
                     const aborted = executionLeaseClaimFailed
                         ? await persistAtomicAbort()
@@ -2113,6 +2134,10 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 catch (error) {
                     terminalPersistenceEstablished = false;
                     reportTerminalStatusPersistenceError(error);
+                    if (eventPersistenceFailure &&
+                        (abortStatusAttempted || eventPersistenceFailure.error !== error)) {
+                        throw new AggregateError([eventPersistenceFailure.error, error], "Run event and abort status persistence both failed");
+                    }
                     throw error;
                 }
             }
@@ -2136,7 +2161,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                     await insertRunPromise;
                 }
                 if (!continuationStatusPersistedBeforeEvent &&
-                    (!terminalPersistenceError || eventPersistenceError)) {
+                    (!terminalPersistenceError || eventPersistenceFailure)) {
                     let statusUpdated = false;
                     try {
                         statusUpdated = await persistOwnTerminalStatus();
@@ -2208,7 +2233,7 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
             }
         }
         if (terminalPersistenceError) {
-            const reconciled = eventPersistenceError
+            const reconciled = eventPersistenceFailure
                 ? false
                 : await reconcileTerminalRun();
             if (!reconciled)
@@ -2242,8 +2267,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
                 attemptCount: options?.attemptCount,
             });
         }
-        if (eventPersistenceError && finalStatus !== "aborted") {
-            throw eventPersistenceError;
+        if (eventPersistenceFailure) {
+            throw eventPersistenceFailure.error;
         }
     })
         .finally(async () => {
@@ -3069,8 +3094,6 @@ export async function abortRunDurably(runId, reason = "user", options) {
             }
             if (run)
                 run.abortPersistenceManaged = abortPersistedDurably;
-            if (eventFlushFailure)
-                throw eventFlushFailure;
         }
         catch (error) {
             if (run)
@@ -3090,8 +3113,13 @@ export async function abortRunDurably(runId, reason = "user", options) {
                 },
             });
             console.error("[run-manager] durable abort persistence failed:", error instanceof Error ? error.message : error);
+            if (eventFlushFailure) {
+                throw new AggregateError([eventFlushFailure, error], "Run abort event flush and marker persistence failed");
+            }
             throw error;
         }
+        if (eventFlushFailure)
+            throw eventFlushFailure;
         return abortedInMemory;
     })();
     if (run) {
@@ -3147,7 +3175,7 @@ export async function abortRunAtSafeBoundaryDurably(runId, reason = "user") {
         throw result.eventFlushFailure;
     return result.aborted;
 }
-export async function abortTurnByRefDurably(threadId, turnId, reason = "user") {
+async function abortTurnByRefDurablyInternal(threadId, turnId, reason, reportedFlushFailure) {
     const fence = currentExecutionFence();
     if (fence && (fence.threadId !== threadId || fence.turnId !== turnId)) {
         throw new StaleExecutionFenceError(fence);
@@ -3161,24 +3189,49 @@ export async function abortTurnByRefDurably(threadId, turnId, reason = "user") {
             runsToFlush.push(run);
         }
     }
-    const flushFailures = await Promise.all(runsToFlush.map((run) => flushRunEventsBeforeAbort(run)));
+    const flushResults = await Promise.allSettled(runsToFlush.map((run) => flushRunEventsBeforeAbort(run)));
+    // Only the same run's repeated flush is already reported by the caller;
+    // a marker write can fail with the very same error object independently.
+    const unreportedFlushFailures = [];
+    let hasRejectedFlush = false;
+    for (const [index, result] of flushResults.entries()) {
+        if (result.status === "rejected") {
+            hasRejectedFlush = true;
+            unreportedFlushFailures.push(result.reason);
+        }
+        else if (result.value &&
+            !(reportedFlushFailure &&
+                runsToFlush[index]?.runId === reportedFlushFailure.runId &&
+                result.value === reportedFlushFailure.error)) {
+            unreportedFlushFailures.push(result.value);
+        }
+    }
+    if (hasRejectedFlush) {
+        if (unreportedFlushFailures.length === 1)
+            throw unreportedFlushFailures[0];
+        throw new AggregateError(unreportedFlushFailures, "Turn abort event flushes failed");
+    }
     let result;
     try {
         result = await markTurnAborted(threadId, turnId, reason);
     }
     catch (error) {
-        const eventFlushFailure = flushFailures.find(Boolean);
-        if (eventFlushFailure) {
-            throw new AggregateError([eventFlushFailure, error], "Turn abort event flush and marker persistence failed");
+        if (unreportedFlushFailures.length) {
+            throw new AggregateError([...unreportedFlushFailures, error], "Turn abort event flush and marker persistence failed");
         }
         throw error;
     }
-    const eventFlushFailure = flushFailures.find(Boolean);
-    if (eventFlushFailure)
-        throw eventFlushFailure;
+    if (unreportedFlushFailures.length === 1)
+        throw unreportedFlushFailures[0];
+    if (unreportedFlushFailures.length > 1) {
+        throw new AggregateError(unreportedFlushFailures, "Turn abort event flushes failed");
+    }
     return result;
 }
-export async function abortTurnDurably(runId, reason = "user") {
+export async function abortTurnByRefDurably(threadId, turnId, reason = "user") {
+    return abortTurnByRefDurablyInternal(threadId, turnId, reason);
+}
+async function abortTurnDurablyInternal(runId, reason, reportedFlushFailure) {
     const memRun = activeRuns.get(runId);
     try {
         const ref = memRun
@@ -3187,7 +3240,7 @@ export async function abortTurnDurably(runId, reason = "user") {
         if (!ref) {
             throw new Error(`Cannot durably abort turn for missing run ${runId}`);
         }
-        return await abortTurnByRefDurably(ref.threadId, ref.turnId, reason);
+        return await abortTurnByRefDurablyInternal(ref.threadId, ref.turnId, reason, reportedFlushFailure);
     }
     catch (error) {
         captureError(error, {
@@ -3199,6 +3252,9 @@ export async function abortTurnDurably(runId, reason = "user") {
         throw error;
     }
 }
+export async function abortTurnDurably(runId, reason = "user") {
+    return abortTurnDurablyInternal(runId, reason);
+}
 /** Persist a Stop's turn marker even when a terminal event flush must be reported. */
 export async function abortRunAndTurnDurably(runId, reason = "user", options) {
     let abortedInMemory = false;
@@ -3222,7 +3278,9 @@ export async function abortRunAndTurnDurably(runId, reason = "user", options) {
     }
     if (!options?.safeBoundary || abortedInMemory) {
         try {
-            await abortTurnDurably(runId, reason);
+            await abortTurnDurablyInternal(runId, reason, terminalFlushFailure
+                ? { runId, error: terminalFlushFailure }
+                : undefined);
         }
         catch (error) {
             if (terminalFlushFailure) {

package/dist/agent/run-store.js

@@ -5138,13 +5138,16 @@ async function retryPendingStaleRunThreadProjections(client) {
         const projection = row;
         if (projection.thread_projection_error_code != null) {
             failed += 1;
+            console.error(`[run-store] stale projection stuck for run ${String(projection.id)}:`, projection.thread_projection_error_code);
             continue;
         }
         const runId = projection.id;
         if (typeof runId !== "string")
             continue;
-        if (!(await finalizeStaleRun(runId, "stale-projection-retry")))
+        if (!(await finalizeStaleRun(runId, "stale-projection-retry"))) {
             failed += 1;
+            console.error(`[run-store] stale projection retry failed for run ${runId}`);
+        }
     }
     return { failed, truncated };
 }

package/dist/client/integrations/workspace-provider-oauth.d.ts

@@ -15,4 +15,28 @@ export interface WorkspaceProviderOAuthOptions {
     targetAccountEmail?: string;
 }
 export declare function workspaceProviderOAuthUrl(provider: string, options: WorkspaceProviderOAuthOptions): string;
+/** True when this app runs inside another page's iframe (for example Dispatch). */
+export declare function isFramedContext(): boolean;
+/**
+ * The completion route the OAuth popup returns to. Written in the
+ * mount-relative, internal `/_agent-native` form: the app's server joins it to
+ * its own mount (see `getAppUrl`), so a path-mounted deployment does not double
+ * the prefix. The completion page posts the workspace-connection message back
+ * to the opener.
+ */
+export declare const WORKSPACE_CONNECTION_COMPLETION_RETURN = "/_agent-native/oauth/popup?complete=workspace-connection";
+/**
+ * The start URL for a popup that returns to the framework completion page, so
+ * an embedded app can learn the flow finished instead of navigating its frame
+ * to the provider (which providers refuse to be framed). The caller's own
+ * `returnPath` is preserved in the options and applied on completion.
+ */
+export declare function workspaceProviderOAuthPopupStartUrl(provider: string, options: WorkspaceProviderOAuthOptions): string;
+/**
+ * Resolve when the popup posts the framework completion message, or when it is
+ * closed without one. Accepts the completion page's origin, which can be a
+ * configured API origin distinct from the embedded UI origin, while still
+ * binding to the exact popup window. Returns a stop function.
+ */
+export declare function watchWorkspaceConnectionCompletion(popup: Window, onComplete: () => void, expectedOrigin?: string): () => void;
 export declare function startWorkspaceProviderOAuth(provider: string, options: WorkspaceProviderOAuthOptions): void;

package/dist/client/integrations/workspace-provider-oauth.js

@@ -1,4 +1,6 @@
+import { FRAMEWORK_INTERNAL_ROUTE_PREFIX } from "../../shared/framework-route-prefix.js";
 import { agentNativePath } from "../api-path.js";
+import { openOAuthPopup } from "../oauth-popup.js";
 import { serverMountReturnPath } from "../sign-in-return.js";
 export function workspaceProviderOAuthUrl(provider, options) {
     const params = new URLSearchParams({
@@ -22,6 +24,114 @@ export function workspaceProviderOAuthUrl(provider, options) {
     }
     return agentNativePath(`/_agent-native/connections/oauth/${provider}/start?${params.toString()}`);
 }
+/** True when this app runs inside another page's iframe (for example Dispatch). */
+export function isFramedContext() {
+    if (typeof window === "undefined")
+        return false;
+    try {
+        return window.top !== window.self;
+    }
+    catch {
+        // A cross-origin ancestor makes `window.top` throw; that means framed.
+        return true;
+    }
+}
+/**
+ * The completion route the OAuth popup returns to. Written in the
+ * mount-relative, internal `/_agent-native` form: the app's server joins it to
+ * its own mount (see `getAppUrl`), so a path-mounted deployment does not double
+ * the prefix. The completion page posts the workspace-connection message back
+ * to the opener.
+ */
+export const WORKSPACE_CONNECTION_COMPLETION_RETURN = `${FRAMEWORK_INTERNAL_ROUTE_PREFIX}/oauth/popup?complete=workspace-connection`;
+/** The origin that will serve the completion page and post the message. */
+function completionOrigin(startUrl) {
+    if (!URL.canParse(startUrl, window.location.href))
+        return undefined;
+    return new URL(startUrl, window.location.href).origin;
+}
+/**
+ * The start URL for a popup that returns to the framework completion page, so
+ * an embedded app can learn the flow finished instead of navigating its frame
+ * to the provider (which providers refuse to be framed). The caller's own
+ * `returnPath` is preserved in the options and applied on completion.
+ */
+export function workspaceProviderOAuthPopupStartUrl(provider, options) {
+    return workspaceProviderOAuthUrl(provider, {
+        ...options,
+        serverReturnPath: WORKSPACE_CONNECTION_COMPLETION_RETURN,
+    });
+}
+/**
+ * Resolve when the popup posts the framework completion message, or when it is
+ * closed without one. Accepts the completion page's origin, which can be a
+ * configured API origin distinct from the embedded UI origin, while still
+ * binding to the exact popup window. Returns a stop function.
+ */
+export function watchWorkspaceConnectionCompletion(popup, onComplete, expectedOrigin) {
+    let closedTicks = 0;
+    const stop = () => {
+        window.removeEventListener("message", onMessage);
+        window.clearInterval(closedTimer);
+    };
+    const onMessage = (event) => {
+        const originAccepted = event.origin === window.location.origin ||
+            (expectedOrigin !== undefined && event.origin === expectedOrigin);
+        if (!originAccepted || event.source !== popup)
+            return;
+        const data = event.data;
+        if (typeof data !== "object" ||
+            data === null ||
+            data.type !==
+                "agent-native:workspace-connection-complete")
+            return;
+        stop();
+        onComplete();
+    };
+    // The completion message is posted just before the popup closes; wait one
+    // extra tick so a close never wins the race against it.
+    const closedTimer = window.setInterval(() => {
+        if (!popup.closed) {
+            closedTicks = 0;
+            return;
+        }
+        closedTicks += 1;
+        if (closedTicks > 1)
+            stop();
+    }, 500);
+    window.addEventListener("message", onMessage);
+    return stop;
+}
+/**
+ * Apply the caller's return target on completion, so resume state carried in
+ * `returnPath` survives an embedded flow. Falls back to a reload.
+ */
+function applyReturnPath(options) {
+    if (options.returnPath) {
+        window.location.assign(options.returnPath);
+        return;
+    }
+    window.location.reload();
+}
 export function startWorkspaceProviderOAuth(provider, options) {
+    if (isFramedContext()) {
+        // Providers refuse to be framed (X-Frame-Options / frame-ancestors), so a
+        // same-window navigation inside Dispatch's iframe is refused. Leave the
+        // frame: run the flow in a popup whose completion page posts back.
+        const startUrl = workspaceProviderOAuthPopupStartUrl(provider, options);
+        const popup = openOAuthPopup({
+            initialUrl: startUrl,
+            features: "width=640,height=760",
+        });
+        if (popup) {
+            watchWorkspaceConnectionCompletion(popup, () => applyReturnPath(options), completionOrigin(startUrl));
+            return;
+        }
+        // Popup blocked while embedded. Never navigate this frame into the
+        // provider — the frame refuses it and the user cannot connect at all.
+        // Surface the recovery; the caller retries once popups are allowed.
+        console.warn("[agent-native] OAuth popup was blocked while embedded in another page; allow popups for this site to connect the provider.");
+        return;
+    }
     window.location.assign(workspaceProviderOAuthUrl(provider, options));
 }

package/dist/framework-package-versions.json

@@ -1,17 +1,17 @@
 {
-  "@agent-native/agentkit": "0.225.0",
+  "@agent-native/agentkit": "0.225.2-nightly-20261106152255",
   "@agent-native/code-agents-ui": "0.1.75",
-  "@agent-native/core": "0.225.0",
-  "@agent-native/core-corpus": "0.225.0",
-  "@agent-native/creative-context": "0.8.66",
-  "@agent-native/dispatch": "0.42.1",
+  "@agent-native/core": "0.225.2-nightly-20261106152255",
+  "@agent-native/core-corpus": "0.225.2-nightly-20261106152255",
+  "@agent-native/creative-context": "0.8.67",
+  "@agent-native/dispatch": "0.42.3-nightly-20261106152255",
   "@agent-native/embedding": "0.2.0",
   "@agent-native/migrate": "0.0.7",
-  "@agent-native/otel": "0.1.33",
-  "@agent-native/pinpoint": "0.1.109",
-  "@agent-native/recap-cli": "0.5.97",
-  "@agent-native/scheduling": "0.2.53",
+  "@agent-native/otel": "0.1.34",
+  "@agent-native/pinpoint": "0.1.110",
+  "@agent-native/recap-cli": "0.5.98",
+  "@agent-native/scheduling": "0.2.54",
   "@agent-native/shared-app-config": "0.1.2",
-  "@agent-native/skills": "0.4.1",
-  "@agent-native/toolkit": "0.225.0"
+  "@agent-native/skills": "0.4.3-nightly-20261106152255",
+  "@agent-native/toolkit": "0.225.2-nightly-20261106152255"
 }

package/dist/server/agent-chat-plugin.js

@@ -8167,28 +8167,38 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                             jobsSkippedReason: "unclaimed-background-sweep-failed",
                         };
                     }
+                    const incompleteSteps = [
+                        staleRunReapIncomplete && "staleRunsReaped",
+                        agentHarnessFollowUpRecoveryIncomplete &&
+                            "expiredAgentHarnessFollowUps",
+                        agentHarnessApprovalRecoveryIncomplete &&
+                            "expiredAgentHarnessApprovals",
+                        appSweepHandlers.failed.length > 0 && "appSweepHandlers",
+                        automationFailureAlerts === null && "automationFailureAlerts",
+                        (queuedSubmissionDrain === null ||
+                            queuedSubmissionDrain.failed > 0) &&
+                            "queuedSubmissionDrain",
+                        (staleAgentTeamRuns === null || staleAgentTeamRuns.failed > 0) &&
+                            "staleAgentTeamRuns",
+                    ].filter((step) => typeof step === "string");
+                    if (incompleteSteps.length > 0) {
+                        console.error("[recurring-jobs] Sweep incomplete:", {
+                            incompleteSteps,
+                            staleRunsReaped,
+                            expiredAgentHarnessFollowUps,
+                            expiredAgentHarnessApprovals,
+                            staleAgentTeamRuns,
+                            queuedSubmissionDrain,
+                            automationFailureAlerts,
+                            appSweepHandlers,
+                        });
+                    }
                     if (!triggerAvailability.available) {
-                        if (staleRunReapIncomplete ||
-                            agentHarnessFollowUpRecoveryIncomplete ||
-                            agentHarnessApprovalRecoveryIncomplete ||
-                            appSweepHandlers.failed.length > 0 ||
-                            automationFailureAlerts === null ||
-                            queuedSubmissionDrain === null ||
-                            queuedSubmissionDrain.failed > 0 ||
-                            staleAgentTeamRuns === null ||
-                            staleAgentTeamRuns.failed > 0) {
+                        if (incompleteSteps.length > 0) {
                             setResponseStatus(event, 500);
                         }
                         return {
-                            ok: !staleRunReapIncomplete &&
-                                !agentHarnessFollowUpRecoveryIncomplete &&
-                                !agentHarnessApprovalRecoveryIncomplete &&
-                                appSweepHandlers.failed.length === 0 &&
-                                automationFailureAlerts !== null &&
-                                queuedSubmissionDrain !== null &&
-                                queuedSubmissionDrain.failed === 0 &&
-                                staleAgentTeamRuns !== null &&
-                                staleAgentTeamRuns.failed === 0,
+                            ok: incompleteSteps.length === 0,
                             staleRunsReaped,
                             expiredAgentHarnessFollowUps,
                             expiredAgentHarnessApprovals,
@@ -8204,15 +8214,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     }
                     try {
                         await processRecurringJobs(schedulerDeps);
-                        if (staleRunReapIncomplete ||
-                            agentHarnessFollowUpRecoveryIncomplete ||
-                            agentHarnessApprovalRecoveryIncomplete ||
-                            appSweepHandlers.failed.length > 0 ||
-                            automationFailureAlerts === null ||
-                            queuedSubmissionDrain === null ||
-                            queuedSubmissionDrain.failed > 0 ||
-                            staleAgentTeamRuns === null ||
-                            staleAgentTeamRuns.failed > 0) {
+                        if (incompleteSteps.length > 0) {
                             setResponseStatus(event, 500);
                             return {
                                 ok: false,

package/dist/server/auth.js

@@ -3211,11 +3211,38 @@ function createAuthGuardFn(app) {
         if (session) {
             const method = getMethod(event);
             if (p.startsWith("/api/") || p.startsWith("/_agent-native/")) {
+                // A fresh loopback dev workspace has no session org yet, and the
+                // read-only session resolver never creates one, so the app-access check
+                // below can deny before the ordinary org initializer runs. Resolve (or
+                // create) the existing default org through the normal policy first and
+                // hand its id to the unchanged check. The check still owns the verdict;
+                // a missing or failed org initialization also denies protected requests,
+                // while null keeps the wrapper's org-recovery exemption.
+                let workspaceOrgId = session.orgId;
+                let workspaceOrgInitializationFailed = false;
+                if (!workspaceOrgId &&
+                    !hasExplicitPersonalOrgScope(event) &&
+                    isSyntheticAutoDevIdentity(session.email) &&
+                    isLoopbackDevRequest(event) &&
+                    getAppConfig().access.orgCreation === "open" &&
+                    getAppConfig().access.autoCreateDefaultOrg) {
+                    const { getOrgContext } = await import("../org/context.js");
+                    try {
+                        const org = await getOrgContext(event);
+                        if (org.orgId)
+                            workspaceOrgId = org.orgId;
+                        else
+                            workspaceOrgInitializationFailed = true;
+                    }
+                    catch {
+                        workspaceOrgInitializationFailed = true;
+                    }
+                }
                 let workspaceAppAccess = await checkWorkspaceAppAccessForRequest({
                     path: p,
                     method,
                     email: session.email,
-                    ...(session.orgId === undefined ? {} : { orgId: session.orgId }),
+                    ...(workspaceOrgId === undefined ? {} : { orgId: workspaceOrgId }),
                 });
                 if (workspaceAppAccess === false &&
                     !session.orgId &&
@@ -3246,7 +3273,8 @@ function createAuthGuardFn(app) {
                     setResponseStatus(event, 503);
                     return workspaceAppAccessUnavailableBody(workspaceAppAccess);
                 }
-                if (workspaceAppAccess === false) {
+                if ((workspaceOrgInitializationFailed && workspaceAppAccess !== null) ||
+                    workspaceAppAccess === false) {
                     setResponseStatus(event, 403);
                     return { error: "You do not have access to this workspace app." };
                 }
@@ -3408,6 +3436,22 @@ export function isLocalDevAuthAllowed(event) {
         ((!isHostedPreviewRequest(event) && isLoopbackRequest(event)) ||
             isBuilderPreviewLocalDevRequest(event)));
 }
+/**
+ * A real loopback dev/test request. `isLocalDevAuthAllowed` also admits the
+ * Builder-preview branch, which does not require loopback, so org
+ * auto-initialization additionally requires the actual socket peer and
+ * excludes hosted-preview hosts. Builder preview keeps the ordinary
+ * app-access path.
+ */
+function isLoopbackDevRequest(event) {
+    return (isLocalDevAuthAllowed(event) &&
+        isLoopbackRequest(event) &&
+        !isHostedPreviewRequest(event));
+}
+/** The framework's own throwaway local account, never a real signup. */
+function isSyntheticAutoDevIdentity(email) {
+    return (email === AUTO_DEV_ACCOUNT_EMAIL || email === LEGACY_AUTO_DEV_ACCOUNT_EMAIL);
+}
 async function createOrReuseAutoDevSession(auth, config) {
     let session = await createBetterAuthSessionForEmail(AUTO_DEV_ACCOUNT_EMAIL, config);
     if (!session) {

package/dist/shared/attachments.d.ts

@@ -1,3 +1,4 @@
+import { isPersistableAttachmentUrl } from "@agent-native/agentkit/protocol";
+export { isPersistableAttachmentUrl };
 export declare function isInlineDataUrl(value: unknown): value is string;
-export declare function isPersistableAttachmentUrl(value: unknown): value is string;
 export declare function stripInlineAttachmentPayloads(value: unknown, attachmentContext?: boolean): unknown;

package/dist/shared/attachments.js

@@ -1,3 +1,5 @@
+import { isPersistableAttachmentUrl } from "@agent-native/agentkit/protocol";
+export { isPersistableAttachmentUrl };
 const ATTACHMENT_BODY_FIELDS = new Set([
     "base64",
     "bytes",
@@ -30,19 +32,6 @@ const ATTACHMENT_CONTEXT_FIELDS = new Set([
 export function isInlineDataUrl(value) {
     return typeof value === "string" && /^\s*data:/i.test(value);
 }
-export function isPersistableAttachmentUrl(value) {
-    if (typeof value !== "string" || !value.trim())
-        return false;
-    if (!URL.canParse(value))
-        return false;
-    const url = new URL(value);
-    return (url.protocol === "https:" &&
-        Boolean(url.hostname) &&
-        !url.username &&
-        !url.password &&
-        !url.search &&
-        !url.hash);
-}
 function isBase64Payload(value) {
     return (typeof value === "string" &&
         value.trim().length >= 64 &&

package/dist/shared/inline-bytes.js

@@ -1,19 +1,6 @@
+import { isPersistableAttachmentReferenceUrl } from "@agent-native/agentkit/protocol";
 import { isInlineDataUrl } from "./attachments.js";
 import { parseDataUrl } from "./data-url.js";
-function isPersistableAttachmentReferenceUrl(value) {
-    if (typeof value !== "string" || !value.trim() || value.length > 8192) {
-        return false;
-    }
-    if (!URL.canParse(value))
-        return false;
-    const url = new URL(value);
-    return ((url.protocol === "http:" || url.protocol === "https:") &&
-        Boolean(url.hostname) &&
-        !url.username &&
-        !url.password &&
-        !url.search &&
-        !url.hash);
-}
 /**
  * Inline file bytes reached a SQL write with no durable URL to stand in for
  * them. Raised only by the `reject` policy; a durable dispatch payload must
@@ -177,10 +164,10 @@ function sanitize(value, policy, inAttachmentList, inheritedUrl, inAttachmentMet
     const ownUrl = hasAttachmentContext ? durableUrl(item) : undefined;
     const fallbackUrl = ownUrl ?? (hasAttachmentContext ? inheritedUrl : undefined);
     const inline = hasAttachmentContext ? inlineKeys(item) : [];
-    const unreferenced = isAttachment &&
-        inline.length > 0 &&
-        !fallbackUrl &&
-        !(typeof item.fileId === "string" && item.fileId);
+    // A `fileId` names the attachment; nothing resolves it back to bytes, so it
+    // never stands in for bytes that need a URL. The dispatch serializer agrees
+    // for parts that carry bytes.
+    const unreferenced = isAttachment && inline.length > 0 && !fallbackUrl;
     if (unreferenced && policy === "reject") {
         throw new DurableAttachmentReferenceRequiredError();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.225.0",
+  "version": "0.225.2-nightly-20261106152255",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -760,8 +760,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.225.0",
-    "@agent-native/recap-cli": "^0.5.97"
+    "@agent-native/agentkit": "^0.225.2-nightly-20261106152255",
+    "@agent-native/recap-cli": "^0.5.98"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -833,7 +833,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": ">=0.196.0",
+    "@agent-native/core-corpus": "0.225.2-nightly-20261106152255",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",