@agent-native/core 0.141.6 → 0.144.0

package/dist/navigation/index.js

@@ -22,12 +22,22 @@ function normalizeLeadingPath(path) {
     return `/${trimmed.replace(/^\/+/, "").replace(/\/+$/, "")}`;
 }
 function normalizeTabId(tab) {
-    return tab
+    const normalized = tab
         .trim()
         .replace(/^#/, "")
         .toLowerCase()
         .replace(/['"]/g, "")
         .replace(/[\s_]+/g, "-");
+    if (normalized === "connections")
+        return "integrations";
+    if (normalized === "team" || normalized === "org")
+        return "organization";
+    if (normalized === "changelog" ||
+        normalized === "what-s-new" ||
+        normalized === "updates") {
+        return "whats-new";
+    }
+    return normalized;
 }
 function pathSegment(value) {
     return encodeURIComponent(value.trim().replace(/^\/+|\/+$/g, ""));
@@ -40,10 +50,11 @@ function resolveOpenPathRoute(route, params) {
 export function buildSettingsRoute(tab, basePath = STANDARD_APP_ROUTES.settings) {
     const path = normalizeLeadingPath(basePath);
     const normalizedTab = tab ? normalizeTabId(tab) : null;
-    if (!normalizedTab || normalizedTab === STANDARD_SETTINGS_TABS.general) {
-        return path;
-    }
-    return `${path}#${encodeURIComponent(normalizedTab)}`;
+    const segments = (normalizedTab || STANDARD_SETTINGS_TABS.general)
+        .split(":")
+        .map((segment) => pathSegment(segment))
+        .filter(Boolean);
+    return `${path}/${segments.join("/")}`;
 }
 export function buildTeamRoute(options = {}) {
     return options.teamInSettings

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;
 }>>;

package/dist/observability/routes.d.ts

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

package/dist/onboarding/app-profile.js

@@ -6,6 +6,14 @@ const LLM_CAPABILITY = {
     keySummary: "One model key: Anthropic, OpenAI, Gemini, Groq, Mistral, or Cohere",
     why: "The agent uses a language model to understand requests and produce answers.",
 };
+const DESIGN_SYSTEM_INTELLIGENCE_CAPABILITY = {
+    id: "design-system-intelligence",
+    label: "Design system intelligence",
+    required: false,
+    builderIncluded: true,
+    keySummary: "Builder Design System Intelligence",
+    why: "Uses your brand and design-system guidance to keep generated work on brand.",
+};
 const PROFILES = {
     analytics: {
         appId: "analytics",
@@ -42,6 +50,7 @@ const PROFILES = {
                 keySummary: "Gemini for video, or OpenAI / Gemini for images",
                 why: "These providers create the images and videos requested in the app.",
             },
+            DESIGN_SYSTEM_INTELLIGENCE_CAPABILITY,
             {
                 id: "file-storage",
                 label: "Media storage",
@@ -169,6 +178,7 @@ const PROFILES = {
         appName: "Design",
         capabilities: [
             LLM_CAPABILITY,
+            DESIGN_SYSTEM_INTELLIGENCE_CAPABILITY,
             {
                 id: "assets-library",
                 label: "Assets library",
@@ -313,6 +323,7 @@ const PROFILES = {
         appName: "Slides",
         capabilities: [
             LLM_CAPABILITY,
+            DESIGN_SYSTEM_INTELLIGENCE_CAPABILITY,
             {
                 id: "image-generation",
                 label: "Image generation",

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

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

@@ -75,9 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
+    id?: undefined;
     deleted?: undefined;
-    found?: undefined;
-    message?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,45 +88,46 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     }[];
     count: number;
     provider?: undefined;
+    found?: undefined;
     registered?: undefined;
-    id?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
+    id?: undefined;
     deleted?: undefined;
-    message?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
-    id?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
     deleted?: undefined;
-    message?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
-} | {
-    found?: undefined;
     message?: undefined;
-    providers?: undefined;
+} | {
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
+    found?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
     deleted?: undefined;
-    found?: undefined;
-    providers?: undefined;
     count?: undefined;
+    providers?: undefined;
     provider?: undefined;
+    found?: undefined;
     registered: boolean;
     id: string;
     label: string;

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

@@ -311,10 +311,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        message?: undefined;
         id?: undefined;
         provider?: undefined;
         deleted?: undefined;
-        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -325,45 +325,45 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        found?: undefined;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
+        message?: undefined;
+        count?: undefined;
         id?: undefined;
         deleted?: undefined;
-        count?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
+        message?: undefined;
+        count?: undefined;
         provider?: undefined;
         deleted?: undefined;
-        count?: undefined;
         providers?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
-        provider?: undefined;
-        found?: undefined;
+        message?: undefined;
         count?: undefined;
+        provider?: undefined;
         providers?: undefined;
+        found?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
+        count?: undefined;
         provider?: undefined;
         deleted?: undefined;
-        found?: undefined;
-        count?: undefined;
         providers?: undefined;
+        found?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/resources/store.js

@@ -1,6 +1,6 @@
 import crypto from "crypto";
 import { getDbExec, isPostgres, intType, retryOnDdlRace, } from "../db/client.js";
-import { ensureColumnExists, ensureTableExists } from "../db/ddl-guard.js";
+import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 import { canUseLocalWorkspaceResourcePath, deleteLocalWorkspaceResource, isLocalWorkspaceResourceId, isLocalWorkspaceResourcesEnabled, listLocalWorkspaceResources, localWorkspaceResourcePathFromId, readLocalWorkspaceResource, writeLocalWorkspaceResource, } from "../local-artifacts/index.js";
 import { getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
@@ -655,6 +655,20 @@ async function _doEnsureTable() {
         "updated_at",
         "expires_at",
     ]);
+    // `cleanupExpiredAgentScratchResources` filters on exactly these two columns
+    // and, without this, full-scans `resources` — a table shared by every
+    // template and read from agent discovery, docs, chat scratch and remote-agent
+    // manifests. Its 60s throttle is a module-scope timestamp that starts at 0 in
+    // a fresh isolate, so the first resource read after EVERY cold start pays
+    // that scan. Idempotent and dialect-agnostic, per the `performance` skill.
+    await ensureIndexExists("resources_visibility_expires_idx", `CREATE INDEX IF NOT EXISTS resources_visibility_expires_idx ON resources (visibility, expires_at)`).catch((err) => {
+        // An index is an optimization, not a correctness requirement: a
+        // concurrent creator or a permissions edge must not fail table init and
+        // take the app down with it. The scan it avoids is slow, not wrong — but
+        // say so, because "silently slow forever" is the outcome nobody notices.
+        // coercion-ok: absence of an index degrades latency, never correctness
+        console.warn("[resources] could not ensure resources_visibility_expires_idx; scratch cleanup will full-scan:", err?.message ?? err);
+    });
     // Seed default shared resources if they don't exist (INSERT OR IGNORE to avoid race conditions)
     const now = Date.now();
     const seedSql = isPostgres()

package/dist/scripts/call-agent.js

@@ -90,6 +90,23 @@ function terminalTaskError(value) {
             : {}),
     };
 }
+/**
+ * A delegated failure must be an error at the caller's tool boundary. Returning
+ * an `Error: ...` string makes the production agent treat the failed call as a
+ * successful tool result, so it can spend the rest of its turn retrying or
+ * changing arguments while the real failure remains invisible to the loop
+ * breaker.
+ */
+class A2AInvocationError extends Error {
+    taskId;
+    errorCode;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "A2AInvocationError";
+        this.taskId = options.taskId;
+        this.errorCode = options.errorCode;
+    }
+}
 function buildMessageIdempotencyKey(originatingTurnId, target, exactMessage) {
     if (!originatingTurnId)
         return undefined;
@@ -363,6 +380,7 @@ export async function run(args, context, selfAppId) {
                     status: terminalStatus,
                     agentCallId,
                     durationMs: Date.now() - startedAt,
+                    ...(terminalCode ? { terminalCode } : {}),
                 });
             }
         }
@@ -534,6 +552,13 @@ export async function run(args, context, selfAppId) {
             let lastProgressEmitAt = callStartedAt;
             let lastActivitySequence = -1;
             const onRemotePollUpdate = (task) => {
+                // Capture the remote task id on every poll, not only on the timeout and
+                // error branches that used to set it. Without this a call that SUCCEEDS
+                // slowly carries no task id, so "why did this one take four minutes?"
+                // cannot be traced into the receiving app's own task record — which is
+                // the question worth asking about a slow cross-app call.
+                if (task?.id)
+                    invocationTaskId = task.id;
                 const state = task?.status?.state;
                 const parts = task.status?.message?.parts;
                 const snapshot = Array.isArray(parts)
@@ -686,7 +711,16 @@ export async function run(args, context, selfAppId) {
                 agentCallId,
                 ...(invocationTaskId ? { taskId: invocationTaskId } : {}),
                 durationMs: Date.now() - callStartedAt,
+                ...(invocationTerminalCode
+                    ? { terminalCode: invocationTerminalCode }
+                    : {}),
             });
+            if (terminalStatus === "error") {
+                throw new A2AInvocationError(responseText || `Error: The ${agent.name} agent returned no result.`, {
+                    taskId: invocationTaskId,
+                    errorCode: invocationTerminalCode,
+                });
+            }
             return (responseText || `Error: The ${agent.name} agent returned no result.`);
         }
         // No context — use the async + poll call so we don't get cut off at the
@@ -734,6 +768,8 @@ export async function run(args, context, selfAppId) {
         return expanded;
     }
     catch (err) {
+        if (err instanceof A2AInvocationError)
+            throw err;
         const msg = err?.message ?? String(err);
         const credentialMessage = formatDownstreamLlmCredentialFailure(agent.name, err);
         if (credentialMessage)
@@ -749,10 +785,13 @@ export async function run(args, context, selfAppId) {
             invocationStatus = "error";
             invocationTaskId = terminal.taskId;
             invocationTerminalCode = terminal.errorCode ?? terminal.state;
-            return (`Error calling ${agent.name}: remote task ${terminal.state}` +
+            throw new A2AInvocationError(`Error calling ${agent.name}: remote task ${terminal.state}` +
                 (terminal.errorCode ? ` (${terminal.errorCode})` : "") +
                 (terminal.taskId ? ` [taskId: ${terminal.taskId}]` : "") +
-                (terminal.responseText ? `: ${terminal.responseText}` : ""));
+                (terminal.responseText ? `: ${terminal.responseText}` : ""), {
+                taskId: terminal.taskId,
+                errorCode: terminal.errorCode ?? terminal.state,
+            });
         }
         const timeoutTaskId = getA2ATaskTimeoutTaskId(err);
         if (timeoutTaskId) {
@@ -766,11 +805,13 @@ export async function run(args, context, selfAppId) {
         if (/timeout|did not complete|Inactivity|504/i.test(msg)) {
             invocationStatus = "error";
             invocationTerminalCode = "timeout_without_task";
-            return `Error calling ${agent.name}: the remote request timed out before a task id could be recovered.`;
+            throw new A2AInvocationError(`Error calling ${agent.name}: the remote request timed out before a task id could be recovered.`, { errorCode: "timeout_without_task" });
         }
         invocationStatus = "error";
         invocationTerminalCode = "call_failed";
-        return `Error calling ${agent.name}: ${msg}`;
+        throw new A2AInvocationError(`Error calling ${agent.name}: ${msg}`, {
+            errorCode: "call_failed",
+        });
     }
     finally {
         trackA2AInvocation({

package/dist/secrets/routes.d.ts

@@ -37,17 +37,17 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     ok?: undefined;
     status?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
     ok?: undefined;
     error: string;
     removed?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
@@ -58,13 +58,13 @@ export declare function createTestSecretHandler(): import("h3").EventHandlerWith
     error: string;
     note?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

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

@@ -75,7 +75,7 @@ type A2AAgentLoopRunner = typeof runAgentLoopDirectWithSoftTimeout;
 export declare const DEFAULT_DELEGATED_MAX_ITERATIONS = 80;
 export declare const DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKENS = 750000;
 export declare const DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS = 20000;
-export declare const DELEGATED_AGENT_EXECUTION_CONTRACT = "\n<delegated-agent-contract>\nThis request was delegated by another app. You are the specialist owner of the work.\n- Interpret the caller's natural-language objective using your own instructions, skills, data dictionary, credentials, and tools. Choose providers, schemas, queries, and joins here; never ask the caller to invent SQL or source-specific implementation details for you.\n- Finish the objective autonomously in this delegated turn whenever a safe, reasonable default exists. Do not bounce the work back with UI-navigation requests, implementation questions, or intermediate status. Ask for input only when authorization, missing credentials, or a consequential user choice truly blocks progress.\n- When evidence is incomplete, return the best grounded partial answer with explicit coverage gaps instead of refusing or asking the caller to choose your source, filter, dashboard, or workflow.\n- Minimize round trips. Filter, join, aggregate, paginate, stage, and reduce large datasets inside your own tools rather than returning raw records or transcripts.\n- Return a concise caller-ready result with the answer, source and coverage details, relevant counts or IDs, caveats/partial gaps, and exact artifact URLs. Do not return tool transcripts or large raw payloads.\n</delegated-agent-contract>";
+export declare const DELEGATED_AGENT_EXECUTION_CONTRACT = "\n<delegated-agent-contract>\nThis request was delegated by another app. You are the specialist owner of the work.\n- Interpret the caller's natural-language objective using your own instructions, skills, data dictionary, credentials, and tools. Choose providers, schemas, queries, and joins here; never ask the caller to invent SQL or source-specific implementation details for you.\n- Finish the objective autonomously in this delegated turn whenever a safe, reasonable default exists. Do not bounce the work back with UI-navigation requests, implementation questions, or intermediate status. Ask for input only when authorization, missing credentials, or a consequential user choice truly blocks progress.\n- When evidence is incomplete, return the best grounded partial answer with explicit coverage gaps instead of refusing or asking the caller to choose your source, filter, dashboard, or workflow.\n- Reach for your own registered actions first and by name. They are the same actions this app's interactive chat uses and are almost always the shortest path to the answer. Do not rediscover your own capabilities by exploring, and never use a shell, filesystem, or code-execution tool to do what one of your actions already does \u2014 that is the difference between answering in seconds and answering in minutes.\n- Minimize round trips. Filter, join, aggregate, paginate, stage, and reduce large datasets inside your own tools rather than returning raw records or transcripts.\n- Return a concise caller-ready result with the answer, source and coverage details, relevant counts or IDs, caveats/partial gaps, and exact artifact URLs. Do not return tool transcripts or large raw payloads.\n</delegated-agent-contract>";
 export interface DelegatedAgentLoopTelemetry {
     runId: string;
     threadId: string | null;

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

@@ -4,6 +4,7 @@ import { collectFinalResponseTextFromAgentEvents } from "../../a2a/response-text
 import { resolveMainChatMaxOutputTokens } from "../../agent/engine/output-tokens.js";
 import { filterInitialEngineTools, resolveAgentRequestReasoningEffort, } from "../../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../../agent/run-loop-with-resume.js";
+import { resolveRunSoftTimeoutMs } from "../../agent/run-manager.js";
 import { isAuthenticatedReadAction, isAutoReadExcludedActionName, } from "../../mcp/build-server.js";
 import { withConfiguredAppBasePath } from "../app-base-path.js";
 // ---------------------------------------------------------------------------
@@ -255,12 +256,44 @@ function formatA2ATerminalError(event) {
 export const DEFAULT_DELEGATED_MAX_ITERATIONS = 80;
 export const DEFAULT_DELEGATED_MAX_RUN_INPUT_TOKENS = 750_000;
 export const DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS = 20_000;
+/**
+ * A sentence naming the wall clock this delegated step actually gets, or "" when
+ * there is no enforced budget (local dev returns 0 from the resolver).
+ *
+ * "I ran out of time before finishing this step" was 39% of all failed inbound
+ * A2A tasks in one measured week, clustered at 35-46s against a 40s foreground
+ * serverless wall. The callee was never told that wall exists: it is handed a
+ * nominal 80 iterations and 750k tokens and plans accordingly, while production
+ * iterations measure ~34s each — so a foreground chunk affords roughly one.
+ *
+ * The clock is already enforced correctly; a second, cruder cap on iterations
+ * would only waste budget. What was missing is that the agent could not see it.
+ * An agent that knows it has forty seconds scopes to forty seconds.
+ */
+function delegatedTimeBudgetNote(runSoftTimeoutMs, backgroundFunction) {
+    const softTimeoutMs = resolveRunSoftTimeoutMs(runSoftTimeoutMs, {
+        useHostedDefault: true,
+        backgroundFunction,
+    });
+    if (!Number.isFinite(softTimeoutMs) || softTimeoutMs <= 0)
+        return "";
+    const seconds = Math.max(1, Math.round(softTimeoutMs / 1000));
+    return (`\n<delegated-time-budget>\n` +
+        `This step is cut off after about ${seconds} seconds. Scope the work to fit it. ` +
+        `Prefer one decisive action over exploring, and note that a single tool call plus a model ` +
+        `response commonly takes tens of seconds — so plan on completing very few steps, not many. ` +
+        `If the objective cannot be finished in that window, return the best grounded partial answer ` +
+        `and say what is missing. Do not begin work you cannot finish, and do not treat this budget ` +
+        `as a reason to skip verifying what you do report.\n` +
+        `</delegated-time-budget>`);
+}
 export const DELEGATED_AGENT_EXECUTION_CONTRACT = `
 <delegated-agent-contract>
 This request was delegated by another app. You are the specialist owner of the work.
 - Interpret the caller's natural-language objective using your own instructions, skills, data dictionary, credentials, and tools. Choose providers, schemas, queries, and joins here; never ask the caller to invent SQL or source-specific implementation details for you.
 - Finish the objective autonomously in this delegated turn whenever a safe, reasonable default exists. Do not bounce the work back with UI-navigation requests, implementation questions, or intermediate status. Ask for input only when authorization, missing credentials, or a consequential user choice truly blocks progress.
 - When evidence is incomplete, return the best grounded partial answer with explicit coverage gaps instead of refusing or asking the caller to choose your source, filter, dashboard, or workflow.
+- Reach for your own registered actions first and by name. They are the same actions this app's interactive chat uses and are almost always the shortest path to the answer. Do not rediscover your own capabilities by exploring, and never use a shell, filesystem, or code-execution tool to do what one of your actions already does — that is the difference between answering in seconds and answering in minutes.
 - Minimize round trips. Filter, join, aggregate, paginate, stage, and reduce large datasets inside your own tools rather than returning raw records or transcripts.
 - Return a concise caller-ready result with the answer, source and coverage details, relevant counts or IDs, caveats/partial gaps, and exact artifact URLs. Do not return tool transcripts or large raw payloads.
 </delegated-agent-contract>`;
@@ -271,7 +304,9 @@ async function runDelegatedAgentLoop(runOptions, pluginOptions, timeoutOptions,
     const delegatedHardToolResultCap = policy?.maxToolResultChars ?? DEFAULT_DELEGATED_MAX_TOOL_RESULT_CHARS;
     const resolvedRunOptions = {
         ...runOptions,
-        systemPrompt: runOptions.systemPrompt + DELEGATED_AGENT_EXECUTION_CONTRACT,
+        systemPrompt: runOptions.systemPrompt +
+            DELEGATED_AGENT_EXECUTION_CONTRACT +
+            delegatedTimeBudgetNote(pluginOptions.runSoftTimeoutMs, timeoutOptions?.backgroundFunction === true),
         // Delegated runs resolve their own model and do not pass through the
         // interactive request handler's output-token setup. Use the same
         // model-aware headroom here so reasoning models (notably GPT-5.x) do

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

@@ -1237,17 +1237,38 @@ export function createAgentChatPlugin(options) {
                         ? ""
                         : await buildSchemaBlock(owner, databaseToolsMode);
                     const extra = await resolveExtraContext(context.event, owner);
+                    const a2aStoredModel = await getStoredModelForEngine(a2aEngine, {
+                        appId: options?.appId,
+                    });
+                    // Preference only, and last before the default: an app that pinned
+                    // a model keeps it. Read separately from the correlation sanitizer
+                    // below so it stays out of every identity/access path.
+                    const a2aCallerModelHint = sanitizeA2ACorrelationMetadata(context.metadata).callerModel;
                     const model = resolveDelegatedRunModel(a2aEngine, {
                         explicitModel: options?.model,
-                        storedModel: await getStoredModelForEngine(a2aEngine, {
-                            appId: options?.appId,
-                        }),
-                        // Preference only, and last before the default: an app that pinned
-                        // a model keeps it. Read separately from the correlation sanitizer
-                        // below so it stays out of every identity/access path.
-                        callerModelHint: sanitizeA2ACorrelationMetadata(context.metadata)
-                            .callerModel,
+                        storedModel: a2aStoredModel,
+                        callerModelHint: a2aCallerModelHint,
                     });
+                    // The interactive path logs its model AND where the model came from;
+                    // this path logged neither, so "the same app answers me in 27s but
+                    // takes 5 minutes when another app asks" had no way to be checked.
+                    // The usual answer is right here: the chat model picker is a
+                    // browser-local preference, so it reaches an interactive turn as the
+                    // highest-precedence request model and never reaches this path at
+                    // all — a delegated turn falls through to the app's stored model or
+                    // the engine default, which can be a different, weaker model.
+                    console.log(`[a2a] resolved engine=${a2aEngine.name} model=${model} ` +
+                        // A hint the callee's engine does not offer is dropped, so the
+                        // label is derived from what actually won — reporting
+                        // "caller-hint" for a rejected hint would send the next person
+                        // debugging this in exactly the wrong direction.
+                        `modelSource=${options?.model
+                            ? "configured"
+                            : a2aStoredModel
+                                ? "stored"
+                                : a2aCallerModelHint && model === a2aCallerModelHint
+                                    ? "caller-hint"
+                                    : "default"} callerHint=${a2aCallerModelHint ?? "(none)"} appId=${options?.appId ?? "(none)"}`);
                     if (a2aRunContext) {
                         a2aRunContext.engine = a2aEngine;
                         a2aRunContext.model = model;

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 {};