@prestyj/ai 4.2.15

package/dist/index.js

@@ -0,0 +1,1071 @@
+// src/errors.ts
+var GGAIError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "GGAIError";
+  }
+};
+var ProviderError = class extends GGAIError {
+  provider;
+  statusCode;
+  constructor(provider, message, options) {
+    super(`[${provider}] ${message}`, { cause: options?.cause });
+    this.name = "ProviderError";
+    this.provider = provider;
+    this.statusCode = options?.statusCode;
+  }
+};
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/utils/event-stream.ts
+var EventStream = class {
+  queue = [];
+  resolve = null;
+  done = false;
+  error = null;
+  push(event) {
+    if (this.queue.length > 5e4) {
+      this.queue.splice(0, this.queue.length - 25e3);
+    }
+    this.queue.push(event);
+    this.resolve?.();
+    this.resolve = null;
+  }
+  close() {
+    this.done = true;
+    this.resolve?.();
+    this.resolve = null;
+  }
+  abort(error) {
+    this.error = error;
+    this.done = true;
+    this.resolve?.();
+    this.resolve = null;
+  }
+  async *[Symbol.asyncIterator]() {
+    let index = 0;
+    while (true) {
+      while (index < this.queue.length) {
+        yield this.queue[index++];
+      }
+      this.queue.splice(0, index);
+      index = 0;
+      if (this.error) throw this.error;
+      if (this.done) return;
+      await new Promise((r) => {
+        this.resolve = r;
+      });
+    }
+  }
+};
+var StreamResult = class {
+  events;
+  response;
+  resolveResponse;
+  rejectResponse;
+  hasConsumer = false;
+  constructor() {
+    this.events = new EventStream();
+    this.response = new Promise((resolve, reject) => {
+      this.resolveResponse = resolve;
+      this.rejectResponse = reject;
+    });
+  }
+  push(event) {
+    this.events.push(event);
+  }
+  complete(response) {
+    this.events.close();
+    this.resolveResponse(response);
+  }
+  abort(error) {
+    this.events.abort(error);
+    this.rejectResponse(error);
+  }
+  [Symbol.asyncIterator]() {
+    this.hasConsumer = true;
+    return this.events[Symbol.asyncIterator]();
+  }
+  then(onfulfilled, onrejected) {
+    this.drainEvents().catch(() => {
+    });
+    return this.response.then(onfulfilled, onrejected);
+  }
+  async drainEvents() {
+    if (this.hasConsumer) return;
+    this.hasConsumer = true;
+    for await (const _ of this.events) {
+    }
+  }
+};
+
+// src/utils/zod-to-json-schema.ts
+import { z } from "zod";
+function zodToJsonSchema(schema) {
+  const jsonSchema = z.toJSONSchema(schema);
+  const { $schema: _schema, ...rest } = jsonSchema;
+  return rest;
+}
+
+// src/providers/transform.ts
+function toAnthropicCacheControl(retention, baseUrl) {
+  const resolved = retention ?? "short";
+  if (resolved === "none") return void 0;
+  const ttl = resolved === "long" && (!baseUrl || baseUrl.includes("api.anthropic.com")) ? "1h" : void 0;
+  return { type: "ephemeral", ...ttl && { ttl } };
+}
+function toAnthropicMessages(messages, cacheControl) {
+  let systemText;
+  const out = [];
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemText = msg.content;
+      continue;
+    }
+    if (msg.role === "user") {
+      out.push({
+        role: "user",
+        content: typeof msg.content === "string" ? msg.content : msg.content.map((part) => {
+          if (part.type === "text") return { type: "text", text: part.text };
+          return {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: part.mediaType,
+              data: part.data
+            }
+          };
+        })
+      });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const content = typeof msg.content === "string" ? msg.content : msg.content.filter((part) => {
+        if (part.type === "thinking" && !part.signature) return false;
+        return true;
+      }).map((part) => {
+        if (part.type === "text") return { type: "text", text: part.text };
+        if (part.type === "thinking")
+          return { type: "thinking", thinking: part.text, signature: part.signature };
+        if (part.type === "tool_call")
+          return {
+            type: "tool_use",
+            id: part.id,
+            name: part.name,
+            input: part.args
+          };
+        if (part.type === "server_tool_call")
+          return {
+            type: "server_tool_use",
+            id: part.id,
+            name: part.name,
+            input: part.input
+          };
+        if (part.type === "server_tool_result")
+          return part.data;
+        if (part.type === "raw") return part.data;
+        return { type: "text", text: "" };
+      });
+      out.push({ role: "assistant", content });
+      continue;
+    }
+    if (msg.role === "tool") {
+      out.push({
+        role: "user",
+        content: msg.content.map((result) => ({
+          type: "tool_result",
+          tool_use_id: result.toolCallId,
+          content: result.content,
+          is_error: result.isError
+        }))
+      });
+    }
+  }
+  if (cacheControl && out.length > 0) {
+    for (let i = out.length - 1; i >= 0; i--) {
+      if (out[i].role === "user") {
+        const content = out[i].content;
+        if (typeof content === "string") {
+          out[i] = {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: content,
+                cache_control: cacheControl
+              }
+            ]
+          };
+        } else if (Array.isArray(content) && content.length > 0) {
+          const last = content[content.length - 1];
+          content[content.length - 1] = {
+            ...last,
+            cache_control: cacheControl
+          };
+        }
+        break;
+      }
+    }
+  }
+  let system;
+  if (systemText) {
+    const marker = "<!-- uncached -->";
+    const markerIdx = systemText.indexOf(marker);
+    if (markerIdx !== -1 && cacheControl) {
+      const cachedPart = systemText.slice(0, markerIdx).trimEnd();
+      const uncachedPart = systemText.slice(markerIdx + marker.length).trimStart();
+      system = [
+        { type: "text", text: cachedPart, cache_control: cacheControl },
+        ...uncachedPart ? [{ type: "text", text: uncachedPart }] : []
+      ];
+    } else {
+      system = [
+        {
+          type: "text",
+          text: systemText,
+          ...cacheControl && { cache_control: cacheControl }
+        }
+      ];
+    }
+  }
+  return { system, messages: out };
+}
+function toAnthropicTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.rawInputSchema ?? zodToJsonSchema(tool.parameters)
+  }));
+}
+function toAnthropicToolChoice(choice) {
+  if (choice === "auto") return { type: "auto" };
+  if (choice === "none") return { type: "none" };
+  if (choice === "required") return { type: "any" };
+  return { type: "tool", name: choice.name };
+}
+function supportsAdaptiveThinking(model) {
+  return /opus-4-6|sonnet-4-6/.test(model);
+}
+function toAnthropicThinking(level, maxTokens, model) {
+  if (supportsAdaptiveThinking(model)) {
+    let effort = level;
+    if (level === "max" && !model.includes("opus")) {
+      effort = "high";
+    }
+    return {
+      thinking: { type: "adaptive" },
+      maxTokens,
+      outputConfig: { effort }
+    };
+  }
+  const effectiveLevel = level === "max" ? "high" : level;
+  const budgetMap = {
+    low: Math.max(1024, Math.floor(maxTokens * 0.25)),
+    medium: Math.max(2048, Math.floor(maxTokens * 0.5)),
+    high: Math.max(4096, maxTokens)
+  };
+  const budget = budgetMap[effectiveLevel];
+  return {
+    thinking: { type: "enabled", budget_tokens: budget },
+    maxTokens: maxTokens + budget
+  };
+}
+function remapToolCallId(id, idMap) {
+  if (id.startsWith("call_")) return id;
+  const existing = idMap.get(id);
+  if (existing) return existing;
+  const mapped = `call_${id.replace(/^toolu_/, "")}`;
+  idMap.set(id, mapped);
+  return mapped;
+}
+function toOpenAIMessages(messages) {
+  const out = [];
+  const idMap = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      out.push({ role: "system", content: msg.content });
+      continue;
+    }
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        out.push({ role: "user", content: msg.content });
+      } else {
+        out.push({
+          role: "user",
+          content: msg.content.map(
+            (part) => {
+              if (part.type === "text") return { type: "text", text: part.text };
+              return {
+                type: "image_url",
+                image_url: {
+                  url: `data:${part.mediaType};base64,${part.data}`
+                }
+              };
+            }
+          )
+        });
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const parts = typeof msg.content === "string" ? msg.content : void 0;
+      const toolCalls = typeof msg.content !== "string" ? msg.content.filter(
+        (p) => p.type === "tool_call"
+      ).map(
+        (tc) => ({
+          id: remapToolCallId(tc.id, idMap),
+          type: "function",
+          function: { name: tc.name, arguments: JSON.stringify(tc.args) }
+        })
+      ) : void 0;
+      const textParts = typeof msg.content !== "string" ? msg.content.filter((p) => p.type === "text").map((p) => p.text).join("") : void 0;
+      const thinkingParts = typeof msg.content !== "string" ? msg.content.filter((p) => p.type === "thinking").map((p) => p.text).join("") : void 0;
+      const assistantMsg = {
+        role: "assistant",
+        content: parts || textParts || null,
+        ...toolCalls?.length ? { tool_calls: toolCalls } : {}
+      };
+      if (thinkingParts || toolCalls?.length) {
+        assistantMsg.reasoning_content = thinkingParts || " ";
+      }
+      out.push(assistantMsg);
+      continue;
+    }
+    if (msg.role === "tool") {
+      for (const result of msg.content) {
+        out.push({
+          role: "tool",
+          tool_call_id: remapToolCallId(result.toolCallId, idMap),
+          content: result.content
+        });
+      }
+    }
+  }
+  return out;
+}
+function toOpenAITools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.rawInputSchema ?? zodToJsonSchema(tool.parameters)
+    }
+  }));
+}
+function toOpenAIToolChoice(choice) {
+  if (choice === "auto") return "auto";
+  if (choice === "none") return "none";
+  if (choice === "required") return "required";
+  return { type: "function", function: { name: choice.name } };
+}
+function toOpenAIReasoningEffort(level) {
+  return level === "max" ? "high" : level;
+}
+function normalizeAnthropicStopReason(reason) {
+  switch (reason) {
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+      return "max_tokens";
+    case "pause_turn":
+      return "pause_turn";
+    case "stop_sequence":
+      return "stop_sequence";
+    case "refusal":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function normalizeOpenAIStopReason(reason) {
+  switch (reason) {
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "stop":
+      return "stop_sequence";
+    default:
+      return "end_turn";
+  }
+}
+
+// src/providers/anthropic.ts
+function streamAnthropic(options) {
+  const result = new StreamResult();
+  runStream(options, result).catch((err) => result.abort(toError(err)));
+  return result;
+}
+async function runStream(options, result) {
+  const isOAuth = options.apiKey?.startsWith("sk-ant-oat");
+  const client = new Anthropic({
+    ...isOAuth ? { apiKey: null, authToken: options.apiKey } : { apiKey: options.apiKey },
+    ...options.baseUrl ? { baseURL: options.baseUrl } : {}
+  });
+  const cacheControl = toAnthropicCacheControl(options.cacheRetention, options.baseUrl);
+  const { system, messages } = toAnthropicMessages(options.messages, cacheControl);
+  let maxTokens = options.maxTokens ?? 4096;
+  let thinking;
+  let outputConfig;
+  if (options.thinking) {
+    const t = toAnthropicThinking(options.thinking, maxTokens, options.model);
+    thinking = t.thinking;
+    maxTokens = t.maxTokens;
+    if (t.outputConfig) {
+      outputConfig = t.outputConfig;
+    }
+  }
+  const params = {
+    model: options.model,
+    max_tokens: maxTokens,
+    messages,
+    ...system ? { system } : {},
+    ...thinking ? { thinking } : {},
+    ...outputConfig ? { output_config: outputConfig } : {},
+    ...options.temperature != null && !thinking ? { temperature: options.temperature } : {},
+    ...options.topP != null ? { top_p: options.topP } : {},
+    ...options.stop ? { stop_sequences: options.stop } : {},
+    ...options.tools?.length || options.serverTools?.length || options.webSearch ? {
+      tools: [
+        ...options.tools?.length ? toAnthropicTools(options.tools) : [],
+        ...options.serverTools ?? [],
+        ...options.webSearch ? [{ type: "web_search_20250305", name: "web_search" }] : []
+      ]
+    } : {},
+    ...options.toolChoice && options.tools?.length ? { tool_choice: toAnthropicToolChoice(options.toolChoice) } : {},
+    ...options.compaction ? { context_management: { edits: [{ type: "compact_20260112" }] } } : {},
+    stream: true
+  };
+  const betaHeaders = [
+    ...isOAuth ? ["oauth-2025-04-20"] : [],
+    ...options.compaction ? ["compact-2026-01-12"] : []
+  ];
+  const stream2 = client.messages.stream(params, {
+    signal: options.signal ?? void 0,
+    ...betaHeaders.length ? { headers: { "anthropic-beta": betaHeaders.join(",") } } : {}
+  });
+  const contentParts = [];
+  let currentToolId = "";
+  let currentToolName = "";
+  stream2.on("text", (text) => {
+    result.push({ type: "text_delta", text });
+  });
+  stream2.on("thinking", (thinkingDelta) => {
+    result.push({ type: "thinking_delta", text: thinkingDelta });
+  });
+  stream2.on("streamEvent", (event) => {
+    if (event.type === "content_block_start") {
+      if (event.content_block.type === "tool_use") {
+        currentToolId = event.content_block.id;
+        currentToolName = event.content_block.name;
+      }
+      if (event.content_block.type === "server_tool_use") {
+        currentToolId = event.content_block.id;
+        currentToolName = event.content_block.name;
+      }
+    }
+  });
+  stream2.on("inputJson", (delta) => {
+    result.push({
+      type: "toolcall_delta",
+      id: currentToolId,
+      name: currentToolName,
+      argsJson: delta
+    });
+  });
+  stream2.on("contentBlock", (block) => {
+    if (block.type === "text") {
+      contentParts.push({ type: "text", text: block.text });
+    } else if (block.type === "thinking") {
+      contentParts.push({ type: "thinking", text: block.thinking, signature: block.signature });
+    } else if (block.type === "tool_use") {
+      const tc = {
+        type: "tool_call",
+        id: block.id,
+        name: block.name,
+        args: block.input
+      };
+      contentParts.push(tc);
+      result.push({
+        type: "toolcall_done",
+        id: tc.id,
+        name: tc.name,
+        args: tc.args
+      });
+    } else if (block.type === "server_tool_use") {
+      const stc = {
+        type: "server_tool_call",
+        id: block.id,
+        name: block.name,
+        input: block.input
+      };
+      contentParts.push(stc);
+      result.push({
+        type: "server_toolcall",
+        id: stc.id,
+        name: stc.name,
+        input: stc.input
+      });
+    } else {
+      const raw = block;
+      const blockType = raw.type;
+      if (blockType === "web_search_tool_result") {
+        const str = {
+          type: "server_tool_result",
+          toolUseId: raw.tool_use_id,
+          resultType: blockType,
+          data: raw
+        };
+        contentParts.push(str);
+        result.push({
+          type: "server_toolresult",
+          toolUseId: str.toolUseId,
+          resultType: str.resultType,
+          data: str.data
+        });
+      } else {
+        contentParts.push({ type: "raw", data: raw });
+      }
+    }
+  });
+  try {
+    const finalMessage = await stream2.finalMessage();
+    const stopReason = normalizeAnthropicStopReason(finalMessage.stop_reason);
+    const response = {
+      message: {
+        role: "assistant",
+        content: contentParts.length > 0 ? contentParts : ""
+      },
+      stopReason,
+      usage: {
+        inputTokens: finalMessage.usage.input_tokens,
+        outputTokens: finalMessage.usage.output_tokens,
+        ...finalMessage.usage.cache_read_input_tokens != null && {
+          cacheRead: finalMessage.usage.cache_read_input_tokens
+        },
+        ...finalMessage.usage.cache_creation_input_tokens != null && {
+          cacheWrite: finalMessage.usage.cache_creation_input_tokens
+        }
+      }
+    };
+    result.push({ type: "done", stopReason });
+    result.complete(response);
+  } catch (err) {
+    const error = toError(err);
+    result.push({ type: "error", error });
+    result.abort(error);
+  }
+}
+function toError(err) {
+  if (err instanceof Anthropic.APIError) {
+    return new ProviderError("anthropic", err.message, {
+      statusCode: err.status,
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    return new ProviderError("anthropic", err.message, { cause: err });
+  }
+  return new ProviderError("anthropic", String(err));
+}
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+function streamOpenAI(options) {
+  const result = new StreamResult();
+  const providerName = options.provider ?? "openai";
+  runStream2(options, result).catch((err) => result.abort(toError2(err, providerName)));
+  return result;
+}
+async function runStream2(options, result) {
+  const client = new OpenAI({
+    apiKey: options.apiKey,
+    ...options.baseUrl ? { baseURL: options.baseUrl } : {}
+  });
+  const usesThinkingParam = options.provider === "glm" || options.provider === "moonshot";
+  const messages = toOpenAIMessages(options.messages);
+  const params = {
+    model: options.model,
+    messages,
+    stream: true,
+    ...options.maxTokens ? { max_tokens: options.maxTokens } : {},
+    ...options.temperature != null && !options.thinking ? { temperature: options.temperature } : {},
+    ...options.topP != null ? { top_p: options.topP } : {},
+    ...options.stop ? { stop: options.stop } : {},
+    ...options.thinking && !usesThinkingParam ? { reasoning_effort: toOpenAIReasoningEffort(options.thinking) } : {},
+    ...options.tools?.length ? { tools: toOpenAITools(options.tools) } : {},
+    ...options.toolChoice && options.tools?.length ? { tool_choice: toOpenAIToolChoice(options.toolChoice) } : {},
+    stream_options: { include_usage: true }
+  };
+  if (options.webSearch) {
+    if (options.provider === "moonshot") {
+      const raw = params;
+      const tools = (raw.tools ?? []).slice();
+      tools.push({ type: "builtin_function", function: { name: "$web_search" } });
+      raw.tools = tools;
+    }
+  }
+  if (usesThinkingParam) {
+    params.thinking = options.thinking ? { type: "enabled" } : { type: "disabled" };
+  }
+  const stream2 = await client.chat.completions.create(params, {
+    signal: options.signal ?? void 0
+  });
+  const contentParts = [];
+  const toolCallAccum = /* @__PURE__ */ new Map();
+  let textAccum = "";
+  let thinkingAccum = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheRead = 0;
+  let finishReason = null;
+  for await (const chunk of stream2) {
+    const choice = chunk.choices?.[0];
+    if (chunk.usage) {
+      inputTokens = chunk.usage.prompt_tokens;
+      outputTokens = chunk.usage.completion_tokens;
+      const details = chunk.usage.prompt_tokens_details;
+      if (details?.cached_tokens) {
+        cacheRead = details.cached_tokens;
+      }
+    }
+    if (!choice) continue;
+    if (choice.finish_reason) {
+      finishReason = choice.finish_reason;
+    }
+    const delta = choice.delta;
+    const reasoningContent = delta.reasoning_content;
+    if (typeof reasoningContent === "string" && reasoningContent) {
+      thinkingAccum += reasoningContent;
+      result.push({ type: "thinking_delta", text: reasoningContent });
+    }
+    if (delta.content) {
+      textAccum += delta.content;
+      result.push({ type: "text_delta", text: delta.content });
+    }
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        let accum = toolCallAccum.get(tc.index);
+        if (!accum) {
+          accum = {
+            id: tc.id ?? "",
+            name: tc.function?.name ?? "",
+            argsJson: ""
+          };
+          toolCallAccum.set(tc.index, accum);
+        }
+        if (tc.id) accum.id = tc.id;
+        if (tc.function?.name) accum.name = tc.function.name;
+        if (tc.function?.arguments) {
+          accum.argsJson += tc.function.arguments;
+          result.push({
+            type: "toolcall_delta",
+            id: accum.id,
+            name: accum.name,
+            argsJson: tc.function.arguments
+          });
+        }
+      }
+    }
+  }
+  if (thinkingAccum) {
+    contentParts.push({ type: "thinking", text: thinkingAccum });
+  }
+  if (textAccum) {
+    contentParts.push({ type: "text", text: textAccum });
+  }
+  for (const [, tc] of toolCallAccum) {
+    let args = {};
+    try {
+      args = JSON.parse(tc.argsJson);
+    } catch {
+    }
+    const toolCall = {
+      type: "tool_call",
+      id: tc.id,
+      name: tc.name,
+      args
+    };
+    contentParts.push(toolCall);
+    result.push({
+      type: "toolcall_done",
+      id: tc.id,
+      name: tc.name,
+      args
+    });
+  }
+  const stopReason = normalizeOpenAIStopReason(finishReason);
+  const response = {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : textAccum || ""
+    },
+    stopReason,
+    usage: { inputTokens, outputTokens, ...cacheRead > 0 && { cacheRead } }
+  };
+  result.push({ type: "done", stopReason });
+  result.complete(response);
+}
+function toError2(err, provider) {
+  if (err instanceof OpenAI.APIError) {
+    let msg = err.message;
+    const body = err.error;
+    if (body) {
+      msg += ` | body: ${JSON.stringify(body)}`;
+    }
+    return new ProviderError(provider, msg, {
+      statusCode: err.status,
+      cause: err
+    });
+  }
+  if (err instanceof Error) {
+    return new ProviderError(provider, err.message, { cause: err });
+  }
+  return new ProviderError(provider, String(err));
+}
+
+// src/providers/openai-codex.ts
+import os from "os";
+var DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
+function streamOpenAICodex(options) {
+  const result = new StreamResult();
+  runStream3(options, result).catch((err) => result.abort(toError3(err)));
+  return result;
+}
+async function runStream3(options, result) {
+  const baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const url = `${baseUrl}/codex/responses`;
+  const { system, input } = toCodexInput(options.messages);
+  const body = {
+    model: options.model,
+    store: false,
+    stream: true,
+    instructions: system,
+    input,
+    tool_choice: "auto",
+    parallel_tool_calls: true,
+    include: ["reasoning.encrypted_content"]
+  };
+  if (options.tools?.length) {
+    body.tools = toCodexTools(options.tools);
+  }
+  if (options.temperature != null && !options.thinking) {
+    body.temperature = options.temperature;
+  }
+  if (options.thinking) {
+    body.reasoning = {
+      effort: options.thinking,
+      summary: "auto"
+    };
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${options.apiKey}`,
+    "OpenAI-Beta": "responses=experimental",
+    originator: "ezcoder",
+    "User-Agent": `ezcoder (${os.platform()} ${os.release()}; ${os.arch()})`
+  };
+  if (options.accountId) {
+    headers["chatgpt-account-id"] = options.accountId;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    let message = `Codex API error (${response.status}): ${text}`;
+    if (response.status === 400 && text.includes("not supported")) {
+      message += `
+
+Hint: Codex models require a ChatGPT Plus ($20/mo) or Pro ($200/mo) subscription. The "codex-spark" variants require ChatGPT Pro. Ensure your account has an active subscription at https://chatgpt.com/settings`;
+    }
+    throw new ProviderError("openai", message, {
+      statusCode: response.status
+    });
+  }
+  if (!response.body) {
+    throw new ProviderError("openai", "No response body from Codex API");
+  }
+  const contentParts = [];
+  let textAccum = "";
+  const toolCalls = /* @__PURE__ */ new Map();
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const event of parseSSE(response.body)) {
+    const type = event.type;
+    if (!type) continue;
+    if (type === "error") {
+      const msg = event.message || JSON.stringify(event);
+      throw new ProviderError("openai", `Codex error: ${msg}`);
+    }
+    if (type === "response.failed") {
+      const msg = event.error?.message || "Codex response failed";
+      throw new ProviderError("openai", msg);
+    }
+    if (type === "response.output_text.delta") {
+      const delta = event.delta;
+      textAccum += delta;
+      result.push({ type: "text_delta", text: delta });
+    }
+    if (type === "response.reasoning_summary_text.delta") {
+      const delta = event.delta;
+      result.push({ type: "thinking_delta", text: delta });
+    }
+    if (type === "response.output_item.added") {
+      const item = event.item;
+      if (item?.type === "function_call") {
+        const callId = item.call_id;
+        const itemId = item.id;
+        const id = `${callId}|${itemId}`;
+        const name = item.name;
+        toolCalls.set(id, { id, name, argsJson: item.arguments || "" });
+      }
+    }
+    if (type === "response.function_call_arguments.delta") {
+      const delta = event.delta;
+      const itemId = event.item_id;
+      for (const [key, tc] of toolCalls) {
+        if (key.endsWith(`|${itemId}`)) {
+          tc.argsJson += delta;
+          result.push({
+            type: "toolcall_delta",
+            id: tc.id,
+            name: tc.name,
+            argsJson: delta
+          });
+          break;
+        }
+      }
+    }
+    if (type === "response.function_call_arguments.done") {
+      const itemId = event.item_id;
+      const argsStr = event.arguments;
+      for (const [key, tc] of toolCalls) {
+        if (key.endsWith(`|${itemId}`)) {
+          tc.argsJson = argsStr;
+          break;
+        }
+      }
+    }
+    if (type === "response.output_item.done") {
+      const item = event.item;
+      if (item?.type === "function_call") {
+        const callId = item.call_id;
+        const itemId = item.id;
+        const id = `${callId}|${itemId}`;
+        const tc = toolCalls.get(id);
+        if (tc) {
+          let args = {};
+          try {
+            args = JSON.parse(tc.argsJson);
+          } catch {
+          }
+          result.push({
+            type: "toolcall_done",
+            id: tc.id,
+            name: tc.name,
+            args
+          });
+        }
+      }
+    }
+    if (type === "response.completed" || type === "response.done") {
+      const resp = event.response;
+      const usage = resp?.usage;
+      if (usage) {
+        inputTokens = usage.input_tokens ?? 0;
+        outputTokens = usage.output_tokens ?? 0;
+      }
+    }
+  }
+  if (textAccum) {
+    contentParts.push({ type: "text", text: textAccum });
+  }
+  for (const [, tc] of toolCalls) {
+    let args = {};
+    try {
+      args = JSON.parse(tc.argsJson);
+    } catch {
+    }
+    const toolCall = {
+      type: "tool_call",
+      id: tc.id,
+      name: tc.name,
+      args
+    };
+    contentParts.push(toolCall);
+  }
+  const hasToolCalls = contentParts.some((p) => p.type === "tool_call");
+  const stopReason = hasToolCalls ? "tool_use" : "end_turn";
+  const streamResponse = {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : textAccum || ""
+    },
+    stopReason,
+    usage: { inputTokens, outputTokens }
+  };
+  result.push({ type: "done", stopReason });
+  result.complete(streamResponse);
+}
+async function* parseSSE(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let idx = buffer.indexOf("\n\n");
+      while (idx !== -1) {
+        const chunk = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 2);
+        const dataLines = chunk.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
+        if (dataLines.length > 0) {
+          const data = dataLines.join("\n").trim();
+          if (data && data !== "[DONE]") {
+            try {
+              yield JSON.parse(data);
+            } catch {
+            }
+          }
+        }
+        idx = buffer.indexOf("\n\n");
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function remapCodexId(id, idMap) {
+  if (id.startsWith("fc_") || id.startsWith("fc-")) return id;
+  const existing = idMap.get(id);
+  if (existing) return existing;
+  const mapped = `fc_${id.replace(/^toolu_/, "")}`;
+  idMap.set(id, mapped);
+  return mapped;
+}
+function toCodexInput(messages) {
+  let system;
+  const input = [];
+  const idMap = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      system = msg.content;
+      continue;
+    }
+    if (msg.role === "user") {
+      const content = typeof msg.content === "string" ? [{ type: "input_text", text: msg.content }] : msg.content.map((part) => {
+        if (part.type === "text") return { type: "input_text", text: part.text };
+        return {
+          type: "input_image",
+          detail: "auto",
+          image_url: `data:${part.mediaType};base64,${part.data}`
+        };
+      });
+      input.push({ role: "user", content });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        input.push({
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: msg.content, annotations: [] }],
+          status: "completed"
+        });
+        continue;
+      }
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          input.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: part.text, annotations: [] }],
+            status: "completed"
+          });
+        } else if (part.type === "tool_call") {
+          const [callId, itemId] = part.id.includes("|") ? part.id.split("|", 2) : [part.id, part.id];
+          input.push({
+            type: "function_call",
+            id: remapCodexId(itemId, idMap),
+            call_id: remapCodexId(callId, idMap),
+            name: part.name,
+            arguments: JSON.stringify(part.args)
+          });
+        }
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      for (const result of msg.content) {
+        const [callId] = result.toolCallId.includes("|") ? result.toolCallId.split("|", 2) : [result.toolCallId];
+        input.push({
+          type: "function_call_output",
+          call_id: remapCodexId(callId, idMap),
+          output: result.content
+        });
+      }
+    }
+  }
+  return { system, input };
+}
+function toCodexTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.rawInputSchema ?? zodToJsonSchema(tool.parameters),
+    strict: null
+  }));
+}
+function toError3(err) {
+  if (err instanceof ProviderError) return err;
+  if (err instanceof Error) {
+    return new ProviderError("openai", err.message, { cause: err });
+  }
+  return new ProviderError("openai", String(err));
+}
+
+// src/stream.ts
+function stream(options) {
+  switch (options.provider) {
+    case "anthropic":
+      return streamAnthropic(options);
+    case "openai":
+      if (options.accountId) {
+        return streamOpenAICodex(options);
+      }
+      return streamOpenAI(options);
+    case "glm":
+      return streamOpenAI({
+        ...options,
+        baseUrl: options.baseUrl ?? "https://api.z.ai/api/coding/paas/v4"
+      });
+    case "moonshot":
+      return streamOpenAI({
+        ...options,
+        baseUrl: options.baseUrl ?? "https://api.moonshot.ai/v1"
+      });
+    default:
+      throw new GGAIError(
+        `Unknown provider: ${options.provider}. Supported: "anthropic", "openai", "glm", "moonshot"`
+      );
+  }
+}
+export {
+  EventStream,
+  GGAIError,
+  ProviderError,
+  StreamResult,
+  stream
+};
+//# sourceMappingURL=index.js.map