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

package/dist/client/chat/runtime.js

@@ -1,4 +1,5 @@
 import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
+import { isInlineDataUrl, } from "@agent-native/agentkit/protocol";
 import { AUTO_CONTINUE_OF_RUN_METADATA_KEY, CONTINUE_OF_RUN_METADATA_KEY, } from "../../agent/auto-continue.js";
 import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch, } from "../agent-engine-readiness.js";
 import { getOrCreateAnalyticsSessionId } from "../analytics-session.js";
@@ -667,12 +668,39 @@ export function createHttpAgentChatRuntime(options) {
     };
     return runtime;
 }
+/**
+ * What an earlier user turn's file or image becomes in replayed history: its
+ * name, type, and durable URL, so a later turn can still refer to it. Inline
+ * bytes are never replayed.
+ */
+function historyAttachmentStub(message, part) {
+    if (message.role !== "user")
+        return undefined;
+    if (part.type !== "file" && part.type !== "image")
+        return undefined;
+    const name = part.type === "file" ? part.filename : part.alt;
+    const url = typeof part.url === "string" && !isInlineDataUrl(part.url)
+        ? part.url
+        : undefined;
+    return `[attached: ${[name || part.type, part.mediaType, url].filter(Boolean).join(" ")}]`;
+}
+/** Reasoning is the model's own scratch work and is never replayed as history. */
 function runtimeMessageText(message) {
     return message.content
-        .map((part) => part.type === "text" || part.type === "reasoning" ? part.text : "")
+        .map((part) => part.type === "text"
+        ? part.text
+        : (historyAttachmentStub(message, part) ?? ""))
         .filter(Boolean)
         .join("\n");
 }
