zidane 4.0.2 → 4.1.4

package/dist/chunk-7GQ7P6DM.js

@@ -1,566 +0,0 @@
-import {
-  toolOutputByteLength
-} from "./chunk-JH6IAAFA.js";
-
-// src/mcp/index.ts
-import { Buffer } from "buffer";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// src/mcp/sse-to-json-fetch.ts
-function isBunRuntime() {
-  return typeof globalThis.Bun !== "undefined";
-}
-function sseToJsonFetchIfNeeded() {
-  return isBunRuntime() ? sseToJsonFetch() : void 0;
-}
-function sseToJsonFetch(baseFetch = fetch) {
-  return async function sseToJsonWrappedFetch(input, init) {
-    const response = await baseFetch(input, init);
-    const method = (init?.method ?? "GET").toString().toUpperCase();
-    if (method !== "POST")
-      return response;
-    const contentType = response.headers.get("content-type");
-    if (!contentType || !contentType.includes("text/event-stream"))
-      return response;
-    if (!response.body)
-      return response;
-    let raw;
-    try {
-      raw = await response.text();
-    } catch {
-      return response;
-    }
-    const events = parseSseDataEvents(raw);
-    const payload = events.length === 1 ? events[0] : events;
-    return synthesizeJsonResponse(response, payload);
-  };
-}
-function parseSseDataEvents(raw) {
-  const events = [];
-  for (const block of raw.split(/\r?\n\r?\n/)) {
-    if (!block.trim())
-      continue;
-    const dataLines = [];
-    let isMessageEvent = true;
-    for (const line of block.split(/\r?\n/)) {
-      if (line.startsWith(":"))
-        continue;
-      if (line.startsWith("event:")) {
-        const eventType = line.slice("event:".length).trim();
-        if (eventType && eventType !== "message")
-          isMessageEvent = false;
-      } else if (line.startsWith("data:")) {
-        const value = line.slice("data:".length);
-        dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
-      }
-    }
-    if (!isMessageEvent || dataLines.length === 0)
-      continue;
-    try {
-      events.push(JSON.parse(dataLines.join("\n")));
-    } catch {
-    }
-  }
-  return events;
-}
-function synthesizeJsonResponse(original, payload) {
-  const headers = new Headers(original.headers);
-  headers.set("content-type", "application/json");
-  return new Response(JSON.stringify(payload), {
-    status: original.status,
-    statusText: original.statusText,
-    headers
-  });
-}
-
-// src/mcp/tolerant-client.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { Protocol } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import {
-  InitializeResultSchema,
-  LATEST_PROTOCOL_VERSION,
-  SUPPORTED_PROTOCOL_VERSIONS
-} from "@modelcontextprotocol/sdk/types.js";
-var TolerantMcpClient = class extends Client {
-  async connect(transport, options) {
-    await Protocol.prototype.connect.call(this, transport);
-    if (transport.sessionId !== void 0)
-      return;
-    const self = this;
-    try {
-      const result = await this.request(
-        {
-          method: "initialize",
-          params: {
-            protocolVersion: LATEST_PROTOCOL_VERSION,
-            capabilities: self._capabilities,
-            clientInfo: self._clientInfo
-          }
-        },
-        InitializeResultSchema,
-        options
-      );
-      if (result === void 0)
-        throw new Error(`Server sent invalid initialize result: ${result}`);
-      if (!SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion))
-        throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
-      self._serverCapabilities = result.capabilities;
-      self._serverVersion = result.serverInfo;
-      const setProtocolVersion = transport.setProtocolVersion;
-      if (setProtocolVersion)
-        setProtocolVersion.call(transport, result.protocolVersion);
-      self._instructions = result.instructions;
-      try {
-        await this.notification({ method: "notifications/initialized" });
-      } catch (notifyError) {
-        const msg = notifyError instanceof Error ? notifyError.message : String(notifyError);
-        console.warn(`[zidane:mcp] server rejected notifications/initialized (continuing): ${msg}`);
-      }
-      if (self._pendingListChangedConfig) {
-        self._setupListChangedHandlers(self._pendingListChangedConfig);
-        self._pendingListChangedConfig = void 0;
-      }
-    } catch (error) {
-      void this.close();
-      throw error;
-    }
-  }
-};
-
-// src/mcp/index.ts
-var DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS = 1e4;
-function inferTransport(raw) {
-  if (raw.transport === "stdio" || raw.transport === "sse" || raw.transport === "streamable-http")
-    return raw.transport;
-  if (raw.type === "stdio" || raw.type === "sse" || raw.type === "streamable-http" || raw.type === "http")
-    return raw.type === "http" ? "streamable-http" : raw.type;
-  if (raw.command)
-    return "stdio";
-  if (raw.httpUrl)
-    return "streamable-http";
-  if (raw.sseUrl)
-    return "sse";
-  if (raw.url)
-    return "streamable-http";
-  throw new Error(`Cannot infer MCP transport from config: ${JSON.stringify(raw)}`);
-}
-function normalizeOne(name, raw) {
-  const transport = inferTransport(raw);
-  const url = raw.url ?? raw.httpUrl ?? raw.sseUrl;
-  const config = { name, transport };
-  if (raw.command)
-    config.command = raw.command;
-  if (raw.args)
-    config.args = raw.args;
-  if (raw.env)
-    config.env = raw.env;
-  if (raw.strictEnv === true)
-    config.strictEnv = true;
-  if (url)
-    config.url = url;
-  if (raw.headers)
-    config.headers = raw.headers;
-  if (typeof raw.bootstrapTimeout === "number")
-    config.bootstrapTimeout = raw.bootstrapTimeout;
-  if (typeof raw.toolTimeout === "number")
-    config.toolTimeout = raw.toolTimeout;
-  if (Array.isArray(raw.enabledTools))
-    config.enabledTools = raw.enabledTools;
-  if (Array.isArray(raw.disabledTools))
-    config.disabledTools = raw.disabledTools;
-  if (typeof raw.toolFilter === "function")
-    config.toolFilter = raw.toolFilter;
-  return config;
-}
-function looksLikeSingleConfig(obj) {
-  const singleConfigKeys = ["transport", "type", "command", "url", "httpUrl", "sseUrl"];
-  return singleConfigKeys.some((key) => typeof obj[key] === "string");
-}
-function normalizeMcpServers(input) {
-  if (input == null)
-    return [];
-  if (Array.isArray(input)) {
-    return input.map((raw, idx) => {
-      const obj = raw;
-      const name = obj.name ?? `mcp_${idx}`;
-      return normalizeOne(name, obj);
-    });
-  }
-  if (typeof input === "object") {
-    const obj = input;
-    if (looksLikeSingleConfig(obj)) {
-      const raw = obj;
-      const name = raw.name ?? "mcp_0";
-      return [normalizeOne(name, raw)];
-    }
-    return Object.entries(obj).map(
-      ([name, raw]) => normalizeOne(name, raw ?? {})
-    );
-  }
-  throw new Error(`Unsupported MCP server config shape: ${typeof input}`);
-}
-function resultToString(content) {
-  if (!content || !Array.isArray(content))
-    return "";
-  return content.map((block) => {
-    if (block && typeof block === "object" && block.type === "text") {
-      const text = block.text;
-      if (typeof text === "string")
-        return text;
-    }
-    return JSON.stringify(block);
-  }).join("\n");
-}
-function normalizeMcpBlocks(content) {
-  if (!Array.isArray(content))
-    return null;
-  const out = [];
-  for (const raw of content) {
-    if (!raw || typeof raw !== "object")
-      continue;
-    const block = raw;
-    if (block.type === "text" && typeof block.text === "string") {
-      out.push({ type: "text", text: block.text });
-      continue;
-    }
-    if (block.type === "image" && typeof block.data === "string") {
-      const mediaType = typeof block.mimeType === "string" ? block.mimeType : typeof block.mediaType === "string" ? block.mediaType : "image/png";
-      out.push({ type: "image", mediaType, data: block.data });
-      continue;
-    }
-    if (block.type === "resource" && block.resource && typeof block.resource === "object") {
-      const res = block.resource;
-      if (typeof res.text === "string") {
-        out.push({ type: "text", text: res.text });
-        continue;
-      }
-      if (typeof res.blob === "string" && typeof res.mimeType === "string" && res.mimeType.startsWith("image/")) {
-        out.push({ type: "image", mediaType: res.mimeType, data: res.blob });
-        continue;
-      }
-    }
-    out.push({ type: "text", text: JSON.stringify(block) });
-  }
-  return out;
-}
-function packMcpResult(content) {
-  const normalized = normalizeMcpBlocks(content);
-  if (!normalized || normalized.length === 0)
-    return "";
-  const parts = [];
-  for (const block of normalized) {
-    if (block.type !== "text")
-      return normalized;
-    parts.push(block.text);
-  }
-  return parts.join("\n");
-}
-function createTransport(config) {
-  switch (config.transport) {
-    case "stdio": {
-      const mergedEnv = config.env && !config.strictEnv ? { ...getDefaultEnvironment(), ...config.env } : config.env;
-      return new StdioClientTransport({
-        command: config.command,
-        args: config.args,
-        env: mergedEnv
-      });
-    }
-    case "sse":
-      return new SSEClientTransport(new URL(config.url), {
-        requestInit: config.headers ? { headers: config.headers } : void 0
-      });
-    case "streamable-http":
-      return new StreamableHTTPClientTransport(new URL(config.url), {
-        requestInit: config.headers ? { headers: config.headers } : void 0,
-        fetch: sseToJsonFetchIfNeeded()
-      });
-    default:
-      throw new Error(`Unknown MCP transport: ${config.transport}`);
-  }
-}
-async function connectMcpServers(configs, _clientFactory, hooks) {
-  const connections = [];
-  const tools = {};
-  const errors = [];
-  let closed = false;
-  const bootstrapResults = await Promise.all(configs.map((config) => bootstrapServer(config, _clientFactory, hooks)));
-  for (const result of bootstrapResults) {
-    if (!result.ok) {
-      errors.push({ name: result.name, error: result.error });
-      await hooks?.callHook("mcp:error", { name: result.name, error: result.error });
-      continue;
-    }
-    connections.push({ name: result.name, client: result.client });
-    const toolNames = [];
-    for (const tool of result.tools) {
-      const namespacedName = `mcp_${result.config.name}_${tool.name}`;
-      toolNames.push(namespacedName);
-      tools[namespacedName] = buildMcpToolDef(result.config, result.client, tool, namespacedName, hooks);
-    }
-    await hooks?.callHook("mcp:connect", {
-      name: result.name,
-      transport: result.config.transport,
-      tools: toolNames
-    });
-  }
-  if (errors.length > 0 && connections.length === 0) {
-    const messages = errors.map((e) => `${e.name}: ${e.error.message}`).join(", ");
-    throw new Error(`All MCP servers failed to connect: ${messages}`);
-  }
-  return {
-    tools,
-    close: async () => {
-      if (closed)
-        return;
-      closed = true;
-      await Promise.allSettled(
-        connections.map(async ({ name, client }) => {
-          await hooks?.callHook("mcp:close", { name });
-          await client.close();
-        })
-      );
-    }
-  };
-}
-async function bootstrapServer(config, _clientFactory, hooks) {
-  const start = Date.now();
-  if (config.enabledTools && config.disabledTools) {
-    const error = new Error(
-      `MCP server "${config.name}": enabledTools and disabledTools are mutually exclusive \u2014 set one or the other, not both.`
-    );
-    await hooks?.callHook("mcp:bootstrap:start", { name: config.name, transport: config.transport });
-    await hooks?.callHook("mcp:bootstrap:end", {
-      name: config.name,
-      transport: config.transport,
-      durationMs: 0,
-      ok: false,
-      error
-    });
-    return { ok: false, name: config.name, error };
-  }
-  await hooks?.callHook("mcp:bootstrap:start", { name: config.name, transport: config.transport });
-  let client = null;
-  try {
-    client = _clientFactory ? _clientFactory() : new TolerantMcpClient({ name: "zidane", version: "1.0.0" });
-    const currentClient = client;
-    const transport = createTransport(config);
-    const bootstrapTimeout = config.bootstrapTimeout ?? DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS;
-    const { tools: mcpTools } = await raceWithTimeout(
-      async () => {
-        await currentClient.connect(transport);
-        return await currentClient.listTools();
-      },
-      bootstrapTimeout,
-      `MCP server "${config.name}" bootstrap timed out after ${bootstrapTimeout}ms`
-    );
-    const filteredTools = await applyMcpToolFilters(config, mcpTools, hooks);
-    const durationMs = Date.now() - start;
-    await hooks?.callHook("mcp:bootstrap:end", {
-      name: config.name,
-      transport: config.transport,
-      durationMs,
-      ok: true,
-      toolCount: filteredTools.length
-    });
-    return { ok: true, name: config.name, config, client: currentClient, tools: filteredTools };
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    await closeClientQuietly(client);
-    const durationMs = Date.now() - start;
-    await hooks?.callHook("mcp:bootstrap:end", {
-      name: config.name,
-      transport: config.transport,
-      durationMs,
-      ok: false,
-      error
-    });
-    return { ok: false, name: config.name, error };
-  }
-}
-async function applyMcpToolFilters(config, tools, hooks) {
-  let filtered = tools;
-  if (config.enabledTools && config.enabledTools.length > 0) {
-    const allow = new Set(config.enabledTools);
-    filtered = filtered.filter((t) => allow.has(t.name));
-  }
-  if (config.disabledTools && config.disabledTools.length > 0) {
-    const deny = new Set(config.disabledTools);
-    filtered = filtered.filter((t) => !deny.has(t.name));
-  }
-  if (config.toolFilter) {
-    const predicate = config.toolFilter;
-    filtered = filtered.filter((t) => predicate(t));
-  }
-  if (hooks) {
-    const ctx = { server: config.name, transport: config.transport, tools: [...filtered] };
-    await hooks.callHook("mcp:tools:filter", ctx);
-    filtered = ctx.tools;
-  }
-  return filtered;
-}
-function buildMcpToolDef(config, client, tool, namespacedName, hooks) {
-  return {
-    spec: {
-      name: namespacedName,
-      description: tool.description || "",
-      inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
-    },
-    execute: async (input, ctx) => {
-      const { turnId, callId, signal } = ctx;
-      const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName;
-      const gateCtx = {
-        turnId,
-        callId,
-        server: config.name,
-        tool: tool.name,
-        displayName,
-        input,
-        block: false,
-        reason: "MCP tool execution was blocked"
-      };
-      await hooks?.callHook("mcp:tool:gate", gateCtx);
-      if (gateCtx.block)
-        return `Blocked: ${gateCtx.reason}`;
-      const effectiveInput = gateCtx.input;
-      if (gateCtx.result !== void 0) {
-        let substitute = gateCtx.result;
-        const transformCtx = {
-          turnId,
-          callId,
-          server: config.name,
-          tool: tool.name,
-          displayName,
-          input: effectiveInput,
-          result: substitute,
-          outputBytes: toolOutputByteLength(substitute)
-        };
-        await hooks?.callHook("mcp:tool:transform", transformCtx);
-        substitute = transformCtx.result;
-        await hooks?.callHook("mcp:tool:after", {
-          turnId,
-          callId,
-          server: config.name,
-          tool: tool.name,
-          displayName,
-          input: effectiveInput,
-          result: substitute,
-          outputBytes: toolOutputByteLength(substitute)
-        });
-        return substitute;
-      }
-      await hooks?.callHook("mcp:tool:before", {
-        turnId,
-        callId,
-        server: config.name,
-        tool: tool.name,
-        displayName,
-        input: effectiveInput
-      });
-      const timeout = config.toolTimeout ?? 3e4;
-      try {
-        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,
-          callId,
-          server: config.name,
-          tool: tool.name,
-          displayName,
-          input: effectiveInput,
-          result: output,
-          outputBytes: toolOutputByteLength(output)
-        };
-        await hooks?.callHook("mcp:tool:transform", transformCtx);
-        output = transformCtx.result;
-        await hooks?.callHook("mcp:tool:after", {
-          turnId,
-          callId,
-          server: config.name,
-          tool: tool.name,
-          displayName,
-          input: effectiveInput,
-          result: output,
-          outputBytes: toolOutputByteLength(output)
-        });
-        return output;
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        await hooks?.callHook("mcp:tool:error", {
-          turnId,
-          callId,
-          server: config.name,
-          tool: tool.name,
-          displayName,
-          input: effectiveInput,
-          error
-        });
-        await hooks?.callHook("mcp:tool:after", {
-          turnId,
-          callId,
-          server: config.name,
-          tool: tool.name,
-          displayName,
-          input: effectiveInput,
-          result: error.message,
-          outputBytes: Buffer.byteLength(error.message)
-        });
-        throw error;
-      }
-    }
-  };
-}
-async function closeClientQuietly(client) {
-  if (!client)
-    return;
-  try {
-    await client.close();
-  } catch {
-  }
-}
-async function raceWithTimeout(task, timeoutMs, timeoutMessage) {
-  let timer;
-  try {
-    return await new Promise((resolvePromise, rejectPromise) => {
-      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs);
-      task().then(resolvePromise, rejectPromise);
-    });
-  } finally {
-    if (timer)
-      clearTimeout(timer);
-  }
-}
-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,
-  resultToString,
-  normalizeMcpBlocks,
-  connectMcpServers
-};

