@yukino.js/yukino 0.0.1

package/dist/lib/chunk-KA6POJKI.js

@@ -0,0 +1,889 @@
+import {
+  AuthenticationError,
+  ContextTooLongError,
+  LLMError,
+  NetworkError,
+  RateLimitError,
+  clampThinkingLevel,
+  ensureToolPairing,
+  getMaxOutputTokens,
+  getSupportedThinkingLevels,
+  getThinkingLevel,
+  resolveAPIKey,
+  toReasoningEffort
+} from "./chunk-QYBQT2DM.js";
+import {
+  asRecord,
+  asString,
+  contentToText,
+  createChildLogger,
+  isRecord,
+  strArg
+} from "./chunk-6OMQD7MK.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/llm/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  OpenAIClient: () => OpenAIClient,
+  OpenAICompatClient: () => OpenAICompatClient,
+  buildChatCompletionMessages: () => buildChatCompletionMessages,
+  buildOpenAIInput: () => buildOpenAIInput
+});
+import OpenAI from "openai";
+var log = createChildLogger({ module: "llm" });
+function computerActionArguments(action) {
+  switch (action.type) {
+    case "scroll":
+      return {
+        type: "scroll",
+        x: action.x,
+        y: action.y,
+        scrollX: action.scroll_x,
+        scrollY: action.scroll_y,
+        ...action.keys?.length ? { keys: action.keys } : {}
+      };
+    case "click":
+    case "double_click":
+    case "drag":
+    case "move": {
+      const { keys, ...rest } = action;
+      return {
+        ...rest,
+        ...keys?.length ? { keys } : {}
+      };
+    }
+    default:
+      return { ...action };
+  }
+}
+function computerCallArguments(item) {
+  const actions = item.actions ?? (item.action ? [item.action] : []);
+  return {
+    actions: actions.map(computerActionArguments),
+    pendingSafetyChecks: item.pending_safety_checks.map((check) => ({
+      id: check.id,
+      ...check.code ? { code: check.code } : {},
+      ...check.message ? { message: check.message } : {}
+    })),
+    status: item.status
+  };
+}
+function toOpenAIResponsesTool(schema) {
+  if ("input_schema" in schema) {
+    const tool = schema;
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema,
+      strict: tool.strict ?? false
+    };
+  }
+  if ("type" in schema && schema.type === "function" && "parameters" in schema) {
+    return { ...schema };
+  }
+  throw new Error(
+    "OpenAI Responses received a tool schema serialized for another protocol."
+  );
+}
+function toOpenAICompatTool(schema) {
+  if ("input_schema" in schema) {
+    const tool = schema;
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+        strict: tool.strict ?? false
+      }
+    };
+  }
+  if ("function" in schema) {
+    return { ...schema };
+  }
+  throw new Error(
+    "OpenAI Chat Completions received a tool schema serialized for another protocol."
+  );
+}
+var OpenAIClient = class {
+  protocol = "openai";
+  client;
+  model;
+  systemPrompt;
+  maxOutputTokens;
+  thinkingLevel;
+  config;
+  constructor(config, systemPrompt) {
+    const apiKey = resolveAPIKey(config);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "OpenAI API key not found, set OPENAI_API_KEY in ~/.yukino/config.yaml, or via OPENAI_API_KEY env variable."
+      );
+    }
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: config.base_url
+    });
+    this.model = config.model;
+    this.systemPrompt = systemPrompt;
+    this.maxOutputTokens = getMaxOutputTokens(config);
+    this.config = { ...config };
+    this.thinkingLevel = getThinkingLevel(config);
+  }
+  async *stream(conversation, toolSchemas, abortSignal) {
+    const messages = buildOpenAIInput(
+      ensureToolPairing(conversation.getMessages())
+    );
+    const input = [];
+    input.push({
+      role: "system",
+      content: this.systemPrompt
+    });
+    for (const message of messages) {
+      input.push(message);
+    }
+    const tools = toolSchemas.map(toOpenAIResponsesTool);
+    const effort = toReasoningEffort(this.getThinkingLevel(), this.config);
+    const params = {
+      model: this.model,
+      input,
+      stream: true,
+      max_output_tokens: this.maxOutputTokens,
+      ...tools.length > 0 ? { tools } : {},
+      // Only explicit reasoning:false omits the field. Off sends none to defeat
+      // server-default reasoning; requesting a summary while off is unnecessary.
+      ...effort !== null ? {
+        reasoning: {
+          effort,
+          ...effort !== "none" ? { summary: "auto" } : {}
+        }
+      } : {}
+    };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    const cacheCreationInputTokens = 0;
+    try {
+      const stream = await this.client.responses.create(params, {
+        ...abortSignal ? { signal: abortSignal } : {}
+      });
+      let currentToolName = "";
+      let currentToolId = "";
+      let jsonAccumulate = "";
+      let reasoningId = "";
+      let reasoningText = "";
+      let sawTerminalResponse = false;
+      for await (const event of stream) {
+        if (event.type === "response.output_text.delta") {
+          yield {
+            type: "text_delta",
+            text: event.delta
+          };
+        } else if (event.type === "response.reasoning_summary_text.delta") {
+          reasoningText += event.delta;
+          yield { type: "thinking_delta", text: event.delta };
+        } else if (event.type === "response.reasoning_summary_text.done") {
+          yield {
+            type: "thinking_complete",
+            thinking: reasoningText,
+            signature: reasoningId
+          };
+        } else if (event.type === "response.function_call_arguments.delta") {
+          jsonAccumulate += event.delta;
+          yield {
+            type: "tool_call_delta",
+            text: event.delta
+          };
+        } else if (event.type === "response.output_item.added") {
+          if (event.item.type === "function_call") {
+            currentToolName = event.item.name;
+            currentToolId = event.item.call_id;
+            jsonAccumulate = "";
+            yield {
+              type: "tool_call_start",
+              toolName: currentToolName,
+              toolId: currentToolId
+            };
+          } else if (event.item.type === "computer_call") {
+            yield {
+              type: "tool_call_start",
+              toolName: "ComputerUse",
+              toolId: event.item.call_id
+            };
+          } else if (event.item.type === "reasoning") {
+            reasoningId = event.item.id ?? "";
+            reasoningText = "";
+          }
+        } else if (event.type === "response.output_item.done") {
+          if (event.item.type === "function_call" && currentToolName) {
+            let args = {};
+            if (jsonAccumulate) {
+              try {
+                const parsed = JSON.parse(jsonAccumulate);
+                args = isRecord(parsed) ? asRecord(parsed) : {};
+              } catch (err) {
+                log.error({ err }, "llm operation failed");
+                args = {};
+              }
+            }
+            yield {
+              type: "tool_call_complete",
+              toolId: currentToolId,
+              toolName: currentToolName,
+              arguments: args
+            };
+            currentToolName = "";
+            currentToolId = "";
+            jsonAccumulate = "";
+          } else if (event.item.type === "computer_call") {
+            yield {
+              type: "tool_call_complete",
+              toolId: event.item.call_id,
+              toolName: "ComputerUse",
+              arguments: computerCallArguments(event.item),
+              providerItemId: event.item.id
+            };
+          }
+        } else if (event.type === "response.completed" || event.type === "response.incomplete") {
+          sawTerminalResponse = true;
+          const usage = event.response.usage;
+          if (usage) {
+            outputTokens = usage.output_tokens;
+            cacheReadInputTokens = usage.input_tokens_details?.cached_tokens ?? 0;
+            inputTokens = Math.max(
+              0,
+              usage.input_tokens - cacheReadInputTokens
+            );
+          }
+          let stopReason = "end_turn";
+          const resp = event.response;
+          if (event.type === "response.incomplete" || resp.status === "incomplete") {
+            const details = resp.incomplete_details;
+            if (details?.reason === "max_output_tokens") {
+              stopReason = "max_tokens";
+            } else {
+              throw new LLMError(
+                `Response incomplete: ${details?.reason ?? "unknown reason"}`
+              );
+            }
+          }
+          yield {
+            type: "stream_end",
+            stopReason,
+            usage: {
+              inputTokens,
+              outputTokens,
+              cacheReadInputTokens,
+              cacheCreationInputTokens
+              // 0
+            }
+          };
+        } else if (event.type === "response.failed") {
+          const error = event.response.error;
+          const message = `${error?.code ?? "unknown"}: ${error?.message ?? "Response failed"}`;
+          throw containsContextLengthError(message) ? new ContextTooLongError(message) : new LLMError(message);
+        } else if (event.type === "error") {
+          const message = `${event.code ?? "unknown"}: ${event.message}`;
+          throw containsContextLengthError(message) ? new ContextTooLongError(message) : new LLMError(message);
+        }
+      }
+      if (!sawTerminalResponse) {
+        throw new NetworkError(
+          "OpenAI Responses stream ended before a terminal response event"
+        );
+      }
+    } catch (err) {
+      log.error({ err }, "llm operation failed");
+      throw classifyOpenAIError(err);
+    }
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  setMaxOutputTokens(maxTokens) {
+    this.maxOutputTokens = maxTokens;
+  }
+  setThinkingLevel(level) {
+    this.thinkingLevel = clampThinkingLevel(this.config, level);
+    return this.thinkingLevel;
+  }
+  getThinkingLevel() {
+    return this.thinkingLevel;
+  }
+  getSupportedThinkingLevels() {
+    return getSupportedThinkingLevels(this.config);
+  }
+};
+function imageDataUrl(block) {
+  if (!isRecord(block) || block.type !== "image" || !isRecord(block.source)) {
+    return null;
+  }
+  if (block.source.type === "url") {
+    return strArg(block.source, "url") || null;
+  }
+  if (block.source.type !== "base64") {
+    return null;
+  }
+  const mediaType = strArg(block.source, "media_type");
+  const data = strArg(block.source, "data");
+  return mediaType && data ? `data:${mediaType};base64,${data}` : null;
+}
+function documentForResponses(block) {
+  if (!isRecord(block) || block.type !== "document" || !isRecord(block.source)) {
+    return null;
+  }
+  const title = typeof block.title === "string" && block.title ? block.title : "tool-result";
+  if (block.source.type === "url") {
+    const fileUrl = strArg(block.source, "url");
+    return fileUrl ? { type: "input_file", file_url: fileUrl } : null;
+  }
+  if (block.source.type === "base64") {
+    const data = strArg(block.source, "data");
+    return data ? { type: "input_file", file_data: data, filename: `${title}.pdf` } : null;
+  }
+  if (block.source.type === "text") {
+    const data = strArg(block.source, "data");
+    return data ? {
+      type: "input_file",
+      file_data: Buffer.from(data, "utf-8").toString("base64"),
+      filename: `${title}.txt`
+    } : null;
+  }
+  return null;
+}
+function documentForChat(block) {
+  if (!isRecord(block) || block.type !== "document" || !isRecord(block.source)) {
+    return null;
+  }
+  const title = typeof block.title === "string" && block.title ? block.title : "tool-result";
+  if (block.source.type === "base64") {
+    const data = strArg(block.source, "data");
+    return data ? { type: "file", file: { file_data: data, filename: `${title}.pdf` } } : null;
+  }
+  if (block.source.type === "text") {
+    const data = strArg(block.source, "data");
+    return data ? {
+      type: "file",
+      file: {
+        file_data: Buffer.from(data, "utf-8").toString("base64"),
+        filename: `${title}.txt`
+      }
+    } : null;
+  }
+  return null;
+}
+function toolOutputForResponses(tr) {
+  if (!tr.contentBlocks?.length) {
+    return tr.content;
+  }
+  const rich = [];
+  if (tr.content) {
+    rich.push({ type: "input_text", text: tr.content });
+  }
+  for (const block of tr.contentBlocks) {
+    const imageUrl = imageDataUrl(block);
+    if (imageUrl) {
+      rich.push({ type: "input_image", image_url: imageUrl, detail: "auto" });
+      continue;
+    }
+    const file = documentForResponses(block);
+    if (file) {
+      rich.push(file);
+    }
+  }
+  return rich.length > 0 ? rich : tr.content;
+}
+function computerActionsForResponses(args) {
+  if (!Array.isArray(args.actions)) {
+    return [];
+  }
+  const actions = [];
+  for (const raw of args.actions) {
+    if (!isRecord(raw) || typeof raw.type !== "string") {
+      continue;
+    }
+    if (raw.type === "scroll") {
+      actions.push({
+        type: "scroll",
+        x: Number(raw.x),
+        y: Number(raw.y),
+        scroll_x: Number(raw.scrollX),
+        scroll_y: Number(raw.scrollY),
+        ...Array.isArray(raw.keys) ? { keys: raw.keys.map(String) } : {}
+      });
+      continue;
+    }
+    actions.push(raw);
+  }
+  return actions;
+}
+function safetyChecksForResponses(args) {
+  if (!Array.isArray(args.pendingSafetyChecks)) {
+    return [];
+  }
+  return args.pendingSafetyChecks.flatMap((raw) => {
+    if (!isRecord(raw) || typeof raw.id !== "string") {
+      return [];
+    }
+    return [
+      {
+        id: raw.id,
+        ...typeof raw.code === "string" ? { code: raw.code } : {},
+        ...typeof raw.message === "string" ? { message: raw.message } : {}
+      }
+    ];
+  });
+}
+function computerScreenshotUrl(tr) {
+  for (const block of tr.contentBlocks ?? []) {
+    const url = imageDataUrl(block);
+    if (url) {
+      return url;
+    }
+  }
+  return void 0;
+}
+function collectRichParts(tr) {
+  if (!tr.contentBlocks?.length) {
+    return [];
+  }
+  const rich = [];
+  for (const block of tr.contentBlocks) {
+    const imageUrl = imageDataUrl(block);
+    if (imageUrl) {
+      rich.push({ type: "image_url", image_url: { url: imageUrl } });
+      continue;
+    }
+    const file = documentForChat(block);
+    if (file) {
+      rich.push(file);
+    }
+  }
+  if (rich.length === 0) {
+    return [];
+  }
+  return [
+    {
+      type: "text",
+      text: `[Rich content returned by tool call ${tr.toolUseId}]`
+    },
+    ...rich
+  ];
+}
+function userContentsFor(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push({ type: "input_text", text: strArg(block, "text") });
+    } else {
+      const url = imageDataUrl(block);
+      if (url) {
+        parts.push({ type: "input_image", image_url: url, detail: "auto" });
+      }
+    }
+  }
+  return parts;
+}
+function userPartsFor(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      parts.push({ type: "text", text: strArg(block, "text") });
+    } else {
+      const url = imageDataUrl(block);
+      if (url) {
+        parts.push({ type: "image_url", image_url: { url } });
+      }
+    }
+  }
+  return parts;
+}
+function buildOpenAIInput(messages) {
+  const result = [];
+  const computerCalls = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const toolUse of message.toolUses ?? []) {
+      if (toolUse.toolName === "ComputerUse") {
+        computerCalls.set(toolUse.toolUseId, toolUse);
+      }
+    }
+  }
+  for (const m of messages) {
+    if (m.thinkingBlocks) {
+      for (const tb of m.thinkingBlocks) {
+        result.push({
+          type: "reasoning",
+          id: tb.signature,
+          summary: [{ type: "summary_text", text: tb.thinking }]
+        });
+      }
+    }
+    if (m.toolUses && m.toolUses.length > 0) {
+      const assistantText = typeof m.content === "string" ? m.content : contentToText(m.content);
+      if (assistantText) {
+        result.push({
+          role: "assistant",
+          content: assistantText
+        });
+      }
+      for (const tu of m.toolUses) {
+        if (tu.toolName === "ComputerUse") {
+          const status = tu.arguments.status;
+          result.push({
+            type: "computer_call",
+            id: tu.providerItemId ?? tu.toolUseId,
+            call_id: tu.toolUseId,
+            status: status === "in_progress" || status === "incomplete" ? status : "completed",
+            actions: computerActionsForResponses(tu.arguments),
+            pending_safety_checks: safetyChecksForResponses(tu.arguments)
+          });
+        } else {
+          result.push({
+            type: "function_call",
+            name: tu.toolName,
+            call_id: tu.toolUseId,
+            arguments: JSON.stringify(tu.arguments)
+          });
+        }
+      }
+    } else if (m.toolResults && m.toolResults.length > 0) {
+      for (const tr of m.toolResults) {
+        const computerCall = computerCalls.get(tr.toolUseId);
+        if (computerCall) {
+          const imageUrl = computerScreenshotUrl(tr);
+          result.push({
+            type: "computer_call_output",
+            call_id: tr.toolUseId,
+            output: {
+              type: "computer_screenshot",
+              ...imageUrl ? { image_url: imageUrl } : {}
+            },
+            acknowledged_safety_checks: safetyChecksForResponses(
+              computerCall.arguments
+            )
+          });
+          if (tr.isError || !imageUrl) {
+            result.push({ role: "user", content: tr.content });
+          }
+        } else {
+          result.push({
+            type: "function_call_output",
+            call_id: tr.toolUseId,
+            output: toolOutputForResponses(tr)
+          });
+        }
+      }
+      if (m.content.length > 0) {
+        result.push({ role: "user", content: userContentsFor(m.content) });
+      }
+    } else if (m.role === "assistant") {
+      result.push({
+        role: "assistant",
+        content: typeof m.content === "string" ? m.content : contentToText(m.content)
+      });
+    } else {
+      result.push({
+        role: m.role,
+        content: userContentsFor(m.content)
+      });
+    }
+  }
+  return result;
+}
+function containsContextLengthError(msg) {
+  return /context_length_exceeded/i.test(msg) || /maximum\scontext\slength/i.test(msg) || /prompts?\s+too\s+long/i.test(msg);
+}
+var OpenAICompatClient = class {
+  protocol = "openai-compat";
+  client;
+  model;
+  systemPrompt;
+  maxOutputTokens;
+  thinkingLevel;
+  config;
+  constructor(config, systemPrompt) {
+    const apiKey = resolveAPIKey(config);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "OpenAI API key not found. Set OPENAI_API_KEY in ~/.yukino/config.yaml, or via OPENAI_API_KEY env variable."
+      );
+    }
+    this.client = new OpenAI({ apiKey, baseURL: config.base_url });
+    this.model = config.model;
+    this.systemPrompt = systemPrompt;
+    this.maxOutputTokens = getMaxOutputTokens(config);
+    this.config = { ...config };
+    this.thinkingLevel = getThinkingLevel(config);
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  setMaxOutputTokens(maxTokens) {
+    this.maxOutputTokens = maxTokens;
+  }
+  setThinkingLevel(level) {
+    this.thinkingLevel = clampThinkingLevel(this.config, level);
+    return this.thinkingLevel;
+  }
+  getThinkingLevel() {
+    return this.thinkingLevel;
+  }
+  getSupportedThinkingLevels() {
+    return getSupportedThinkingLevels(this.config);
+  }
+  async *stream(conversation, toolSchemas, abortSignal) {
+    const messages = [
+      {
+        role: "system",
+        content: this.systemPrompt
+      },
+      ...buildChatCompletionMessages(
+        ensureToolPairing(conversation.getMessages())
+      )
+    ];
+    const tools = toolSchemas.map(toOpenAICompatTool);
+    const effort = toReasoningEffort(this.getThinkingLevel(), this.config);
+    const params = {
+      model: this.model,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true },
+      max_tokens: this.maxOutputTokens,
+      ...tools.length > 0 ? { tools } : {},
+      // Configured non-reasoning providers omit the field; off otherwise sends
+      // none explicitly so a server default cannot silently enable reasoning.
+      ...effort !== null ? { reasoning_effort: effort } : {}
+    };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    const cacheCreationInputTokens = 0;
+    try {
+      const stream = await this.client.chat.completions.create(params, {
+        ...abortSignal ? { signal: abortSignal } : {}
+      });
+      const toolCalls = /* @__PURE__ */ new Map();
+      let finishReason = null;
+      let reasoningAccumulate = "";
+      for await (const chunk of stream) {
+        if (chunk.usage) {
+          outputTokens = chunk.usage.completion_tokens ?? 0;
+          cacheReadInputTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+          inputTokens = Math.max(
+            0,
+            (chunk.usage.prompt_tokens ?? 0) - cacheReadInputTokens
+          );
+        }
+        if (chunk.choices.length === 0) {
+          continue;
+        }
+        const delta = chunk.choices[0].delta;
+        if (delta.content) {
+          yield { type: "text_delta", text: delta.content };
+        }
+        const reasoningContent = strArg(asRecord(delta), "reasoning_content");
+        if (reasoningContent) {
+          reasoningAccumulate += reasoningContent;
+          yield { type: "thinking_delta", text: reasoningContent };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            if (!toolCalls.has(tc.index)) {
+              toolCalls.set(tc.index, {
+                id: tc.id ?? "",
+                name: tc.function?.name ?? "",
+                args: ""
+              });
+              if (tc.id) {
+                yield {
+                  type: "tool_call_start",
+                  toolName: tc.function?.name ?? "",
+                  toolId: tc.id ?? ""
+                };
+              }
+            }
+            const existing = toolCalls.get(tc.index);
+            if (existing) {
+              if (tc.id) {
+                existing.id = tc.id;
+              }
+              if (tc.function?.name) {
+                existing.name = tc.function.name;
+              }
+              if (tc.function?.arguments) {
+                existing.args += tc.function.arguments;
+                yield {
+                  type: "tool_call_delta",
+                  text: tc.function.arguments
+                };
+              }
+            }
+          }
+        }
+        if (chunk.choices[0].finish_reason) {
+          finishReason = chunk.choices[0].finish_reason;
+          if (reasoningAccumulate) {
+            yield {
+              type: "thinking_complete",
+              thinking: reasoningAccumulate,
+              signature: ""
+            };
+            reasoningAccumulate = "";
+          }
+          for (const tu of toolCalls.values()) {
+            let args = {};
+            const jsonArgs = tu.args;
+            if (jsonArgs) {
+              try {
+                const parsed = JSON.parse(jsonArgs);
+                args = isRecord(parsed) ? asRecord(parsed) : {};
+              } catch (err) {
+                log.error({ err }, "llm operation failed");
+                args = {};
+              }
+              yield {
+                type: "tool_call_complete",
+                toolName: tu.name,
+                toolId: tu.id,
+                arguments: args
+              };
+            }
+          }
+        }
+      }
+      if (finishReason === null) {
+        throw new NetworkError(
+          "Chat Completions stream ended before a finish reason"
+        );
+      }
+      let stopReason;
+      if (finishReason === "length") {
+        stopReason = "max_tokens";
+      } else if (finishReason === "tool_calls" || toolCalls.size > 0) {
+        stopReason = "tool_use";
+      } else {
+        stopReason = "end_turn";
+      }
+      yield {
+        type: "stream_end",
+        stopReason,
+        usage: {
+          inputTokens,
+          outputTokens,
+          cacheReadInputTokens,
+          cacheCreationInputTokens
+        }
+      };
+    } catch (err) {
+      log.error({ err }, "llm operation failed");
+      throw classifyOpenAIError(err);
+    }
+  }
+};
+function classifyOpenAIError(err) {
+  if (err instanceof LLMError) {
+    return err;
+  }
+  if (err instanceof OpenAI.APIError) {
+    if (err.status === 413 /* PromptTooLong */ || err.status === 400 /* BadRequest */ && containsContextLengthError(err.message)) {
+      return new ContextTooLongError(`Context Too Long: ${err.message}`);
+    }
+    if (err.status === 401 /* InvalidAPIKey */) {
+      return new AuthenticationError(`Invalid API key: ${err.message}`);
+    }
+    if (err.status === 429 /* RateLimitError */) {
+      const headers = err.headers;
+      return new RateLimitError(
+        "Rate limit error, please wait.",
+        headers instanceof Headers ? headers.get("retry-after") ?? void 0 : void 0
+      );
+    }
+    return new LLMError(
+      `OpenAI API error (${asString(err.status)}): ${err.message}`
+    );
+  }
+  return new NetworkError(
+    `Network error: ${err instanceof Error ? err.message : asString(err)}`
+  );
+}
+function buildChatCompletionMessages(messages) {
+  const params = [];
+  for (const m of messages) {
+    const reasoning = m.thinkingBlocks?.map((tb) => tb.thinking).join("") ?? "";
+    const assistantText = typeof m.content === "string" ? m.content : contentToText(m.content);
+    if (m.toolUses && m.toolUses.length > 0) {
+      params.push({
+        role: "assistant",
+        content: assistantText || null,
+        ...reasoning ? { reasoning_content: reasoning } : {},
+        tool_calls: m.toolUses.map((tu) => ({
+          id: tu.toolUseId,
+          type: "function",
+          function: {
+            name: tu.toolName,
+            arguments: JSON.stringify(tu.arguments)
+          }
+        }))
+      });
+    } else if (m.toolResults && m.toolResults.length > 0) {
+      const pendingRichParts = [];
+      for (const tr of m.toolResults) {
+        params.push({
+          role: "tool",
+          tool_call_id: tr.toolUseId,
+          content: tr.content
+        });
+        pendingRichParts.push(...collectRichParts(tr));
+      }
+      if (m.content.length > 0) {
+        const content = userPartsFor(m.content);
+        pendingRichParts.push(
+          ...typeof content === "string" ? [{ type: "text", text: content }] : content
+        );
+      }
+      if (pendingRichParts.length > 0) {
+        params.push({
+          role: "user",
+          content: pendingRichParts
+        });
+      }
+    } else if (m.role === "assistant") {
+      params.push({
+        role: "assistant",
+        content: assistantText,
+        ...reasoning ? {
+          reasoning_content: reasoning
+        } : {}
+      });
+    } else if (m.role === "system") {
+      params.push({
+        role: "system",
+        content: typeof m.content === "string" ? m.content : contentToText(m.content)
+      });
+    } else {
+      params.push({
+        role: "user",
+        content: userPartsFor(m.content)
+      });
+    }
+  }
+  return params;
+}
+
+export {
+  OpenAIClient,
+  buildOpenAIInput,
+  OpenAICompatClient,
+  buildChatCompletionMessages,
+  openai_exports
+};