zidane 4.0.2 → 4.1.3

package/dist/chunk-4ILGBQ23.js

@@ -1,803 +0,0 @@
-import {
-  matchesContextExceeded
-} from "./chunk-LNN5UTS2.js";
-
-// src/providers/openai-compat.ts
-var TOOL_RESULTS_TAG = "__zidane_tool_results__";
-var ASSISTANT_TOOL_CALLS_TAG = "__zidane_assistant_tc__";
-var SSE_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
-var OpenAICompatStreamError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "OpenAICompatStreamError";
-  }
-};
-async function consumeSSE(response, callbacks, signal) {
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let text = "";
-  let thinking = "";
-  let finishReason = "stop";
-  let usage = { input: 0, output: 0 };
-  const tcMap = /* @__PURE__ */ new Map();
-  const reasoningMap = /* @__PURE__ */ new Map();
-  let sawReasoningDetails = false;
-  try {
-    while (true) {
-      if (signal?.aborted)
-        break;
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      if (buffer.length > SSE_MAX_BUFFER_BYTES) {
-        throw new OpenAICompatStreamError(
-          `SSE buffer exceeded ${SSE_MAX_BUFFER_BYTES} bytes without a line boundary \u2014 upstream may be streaming non-SSE data.`
-        );
-      }
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.startsWith("data: "))
-          continue;
-        const data = line.slice(6).trim();
-        if (data === "[DONE]")
-          continue;
-        let chunk;
-        try {
-          chunk = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        const choices = chunk.choices;
-        const choice = choices?.[0];
-        if (!choice)
-          continue;
-        const fr = choice.finish_reason;
-        if (fr)
-          finishReason = fr;
-        const delta = choice.delta;
-        const reasoningDeltaArr = delta?.reasoning_details;
-        if (reasoningDeltaArr && reasoningDeltaArr.length > 0) {
-          sawReasoningDetails = true;
-          for (const item of reasoningDeltaArr) {
-            const idx = typeof item.index === "number" ? item.index : 0;
-            const existing = reasoningMap.get(idx) ?? {};
-            if (typeof item.text === "string") {
-              existing.text = (existing.text ?? "") + item.text;
-              thinking += item.text;
-              callbacks.onThinking?.(item.text);
-            }
-            if (typeof item.summary === "string") {
-              existing.summary = (existing.summary ?? "") + item.summary;
-              thinking += item.summary;
-              callbacks.onThinking?.(item.summary);
-            }
-            for (const key of ["type", "signature", "data", "format", "id"]) {
-              const v = item[key];
-              if (typeof v === "string")
-                existing[key] = v;
-            }
-            reasoningMap.set(idx, existing);
-          }
-        }
-        if (!sawReasoningDetails) {
-          const thinkingDelta = delta?.reasoning_content ?? delta?.reasoning;
-          if (thinkingDelta) {
-            thinking += thinkingDelta;
-            callbacks.onThinking?.(thinkingDelta);
-          }
-        }
-        const contentDelta = delta?.content;
-        if (contentDelta) {
-          text += contentDelta;
-          callbacks.onText(contentDelta);
-        }
-        const toolCallsDelta = delta?.tool_calls;
-        if (toolCallsDelta) {
-          for (const tc of toolCallsDelta) {
-            const existing = tcMap.get(tc.index);
-            if (existing) {
-              if (tc.function?.arguments)
-                existing.args += tc.function.arguments;
-            } else {
-              tcMap.set(tc.index, {
-                id: tc.id || `call_${tc.index}`,
-                name: tc.function?.name || "",
-                args: tc.function?.arguments || ""
-              });
-            }
-          }
-        }
-        const chunkUsage = chunk.usage;
-        if (chunkUsage) {
-          const cachedRead = chunkUsage.prompt_tokens_details?.cached_tokens;
-          const cachedWrite = chunkUsage.prompt_tokens_details?.cache_creation_input_tokens ?? chunkUsage.prompt_tokens_details?.cache_write_tokens ?? chunkUsage.cache_creation_input_tokens;
-          usage = {
-            input: chunkUsage.prompt_tokens ?? 0,
-            output: chunkUsage.completion_tokens ?? 0,
-            cost: chunkUsage.total_cost ?? void 0,
-            ...typeof cachedRead === "number" && cachedRead > 0 ? { cacheRead: cachedRead } : {},
-            ...typeof cachedWrite === "number" && cachedWrite > 0 ? { cacheCreation: cachedWrite } : {}
-          };
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const toolCalls = [];
-  for (const tc of tcMap.values()) {
-    if (!tc.args) {
-      toolCalls.push({ id: tc.id, name: tc.name, input: {} });
-      continue;
-    }
-    try {
-      toolCalls.push({ id: tc.id, name: tc.name, input: JSON.parse(tc.args) });
-    } catch (err) {
-      throw new OpenAICompatStreamError(
-        `Tool call "${tc.name}" (${tc.id}) arguments were truncated or malformed: ${err.message}`
-      );
-    }
-  }
-  const reasoningDetails = Array.from(reasoningMap.entries()).sort(([a], [b]) => a - b).map(([, item]) => item);
-  return { text, thinking, toolCalls, finishReason, usage, reasoningDetails };
-}
-function toImageUrlPart(img) {
-  return {
-    type: "image_url",
-    image_url: { url: `data:${img.mediaType};base64,${img.data}` }
-  };
-}
-function summarizeToolResultOutput(output) {
-  if (typeof output === "string")
-    return { text: output, images: [] };
-  const texts = [];
-  const images = [];
-  for (const block of output) {
-    if (block.type === "text")
-      texts.push(block.text);
-    else if (block.type === "image")
-      images.push({ mediaType: block.mediaType, data: block.data });
-  }
-  return { text: texts.join("\n"), images };
-}
-function toOAIMessages(system, messages, options = {}) {
-  const out = [{ role: "system", content: system }];
-  const nativeImageInTool = options.imageInToolResult === true;
-  const reasoningEnabled = options.supportsReasoning === true;
-  const activeModel = options.model;
-  for (const msg of messages) {
-    const toolResults = msg.content.filter((b) => b.type === "tool_result");
-    const toolCalls = msg.content.filter((b) => b.type === "tool_call");
-    const textBlocks = msg.content.filter((b) => b.type === "text");
-    const imageBlocks = msg.content.filter((b) => b.type === "image");
-    const reasoningBlocks = reasoningEnabled ? msg.content.filter((b) => {
-      if (b.type !== "provider_reasoning")
-        return false;
-      if (b.producer !== "openrouter")
-        return false;
-      if (b.model && activeModel && b.model !== activeModel)
-        return false;
-      return true;
-    }) : [];
-    const reasoningDetails = reasoningBlocks.flatMap((b) => b.details);
-    if (toolResults.length > 0) {
-      for (const tr of toolResults) {
-        if (typeof tr.output === "string") {
-          out.push({ role: "tool", tool_call_id: tr.callId, content: tr.output });
-          continue;
-        }
-        if (nativeImageInTool) {
-          const parts = tr.output.map((block) => block.type === "image" ? toImageUrlPart({ mediaType: block.mediaType, data: block.data }) : { type: "text", text: block.text });
-          out.push({ role: "tool", tool_call_id: tr.callId, content: parts });
-          continue;
-        }
-        const { text, images } = summarizeToolResultOutput(tr.output);
-        if (images.length === 0) {
-          out.push({ role: "tool", tool_call_id: tr.callId, content: text });
-          continue;
-        }
-        const noun = images.length === 1 ? "image" : "images";
-        const attachedMarker = `[${images.length} ${noun} attached \u2014 see next user message]`;
-        const toolMarker = text.length > 0 ? `${text}
-
-${attachedMarker}` : attachedMarker;
-        out.push({ role: "tool", tool_call_id: tr.callId, content: toolMarker });
-        out.push({
-          role: "user",
-          content: [
-            ...images.map(toImageUrlPart),
-            { type: "text", text: `(${noun} returned by tool call ${tr.callId})` }
-          ]
-        });
-      }
-      continue;
-    }
-    if (toolCalls.length > 0) {
-      const textContent = textBlocks.length > 0 ? textBlocks[0].text : null;
-      const m = {
-        role: "assistant",
-        content: textContent,
-        tool_calls: toolCalls.map((tc) => ({
-          id: tc.id,
-          type: "function",
-          function: { name: tc.name, arguments: JSON.stringify(tc.input) }
-        }))
-      };
-      if (reasoningDetails.length > 0)
-        m.reasoning_details = reasoningDetails;
-      out.push(m);
-      continue;
-    }
-    if (imageBlocks.length > 0) {
-      const parts = imageBlocks.map((img) => ({
-        type: "image_url",
-        image_url: { url: `data:${img.mediaType};base64,${img.data}` }
-      }));
-      for (const b of textBlocks) {
-        parts.push({ type: "text", text: b.text });
-      }
-      const m = { role: msg.role, content: parts };
-      if (msg.role === "assistant" && reasoningDetails.length > 0)
-        m.reasoning_details = reasoningDetails;
-      out.push(m);
-      continue;
-    }
-    let pushed;
-    if (textBlocks.length === 1) {
-      pushed = { role: msg.role, content: textBlocks[0].text };
-    } else if (textBlocks.length > 1) {
-      pushed = { role: msg.role, content: textBlocks.map((b) => ({ type: "text", text: b.text })) };
-    } else {
-      pushed = { role: msg.role, content: null };
-    }
-    if (msg.role === "assistant" && reasoningDetails.length > 0)
-      pushed.reasoning_details = reasoningDetails;
-    out.push(pushed);
-  }
-  return out;
-}
-var EPHEMERAL = { type: "ephemeral" };
-function applyOAICacheBreakpoints(messages) {
-  if (messages.length === 0)
-    return;
-  const first = messages[0];
-  if (first.role === "system")
-    markLastContentPart(first);
-  const lastIdx = messages.length - 1;
-  if (lastIdx > 0)
-    markLastContentPart(messages[lastIdx]);
-}
-function markLastContentPart(msg) {
-  if (typeof msg.content === "string") {
-    if (msg.content.length === 0)
-      return;
-    msg.content = [{ type: "text", text: msg.content, cache_control: EPHEMERAL }];
-    return;
-  }
-  if (!Array.isArray(msg.content) || msg.content.length === 0)
-    return;
-  const parts = msg.content;
-  const lastBlockIdx = parts.length - 1;
-  parts[lastBlockIdx] = { ...parts[lastBlockIdx], cache_control: EPHEMERAL };
-}
-function applyOAIToolCacheBreakpoint(tools) {
-  if (tools.length === 0)
-    return tools;
-  const lastIdx = tools.length - 1;
-  return tools.map(
-    (tool, i) => i === lastIdx ? { ...tool, cache_control: EPHEMERAL } : tool
-  );
-}
-function formatTools(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: { name: t.name, description: t.description, parameters: t.inputSchema }
-  }));
-}
-function userMessage(content) {
-  return { role: "user", content: [{ type: "text", text: content }] };
-}
-function assistantMessage(content) {
-  return { role: "assistant", content: [{ type: "text", text: content }] };
-}
-function toolResultsMessage(results) {
-  return {
-    role: "user",
-    content: results.map((r) => ({
-      type: "tool_result",
-      callId: r.id,
-      output: r.content
-    }))
-  };
-}
-function buildAssistantContent(text, toolCalls, thinking, reasoning) {
-  const content = [];
-  if (reasoning && reasoning.details.length > 0) {
-    const block = {
-      type: "provider_reasoning",
-      producer: reasoning.producer,
-      details: reasoning.details
-    };
-    if (reasoning.model)
-      block.model = reasoning.model;
-    content.push(block);
-  }
-  if (thinking)
-    content.push({ type: "thinking", text: thinking });
-  if (text)
-    content.push({ type: "text", text });
-  for (const tc of toolCalls) {
-    content.push({ type: "tool_call", id: tc.id, name: tc.name, input: tc.input });
-  }
-  return { role: "assistant", content };
-}
-var OpenAICompatHttpError = class extends Error {
-  status;
-  providerCode;
-  bodyText;
-  constructor(status, bodyText) {
-    let message = bodyText;
-    let code;
-    try {
-      const parsed = JSON.parse(bodyText);
-      message = parsed?.error?.message ?? bodyText;
-      code = parsed?.error?.code ?? parsed?.error?.type;
-    } catch {
-    }
-    super(`HTTP ${status}: ${message}`);
-    this.name = "OpenAICompatHttpError";
-    this.status = status;
-    this.providerCode = code;
-    this.bodyText = bodyText;
-  }
-};
-var TRAILING_SLASH_RE = /\/$/;
-function classifyOpenAICompatError(err) {
-  if (!err || typeof err !== "object")
-    return null;
-  if (err.name === "AbortError")
-    return { kind: "aborted" };
-  if (err instanceof OpenAICompatStreamError) {
-    return {
-      kind: "provider_error",
-      providerCode: "stream_error",
-      message: err.message,
-      retryable: true
-    };
-  }
-  if (!(err instanceof OpenAICompatHttpError))
-    return null;
-  const code = err.providerCode;
-  const msg = err.message;
-  if (code === "context_length_exceeded" || matchesContextExceeded(msg)) {
-    return {
-      kind: "context_exceeded",
-      providerCode: code ?? "context_length_exceeded",
-      message: msg
-    };
-  }
-  return {
-    kind: "provider_error",
-    providerCode: code ?? String(err.status),
-    message: msg,
-    retryable: isRetryableHttpStatus(err.status)
-  };
-}
-function isRetryableHttpStatus(status) {
-  if (status === 429)
-    return true;
-  if (status >= 500 && status !== 501)
-    return true;
-  return false;
-}
-function mapOAIFinishReason(reason) {
-  if (!reason)
-    return void 0;
-  switch (reason) {
-    case "stop":
-      return "stop";
-    case "tool_calls":
-    case "function_call":
-      return "tool-calls";
-    case "length":
-      return "length";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "other";
-  }
-}
-function planOpenRouterReasoning(thinking, thinkingBudget) {
-  if ((!thinking || thinking === "off") && typeof thinkingBudget !== "number")
-    return void 0;
-  const out = {};
-  if (thinking && thinking !== "off" && thinking !== "adaptive") {
-    out.effort = thinking === "minimal" ? "low" : thinking;
-  }
-  if (typeof thinkingBudget === "number" && thinkingBudget > 0) {
-    out.max_tokens = thinkingBudget;
-  }
-  return out;
-}
-function openaiCompat(params) {
-  const name = params.name ?? "openai-compat";
-  const defaultModel = params.defaultModel ?? "gpt-4o-mini";
-  const authHeaderName = params.authHeader?.name ?? "Authorization";
-  const authHeaderValue = params.authHeader?.scheme ? `${params.authHeader.scheme} ${params.apiKey}` : params.authHeader ? params.apiKey : `Bearer ${params.apiKey}`;
-  const extraHeaders = params.extraHeaders ?? {};
-  const endpoint = `${params.baseURL.replace(TRAILING_SLASH_RE, "")}/chat/completions`;
-  const capabilities = {
-    vision: params.capabilities?.vision ?? false,
-    imageInToolResult: params.capabilities?.imageInToolResult ?? false
-  };
-  const cacheBreakpointsEnabled = params.cacheBreakpoints === true;
-  const reasoningEnabled = params.supportsReasoning === true;
-  return {
-    name,
-    meta: { defaultModel, capabilities },
-    formatTools,
-    userMessage,
-    assistantMessage,
-    toolResultsMessage,
-    classifyError: classifyOpenAICompatError,
-    async stream(options, callbacks) {
-      const modelId = options.model || defaultModel;
-      const messages = toOAIMessages(options.system, options.messages, {
-        imageInToolResult: capabilities.imageInToolResult === true,
-        supportsReasoning: reasoningEnabled,
-        model: modelId
-      });
-      const shouldCache = cacheBreakpointsEnabled && options.cache !== false;
-      if (shouldCache) {
-        applyOAICacheBreakpoints(messages);
-      }
-      const maxTokens = options.thinkingBudget ? options.thinkingBudget + options.maxTokens : options.maxTokens;
-      const body = {
-        // Spread first so the typed core below wins on collision — explicit
-        // always overrides generic.
-        ...params.extraBodyParams ?? {},
-        model: modelId,
-        messages,
-        max_tokens: maxTokens,
-        stream: true
-      };
-      if (reasoningEnabled) {
-        const reasoning = planOpenRouterReasoning(options.thinking, options.thinkingBudget);
-        if (reasoning)
-          body.reasoning = reasoning;
-      }
-      if (options.tools && options.tools.length > 0) {
-        body.tools = shouldCache ? applyOAIToolCacheBreakpoint(options.tools) : options.tools;
-      }
-      if (options.toolChoice) {
-        if (options.toolChoice.type === "tool" && options.toolChoice.name)
-          body.tool_choice = { type: "function", function: { name: options.toolChoice.name } };
-        else if (options.toolChoice.type === "required")
-          body.tool_choice = "required";
-        else
-          body.tool_choice = "auto";
-      }
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          [authHeaderName]: authHeaderValue,
-          "Content-Type": "application/json",
-          ...extraHeaders
-        },
-        body: JSON.stringify(body),
-        signal: options.signal
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new OpenAICompatHttpError(response.status, errorText);
-      }
-      const result = await consumeSSE(response, callbacks, options.signal);
-      const finishReason = mapOAIFinishReason(result.finishReason);
-      return {
-        assistantMessage: buildAssistantContent(
-          result.text,
-          result.toolCalls,
-          result.thinking,
-          reasoningEnabled && result.reasoningDetails.length > 0 ? { details: result.reasoningDetails, producer: "openrouter", model: modelId } : void 0
-        ),
-        text: result.text,
-        toolCalls: result.toolCalls,
-        done: result.finishReason === "stop" || result.toolCalls.length === 0,
-        usage: {
-          input: result.usage.input,
-          output: result.usage.output,
-          ...result.usage.cacheRead !== void 0 ? { cacheRead: result.usage.cacheRead } : {},
-          ...result.usage.cacheCreation !== void 0 ? { cacheCreation: result.usage.cacheCreation } : {},
-          ...result.usage.cost !== void 0 ? { cost: result.usage.cost } : {},
-          ...finishReason ? { finishReason } : {},
-          modelId
-        }
-      };
-    }
-  };
-}
-
-// src/session/messages.ts
-function decodeAnthropicToolResultContent(content) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return JSON.stringify(content);
-  const blocks = [];
-  for (const raw of content) {
-    if (!raw || typeof raw !== "object")
-      continue;
-    const b = raw;
-    if (b.type === "text" && typeof b.text === "string") {
-      blocks.push({ type: "text", text: b.text });
-      continue;
-    }
-    if (b.type === "image" && b.source && typeof b.source === "object") {
-      const src = b.source;
-      if (src.type === "base64" && typeof src.data === "string" && typeof src.media_type === "string") {
-        blocks.push({ type: "image", mediaType: src.media_type, data: src.data });
-        continue;
-      }
-    }
-    blocks.push({ type: "text", text: JSON.stringify(raw) });
-  }
-  if (blocks.length === 0)
-    return "";
-  const hasNonText = blocks.some((b) => b.type !== "text");
-  if (!hasNonText)
-    return blocks.map((b) => b.text).join("\n");
-  return blocks;
-}
-function encodeAnthropicToolResultContent(output) {
-  if (typeof output === "string")
-    return output;
-  return output.map((b) => {
-    if (b.type === "text")
-      return { type: "text", text: b.text };
-    return {
-      type: "image",
-      source: { type: "base64", media_type: b.mediaType, data: b.data }
-    };
-  });
-}
-function fromAnthropic(msg) {
-  const role = msg.role;
-  const content = [];
-  if (typeof msg.content === "string") {
-    content.push({ type: "text", text: msg.content });
-    return { role, content };
-  }
-  if (Array.isArray(msg.content)) {
-    for (const block of msg.content) {
-      if (!block || typeof block !== "object")
-        continue;
-      const b = block;
-      if (b.type === "text") {
-        content.push({ type: "text", text: b.text });
-      } else if (b.type === "image") {
-        const source = b.source;
-        if (source?.type === "base64") {
-          content.push({ type: "image", mediaType: source.media_type, data: source.data });
-        }
-      } else if (b.type === "tool_use") {
-        content.push({ type: "tool_call", id: b.id, name: b.name, input: b.input });
-      } else if (b.type === "tool_result") {
-        const output = decodeAnthropicToolResultContent(b.content);
-        const block2 = {
-          type: "tool_result",
-          callId: b.tool_use_id,
-          output
-        };
-        if (b.is_error === true)
-          block2.isError = true;
-        content.push(block2);
-      } else if (b.type === "thinking") {
-        const block2 = {
-          type: "thinking",
-          text: b.thinking ?? ""
-        };
-        if (typeof b.signature === "string") {
-          block2.signature = b.signature;
-          block2.signatureProducer = "anthropic";
-        }
-        content.push(block2);
-      } else if (b.type === "redacted_thinking") {
-        content.push({ type: "redacted_thinking", data: b.data ?? "" });
-      }
-    }
-  }
-  return { role, content };
-}
-function fromOpenAI(msg) {
-  const role = msg.role;
-  const content = [];
-  const c = msg.content;
-  if (c == null) {
-    return { role, content };
-  }
-  if (typeof c === "string") {
-    content.push({ type: "text", text: c });
-    return { role, content };
-  }
-  if (typeof c === "object" && !Array.isArray(c) && c._tag === ASSISTANT_TOOL_CALLS_TAG) {
-    const tagged = c;
-    if (typeof tagged.text === "string" && tagged.text) {
-      content.push({ type: "text", text: tagged.text });
-    }
-    if (Array.isArray(tagged.tool_calls)) {
-      for (const raw of tagged.tool_calls) {
-        if (!raw || typeof raw !== "object")
-          continue;
-        const tc = raw;
-        const rawArgs = tc.function?.arguments;
-        const input = rawArgs ? typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs : {};
-        content.push({ type: "tool_call", id: tc.id ?? "", name: tc.function?.name ?? "", input });
-      }
-    }
-    return { role, content };
-  }
-  if (typeof c === "object" && !Array.isArray(c) && c._tag === TOOL_RESULTS_TAG) {
-    const tagged = c;
-    if (Array.isArray(tagged.results)) {
-      for (const raw of tagged.results) {
-        if (!raw || typeof raw !== "object")
-          continue;
-        const r = raw;
-        content.push({ type: "tool_result", callId: r.tool_call_id ?? "", output: r.content ?? "" });
-      }
-    }
-    return { role, content };
-  }
-  if (Array.isArray(c)) {
-    for (const block of c) {
-      if (!block || typeof block !== "object")
-        continue;
-      const b = block;
-      if (b.type === "text") {
-        content.push({ type: "text", text: b.text });
-      } else if (b.type === "image_url") {
-        const imageUrl = b.image_url?.url;
-        if (imageUrl?.startsWith("data:")) {
-          const [meta, data] = imageUrl.slice(5).split(",", 2);
-          const mediaType = meta.replace(";base64", "");
-          content.push({ type: "image", mediaType, data });
-        }
-      }
-    }
-    return { role, content };
-  }
-  return { role, content };
-}
-function toAnthropic(msg) {
-  const blocks = msg.content.filter((b) => !(b.type === "thinking" && b.signatureProducer === "openai")).filter((b) => b.type !== "provider_reasoning").map((block) => {
-    switch (block.type) {
-      case "text":
-        return { type: "text", text: block.text };
-      case "image":
-        return { type: "image", source: { type: "base64", media_type: block.mediaType, data: block.data } };
-      case "tool_call":
-        return { type: "tool_use", id: block.id, name: block.name, input: block.input };
-      case "tool_result": {
-        const out = {
-          type: "tool_result",
-          tool_use_id: block.callId,
-          content: encodeAnthropicToolResultContent(block.output)
-        };
-        if (block.isError)
-          out.is_error = true;
-        return out;
-      }
-      case "thinking": {
-        const out = { type: "thinking", thinking: block.text };
-        if (block.signature)
-          out.signature = block.signature;
-        return out;
-      }
-      case "redacted_thinking":
-        return { type: "redacted_thinking", data: block.data };
-      default:
-        return { type: "text", text: "" };
-    }
-  });
-  if (blocks.length === 1 && blocks[0].type === "text") {
-    return { role: msg.role, content: blocks[0].text };
-  }
-  return { role: msg.role, content: blocks };
-}
-function toOpenAI(msg) {
-  const toolCalls = msg.content.filter((b) => b.type === "tool_call");
-  const toolResults = msg.content.filter((b) => b.type === "tool_result");
-  const textBlocks = msg.content.filter((b) => b.type === "text");
-  const imageBlocks = msg.content.filter((b) => b.type === "image");
-  if (toolResults.length > 0) {
-    return {
-      role: msg.role,
-      content: {
-        _tag: TOOL_RESULTS_TAG,
-        results: toolResults.map((b) => {
-          const tr = b;
-          return { tool_call_id: tr.callId, content: tr.output };
-        })
-      }
-    };
-  }
-  if (toolCalls.length > 0) {
-    const textContent = textBlocks.length > 0 ? textBlocks[0].text : null;
-    return {
-      role: msg.role,
-      content: {
-        _tag: ASSISTANT_TOOL_CALLS_TAG,
-        text: textContent,
-        tool_calls: toolCalls.map((b) => {
-          const tc = b;
-          return {
-            id: tc.id,
-            type: "function",
-            function: { name: tc.name, arguments: JSON.stringify(tc.input) }
-          };
-        })
-      }
-    };
-  }
-  if (imageBlocks.length > 0) {
-    const parts = imageBlocks.map((b) => {
-      const img = b;
-      return { type: "image_url", image_url: { url: `data:${img.mediaType};base64,${img.data}` } };
-    });
-    for (const b of textBlocks) {
-      parts.push({ type: "text", text: b.text });
-    }
-    return { role: msg.role, content: parts };
-  }
-  if (textBlocks.length === 1) {
-    return { role: msg.role, content: textBlocks[0].text };
-  }
-  if (textBlocks.length > 1) {
-    return { role: msg.role, content: textBlocks.map((b) => ({ type: "text", text: b.text })) };
-  }
-  return { role: msg.role, content: null };
-}
-function autoDetectAndConvert(msg) {
-  const c = msg.content;
-  if (c && typeof c === "object" && !Array.isArray(c)) {
-    const tag = c._tag;
-    if (typeof tag === "string" && tag.startsWith("__zidane_"))
-      return fromOpenAI(msg);
-  }
-  if (Array.isArray(c)) {
-    for (const block of c) {
-      if (!block || typeof block !== "object")
-        continue;
-      const b = block;
-      if (b.type === "tool_use" || b.type === "tool_result" && "tool_use_id" in b) {
-        return fromAnthropic(msg);
-      }
-      if (b.type === "image_url") {
-        return fromOpenAI(msg);
-      }
-    }
-    return fromAnthropic(msg);
-  }
-  if (typeof c === "string") {
-    return fromAnthropic(msg);
-  }
-  return fromAnthropic(msg);
-}
-
-export {
-  userMessage,
-  assistantMessage,
-  toolResultsMessage,
-  OpenAICompatHttpError,
-  classifyOpenAICompatError,
-  mapOAIFinishReason,
-  openaiCompat,
-  fromAnthropic,
-  fromOpenAI,
-  toAnthropic,
-  toOpenAI,
-  autoDetectAndConvert
-};