zidane 2.0.1 → 2.1.1

package/dist/{chunk-SZA4FKW5.js → chunk-2EQT4EHD.js}

@@ -165,10 +165,11 @@ function createProcessContext(config) {
         });
         return { stdout, stderr, exitCode: 0 };
       } catch (err) {
+        const e = err;
         return {
-          stdout: err.stdout ?? "",
-          stderr: err.stderr ?? err.message,
-          exitCode: err.code ?? 1
+          stdout: typeof e.stdout === "string" ? e.stdout : "",
+          stderr: typeof e.stderr === "string" ? e.stderr : typeof e.message === "string" ? e.message : String(err),
+          exitCode: typeof e.code === "number" ? e.code : 1
         };
       }
     },

package/dist/{chunk-PASFWG7S.js → chunk-AWDWJ2YJ.js}

@@ -6,18 +6,18 @@ import {
   mergeSkillsConfig,
   resolveSkills,
   validateResourcePath
-} from "./chunk-BCXXXJ3G.js";
+} from "./chunk-DCYJYM3E.js";
 import {
   createProcessContext
-} from "./chunk-SZA4FKW5.js";
+} from "./chunk-2EQT4EHD.js";
 import {
   connectMcpServers
-} from "./chunk-PJUUYBKF.js";
+} from "./chunk-IJORSHFI.js";
 import {
   AgentAbortedError,
   AgentProviderError,
   toTypedError
-} from "./chunk-7JTBBZ2U.js";
+} from "./chunk-LNN5UTS2.js";
 
 // src/tools/glob.ts
 var DEFAULT_LIMIT = 1e3;
@@ -69,7 +69,8 @@ var glob = {
       const entries = ctx.execution.type === "process" ? await globInProcess(pat, ctx.handle.cwd, max) : await globViaShell(pat, ctx, max);
       return entries.length > 0 ? entries.join("\n") : "(no matches)";
     } catch (err) {
-      return `Glob error: ${err.message}`;
+      const message = err instanceof Error ? err.message : String(err);
+      return `Glob error: ${message}`;
     }
   }
 };
@@ -211,7 +212,8 @@ function createSkillsReadTool(options) {
       try {
         content = await ctx.execution.readFile(ctx.handle, validated.absolutePath);
       } catch (err) {
-        return `Error reading "${relPath}" in skill "${skillName}": ${err.message}`;
+        const message = err instanceof Error ? err.message : String(err);
+        return `Error reading "${relPath}" in skill "${skillName}": ${message}`;
       }
       if (looksBinary(content)) {
         return JSON.stringify({
@@ -289,7 +291,8 @@ function createSkillsRunScriptTool(options) {
           stderr: result.stderr
         });
       } catch (err) {
-        return `Error running script "${scriptRel}" for skill "${skillName}": ${err.message}`;
+        const message = err instanceof Error ? err.message : String(err);
+        return `Error running script "${scriptRel}" for skill "${skillName}": ${message}`;
       }
     }
   };
@@ -774,19 +777,23 @@ async function executeSingleTool(ctx, call, turnId) {
       hooks: ctx.hooks,
       harness: ctx.harness,
       turnId,
-      callId
+      callId,
+      runId: ctx.runId,
+      ...ctx.session ? { session: ctx.session } : {},
+      ...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
     };
     output = await toolDef.execute(effectiveInput, toolCtx);
   } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
     await ctx.hooks.callHook("tool:error", {
       turnId,
       callId,
       name: call.name,
       displayName,
       input: effectiveInput,
-      error: err
+      error
     });
