zidane 2.0.1 → 2.2.0

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-PJUUYBKF.js → chunk-37GD7NL3.js}

@@ -69,8 +69,11 @@ function resultToString(content) {
   if (!content || !Array.isArray(content))
     return "";
   return content.map((block) => {
-    if (block?.type === "text")
-      return block.text;
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string")
+        return text;
+    }
     return JSON.stringify(block);
   }).join("\n");
 }
@@ -144,6 +147,7 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
   const connections = [];
   const tools = {};
   const errors = [];
+  let closed = false;
   for (const config of configs) {
     try {
       const client = _clientFactory ? _clientFactory() : new Client({ name: "zidane", version: "1.0.0" });
@@ -162,8 +166,8 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
             inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
           },
           execute: async (input, ctx) => {
-            const { turnId, callId } = ctx;
-            const displayName = ctx.harness?.toolAliases?.[namespacedName] ?? namespacedName;
+            const { turnId, callId, signal } = ctx;
+            const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName;
             const gateCtx = {
               turnId,
               callId,
@@ -188,13 +192,12 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
             });
             const timeout = config.toolTimeout ?? 3e4;
             try {
-              let timer;
-              const result = await Promise.race([
-                client.callTool({ name: tool.name, arguments: effectiveInput }),
-                new Promise((_, reject) => {
-                  timer = setTimeout(() => reject(new Error(`MCP tool "${tool.name}" on server "${config.name}" timed out after ${timeout}ms`)), timeout);
-                })
-              ]).finally(() => clearTimeout(timer));
+              const result = await raceWithTimeoutAndSignal(
+                () => client.callTool({ name: tool.name, arguments: effectiveInput }),
+                timeout,
+                `MCP tool "${tool.name}" on server "${config.name}" timed out after ${timeout}ms`,
+                signal
+              );
               let output = packMcpResult(result.content);
               const transformCtx = {
                 turnId,
@@ -218,6 +221,7 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
               });
               return output;
             } catch (err) {
+              const error = err instanceof Error ? err : new Error(String(err));
               await hooks?.callHook("mcp:tool:error", {
                 turnId,
                 callId,
@@ -225,7 +229,7 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
                 tool: tool.name,
                 displayName,
                 input: effectiveInput,
-                error: err
+                error
               });
               await hooks?.callHook("mcp:tool:after", {
                 turnId,
@@ -234,9 +238,9 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
                 tool: tool.name,
                 displayName,
                 input: effectiveInput,
-                result: err.message ?? String(err)
+                result: error.message
               });
-              throw err;
+              throw error;
             }
           }
         };
@@ -247,8 +251,9 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
         tools: toolNames
       });
     } catch (err) {
-      errors.push({ name: config.name, error: err });
-      await hooks?.callHook("mcp:error", { name: config.name, error: err });
+      const error = err instanceof Error ? err : new Error(String(err));
+      errors.push({ name: config.name, error });
+      await hooks?.callHook("mcp:error", { name: config.name, error });
     }
   }
   if (errors.length > 0 && connections.length === 0) {
@@ -258,6 +263,9 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
   return {
     tools,
     close: async () => {
+      if (closed)
+        return;
+      closed = true;
       await Promise.allSettled(
         connections.map(async ({ name, client }) => {
           await hooks?.callHook("mcp:close", { name });
@@ -267,6 +275,27 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
     }
   };
 }
+async function raceWithTimeoutAndSignal(task, timeoutMs, timeoutMessage, signal) {
+  if (signal?.aborted)
+    throw new Error("MCP tool call aborted");
+  let timer;
+  let onAbort;
+  try {
+    return await new Promise((resolvePromise, rejectPromise) => {
+      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs);
+      if (signal) {
+        onAbort = () => rejectPromise(new Error("MCP tool call aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      task().then(resolvePromise, rejectPromise);
+    });
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    if (signal && onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
 
 export {
   normalizeMcpServers,

package/dist/{chunk-LVC7NQUZ.js → chunk-BW3WTFIR.js}

@@ -1,6 +1,6 @@
 import {
   validateSkillForWrite
-} from "./chunk-BCXXXJ3G.js";
+} from "./chunk-TPXPVEH6.js";
 
 // src/skills/index.ts
 function defineSkill(config) {

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