package/dist/chunk-IC7FT4OD.js

@@ -1,37 +0,0 @@
-// src/stats.ts
-function flattenTurns(stats) {
-  const out = [];
-  collectTurns(stats, out);
-  return out;
-}
-function collectTurns(stats, out) {
-  if (stats.turnUsage)
-    out.push(...stats.turnUsage);
-  if (stats.children) {
-    for (const child of stats.children)
-      collectTurns(child.stats, out);
-  }
-}
-function statsByModel(stats) {
-  const out = /* @__PURE__ */ new Map();
-  for (const turn of flattenTurns(stats)) {
-    const key = turn.modelId ?? "(unknown)";
-    let entry = out.get(key);
-    if (!entry) {
-      entry = { input: 0, output: 0, cost: 0, cacheRead: 0, cacheCreation: 0, turns: 0 };
-      out.set(key, entry);
-    }
-    entry.input += turn.input;
-    entry.output += turn.output;
-    entry.cost += turn.cost ?? 0;
-    entry.cacheRead += turn.cacheRead ?? 0;
-    entry.cacheCreation += turn.cacheCreation ?? 0;
-    entry.turns += 1;
-  }
-  return out;
-}
-
-export {
-  flattenTurns,
-  statsByModel
-};

package/dist/chunk-JCOB6IYO.js

