tnega 0.1.0 → 0.3.0

package/dist/llm.js

@@ -0,0 +1,1016 @@
+import { createRequire as __tnegaCreateRequire } from 'node:module'; const require = __tnegaCreateRequire(import.meta.url);
+
+// packages/llm/src/anthropic-messages.ts
+import { randomUUID } from "node:crypto";
+
+// packages/llm/src/errors.ts
+var OpenAICompatibleError = class extends Error {
+  constructor(status, message, detail) {
+    super(message);
+    this.status = status;
+    this.detail = detail;
+  }
+  status;
+  detail;
+  name = "OpenAICompatibleError";
+};
+
+// packages/llm/src/models.ts
+var DEFAULT_MODEL = "deepseek-v4-flash";
+var DEFAULT_DEEPSEEK_MODEL = "deepseek-v4-flash";
+var MODEL_CATALOG = [
+  {
+    id: "minimax-m3",
+    provider: "opencode-go",
+    protocol: "anthropic",
+    contextWindow: 1e6,
+    pricing: {
+      rates: {
+        input: 0.3,
+        output: 1.2,
+        cachedRead: 0.06
+      },
+      monthlyUsage: 60
+    }
+  },
+  {
+    id: "deepseek-v4-flash",
+    provider: "opencode-go",
+    protocol: "openai",
+    contextWindow: 1e6,
+    pricing: {
+      rates: {
+        offPeak: {
+          input: 0.22,
+          output: 0.66,
+          cachedRead: 7e-3
+        },
+        peak: {
+          input: 0.44,
+          output: 1.32,
+          cachedRead: 0.014
+        }
+      },
+      monthlyUsage: 30
+    }
+  },
+  {
+    id: "deepseek-v4-pro",
+    provider: "opencode-go",
+    protocol: "openai",
+    contextWindow: 1e6,
+    pricing: {
+      rates: {
+        offPeak: {
+          input: 0.66,
+          output: 1.98,
+          cachedRead: 0.022
+        },
+        peak: {
+          input: 1.32,
+          output: 3.96,
+          cachedRead: 0.044
+        }
+      },
+      monthlyUsage: 15
+    }
+  }
+];
+function lookupModel(id) {
+  if (!id) return void 0;
+  const normalized = id.trim().toLowerCase();
+  return MODEL_CATALOG.find((model) => model.id === normalized);
+}
+
+// packages/llm/src/shared.ts
+var DEFAULT_OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
+var DEFAULT_LLM_TIMEOUT_MS = 12e4;
+var DEFAULT_LLM_MAX_RETRIES = 2;
+var DEFAULT_LLM_RETRY_DELAY_MS = 500;
+function combineSignal(signal, timeoutMs) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function isExternalAbort(error, signal) {
+  return Boolean(signal?.aborted && isAbortLike(error));
+}
+function isAbortLike(error) {
+  if (!error || typeof error !== "object") return false;
+  const name = error.name;
+  return name === "AbortError" || name === "TimeoutError";
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeBaseUrl(baseUrl) {
+  return (baseUrl ?? DEFAULT_OPENCODE_GO_BASE_URL).replace(/\/+$/, "");
+}
+function stringifyArguments(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? "{}";
+  } catch {
+    return "{}";
+  }
+}
+function parseArguments(raw) {
+  const text = raw.trim();
+  if (!text) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return raw;
+  }
+}
+async function assertOk(response, redact) {
+  if (response.ok) return;
+  let detail;
+  try {
+    const text = await response.text();
+    if (text.trim()) {
+      const preview = text.slice(0, 2e3);
+      detail = redact && preview.includes(redact) ? preview.replaceAll(redact, "[redacted]") : preview;
+    }
+  } catch {
+    detail = void 0;
+  }
+  throw new OpenAICompatibleError(
+    response.status,
+    `LLM request failed with status ${response.status}`,
+    detail
+  );
+}
+async function parseJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    throw new OpenAICompatibleError(
+      response.status,
+      "LLM response was not valid JSON"
+    );
+  }
+}
+
+// packages/llm/src/anthropic-messages.ts
+var ANTHROPIC_VERSION = "2023-06-01";
+function anthropicMessagesAdapter(config = {}) {
+  return {
+    async complete(messages, tools, options) {
+      const timeoutMs = config.timeoutMs ?? DEFAULT_LLM_TIMEOUT_MS;
+      const maxRetries = config.maxRetries ?? DEFAULT_LLM_MAX_RETRIES;
+      const retryDelayMs = config.retryDelayMs ?? DEFAULT_LLM_RETRY_DELAY_MS;
+      for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+        const request = buildRequest(
+          messages,
+          tools,
+          config,
+          combineSignal(options.signal, timeoutMs)
+        );
+        try {
+          const response = await fetch(request.url, request.init);
+          if (!isRetryableStatus(response.status) || attempt >= maxRetries) {
+            return parseResponse(response, config.apiKey);
+          }
+          await response.body?.cancel();
+        } catch (error) {
+          if (isExternalAbort(error, options.signal)) {
+            throw new OpenAICompatibleError(
+              0,
+              `LLM request aborted: ${errorMessage(error)}`
+            );
+          }
+          if (attempt >= maxRetries) {
+            throw toRequestError(error, timeoutMs);
+          }
+        }
+        await sleep(retryDelayMs * 2 ** attempt);
+      }
+      throw new OpenAICompatibleError(0, "LLM request failed");
+    },
+    async *stream(messages, tools, options) {
+      const timeoutMs = config.timeoutMs ?? DEFAULT_LLM_TIMEOUT_MS;
+      const maxRetries = config.maxRetries ?? DEFAULT_LLM_MAX_RETRIES;
+      const retryDelayMs = config.retryDelayMs ?? DEFAULT_LLM_RETRY_DELAY_MS;
+      for (let attempt = 0; ; attempt += 1) {
+        const request = buildRequest(
+          messages,
+          tools,
+          config,
+          combineSignal(options.signal, timeoutMs),
+          true
+        );
+        let response;
+        try {
+          response = await fetch(request.url, request.init);
+        } catch (error) {
+          if (isExternalAbort(error, options.signal)) {
+            throw new OpenAICompatibleError(
+              0,
+              `LLM stream aborted: ${errorMessage(error)}`
+            );
+          }
+          if (attempt >= maxRetries) {
+            throw toStreamError(error, timeoutMs);
+          }
+          await sleep(retryDelayMs * 2 ** attempt);
+          continue;
+        }
+        if (!response.ok || !response.body) {
+          if (isRetryableStatus(response.status) && attempt < maxRetries) {
+            await response.body?.cancel();
+            await sleep(retryDelayMs * 2 ** attempt);
+            continue;
+          }
+          if (!response.ok) await assertOk(response, config.apiKey);
+          throw new OpenAICompatibleError(
+            response.status,
+            "LLM stream response had no body"
+          );
+        }
+        let sawEvent = false;
+        try {
+          for await (const event of parseAnthropicStream(response.body)) {
+            sawEvent = true;
+            yield event;
+          }
+          return;
+        } catch (error) {
+          if (isExternalAbort(error, options.signal)) {
+            throw new OpenAICompatibleError(
+              0,
+              `LLM stream aborted: ${errorMessage(error)}`
+            );
+          }
+          if (sawEvent || attempt >= maxRetries) {
+            throw toStreamError(error, timeoutMs);
+          }
+          await sleep(retryDelayMs * 2 ** attempt);
+        }
+      }
+    }
+  };
+}
+function buildRequest(messages, tools, config, signal, stream = false) {
+  const body = {
+    model: config.model ?? DEFAULT_MODEL,
+    max_tokens: config.maxTokens ?? 4096,
+    messages: toAnthropicMessages(messages)
+  };
+  if (stream) body.stream = true;
+  const system = systemPrompt(messages);
+  if (system) body.system = system;
+  if (tools.length) {
+    body.tools = tools.map(toAnthropicTool);
+  }
+  if (config.temperature !== void 0) body.temperature = config.temperature;
+  return {
+    url: anthropicMessagesUrl(config.baseUrl),
+    init: {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "anthropic-version": ANTHROPIC_VERSION,
+        ...config.apiKey ? { "x-api-key": config.apiKey } : {}
+      },
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
+    }
+  };
+}
+function anthropicMessagesUrl(baseUrl) {
+  const normalized = normalizeBaseUrl(baseUrl);
+  return normalized.endsWith("/messages") ? normalized : `${normalized}/messages`;
+}
+function systemPrompt(messages) {
+  return messages.filter((message) => message.role === "system").map((message) => String(message.content ?? "")).join("\n\n");
+}
+function toAnthropicMessages(messages) {
+  const result = [];
+  for (const message of messages) {
+    if (message.role === "system") continue;
+    if (message.role === "tool") {
+      const toolResult = {
+        type: "tool_result",
+        tool_use_id: message.tool_call_id ?? "",
+        content: String(message.content ?? "")
+      };
+      if (message.toolError) toolResult.is_error = true;
+      result.push({
+        role: "user",
+        content: [toolResult]
+      });
+      continue;
+    }
+    if (message.role === "assistant" && message.tool_calls?.length) {
+      result.push({
+        role: "assistant",
+        content: [
+          ...message.content ? [{ type: "text", text: message.content }] : [],
+          ...message.tool_calls.map((call) => ({
+            type: "tool_use",
+            id: call.id,
+            name: call.name,
+            input: typeof call.arguments === "object" && call.arguments !== null ? call.arguments : parseArguments(String(call.arguments ?? ""))
+          }))
+        ]
+      });
+      continue;
+    }
+    result.push({
+      role: message.role,
+      content: String(message.content ?? "")
+    });
+  }
+  return result;
+}
+function toAnthropicTool(tool) {
+  return {
+    name: tool.schema.name,
+    ...tool.schema.description ? { description: tool.schema.description } : {},
+    input_schema: tool.schema.parameters ?? { type: "object", properties: {} }
+  };
+}
+async function parseResponse(response, apiKey) {
+  await assertOk(response, apiKey);
+  const payload = await parseJson(response);
+  return parseCompletion(payload);
+}
+function parseCompletion(payload) {
+  const record = payload;
+  const blocks = Array.isArray(record?.content) ? record.content : [];
+  const text = blocks.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+  const toolCalls = parseToolCalls(blocks);
+  const finishReason = toFinishReason(
+    record?.stop_reason,
+    text,
+    toolCalls.length > 0
+  );
+  const completion = { finishReason };
+  if (text) completion.content = text;
+  if (toolCalls.length) completion.toolCalls = toolCalls;
+  return completion;
+}
+function parseToolCalls(blocks) {
+  const calls = [];
+  for (const block of blocks) {
+    if (block.type !== "tool_use") continue;
+    const name = typeof block.name === "string" ? block.name : "";
+    if (!name) continue;
+    const id = typeof block.id === "string" && block.id ? block.id : `toolu_${calls.length + 1}`;
+    calls.push({
+      id,
+      name,
+      arguments: block.input ?? {}
+    });
+  }
+  return calls;
+}
+function toFinishReason(raw, content, hasToolCalls) {
+  if (raw === "end_turn" || raw === "stop_sequence") return "stop";
+  if (raw === "max_tokens") return "length";
+  if (raw === "tool_use" || hasToolCalls) return "tool_calls";
+  if (content) return "stop";
+  return "error";
+}
+function toRequestError(error, timeoutMs) {
+  if (isAbortLike(error)) {
+    return new OpenAICompatibleError(
+      0,
+      `LLM request timed out after ${timeoutMs}ms`
+    );
+  }
+  return new OpenAICompatibleError(0, `LLM request failed: ${errorMessage(error)}`);
+}
+async function* parseAnthropicStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let messageId = randomUUID();
+  let model;
+  let messageStarted = false;
+  let text = "";
+  let stopReason;
+  let stopped = false;
+  let textBlockIndex;
+  const calls = /* @__PURE__ */ new Map();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line.startsWith("data:")) {
+          const data = line.slice(5).trim();
+          if (!data) continue;
+          let payload;
+          try {
+            payload = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          const record = payload;
+          if (record?.type === "error") {
+            const message = typeof record.error?.message === "string" ? record.error.message : "LLM stream returned an error event";
+            throw new OpenAICompatibleError(0, `LLM stream failed: ${message}`);
+          }
+          if (record?.type === "ping") continue;
+          if (record?.type === "message_start") {
+            const start = record;
+            messageId = typeof start.message?.id === "string" && start.message.id ? start.message.id : randomUUID();
+            model = typeof start.message?.model === "string" ? start.message.model : void 0;
+            messageStarted = true;
+            yield {
+              type: "message_start",
+              id: messageId,
+              ...model ? { model } : {}
+            };
+            continue;
+          }
+          if (record?.type === "content_block_start") {
+            const block = record.content_block;
+            const index = toIndex(record);
+            if (block?.type === "text") {
+              textBlockIndex = index;
+              if (typeof block.text === "string" && block.text) {
+                text += block.text;
+                yield { type: "message_delta", id: messageId, delta: block.text };
+              }
+            } else if (block?.type === "tool_use") {
+              const call = calls.get(index) ?? {
+                index,
+                id: typeof block.id === "string" ? block.id : "",
+                name: typeof block.name === "string" ? block.name : "",
+                rawArguments: typeof block.partial_json === "string" ? block.partial_json : "",
+                emitted: false,
+                finalized: false
+              };
+              calls.set(index, call);
+              if (!call.emitted && call.id && call.name) {
+                call.emitted = true;
+                yield {
+                  type: "toolcall_start",
+                  id: call.id,
+                  index,
+                  name: call.name
+                };
+              }
+            }
+            continue;
+          }
+          if (record?.type === "content_block_delta") {
+            const block = record.delta;
+            const index = toIndex(record);
+            if (block?.type === "text_delta" && typeof block.text === "string") {
+              if (textBlockIndex === void 0) textBlockIndex = index;
+              if (textBlockIndex === index && block.text) {
+                text += block.text;
+                yield { type: "message_delta", id: messageId, delta: block.text };
+              }
+            } else if (block?.type === "input_json_delta") {
+              const call = calls.get(index);
+              if (call && typeof block.partial_json === "string") {
+                call.rawArguments += block.partial_json;
+              }
+            }
+            continue;
+          }
+          if (record?.type === "content_block_stop") {
+            const block = record;
+            const index = toIndex(block);
+            const call = calls.get(index);
+            if (call && !call.finalized) {
+              call.finalized = true;
+              if (!call.name) {
+                const partial = parseArguments(call.rawArguments);
+                if (partial && typeof partial === "object") {
+                  const name = partial.name;
+                  if (typeof name === "string") call.name = name;
+                }
+              }
+              if (!call.emitted && call.id && call.name) {
+                call.emitted = true;
+                yield {
+                  type: "toolcall_start",
+                  id: call.id,
+                  index,
+                  name: call.name
+                };
+              }
+              yield {
+                type: "toolcall_end",
+                id: call.id || `toolu_${index + 1}`,
+                index,
+                name: call.name,
+                arguments: parseArguments(call.rawArguments)
+              };
+            }
+            continue;
+          }
+          if (record?.type === "message_delta") {
+            const delta = record.delta;
+            if (delta?.stop_reason !== void 0) {
+              stopReason = delta.stop_reason;
+            }
+            continue;
+          }
+          if (record?.type === "message_stop") {
+            if (!messageStarted) {
+              messageStarted = true;
+              yield {
+                type: "message_start",
+                id: messageId,
+                ...model ? { model } : {}
+              };
+            }
+            stopped = true;
+            yield {
+              type: "message_stop",
+              id: messageId,
+              finishReason: toFinishReason(stopReason, text, calls.size > 0)
+            };
+            continue;
+          }
+        }
+      }
+    }
+  } finally {
+    if (reader.releaseLock) {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  if (!messageStarted) {
+    yield {
+      type: "message_start",
+      id: messageId,
+      ...model ? { model } : {}
+    };
+  }
+  if (!stopped) {
+    yield {
+      type: "message_stop",
+      id: messageId,
+      finishReason: toFinishReason(stopReason, text, calls.size > 0)
+    };
+  }
+}
+function toIndex(block) {
+  return typeof block.index === "number" ? block.index : 0;
+}
+function toStreamError(error, timeoutMs) {
+  if (isAbortLike(error)) {
+    return new OpenAICompatibleError(
+      0,
+      `LLM stream timed out after ${timeoutMs}ms`
+    );
+  }
+  return new OpenAICompatibleError(0, `LLM stream failed: ${errorMessage(error)}`);
+}
+
+// packages/llm/src/openai.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function openaiCompatAdapter(config = {}) {
+  return {
+    async complete(messages, tools, options) {
+      const timeoutMs = config.timeoutMs ?? DEFAULT_LLM_TIMEOUT_MS;
+      const maxRetries = config.maxRetries ?? DEFAULT_LLM_MAX_RETRIES;
+      const retryDelayMs = config.retryDelayMs ?? DEFAULT_LLM_RETRY_DELAY_MS;
+      for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+        const request = buildRequest2(
+          messages,
+          tools,
+          config,
+          combineSignal(options.signal, timeoutMs)
+        );
+        try {
+          const response = await fetch(request.url, request.init);
+          if (!isRetryableStatus(response.status) || attempt >= maxRetries) {
+            return parseResponse2(response, config.apiKey);
+          }
+          await response.body?.cancel();
+        } catch (error) {
+          if (isExternalAbort(error, options.signal)) {
+            throw new OpenAICompatibleError(
+              0,
+              `LLM request aborted: ${errorMessage(error)}`
+            );
+          }
+          if (attempt >= maxRetries) {
+            throw toRequestError2(error, timeoutMs);
+          }
+        }
+        await sleep(retryDelayMs * 2 ** attempt);
+      }
+      throw new OpenAICompatibleError(0, "LLM request failed");
+    },
+    async *stream(messages, tools, options) {
+      const timeoutMs = config.timeoutMs ?? DEFAULT_LLM_TIMEOUT_MS;
+      const maxRetries = config.maxRetries ?? DEFAULT_LLM_MAX_RETRIES;
+      const retryDelayMs = config.retryDelayMs ?? DEFAULT_LLM_RETRY_DELAY_MS;
+      for (let attempt = 0; ; attempt += 1) {
+        const request = buildRequest2(
+          messages,
+          tools,
+          config,
+          combineSignal(options.signal, timeoutMs),
+          true
+        );
+        let response;
+        try {
+          response = await fetch(request.url, request.init);
+        } catch (error) {
+          if (isExternalAbort(error, options.signal)) {
+            throw new OpenAICompatibleError(
+              0,
+              `LLM stream aborted: ${errorMessage(error)}`
+            );
+          }
+          if (attempt >= maxRetries) {
+            throw toStreamError2(error, timeoutMs);
+          }
+          await sleep(retryDelayMs * 2 ** attempt);
+          continue;
+        }
+        if (!response.ok || !response.body) {
+          if (isRetryableStatus(response.status) && attempt < maxRetries) {
+            await response.body?.cancel();
+            await sleep(retryDelayMs * 2 ** attempt);
+            continue;
+          }
+          if (!response.ok) await assertOk(response, config.apiKey);
+          throw new OpenAICompatibleError(
+            response.status,
+            "LLM stream response had no body"
+          );
+        }
+        let sawEvent = false;
+        try {
+          for await (const event of parseOpenAIStream(response.body)) {
+            sawEvent = true;
+            yield event;
+          }
+          return;
+        } catch (error) {
+          if (isExternalAbort(error, options.signal)) {
+            throw new OpenAICompatibleError(
+              0,
+              `LLM stream aborted: ${errorMessage(error)}`
+            );
+          }
+          if (sawEvent || attempt >= maxRetries) {
+            throw toStreamError2(error, timeoutMs);
+          }
+          await sleep(retryDelayMs * 2 ** attempt);
+        }
+      }
+    }
+  };
+}
+async function listModels(config = {}) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  const headers = authHeaders(config.apiKey);
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/models`, { headers });
+  } catch (error) {
+    throw new OpenAICompatibleError(
+      0,
+      `model list request failed: ${errorMessage(error)}`
+    );
+  }
+  await assertOk(response);
+  const payload = await parseJson(response);
+  const data = payload?.data;
+  if (!Array.isArray(data)) {
+    throw new OpenAICompatibleError(
+      response.status,
+      "model list response did not contain an array in data"
+    );
+  }
+  return data.map((entry) => {
+    const record = entry;
+    return typeof record?.id === "string" ? record.id : "";
+  }).filter(Boolean);
+}
+function buildRequest2(messages, tools, config, signal, stream = false) {
+  const body = {
+    model: config.model ?? DEFAULT_DEEPSEEK_MODEL,
+    messages: messages.map(toOpenAIMessage)
+  };
+  if (stream) body.stream = true;
+  if (tools.length) {
+    body.tools = tools.map(toOpenAITool);
+  }
+  if (config.temperature !== void 0) body.temperature = config.temperature;
+  if (config.maxTokens !== void 0) body.max_tokens = config.maxTokens;
+  return {
+    url: `${normalizeBaseUrl(config.baseUrl)}/chat/completions`,
+    init: {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...authHeaders(config.apiKey)
+      },
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
+    }
+  };
+}
+function authHeaders(apiKey) {
+  return apiKey ? { authorization: `Bearer ${apiKey}` } : {};
+}
+function toOpenAIMessage(message) {
+  const payload = {
+    role: message.role,
+    content: message.content
+  };
+  if (message.role === "tool" && message.name) payload.name = message.name;
+  if (message.tool_call_id) payload.tool_call_id = message.tool_call_id;
+  if (message.tool_calls?.length) {
+    payload.tool_calls = message.tool_calls.map((call) => ({
+      id: call.id,
+      type: "function",
+      function: {
+        name: call.name,
+        arguments: stringifyArguments(call.arguments)
+      }
+    }));
+  }
+  return payload;
+}
+function toOpenAITool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      parameters: tool.schema.parameters ?? { type: "object", properties: {} }
+    }
+  };
+}
+async function parseResponse2(response, apiKey) {
+  await assertOk(response, apiKey);
+  const payload = await parseJson(response);
+  return parseCompletion2(payload);
+}
+function parseCompletion2(payload) {
+  const record = payload;
+  const choices = Array.isArray(record?.choices) ? record.choices : [];
+  const choice = choices[0];
+  const rawContent = choice?.message?.content;
+  const content = typeof rawContent === "string" ? rawContent : void 0;
+  const toolCalls = parseToolCalls2(choice?.message?.tool_calls);
+  const finishReason = toFinishReason2(
+    choice?.finish_reason,
+    content,
+    toolCalls !== void 0
+  );
+  const completion = {
+    finishReason
+  };
+  if (content !== void 0) completion.content = content;
+  if (toolCalls !== void 0) completion.toolCalls = toolCalls;
+  return completion;
+}
+function parseToolCalls2(value) {
+  if (!Array.isArray(value)) return void 0;
+  const calls = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const item = entry;
+    const name = typeof item.function?.name === "string" ? item.function.name : "";
+    if (!name) continue;
+    const id = typeof item.id === "string" && item.id ? item.id : `call_${calls.length + 1}`;
+    const rawArguments = typeof item.function?.arguments === "string" ? item.function.arguments : "";
+    calls.push({
+      id,
+      name,
+      arguments: parseArguments(rawArguments)
+    });
+  }
+  return calls.length ? calls : void 0;
+}
+function toFinishReason2(raw, content, hasToolCalls) {
+  if (raw === "stop" || raw === void 0 && content !== void 0 && !hasToolCalls) {
+    return "stop";
+  }
+  if (raw === "length") return "length";
+  if (raw === "tool_calls" || hasToolCalls) return "tool_calls";
+  return "error";
+}
+function toRequestError2(error, timeoutMs) {
+  if (isAbortLike(error)) {
+    return new OpenAICompatibleError(
+      0,
+      `LLM request timed out after ${timeoutMs}ms`
+    );
+  }
+  return new OpenAICompatibleError(0, `LLM request failed: ${errorMessage(error)}`);
+}
+async function* parseOpenAIStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let content = "";
+  let messageId = randomUUID2();
+  let model;
+  let messageStarted = false;
+  let finishReason;
+  const calls = /* @__PURE__ */ new Map();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+        buffer = buffer.slice(newlineIndex + 1);
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (!data) continue;
+        if (data === "[DONE]") {
+          yield* finalizeStreamEvents(messageId, content, calls, finishReason);
+          return;
+        }
+        let payload;
+        try {
+          payload = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const events = processStreamChunk(
+          payload,
+          { messageId, model, messageStarted },
+          { content, finishReason },
+          calls
+        );
+        messageId = events.messageId;
+        model = events.model;
+        messageStarted = true;
+        content = events.content;
+        finishReason = events.finishReason;
+        for (const event of events.events) yield event;
+      }
+    }
+  } finally {
+    if (reader.releaseLock) {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  yield* finalizeStreamEvents(messageId, content, calls, finishReason);
+}
+function processStreamChunk(payload, state, progress, calls) {
+  const record = payload;
+  const events = [];
+  let messageId = state.messageId;
+  let model = state.model;
+  let messageStarted = state.messageStarted;
+  let content = progress.content;
+  let finishReason = progress.finishReason;
+  if (typeof record?.id === "string" && record.id) messageId = record.id;
+  if (typeof record?.model === "string" && record.model) model = record.model;
+  if (!messageStarted) {
+    messageStarted = true;
+    const start = {
+      type: "message_start",
+      id: messageId,
+      ...model ? { model } : {}
+    };
+    events.push(start);
+  }
+  const choices = Array.isArray(record?.choices) ? record.choices : [];
+  const choice = choices[0];
+  if (choice?.finish_reason !== void 0 && choice.finish_reason !== null) {
+    finishReason = choice.finish_reason;
+  }
+  const delta = choice?.delta;
+  if (typeof delta?.content === "string" && delta.content) {
+    content += delta.content;
+    events.push({ type: "message_delta", id: messageId, delta: delta.content });
+  }
+  if (Array.isArray(delta?.tool_calls)) {
+    for (const entry of delta.tool_calls) {
+      const index = typeof entry.index === "number" ? entry.index : 0;
+      let call = calls.get(index);
+      if (!call) {
+        call = { index, id: "", name: "", arguments: "", emitted: false };
+        calls.set(index, call);
+      }
+      if (typeof entry.id === "string" && entry.id) call.id = entry.id;
+      if (typeof entry.function?.name === "string" && entry.function.name) {
+        call.name = entry.function.name;
+      }
+      if (typeof entry.function?.arguments === "string") {
+        call.arguments += entry.function.arguments;
+      }
+      if (!call.emitted && call.id && call.name) {
+        call.emitted = true;
+        events.push({
+          type: "toolcall_start",
+          id: call.id,
+          index,
+          name: call.name
+        });
+      }
+    }
+  }
+  return {
+    messageId,
+    model,
+    messageStarted,
+    content,
+    finishReason,
+    events
+  };
+}
+function finalizeStreamEvents(messageId, content, calls, finishReason) {
+  const events = [];
+  const toolCalls = [];
+  for (const call of calls.values()) {
+    if (!call.emitted) continue;
+    events.push({
+      type: "toolcall_end",
+      id: call.id,
+      index: call.index,
+      name: call.name,
+      arguments: parseArguments(call.arguments)
+    });
+    toolCalls.push({
+      id: call.id,
+      name: call.name,
+      arguments: parseArguments(call.arguments)
+    });
+  }
+  events.push({
+    type: "message_stop",
+    id: messageId,
+    finishReason: toFinishReason2(finishReason, content, toolCalls.length > 0)
+  });
+  return events;
+}
+function toStreamError2(error, timeoutMs) {
+  if (isAbortLike(error)) {
+    return new OpenAICompatibleError(
+      0,
+      `LLM stream timed out after ${timeoutMs}ms`
+    );
+  }
+  return new OpenAICompatibleError(0, `LLM stream failed: ${errorMessage(error)}`);
+}
+
+// packages/llm/src/provider.ts
+function createLlmAdapter(config) {
+  if (config.protocol === "anthropic") {
+    return anthropicMessagesAdapter(config);
+  }
+  if (config.protocol === "openai") {
+    return openaiCompatAdapter(config);
+  }
+  if (lookupModel(config.model)?.protocol === "anthropic") {
+    return anthropicMessagesAdapter(config);
+  }
+  return openaiCompatAdapter(config);
+}
+export {
+  DEFAULT_DEEPSEEK_MODEL,
+  DEFAULT_LLM_MAX_RETRIES,
+  DEFAULT_LLM_RETRY_DELAY_MS,
+  DEFAULT_LLM_TIMEOUT_MS,
+  DEFAULT_MODEL,
+  DEFAULT_OPENCODE_GO_BASE_URL,
+  MODEL_CATALOG,
+  OpenAICompatibleError,
+  anthropicMessagesAdapter,
+  assertOk,
+  combineSignal,
+  createLlmAdapter,
+  errorMessage,
+  isAbortLike,
+  isExternalAbort,
+  isRetryableStatus,
+  listModels,
+  lookupModel,
+  normalizeBaseUrl,
+  openaiCompatAdapter,
+  parseArguments,
+  parseJson,
+  sleep,
+  stringifyArguments
+};
+//# sourceMappingURL=llm.js.map