@agent-native/core 0.153.10 → 0.154.1

package/dist/client/sse-event-processor.js

@@ -1,7 +1,7 @@
 import { LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "../agent/engine/credential-errors.js";
 import { emitChatFirstOpenApp } from "./chat-first.js";
 import { formatChatErrorText, normalizeChatError } from "./error-format.js";
-import { humanizeToolLabelText, humanizeToolName, runningToolLabel, } from "./tool-display.js";
+import { humanizeToolLabelText, humanizeToolName, isToolCallActive, runningToolLabel, } from "./tool-display.js";
 /**
  * Kept verbatim in sync with `INTERRUPTED_TOOL_RESULT_MARKER`
  * (agent/production-agent.ts): the server matches this substring in replayed
@@ -13,16 +13,21 @@ const INTERRUPTED_ACTIVITY_RESULT = "Stopped before this action started.";
 /**
  * Maximum number of assistant-ui repository updates we deliver in one browser
  * event-loop turn. Durable-run replay can put hundreds of SSE frames into the
- * stream queue before the client attaches; draining all of them through
- * assistant-ui without a macrotask boundary synchronously nests React external
- * store notifications until React throws "Maximum update depth exceeded."
+ * stream queue before the client attaches; allowing even a small burst through
+ * assistant-ui can synchronously nest React external-store notifications until
+ * React throws "Maximum update depth exceeded."
  *
- * A timer scheduled on the first result resets the count when the stream is
+ * A task scheduled on the first result resets the count when the stream is
  * naturally idle between network chunks. We only await it when results are
  * arriving densely enough to hit this bound, so normal live token streaming
  * keeps its existing latency while replay bursts yield cooperatively.
  */
-const SSE_RENDER_UPDATES_PER_EVENT_LOOP_TURN = 20;
+const SSE_RENDER_UPDATES_PER_EVENT_LOOP_TURN = 1;
+function waitForNextEventLoopTurn() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+}
 export function settleInterruptedToolCalls(content, result = INTERRUPTED_TOOL_RESULT, options) {
     let changed = false;
     for (const part of content) {
@@ -825,6 +830,8 @@ function hasCompletedCustomUi(content) {
     return hasCompletedTool && lastCompletedToolIsCustomUi;
 }
 export function appendMissingFinalResponseWarning(content, completedToolNames) {
+    if (content.some((part) => isToolCallActive(part)))
+        return null;
     const lastTextIndex = lastAssistantTextIndex(content);
     const successfulToolNames = [
         ...new Set(completedToolNames ?? completedToolNamesAfterLastAssistantText(content)),
@@ -1245,6 +1252,7 @@ export function processEvent(ev, content, toolCallCounter, tabId, state) {
                                 : "Done";
                     part.structuredMeta = {
                         ...part.structuredMeta,
+                        ...(ev.status === "pending" ? { agentPending: true } : {}),
                         ...(ev.durationMs != null
                             ? { agentDurationMs: ev.durationMs }
                             : {}),
@@ -1618,15 +1626,19 @@ export async function* readSSEStream(body, content, toolCallCounter, tabId, onSe
     const currentNoProgressTimeoutMs = () => inFlightWork > 0
         ? Math.max(noProgressTimeoutMs, SSE_IN_FLIGHT_WORK_TIMEOUT_MS)
         : noProgressTimeoutMs;
-    const paceRenderUpdate = async () => {
+    const paceRenderUpdate = async (hasBufferedEvent) => {
+        // A single event in a network chunk already has a natural read boundary.
+        // Avoid inserting a task into quiet streams so watchdogs and fake-clock
+        // consumers can continue to observe their own timers normally.
+        if (!hasBufferedEvent) {
+            renderUpdatesThisTurn = 0;
+            return;
+        }
         renderUpdatesThisTurn += 1;
         if (!nextEventLoopTurn) {
-            nextEventLoopTurn = new Promise((resolve) => {
-                setTimeout(() => {
-                    renderUpdatesThisTurn = 0;
-                    nextEventLoopTurn = null;
-                    resolve();
-                }, 0);
+            nextEventLoopTurn = waitForNextEventLoopTurn().then(() => {
+                renderUpdatesThisTurn = 0;
+                nextEventLoopTurn = null;
             });
         }
         if (renderUpdatesThisTurn >= SSE_RENDER_UPDATES_PER_EVENT_LOOP_TURN) {
@@ -1686,12 +1698,19 @@ export async function* readSSEStream(body, content, toolCallCounter, tabId, onSe
             const lines = buf.split("\n");
             buf = lines.pop() ?? "";
             let sawProgressEvent = false;
-            for (const line of lines) {
+            let bufferedDataEvents = lines.reduce((count, pendingLine) => count +
+                (pendingLine.startsWith("data: ") &&
+                    pendingLine.slice(6).trim().length > 0
+                    ? 1
+                    : 0), 0);
+            for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+                const line = lines[lineIndex];
                 if (!line.startsWith("data: "))
                     continue;
                 const raw = line.slice(6).trim();
                 if (!raw)
                     continue;
+                bufferedDataEvents -= 1;
                 let ev;
                 try {
                     ev = JSON.parse(raw);
@@ -1751,7 +1770,8 @@ export async function* readSSEStream(body, content, toolCallCounter, tabId, onSe
                     }
                     : result;
                 if (terminalResult) {
-                    await paceRenderUpdate();
+                    const hasBufferedEvent = bufferedDataEvents > 0;
+                    await paceRenderUpdate(hasBufferedEvent);
                     yield withStreamMetadata(terminalResult);
                 }
                 if (hasStalledPreparingAction(preparingActionState, Date.now(), preparationStallTimeoutMs)) {

package/dist/client/tool-display.d.ts

@@ -7,7 +7,16 @@ type ToolDisplayPart = {
     toolName?: string;
     argsText?: string;
     args?: Record<string, unknown>;
+    result?: unknown;
+    outcome?: "unknown";
+    activity?: boolean;
+    structuredMeta?: Record<string, unknown>;
 };
+export declare function isDelegatedAgentToolCall(part: ToolDisplayPart): boolean;
+/** True when a tool has not reported a result and the stream did not mark it unknown. */
+export declare function isToolCallInFlight(part: ToolDisplayPart): boolean;
+/** True when the UI must not present this tool as finished. */
+export declare function isToolCallActive(part: ToolDisplayPart): boolean;
 /**
  * `call-agent` emits both its ordinary tool row and a richer `agent:<name>`
  * progress row. Keep the ordinary part in message state for tool completion

package/dist/client/tool-display.js

@@ -33,6 +33,45 @@ export function humanizeToolLabelText(label, toolName) {
         return text;
     return text.split(tool).join(humanizeToolName(tool));
 }
+const ACTIVE_AGENT_ACTIVITY_PHASES = new Set([
+    "reasoning",
+    "tool",
+    "responding",
+]);
+export function isDelegatedAgentToolCall(part) {
+    return (part.type === "tool-call" && part.toolName?.startsWith("agent:") === true);
+}
+function hasActiveDelegatedAgentActivity(part) {
+    const snapshot = part.structuredMeta?.agentActivity;
+    if (!snapshot || typeof snapshot !== "object")
+        return false;
+    const record = snapshot;
+    if (typeof record.activePhase === "string" &&
+        ACTIVE_AGENT_ACTIVITY_PHASES.has(record.activePhase)) {
+        return true;
+    }
+    return (Array.isArray(record.toolCalls) &&
+        record.toolCalls.some((tool) => tool != null &&
+            typeof tool === "object" &&
+            tool.status === "running"));
+}
+/** True when a tool has not reported a result and the stream did not mark it unknown. */
+export function isToolCallInFlight(part) {
+    if (part.type !== "tool-call")
+        return false;
+    if (part.result !== undefined || part.outcome === "unknown")
+        return false;
+    return part.activity !== true || isDelegatedAgentToolCall(part);
+}
+/** True when the UI must not present this tool as finished. */
+export function isToolCallActive(part) {
+    if (isToolCallInFlight(part))
+        return true;
+    return (isDelegatedAgentToolCall(part) &&
+        part.outcome !== "unknown" &&
+        (part.structuredMeta?.agentPending === true ||
+            hasActiveDelegatedAgentActivity(part)));
+}
 function normalizedAgentName(value) {
     if (typeof value !== "string")
         return null;

package/dist/client/vite-dev-recovery-script.js

@@ -87,7 +87,7 @@ export function getViteDevRecoveryScript() {
       console.warn("[agent-native] Dev server keeps re-bundling. Manual refresh needed.", reason);
       showOverlay(
         "Dev server out of sync",
-        "Auto-reload gave up after " + MAX_RELOADS + " tries. Refresh the page (\\u2318R / Ctrl+R)."
+        "Auto-reload gave up after " + MAX_RELOADS + " tries. Refresh the page (\\u2318R / Ctrl R)."
       );
       return;
     }

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

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/extensions/html-shell.js

@@ -147,6 +147,11 @@ export function buildExtensionHtml(content, themeVars, isDark, extensionId, bind
   </style>
 	  <style>
 	    *, *::before, *::after { border-color: hsl(var(--border)); }
+	    /* Alpine only honours x-cloak when a stylesheet hides it, and extension
+	       content is a body snippet that cannot supply one. Without this, an
+	       x-cloak overlay paints over the whole extension until Alpine boots —
+	       and forever if it never does. */
+	    [x-cloak] { display: none !important; }
 	    html, body {
 	      /* Transparent so the iframe inherits the host surface (dashboard panel,
 	         sidebar, chat) instead of painting the browser's default white canvas.

package/dist/notifications/routes.d.ts

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

package/dist/observability/routes.d.ts

@@ -41,16 +41,16 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    error?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
+    error?: undefined;
     ok?: undefined;
 } | {
     summary?: undefined;
@@ -59,9 +59,9 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     error: any;
     ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    id?: undefined;
     deleted?: undefined;
+    id?: undefined;
     provider?: undefined;
     providers: {
         id: string;
@@ -93,8 +93,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
     message?: undefined;
 } | {
-    id?: undefined;
     deleted?: undefined;
+    id?: undefined;
     providers?: undefined;
     count?: undefined;
     found: boolean;

package/dist/server/agent-chat/action-filters-a2a.d.ts

@@ -1,4 +1,5 @@
 import { type A2AArtifactResponseOptions, type A2AToolResultSummary } from "../../a2a/artifact-response.js";
+import type { AgentSkill } from "../../a2a/types.js";
 import type { EngineTool } from "../../agent/engine/types.js";
 import { type ActionEntry, type AgentLoopOutcome } from "../../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../../agent/run-loop-with-resume.js";
@@ -44,6 +45,13 @@ export interface A2AExternalAgentSurface {
  * query the caller wrote.
  */
 export declare function filterDirectA2AActions(actions: Record<string, ActionEntry>, options: A2AExternalAgentSurface): Record<string, ActionEntry>;
+/**
+ * Authenticated write capabilities that a sibling may delegate to this app's
+ * agent, but never invoke directly. `publicAgent` is the action-owned opt-in;
+ * keeping this projection independent of `connectorCatalog` avoids making apps
+ * maintain a second capability registry. The deny list remains a final veto.
+ */
+export declare function filterDelegatedA2ACapabilityActions(actions: Record<string, ActionEntry>, options: A2AExternalAgentSurface): Record<string, ActionEntry>;
 export declare function buildPublicAgentA2ASkills(actions: Record<string, ActionEntry>): Array<{
     id: string;
     name: string;
@@ -52,20 +60,13 @@ export declare function buildPublicAgentA2ASkills(actions: Record<string, Action
     inputSchema?: Record<string, unknown>;
 }>;
 /**
- * Skills for a caller with a verified A2A identity: exactly what
- * `filterDirectA2AActions` will execute. Kept separate from
- * `buildPublicAgentA2ASkills` because the public card may only name actions
- * with `requiresAuth !== true` while direct invocation requires
- * `requiresAuth === true` — advertising the public set alone tells siblings
- * an app has nothing callable when it does.
+ * Skills for a caller with a verified A2A identity. Exact bounded reads carry
+ * schemas and may be invoked directly; explicitly exposed writes carry no
+ * schema and are discoverable only as natural-language delegation targets.
+ * Kept separate from `buildPublicAgentA2ASkills` because neither authenticated
+ * surface may be disclosed by the anonymous card.
  */
-export declare function buildAuthenticatedAgentA2ASkills(actions: Record<string, ActionEntry>, options: A2AExternalAgentSurface): Array<{
-    id: string;
-    name: string;
-    description: string;
-    publicAgent: ActionEntry["publicAgent"];
-    inputSchema?: Record<string, unknown>;
-}>;
+export declare function buildAuthenticatedAgentA2ASkills(actions: Record<string, ActionEntry>, options: A2AExternalAgentSurface): AgentSkill[];
 export declare function resolveArtifactBaseUrl(event: any | undefined): string | undefined;
 export declare function assembleA2AFinalResponse(events: readonly AgentChatEvent[], toolResults: readonly A2AToolResultSummary[], options?: A2AArtifactResponseOptions & {
     event?: any;

package/dist/server/agent-chat/action-filters-a2a.js

@@ -96,6 +96,24 @@ export function filterDirectA2AActions(actions, options) {
             exposure.isConsequential !== true);
     }));
 }
+/**
+ * Authenticated write capabilities that a sibling may delegate to this app's
+ * agent, but never invoke directly. `publicAgent` is the action-owned opt-in;
+ * keeping this projection independent of `connectorCatalog` avoids making apps
+ * maintain a second capability registry. The deny list remains a final veto.
+ */
+export function filterDelegatedA2ACapabilityActions(actions, options) {
+    const denied = new Set(options.externalAgents?.denyActions ?? []);
+    return Object.fromEntries(Object.entries(actions).filter(([name, entry]) => {
+        const exposure = entry.publicAgent;
+        return (!denied.has(name) &&
+            entry.agentTool !== false &&
+            entry.readOnly !== true &&
+            exposure?.expose === true &&
+            exposure.readOnly === false &&
+            exposure.requiresAuth === true);
+    }));
+}
 export function buildPublicAgentA2ASkills(actions) {
     return Object.entries(filterPublicAgentActions(actions)).map(([name, entry]) => ({
         id: name,
@@ -110,31 +128,49 @@ export function buildPublicAgentA2ASkills(actions) {
     }));
 }
 /**
- * Skills for a caller with a verified A2A identity: exactly what
- * `filterDirectA2AActions` will execute. Kept separate from
- * `buildPublicAgentA2ASkills` because the public card may only name actions
- * with `requiresAuth !== true` while direct invocation requires
- * `requiresAuth === true` — advertising the public set alone tells siblings
- * an app has nothing callable when it does.
+ * Skills for a caller with a verified A2A identity. Exact bounded reads carry
+ * schemas and may be invoked directly; explicitly exposed writes carry no
+ * schema and are discoverable only as natural-language delegation targets.
+ * Kept separate from `buildPublicAgentA2ASkills` because neither authenticated
+ * surface may be disclosed by the anonymous card.
  */
 export function buildAuthenticatedAgentA2ASkills(actions, options) {
-    return Object.entries(filterDirectA2AActions(actions, options)).map(([name, entry]) => ({
-        id: name,
-        name,
-        description: entry.tool.description,
-        publicAgent: entry.publicAgent,
-        // Every action in this set is read-only by construction. Omitting the
-        // flag made discovery label all of them "(mutating)", which pushes a
-        // caller away from invoking them and back into open-ended delegation.
-        readOnly: true,
-        // Naming an action without its parameters is what makes a caller invoke
-        // it with `{}` and fail on a required field.
-        ...(entry.tool.parameters
-            ? {
-                inputSchema: entry.tool.parameters,
-            }
-            : {}),
-    }));
+    const directActions = filterDirectA2AActions(actions, options);
+    const delegatedActions = filterDelegatedA2ACapabilityActions(actions, options);
+    return Object.entries(actions).flatMap(([name, entry]) => {
+        const directEntry = directActions[name];
+        const delegatedEntry = delegatedActions[name];
+        if (!directEntry && !delegatedEntry)
+            return [];
+        if (directEntry) {
+            return {
+                id: name,
+                name,
+                description: entry.tool.description,
+                publicAgent: entry.publicAgent,
+                // Every action in this set is read-only by construction. Omitting the
+                // flag made discovery label all of them "(mutating)", which pushes a
+                // caller away from invoking them and back into open-ended delegation.
+                readOnly: true,
+                // Naming a directly callable action without its parameters is what
+                // makes a caller invoke it with `{}` and fail on a required field.
+                ...(entry.tool.parameters
+                    ? {
+                        inputSchema: entry.tool.parameters,
+                    }
+                    : {}),
+            };
+        }
+        return {
+            id: name,
+            name,
+            description: entry.tool.description,
+            publicAgent: entry.publicAgent,
+            // No input schema: the sibling sends an objective to the receiving app,
+            // whose agent chooses and validates its own local actions.
+            readOnly: false,
+        };
+    });
 }
 export function resolveArtifactBaseUrl(event) {
     const fromEnv = process.env.APP_URL ||

package/dist/server/agent-chat/prompt-resources.js

@@ -416,21 +416,22 @@ export function resourceScopeForOwner(owner, currentOwner) {
     return "resource";
 }
 async function loadAgentsResourceForPrompt(owner, scope, maxChars = SHARED_PROMPT_RESOURCE_MAX_CHARS) {
+    let agents;
     try {
-        const agents = await resourceGetByPath(owner, "AGENTS.md");
-        if (!agents?.content?.trim())
-            return null;
-        return promptResourceBlock({
-            name: "AGENTS.md",
-            scope,
-            path: "AGENTS.md",
-            content: agents.content,
-            maxChars,
-        });
+        agents = await resourceGetByPath(owner, "AGENTS.md");
     }
-    catch {
-        return null;
+    catch (error) {
+        throw new Error(`Unable to read durable AGENTS.md instructions for ${scope} (${owner}). The run cannot safely continue without them.`, { cause: error });
     }
+    if (!agents?.content?.trim())
+        return null;
+    return promptResourceBlock({
+        name: "AGENTS.md",
+        scope,
+        path: "AGENTS.md",
+        content: agents.content,
+        maxChars,
+    });
 }
 async function loadInstructionResourcesForPrompt(owner, scope, maxChars = SHARED_PROMPT_RESOURCE_MAX_CHARS, summaryOnly = false) {
     try {
@@ -671,14 +672,14 @@ export async function loadResourcesForPrompt(owner, compact = false, selfAppId,
     // every app in the workspace, not copied into app scopes. They may come from
     // SQL, Dispatch, or local file mode.
     const workspaceAgents = await loadAgentsResourceForPrompt(WORKSPACE_OWNER, "workspace", promptResourceMaxChars);
-    addSection(workspaceAgents);
+    addSection(workspaceAgents, "required");
     addSections(await loadInstructionResourcesForPrompt(WORKSPACE_OWNER, "workspace-instruction", promptResourceMaxChars, compact));
     const organizationOwner = sharedResourceOwner(orgId);
     // 4. Legacy app-wide defaults. Existing deployments keep their seeded
     // shared guidance as an inherited fallback; organization writes never
     // mutate this owner.
     const appDefaultAgents = await loadAgentsResourceForPrompt(SHARED_OWNER, organizationOwner === SHARED_OWNER ? "shared" : "app-default", promptResourceMaxChars);
-    addSection(appDefaultAgents);
+    addSection(appDefaultAgents, "required");
     addSections(await loadInstructionResourcesForPrompt(SHARED_OWNER, organizationOwner === SHARED_OWNER
         ? "shared-instruction"
         : "app-default-instruction", promptResourceMaxChars, compact));
@@ -686,14 +687,14 @@ export async function loadResourcesForPrompt(owner, compact = false, selfAppId,
     // learnings that Slack/integration runs share with interactive app chat.
     if (organizationOwner !== SHARED_OWNER) {
         const organizationAgents = await loadAgentsResourceForPrompt(organizationOwner, "organization", promptResourceMaxChars);
-        addSection(organizationAgents);
+        addSection(organizationAgents, "required");
         addSections(await loadInstructionResourcesForPrompt(organizationOwner, "organization-instruction", promptResourceMaxChars, compact));
     }
     // 6. Personal SQL resources. These come last in the instruction stack so a
     // user can narrow or override organization/app and workspace defaults.
     if (owner !== SHARED_OWNER && owner !== WORKSPACE_OWNER) {
         const personalAgents = await loadAgentsResourceForPrompt(owner, "personal", promptResourceMaxChars);
-        addSection(personalAgents, "user");
+        addSection(personalAgents, "required");
         addSections(await loadInstructionResourcesForPrompt(owner, "personal-instruction", promptResourceMaxChars, compact), "user");
     }
     const resourceSkillsBlock = await loadResourceSkillsPromptBlock(owner, orgId);

package/dist/server/agent-chat-plugin.d.ts

@@ -16,6 +16,15 @@ export { loadResourcesForPrompt };
 export { _agentChatPromptSectionsForTests };
 export { buildPublicAgentA2ASkills };
 export { assembleA2AFinalResponse };
+export declare function buildLeanSystemPrompt(input: {
+    basePrompt: string;
+    resources: string;
+    additionalFramework?: string;
+    cacheSplit?: string;
+    extra?: string;
+    modelOverlay?: string;
+    runtimeContext?: string;
+}): string;
 export type { AgentChatPluginOptions };
 export { runA2AAgentLoop };
 export { runMCPAgentLoop };

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

@@ -125,6 +125,15 @@ export { loadResourcesForPrompt };
 export { _agentChatPromptSectionsForTests };
 export { buildPublicAgentA2ASkills };
 export { assembleA2AFinalResponse };
+export function buildLeanSystemPrompt(input) {
+    return (input.basePrompt +
+        (input.additionalFramework ?? "") +
+        (input.cacheSplit ?? "") +
+        input.resources +
+        (input.extra ?? "") +
+        (input.modelOverlay ?? "") +
+        (input.runtimeContext ?? ""));
+}
 export { runA2AAgentLoop };
 export { runMCPAgentLoop };
 export { createA2AEngineToolSurface };
@@ -2601,20 +2610,25 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     // so everything after it can change without a cache write.
                     if (leanPrompt) {
                         const leanRunPolicyPrompt = buildLeanRunPolicyPrompt(codeEditingSurfaceRestriction, prodCodeExecPromptNote);
+                        const resources = await loadResourcesForPrompt(owner, true, options?.appId, undefined, { disabledFrameworkGroups });
                         await emitContextXraySystemSections(event, {
                             frameworkPrompt: leanBasePrompt.slice(0, Math.max(0, leanBasePrompt.length - leanActionsPrompt.length)),
                             actionsPrompt: leanActionsPrompt,
                             additionalFramework: leanRunPolicyPrompt,
+                            resources,
                             extra,
                             modelOverlay,
                             runtimeContext,
                         });
-                        return setSystemPromptOnContext(leanBasePrompt +
-                            leanRunPolicyPrompt +
-                            SYSTEM_PROMPT_CACHE_SPLIT +
-                            extra +
-                            modelOverlay +
-                            runtimeContext);
+                        return setSystemPromptOnContext(buildLeanSystemPrompt({
+                            basePrompt: leanBasePrompt,
+                            additionalFramework: leanRunPolicyPrompt,
+                            cacheSplit: SYSTEM_PROMPT_CACHE_SPLIT,
+                            resources,
+                            extra,
+                            modelOverlay,
+                            runtimeContext,
+                        }));
                     }
                     const resources = await loadResourcesForPrompt(owner, lazyContext, options?.appId, undefined, { disabledFrameworkGroups });
                     // In lazy context mode, skip embedding the full schema. When database
@@ -2840,14 +2854,22 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                         // cached prompt prefix as possible. See the prod handler above
                         // for the same pattern.
                         if (leanPrompt) {
+                            const resources = await loadResourcesForPrompt(owner, true, options?.appId, undefined, { disabledFrameworkGroups });
                             await emitContextXraySystemSections(event, {
                                 frameworkPrompt: leanBasePrompt.slice(0, Math.max(0, leanBasePrompt.length - leanActionsPrompt.length)),
                                 actionsPrompt: leanActionsPrompt,
+                                resources,
                                 extra,
                                 modelOverlay,
                                 runtimeContext,
                             });
-                            return setSystemPromptOnContext(leanBasePrompt + extra + modelOverlay + runtimeContext);
+                            return setSystemPromptOnContext(buildLeanSystemPrompt({
+                                basePrompt: leanBasePrompt,
+                                resources,
+                                extra,
+                                modelOverlay,
+                                runtimeContext,
+                            }));
                         }
                         const resources = await loadResourcesForPrompt(owner, lazyContext, options?.appId, undefined, { disabledFrameworkGroups });
                         const schemaBlock = lazyContext || !databaseToolsEnabled

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
+    error?: undefined;
 }>>;
 export {};