@@ -1,22 +0,0 @@
-import {
-  validateSkillForWrite
-} from "./chunk-6STZTA4N.js";
-
-// src/skills/index.ts
-function defineSkill(config) {
-  const normalized = {
-    ...config,
-    source: config.source ?? "inline"
-  };
-  const result = validateSkillForWrite(normalized);
-  if (!result.valid) {
-    const summary = result.errors.map((e) => `  - [${e.code}] ${e.message}`).join("\n");
-    throw new Error(`Invalid skill "${normalized.name}":
-${summary}`);
-  }
-  return normalized;
-}
-
-export {
-  defineSkill
-};

package/dist/chunk-JH6IAAFA.js

@@ -1,28 +0,0 @@
-// src/types.ts
-import { Buffer } from "buffer";
-function toolResultToText(content) {
-  if (typeof content === "string")
-    return content;
-  return content.map((block) => {
-    if (block.type === "text")
-      return block.text;
-    return `[image: ${block.mediaType} \u2014 ${block.data.length} b64 bytes]`;
-  }).join("\n");
-}
-function toolOutputByteLength(content) {
-  if (typeof content === "string")
-    return Buffer.byteLength(content);
-  let total = 0;
-  for (const block of content) {
-    if (block.type === "text")
-      total += Buffer.byteLength(block.text);
-    else
-      total += block.data.length;
-  }
-  return total;
-}
-
-export {
-  toolResultToText,
-  toolOutputByteLength
-};