@agent-native/core 0.206.0 → 0.206.1-nightly-20261009183700

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

@@ -11,6 +11,7 @@ import { getRequestOrgId, getRequestUserEmail, } from "../server/request-context
 import { getOrgSetting, putOrgSetting } from "../settings/org-settings.js";
 import { getSetting } from "../settings/store.js";
 import { getUserSetting, putUserSetting } from "../settings/user-settings.js";
+import { track } from "../tracking/registry.js";
 import { canUpdateAgentAppModelDefaultSettings } from "./app-model-defaults.js";
 export const DEFAULT_AGENT_ENGINE_SETTING_KEY = "agent-engine";
 /** Audit target type for default-model changes and refused attempts. */
@@ -98,6 +99,7 @@ async function writeScopedRow(authority, value) {
  * stores only that scope and records the change.
  */
 export async function writeDefaultAgentEngineSelection(authority, selection, meta) {
+    const previous = await readDefaultAgentEngineSettingDetailed(authority);
     await writeScopedRow(authority, {
         engine: selection.engine,
         model: selection.model,
@@ -112,12 +114,25 @@ export async function writeDefaultAgentEngineSelection(authority, selection, met
         operation: "set",
         selection,
     });
+    track("llm_default_model_changed", {
+        engine: selection.engine,
+        model: selection.model,
+        ...(typeof previous.value?.engine === "string"
+            ? { previous_engine: previous.value.engine }
+            : {}),
+        ...(typeof previous.value?.model === "string"
+            ? { previous_model: previous.value.model }
+            : {}),
+        scope: authority.scope,
+        operation: "set",
+    }, { userId: authority.userEmail });
 }
 /**
  * Clear the default for the authority's scope. Writes a cleared marker rather
  * than deleting the row; see {@link readDefaultAgentEngineSettingDetailed}.
  */
 export async function clearDefaultAgentEngineSelection(authority, meta) {
+    const previous = await readDefaultAgentEngineSettingDetailed(authority);
     await writeScopedRow(authority, {
         cleared: true,
         updatedAt: Date.now(),
@@ -130,6 +145,16 @@ export async function clearDefaultAgentEngineSelection(authority, meta) {
         status: "success",
         operation: "clear",
     });
+    track("llm_default_model_changed", {
+        ...(typeof previous.value?.engine === "string"
+            ? { previous_engine: previous.value.engine }
+            : {}),
+        ...(typeof previous.value?.model === "string"
+            ? { previous_model: previous.value.model }
+            : {}),
+        scope: authority.scope,
+        operation: "reset",
+    }, { userId: authority.userEmail });
 }
 /** Record a refused change so owners and admins can see who tried. */
 export async function recordDefaultAgentEngineRefusal(ctx, authority, operation, meta, selection) {

package/dist/agent/durable-background.d.ts

@@ -51,6 +51,8 @@ export declare const AGENT_CHAT_DURABLE_BACKGROUND_ENV = "AGENT_CHAT_DURABLE_BAC
  * verifies the HMAC token before invoking the handler.
  */
 export declare const AGENT_CHAT_BACKGROUND_RUN_FIELD = "__backgroundRun";
+/** Analytics-only source context captured before the run leaves its browser request. */
+export declare const AGENT_CHAT_BROWSER_SESSION_ID_FIELD = "__agentNativeBrowserSessionId";
 export declare function isHostedRuntimeForDurableBackground(): boolean;
 export declare function isNetlifyHostedRuntimeForDurableBackground(): boolean;
 export declare function isInBackgroundFunctionRuntime(): boolean;

package/dist/agent/durable-background.js

@@ -131,6 +131,8 @@ export const AGENT_CHAT_DURABLE_BACKGROUND_ENV = "AGENT_CHAT_DURABLE_BACKGROUND"
  * verifies the HMAC token before invoking the handler.
  */
 export const AGENT_CHAT_BACKGROUND_RUN_FIELD = "__backgroundRun";
+/** Analytics-only source context captured before the run leaves its browser request. */
+export const AGENT_CHAT_BROWSER_SESSION_ID_FIELD = "__agentNativeBrowserSessionId";
 export function isHostedRuntimeForDurableBackground() {
     if (process.env.NETLIFY_LOCAL === "true")
         return false;

package/dist/agent/engine/error-detail.d.ts

@@ -16,6 +16,7 @@ export interface ProviderErrorClassification {
     providerRetryable?: boolean;
     retryAfterMs?: number;
 }
+export declare function isInvalidAttachmentProviderMessage(message: string): boolean;
 export declare function extractRetryAfterMs(err: unknown): number | undefined;
 export declare function classifyProviderError(err: unknown, timedOut?: boolean): ProviderErrorClassification;
 /**

package/dist/agent/engine/error-detail.js

@@ -90,7 +90,12 @@ export function isContextOverflowCode(code) {
 const MAX_RETRY_AFTER_MS = 60_000;
 const PROVIDER_ATTACHMENT_FIELD_PATTERN = /\b(?:images?|files?|attachments?|media)[_-](?:url|data|source|type|format|size|input|content)\b|\b(?:images?|files?)\s+(?:url|data|source|type|format|size|content)\b|\b(?:url|data|source|type|format|size|input|content)\b.{0,40}\b(?:images?|files?|attachments?|media)\b|\bmime[\s_-]?type\b/gi;
 const PROVIDER_ATTACHMENT_REJECTION_PATTERN = /\b(?:invalid|unsupported|not supported|does not support|too large|too big|too long|exceeds?|over(?:sized|size| the)? limit|maximum (?:allowed )?(?:size|length)|(?:size|length) limit|malformed)\b/i;
-function isInvalidAttachmentProviderMessage(message) {
+// Phrasings Anthropic, OpenAI, Google, and the Builder gateway use for an
+// image they refused. Specific enough to classify without a status code.
+const PROVIDER_IMAGE_REJECTION_PATTERN = /\bimage exceeds \d+(?:\.\d+)?\s*mb\b|\b(?:could not|unable to) process (?:the )?(?:input )?image\b|\binvalid image\b|\bunsupported image\b|\bimage (?:is )?too (?:large|big)\b|\bprovided image is not valid\b/i;
+export function isInvalidAttachmentProviderMessage(message) {
+    if (PROVIDER_IMAGE_REJECTION_PATTERN.test(message))
+        return true;
     for (const match of message.matchAll(PROVIDER_ATTACHMENT_FIELD_PATTERN)) {
         const index = match.index ?? 0;
         const start = Math.max(0, index - 100);

package/dist/agent/engine/translate-anthropic.d.ts

@@ -10,6 +10,15 @@ export declare function unmatchedToolResultReplayText(part: {
     content: unknown;
     isError?: boolean;
 }): string;
+/**
+ * Identity of a synthetic interrupted tool result in engine messages, thread
+ * data, and the client (`client/sse-event-processor.ts` matches it verbatim).
+ * The model never sees it bare: replay rewrites it to an error whose outcome
+ * is unknown, or the model treats it as "did not run" and repeats a write that
+ * may have landed.
+ */
+export declare const INTERRUPTED_TOOL_RESULT_MARKER = "Interrupted before this tool returned a result.";
+export declare function isInterruptedToolResult(content: unknown): boolean;
 export declare function backfillEngineMessagesToolResults(messages: EngineMessage[]): EngineMessage[];
 export declare function engineMessageToAnthropic(msg: EngineMessage, opts?: {
     builderGateway?: boolean;

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

@@ -74,13 +74,27 @@ export function unmatchedToolResultReplayText(part) {
     const err = part.isError ? " isError=true" : "";
     return `${UNMATCHED_TOOL_RESULT_REPLAY_PREFIX} [tool_use_id=${part.toolCallId}${err}] ${body}`;
 }
+/**
+ * Identity of a synthetic interrupted tool result in engine messages, thread
+ * data, and the client (`client/sse-event-processor.ts` matches it verbatim).
+ * The model never sees it bare: replay rewrites it to an error whose outcome
+ * is unknown, or the model treats it as "did not run" and repeats a write that
+ * may have landed.
+ */
+export const INTERRUPTED_TOOL_RESULT_MARKER = "Interrupted before this tool returned a result.";
+const INTERRUPTED_TOOL_RESULT_FOR_MODEL = `${INTERRUPTED_TOOL_RESULT_MARKER} Its outcome is UNKNOWN: the tool may have run. Verify the current state before repeating any write.`;
+export function isInterruptedToolResult(content) {
+    return (typeof content === "string" &&
+        content.startsWith(INTERRUPTED_TOOL_RESULT_MARKER));
+}
 function interruptedToolResultPart(part) {
     return {
         type: "tool-result",
         toolCallId: part.id,
         toolName: part.name,
         toolInput: stringifyToolUseInputForGateway(part.input),
-        content: "Interrupted before this tool returned a result.",
+        content: INTERRUPTED_TOOL_RESULT_FOR_MODEL,
+        isError: true,
     };
 }
 export function backfillEngineMessagesToolResults(messages) {
@@ -167,13 +181,14 @@ export function backfillEngineMessagesToolResults(messages) {
             const toolInput = typeof part.toolInput === "string" && part.toolInput.length > 0
                 ? part.toolInput
                 : stringifyToolUseInputForGateway(pendingLookup?.input ?? lookup?.input);
+            const interrupted = part.content === INTERRUPTED_TOOL_RESULT_MARKER;
             const filled = {
                 type: "tool-result",
                 toolCallId: part.toolCallId,
                 toolName,
                 toolInput,
-                content: part.content,
-                ...(part.isError ? { isError: true } : {}),
+                content: interrupted ? INTERRUPTED_TOOL_RESULT_FOR_MODEL : part.content,
+                ...(part.isError || interrupted ? { isError: true } : {}),
                 ...(part.images && part.images.length > 0
                     ? { images: part.images }
                     : {}),

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

@@ -10,6 +10,7 @@ import { type BuilderGatewayAuth } from "../server/credential-provider.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { type RefusedTurnRetryContext } from "../shared/agent-chat-run-not-started.js";
 import { type ContextStatus } from "../shared/context-status.js";
+import { DurableAttachmentReferenceRequiredError } from "../shared/inline-bytes.js";
 import { type ReasoningEffort } from "../shared/reasoning-effort.js";
 import type { TrackingMeta } from "../tracking/registry.js";
 import { type ResolveEngineConfig } from "./engine/index.js";
@@ -357,10 +358,7 @@ export declare function runCompletionCallbackWithDatabaseRetry(callback: () => v
 }): Promise<void>;
 export declare function resolveSourceSweepToolCallThreshold(): number;
 declare function generateRunId(): string;
-export declare class DurableAttachmentReferenceRequiredError extends Error {
-    readonly code = "attachment_storage_required";
-    constructor();
-}
+export { DurableAttachmentReferenceRequiredError };
 export declare function serializeDurableDispatchPayload(body: Record<string, unknown>): string;
 /** Check if an error is transient and should be retried
  * @internal exported for unit tests only
@@ -778,6 +776,8 @@ 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>;
+/** @internal exported for unit tests only */
+export declare function queuedPromotionAttachments(attachments: unknown[]): AgentChatAttachment[];
 declare function emitRunText(run: ActiveRun, text: string): Promise<void>;
 export interface ChainServerDrivenContinuationDeps {
     countRunsForTurn?: typeof countRunsForTurn;

package/dist/agent/production-agent.js

@@ -45,6 +45,7 @@ import { ANALYTICS_CLIENT_PLATFORM_BODY_FIELD } from "../shared/analytics-platfo
 import { isContextDegraded, preloadedContextUnavailableNote, readReportedContextStatus, screenContextUnavailableNote, SELECTION_CONTEXT_UNAVAILABLE_NOTE, worstContextStatus, } from "../shared/context-status.js";
 import { parseBase64DataUrl } from "../shared/data-url.js";
 import { stripDiagnosticSnippets } from "../shared/diagnostic-snippet.js";
+import { DurableAttachmentReferenceRequiredError, stripInlineBytes, } from "../shared/inline-bytes.js";
 import { isReasoningEffort, normalizeReasoningEffortForRequest, stepDownReasoningEffort, } from "../shared/reasoning-effort.js";
 import { SYNTHETIC_TRAFFIC_BETA_E2E, SYNTHETIC_TRAFFIC_HEADER, } from "../shared/test-traffic.js";
 import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
@@ -53,17 +54,17 @@ import { CONTINUE_UNAVAILABLE_CODE, } from "./auto-continue.js";
 import { clipHead } from "./clip-text.js";
 import { connectionRequiredMessage, priorConnectionContextNote, resolvePriorConnectionNote, } from "./connection-required-note.js";
 import { buildSystemManifestSections, readContextXraySystemSections, } from "./context-xray/manifest.js";
-import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, isInBackgroundFunctionRuntime, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
+import { AGENT_CHAT_BROWSER_SESSION_ID_FIELD, AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroundRuntimeDiagnosticDetail, dispatchPathTargetsNetlifyBackgroundFunction, isAgentChatDurableBackgroundEnabled, isAgentChatForegroundSelfChainEnabled, isInBackgroundFunctionRuntime, resolveAgentChatProcessRunDispatchPath, shouldUseBackgroundFunctionTimeoutForWorker, } from "./durable-background.js";
 import { applyContextXrayTransformForIteration } from "./engine/context-directives-transform.js";
 import { attemptContinuationDispatch } from "./engine/continuation-dispatch-retry.js";
 import { formatLlmCredentialErrorMessage, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, userFacingLlmCredentialError, } from "./engine/credential-errors.js";
-import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE, isContextOverflowCode, isContextOverflowMessage, isProviderConnectionErrorMessage, PROVIDER_RATE_LIMITED_ERROR_CODE, PROVIDER_TRANSIENT_REJECTION_ERROR_CODE, } from "./engine/error-detail.js";
+import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE, isContextOverflowCode, isContextOverflowMessage, isInvalidAttachmentProviderMessage, isProviderConnectionErrorMessage, PROVIDER_RATE_LIMITED_ERROR_CODE, PROVIDER_TRANSIENT_REJECTION_ERROR_CODE, } from "./engine/error-detail.js";
 import { resolveEngine, explicitEngineName, registerBuiltinEngines, getStoredModelForEngine, normalizeModelForEngine, isResolvedEngineUsableForRequest, } from "./engine/index.js";
 import { limitProviderTools, MAX_PROVIDER_TOOLS, } from "./engine/limit-provider-tools.js";
 import { resolveEmptyResponseRetryMaxOutputTokens, resolveMainChatMaxOutputTokens, resolveMaxOutputTokensForEngine, } from "./engine/output-tokens.js";
 import { PROVIDER_TO_ENV } from "./engine/provider-env-vars.js";
 import { JOURNALED_TOOL_REPLAY_PREFIX, RECOVERED_TOOL_REPLAY_PREFIX, loadedSkillPagesContext, loadPriorTurnToolCallJournal, seedRepeatedToolErrorCountsFromJournal, seedRepeatedToolCallCountsFromJournal, } from "./engine/tool-call-journal-seed.js";
-import { backfillEngineMessagesToolResults, stringifyToolUseInputForGateway, unmatchedToolResultReplayText, } from "./engine/translate-anthropic.js";
+import { backfillEngineMessagesToolResults, INTERRUPTED_TOOL_RESULT_MARKER, isInterruptedToolResult, stringifyToolUseInputForGateway, unmatchedToolResultReplayText, } from "./engine/translate-anthropic.js";
 import { EngineError } from "./engine/types.js";
 import { FOLLOW_UP_SUGGESTIONS_COMPLETION_SYSTEM_PROMPT, FOLLOW_UP_SUGGESTIONS_INSTRUCTION, FOLLOW_UP_SUGGESTIONS_MAX_OUTPUT_TOKENS, FOLLOW_UP_SUGGESTIONS_TOOL_NAME, buildFollowUpCompletionMessages, followUpSuggestionsTool, identifyFollowUpSuggestions, parseFollowUpSuggestions, } from "./follow-up-suggestions.js";
 import { filterHostedHarnessToolNames, normalizeHostedHarnessRuntime, } from "./harness/hosted.js";
@@ -1139,59 +1140,9 @@ function limitInventoryLines(lines, label) {
 function generateRunId() {
     return `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
-export class DurableAttachmentReferenceRequiredError extends Error {
-    code = "attachment_storage_required";
-    constructor() {
-        super("An attachment has inline bytes but no durable file URL. Configure file storage and retry this background run.");
-        this.name = "DurableAttachmentReferenceRequiredError";
-    }
-}
-function isDataUrlReference(value) {
-    return typeof value === "string" && /^\s*data:/i.test(value);
-}
-function hasDurableAttachmentUrl(value) {
-    return (typeof value === "string" &&
-        value.trim().length > 0 &&
-        !isDataUrlReference(value));
-}
-function sanitizeDurableAttachment(value, attachmentContext = false) {
-    if (Array.isArray(value)) {
-        return value.map((item) => sanitizeDurableAttachment(item));
-    }
-    if (!value || typeof value !== "object")
-        return value;
-    const item = value;
-    const isAttachment = attachmentContext ||
-        item.type === "image" ||
-        item.type === "file" ||
-        item.type === "document";
-    if (isAttachment &&
-        (isDataUrlReference(item.url) || isDataUrlReference(item.referenceUrl))) {
-        throw new DurableAttachmentReferenceRequiredError();
-    }
-    const hasInlineData = isAttachment && item.data !== undefined;
-    if (hasInlineData &&
-        !hasDurableAttachmentUrl(item.url) &&
-        !hasDurableAttachmentUrl(item.referenceUrl)) {
-        throw new DurableAttachmentReferenceRequiredError();
-    }
-    const sanitized = {};
-    for (const [key, child] of Object.entries(item)) {
-        if (key === "data" && hasInlineData)
-            continue;
-        if (key === "attachments" || key === "requestAttachments") {
-            sanitized[key] = Array.isArray(child)
-                ? child.map((attachment) => sanitizeDurableAttachment(attachment, true))
-                : sanitizeDurableAttachment(child);
-        }
-        else {
-            sanitized[key] = sanitizeDurableAttachment(child);
-        }
-    }
-    return sanitized;
-}
+export { DurableAttachmentReferenceRequiredError };
 export function serializeDurableDispatchPayload(body) {
-    const payload = JSON.stringify(sanitizeDurableAttachment(body));
+    const payload = JSON.stringify(stripInlineBytes(body, "reject"));
     if (typeof payload !== "string") {
         throw new TypeError("Durable dispatch payload could not be serialized");
     }
@@ -1550,6 +1501,51 @@ export function buildUserContentWithAttachments(opts) {
     });
     return userContent;
 }
+/** Images reach only a model that reads them; the model learns one was withheld. */
+function replaceImagesForModelWithoutVision(messages, model) {
+    const note = `<chat-attachment-processing-error code="model-without-vision" model="${escapeAttachmentAttribute(model)}">An attached image was not sent because the active model cannot read images. Do not infer or describe its contents. Tell the user to switch to a vision-capable model if the image matters.</chat-attachment-processing-error>`;
+    return messages.map((message) => message.content.some((part) => part.type === "image")
+        ? {
+            ...message,
+            content: message.content.map((part) => part.type === "image"
+                ? { type: "text", text: note }
+                : part),
+        }
+        : message);
+}
+/**
+ * Every engine's stop error passes through here with the request in hand, so
+ * this is where a provider's rejection of an inline attachment becomes the
+ * non-retryable `invalid_attachment`: resending the same bytes fails the same
+ * way, and an `http_400` lets Retry loop on it.
+ */
+function engineStopError(event, messages) {
+    const error = event.error ?? "Engine stream error";
+    const parts = messages.flatMap((message) => message.content);
+    const hasInlineAttachment = parts.some((part) => part.type === "image" ||
+        part.type === "file" ||
+        (part.type === "tool-result" && (part.images?.length ?? 0) > 0));
+    const attachmentRejected = event.errorCode === "invalid_attachment" ||
+        (hasInlineAttachment &&
+            (event.statusCode === 413 ||
+                ((event.statusCode === undefined ||
+                    event.statusCode === 400 ||
+                    event.statusCode === 422) &&
+                    isInvalidAttachmentProviderMessage(error))));
+    const names = parts.flatMap((part) => part.type === "file" && part.filename ? [`"${part.filename}"`] : []);
+    return new EngineError(attachmentRejected
+        ? `The model provider rejected an attachment in this request${names.length > 0 ? ` (${names.join(", ")})` : ""}: ${error}`
+        : error, {
+        errorCode: attachmentRejected ? "invalid_attachment" : event.errorCode,
+        upgradeUrl: event.upgradeUrl,
+        statusCode: event.statusCode,
+        providerRetryable: attachmentRejected ? false : event.providerRetryable,
+        contextOverflow: event.contextOverflow,
+        requestId: event.requestId,
+        requestShape: event.requestShape,
+        retryAfterMs: event.retryAfterMs,
+    });
+}
 export function appendRequestAttachmentContextToResumedHistory(messages, attachments) {
     if (!attachments?.length)
         return;
@@ -2448,7 +2444,6 @@ export function isCachedToolResultVisibleInContext(contextMessages, toolCall, ca
     }
     return false;
 }
-const INTERRUPTED_TOOL_RESULT_MARKER = "Interrupted before this tool returned a result.";
 const INTERRUPTED_TOOL_LEDGER_RECOVERY_TIMEOUT_MS = 5_000;
 const MAX_IDENTICAL_TOOL_ERRORS = 3;
 export const MAX_SAME_ERROR_ACROSS_ARGUMENTS = 3;
@@ -2535,9 +2530,10 @@ function seedWriteToolInterruptionsFromHistory(messages, actions) {
             const call = pendingToolCalls.get(part.toolCallId);
             if (!call)
                 continue;
-            if (typeof part.content === "string" &&
-                (part.content === INTERRUPTED_TOOL_RESULT_MARKER ||
-                    (part.isError === true && isToolCallTimeoutResult(part.content)))) {
+            if (isInterruptedToolResult(part.content) ||
+                (part.isError === true &&
+                    typeof part.content === "string" &&
+                    isToolCallTimeoutResult(part.content))) {
                 const key = toolCallCacheKey(call.name, call.input);
                 interruptions.set(key, (interruptions.get(key) ?? 0) + 1);
             }
@@ -3930,12 +3926,15 @@ export async function runAgentLoop(opts) {
                     const { thinking: _thinking, ...anthropic } = providerOptions.anthropic;
                     providerOptions = { ...providerOptions, anthropic };
                 }
+                const engineMessages = engine.capabilities.vision === false
+                    ? replaceImagesForModelWithoutVision(contextMessages, model)
+                    : contextMessages;
                 const streamOpts = {
                     model,
                     systemPrompt: completingFollowUpSuggestions
                         ? FOLLOW_UP_SUGGESTIONS_COMPLETION_SYSTEM_PROMPT
                         : continuationSystemPrompt,
-                    messages: contextMessages,
+                    messages: engineMessages,
                     tools: loopBreakerCloseout
                         ? []
                         : completingFollowUpSuggestions
@@ -3954,7 +3953,7 @@ export async function runAgentLoop(opts) {
                     providerOptions,
                 };
                 usage.llmCalls = (usage.llmCalls ?? 0) + 1;
-                notifyModelInputObserver(opts.onModelInput, contextMessages);
+                notifyModelInputObserver(opts.onModelInput, engineMessages);
                 const eventStream = engine.stream(streamOpts);
                 let thinkingBuffer = "";
                 const toolInputNames = new Map();
@@ -4224,16 +4223,7 @@ export async function runAgentLoop(opts) {
                         else if (event.type === "stop") {
                             terminalStopReason = event.reason;
                             if (event.reason === "error") {
-                                throw new EngineError(event.error ?? "Engine stream error", {
-                                    errorCode: event.errorCode,
-                                    upgradeUrl: event.upgradeUrl,
-                                    statusCode: event.statusCode,
-                                    providerRetryable: event.providerRetryable,
-                                    contextOverflow: event.contextOverflow,
-                                    requestId: event.requestId,
-                                    requestShape: event.requestShape,
-                                    retryAfterMs: event.retryAfterMs,
-                                });
+                                throw engineStopError(event, engineMessages);
                             }
                         }
                         if (hasNoProgressStalled()) {
@@ -6500,11 +6490,20 @@ async function readAdmittedQueuedMessagePromotion(opts) {
         ...(options ? { options: options } : {}),
     };
 }
-function queuedPromotionAttachments(attachments) {
+/** @internal exported for unit tests only */
+export function queuedPromotionAttachments(attachments) {
     return attachments.map((value) => {
         const file = queuedPromotionRecord(value);
+        // A saved queue entry is always a file part; the media type decides whether
+        // the model sees pixels (image) or a file reference.
+        const isImage = typeof file.mediaType === "string" &&
+            file.mediaType
+                .split(";", 1)[0]
+                .trim()
+                .toLowerCase()
+                .startsWith("image/");
         return {
-            type: "file",
+            type: isImage ? "image" : "file",
             name: file.name,
             ...(typeof file.fileId === "string" ? { id: file.fileId } : {}),
             ...(typeof file.mediaType === "string"
@@ -7063,6 +7062,9 @@ export function createProductionAgentHandler(options) {
             });
         const mutableBody = body;
         if (!isBackgroundWorker) {
+            // A client can submit this private field, so overwrite it at the boundary.
+            mutableBody[AGENT_CHAT_BROWSER_SESSION_ID_FIELD] =
+                getRequestContext()?.browserSessionId ?? null;
             delete mutableBody[ANALYTICS_CLIENT_PLATFORM_BODY_FIELD];
         }
         if (dispatchToBackground) {
@@ -7531,7 +7533,9 @@ export function createProductionAgentHandler(options) {
         const turnUsageLabel = normalizeUsageLabel(body.usageLabel);
         let experimentAssignments = [];
         try {
-            if (ownerEmail) {
+            // A pinned request model suppresses the experiment's model override, so
+            // resolving would assign (and persist) a variant this turn never ran.
+            if (ownerEmail && !requestModelIsExplicit) {
                 const { resolveActiveExperimentConfig } = await import("../observability/experiments.js");
                 const expConfig = await resolveActiveExperimentConfig(ownerEmail);
                 if (expConfig) {

package/dist/agent/run-store.js

@@ -5,6 +5,7 @@ import { ensureColumnExists, ensureTableExists } from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 import { lockAndAssertServicePrincipalMayStartRun, prepareServicePrincipalRunStart, recordServicePrincipalDenial, } from "../org/service-principal-guard.js";
 import { captureError } from "../server/capture-error.js";
+import { stripInlineBytes, stripInlineBytesFromJson, } from "../shared/inline-bytes.js";
 import { isRequestedStopAbortReason } from "./abort-reasons.js";
 import { admitAutoContinue, admitManualContinue, } from "./auto-continue.js";
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./engine/credential-errors.js";
@@ -1335,7 +1336,7 @@ function staleRecoveryDispatchPayload(payload) {
             return payload;
         }
         return JSON.stringify({
-            ...parsed,
+            ...stripInlineBytes(parsed, "placeholder"),
             internalContinuation: true,
         });
     }
@@ -1823,7 +1824,13 @@ export async function insertRunEvent(runId, seq, eventData) {
         WHERE id = ? AND status <> 'running'
       )
       ON CONFLICT (run_id, seq) DO NOTHING`,
-        args: [runId, seq, Date.now(), eventData, runId],
+        args: [
+            runId,
+            seq,
+            Date.now(),
+            stripInlineBytesFromJson(eventData, "placeholder"),
+            runId,
+        ],
     });
 }
 export const CHECKPOINT_TERMINAL_EVENT_SEQ = 1_000_000_000;
@@ -2479,6 +2486,11 @@ async function appendTerminalRunEvent(runId, event) {
     const nextSeq = last ? Number(last.seq ?? -1) + 1 : 0;
     await client.execute({
         sql: `INSERT INTO agent_run_events (run_id, seq, event_at, event_data) VALUES (?, ?, ?, ?) ON CONFLICT (run_id, seq) DO NOTHING`,
-        args: [runId, nextSeq, Date.now(), JSON.stringify(event)],
+        args: [
+            runId,
+            nextSeq,
+            Date.now(),
+            stripInlineBytesFromJson(JSON.stringify(event), "placeholder"),
+        ],
     });
 }

package/dist/agent/thread-data-builder.js

@@ -4,10 +4,9 @@ import { isCredentialGapCodeAgentEvent, normalizeCodeAgentTranscript, } from "..
 import { stripAgentChatContextFromMessage } from "../shared/agent-chat-context.js";
 import { RUN_NOT_STARTED_METADATA_KEY, } from "../shared/agent-chat-run-not-started.js";
 import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE } from "./engine/error-detail.js";
-import { stringifyToolUseInputForGateway } from "./engine/translate-anthropic.js";
+import { INTERRUPTED_TOOL_RESULT_MARKER as INTERRUPTED_TOOL_RESULT, stringifyToolUseInputForGateway, } from "./engine/translate-anthropic.js";
 import { parseFollowUpSuggestions } from "./follow-up-suggestions.js";
 import { isContinuationTerminalReason } from "./types.js";
-const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
 const INTERRUPTED_ACTIVITY_RESULT = "Stopped before this action started.";
 export const ASSISTANT_RUN_DURATION_METADATA_KEY = "agentNativeRunDurationMs";
 const MAX_STORED_ATTACHMENT_CHARS = 60_000;

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/chat-threads/store.js

@@ -7,6 +7,7 @@ import { createGetDb } from "../db/create-get-db.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 import { getRequestOrgId } from "../server/request-context.js";
+import { stripInlineBytes } from "../shared/inline-bytes.js";
 import { resolveAccess } from "../sharing/access.js";
 import { registerShareableResource } from "../sharing/registry.js";
 import { roleSatisfies } from "../sharing/schema.js";
@@ -808,7 +809,7 @@ export async function forkThread(sourceId, ownerEmail, opts) {
         return null;
     }
     const id = opts?.id ?? generateId();
-    const threadData = forkThreadData(source.threadData, id, snapshot?.fromMessageId);
+    const threadData = JSON.stringify(stripInlineBytes(JSON.parse(forkThreadData(source.threadData, id, snapshot?.fromMessageId)), "placeholder"));
     const now = Date.now();
     const title = source.title ? `${source.title} (fork)` : "";
     const client = getDbExec();
@@ -1096,7 +1097,10 @@ export async function updateThreadData(id, threadData, title, preview, messageCo
                 preserveExistingTopLevelKeys: options.preserveExistingTopLevelKeys ?? true,
                 onAnnotationConflict: (conflict) => annotationConflicts.push(conflict),
             });
-            nextThreadData = JSON.stringify(merged);
+            // Client snapshots can predate their upload URL, so inline bytes become a
+            // visible placeholder rather than failing the save; legacy rows are
+            // scrubbed on their next write.
+            nextThreadData = JSON.stringify(stripInlineBytes(merged, "placeholder"));
             nextMessageCount = countThreadMessages(merged, messageCount);
             const nextUpdatedAt = Math.max(Date.now(), current.updatedAt + 1);
             // Completion persistence can race the separate generated-title save.

package/dist/client/chat/agentkit-agent-native.js

@@ -1,5 +1,5 @@
 import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
-import { isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, } from "@agent-native/agentkit/protocol";
+import { isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
 import { projectRootAssistantMessages } from "../../agent/thread-message-projection.js";
 import { RUN_NOT_STARTED_METADATA_KEY, retryContextFromRequest, } from "../../shared/agent-chat-run-not-started.js";
 import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch, } from "../agent-engine-readiness.js";
@@ -167,6 +167,9 @@ function messagePart(value, fallbackTextFormat) {
                 : typeof part.mimeType === "string"
                     ? { mediaType: part.mimeType }
                     : {}),
+            ...(part.omitted === "inline-bytes"
+                ? { omitted: "inline-bytes" }
+                : {}),
         };
     }
     return {
@@ -1046,9 +1049,6 @@ function assistantMessageIdsByRun(events) {
     }
     return uniqueMessageIdsByRun;
 }
-function persistedFileUrl(url) {
-    return url && !/^\s*data:/i.test(url) ? url : undefined;
-}
 function persistedHistoryEvents(events = []) {
     const sequenceByRun = new Map();
     return events.flatMap((event) => {
@@ -1154,16 +1154,17 @@ function persistedMessages(messages) {
                 ];
             }
             if (part.type === "file") {
-                const url = persistedFileUrl(part.url);
-                if (!url && !part.fileId)
+                const stored = persistableFilePart(part);
+                if (!stored.url && !stored.fileId && !stored.omitted)
                     return [];
                 return [
                     {
                         type: "file",
-                        name: part.name,
-                        ...(part.mediaType ? { mediaType: part.mediaType } : {}),
-                        ...(url ? { url } : {}),
-                        ...(part.fileId ? { fileId: part.fileId } : {}),
+                        name: stored.name,
+                        ...(stored.mediaType ? { mediaType: stored.mediaType } : {}),
+                        ...(stored.url ? { url: stored.url } : {}),
+                        ...(stored.fileId ? { fileId: stored.fileId } : {}),
+                        ...(stored.omitted ? { omitted: stored.omitted } : {}),
                     },
                 ];
             }

package/dist/client/chat/agentkit-protocol.js

@@ -1,4 +1,4 @@
-import { AGENT_TOOL_CALL_HISTORY_MEDIA_TYPE, AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE, AGENTKIT_PROTOCOL_VERSION, AgentProtocolValidationError, approvalResponseFromResume, createCapabilityUnavailableError, createCapabilityUnsupportedError, inferAgentActivityKind, negotiateAgentKitProtocolVersion, resumeEntryFromApproval, resumeOptionId, } from "@agent-native/agentkit/protocol";
+import { AGENT_TOOL_CALL_HISTORY_MEDIA_TYPE, AGENT_TOOL_RESULT_HISTORY_MEDIA_TYPE, AGENTKIT_PROTOCOL_VERSION, AgentProtocolValidationError, approvalResponseFromResume, createCapabilityUnavailableError, createCapabilityUnsupportedError, inferAgentActivityKind, isInlineDataUrl, negotiateAgentKitProtocolVersion, resumeEntryFromApproval, resumeOptionId, } from "@agent-native/agentkit/protocol";
 import { AUTO_CONTINUE_OF_RUN_METADATA_KEY, AUTO_CONTINUE_PROMPT, AUTO_CONTINUE_REFUSAL_CODES, CONTINUE_OF_RUN_METADATA_KEY, CONTINUE_UNAVAILABLE_CODE, } from "../../agent/auto-continue.js";
 import { parseBase64DataUrl } from "../../shared/data-url.js";
 import { emitChatFirstOpenApp, emitChatFirstOpenBrowser, } from "../chat-first-state.js";
@@ -3255,10 +3255,14 @@ export function createAgentKitProtocolAdapter(runtime, options = {}) {
             if (state.status === "missing" || !state.turnId) {
                 throw Object.assign(new Error(`Agent run ${input.runId} cannot be continued.`), { code: CONTINUE_UNAVAILABLE_CODE, retryable: false });
             }
+            const attachments = (input.attachments ?? [])
+                .filter((part) => !isInlineDataUrl(part.url))
+                .map(runtimeAttachmentFromFilePart);
             const turn = await session.continueTurn({
                 turnId: state.turnId,
                 prompt: AUTO_CONTINUE_PROMPT,
                 metadata: { [CONTINUE_OF_RUN_METADATA_KEY]: state.runId },
+                ...(attachments.length ? { attachments } : {}),
                 abortSignal: readers.signal,
             });
             const runId = await openStartedRun(input.threadId, session, turn, undefined, { continuedRunId: input.runId });

package/dist/client/chat/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { AgentSuggestion } from "@agent-native/agentkit/protocol";
+import { type AgentSuggestion } from "@agent-native/agentkit/protocol";
 import type { ActionChatUIConfig } from "../../action-ui.js";
 import type { AgentMcpAppPayload } from "../../mcp-client/app-result.js";
 import type { ReasoningEffort } from "../../shared/reasoning-effort.js";
@@ -240,6 +240,8 @@ export interface AgentChatRuntimeContinueInput {
     readonly prompt?: string;
     readonly approval?: AgentChatRuntimeApprovalResponse;
     readonly connection?: AgentChatRuntimeConnectionResponse;
+    /** Durable references to the continued turn's attachments; never bytes. */
+    readonly attachments?: readonly AgentChatRuntimeAttachment[];
     readonly metadata?: AgentChatRuntimeMetadata;
     readonly abortSignal?: AbortSignal;
 }