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

package/dist/action.d.ts

@@ -38,6 +38,8 @@ export interface ActionRunContext {
     actionName?: string;
     /** Present only on frontend GETs authorized by a scoped directory-widget read capability. */
     mcpDirectoryWidgetReadOnly?: true;
+    /** Present only on frontend calls authorized by a scoped directory-widget capability: the resource IDs it is bound to. */
+    mcpDirectoryWidgetResourceIds?: Record<string, string>;
     /** Present only on frontend mutations authorized by a scoped directory-widget write capability. */
     mcpDirectoryWidgetWrite?: {
         appId: string;

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/tool-call-journal-seed.d.ts

@@ -36,7 +36,7 @@ export type PriorTurnToolCallJournalRead = {
 export declare function loadPriorTurnToolCallJournal(threadId: string | undefined, turnId?: string): Promise<PriorTurnToolCallJournalRead>;
 export declare const JOURNALED_TOOL_REPLAY_PREFIX = "(Already completed in an earlier interrupted attempt - not re-run to avoid a duplicate side effect.)\n\n";
 export declare const RECOVERED_TOOL_REPLAY_PREFIX = "(Recovered from prior interrupted chunk \u2014 action already completed.)\n\n";
-export declare function loadedSkillPagesContext(results: readonly PriorTurnToolResultSummary[], allowedSlugs: ReadonlySet<string>): string;
+export declare function loadedSkillPagesContext(results: readonly PriorTurnToolResultSummary[], threadPages: ReadonlyMap<string, string>, currentSkillBodies: ReadonlyMap<string, string>, isInHistory?: (slug: string, page: string) => boolean): string;
 export declare function seedRepeatedToolCallCountsFromJournal(calls: readonly PriorTurnToolCallSequenceEntry[], keyForCall: (name: string, input: unknown) => string, isResurfacedReadOnlyDuplicate: (name: string, result: string) => boolean): Map<string, number>;
 export declare function seedRepeatedToolErrorCountsFromJournal(calls: readonly PriorTurnToolCallSequenceEntry[], keyForCall: (name: string, input: unknown) => string, normalizeError: (error: string) => string): {
     sameArguments: Map<string, number>;

package/dist/agent/engine/tool-call-journal-seed.js

@@ -91,8 +91,9 @@ export async function loadPriorTurnToolCallJournal(threadId, turnId) {
 }
 export const JOURNALED_TOOL_REPLAY_PREFIX = "(Already completed in an earlier interrupted attempt - not re-run to avoid a duplicate side effect.)\n\n";
 export const RECOVERED_TOOL_REPLAY_PREFIX = "(Recovered from prior interrupted chunk — action already completed.)\n\n";
-const LOADED_SKILL_CONTEXT_MAX_CHARS = 24_000;
-export function loadedSkillPagesContext(results, allowedSlugs) {
+const LOADED_SKILL_CONTEXT_MAX_CHARS = 40_000;
+const OMITTED_NOTICE_RESERVE_CHARS = 1_000;
+export function loadedSkillPagesContext(results, threadPages, currentSkillBodies, isInHistory = () => false) {
     const pages = new Map();
     for (const result of results) {
         if (result.name !== "docs-search" || result.isError)
@@ -101,37 +102,72 @@ export function loadedSkillPagesContext(results, allowedSlugs) {
             ? result.input
             : null;
         const slug = input?.slug;
+        const currentBody = typeof slug === "string" ? currentSkillBodies.get(slug) : undefined;
+        // A journaled read may predate a skill edit or have been truncated; only
+        // reuse it if it still holds the skill's current body.
         if (typeof slug !== "string" ||
             !slug.startsWith("skill-") ||
-            !allowedSlugs.has(slug) ||
+            currentBody === undefined ||
             !result.content.startsWith("# Skill:") ||
-            result.content.includes("Doc not found:")) {
+            result.content.includes("Doc not found:") ||
+            !result.content.includes(currentBody.trim())) {
             continue;
         }
         pages.delete(slug);
         pages.set(slug, result.content);
     }
+    const merged = new Map(threadPages);
+    for (const [slug, page] of pages) {
+        merged.delete(slug);
+        merged.set(slug, page);
+    }
+    for (const [slug, page] of merged) {
+        if (isInHistory(slug, page))
+            merged.delete(slug);
+    }
+    return renderLoadedSkillPages(merged);
+}
+// Newest reads win the budget: they are likeliest to apply to the current task.
+function renderLoadedSkillPages(pages) {
     if (pages.size === 0)
         return "";
-    const opening = "<already-loaded-skills>These skill pages were already read earlier in this turn. Reuse them instead of calling docs-search again. If a page is marked truncated, read only when missing detail matters.\n";
+    const opening = "<already-loaded-skills>These skill pages were already read earlier in this conversation. Reuse them instead of calling docs-search again. If a page is marked truncated or listed as omitted, read it with docs-search when missing detail matters.\n";
     const closing = "\n</already-loaded-skills>";
-    let remaining = LOADED_SKILL_CONTEXT_MAX_CHARS - opening.length - closing.length;
+    let remaining = LOADED_SKILL_CONTEXT_MAX_CHARS -
+        opening.length -
+        closing.length -
+        OMITTED_NOTICE_RESERVE_CHARS;
     const blocks = [];
-    for (const [slug, page] of pages) {
+    const entries = [...pages].reverse();
+    let omitted = [];
+    for (const [index, [slug, page]] of entries.entries()) {
         const heading = `\n## ${slug}\n`;
-        if (remaining <= heading.length)
+        if (remaining <= heading.length) {
+            omitted = entries.slice(index).map(([omittedSlug]) => omittedSlug);
             break;
+        }
         const truncated = page.length > remaining - heading.length;
         const marker = truncated
-            ? "\n[Skill page truncated to fit continuation context.]"
+            ? "\n[Skill page truncated to fit loaded-skill context.]"
             : "";
         const body = page.slice(0, Math.max(0, remaining - heading.length - marker.length));
         blocks.push(`${heading}${body}${marker}`);
         remaining -= heading.length + body.length + marker.length;
-        if (truncated)
+        if (truncated) {
+            omitted = entries.slice(index + 1).map(([omittedSlug]) => omittedSlug);
             break;
+        }
+    }
+    if (blocks.length === 0)
+        return "";
+    if (omitted.length > 0) {
+        const prefix = "\n[Omitted to fit loaded-skill context; read with docs-search if needed: ";
+        const names = omitted
+            .join(", ")
+            .slice(0, OMITTED_NOTICE_RESERVE_CHARS - prefix.length - 4);
+        blocks.push(`${prefix}${names}]`);
     }
-    return blocks.length > 0 ? `${opening}${blocks.join("\n")}${closing}` : "";
+    return `${opening}${blocks.join("\n")}${closing}`;
 }
 export function seedRepeatedToolCallCountsFromJournal(calls, keyForCall, isResurfacedReadOnlyDuplicate) {
     const counts = new Map();

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";
@@ -355,12 +356,10 @@ export declare function resolveAgentOwnerEmail(options: Pick<ProductionAgentOpti
 export declare function runCompletionCallbackWithDatabaseRetry(callback: () => void | Promise<void>, options?: {
     sleep?: (ms: number) => Promise<void>;
 }): Promise<void>;
+export declare function normalizeLoadedSkillSlugs(value: unknown): string[];
 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
@@ -650,6 +649,7 @@ export declare function runAgentLoop(opts: {
     finalResponseGuardRequestText?: string;
     threadId?: string;
     turnId?: string;
+    loadedSkillSlugs?: readonly string[];
     runSoftTimeoutMs?: number;
     toolLimits?: {
         timeoutMs?: number;
@@ -778,6 +778,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;