@aexhq/sdk 0.26.4 → 0.27.0

package/dist/_contracts/submission.js

@@ -196,6 +196,7 @@ export const deniedSecretFields = new Set([
     "providerApiKey",
     "anthropicApiKey",
     "apiKey",
+    "apiKeys",
     "accessToken",
     "refreshToken",
     "password",
@@ -708,8 +709,12 @@ export function crossValidateSecretEnvAndValues(secretEnv, envSecrets) {
     }
 }
 export function parseInlineSecrets(input) {
+    // A child run (parentRunId set) inherits its provider keys server-side from
+    // the parent's vault, so it may omit `secrets` entirely.
+    if (input === undefined || input === null)
+        return {};
     const value = requireRecord(input, "secrets");
-    const allowedTopLevel = new Set(["apiKey", "mcpServers", "proxyEndpointAuth", "envSecrets"]);
+    const allowedTopLevel = new Set(["apiKey", "apiKeys", "mcpServers", "proxyEndpointAuth", "envSecrets"]);
     for (const key of Object.keys(value)) {
         if (key.startsWith("__aex_")) {
             // Platform-internal namespace (e.g. __aex_proxy_token). The BFF
@@ -723,16 +728,39 @@ export function parseInlineSecrets(input) {
         }
     }
     const apiKey = value.apiKey !== undefined ? requireString(value.apiKey, "secrets.apiKey") : undefined;
+    const apiKeys = parseApiKeys(value.apiKeys);
     const mcpServers = parseMcpServerSecrets(value.mcpServers);
     const proxyEndpointAuth = parseProxyEndpointAuth(value.proxyEndpointAuth);
     const envSecrets = parseEnvSecrets(value.envSecrets);
     return {
         ...(apiKey !== undefined ? { apiKey } : {}),
+        ...(apiKeys ? { apiKeys } : {}),
         ...(mcpServers ? { mcpServers } : {}),
         ...(proxyEndpointAuth ? { proxyEndpointAuth } : {}),
         ...(envSecrets ? { envSecrets } : {})
     };
 }
+/**
+ * Parse the per-provider BYOK key map. Each key must name a known
+ * {@link RunProvider}; each value must be a non-empty string. Returns
+ * `undefined` for an absent or empty map so the spread above stays clean.
+ */
+function parseApiKeys(input) {
+    if (input === undefined || input === null)
+        return undefined;
+    const value = requireRecord(input, "secrets.apiKeys");
+    const out = {};
+    for (const [provider, key] of Object.entries(value)) {
+        if (!RUN_PROVIDERS.includes(provider)) {
+            throw new Error(`secrets.apiKeys["${provider}"] is not a known provider; permitted: ${RUN_PROVIDERS.join(", ")}`);
+        }
+        if (typeof key !== "string" || key.length === 0) {
+            throw new Error(`secrets.apiKeys["${provider}"] must be a non-empty string`);
+        }
+        out[provider] = key;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
 function parseEnvSecrets(input) {
     if (input === undefined || input === null)
         return undefined;
@@ -1050,7 +1078,9 @@ export function parseRunSubmissionRequest(input, options = {}) {
     const postHook = parsePostHook(value.postHook, "submission.postHook");
     const proxyEndpoints = parseProxyEndpoints(value.proxyEndpoints);
     const secrets = parseInlineSecrets(value.secrets);
-    enforceCredentialSecretPolicy(credentialMode, secrets);
+    enforceCredentialSecretPolicy(credentialMode, secrets, provider, {
+        inheritsFromParent: parentRunId !== undefined
+    });
     crossValidateProxyEndpointsAndAuth(proxyEndpoints, secrets.proxyEndpointAuth);
     const submission = parseSubmission(value.submission);
     assertRunModelMatchesProvider(provider, submission.model);
@@ -1169,13 +1199,22 @@ export function parseRunProvider(input) {
 }
 /**
  * Cross-check the supplied secrets bundle against the credential mode. BYOK
- * requires `secrets.apiKey` (the provider key for the run's `provider`). MCP /
- * proxy endpoint auth carry across providers and are not checked here.
+ * requires `secrets.apiKeys[provider]` (the key for the run's own `provider`).
+ * Additional provider keys are optional (validated for shape only) so the run
+ * can supply keys for the other providers its subagents may use. MCP / proxy
+ * endpoint auth carry across providers and are not checked here.
+ *
+ * A CHILD run (`inheritsFromParent`) is exempt from the own-key requirement: it
+ * inherits its provider keys server-side from the parent's vaulted bundle, so
+ * it need not carry any of its own. The server still verifies, at admission,
+ * that the parent actually holds a key for the child's provider.
  */
-export function enforceCredentialSecretPolicy(credentialMode, secrets) {
+export function enforceCredentialSecretPolicy(credentialMode, secrets, provider, opts) {
     void credentialMode;
-    if (!secrets.apiKey) {
-        throw new Error(`secrets.apiKey is required when credentialMode is byok`);
+    if (opts?.inheritsFromParent)
+        return;
+    if (!(secrets.apiKeys?.[provider] ?? secrets.apiKey)) {
+        throw new Error(`secrets.apiKey is required when credentialMode is byok (or secrets.apiKeys["${provider}"])`);
     }
 }
 export function parseSubmission(input) {
@@ -1194,7 +1233,7 @@ export function parseSubmission(input) {
         "securityProfile",
         "metadata",
         "outputs",
-        "builtins",
+        "includeBuiltinTools",
         "outputMode",
         "platform"
     ]);
@@ -1207,7 +1246,7 @@ export function parseSubmission(input) {
     const system = optionalString(value.system, "submission.system");
     const prompt = parsePrompt(value.prompt);
     const skills = parseSkills(value.skills);
-    const tools = parseTools(value.tools);
+    const { tools, builtinTools } = parseTools(value.tools);
     const agentsMd = parseAgentsMd(value.agentsMd);
     const files = parseFiles(value.files);
     const mcpServers = parseMcpServers(value.mcpServers);
@@ -1216,7 +1255,7 @@ export function parseSubmission(input) {
     const securityProfile = parseRuntimeSecurityProfile(value.securityProfile);
     const metadata = optionalJsonRecord(value.metadata, "submission.metadata");
     const outputs = parseOutputs(value.outputs);
-    const builtins = parseBuiltins(value.builtins);
+    const includeBuiltinTools = parseIncludeBuiltinTools(value.includeBuiltinTools);
     const outputMode = parseOutputMode(value.outputMode);
     const platform = parsePlatformConfig(value.platform);
     return {
@@ -1233,7 +1272,8 @@ export function parseSubmission(input) {
         ...(securityProfile ? { securityProfile } : {}),
         ...(metadata ? { metadata } : {}),
         ...(outputs ? { outputs } : {}),
-        ...(builtins !== undefined ? { builtins } : {}),
+        ...(includeBuiltinTools !== undefined ? { includeBuiltinTools } : {}),
+        ...(builtinTools.length > 0 ? { builtinTools } : {}),
         ...(outputMode !== undefined ? { outputMode } : {}),
         ...(platform ? { platform } : {})
     };
@@ -1297,108 +1337,105 @@ function parseOutputMode(input) {
     return input;
 }
 /**
- * Managed-runtime builtins — the closed set the managed runtime accepts.
- * Closed so an invalid name is a compile error via {@link Builtins}, not a
- * silent runtime no-op.
+ * The CLOSED set of builtin tool NAMES the managed runtime can inject — one per
+ * machine tool the hands implement. This list is the single source of truth for
+ * validating builtin tool references; the platform's `HANDS_TOOLS` (the execute
+ * vocabulary) is pinned EQUAL to it at module load (`platform-runtime-agent`
+ * `assertNamesMatch`), so a rename on either side fails loudly rather than
+ * silently shipping a name the executors do not speak.
  *
- * The first entries are the recommended concrete builtins. The legacy aggregate
- * extension names remain accepted for existing callers, but are not the default.
+ * Order mirrors `HANDS_TOOLS`. A builtin tool reference (a bare string in
+ * `submission.tools`) must be a member of this set.
  */
-export const BUILTINS = [
-    "web_search",
-    "web_fetch",
-    "read",
-    "edit",
-    "glob",
-    "grep",
-    "head",
-    "tail",
+export const BUILTIN_TOOL_NAMES = [
     "bash",
-    "notebook",
-    "developer",
-    "computercontroller",
-    "memory",
-    "autovisualiser",
-    "tutorial"
-];
-/**
- * DX-first managed-runtime defaults. Omitted `builtins` resolves to this list.
- * Notebook support remains opt-in through {@link Builtins.NOTEBOOK}.
- */
-export const DEFAULT_BUILTINS = [
-    "web_search",
-    "web_fetch",
-    "read",
-    "edit",
-    "glob",
+    "read_file",
+    "write_file",
+    "edit_file",
     "grep",
+    "glob",
     "head",
     "tail",
-    "bash"
+    "todo_write",
+    "subagent",
+    "subagent_result",
+    "web_fetch",
+    "web_search",
+    "notebook_edit",
+    "bash_output",
+    "bash_kill",
+    "code_execution",
+    "wait",
+    "git"
 ];
 /**
- * Symbol-style accessors for the closed builtin set, e.g.
- * `Builtins.WEB_SEARCH`.
+ * Typo-safe accessors for the closed builtin tool set: each key maps to the
+ * real tool NAME string. Reference a builtin in `submission.tools` via
+ * `BuiltinTools.notebook_edit` rather than the bare string so a rename is a
+ * compile error, not a runtime 400.
+ *
+ * Keys are the real tool names; a unit test asserts `Object.values(BuiltinTools)`
+ * deep-equals `BUILTIN_TOOL_NAMES` so the two can never drift.
  */
-export const Builtins = {
-    /** Managed web search. Included in {@link DEFAULT_BUILTINS}. */
-    WEB_SEARCH: "web_search",
-    /** Fetch a URL and return readable text. Included in {@link DEFAULT_BUILTINS}. */
-    WEB_FETCH: "web_fetch",
-    /** Read files. Included in {@link DEFAULT_BUILTINS}. */
-    READ: "read",
-    /** Create/modify files. Included in {@link DEFAULT_BUILTINS}. */
-    EDIT: "edit",
-    /** Search paths by glob. Included in {@link DEFAULT_BUILTINS}. */
-    GLOB: "glob",
-    /** Search file contents. Included in {@link DEFAULT_BUILTINS}. */
-    GREP: "grep",
-    /** Read the first lines of a file. Included in {@link DEFAULT_BUILTINS}. */
-    HEAD: "head",
-    /** Read the last lines of a file. Included in {@link DEFAULT_BUILTINS}. */
-    TAIL: "tail",
-    /** Shell command execution. Included in {@link DEFAULT_BUILTINS}. */
-    BASH: "bash",
-    /** Jupyter notebook editing. Optional; not in {@link DEFAULT_BUILTINS}. */
-    NOTEBOOK: "notebook",
-    /** Legacy aggregate: shell/filesystem/navigation/web/notebook tools. */
-    DEVELOPER: "developer",
-    /** Legacy aggregate alias retained for existing callers. */
-    COMPUTER_CONTROLLER: "computercontroller",
-    /** Legacy aggregate alias retained for existing callers. */
-    MEMORY: "memory",
-    /** Legacy aggregate alias retained for existing callers. */
-    AUTOVISUALISER: "autovisualiser",
-    /** Legacy aggregate alias retained for existing callers. */
-    TUTORIAL: "tutorial"
+export const BuiltinTools = {
+    bash: "bash",
+    read_file: "read_file",
+    write_file: "write_file",
+    edit_file: "edit_file",
+    grep: "grep",
+    glob: "glob",
+    head: "head",
+    tail: "tail",
+    todo_write: "todo_write",
+    subagent: "subagent",
+    subagent_result: "subagent_result",
+    web_fetch: "web_fetch",
+    web_search: "web_search",
+    notebook_edit: "notebook_edit",
+    bash_output: "bash_output",
+    bash_kill: "bash_kill",
+    code_execution: "code_execution",
+    wait: "wait",
+    git: "git"
 };
-const MAX_BUILTINS = 16;
-function parseBuiltins(input) {
+/**
+ * The default builtin tool set injected when `includeBuiltinTools !== false`:
+ * every builtin tool EXCEPT `notebook_edit` (notebook editing stays opt-in —
+ * add `BuiltinTools.notebook_edit` to `tools` to enable it). Derived by
+ * filtering {@link BUILTIN_TOOL_NAMES} so it can never drift from the closed
+ * set.
+ */
+export const DEFAULT_BUILTIN_TOOLS = BUILTIN_TOOL_NAMES.filter((name) => name !== "notebook_edit");
+/**
+ * Resolve the set of builtin tool NAMES a submission injects, deduplicated and
+ * in {@link BUILTIN_TOOL_NAMES} order.
+ *
+ *   - `includeBuiltinTools !== false` ⇒ start from {@link DEFAULT_BUILTIN_TOOLS}
+ *     (the standard set); `false` ⇒ start from none (pure-MCP / pure-custom).
+ *   - union in every builtin-name string the caller listed in `tools` (a
+ *     cherry-pick, e.g. `BuiltinTools.notebook_edit` to opt the notebook in).
+ *
+ * Every `toolRefs` string MUST be a member of {@link BUILTIN_TOOL_NAMES}; the
+ * union is validated ⊆ the closed set so an invalid name can never leak through.
+ */
+export function resolveBuiltinToolNames(includeBuiltinTools, toolRefs) {
+    const enabled = new Set(includeBuiltinTools !== false ? DEFAULT_BUILTIN_TOOLS : []);
+    for (const ref of toolRefs ?? []) {
+        if (!BUILTIN_TOOL_NAMES.includes(ref)) {
+            throw new Error(`${JSON.stringify(ref)} is not a builtin tool; expected one of: ${BUILTIN_TOOL_NAMES.join(", ")}`);
+        }
+        enabled.add(ref);
+    }
+    return BUILTIN_TOOL_NAMES.filter((name) => enabled.has(name));
+}
+/** Validate the optional `includeBuiltinTools` flag (default `true`). */
+function parseIncludeBuiltinTools(input) {
     if (input === undefined || input === null)
         return undefined;
-    if (!Array.isArray(input)) {
-        throw new Error("submission.builtins must be an array of strings");
-    }
-    if (input.length > MAX_BUILTINS) {
-        throw new Error(`submission.builtins exceeds the max of ${MAX_BUILTINS} entries`);
-    }
-    const seen = new Set();
-    const out = [];
-    for (let i = 0; i < input.length; i++) {
-        const v = input[i];
-        if (typeof v !== "string") {
-            throw new Error(`submission.builtins[${i}] must be a string`);
-        }
-        if (!BUILTINS.includes(v)) {
-            throw new Error(`submission.builtins[${i}] (${JSON.stringify(v)}) is not a managed-runtime builtin; ` +
-                `expected one of: ${BUILTINS.join(", ")}`);
-        }
-        if (seen.has(v))
-            continue; // dedupe silently
-        seen.add(v);
-        out.push(v);
+    if (typeof input !== "boolean") {
+        throw new Error("submission.includeBuiltinTools must be a boolean");
     }
-    return out;
+    return input;
 }
 /**
  * Maximum number of output capture entries accepted per list.
@@ -1626,17 +1663,35 @@ function parseSkills(input) {
         return ref;
     });
 }
+/**
+ * Parse the `submission.tools` union: each entry is either a BARE STRING (a
+ * builtin tool reference, validated against {@link BUILTIN_TOOL_NAMES}) or a
+ * custom tool bundle OBJECT ({@link ToolRef}). Returns the two groups split:
+ * `tools` (custom bundles, the existing downstream shape) and `builtinTools`
+ * (the deduped builtin-name references, in {@link BUILTIN_TOOL_NAMES} order).
+ */
 function parseTools(input) {
     if (input === undefined) {
-        return [];
+        return { tools: [], builtinTools: [] };
     }
     if (!Array.isArray(input)) {
-        throw new Error("submission.tools must be an array of ToolRef objects");
+        throw new Error("submission.tools must be an array of builtin tool names or ToolRef objects");
     }
     const seenNames = new Set();
     const seenAssetIds = new Set();
-    return input.map((item, index) => {
+    const seenBuiltins = new Set();
+    const tools = [];
+    input.forEach((item, index) => {
         const path = `submission.tools[${index}]`;
+        // A bare string is a builtin tool reference (e.g. BuiltinTools.notebook_edit).
+        if (typeof item === "string") {
+            if (!BUILTIN_TOOL_NAMES.includes(item)) {
+                throw new Error(`${path} (${JSON.stringify(item)}) is not a builtin tool name; ` +
+                    `expected one of: ${BUILTIN_TOOL_NAMES.join(", ")}`);
+            }
+            seenBuiltins.add(item);
+            return;
+        }
         const raw = requireRecord(item, path);
         for (const key of Object.keys(raw)) {
             if (key !== "kind" &&
@@ -1678,15 +1733,17 @@ function parseTools(input) {
             throw new Error(`${path}.input_schema.type must be "object"`);
         }
         const entry = normaliseSkillBundlePath(requireString(raw.entry, `${path}.entry`));
-        return {
+        tools.push({
             kind: "asset",
             assetId: fields.assetId,
             name: fields.name,
             description,
             input_schema: inputSchema,
             entry
-        };
+        });
     });
+    const builtinTools = BUILTIN_TOOL_NAMES.filter((name) => seenBuiltins.has(name));
+    return { tools, builtinTools };
 }
 function parseAgentsMd(input) {
     if (input === undefined)

package/dist/cli.mjs

@@ -798,6 +798,28 @@ function parseRunRegion(input) {
   }
   return input;
 }
+var BUILTIN_TOOL_NAMES = [
+  "bash",
+  "read_file",
+  "write_file",
+  "edit_file",
+  "grep",
+  "glob",
+  "head",
+  "tail",
+  "todo_write",
+  "subagent",
+  "subagent_result",
+  "web_fetch",
+  "web_search",
+  "notebook_edit",
+  "bash_output",
+  "bash_kill",
+  "code_execution",
+  "wait",
+  "git"
+];
+var DEFAULT_BUILTIN_TOOLS = BUILTIN_TOOL_NAMES.filter((name) => name !== "notebook_edit");
 var MAX_OUTPUT_CAPTURE_TIMEOUT_MS = 6 * 60 * 60 * 1e3;
 
 // ../contracts/dist/connection-ticket.js
@@ -950,7 +972,7 @@ function highEntropyShannonBits(value) {
   return bits;
 }
 function isForbiddenCustodyFieldName(key) {
-  return /^(apiKey|secretValue|bearerHash|signedUrl|objectStoreKey|objectKey|vaultId|providerResponseBody|responseBody|privateResourceHandle|resourceHandle|rawBody)$/i.test(key);
+  return /^(apiKey|apiKeys|secretValue|bearerHash|signedUrl|objectStoreKey|objectKey|vaultId|providerResponseBody|responseBody|privateResourceHandle|resourceHandle|rawBody)$/i.test(key);
 }
 
 // ../contracts/dist/run-record.js
@@ -1376,6 +1398,8 @@ function extractErrorMessage(body) {
 // ../contracts/dist/operations.js
 var operations_exports = {};
 __export(operations_exports, {
+  READ_OUTPUT_TEXT_DEFAULT_BYTES: () => READ_OUTPUT_TEXT_DEFAULT_BYTES,
+  READ_OUTPUT_TEXT_MAX_BYTES: () => READ_OUTPUT_TEXT_MAX_BYTES,
   cancelRun: () => cancelRun,
   classifyOutput: () => classifyOutput,
   createAgentsMd: () => createAgentsMd,
@@ -1414,10 +1438,12 @@ __export(operations_exports, {
   listFiles: () => listFiles,
   listOutputs: () => listOutputs,
   listRunEvents: () => listRunEvents,
+  listRuns: () => listRuns,
   listSecrets: () => listSecrets,
   listSkills: () => listSkills,
   normalizeOutputLinkExpiresIn: () => normalizeOutputLinkExpiresIn,
   outputLink: () => outputLink,
+  readOutputText: () => readOutputText,
   redeliverRunWebhook: () => redeliverRunWebhook,
   resolveOutputFileSelector: () => resolveOutputFileSelector,
   rotateSecret: () => rotateSecret,
@@ -2151,6 +2177,18 @@ async function getRun(http, runId) {
 async function getRunUnit(http, runId) {
   return http.request(`/api/runs/${encodeURIComponent(runId)}`);
 }
+async function listRuns(http, query) {
+  const params = {};
+  if (query?.status !== void 0)
+    params.status = query.status;
+  if (query?.since !== void 0)
+    params.since = query.since;
+  if (query?.limit !== void 0)
+    params.limit = String(query.limit);
+  if (query?.cursor !== void 0)
+    params.cursor = query.cursor;
+  return http.request("/api/runs", {}, params);
+}
 var LIST_EVENTS_PAGE_BUDGET = 1e3;
 async function listRunEvents(http, runId) {
   const path = `/api/runs/${encodeURIComponent(runId)}/events`;
@@ -2249,6 +2287,74 @@ async function downloadOutput(http, runId, selector) {
   const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(output.id)}/download`);
   return { output, bytes: new Uint8Array(await response.arrayBuffer()) };
 }
+var READ_OUTPUT_TEXT_MAX_BYTES = 1e7;
+var READ_OUTPUT_TEXT_DEFAULT_BYTES = 5e4;
+async function readOutputText(http, runId, selector, options) {
+  const maxBytes = Math.max(1, Math.min(options?.maxBytes ?? READ_OUTPUT_TEXT_DEFAULT_BYTES, READ_OUTPUT_TEXT_MAX_BYTES));
+  const output = isPathSelector(selector) ? resolveOutputFileSelector(await listOutputs(http, runId), selector, runId) : resolveOutputFileSelector([], selector, runId);
+  const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(output.id)}/download`);
+  const capped = await readCappedText(response, maxBytes);
+  const text = options?.grep === void 0 ? capped.text : grepLines(capped.text, options.grep);
+  return { output, text, truncated: capped.truncated, totalBytes: capped.totalBytes };
+}
+async function readCappedText(response, maxBytes) {
+  const declaredRaw = response.headers.get("content-length");
+  const declared = declaredRaw !== null && /^\d+$/.test(declaredRaw) ? Number(declaredRaw) : void 0;
+  const decoder = new TextDecoder("utf-8");
+  const body = response.body;
+  if (!body) {
+    const buf = new Uint8Array(await response.arrayBuffer());
+    const total = declared ?? buf.byteLength;
+    return {
+      text: decoder.decode(buf.subarray(0, maxBytes)),
+      truncated: buf.byteLength > maxBytes,
+      totalBytes: total
+    };
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let read = 0;
+  let sawMore = false;
+  try {
+    while (read < maxBytes) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value && value.byteLength > 0) {
+        read += value.byteLength;
+        chunks.push(value);
+      }
+    }
+    if (read >= maxBytes) {
+      const next = await reader.read();
+      if (!next.done && next.value && next.value.byteLength > 0)
+        sawMore = true;
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+  }
+  const merged = concatBytes(chunks).subarray(0, maxBytes);
+  const truncated = declared !== void 0 ? declared > maxBytes : sawMore;
+  const totalBytes = declared ?? read;
+  return { text: decoder.decode(merged), truncated, totalBytes };
+}
+function concatBytes(chunks) {
+  if (chunks.length === 1)
+    return chunks[0];
+  const total = chunks.reduce((n, c) => n + c.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+function grepLines(text, pattern) {
+  const test = typeof pattern === "string" ? (line) => line.toLowerCase().includes(pattern.toLowerCase()) : (line) => pattern.test(line);
+  return text.split("\n").filter((line) => test(line)).join("\n");
+}
 async function cancelRun(http, runId) {
   await http.request(`/api/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" });
 }
@@ -3408,15 +3514,6 @@ async function runRunCmd(io2, argv) {
 `);
     return USAGE_ERR;
   }
-  for (const p of RUN_PROVIDERS) {
-    if (p === provider)
-      continue;
-    if (providerKeyValues[p] !== void 0) {
-      io2.stderr(`--${p}-api-key is not allowed when --provider is ${provider}
-`);
-      return USAGE_ERR;
-    }
-  }
   const runtimeFlag = takeFlagValue(rest, "--runtime");
   if (runtimeFlag.error) {
     io2.stderr(`${runtimeFlag.error}
@@ -3720,8 +3817,10 @@ async function runRunCmd(io2, argv) {
     ...runConfig.environment ? { environment: runConfig.environment } : {},
     ...runConfig.metadata ? { metadata: runConfig.metadata } : {}
   };
+  const hasAdditionalProviderKeys = Object.keys(providerKeyValues).some((p) => p !== provider);
   const secrets = {
     apiKey: providerKeyValues[provider],
+    ...hasAdditionalProviderKeys ? { apiKeys: providerKeyValues } : {},
     ...mcpServerSecrets.length > 0 ? { mcpServers: mcpServerSecrets } : {},
     ...proxyAuth.length > 0 ? { proxyEndpointAuth: proxyAuth } : {}
   };

package/dist/cli.mjs.sha256

@@ -1 +1 @@
-65e49dd08ff380ad5b4235dbc0f2fd2e6a7a677f1d8f7b67df91b448aa4472a8  cli.mjs
+0386d2625bfa4f8aea426cffc3bf21546c48b33b7134eb7cd4bbfefdc2d69d96  cli.mjs