-    output = `Tool error: ${err.message}`;
+    output = `Tool error: ${error.message}`;
     isError = true;
   }
   const transformCtx = {
@@ -921,6 +928,57 @@ function buildPromptMessage(provider, parts) {
 
 // src/agent.ts
 var noTools = { name: "none", system: "You are a helpful assistant.", tools: {} };
+var HOOK_EVENT_NAMES = [
+  "system:before",
+  "turn:before",
+  "turn:after",
+  "stream:text",
+  "stream:end",
+  "stream:thinking",
+  "oauth:refresh",
+  "tool:gate",
+  "tool:before",
+  "tool:after",
+  "tool:error",
+  "tool:transform",
+  "context:transform",
+  "steer:inject",
+  "spawn:before",
+  "spawn:complete",
+  "spawn:error",
+  "child:stream:text",
+  "child:stream:thinking",
+  "child:stream:end",
+  "child:tool:before",
+  "child:tool:after",
+  "child:tool:error",
+  "child:turn:after",
+  "mcp:connect",
+  "mcp:error",
+  "mcp:close",
+  "mcp:tool:gate",
+  "mcp:tool:before",
+  "mcp:tool:after",
+  "mcp:tool:transform",
+  "mcp:tool:error",
+  "skills:resolve",
+  "skills:catalog",
+  "skills:activate",
+  "skills:deactivate",
+  "usage",
+  "output",
+  "agent:abort",
+  "agent:done",
+  "session:start",
+  "session:end",
+  "session:turns",
+  "session:meta",
+  "session:save"
+];
+var HOOK_EVENT_SET = new Set(HOOK_EVENT_NAMES);
+function isKnownHookEvent(event) {
+  return HOOK_EVENT_SET.has(event);
+}
 function resolveBehavior(harnessBehavior, agentBehavior, runBehavior) {
   return {
     toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? harnessBehavior?.toolExecution ?? "parallel",
@@ -971,7 +1029,10 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     abortController = new AbortController();
     const runId = `run_${++runCounter}`;
     const promptLabel = typeof options.prompt === "string" ? options.prompt : Array.isArray(options.prompt) ? options.prompt.filter((p) => p.type === "text").map((p) => p.text).join("\n") : "";
-    session?.startRun(runId, promptLabel);
+    session?.startRun(runId, promptLabel, {
+      ...options.parentRunId ? { parentRunId: options.parentRunId } : {},
+      depth: typeof options.depth === "number" ? options.depth : 0
+    });
     if (session) {
       await session.updateStatus("running");
       await hooks.callHook("session:start", { sessionId: session.id, runId, prompt: promptLabel });
@@ -994,6 +1055,11 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     const perRunUnregisters = [];
     if (options.hooks) {
       for (const [event, handler] of Object.entries(options.hooks)) {
+        if (!isKnownHookEvent(event)) {
+          throw new Error(
+            `Unknown hook event "${event}" passed to run(). See AgentHooks for valid events.`
+          );
+        }
         const handlerList = Array.isArray(handler) ? handler : [handler];
         for (const fn of handlerList) {
           if (typeof fn !== "function")
@@ -1140,6 +1206,7 @@ ${skillsCatalog}`;
     }
     const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
     const runStartMs = Date.now();
+    const runDepth = typeof options.depth === "number" ? options.depth : 0;
     try {
       const stats = await runLoop({
         provider,
@@ -1162,6 +1229,8 @@ ${skillsCatalog}`;
         generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID(),
         maxTurns,
         maxTokens,
+        ...session ? { session } : {},
+        depth: runDepth,
         thinkingBudget,
         schema,
         runStartMs
@@ -1199,7 +1268,8 @@ ${skillsCatalog}`;
         await hooks.callHook("agent:done", stats);
         return stats;
       }
-      session?.errorRun(runId, err.message);
+      const message = err instanceof Error ? err.message : String(err);
+      session?.errorRun(runId, message);
       await finalizeSession("error");
       throw err;
     } finally {
@@ -1230,12 +1300,13 @@ ${skillsCatalog}`;
   function waitForIdle() {
     return idlePromise ?? Promise.resolve();
   }
-  function reset() {
+  async function reset() {
     conversationTurns = [];
     steeringQueue.length = 0;
     followUpQueue.length = 0;
-    for (const record of skillActivationState.clear())
-      void hooks.callHook("skills:deactivate", { skill: record.skill, reason: "reset" });
+    const cleared = skillActivationState.clear();
+    for (const record of cleared)
+      await hooks.callHook("skills:deactivate", { skill: record.skill, reason: "reset" });
   }
   async function activateSkill(name) {
     if (!resolvedSkills) {
@@ -1271,10 +1342,16 @@ ${skillsCatalog}`;
     };
     session.setMeta = (key, value) => {
       originalSetMeta(key, value);
-      hooks.callHook("session:meta", { sessionId: session.id, key, value });
+      void Promise.resolve(hooks.callHook("session:meta", { sessionId: session.id, key, value })).catch((err) => {
+        console.error("[zidane] session:meta listener rejected:", err);
+      });
     };
   }
+  let destroyed = false;
   async function destroy() {
+    if (destroyed)
+      return;
+    destroyed = true;
     if (mcpConnection) {
       await mcpConnection.close();
       mcpConnection = null;
@@ -1313,11 +1390,34 @@ ${skillsCatalog}`;
     get activeSkills() {
       return skillActivationState.active();
     },
-    meta: provider.meta
+    // Expose a frozen view of provider.meta. Hosts previously could mutate
+    // the underlying provider meta (e.g. via `agent.meta.defaultModel = …`),
+    // which quietly affected every other agent sharing the same provider
+    // instance. Freezing forces callers to construct a new provider when
+    // they want to override model/capabilities.
+    meta: Object.freeze({ ...provider.meta })
   };
 }
 
 // src/tools/spawn.ts
+var BUBBLED_EVENTS = [
+  "stream:text",
+  "stream:thinking",
+  "stream:end",
+  "tool:before",
+  "tool:after",
+  "tool:error",
+  "turn:after"
+];
+var CHILD_EVENT_NAME = {
+  "stream:text": "child:stream:text",
+  "stream:thinking": "child:stream:thinking",
+  "stream:end": "child:stream:end",
+  "tool:before": "child:tool:before",
+  "tool:after": "child:tool:after",
+  "tool:error": "child:tool:error",
+  "turn:after": "child:turn:after"
+};
 function extractText(message) {
   if (!message || typeof message !== "object")
     return "";
@@ -1325,15 +1425,60 @@ function extractText(message) {
   if (typeof msg.content === "string")
     return msg.content;
   if (Array.isArray(msg.content)) {
-    return msg.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    return msg.content.filter((block) => !!block && typeof block === "object" && block.type === "text").map((block) => block.text).join("\n");
   }
   return "";
 }
+async function raceWithTimeout(task, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0)
+    return task;
+  let timer;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => reject(new SpawnTimeoutError(timeoutMs)), timeoutMs);
+      task.then(resolve, reject);
+    });
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+var SpawnTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Child agent timed out after ${timeoutMs}ms`);
+    this.name = "SpawnTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+function bubbleHooks(childHooks, parentHooks, childId, depth) {
+  const unregisters = [];
+  const fire = parentHooks.callHook;
+  for (const evt of BUBBLED_EVENTS) {
+    const parentEvt = CHILD_EVENT_NAME[evt];
+    const unregister = childHooks.hook(evt, (ctx) => {
+      void fire(parentEvt, { ...ctx, childId, depth });
+    });
+    unregisters.push(unregister);
+  }
+  for (const evt of BUBBLED_EVENTS) {
+    const parentEvt = CHILD_EVENT_NAME[evt];
+    const unregister = childHooks.hook(parentEvt, (ctx) => {
+      void fire(parentEvt, ctx);
+    });
+    unregisters.push(unregister);
+  }
+  return () => {
+    for (const u of unregisters) u();
+  };
+}
 function createSpawnTool(options = {}) {
   const localChildren = /* @__PURE__ */ new Map();
   let localCounter = 0;
   let localActiveCount = 0;
   const maxConcurrent = options.maxConcurrent ?? 3;
+  const maxDepth = options.maxDepth ?? 3;
+  const forwardHooks = options.forwardHooks ?? true;
   const localStats = {
     totalIn: 0,
     totalOut: 0,
@@ -1368,51 +1513,118 @@ function createSpawnTool(options = {}) {
     async execute(input, ctx) {
       const task = input.task;
       const systemOverride = input.system;
+      const parentDepth = ctx.depth ?? 0;
+      const childDepth = parentDepth + 1;
+      if (childDepth > maxDepth) {
+        return `Cannot spawn: maxDepth=${maxDepth} reached (parent depth=${parentDepth}). Deepen the cap with createSpawnTool({ maxDepth }).`;
+      }
       if (localActiveCount >= maxConcurrent) {
         return `Cannot spawn: ${localActiveCount}/${maxConcurrent} sub-agents already running. Wait for one to complete.`;
       }
+      if (ctx.signal.aborted) {
+        return `[sub-agent pre-aborted] Parent signal was already aborted \u2014 skipped "${task.slice(0, 80)}"`;
+      }
       const id = `child-${++localCounter}`;
-      const child = { id, task, startedAt: Date.now() };
-      const agent = createAgent({
-        harness: options.harness ?? ctx.harness,
-        provider: ctx.provider,
-        execution: ctx.execution
-      });
-      localChildren.set(id, child);
       localActiveCount++;
-      options.onSpawn?.(child);
-      await ctx.hooks.callHook("spawn:before", { id, task });
+      const child = { id, task, startedAt: Date.now(), depth: childDepth };
+      localChildren.set(id, child);
+      let destroyError;
+      let childRunStatus = "completed";
+      let finalStats;
+      let result = "";
+      let unbubble;
       try {
-        const stats = await agent.run({
+        const agent = createAgent({
+          harness: options.harness ?? ctx.harness,
+          provider: ctx.provider,
+          execution: ctx.execution,
+          // Share the parent's session on opt-in. Child turns get appended to
+          // the same session.turns stream with the child's runId; the child
+          // run itself is tagged with parentRunId below, via AgentRunOptions.
+          ...options.persist && ctx.session ? { session: ctx.session } : {}
+        });
+        if (forwardHooks)
+          unbubble = bubbleHooks(agent.hooks, ctx.hooks, id, childDepth);
+        options.onSpawn?.(child);
+        await ctx.hooks.callHook("spawn:before", { id, task, depth: childDepth });
+        const runPromise = agent.run({
           prompt: task,
           model: options.model,
           system: systemOverride ?? options.system,
           thinking: options.thinking,
-          signal: ctx.signal
+          signal: ctx.signal,
+          depth: childDepth,
+          ...options.persist && ctx.runId ? { parentRunId: ctx.runId } : {}
         });
-        localStats.totalIn += stats.totalIn;
-        localStats.totalOut += stats.totalOut;
-        localStats.turns += stats.turns;
-        localStats.elapsed += stats.elapsed;
-        options.onComplete?.(child, stats);
-        await ctx.hooks.callHook("spawn:complete", {
+        try {
+          finalStats = await raceWithTimeout(runPromise, options.timeoutMs);
+          if (ctx.signal.aborted) {
+            childRunStatus = "aborted";
+            result = [
+              `[sub-agent ${id}] Aborted after ${finalStats.turns} turns (${finalStats.elapsed}ms)`,
+              `Tokens: ${finalStats.totalIn} in / ${finalStats.totalOut} out`
+            ].join("\n");
+          } else {
+            const response = extractText(agent.turns.at(-1));
+            result = [
+              `[sub-agent ${id}] Completed in ${finalStats.turns} turns (${finalStats.elapsed}ms)`,
+              `Tokens: ${finalStats.totalIn} in / ${finalStats.totalOut} out`,
+              "",
+              response || "(no text response)"
+            ].join("\n");
+          }
+        } catch (err) {
+          if (err instanceof SpawnTimeoutError) {
+            childRunStatus = "timeout";
+            agent.abort();
+            try {
+              finalStats = await runPromise;
+            } catch {
+              finalStats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: err.timeoutMs };
+            }
+            result = `[sub-agent ${id}] Timed out after ${err.timeoutMs}ms`;
+          } else {
+            const error = err instanceof Error ? err : new Error(String(err));
+            childRunStatus = "error";
+            finalStats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: 0 };
+            result = `[sub-agent ${id}] Error: ${error.message}`;
+            await ctx.hooks.callHook("spawn:error", { id, task, depth: childDepth, error });
+          }
+        } finally {
+          try {
+            await agent.destroy();
+          } catch (err) {
+            destroyError = err instanceof Error ? err : new Error(String(err));
+          }
+        }
+        if (finalStats) {
+          localStats.totalIn += finalStats.totalIn;
+          localStats.totalOut += finalStats.totalOut;
+          localStats.turns += finalStats.turns;
+          localStats.elapsed += finalStats.elapsed;
+        }
+        const childRunStats = {
           id,
           task,
-          stats
-        });
-        const response = extractText(agent.turns.at(-1));
-        return [
-          `[sub-agent ${id}] Completed in ${stats.turns} turns (${stats.elapsed}ms)`,
-          `Tokens: ${stats.totalIn} in / ${stats.totalOut} out`,
-          "",
-          response || "(no text response)"
-        ].join("\n");
-      } catch (err) {
-        await ctx.hooks.callHook("spawn:error", { id, task, error: err });
-        return `[sub-agent ${id}] Error: ${err.message}`;
+          stats: finalStats,
+          depth: childDepth,
+          status: childRunStatus,
+          ...finalStats.output ? { output: finalStats.output } : {}
+        };
+        options.onComplete?.(child, finalStats, childRunStatus);
+        await ctx.hooks.callHook("spawn:complete", childRunStats);
+        if (destroyError) {
+          await ctx.hooks.callHook("spawn:error", {
+            id,
+            task,
+            depth: childDepth,
+            error: destroyError
+          });
+        }
+        return result;
       } finally {
+        unbubble?.();
         localActiveCount--;
-        await agent.destroy();
         localChildren.delete(id);
       }
     }

package/dist/{chunk-FRNFVKWW.js → chunk-CDRXC7A7.js}

@@ -5,27 +5,39 @@ import {
   toAnthropic,
   toolResultsMessage,
   userMessage
-} from "./chunk-LN4LLLHA.js";
+} from "./chunk-S3FCOMRI.js";
 import {
   matchesContextExceeded
-} from "./chunk-7JTBBZ2U.js";
-
-// src/providers/anthropic.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+} from "./chunk-LNN5UTS2.js";
 
 // src/providers/oauth.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { getOAuthApiKey } from "@yaelg/pi-ai/oauth";
-var CREDENTIALS_FILE = resolve(process.cwd(), ".credentials.json");
+function credentialsFilePath() {
+  return resolve(process.cwd(), ".credentials.json");
+}
+var CREDENTIALS_FILE_MODE = 384;
+var refreshLocks = /* @__PURE__ */ new Map();
 function readOAuthCredentials() {
-  if (!existsSync(CREDENTIALS_FILE))
+  const path = credentialsFilePath();
+  if (!existsSync(path))
     return {};
-  return JSON.parse(readFileSync(CREDENTIALS_FILE, "utf-8"));
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return {};
+    return parsed;
+  } catch {
+    return {};
+  }
 }
 function writeOAuthCredentials(credentials) {
-  writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2));
+  const path = credentialsFilePath();
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(credentials, null, 2), { mode: CREDENTIALS_FILE_MODE });
+  renameSync(tmp, path);
 }
 function credentialsFromParams(params, extraKeys = []) {
   if (typeof params?.access !== "string" || typeof params.refresh !== "string" || typeof params.expires !== "number")
@@ -45,7 +57,10 @@ async function resolveOAuthApiKey(options, callbacks) {
     return options.params.apiKey;
   const paramsCredentials = credentialsFromParams(options.params, options.extraCredentialKeys);
   if (paramsCredentials) {
-    return await resolveCredentialSource("params", paramsCredentials);
+    return await withRefreshLock(
+      `params:${options.providerId}`,
+      () => resolveCredentialSource("params", paramsCredentials)
+    );
   }
   if (typeof options.params?.access === "string")
     return options.params.access;
@@ -53,21 +68,23 @@ async function resolveOAuthApiKey(options, callbacks) {
     return process.env[options.envKey];
   const readCredentials = options.readCredentials ?? readOAuthCredentials;
   const writeCredentials = options.writeCredentials ?? writeOAuthCredentials;
-  const allCredentials = readCredentials();
-  const storedCredentials = allCredentials[options.providerId];
-  if (!storedCredentials)
-    throw new Error(options.missingError);
-  return await resolveCredentialSource("file", storedCredentials, allCredentials, writeCredentials);
-  async function resolveCredentialSource(source, current, allCredentials2, persistCredentials) {
+  return await withRefreshLock(`file:${options.providerId}`, async () => {
+    const allCredentials = readCredentials();
+    const storedCredentials = allCredentials[options.providerId];
+    if (!storedCredentials)
+      throw new Error(options.missingError);
+    return await resolveCredentialSource("file", storedCredentials, allCredentials, writeCredentials);
+  });
+  async function resolveCredentialSource(source, current, allCredentials, persistCredentials) {
     try {
       const refreshOAuthApiKey = options.getOAuthApiKey ?? getOAuthApiKey;
       const result = await refreshOAuthApiKey(options.providerId, { [options.providerId]: current });
       if (!result)
         throw new Error(options.missingError);
       if (result.newCredentials !== current) {
-        if (source === "file" && allCredentials2 && persistCredentials) {
-          allCredentials2[options.providerId] = result.newCredentials;
-          persistCredentials(allCredentials2);
+        if (source === "file" && allCredentials && persistCredentials) {
+          allCredentials[options.providerId] = result.newCredentials;
+          persistCredentials(allCredentials);
         }
         await callbacks?.onOAuthRefresh?.({
           provider: options.provider,
@@ -84,9 +101,22 @@ async function resolveOAuthApiKey(options, callbacks) {
     }
   }
 }
+async function withRefreshLock(key, fn) {
+  const existing = refreshLocks.get(key);
+  if (existing)
+    return existing;
+  const task = (async () => {
+    try {
+      return await fn();
+    } finally {
+      refreshLocks.delete(key);
+    }
+  })();
+  refreshLocks.set(key, task);
+  return task;
+}
 
 // src/providers/anthropic.ts
-var CREDENTIALS_FILE2 = resolve2(process.cwd(), ".credentials.json");
 var _sdkCtor = null;
 async function loadAnthropicSdk() {
   if (_sdkCtor)
@@ -109,11 +139,9 @@ function getConfiguredApiKey(anthropicParams) {
     return anthropicParams.access;
   if (process.env.ANTHROPIC_API_KEY)
     return process.env.ANTHROPIC_API_KEY;
-  if (existsSync2(CREDENTIALS_FILE2)) {
-    const creds = JSON.parse(readFileSync2(CREDENTIALS_FILE2, "utf-8"));
-    if (creds.anthropic?.access)
-      return creds.anthropic.access;
-  }
+  const access = readOAuthCredentials().anthropic?.access;
+  if (typeof access === "string" && access.length > 0)
+    return access;
   throw new Error("No API key found. Run `bun run auth` first.");
 }
 function createClient(SDK, apiKey, isOAuth, baseURL) {
@@ -183,10 +211,13 @@ function classifyAnthropicError(err) {
       message
     };
   }
+  const status = anyErr.status;
+  const retryable = typeof status === "number" ? status === 429 || status >= 500 && status !== 501 : void 0;
   return {
     kind: "provider_error",
-    providerCode: nativeType ?? (anyErr.status ? String(anyErr.status) : void 0),
-    message
+    providerCode: nativeType ?? (status ? String(status) : void 0),
+    message,
+    ...retryable !== void 0 ? { retryable } : {}
   };
 }
 function anthropicPromptMessage(parts) {
@@ -368,11 +399,11 @@ function anthropic(anthropicParams) {
 // src/providers/cerebras.ts
 var BASE_URL = "https://api.cerebras.ai/v1";
 function getApiKey(params) {
-  if (params?.apiKey)
+  if (typeof params?.apiKey === "string" && params.apiKey.length > 0)
     return params.apiKey;
   if (process.env.CEREBRAS_API_KEY)
     return process.env.CEREBRAS_API_KEY;
-  throw new Error("No Cerebras API key found. Set CEREBRAS_API_KEY in your environment.");
+  throw new Error("No Cerebras API key found. Pass `apiKey` or set CEREBRAS_API_KEY in your environment.");
 }
 function cerebras(params) {
   const apiKey = getApiKey(params);
@@ -650,11 +681,11 @@ function openai(params) {
 // src/providers/openrouter.ts
 var BASE_URL2 = "https://openrouter.ai/api/v1";
 function getApiKey2(params) {
-  if (params?.apiKey)
+  if (typeof params?.apiKey === "string" && params.apiKey.length > 0)
     return params.apiKey;
   if (process.env.OPENROUTER_API_KEY)
     return process.env.OPENROUTER_API_KEY;
-  throw new Error("No OpenRouter API key found. Set OPENROUTER_API_KEY in your environment.");
+  throw new Error("No OpenRouter API key found. Pass `apiKey` or set OPENROUTER_API_KEY in your environment.");
 }
 function openrouter(params) {
   const apiKey = getApiKey2(params);