@agent-native/core 0.161.12 → 0.161.16

package/dist/action.js

@@ -349,6 +349,50 @@ const SUBSCHEMA_MAP_KEYS = [
  * `default`, `const`, `enum`, or `examples`, whose objects may legitimately
  * contain a `propertyNames` data key that must be preserved.
  */
+/**
+ * A schema position with no `type` — what Zod emits for `z.unknown()` /
+ * `z.any()` — is rejected by OpenAI with "schema must have a 'type' key",
+ * 400ing the whole request exactly like `oneOf` did. There are 137 such sites
+ * across the templates, so this has to be answered at the boundary rather than
+ * by retyping every action.
+ *
+ * Expressed as a union of concrete JSON types because that shape is already
+ * proven against the live validator: `setFilterDefault.value`, a
+ * `z.union([string, number, boolean, null])` sitting in the same tool schema,
+ * was never flagged while the typeless sibling next to it was. `true` for
+ * `additionalProperties` is a boolean, not a subschema, so it needs no type of
+ * its own; array items get one bounded level rather than recursing forever.
+ */
+const JSON_VALUE_BRANCHES = [
+    { type: "string" },
+    { type: "number" },
+    { type: "boolean" },
+    { type: "null" },
+    { type: "object", additionalProperties: true },
+    {
+        type: "array",
+        items: {
+            anyOf: [
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "null" },
+                { type: "object", additionalProperties: true },
+            ],
+        },
+    },
+];
+/** Keywords that make a `type`-less schema meaningful on their own. */
+const TYPE_SUBSTITUTE_KEYS = [
+    "type",
+    "anyOf",
+    "oneOf",
+    "allOf",
+    "enum",
+    "const",
+    "$ref",
+    "not",
+];
 function stripUnsupportedSchemaKeywords(node) {
     if (!node || typeof node !== "object" || Array.isArray(node))
         return node;
@@ -388,6 +432,11 @@ function stripUnsupportedSchemaKeywords(node) {
         obj.anyOf = [...existing, ...obj.oneOf];
         delete obj.oneOf;
     }
+    // Last, so a node that only became typed above (oneOf -> anyOf) is not also
+    // given a redundant value union.
+    if (!TYPE_SUBSTITUTE_KEYS.some((key) => obj[key] !== undefined)) {
+        obj.anyOf = JSON_VALUE_BRANCHES.map((branch) => ({ ...branch }));
+    }
     return node;
 }
 /**

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

@@ -343,6 +343,11 @@ function enginePartToAnthropic(part, builderGateway) {
             };
         }
         case "thinking":
+            // A redacted block has no readable thinking or signature — only its
+            // encrypted payload, which Anthropic requires back unmodified.
+            if (part.redactedData) {
+                return { type: "redacted_thinking", data: part.redactedData };
+            }
             // Anthropic thinking blocks — pass through with signature for context window continuity
             return {
                 type: "thinking",
@@ -409,7 +414,20 @@ export function anthropicContentToEngine(content) {
                 signature: b.signature,
             };
         }
-        // Unknown block type — skip
+        if (block.type === "redacted_thinking") {
+            // Dropping this looked like "skip an unreadable block", but Anthropic
+            // requires the whole thinking sequence back verbatim within a tool-use
+            // turn: losing it makes the very next loop iteration send an assistant
+            // turn the API refuses, from a turn that streamed perfectly.
+            return {
+                type: "thinking",
+                text: "",
+                redactedData: block.data ?? "",
+            };
+        }
+        // Unknown block type. Skipping is the only safe replay, but a silent skip
+        // is how redacted_thinking went missing — say which type was dropped.
+        console.warn(`[anthropic-engine] dropping unrecognized content block type "${block.type}" from the assistant turn; it will not be replayed`);
         return { type: "text", text: "" };
     })
         .filter((p) => !(p.type === "text" && p.text === ""));

package/dist/agent/engine/types.d.ts

@@ -121,6 +121,13 @@ export interface EngineThinkingPart {
     text: string;
     /** Opaque signature for pass-through on next turn (Anthropic extended thinking) */
     signature?: string;