+function isUserAsk(message) {
+    return (message.role === "user" &&
+        message.content.some((part) => (part.type === "text" && part.text.trim()) ||
+            historyAttachmentStub(message, part) !== undefined));
+}
+function hasHistoryAttachment(message) {
+    return message.content.some((part) => historyAttachmentStub(message, part) !== undefined);
+}
 function isSyntheticToolHistoryOmissionMessage(message) {
     return (message.role === "assistant" &&
         (message.id === AGENTKIT_TOOL_HISTORY_OMISSION_MESSAGE_ID_PREFIX ||
@@ -719,6 +747,9 @@ const MAX_STRUCTURED_HISTORY_TEXT_SOURCE_PARTS = MAX_TOOL_HISTORY_CALLS * 2;
 const MAX_STRUCTURED_HISTORY_SOURCE_PARTS = MAX_STRUCTURED_HISTORY_TOOL_SOURCE_PARTS +
     MAX_STRUCTURED_HISTORY_TEXT_SOURCE_PARTS;
 const MAX_STRUCTURED_HISTORY_SOURCE_MESSAGES = 1024;
+const MAX_PINNED_ATTACHMENT_PROMPTS = 32;
+/** Above every other candidate, so the byte budget drops pinned asks last. */
+const PINNED_USER_PROMPT_TEXT_PRIORITY = 4;
 const MAX_STRUCTURED_HISTORY_SOURCE_SCAN_STEPS = MAX_STRUCTURED_HISTORY_SOURCE_PARTS * 4;
 const TOOL_INPUT_OMISSION_TEXT = "Tool input omitted from history because it could not be serialized.";
 const TOOL_INPUT_SIZE_OMISSION_TEXT = "Tool input omitted from history because it exceeds 64 KiB.";
@@ -1177,7 +1208,7 @@ function runtimeMessageTextMatches(message, expected) {
             return { matches: true, complete: false };
         }
         scannedParts++;
-        if (part.type !== "text" && part.type !== "reasoning")
+        if (part.type !== "text")
             continue;
         if (!part.text)
             continue;
@@ -1229,16 +1260,19 @@ function boundedStructuredHistorySources(messages, currentPrompt, supplementalMe
         }
     }
     let firstUserPromptMessageIndex;
+    const attachmentPromptMessageIndices = [];
     const historyWindowStart = Math.max(0, historyMessages.length - MAX_STRUCTURED_HISTORY_SOURCE_MESSAGES);
     for (let index = historyWindowStart; index < historyMessages.length; index++) {
         if (index === currentPromptMessageIndex)
             continue;
         const message = historyMessages[index];
-        if (message.role === "user" &&
-            message.content.some((part) => (part.type === "text" || part.type === "reasoning") &&
-                part.text.trim())) {
+        if (message.role !== "user")
+            continue;
+        if (firstUserPromptMessageIndex === undefined && isUserAsk(message)) {
             firstUserPromptMessageIndex = index;
-            break;
+        }
+        if (hasHistoryAttachment(message)) {
+            attachmentPromptMessageIndices.push(index);
         }
     }
     let previousUserPromptMessageIndex;
@@ -1246,25 +1280,43 @@ function boundedStructuredHistorySources(messages, currentPrompt, supplementalMe
         for (let index = historyMessages.length - 1; index >= 0; index--) {
             if (index === currentPromptMessageIndex)
                 continue;
-            const message = historyMessages[index];
-            if (message.role === "user" &&
-                message.content.some((part) => (part.type === "text" || part.type === "reasoning") &&
-                    part.text.trim())) {
+            if (isUserAsk(historyMessages[index])) {
                 previousUserPromptMessageIndex = index;
                 break;
             }
         }
     }
-    const protectedUserPromptMessageIndices = new Set([firstUserPromptMessageIndex, previousUserPromptMessageIndex].filter((index) => index !== undefined));
+    // The first ask ("LinkedIn ad 1200x627 PNG") and every turn that attached a
+    // file stay in the window however long the agentic tail after them grows.
+    // ponytail: only the newest 32 attachment turns are pinned; older ones fall
+    // back to the newest-first window.
+    const pinnedUserPromptMessageIndices = new Set([
+        firstUserPromptMessageIndex,
+        previousUserPromptMessageIndex,
+        ...attachmentPromptMessageIndices.slice(-MAX_PINNED_ATTACHMENT_PROMPTS),
+    ].filter((index) => index !== undefined));
     const regularTextPartLimit = MAX_STRUCTURED_HISTORY_TEXT_SOURCE_PARTS -
-        protectedUserPromptMessageIndices.size;
+        pinnedUserPromptMessageIndices.size;
     const selectedReversed = [];
+    const pinnedPromptsAdded = new Set();
     let selectedToolPartCount = 0;
     let selectedTextPartCount = 0;
     let scannedPartCount = 0;
     let visitedMessageCount = 0;
     let toolBoundary;
     let stop = false;
+    const addPinnedPromptText = (parts, messageIndex) => {
+        pinnedPromptsAdded.add(messageIndex);
+        const text = runtimeMessageText(historyMessages[messageIndex]);
+        if (!text.trim())
+            return;
+        if (selectedTextPartCount >= MAX_STRUCTURED_HISTORY_TEXT_SOURCE_PARTS) {
+            omitted = true;
+            return;
+        }
+        selectedTextPartCount++;
+        parts.push({ type: "text", text });
+    };
     const visitMessage = (message, list, messageIndex) => {
         if (visitedMessageCount >= MAX_STRUCTURED_HISTORY_SOURCE_MESSAGES) {
             omitted = true;
@@ -1280,12 +1332,12 @@ function boundedStructuredHistorySources(messages, currentPrompt, supplementalMe
         visitedMessageCount++;
         if (message.role !== "user" && message.role !== "assistant")
             return;
-        const isFirstUserPrompt = list === "messages" && messageIndex === firstUserPromptMessageIndex;
-        const isPreviousUserPrompt = list === "messages" && messageIndex === previousUserPromptMessageIndex;
-        const isProtectedUserPrompt = isFirstUserPrompt || isPreviousUserPrompt;
+        const isPinnedUserPrompt = list === "messages" && pinnedUserPromptMessageIndices.has(messageIndex);
         const partsReversed = [];
-        let protectedPromptTextAdded = false;
         for (let partIndex = message.content.length - 1; partIndex >= 0; partIndex--) {
+            const part = message.content[partIndex];
+            if (part.type === "reasoning")
+                continue;
             if (scannedPartCount >= MAX_STRUCTURED_HISTORY_SOURCE_SCAN_STEPS) {
                 omitted = true;
                 toolHistoryOmitted = true;
@@ -1294,30 +1346,15 @@ function boundedStructuredHistorySources(messages, currentPrompt, supplementalMe
                 break;
             }
             scannedPartCount++;
-            const part = message.content[partIndex];
+            const attachmentStub = historyAttachmentStub(message, part);
             const isToolPart = (part.type === "tool-call" && message.role === "assistant") ||
                 part.type === "tool-result";
-            const isTextPart = part.type === "text" || part.type === "reasoning";
+            const isTextPart = part.type === "text" || attachmentStub !== undefined;
             if (!isToolPart && !isTextPart)
                 continue;
-            if (isProtectedUserPrompt && isTextPart) {
-                if (!protectedPromptTextAdded) {
-                    const text = message.content
-                        .filter((candidate) => candidate.type === "text" || candidate.type === "reasoning")
-                        .map((candidate) => candidate.type === "text" || candidate.type === "reasoning"
-                        ? candidate.text
-                        : "")
-                        .join("\n");
-                    if (text.trim()) {
-                        if (selectedTextPartCount >= MAX_STRUCTURED_HISTORY_TEXT_SOURCE_PARTS) {
-                            omitted = true;
-                        }
-                        else {
-                            selectedTextPartCount++;
-                            partsReversed.push({ type: "text", text });
-                        }
-                    }
-                    protectedPromptTextAdded = true;
+            if (isPinnedUserPrompt && isTextPart) {
+                if (!pinnedPromptsAdded.has(messageIndex)) {
+                    addPinnedPromptText(partsReversed, messageIndex);
                 }
                 continue;
             }
@@ -1345,15 +1382,17 @@ function boundedStructuredHistorySources(messages, currentPrompt, supplementalMe
                 }
                 selectedTextPartCount++;
             }
-            partsReversed.push(part);
+            partsReversed.push(attachmentStub === undefined
+                ? part
+                : { type: "text", text: attachmentStub });
         }
         if (partsReversed.length) {
             selectedReversed.push({
                 message,
                 parts: partsReversed.reverse(),
                 priority: list === "supplemental",
-                textPriority: isPreviousUserPrompt
-                    ? 2
+                textPriority: isPinnedUserPrompt
+                    ? PINNED_USER_PROMPT_TEXT_PRIORITY
                     : list === "supplemental"
                         ? 1
                         : 0,
@@ -1370,6 +1409,22 @@ function boundedStructuredHistorySources(messages, currentPrompt, supplementalMe
             continue;
         visitMessage(historyMessages[index], "messages", index);
     }
+    // The newest-first scan stops long before the first turns of a long agentic
+    // thread; the pinned asks it never reached are replayed anyway.
+    for (const index of [...pinnedUserPromptMessageIndices].sort((left, right) => right - left)) {
+        if (pinnedPromptsAdded.has(index))
+            continue;
+        const parts = [];
+        addPinnedPromptText(parts, index);
+        if (parts.length) {
+            selectedReversed.push({
+                message: historyMessages[index],
+                parts,
+                priority: false,
+                textPriority: PINNED_USER_PROMPT_TEXT_PRIORITY,
+            });
+        }
+    }
     return {
         messages: selectedReversed.reverse(),
         omitted,
@@ -1520,7 +1575,7 @@ function nativeStructuredHistoryFromMessages(messages, currentPrompt, supplement
             results = [];
         };
         for (const part of parts) {
-            if (part.type === "text" || part.type === "reasoning") {
+            if (part.type === "text") {
                 if (jsonStringByteLengthWithinLimit(part.text, MAX_ADDED_TOOL_HISTORY_BYTES) === undefined ||
                     part.text.trim()) {
                     flushResults();
@@ -2700,6 +2755,9 @@ export function createAgentNativeChatRuntime(options = {}) {
             // Only the continuation that names a stopped run continues it; an approval
             // or connection answered later is not another continuation of that run.
             const { [AUTO_CONTINUE_OF_RUN_METADATA_KEY]: _autoContinueOf, [CONTINUE_OF_RUN_METADATA_KEY]: _continueOf, ...previousMetadata } = previousTurn?.metadata ?? {};
+            const turnToContinue = continuation.attachments?.length
+                ? { ...previousTurn, attachments: continuation.attachments }
+                : previousTurn;
             const approval = continuation.approval;
             const connection = continuation.connection;
             const messageStateKey = continuation.turnId ?? session.id;
@@ -2716,7 +2774,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                 if (messageState)
                     messageState.message.connectionPending = false;
                 return startTurn({
-                    ...previousTurn,
+                    ...turnToContinue,
                     prompt: continuation.prompt ??
                         `The ${connection.id} connection is now available. Continue the requested work.`,
                     metadata: {
@@ -2736,7 +2794,7 @@ export function createAgentNativeChatRuntime(options = {}) {
                 if (messageState)
                     messageState.message.approvalPending = false;
                 return startTurn({
-                    ...previousTurn,
+                    ...turnToContinue,
                     prompt: continuation.prompt,
                     metadata: {
                         ...previousMetadata,
@@ -2759,7 +2817,7 @@ export function createAgentNativeChatRuntime(options = {}) {
             if (messageState)
                 messageState.message.approvalPending = false;
             return startTurn({
-                ...previousTurn,
+                ...turnToContinue,
                 prompt: continuation.prompt ??
                     "Approved. Go ahead and run the requested action.",
                 metadata: {

package/dist/client/use-action.d.ts

@@ -110,5 +110,6 @@ export declare function useActionMutation<TData = undefined, TVariables = undefi
     method?: "POST" | "PUT" | "DELETE";
     skipActionQueryInvalidation?: boolean;
     timeoutMs?: number;
+    headers?: Record<string, string> | ((variables: TVariables extends undefined ? ActionParams<TName> : TVariables) => Record<string, string> | undefined);
 }): import("@tanstack/react-query").UseMutationResult<TData extends undefined ? ActionResult<TName> : TData, Error, TVariables extends undefined ? ActionParams<TName> : TVariables, unknown>;
 export {};

package/dist/client/use-action.js

@@ -782,12 +782,13 @@ export function useActionQuery(actionName, params, options) {
 }
 export function useActionMutation(actionName, options) {
     const queryClient = useQueryClient();
-    const { method: methodOpt, onSuccess, skipActionQueryInvalidation = false, timeoutMs, ...restOptions } = options ?? {};
+    const { method: methodOpt, onSuccess, skipActionQueryInvalidation = false, timeoutMs, headers, ...restOptions } = options ?? {};
     const method = methodOpt ?? "POST";
     return useMutation({
         ...restOptions,
         mutationFn: (params) => actionFetch(actionName, method, params, {
             timeoutMs,
+            headers: typeof headers === "function" ? headers(params) : headers,
         }),
         onSuccess: (...args) => {
             // A write that succeeded may have fixed whatever was failing reads.

package/dist/collab/routes.d.ts

@@ -13,8 +13,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.js

@@ -1910,7 +1910,7 @@ async function getHandler() {
         headers: {
           "Access-Control-Allow-Origin": "*",
           "Access-Control-Allow-Methods": "GET,HEAD,POST,PUT,PATCH,DELETE,OPTIONS",
-          "Access-Control-Allow-Headers": "Content-Type,Authorization,X-Requested-With,X-Request-Source,X-Agent-Native-CSRF,X-User-Timezone,X-Agent-Native-Session-Id,X-Agent-Native-Client-Platform,X-Agent-Native-Desktop-Verifier,X-Agent-Native-Test-Traffic,X-Agent-Native-Tool-Bridge,X-Agent-Native-Tool-Id,X-Agent-Native-Frontend,X-Agent-Native-Client-Compatibility,X-Agent-Native-Build-Id,X-Agent-Native-Embed-Target",
+          "Access-Control-Allow-Headers": "Content-Type,Authorization,X-Requested-With,X-Request-Source,X-Content-Save-Origin,X-Agent-Native-CSRF,X-User-Timezone,X-Agent-Native-Session-Id,X-Agent-Native-Client-Platform,X-Agent-Native-Desktop-Verifier,X-Agent-Native-Test-Traffic,X-Agent-Native-Tool-Bridge,X-Agent-Native-Tool-Id,X-Agent-Native-Frontend,X-Agent-Native-Client-Compatibility,X-Agent-Native-Build-Id,X-Agent-Native-Embed-Target",
         },
       });
     }

package/dist/deploy/workspace-deploy.js

@@ -1,5 +1,6 @@
-import { execFileSync } from "child_process";
+import { spawn } from "child_process";
 import fs from "fs";
+import os from "os";
 import path from "path";
 import { AGENT_BACKGROUND_PROCESSOR_A2A, AGENT_BACKGROUND_PROCESSOR_AGENT_TEAM, AGENT_BACKGROUND_PROCESSOR_FIELD, AGENT_BACKGROUND_PROCESSOR_INTEGRATION, AGENT_BACKGROUND_PROCESSOR_ROUTE, AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, AGENT_TEAM_PROCESS_RUN_PATH, isDurableBackgroundFlagExplicitlyDisabled, } from "../agent/durable-background.js";
 import { getAppConfig } from "../app-config/index.js";
@@ -210,10 +211,12 @@ export async function runWorkspaceDeploy(opts = {}) {
         fs.mkdirSync(functionsDir, { recursive: true });
     }
     console.log(`[workspace-deploy] Building ${apps.length} app(s) for preset=${preset}`);
-    const execFile = opts.execFile ?? execFileSync;
+    const concurrency = workspaceBuildConcurrency();
+    const runBuild = opts.execFile ?? spawnBuild;
+    await runWithConcurrency(apps, concurrency, (app) => buildOneApp(workspaceRoot, appsDir, app, preset, runBuild, workspaceApps, workspaceAuthMode, concurrency > 1 ? "pipe" : "inherit"));
+    // Copy in app order after all builds so shared outputs stay deterministic.
     const sweepCrons = [];
     for (const app of apps) {
-        buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApps, workspaceAuthMode);
         moveAppBuildIntoWorkspaceOutput(workspaceRoot, appsDir, app, preset, distDir, vercelOutputDir, workspaceApps, workspaceAuthMode);
         if (preset === "vercel") {
             sweepCrons.push(readVercelSweepCron(path.join(appsDir, app, VERCEL_OUTPUT_DIR), `/${app}`));
@@ -245,7 +248,7 @@ export async function runWorkspaceDeploy(opts = {}) {
     }
     console.log(`All apps live at https://<origin>/<app-name>/*. Log in once on any app\nand the session is shared across the workspace.`);
 }
-function buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApps, workspaceAuthMode) {
+async function buildOneApp(workspaceRoot, appsDir, app, preset, runBuild, workspaceApps, workspaceAuthMode, stdio) {
     const appDir = path.join(appsDir, app);
     const workspaceAppAudience = workspaceAppAudienceForApp(workspaceApps, app);
     const workspaceAppRouteAccess = workspaceAppRouteAccessForApp(workspaceApps, app);
@@ -306,10 +309,66 @@ function buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApp
     }
     console.log(`[workspace-deploy] Building ${app} (base=/${app}, preset=${preset})`);
     cleanAppBuildOutputs(appDir);
-    execFile("pnpm", ["--filter", app, "build"], {
+    const startedAt = Date.now();
+    await runBuild("pnpm", ["--filter", app, "build"], {
         cwd: workspaceRoot,
         env,
-        stdio: "inherit",
+        stdio,
+    });
+    console.log(`[workspace-deploy] Built ${app} in ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);
+}
+function workspaceBuildConcurrency() {
+    const raw = process.env.AGENT_NATIVE_DEPLOY_CONCURRENCY?.trim();
+    if (raw) {
+        const parsed = Number(raw);
+        if (!Number.isInteger(parsed) || parsed < 1) {
+            throw new Error(`AGENT_NATIVE_DEPLOY_CONCURRENCY must be a positive integer, got "${raw}"`);
+        }
+        return parsed;
+    }
+    // Each app build can use 1-2 GB, so stay well under typical CI memory limits.
+    return Math.min(3, os.availableParallelism());
+}
+async function runWithConcurrency(items, limit, fn) {
+    let next = 0;
+    const errors = [];
+    const worker = async () => {
+        while (errors.length === 0 && next < items.length) {
+            try {
+                await fn(items[next++]);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+    };
+    // Let in-flight builds finish so none are orphaned when the CLI exits and
+    // every failure gets reported, not just the first.
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    if (errors.length === 1)
+        throw errors[0];
+    if (errors.length > 1) {
+        throw new Error(errors
+            .map((error) => error instanceof Error ? error.message : String(error))
+            .join("\n"));
+    }
+}
+function spawnBuild(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, options);
+        // Buffered so parallel builds print as whole blocks instead of interleaving.
+        const chunks = [];
+        child.stdout?.on("data", (chunk) => chunks.push(chunk));
+        child.stderr?.on("data", (chunk) => chunks.push(chunk));
+        child.on("error", reject);
+        child.on("close", (code, signal) => {
+            if (chunks.length)
+                process.stdout.write(Buffer.concat(chunks));
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Command failed: ${cmd} ${args.join(" ")} (${signal ?? `exit code ${code}`})`));
+        });
     });
 }
 function moveAppBuildIntoWorkspaceOutput(workspaceRoot, appsDir, app, preset, distDir, vercelOutputDir, workspaceApps, workspaceAuthMode) {

package/dist/file-upload/actions/upload-image.d.ts

@@ -33,20 +33,20 @@ declare const _default: import("../../action.js").ActionDefinition<{
     idempotencyKey: string;
     deleted: boolean;
 } | {
-    id?: undefined;
     error: string;
     url?: undefined;
+    id?: undefined;
     provider?: undefined;
     configured?: undefined;
 } | {
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
-    id?: undefined;
     url?: undefined;
+    id?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;

package/dist/file-upload/registry.d.ts

@@ -2,7 +2,13 @@ import type { FileUploadDeleteInput, FileUploadInput, FileUploadProvider, FileUp
 export declare function registerFileUploadProvider(provider: FileUploadProvider): void;
 export declare function unregisterFileUploadProvider(id: string): void;
 export declare function listFileUploadProviders(): FileUploadProvider[];
-/** Resolve a public upload URL only through a provider that claims ownership. */
+/**
+ * Resolve a public upload URL only through a provider that claims ownership.
+ * Each provider is checked independently: one provider whose check throws
+ * (S3 reads its config from the DB) must not hide another's positive claim, so
+ * this throws only when no provider claims the URL and at least one could not
+ * answer — "unverifiable", never reported as "not owned".
+ */
 export declare function findFileUploadProviderOwningUrl(url: string): Promise<FileUploadProvider | null>;
 export declare function getActiveFileUploadProvider(): FileUploadProvider | null;
 /**

package/dist/file-upload/registry.js

@@ -11,17 +11,35 @@ export function unregisterFileUploadProvider(id) {
 export function listFileUploadProviders() {
     return [...providers.values()];
 }
-/** Resolve a public upload URL only through a provider that claims ownership. */
+/**
+ * Resolve a public upload URL only through a provider that claims ownership.
+ * Each provider is checked independently: one provider whose check throws
+ * (S3 reads its config from the DB) must not hide another's positive claim, so
+ * this throws only when no provider claims the URL and at least one could not
+ * answer — "unverifiable", never reported as "not owned".
+ */
 export async function findFileUploadProviderOwningUrl(url) {
-    const candidates = [...providers.values()];
-    if (!candidates.includes(builderFileUploadProvider)) {
-        candidates.push(builderFileUploadProvider);
-    }
+    const candidates = [
+        builderFileUploadProvider,
+        ...[...providers.values()].filter((p) => p !== builderFileUploadProvider),
+    ];
+    const failures = [];
+    const unverifiable = [];
     for (const provider of candidates) {
-        if (provider.isOwnedUrl && (await provider.isOwnedUrl(url))) {
-            return provider;
+        if (!provider.isOwnedUrl)
+            continue;
+        try {
+            if (await provider.isOwnedUrl(url))
+                return provider;
+        }
+        catch (error) {
+            failures.push(error);
+            unverifiable.push(provider.id);
         }
     }
+    if (failures.length > 0) {
+        throw new AggregateError(failures, `Upload URL ownership is unverifiable: ${unverifiable.join(", ")} failed its check`);
+    }
     return null;
 }
 export function getActiveFileUploadProvider() {

package/dist/mcp/build-server.js

@@ -894,16 +894,6 @@ async function withServerMintedMcpAppEmbedStart(result, meta, directoryLinkUrl,
                 (ctx?.orgId ?? undefined))) {
         throw new Error("The widget write grant must match the authenticated MCP user and organization.");
     }
-    const scope = restrictDirectoryWidgetCapability
-        ? directoryWidget.capability.mode === "write"
-            ? createMcpDirectoryWidgetWriteCapability(directoryWidget.capability.value)
-            : createMcpDirectoryWidgetReadCapability(directoryWidget.capability.value)
-        : typeof out.chrome === "string"
-            ? out.chrome
-            : null;
-    if (restrictDirectoryWidgetCapability && !scope) {
-        throw new Error("Could not create a valid scoped capability for this MCP directory widget.");
-    }
     const revocationAnchorCandidate = ctx?.mcpCredentialIssuedAtMs;
     const revocationAnchorCreatedAtMs = typeof revocationAnchorCandidate === "number" &&
         Number.isSafeInteger(revocationAnchorCandidate)
@@ -913,18 +903,50 @@ async function withServerMintedMcpAppEmbedStart(result, meta, directoryLinkUrl,
         revocationAnchorCreatedAtMs === undefined) {
         throw new Error("Directory widget sessions require a trusted MCP credential issue time.");
     }
-    const ticket = await createEmbedSessionTicket({
-        ownerEmail,
-        orgId: ctx?.orgId,
-        targetPath,
-        scope,
-        ...(directoryWidget?.capability.mode === "write"
-            ? { ttlSeconds: 5 * 60 }
-            : {}),
-        ...(restrictDirectoryWidgetCapability
-            ? { revocationAnchorCreatedAtMs }
-            : {}),
-    });
+    const mintTicket = async (capability) => {
+        const scope = capability
+            ? capability.mode === "write"
+                ? createMcpDirectoryWidgetWriteCapability(capability.value)
+                : createMcpDirectoryWidgetReadCapability(capability.value)
+            : typeof out.chrome === "string"
+                ? out.chrome
+                : null;
+        if (capability && !scope) {
+            throw new Error("Could not create a valid scoped capability for this MCP directory widget.");
+        }
+        return createEmbedSessionTicket({
+            ownerEmail,
+            orgId: ctx?.orgId,
+            targetPath,
+            scope,
+            ...(capability?.mode === "write" ? { ttlSeconds: 5 * 60 } : {}),
+            ...(capability ? { revocationAnchorCreatedAtMs } : {}),
+        });
+    };
+    const writeCapability = directoryWidget?.capability.mode === "write"
+        ? directoryWidget.capability
+        : undefined;
+    let ticket;
+    try {
+        ticket = await mintTicket(directoryWidget?.capability);
+    }
+    catch (error) {
+        if (!writeCapability)
+            throw error;
+        // The write grant is an upgrade over the read grant. Losing it must not
+        // also lose the widget's session ticket, which the shell cannot start without.
+        console.error("[mcp:directory] Could not mint the widget write grant; issuing a read-only widget session instead.", error);
+        const { appId, resourceUri, resourceIds, readActionArguments } = writeCapability.value;
+        ticket = await mintTicket({
+            mode: "read",
+            value: {
+                appId,
+                resourceUri,
+                resourceIds,
+                actionArguments: readActionArguments,
+            },
+        });
+    }
     const startPath = buildEmbedStartPath(ticket.ticket);
     const embedStartUrl = meta?.origin
         ? new URL(startPath, meta.origin).toString()
@@ -2441,11 +2463,24 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     mcpAppResourceCandidate !== null &&
                     directoryWidget === undefined;
                 const suppressDirectoryWidget = directoryCatalog && !hasVerifiedMcpUserIdentity(effectiveIdentity);
+                // The host mounts a widget for this tool from its descriptor, with or
+                // without a ticket in the result, so a withheld ticket must be visible.
+                if (missingDirectoryWidgetCapability &&
+                    !suppressDirectoryWidget &&
+                    !mcpResultIsError) {
+                    console.warn(`[mcp:directory] ${name} returned no widget session ticket: ${typeof trustedCredentialIssuedAtMs === "number"
+                        ? "the result has no widget target or scoped actions"
+                        : "the credential carries no issue time"}.`);
+                }
                 const rawResultForClient = missingDirectoryWidgetCapability || suppressDirectoryWidget
                     ? withoutMcpAppEmbedTicket(projectedRawResult)
                     : mcpAppResourceCandidate
                         ? await withServerMintedMcpAppEmbedStart(projectedRawResult, requestMeta, directoryLinkUrl, directoryWidget)
                         : projectedRawResult;
+                if (directoryWidget &&
+                    typeof metadataObject(rawResultForClient).embedStartUrl !== "string") {
+                    console.error(`[mcp:directory] ${name} built a widget capability but issued no session ticket.`);
+                }
                 const { value: actionResultForClient, images: resultImages, notes: resultImageNotes, } = extractAgentImagesFromActionResult(rawResultForClient);
                 const textResultForClient = mcpResult
                     ? projectedResultForClient
@@ -2996,12 +3031,15 @@ async function admitIssuedMcpCredential(credential, requestOrigin) {
         stored = lookup;
     }
     const orgId = credential.orgId !== undefined ? credential.orgId : stored?.orgId;
-    const credentialIssuedAtMs = credential.oauthClientId !== undefined
-        ? credential.grantCreatedAtMs
-        : typeof credential.issuedAt === "number" &&
+    // Access tokens signed before grant times existed carry no claim, and the
+    // directory widget refuses to mint a session without an issue time. Their
+    // signed `iat` is the only anchor they have. `iat` moves on every refresh, so
+    // it must stay the fallback and never outrank a signed grant time.
+    const credentialIssuedAtMs = credential.grantCreatedAtMs ??
+        (typeof credential.issuedAt === "number" &&
             Number.isSafeInteger(credential.issuedAt)
             ? credential.issuedAt * 1000
-            : undefined;
+            : undefined);
     const mcpCredentialIssuedAtMs = credentialIssuedAtMs !== undefined &&
         Number.isSafeInteger(credentialIssuedAtMs)
         ? credentialIssuedAtMs