@agent-native/core 0.84.20 → 0.84.22

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -944,6 +944,8 @@ function incrementalActionGuidance(tool: string): string | undefined {
     case "generate-design":
     case "update-design":
       return 'if an existing design file or snapshot is already in history, especially after a Design variant pick, stop retrying `generate-design`: call `get-design-snapshot` for the selected file, then call `edit-design` once on that same `fileId` (`mode: "replace-file"` for a compact full-file replacement, or search/replace for smaller edits). Use `generate-design` only for a brand-new compact first file when no target file exists yet';
+    case "edit-design":
+      return "retry with a smaller `edit-design` payload: prefer a handful of exact search/replace edits against the already-snapshotted file, and avoid `replacementContent` for a huge full-file rewrite. If a selected variant needs expansion, upgrade the highest-value visible sections first, save once, and summarize any remaining refinements";
     case "present-design-variants":
       return 'call `present-design-variants` with concise labels, descriptions, accent colors, and feature bullets; omit large `content` HTML when needed so the action can render compact representative screens. After the user picks a direction, delete unchosen screens, snapshot the selected `fileId`, and refine that same file with `edit-design` (`mode: "replace-file"` for placeholder expansion). Do not call `generate-design` after the variant pick';
     case "create-visual-plan":
@@ -980,7 +982,9 @@ function autoContinueMessage(signal: AgentAutoContinueSignal): string {
   // toward a compact first version it can actually finish in a single run, then
   // incremental refinements — never re-streaming the same oversized payload.
   const cutoffPreparingAction =
-    signal.reason === "run_timeout" || signal.reason === "stream_ended";
+    signal.reason === "run_timeout" ||
+    signal.reason === "stream_ended" ||
+    signal.reason === "no_progress";
   let actionInputNote = "";
   if (cutoffPreparingAction && tool) {
     const guidance = incrementalActionGuidance(tool);

package/corpus/core/src/client/guided-questions.tsx

@@ -150,6 +150,16 @@ export function formatGuidedAnswersForAgent(
     .join("\n");
 }
 
+function defaultGuidedSubmitContext(formattedAnswers: string): string {
+  return [
+    "The user answered the guided questions.",
+    "Use the selected option values below as authoritative. If an answer includes exact ids, file names, or action instructions, follow those exact details instead of inferring them.",
+    "",
+    "Answers:",
+    formattedAnswers,
+  ].join("\n");
+}
+
 /** A single option for {@link askUserQuestion}. Mirrors the agent `ask-question`
  *  tool and Claude Code's AskUserQuestion option shape. */
 export interface AskUserQuestionOption {
@@ -1080,12 +1090,7 @@ export function useGuidedQuestionFlow({
       const resolvedSubmitMessage = payload?.submitMessage ?? submitMessage;
       const context =
         buildSubmitContext?.({ answers, formattedAnswers }) ??
-        [
-          "The user answered the pre-generation questions.",
-          "",
-          "Answers:",
-          formattedAnswers,
-        ].join("\n");
+        defaultGuidedSubmitContext(formattedAnswers);
       sendToAgentChat({
         message: resolvedSubmitMessage,
         context,

package/corpus/core/src/client/i18n.tsx

@@ -674,7 +674,7 @@ export function LanguagePicker({
   className?: string;
   includeSystem?: boolean;
   label?: string;
-  variant?: "select" | "icon";
+  variant?: "select" | "icon" | "ghost-icon";
 }) {
   const { locale, preference, setPreference } = useLocale();
   const [open, setOpen] = useState(false);
@@ -716,10 +716,15 @@ export function LanguagePicker({
             title={triggerLabel}
             data-language-picker-trigger
             className={cn(
-              "shrink-0 rounded-md border border-border bg-background text-foreground outline-none transition-colors hover:border-foreground/30 hover:bg-accent/40 hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 data-[state=open]:border-foreground/30 data-[state=open]:bg-accent/40",
+              "shrink-0 rounded-md outline-none transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+              variant === "ghost-icon"
+                ? "flex h-9 w-9 items-center justify-center text-muted-foreground hover:bg-accent hover:text-foreground data-[state=open]:bg-accent data-[state=open]:text-foreground"
+                : "border border-border bg-background text-foreground hover:border-foreground/30 hover:bg-accent/40 hover:text-foreground data-[state=open]:border-foreground/30 data-[state=open]:bg-accent/40",
               variant === "icon"
                 ? "flex h-8 w-8 items-center justify-center"
-                : "flex h-9 w-full items-center justify-between gap-2 px-3 text-start text-sm",
+                : variant === "select"
+                  ? "flex h-9 w-full items-center justify-between gap-2 px-3 text-start text-sm"
+                  : null,
             )}
           >
             <span className="flex min-w-0 items-center gap-2">
@@ -740,12 +745,12 @@ export function LanguagePicker({
         </PopoverPrimitive.Trigger>
         <PopoverPrimitive.Portal>
           <PopoverPrimitive.Content
-            align={variant === "icon" ? "end" : "start"}
+            align={variant === "select" ? "start" : "end"}
             sideOffset={6}
             role="menu"
             className={cn(
               "z-[9999] max-h-[min(20rem,var(--radix-popover-content-available-height))] overflow-y-auto rounded-lg border border-border bg-popover p-1 text-popover-foreground shadow-lg outline-none will-change-[transform,opacity] data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:duration-100 data-[state=open]:duration-150 data-[state=closed]:ease-in data-[state=open]:ease-out data-[side=bottom]:slide-in-from-top-1 data-[side=left]:slide-in-from-right-1 data-[side=right]:slide-in-from-left-1 data-[side=top]:slide-in-from-bottom-1",
-              variant === "icon"
+              variant === "icon" || variant === "ghost-icon"
                 ? "min-w-56"
                 : "w-[min(20rem,calc(100vw-2rem))] min-w-[var(--radix-popover-trigger-width)]",
             )}

package/corpus/core/src/client/sse-event-processor.ts

@@ -49,6 +49,7 @@ export interface SSEEvent {
   /** Server-assigned call identifier emitted on tool_start / tool_done events. */
   id?: string;
   label?: string;
+  progressBytes?: number;
   input?: Record<string, string>;
   result?: string;
   isError?: boolean;
@@ -144,9 +145,58 @@ export class AgentAutoContinueSignal extends Error {
 }
 
 export const SSE_NO_PROGRESS_TIMEOUT_MS = 75_000;
+export const SSE_ACTION_PREPARATION_STALL_TIMEOUT_MS = 90_000;
 
 type ActivityTrailEntry = AgentActivityTrailEntry;
 
+type PreparingActionState = {
+  tool?: string;
+  startedAt?: number;
+  /**
+   * Timestamp of the last real streaming progress for the in-preparation tool
+   * input. The server emits a throttled `activity` heartbeat per
+   * `tool-input-delta`, so while the model is actively streaming a (possibly
+   * very large) tool argument this keeps advancing. The stall guard measures
+   * silence from HERE — not from `startedAt` — so a legitimately large, still-
+   * streaming input is never aborted; only genuine silence (keepalive-only, no
+   * further deltas) can trip it.
+   */
+  lastProgressAt?: number;
+};
+
+function formatProgressBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function activityProgressBytes(ev: SSEEvent): number | undefined {
+  return typeof ev.progressBytes === "number" &&
+    Number.isFinite(ev.progressBytes) &&
+    ev.progressBytes >= 0
+    ? Math.floor(ev.progressBytes)
+    : undefined;
+}
+
+function isPreparingActionActivity(ev: SSEEvent): boolean {
+  if (ev.type !== "activity") return false;
+  const label = (ev.label ?? "").trim().toLowerCase();
+  return label.startsWith("preparing ") && label.includes(" action");
+}
+
+function baseActivityLabel(ev: SSEEvent, tool?: string): string {
+  return humanizeToolLabelText(ev.label ?? "Working", tool);
+}
+
+function visibleActivityLabel(ev: SSEEvent, tool?: string): string {
+  const label = baseActivityLabel(ev, tool);
+  const progressBytes = activityProgressBytes(ev);
+  if (progressBytes === undefined || !isPreparingActionActivity(ev)) {
+    return label;
+  }
+  return `${label} (${formatProgressBytes(progressBytes)} streamed)`;
+}
+
 function findPendingToolCallIndex(
   content: ContentPart[],
   toolName: string,
@@ -199,6 +249,53 @@ function appendActivityTrail(
   }
 }
 
+function updatePreparingActionState(
+  state: PreparingActionState,
+  ev: SSEEvent,
+  now: number,
+) {
+  if (ev.type === "activity" && isPreparingActionActivity(ev)) {
+    const tool = ev.tool?.trim() || undefined;
+    if (!tool) return;
+    if (state.tool !== tool || state.startedAt === undefined) {
+      state.tool = tool;
+      state.startedAt = now;
+    }
+    // Every tool-input activity is a throttled proof the model is still
+    // streaming this action's argument. Treat it as progress so large inputs
+    // that take many seconds/minutes to stream are NOT flagged as stalled.
+    state.lastProgressAt = now;
+    return;
+  }
+
+  if (
+    ev.type === "clear" ||
+    ev.type === "text" ||
+    ev.type === "tool_start" ||
+    ev.type === "tool_done" ||
+    ev.type === "done" ||
+    ev.type === "error" ||
+    ev.type === "missing_api_key"
+  ) {
+    state.tool = undefined;
+    state.startedAt = undefined;
+    state.lastProgressAt = undefined;
+  }
+}
+
+function hasStalledPreparingAction(state: PreparingActionState, now: number) {
+  // Fire only when a tool input has gone SILENT — no further streaming deltas
+  // for the whole window — never merely because a large input has been
+  // streaming for a long time. `lastProgressAt` advances on every delta
+  // heartbeat, so an actively-streaming large output keeps resetting this and
+  // survives; a genuinely stuck prep (keepalive-only, no deltas) trips it.
+  return (
+    state.tool !== undefined &&
+    state.lastProgressAt !== undefined &&
+    now - state.lastProgressAt >= SSE_ACTION_PREPARATION_STALL_TIMEOUT_MS
+  );
+}
+
 async function readChunkWithProgressTimeout(
   reader: ReadableStreamDefaultReader<Uint8Array>,
   lastMeaningfulEventAt: number,
@@ -491,7 +588,7 @@ export function processEvent(
 
   if (ev.type === "activity") {
     const tool = ev.tool?.trim() || undefined;
-    const label = humanizeToolLabelText(ev.label ?? "Working", tool);
+    const label = visibleActivityLabel(ev, tool);
     if (typeof window !== "undefined") {
       window.dispatchEvent(
         new CustomEvent("agent-chat:activity", {
@@ -941,6 +1038,7 @@ export async function* readSSEStream(
   let buf = "";
   let lastMeaningfulEventAt = Date.now();
   const activityTrail: ActivityTrailEntry[] = [];
+  const preparingActionState: PreparingActionState = {};
   const processEventState: ProcessEventState = {
     completedToolsAfterLastAssistantText: new Set(),
   };
@@ -1000,7 +1098,9 @@ export async function* readSSEStream(
           continue;
         }
         sawDataEvent = true;
-        lastMeaningfulEventAt = Date.now();
+        const now = Date.now();
+        lastMeaningfulEventAt = now;
+        updatePreparingActionState(preparingActionState, ev, now);
 
         // Track sequence number for reconnection
         if (ev.seq !== undefined && onSeq) {
@@ -1012,7 +1112,7 @@ export async function* readSSEStream(
         } else if (ev.type === "activity") {
           const tool = ev.tool?.trim() || undefined;
           appendActivityTrail(activityTrail, {
-            label: humanizeToolLabelText(ev.label ?? "Working", tool),
+            label: baseActivityLabel(ev, tool),
             ...(tool ? { tool } : {}),
           });
         } else if (ev.type === "tool_start") {
@@ -1039,6 +1139,12 @@ export async function* readSSEStream(
         );
 
         if (result) yield withStreamMetadata(result);
+        if (hasStalledPreparingAction(preparingActionState, Date.now())) {
+          throw new AgentAutoContinueSignal({
+            reason: "no_progress",
+            activityTrail: [...activityTrail],
+          });
+        }
         if (action === "auto_continue") {
           throw new AgentAutoContinueSignal(
             autoContinue
@@ -1099,6 +1205,8 @@ export async function readSSEStreamRaw(
   const decoder = new TextDecoder();
   let buf = "";
   let lastMeaningfulEventAt = Date.now();
+  const activityTrail: ActivityTrailEntry[] = [];
+  const preparingActionState: PreparingActionState = {};
   const processEventState: ProcessEventState = {
     completedToolsAfterLastAssistantText: new Set(),
   };
@@ -1134,12 +1242,37 @@ export async function readSSEStreamRaw(
           continue;
         }
         sawDataEvent = true;
-        lastMeaningfulEventAt = Date.now();
+        const now = Date.now();
+        lastMeaningfulEventAt = now;
+        updatePreparingActionState(preparingActionState, ev, now);
 
         if (ev.seq !== undefined && onSeq) {
           onSeq(ev.seq);
         }
 
+        if (ev.type === "clear") {
+          activityTrail.length = 0;
+        } else if (ev.type === "activity") {
+          const tool = ev.tool?.trim() || undefined;
+          appendActivityTrail(activityTrail, {
+            label: baseActivityLabel(ev, tool),
+            ...(tool ? { tool } : {}),
+          });
+        } else if (ev.type === "tool_start") {
+          const tool = ev.tool ?? "unknown";
+          appendActivityTrail(activityTrail, {
+            label: runningToolLabel(tool),
+            tool,
+          });
+        } else if (ev.type === "tool_done") {
+          const tool = ev.tool ?? "unknown";
+          for (let i = activityTrail.length - 1; i >= 0; i--) {
+            if (activityTrail[i]?.tool === tool) {
+              activityTrail.splice(i, 1);
+            }
+          }
+        }
+
         const { action, autoContinue } = processEvent(
           ev,
           content,
@@ -1159,9 +1292,18 @@ export async function readSSEStreamRaw(
         if (action === "auto_continue") {
           onUpdate([...content]);
           throw new AgentAutoContinueSignal(
-            autoContinue ?? { reason: "stream_ended" },
+            autoContinue
+              ? { ...autoContinue, activityTrail: [...activityTrail] }
+              : { reason: "stream_ended", activityTrail: [...activityTrail] },
           );
         }
+        if (hasStalledPreparingAction(preparingActionState, Date.now())) {
+          onUpdate([...content]);
+          throw new AgentAutoContinueSignal({
+            reason: "no_progress",
+            activityTrail: [...activityTrail],
+          });
+        }
         if (
           action === "done" ||
           action === "error" ||

package/corpus/core/src/client/tool-display.ts

@@ -1,6 +1,14 @@
+const TOOL_DISPLAY_NAMES: Record<string, string> = {
+  "delete-file": "delete screen",
+  "get-design-snapshot": "get screen snapshot",
+  "edit-design": "edit screen",
+};
+
 export function humanizeToolName(toolName: string | undefined): string {
   const raw = (toolName ?? "").trim();
   if (!raw) return "tool";
+  const displayName = TOOL_DISPLAY_NAMES[raw];
+  if (displayName) return displayName;
 
   let name = raw;
   if (name.startsWith("mcp__")) {

package/corpus/core/src/file-upload/builder.ts

@@ -27,6 +27,15 @@ function makeBody(bytes: Uint8Array, mimeType: string): BodyInit {
     : (bytes as unknown as BodyInit);
 }
 
+function shouldUseSignedUrlUpload(
+  bytes: Uint8Array,
+  mimeType: string,
+): boolean {
+  return (
+    bytes.byteLength > LARGE_FILE_THRESHOLD_BYTES || /^video\//i.test(mimeType)
+  );
+}
+
 function fetchWithTimeout(url: string, init: RequestInit): Promise<Response> {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), UPLOAD_TIMEOUT_MS);
@@ -35,6 +44,11 @@ function fetchWithTimeout(url: string, init: RequestInit): Promise<Response> {
   );
 }
 
+function setSkipCompressionQueryParams(url: URL): void {
+  url.searchParams.set("skipCompressionWait", "true");
+  url.searchParams.set("skipCompression", "true");
+}
+
 async function assertOk(res: Response, label: string): Promise<void> {
   if (!res.ok) {
     const body = await res.text().catch(() => "");
@@ -86,6 +100,7 @@ async function uploadLargeFileViaSignedUrl(
     privateKey,
     assetId,
     input.filename,
+    { skipCompressionWait: input.skipCompressionWait },
   );
   console.log(`[builder-upload] done [${assetId}]: ${url}`);
   return { url, id, provider: "builder" };
@@ -139,19 +154,21 @@ async function completeBuilderUpload(
   privateKey: string,
   assetId: string,
   filename: string | undefined,
+  options?: { skipCompressionWait?: boolean },
 ): Promise<{ url: string; id?: string }> {
   const host = builderUploadHost();
-  const res = await fetchWithTimeout(
-    new URL("/api/v1/upload/complete", host).toString(),
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${privateKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ assetId, name: filename }),
+  const url = new URL("/api/v1/upload/complete", host);
+  if (options?.skipCompressionWait) {
+    setSkipCompressionQueryParams(url);
+  }
+  const res = await fetchWithTimeout(url.toString(), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${privateKey}`,
+      "Content-Type": "application/json",
     },
-  );
+    body: JSON.stringify({ assetId, name: filename }),
+  });
   await assertOk(res, "Builder.io upload complete failed");
   const json = (await res.json()) as { url?: string; id?: string };
   if (!json.url) throw new Error("Builder.io upload/complete returned no URL");
@@ -204,7 +221,8 @@ export const builderFileUploadProvider: FileUploadProvider = {
   id: "builder",
   name: "Builder.io",
   isConfigured: () => !!process.env.BUILDER_PRIVATE_KEY,
-  upload: async ({ data, filename, mimeType }: FileUploadInput) => {
+  upload: async (input: FileUploadInput) => {
+    const { data, filename, mimeType } = input;
     const { resolveBuilderPrivateKey } =
       await import("../server/credential-provider.js");
     const privateKey = await resolveBuilderPrivateKey();
@@ -226,9 +244,9 @@ export const builderFileUploadProvider: FileUploadProvider = {
       data instanceof Uint8Array ? data : new Uint8Array(data as any);
     const mb = (bytes.byteLength / (1024 * 1024)).toFixed(1);
 
-    if (bytes.byteLength > LARGE_FILE_THRESHOLD_BYTES) {
+    if (shouldUseSignedUrlUpload(bytes, bareMimeType)) {
       return uploadLargeFileViaSignedUrl(
-        { data, filename, mimeType },
+        input,
         privateKey,
         bareMimeType,
         bytes,
@@ -241,6 +259,9 @@ export const builderFileUploadProvider: FileUploadProvider = {
 
     const url = new URL("/api/v1/upload", builderUploadHost());
     if (filename) url.searchParams.set("name", filename);
+    if (input.skipCompressionWait) {
+      setSkipCompressionQueryParams(url);
+    }
 
     const response = await uploadSmallFile(url, {
       method: "POST",
@@ -366,7 +387,7 @@ export const builderFileUploadProvider: FileUploadProvider = {
         : new Error("GCS PUT failed after retries");
     },
 
-    async completeSession(session, filename) {
+    async completeSession(session, filename, options) {
       const { resolveBuilderPrivateKey } =
         await import("../server/credential-provider.js");
       const privateKey = await resolveBuilderPrivateKey();
@@ -378,6 +399,11 @@ export const builderFileUploadProvider: FileUploadProvider = {
         privateKey,
         assetId,
         filename,
+        {
+          skipCompressionWait:
+            options?.skipCompressionWait ||
+            session.meta.skipCompressionWait === true,
+        },
       );
       console.log(`[builder-resumable] upload complete: ${url}`);
       return url;

package/corpus/core/src/file-upload/types.ts

@@ -16,6 +16,8 @@ export interface FileUploadInput {
   mimeType?: string;
   /** Optional owner email for per-user scoping in fallback storage. */
   ownerEmail?: string;
+  /** Builder.io upload hint: return after asset registration instead of waiting for server-side compression. */
+  skipCompressionWait?: boolean;
 }
 
 export interface FileUploadResult {
@@ -77,6 +79,7 @@ export interface FileUploadProvider {
     completeSession(
       session: ResumableUploadSession,
       filename: string,
+      options?: { skipCompressionWait?: boolean },
     ): Promise<string>;
   };
 }

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -150,11 +150,11 @@ async function processClaimedContinuation(
     return;
   }
 
-  const client = new A2AClient(
-    continuation.agentUrl,
-    await signContinuationToken(continuation),
-    { requestTimeoutMs: POLL_REQUEST_TIMEOUT_MS },
-  );
+  const auth = await signContinuationToken(continuation);
+  const client = new A2AClient(continuation.agentUrl, auth.apiKey, {
+    requestTimeoutMs: POLL_REQUEST_TIMEOUT_MS,
+    ...(auth.apiKeyFallbacks ? { fallbackApiKeys: auth.apiKeyFallbacks } : {}),
+  });
   const deadline = Date.now() + PROCESSOR_WAIT_MS;
   let task: Task | null = null;
 
@@ -438,28 +438,35 @@ function sanitizeFailureReason(reason: string): string {
 
 async function signContinuationToken(
   continuation: A2AContinuation,
-): Promise<string | undefined> {
+): Promise<{ apiKey?: string; apiKeyFallbacks?: string[] }> {
   if (continuation.a2aAuthToken === "") {
-    return undefined;
+    return {};
   }
 
   const storedToken = continuation.a2aAuthToken;
-  if (storedToken && !isLikelyJwt(storedToken)) return storedToken;
-
-  const freshToken = await signFreshContinuationToken(continuation);
-  if (freshToken) return freshToken;
-  if (!storedToken) return undefined;
+  if (storedToken && !isLikelyJwt(storedToken)) return { apiKey: storedToken };
+
+  const freshTokens = await signFreshContinuationTokens(continuation);
+  if (freshTokens.length > 0) {
+    return {
+      apiKey: freshTokens[0],
+      ...(freshTokens.length > 1
+        ? { apiKeyFallbacks: freshTokens.slice(1) }
+        : {}),
+    };
+  }
+  if (!storedToken) return {};
 
   // Older continuations may have persisted the initial short-lived JWT. Avoid
   // replaying it forever after expiry; opaque legacy bearer keys can still be
   // reused because we cannot re-mint those.
-  if (isLikelyJwt(storedToken)) return undefined;
-  return storedToken;
+  if (isLikelyJwt(storedToken)) return {};
+  return { apiKey: storedToken };
 }
 
-async function signFreshContinuationToken(
+async function signFreshContinuationTokens(
   continuation: A2AContinuation,
-): Promise<string | undefined> {
+): Promise<string[]> {
   let orgDomain: string | undefined;
   let orgSecret: string | undefined;
   if (continuation.orgId) {
@@ -472,17 +479,35 @@ async function signFreshContinuationToken(
   }
 
   if (!continuation.ownerEmail || !(orgSecret || process.env.A2A_SECRET)) {
-    return undefined;
+    return [];
   }
 
-  try {
-    return await signA2AToken(continuation.ownerEmail, orgDomain, orgSecret, {
-      expiresIn: "30m",
-      preferGlobalSecret: !orgSecret,
-    });
-  } catch {
-    return undefined;
+  const tokens: string[] = [];
+  const add = (token: string | undefined) => {
+    if (token && !tokens.includes(token)) tokens.push(token);
+  };
+
+  if (process.env.A2A_SECRET?.trim()) {
+    try {
+      add(
+        await signA2AToken(continuation.ownerEmail, orgDomain, orgSecret, {
+          expiresIn: "30m",
+          preferGlobalSecret: true,
+        }),
+      );
+    } catch {}
+  }
+  if (orgSecret) {
+    try {
+      add(
+        await signA2AToken(continuation.ownerEmail, orgDomain, orgSecret, {
+          expiresIn: "30m",
+          preferGlobalSecret: false,
+        }),
+      );
+    } catch {}
   }
+  return tokens;
 }
 
 function isLikelyJwt(token: string): boolean {

package/corpus/core/src/mcp/builtin-tools.ts

@@ -260,6 +260,9 @@ async function createA2AClientForAskApp(origin: string): Promise<{
   return {
     client: new A2AClient(origin, auth.apiKey, {
       requestTimeoutMs: ASK_APP_A2A_REQUEST_TIMEOUT_MS,
+      ...(auth.apiKeyFallbacks
+        ? { fallbackApiKeys: auth.apiKeyFallbacks }
+        : {}),
     }),
     metadata,
   };