+    /**
+     * Encrypted payload of an Anthropic `redacted_thinking` block, which carries
+     * no readable `text` or `signature`. Anthropic requires the block back
+     * verbatim in the same tool-use turn, so it has to survive normalization —
+     * a part with this set replays as `redacted_thinking`, not as `thinking`.
+     */
+    redactedData?: string;
 }
 export type EngineContentPart = EngineTextPart | EngineImagePart | EngineFilePart | EngineToolCallPart | EngineToolResultPart | EngineThinkingPart;
 export type EngineMessage = {

package/dist/agent/production-agent.js

@@ -772,6 +772,15 @@ const RUN_BUDGET_EXHAUSTED_ERROR_CODE = "run_budget_exhausted";
 const RUN_BUDGET_EXHAUSTED_MESSAGE = "I ran out of time before finishing this step. " +
     "I stopped rather than keep retrying silently. " +
     "Check any completed tool cards above before retrying, ideally as one smaller follow-up.";
+/**
+ * Text attachments have been capped since forever; binary ones never were, so
+ * a large PDF or screenshot went to the provider as unbounded inline base64.
+ * OpenAI rejects the whole request over 1,048,576 chars in one `file_url`
+ * ("string too long", measured at 4,149,128), which kills the turn — the cap is
+ * on the encoded string, so that is what this counts rather than decoded bytes.
+ * Held under the limit to leave room for the `data:<mediaType>;base64,` prefix.
+ */
+const MAX_INLINE_ATTACHMENT_BASE64_CHARS = 1_000_000;
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_TEXT_ATTACHMENTS_TOTAL_CHARS = 80_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
@@ -1093,6 +1102,17 @@ export function buildUserContentWithAttachments(opts) {
                 continue;
             }
             const match = att.data.match(/^data:(image\/[^;]+);base64,(.+)$/);
+            if (match &&
+                isSupportedImageMediaType(match[1]) &&
+                match[2].length > MAX_INLINE_ATTACHMENT_BASE64_CHARS) {
+                // The upload already happened and `uploadedUrl` is the whole point of
+                // it. Inlining the bytes anyway is what made the request unsendable.
+                const label = att.name ? `"${att.name}"` : "An image";
+                textAttachments.push(uploadedUrl
+                    ? `[${label} was uploaded to ${uploadedUrl}. It was too large to send inline for vision analysis, so use the URL for embedding/reference.]`
+                    : `[${label} was too large to send inline for vision analysis and no upload URL is available. Ask the user to attach a smaller image.]`);
+                continue;
+            }
             if (match && isSupportedImageMediaType(match[1])) {
                 userContent.push({
                     type: "image",
@@ -1125,6 +1145,13 @@ export function buildUserContentWithAttachments(opts) {
         }
         const filePart = dataUrlToFilePart(att);
         if (filePart) {
+            if (filePart.data.length > MAX_INLINE_ATTACHMENT_BASE64_CHARS) {
+                const label = att.name ? `"${att.name}"` : "A file";
+                textAttachments.push(uploadedUrl
+                    ? `[${label} was uploaded to ${uploadedUrl}. It was too large to send inline, so read it from the URL if its contents are needed.]`
+                    : `[${label} was too large to send inline and no upload URL is available. Ask the user for a smaller file.]`);
+                continue;
+            }
             userContent.push(filePart);
             continue;
         }
@@ -7161,6 +7188,11 @@ export function createProductionAgentHandler(options) {
                 const { threadDataToEngineMessages } = await import("./thread-data-builder.js");
                 const priorThreadData = (await getThread(effectiveThreadId))
                     ?.threadData;
+                // `threadDataToEngineMessages` takes one argument and flattens tool
+                // calls to text by design. The second argument never existed anywhere
+                // in the repo, so this failed `tsc` and broke every production build
+                // between 16:29 and now -- it reached main only because admin merges
+                // do not wait for the typecheck that would have caught it.
                 const resumed = threadDataToEngineMessages(priorThreadData);
                 if (resumed.length > 0) {
                     const actionPreparationTool = typeof backgroundRunMarker?.actionPreparationTool === "string" &&

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

@@ -62,17 +62,29 @@ export declare function buildAssistantMessage(events: RunEvent[], runId?: string
  * fail with "Parent message not found".
  */
 export declare function normalizeThreadRepository(repo: any): any;
+export interface ThreadDataToEngineMessagesOptions {
+    /**
+     * Replay the tool calls and results thread_data already stores instead of
+     * flattening each turn to its prose. Required by callers that RESUME a run
+     * (chained background continuation, agent-teams continue): a turn rebuilt as
+     * text alone tells the model what it said but not what it did, so it re-runs
+     * tools it already ran and cannot see their output. Callers that only need
+     * "what was said" — recovery floors, memory compaction — leave this off.
+     */
+    includeToolCalls?: boolean;
+}
 /**
  * Rebuild a flat `EngineMessage[]` from persisted thread_data (the
- * assistant-ui ExportedMessageRepository shape). Text-only — tool calls/results
- * are flattened to their text so a continuation run gets the conversation
- * prefix as plain context (Anthropic's prompt cache makes the resume cheap).
+ * assistant-ui ExportedMessageRepository shape). Each turn collapses to its
+ * text by default, which is all a recovery floor or a memory compaction needs.
+ * Callers resuming a run pass `includeToolCalls` to replay what the turn
+ * actually DID as well as what it said.
  *
  * Used to resume a background sub-agent in a fresh function invocation (the
  * server-side analog of the browser re-POSTing history for the main chat).
  * Originally inlined in `integrations/webhook-handler.ts`.
  */
-export declare function threadDataToEngineMessages(threadData: string | Record<string, unknown> | null | undefined): EngineMessage[];
+export declare function threadDataToEngineMessages(threadData: string | Record<string, unknown> | null | undefined, options?: ThreadDataToEngineMessagesOptions): EngineMessage[];
 /**
  * The trailing window of what was actually said in a thread, for a request that
  * arrived carrying no history of its own. The client trims history against a

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

@@ -1,6 +1,7 @@
 import { formatChatErrorText, normalizeChatError, } from "../client/error-format.js";
 import { isCredentialGapCodeAgentEvent, normalizeCodeAgentTranscript, } from "../code-agents/transcript-normalizer.js";
 import { BUILDER_GATEWAY_INTERNAL_ERROR_CODE } from "./engine/error-detail.js";
+import { stringifyToolUseInputForGateway } from "./engine/translate-anthropic.js";
 const INTERRUPTED_TOOL_RESULT = "Interrupted before this tool returned a result.";
 export const ASSISTANT_RUN_DURATION_METADATA_KEY = "agentNativeRunDurationMs";
 const MAX_STORED_ATTACHMENT_CHARS = 60_000;
@@ -653,17 +654,121 @@ export function normalizeThreadRepository(repo) {
         headId && seenIds.has(headId) ? headId : (previousId ?? null);
     return normalized;
 }
+/**
+ * A replayed tool result is evidence, not the source of truth — the resumed
+ * turn can always re-read current state. Bound each one so restoring fidelity
+ * cannot itself overflow the context window, and say so in-band when it bites.
+ */
+const MAX_REPLAYED_TOOL_RESULT_CHARS = 12_000;
+/**
+ * Total budget for replayed tool payloads across the whole thread. Per-result
+ * capping alone is not a bound: a long run has hundreds of calls, so replaying
+ * every one of them would overflow the context window and break the very
+ * continuation this replay exists to serve. The newest turns keep their tool
+ * detail; older turns fall back to prose and say so.
+ */
+const MAX_REPLAYED_TOOL_PAYLOAD_CHARS = 64_000;
+const ELIDED_TOOL_DETAIL_NOTE = "[Tool calls from this turn were elided from replayed history to fit the context. Re-read the current state with tools if their detail matters.]";
+function replayedToolResultContent(result) {
+    const body = typeof result === "string"
+        ? result
+        : result === undefined || result === null
+            ? ""
+            : (() => {
+                try {
+                    return JSON.stringify(result) ?? "";
+                }
+                catch {
+                    return String(result);
+                }
+            })();
+    if (body.length <= MAX_REPLAYED_TOOL_RESULT_CHARS)
+        return body;
+    const omitted = body.length - MAX_REPLAYED_TOOL_RESULT_CHARS;
+    return `${body.slice(0, MAX_REPLAYED_TOOL_RESULT_CHARS)}\n\n[Tool result truncated after ${MAX_REPLAYED_TOOL_RESULT_CHARS.toLocaleString()} characters; ${omitted.toLocaleString()} omitted from replayed history. Re-read the current state with tools if the exact content matters.]`;
+}
+/**
+ * Integration turns (Slack and friends) deliberately replay only what the
+ * participant saw plus a compact artifact ledger — never the raw tool results.
+ * `threadMessageTextForEngine` owns that policy, so a structured replay has to
+ * defer to it rather than reach past it into `content`.
+ */
+function hasIntegrationReplayPolicy(message) {
+    const metadata = message?.metadata;
+    if (!metadata || typeof metadata !== "object")
+        return false;
+    return (metadata.integrationDelivery !== undefined ||
+        metadata.integrationDeliveryAttempted === true ||
+        Array.isArray(metadata.integrationArtifacts));
+}
+function replayableToolCalls(message) {
+    const content = Array.isArray(message?.content) ? message.content : [];
+    return content.filter((part) => part?.type === "tool-call" &&
+        typeof part.toolCallId === "string" &&
+        part.toolCallId.trim() &&
+        typeof part.toolName === "string" &&
+        part.toolName.trim());
+}
+/** What replaying this turn's tool calls with their results would actually cost. */
+function replayedToolPayloadCost(message) {
+    let cost = 0;
+    for (const part of replayableToolCalls(message)) {
+        cost += stringifyToolUseInputForGateway(part.args ?? {}).length;
+        if (part.result !== undefined) {
+            cost += replayedToolResultContent(part.result).length;
+        }
+    }
+    return cost;
+}
+/**
+ * One persisted assistant turn spans many tool rounds. Replay it as the
+ * provider protocol wants it — one assistant message carrying every `tool-call`,
+ * then one user message carrying every matching `tool-result`. The exact
+ * round-by-round interleaving is not recoverable from thread_data and does not
+ * matter; what matters is that the calls and their outputs survive at all.
+ */
+function assistantReplayContent(message, text) {
+    const assistant = [];
+    const results = [];
+    if (text.trim())
+        assistant.push({ type: "text", text });
+    const content = Array.isArray(message?.content) ? message.content : [];
+    for (const part of content) {
+        if (part?.type !== "tool-call")
+            continue;
+        const id = typeof part.toolCallId === "string" ? part.toolCallId.trim() : "";
+        const name = typeof part.toolName === "string" ? part.toolName.trim() : "";
+        if (!id || !name)
+            continue;
+        const input = part.args && typeof part.args === "object" && !Array.isArray(part.args)
+            ? part.args
+            : {};
+        assistant.push({ type: "tool-call", id, name, input });
+        if (part.result === undefined)
+            continue;
+        results.push({
+            type: "tool-result",
+            toolCallId: id,
+            toolName: name,
+            toolInput: stringifyToolUseInputForGateway(input),
+            content: replayedToolResultContent(part.result),
+            ...(part.isError === true ? { isError: true } : {}),
+        });
+    }
+    return { assistant, results };
+}
 /**
  * Rebuild a flat `EngineMessage[]` from persisted thread_data (the
- * assistant-ui ExportedMessageRepository shape). Text-only — tool calls/results
- * are flattened to their text so a continuation run gets the conversation
- * prefix as plain context (Anthropic's prompt cache makes the resume cheap).
+ * assistant-ui ExportedMessageRepository shape). Each turn collapses to its
+ * text by default, which is all a recovery floor or a memory compaction needs.
+ * Callers resuming a run pass `includeToolCalls` to replay what the turn
+ * actually DID as well as what it said.
  *
  * Used to resume a background sub-agent in a fresh function invocation (the
  * server-side analog of the browser re-POSTing history for the main chat).
  * Originally inlined in `integrations/webhook-handler.ts`.
  */
-export function threadDataToEngineMessages(threadData) {
+export function threadDataToEngineMessages(threadData, options = {}) {
     const messages = [];
     if (!threadData)
         return messages;
@@ -676,11 +781,60 @@ export function threadDataToEngineMessages(threadData) {
     }
     if (!Array.isArray(data?.messages))
         return messages;
-    for (const entry of data.messages) {
+    const entries = data.messages;
+    const replaysTools = (m) => options.includeToolCalls === true &&
+        m?.role === "assistant" &&
+        !hasIntegrationReplayPolicy(m);
+    // Spend the tool-payload budget on the most recent turns: those are the ones
+    // a resumed run is about to build on. Decided up front so the walk below can
+    // stay in conversation order.
+    const toolPayloadAllowed = new Set();
+    if (options.includeToolCalls) {
+        let spent = 0;
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const m = entries[i]?.message ?? entries[i];
+            if (!replaysTools(m))
+                continue;
+            const cost = replayedToolPayloadCost(m);
+            if (cost === 0)
+                continue;
+            if (spent + cost > MAX_REPLAYED_TOOL_PAYLOAD_CHARS)
+                continue;
+            spent += cost;
+            toolPayloadAllowed.add(i);
+        }
+    }
+    for (const [index, entry] of entries.entries()) {
         const m = entry?.message ?? entry;
         if (!m || (m.role !== "user" && m.role !== "assistant"))
             continue;
         const text = threadMessageTextForEngine(m);
+        if (replaysTools(m)) {
+            if (toolPayloadAllowed.has(index)) {
+                const { assistant, results } = assistantReplayContent(m, text);
+                if (assistant.length === 0)
+                    continue;
+                messages.push({ role: "assistant", content: assistant });
+                if (results.length > 0) {
+                    messages.push({ role: "user", content: results });
+                }
+                continue;
+            }
+            // Over budget, or nothing to replay. Prose still travels — but a turn
+            // whose tool detail was dropped must not read like a turn that never
+            // called a tool.
+            const elided = replayableToolCalls(m).length > 0;
+            const prose = elided
+                ? `${text.trim() ? `${text.trim()}\n\n` : ""}${ELIDED_TOOL_DETAIL_NOTE}`
+                : text;
+            if (!prose.trim())
+                continue;
+            messages.push({
+                role: "assistant",
+                content: [{ type: "text", text: prose }],
+            });
+            continue;
+        }
         if (!text.trim())
             continue;
         messages.push({ role: m.role, content: [{ type: "text", text }] });

package/dist/client/AssistantChat.js

@@ -2603,6 +2603,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         // A restored tab can be reclassified as client-only after the thread list
         // loads. Once that happens, there is no server row to restore, so show the
         // empty composer instead of leaving the per-thread restore skeleton up.
+        setThreadRestoreError(null);
         setIsRestoring(false);
     }, [isNewThread, threadId]);
     // Restore messages from server on mount (when threadId is set). The

package/dist/client/agent-chat-adapter.js

@@ -66,6 +66,17 @@ const MAX_HISTORY_ATTACHMENT_CHARS = 60_000;
 // visibly (not silently) capped.
 const MAX_OUTBOUND_ATTACHMENT_CHARS = 200_000;
 const MAX_HISTORY_MESSAGES = 24;
+// Every provider prompt cache matches a byte-identical PREFIX. A window that
+// ends at the newest message and starts MAX_HISTORY_MESSAGES back moves its
+// START by one message per turn, so from the first turn past the cap onward no
+// cached prefix ever matches again and the whole conversation is re-billed at
+// full write price on every turn — the cache breakpoints the engines place
+// (system prefix, last tool, last user message) cannot save a prefix whose
+// first bytes changed. Quantizing where the window starts holds those bytes
+// identical for a stride of turns, so one turn in STRIDE pays the write and the
+// rest read. The window then holds up to MAX + STRIDE - 1 messages; the char
+// budgets below, not the message count, are what bound the payload.
+const HISTORY_WINDOW_STRIDE = 8;
 const MAX_HISTORY_TOTAL_CHARS = 64_000;
 // Budget for everything actually said in the thread — every user ask and every
 // assistant conclusion. Separate from MAX_HISTORY_TOTAL_CHARS, which bounds the
@@ -788,7 +799,8 @@ function estimateHistoryMessageCost(message) {
     return Math.max(1, cost);
 }
 function limitPriorMessagesForRequest(messages) {
-    const recent = messages.slice(-MAX_HISTORY_MESSAGES);
+    const overflow = Math.max(0, messages.length - MAX_HISTORY_MESSAGES);
+    const recent = messages.slice(Math.floor(overflow / HISTORY_WINDOW_STRIDE) * HISTORY_WINDOW_STRIDE);
     const kept = [];
     let words = 0;
     let payload = 0;

package/dist/client/chat-first/app-open-actions.js

@@ -21,5 +21,5 @@ export function AppOpenActions({ name, href, target, rel, labels: labelOverrides
     if (!canOpen && !hasMenu) {
         return (_jsx(Button, { size: "sm", variant: "outline", disabled: true, children: labels.openApp }));
     }
-    return (_jsxs("div", { className: cn("app-open-actions flex shrink-0 overflow-hidden rounded-md border border-border focus-within:ring-2 focus-within:ring-ring focus-within:ring-offset-2", className), children: [_jsx(Button, { asChild: primaryUsesHref, size: "sm", variant: "outline", className: "app-open-actions__primary h-7 rounded-none border-0 border-e border-border px-0 pe-2 ps-3 text-xs", disabled: !canOpen, onClick: onOpen, type: primaryUsesHref ? undefined : "button", "aria-label": !primaryUsesHref ? `Open ${name}` : undefined, children: primaryUsesHref ? (_jsx("a", { href: href ?? undefined, target: target, rel: rel, children: labels.openApp })) : (_jsx("span", { children: labels.openApp })) }), hasMenu ? (_jsxs(DropdownMenu, { children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(Button, { type: "button", size: "sm", variant: "outline", className: "app-open-actions__menu size-7 rounded-none border-0 p-0 text-xs", "aria-label": `Open options for ${name}`, children: _jsx(IconChevronDown, { size: 15 }) }) }), _jsxs(DropdownMenuContent, { align: "end", className: APP_ACTION_MENU_CONTENT_CLASS, children: [onAddApp ? (_jsxs(DropdownMenuItem, { onSelect: onAddApp, children: [_jsx(IconPlus, { size: 14, "aria-hidden": "true" }), labels.addApp] })) : null, showInlineOption && href && onOpenInline ? (_jsxs(DropdownMenuItem, { onSelect: onOpenInline, children: [_jsx(IconAppWindow, { size: 14, "aria-hidden": "true" }), labels.openInline] })) : null, canOfferNewTab && href ? (_jsx(DropdownMenuItem, { asChild: true, children: _jsxs("a", { href: href ?? undefined, target: "_blank", rel: "noreferrer", children: [_jsx(IconExternalLink, { size: 14, "aria-hidden": "true" }), labels.openInNewTab] }) })) : null, menuItems?.map((item) => (_jsxs(DropdownMenuItem, { onSelect: item.onSelect, children: [item.icon ? (_jsx("span", { "aria-hidden": "true", className: "shrink-0", children: item.icon })) : null, item.label] }, item.id)))] })] })) : null] }));
+    return (_jsxs("div", { className: cn("app-open-actions flex shrink-0 overflow-hidden rounded-md border border-border focus-within:ring-2 focus-within:ring-ring focus-within:ring-offset-2", className), children: [_jsx(Button, { asChild: primaryUsesHref, size: "sm", variant: "outline", className: "app-open-actions__primary h-7 rounded-none border-0 border-e border-border px-0 pe-2 ps-3 text-xs", disabled: !canOpen, onClick: onOpen, type: primaryUsesHref ? undefined : "button", "aria-label": !primaryUsesHref ? `Open ${name}` : undefined, children: primaryUsesHref ? (_jsx("a", { href: href ?? undefined, target: target, rel: rel, children: labels.openApp })) : (_jsx("span", { children: labels.openApp })) }), hasMenu ? (_jsxs(DropdownMenu, { children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(Button, { type: "button", size: "sm", variant: "outline", className: "app-open-actions__menu size-7 rounded-none border-0 p-0 text-xs", "aria-label": `Open options for ${name}`, children: _jsx(IconChevronDown, { size: 15 }) }) }), _jsxs(DropdownMenuContent, { align: "end", className: cn(APP_ACTION_MENU_CONTENT_CLASS, "min-w-max"), children: [onAddApp ? (_jsxs(DropdownMenuItem, { onSelect: onAddApp, children: [_jsx(IconPlus, { size: 14, "aria-hidden": "true" }), labels.addApp] })) : null, showInlineOption && href && onOpenInline ? (_jsxs(DropdownMenuItem, { onSelect: onOpenInline, children: [_jsx(IconAppWindow, { size: 14, "aria-hidden": "true" }), labels.openInline] })) : null, canOfferNewTab && href ? (_jsx(DropdownMenuItem, { asChild: true, children: _jsxs("a", { href: href ?? undefined, target: "_blank", rel: "noreferrer", children: [_jsx(IconExternalLink, { size: 14, "aria-hidden": "true" }), labels.openInNewTab] }) })) : null, menuItems?.map((item) => (_jsxs(DropdownMenuItem, { onSelect: item.onSelect, children: [item.icon ? (_jsx("span", { "aria-hidden": "true", className: "shrink-0", children: item.icon })) : null, item.label] }, item.id)))] })] })) : null] }));
 }

package/dist/client/chat-first/copy.js

@@ -12,8 +12,8 @@ const DEFAULT_COPY = {
     createApp: "Create app",
     retry: "Retry",
     dismiss: "Dismiss",
-    unpinApp: "Unpin {name}",
-    pinApp: "Pin {name}",
+    unpinApp: "Unpin this app",
+    pinApp: "Pin this app",
     removePinned: "Remove from pinned apps",
     pinTop: "Pin app to the top",
     moveUp: "Move up",

package/dist/client/mcp-apps/McpAppRenderer.js

@@ -55,6 +55,11 @@ export function McpAppRenderer({ app, className }) {
         setReady(true);
         setError(null);
     }, []);
+    const handleIframeError = useCallback(() => {
+        readyRef.current = false;
+        setReady(false);
+        setError("MCP App iframe failed to load.");
+    }, []);
     const applyHeight = useCallback((desiredHeight) => {
         if (typeof desiredHeight === "number" &&
             Number.isFinite(desiredHeight) &&
@@ -228,9 +233,9 @@ export function McpAppRenderer({ app, className }) {
         // new-but-equal `app` object reference does not tear down a live bridge.
     }, [applyHeight, markReady, srcDoc]);
     if (!resourceHtml) {
-        return (_jsxs("div", { className: cn("agent-mcp-app agent-mcp-app--error", className), children: [_jsx(IconAlertTriangle, { size: 15 }), _jsx("span", { children: "MCP App resource was not available." })] }));
+        return (_jsxs("div", { className: cn("agent-mcp-app agent-mcp-app--error", className), children: [_jsx(IconAlertTriangle, { size: 15 }), _jsx("span", { children: "MCP App resource was not available." }), externalOpenUrl && (_jsx("button", { type: "button", className: "agent-mcp-app__open", onClick: () => window.open(externalOpenUrl, "_blank", "noopener,noreferrer"), children: "Open in new tab" }))] }));
     }
-    return (_jsxs("div", { className: cn("agent-mcp-app", uiMeta.prefersBorder === false && "agent-mcp-app--flush", className), children: [!ready && !error && (_jsxs("div", { className: "agent-mcp-app__loading", children: [_jsx(IconLoader2, { size: 14, className: "agent-conversation-spin" }), _jsx("span", { children: "Loading MCP App" })] })), error && (_jsxs("div", { className: "agent-mcp-app__error", children: [_jsx(IconAlertTriangle, { size: 15 }), _jsx("span", { children: error }), externalOpenUrl && (_jsx("button", { type: "button", className: "agent-mcp-app__open", onClick: () => window.open(externalOpenUrl, "_blank", "noopener,noreferrer"), children: "Open in new tab" }))] })), _jsx("iframe", { ref: iframeRef, title: app.tool?.title ?? app.originalToolName, srcDoc: srcDoc, sandbox: SANDBOX_FLAGS, allow: buildAllowAttribute(supportedPermissions), style: { height } })] }));
+    return (_jsxs("div", { className: cn("agent-mcp-app", uiMeta.prefersBorder === false && "agent-mcp-app--flush", className), children: [!ready && !error && (_jsxs("div", { className: "agent-mcp-app__loading", children: [_jsx(IconLoader2, { size: 14, className: "agent-conversation-spin" }), _jsx("span", { children: "Loading MCP App" })] })), error && (_jsx("div", { className: "agent-mcp-app__error", role: "alert", children: _jsxs("div", { className: "agent-mcp-app__error-box", children: [_jsx(IconAlertTriangle, { size: 15 }), _jsx("span", { children: error }), externalOpenUrl && (_jsx("button", { type: "button", className: "agent-mcp-app__open", onClick: () => window.open(externalOpenUrl, "_blank", "noopener,noreferrer"), children: "Open in new tab" }))] }) })), _jsx("iframe", { ref: iframeRef, title: app.tool?.title ?? app.originalToolName, srcDoc: srcDoc, sandbox: SANDBOX_FLAGS, allow: buildAllowAttribute(supportedPermissions), style: { height }, onError: handleIframeError })] }));
 }
 function messageTextFromMcpUiMessage(params) {
     return textPartsFromMcpContent(params.content).join("\n\n").trim();

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

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/mcp/embed-app.js

@@ -47,6 +47,8 @@ export function embedApp(options = {}) {
     iframe { display: block; width: 100%; height: var(--agent-native-viewport-height); border: 0; background: Canvas; }
     .message { display: grid; place-items: center; min-height: var(--agent-native-viewport-height); padding: 18px; color: color-mix(in srgb, CanvasText 62%, Canvas); font-size: 13px; line-height: 1.45; text-align: center; }
     .fallback { display: grid; align-content: center; justify-items: center; gap: 12px; min-height: var(--agent-native-viewport-height); padding: 24px; background: Canvas; color: CanvasText; text-align: center; }
+    .fallback-overlay { position: absolute; inset: 0; z-index: 2; display: grid; align-items: start; justify-items: end; padding: 12px; pointer-events: none; }
+    .fallback-overlay .fallback { width: min(100%, 560px); min-height: 0; border: 1px solid color-mix(in srgb, CanvasText 18%, Canvas); border-radius: 9px; background: color-mix(in srgb, Canvas 96%, transparent); box-shadow: 0 8px 24px color-mix(in srgb, CanvasText 16%, transparent); pointer-events: auto; }
     .fallback-title { max-width: 440px; font-size: 14px; font-weight: 700; }
     .fallback-copy { max-width: 520px; color: color-mix(in srgb, CanvasText 64%, Canvas); font-size: 13px; line-height: 1.45; }
     .fallback-actions { display: flex; flex-wrap: wrap; align-items: center; justify-content: center; gap: 8px; }
@@ -1073,14 +1075,64 @@ export function embedApp(options = {}) {
       } catch {}
     }
 
+    function clearFallbackOverlay() {
+      stage.querySelector("[data-fallback-overlay]")?.remove();
+    }
+
+    function renderFallbackOverlay({ title, copyHtml, retryLabel, onRetry }) {
+      if (!appFrame || appFrame.parentElement !== stage) return false;
+      clearFallbackOverlay();
+      const overlay = document.createElement("div");
+      overlay.className = "fallback-overlay";
+      overlay.dataset.fallbackOverlay = "1";
+      overlay.innerHTML =
+        '<div class="fallback">' +
+          '<div class="fallback-title">' + esc(title) + '</div>' +
+          '<div class="fallback-copy">' + copyHtml + '</div>' +
+          '<div class="fallback-actions">' +
+            '<button type="button" class="primary" data-fallback-open>Open in new tab</button>' +
+            '<button type="button" data-fallback-retry>' + esc(retryLabel) + '</button>' +
+          '</div>' +
+          (openUrl ? '<a class="fallback-url" href="' + esc(openUrl) + '" target="_blank" rel="noreferrer">' + esc(openUrl) + '</a>' : '') +
+        '</div>';
+      stage.appendChild(overlay);
+
+      const fallbackOpen = overlay.querySelector("[data-fallback-open]");
+      const fallbackRetry = overlay.querySelector("[data-fallback-retry]");
+      if (fallbackOpen) {
+        fallbackOpen.disabled = !openUrl;
+        fallbackOpen.onclick = () => {
+          if (openUrl) void openFallbackExternal();
+        };
+      }
+      if (fallbackRetry) {
+        fallbackRetry.disabled = typeof onRetry !== "function";
+        fallbackRetry.onclick = () => {
+          if (typeof onRetry === "function") void onRetry();
+        };
+      }
+      return true;
+    }
+
     function renderFrameFallback() {
       clearFrameReadyTimer();
       clearFrameLoadTimer();
-      appFrame = null;
+      appFrameReady = false;
       const fallbackCopy = openUrl
         ? "This chat host did not allow the embedded app frame to load inline. You can still open the same app route through the host or use the URL below."
         : "This chat host did not allow the embedded app frame to load inline.";
       reportEmbedError("frame-fallback", fallbackCopy);
+      if (renderFallbackOverlay({
+        title: "Open this app in its own tab",
+        copyHtml: esc(fallbackCopy),
+        retryLabel: "Try inline again",
+        onRetry: lastFrameSrc
+          ? () => renderFrame(lastFrameSrc)
+          : undefined
+      })) {
+        return;
+      }
+      appFrame = null;
       stage.innerHTML =
         '<div class="fallback">' +
           '<div class="fallback-title">Open this app in its own tab</div>' +
@@ -1110,7 +1162,7 @@ export function embedApp(options = {}) {
     function renderAppLaunchError(message) {
       clearFrameReadyTimer();
       clearFrameLoadTimer();
-      appFrame = null;
+      appFrameReady = false;
       const fallbackCopy = openUrl
         ? "The inline MCP app could not load in this chat host. You can open the same app route in a new tab or retry the inline load."
         : "The inline MCP app could not load in this chat host.";
@@ -1118,6 +1170,18 @@ export function embedApp(options = {}) {
       const copyHtml = message
         ? '<div>' + esc(message) + '</div><div>' + esc(fallbackCopy) + '</div>'
         : esc(fallbackCopy);
+      if (renderFallbackOverlay({
+        title: "App did not load",
+        copyHtml,
+        retryLabel: "Retry",
+        onRetry: () => {
+          startedFor = "";
+          void launchEmbed();
+        }
+      })) {
+        return;
+      }
+      appFrame = null;
       stage.innerHTML =
         '<div class="fallback">' +
           '<div class="fallback-title">App did not load</div>' +
@@ -1178,6 +1242,10 @@ export function embedApp(options = {}) {
         sendFrameReadyMessages(frame);
         startFrameReadyTimer(frame);
       });
+      frame.addEventListener("error", () => {
+        if (appFrame !== frame) return;
+        renderFrameFallback();
+      });
       stage.replaceChildren(frame);
       notifyHostHeight();
       appFrameLoadTimer = setTimeout(() => {
@@ -1475,6 +1543,7 @@ export function embedApp(options = {}) {
       const data = event.data.data || {};
       if (message.type === "agentNative.embeddedAppReady") {
         appFrameReady = true;
+        clearFallbackOverlay();
         embedSessionRefreshAttempts = 0;
         clearFrameLoadTimer();
         clearFrameReadyTimer();

package/dist/notifications/routes.d.ts

@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;