@agentdevjs/llm 0.1.0

package/dist/index.js

@@ -0,0 +1,2057 @@
+// src/custom-headers.ts
+import { randomUUID } from "crypto";
+function resolveCustomHeaders(headers) {
+  if (!headers || headers.length === 0) return {};
+  const result = {};
+  for (const h of headers) {
+    const key = (h.key ?? "").trim();
+    if (!key) continue;
+    const mode = h.valueMode ?? "static";
+    if (mode === "uuid") {
+      result[key] = randomUUID();
+    } else if (mode === "random") {
+      result[key] = String(Math.floor(Math.random() * 1e16));
+    } else {
+      result[key] = h.value ?? "";
+    }
+  }
+  return result;
+}
+
+// src/anthropic.ts
+import { getRetryDelay, parseRetryAfter, shouldRetry, resolveModelCallPolicy, withDeadline } from "@agentdevjs/core";
+import { classifyAndWrapError } from "@agentdevjs/core";
+
+// src/http-client.ts
+import { createLogger } from "@agentdevjs/core";
+var logger = createLogger("llm.http-client");
+var undici;
+var undiciLoadPromise = null;
+var initialGlobalDispatcher = null;
+var HTTP_CONNECT_TIMEOUT_MS = 1e4;
+var HTTP_HEADERS_TIMEOUT_MS = 6e4;
+var HTTP_BODY_TIMEOUT_MS = 6e4;
+function buildHttpDispatcherOptions(noProxy) {
+  return {
+    ...noProxy ? { noProxy } : {},
+    headersTimeout: HTTP_HEADERS_TIMEOUT_MS,
+    bodyTimeout: HTTP_BODY_TIMEOUT_MS,
+    connect: { timeout: HTTP_CONNECT_TIMEOUT_MS }
+  };
+}
+function isExternallyManagedDispatcher(current, initial) {
+  return current != null && initial != null && current !== initial;
+}
+async function loadUndici() {
+  if (undiciLoadPromise) {
+    return undiciLoadPromise;
+  }
+  undiciLoadPromise = (async () => {
+    try {
+      const mod = await import("undici");
+      return mod;
+    } catch {
+      try {
+        const { createRequire } = await import("module");
+        const _require = createRequire(import.meta.url);
+        return _require("undici");
+      } catch {
+        logger.warn("Failed to load undici, proxy and DNS caching will not be available");
+        return null;
+      }
+    }
+  })();
+  return undiciLoadPromise;
+}
+undici = await loadUndici();
+initialGlobalDispatcher = undici?.getGlobalDispatcher?.() ?? null;
+function getProxyUrl() {
+  return process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+}
+function maskProxyUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
+    }
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+var httpClientInitialized = false;
+var _dispatcher = null;
+function getGlobalDispatcher() {
+  return _dispatcher;
+}
+async function initHttpClient() {
+  if (httpClientInitialized) return;
+  httpClientInitialized = true;
+  if (!undici) {
+    undici = await loadUndici();
+    if (!undici) {
+      logger.warn("undici not available, skipping HTTP client initialization");
+      return;
+    }
+  }
+  const proxyUrl = getProxyUrl();
+  try {
+    const currentDispatcher = undici.getGlobalDispatcher?.() ?? null;
+    if (isExternallyManagedDispatcher(currentDispatcher, initialGlobalDispatcher)) {
+      _dispatcher = currentDispatcher;
+      logger.info("Using host-managed Undici dispatcher");
+      return;
+    }
+    if (proxyUrl) {
+      const proxyAgent = new undici.EnvHttpProxyAgent({
+        httpProxy: proxyUrl,
+        httpsProxy: proxyUrl,
+        ...buildHttpDispatcherOptions(process.env.NO_PROXY || process.env.no_proxy)
+      });
+      undici.setGlobalDispatcher(proxyAgent);
+      _dispatcher = proxyAgent;
+      logger.info("Proxy Agent configured (EnvHttpProxyAgent)", {
+        proxy: maskProxyUrl(proxyUrl)
+      });
+    } else {
+      const agent = new undici.Agent({
+        ...buildHttpDispatcherOptions(),
+        keepAliveTimeout: 3e4,
+        keepAliveMaxTimeout: 3e5,
+        connections: 50,
+        pipelining: 1
+      });
+      undici.setGlobalDispatcher(agent);
+      _dispatcher = agent;
+      logger.debug("Undici Agent configured (default, with keep-alive)");
+    }
+  } catch (e) {
+    logger.warn("Failed to set up undici dispatcher, proxy env vars will be ignored", {
+      error: e.message || String(e)
+    });
+  }
+}
+
+// src/image-resolver.ts
+import { readFileSync } from "fs";
+function resolveImageBase64(img) {
+  if (img.base64) return img.base64;
+  if (img.path) {
+    try {
+      const buf = readFileSync(img.path);
+      return buf.toString("base64");
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function resolveImageDataUri(img) {
+  const base64 = resolveImageBase64(img);
+  if (!base64) return null;
+  const mediaType = img.mediaType || "image/png";
+  return `data:${mediaType};base64,${base64}`;
+}
+
+// src/schema-sanitizer.ts
+function sanitizeToolSchema(parameters) {
+  const base = parameters && typeof parameters === "object" ? parameters : { type: "object", properties: {} };
+  return stripSchemaMeta(base);
+}
+function stripSchemaMeta(node) {
+  if (Array.isArray(node)) {
+    return node.map(stripSchemaMeta);
+  }
+  if (node && typeof node === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "$schema") continue;
+      out[key] = stripSchemaMeta(value);
+    }
+    return out;
+  }
+  return node;
+}
+
+// src/retry-observability.ts
+import { classifyAPIError } from "@agentdevjs/core";
+async function emitRetryObservability(params) {
+  const { attempt, maxRetries, delayMs, signal, error, status } = params;
+  const base = {
+    attempt,
+    maxRetries,
+    ...delayMs !== void 0 ? { delayMs } : {},
+    ...status !== void 0 ? { statusCode: status } : {},
+    errorType: classifyAPIError(error, status)
+  };
+  await emitRetryNotification({ ...base, phase: "waiting" });
+  await sleepQuietly(delayMs, signal);
+  await emitRetryNotification({ ...base, phase: "requesting" });
+}
+async function emitRetryNotification(data) {
+  try {
+    const { emitNotification, createLLMRetry } = await import("@agentdevjs/core");
+    emitNotification(createLLMRetry(data));
+  } catch {
+  }
+}
+async function sleepQuietly(ms, signal) {
+  const { sleep: sleep2 } = await import("@agentdevjs/core");
+  await sleep2(ms, signal);
+}
+
+// src/reminder.ts
+function wrapReminder(text) {
+  const trimmed = text.trim();
+  return /^<reminder[\s>]/.test(trimmed) ? trimmed : `<reminder>${trimmed}</reminder>`;
+}
+
+// src/anthropic.ts
+var httpClientInitPromise = null;
+function ensureHttpClientInitialized() {
+  if (!httpClientInitPromise) {
+    httpClientInitPromise = initHttpClient();
+  }
+  return httpClientInitPromise;
+}
+var DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
+var DEFAULT_MAX_TOKENS = 4096;
+var AnthropicLLM = class {
+  constructor(apiKey, _modelName = "claude-sonnet-4-5-20250929", baseUrl = DEFAULT_BASE_URL, maxTokens = DEFAULT_MAX_TOKENS, thinkingEffort, _thinkingBudgetTokens, _thinkingKeepTurns = 5, customHeaders, visionEnabled = false, callPolicy) {
+    this.apiKey = apiKey;
+    this._modelName = _modelName;
+    this.baseUrl = baseUrl;
+    this.maxTokens = maxTokens;
+    this.thinkingEffort = thinkingEffort;
+    this._thinkingBudgetTokens = _thinkingBudgetTokens;
+    this._thinkingKeepTurns = _thinkingKeepTurns;
+    this.customHeaders = customHeaders;
+    this.visionEnabled = visionEnabled;
+    const resolved = resolveModelCallPolicy(callPolicy);
+    this.maxRetries = resolved.maxRetries;
+    this.deadlineMs = resolved.timeoutMs;
+    this.initPromise = ensureHttpClientInitialized();
+  }
+  apiKey;
+  _modelName;
+  baseUrl;
+  maxTokens;
+  thinkingEffort;
+  _thinkingBudgetTokens;
+  _thinkingKeepTurns;
+  customHeaders;
+  visionEnabled;
+  initPromise;
+  maxRetries;
+  deadlineMs;
+  /** 返回当前 LLM 实例使用的模型名 */
+  get modelName() {
+    return this._modelName;
+  }
+  async chat(messages, tools, options) {
+    await this.initPromise;
+    const signal = withDeadline(options?.signal, this.deadlineMs);
+    const compiled = compileContextForAnthropic(messages, tools, this.visionEnabled);
+    const noStream = options?.noStream === true;
+    for (let attempt = 1; attempt <= this.maxRetries + 1; attempt++) {
+      let response;
+      try {
+        if (signal?.aborted) {
+          throw new DOMException("Aborted", "AbortError");
+        }
+        const effectiveMaxTokens = this.maxTokens;
+        const effort = this.thinkingEffort;
+        const validEfforts = ["low", "medium", "high", "xhigh", "max"];
+        const wantsThinking = effort !== void 0 && validEfforts.includes(effort);
+        const useDisabled = effort === "none";
+        const budget = this._thinkingBudgetTokens;
+        const useEnabled = wantsThinking && typeof budget === "number" && budget > 0;
+        const effectiveBudget = useEnabled ? Math.min(budget, effectiveMaxTokens - 1) : void 0;
+        response = await fetch(resolveAnthropicMessagesUrl(this.baseUrl), {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": this.apiKey,
+            "anthropic-version": "2023-06-01",
+            ...resolveCustomHeaders(this.customHeaders)
+          },
+          body: JSON.stringify({
+            model: this._modelName,
+            max_tokens: effectiveMaxTokens,
+            ...noStream ? {} : { stream: true },
+            ...useDisabled ? { thinking: { type: "disabled" } } : useEnabled ? { thinking: { type: "enabled", budget_tokens: effectiveBudget } } : {},
+            ...compiled.system ? { system: compiled.system } : {},
+            messages: compiled.messages,
+            ...compiled.tools && compiled.tools.length > 0 ? { tools: compiled.tools } : {}
+          }),
+          signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          const err = new Error(`Anthropic API error ${response.status}: ${errorText}`);
+          err.status = response.status;
+          throw err;
+        }
+        if (noStream) {
+          const payload = await response.json();
+          if (isCompatErrorPayload(payload)) {
+            const err = new Error(`Anthropic-compatible API error ${payload.code ?? "unknown"}: ${payload.msg ?? payload.message ?? "unknown error"}`);
+            err.status = payload.code;
+            throw err;
+          }
+          return parseAnthropicJsonResponse(payload);
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          const payload = await response.json();
+          if (isCompatErrorPayload(payload)) {
+            const err = new Error(`Anthropic-compatible API error ${payload.code ?? "unknown"}: ${payload.msg ?? payload.message ?? "unknown error"}`);
+            err.status = payload.code;
+            throw err;
+          }
+          throw new Error(`Anthropic streaming expected SSE but received JSON: ${JSON.stringify(payload)}`);
+        }
+        if (!response.body) {
+          throw new Error("Anthropic API returned an empty response body");
+        }
+        return await readAnthropicStream(response.body, signal);
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw error;
+        }
+        const status = error?.status;
+        if (attempt <= this.maxRetries && shouldRetry(error, status)) {
+          const retryAfterMs = parseRetryAfter(response?.headers);
+          const delayMs = getRetryDelay(attempt, retryAfterMs);
+          await emitRetryObservability({
+            attempt,
+            maxRetries: this.maxRetries,
+            delayMs,
+            signal,
+            error,
+            status
+          });
+          continue;
+        }
+        throw classifyAndWrapError(error, status);
+      }
+    }
+    throw new Error("Anthropic API call failed after all retries");
+  }
+};
+function resolveAnthropicMessagesUrl(baseUrl) {
+  const normalized = baseUrl.replace(/\/+$/, "");
+  if (/\/v\d+$/i.test(normalized)) {
+    return `${normalized}/messages`;
+  }
+  return `${normalized}/v1/messages`;
+}
+function isCompatErrorPayload(payload) {
+  if (payload.success === false) return true;
+  if (typeof payload.code === "number" && payload.code !== 0) return true;
+  return false;
+}
+function compileContextForAnthropic(messages, tools, visionEnabled = false) {
+  const systemBlocks = [];
+  const compiledMessages = [];
+  let seenFirstUser = false;
+  let pendingUserBlocks = [];
+  const flushPendingUserBlocks = () => {
+    if (pendingUserBlocks.length === 0) return;
+    compiledMessages.push({ role: "user", content: pendingUserBlocks });
+    pendingUserBlocks = [];
+  };
+  for (const message of messages) {
+    if (!seenFirstUser && message.role === "system") {
+      if (!message.source) {
+        systemBlocks.push({
+          type: "text",
+          text: message.content,
+          cache_control: { type: "ephemeral" }
+        });
+      } else {
+        pendingUserBlocks.push({
+          type: "text",
+          text: wrapReminder(message.content)
+        });
+      }
+      continue;
+    }
+    if (!seenFirstUser && message.role !== "user") {
+      throw new Error(`Anthropic compilation requires the first non-system message to be user, got '${message.role}'`);
+    }
+    switch (message.role) {
+      case "system":
+        pendingUserBlocks.push({
+          type: "text",
+          text: wrapReminder(message.content)
+        });
+        break;
+      case "tool":
+        pendingUserBlocks.push(toolMessageToAnthropicBlock(message, visionEnabled));
+        break;
+      case "user": {
+        seenFirstUser = true;
+        const contentBlocks = [...pendingUserBlocks];
+        let textContent = message.content;
+        if (message.images && message.images.length > 0) {
+          if (visionEnabled) {
+            for (const img of message.images) {
+              const data = resolveImageBase64(img);
+              if (data) {
+                contentBlocks.push({
+                  type: "image",
+                  source: {
+                    type: "base64",
+                    media_type: img.mediaType || "image/png",
+                    data
+                  }
+                });
+              }
+            }
+          } else {
+            const placeholders = message.images.map((img) => `\u3010Image\u3011${img.source || "(inline image)"}`).join("\n");
+            textContent = `${message.content}
+${placeholders}`;
+          }
+        }
+        contentBlocks.push({ type: "text", text: textContent });
+        compiledMessages.push({
+          role: "user",
+          content: contentBlocks.length === 1 ? textContent : contentBlocks
+        });
+        pendingUserBlocks = [];
+        break;
+      }
+      case "assistant":
+        flushPendingUserBlocks();
+        compiledMessages.push({
+          role: "assistant",
+          content: assistantMessageToAnthropicContent(message)
+        });
+        break;
+      default:
+        throw new Error(`Anthropic compilation does not support message role '${message.role}'`);
+    }
+  }
+  flushPendingUserBlocks();
+  return {
+    ...systemBlocks.length > 0 ? { system: systemBlocks } : {},
+    messages: compiledMessages,
+    ...tools.length > 0 ? { tools: tools.map(toolToAnthropicDefinition) } : {}
+  };
+}
+function toolToAnthropicDefinition(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: sanitizeToolSchema(tool.parameters)
+  };
+}
+function assistantMessageToAnthropicContent(message) {
+  const blocks = [];
+  if (message.thinkingBlocks) {
+    for (const thinkingBlock of message.thinkingBlocks) {
+      blocks.push({
+        type: "thinking",
+        thinking: thinkingBlock.thinking,
+        signature: thinkingBlock.signature
+      });
+    }
+  }
+  if (message.content) {
+    blocks.push({ type: "text", text: message.content });
+  }
+  if (message.toolCalls) {
+    for (const toolCall of message.toolCalls) {
+      blocks.push({
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.name,
+        input: toolCall.arguments
+      });
+    }
+  }
+  if (blocks.length === 0) {
+    return "";
+  }
+  if (blocks.length === 1 && blocks[0].type === "text") {
+    return blocks[0].text;
+  }
+  return blocks;
+}
+function toolMessageToAnthropicBlock(message, visionEnabled) {
+  if (!message.toolCallId) {
+    throw new Error("Anthropic compilation requires tool messages to include toolCallId");
+  }
+  const parsed = parseToolPayload(message.content);
+  const isError = parsed.isError;
+  if (!message.images || message.images.length === 0) {
+    return {
+      type: "tool_result",
+      tool_use_id: message.toolCallId,
+      content: parsed.content,
+      ...isError ? { is_error: true } : {}
+    };
+  }
+  if (visionEnabled) {
+    const contentParts = [
+      { type: "text", text: parsed.content }
+    ];
+    for (const img of message.images) {
+      const data = resolveImageBase64(img);
+      if (data) {
+        contentParts.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: img.mediaType || "image/png",
+            data
+          }
+        });
+      }
+    }
+    return {
+      type: "tool_result",
+      tool_use_id: message.toolCallId,
+      content: contentParts,
+      ...isError ? { is_error: true } : {}
+    };
+  }
+  const placeholders = message.images.map((img) => `\u3010Image\u3011${img.source || "(inline image)"}`).join("\n");
+  return {
+    type: "tool_result",
+    tool_use_id: message.toolCallId,
+    content: `${parsed.content}
+${placeholders}`,
+    ...isError ? { is_error: true } : {}
+  };
+}
+function parseToolPayload(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object" && ("result" in parsed || "error" in parsed || "success" in parsed)) {
+      const isError = parsed.success === false || !!parsed.error;
+      if (isError && typeof parsed.error === "string" && parsed.error.trim()) {
+        return { content: parsed.error, isError: true };
+      }
+      if (parsed.result !== void 0) {
+        return { content: stringifyToolValue(parsed.result), isError };
+      }
+      return { content, isError };
+    }
+  } catch {
+  }
+  return { content, isError: false };
+}
+function stringifyToolValue(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function findDoubleNewlineIndex(buffer) {
+  for (let i = 0; i < buffer.length - 1; i++) {
+    const ch = buffer[i];
+    const next = buffer[i + 1];
+    if (ch === "\n" && next === "\n") return { index: i, separatorLen: 2 };
+    if (ch === "\r" && next === "\r") return { index: i, separatorLen: 2 };
+    if (ch === "\r" && next === "\n" && i + 3 < buffer.length && buffer[i + 2] === "\r" && buffer[i + 3] === "\n") {
+      return { index: i, separatorLen: 4 };
+    }
+  }
+  return { index: -1, separatorLen: 0 };
+}
+function parseAnthropicJsonResponse(data) {
+  let content = "";
+  let reasoning = "";
+  const toolCalls = [];
+  const thinkingBlocks = [];
+  if (Array.isArray(data.content)) {
+    for (const block of data.content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        content += block.text;
+      } else if (block.type === "thinking") {
+        const thinking = typeof block.thinking === "string" ? block.thinking : "";
+        const signature = typeof block.signature === "string" ? block.signature : "";
+        if (thinking) reasoning += thinking;
+        if (signature.length > 0 && thinking.length > 0) {
+          thinkingBlocks.push({ thinking, signature });
+        }
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: String(block.id ?? ""),
+          name: String(block.name ?? ""),
+          arguments: block.input && typeof block.input === "object" && !Array.isArray(block.input) ? block.input : {}
+        });
+      }
+    }
+  }
+  const usageRaw = data.usage;
+  let usageInfo;
+  if (usageRaw && (usageRaw.input_tokens !== void 0 || usageRaw.output_tokens !== void 0)) {
+    const realInput = (usageRaw.input_tokens || 0) + (usageRaw.cache_creation_input_tokens || 0) + (usageRaw.cache_read_input_tokens || 0);
+    usageInfo = {
+      inputTokens: realInput,
+      outputTokens: usageRaw.output_tokens || 0,
+      totalTokens: realInput + (usageRaw.output_tokens || 0),
+      ...usageRaw.cache_creation_input_tokens ? { cacheCreationTokens: usageRaw.cache_creation_input_tokens } : {},
+      ...usageRaw.cache_read_input_tokens ? { cacheReadTokens: usageRaw.cache_read_input_tokens } : {}
+    };
+  }
+  return {
+    content,
+    ...toolCalls.length > 0 ? { toolCalls } : {},
+    ...reasoning ? { reasoning } : {},
+    ...thinkingBlocks.length > 0 ? { thinkingBlocks } : {},
+    ...usageInfo ? { usage: usageInfo } : {},
+    stopReason: data.stop_reason ?? null
+  };
+}
+async function readAnthropicStream(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let content = "";
+  let reasoning = "";
+  const pendingThinkingBlocks = /* @__PURE__ */ new Map();
+  let charCount = 0;
+  let currentPhase = "content";
+  const pendingToolUses = /* @__PURE__ */ new Map();
+  let usageInfo = null;
+  let stopReason = null;
+  let receivedMessageStart = false;
+  let receivedMessageStop = false;
+  const onStreamAbort = () => reader.cancel().catch(() => {
+  });
+  if (signal && !signal.aborted) {
+    signal.addEventListener("abort", onStreamAbort, { once: true });
+  }
+  const phaseCharCount = (phase) => phase === "thinking" ? reasoning.length : content.length;
+  const applyEvent = (event) => {
+    if (event.type === "message_start") receivedMessageStart = true;
+    if (event.type === "message_stop") receivedMessageStop = true;
+    applyAnthropicStreamEvent(event, pendingThinkingBlocks, pendingToolUses, (delta) => {
+      content += delta.content;
+      reasoning += delta.reasoning;
+      charCount += delta.charCount;
+      currentPhase = delta.phase;
+    }, (usage) => {
+      if (usageInfo) {
+        const inputTokens = usage.inputTokens || usageInfo.inputTokens;
+        const outputTokens = usage.outputTokens || usageInfo.outputTokens;
+        usageInfo = {
+          ...usageInfo,
+          ...usage,
+          inputTokens,
+          totalTokens: inputTokens + outputTokens
+        };
+      } else {
+        usageInfo = usage;
+      }
+    }, (reason) => {
+      stopReason = reason;
+    });
+  };
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      const { value, done } = await reader.read();
+      if (signal?.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep = findDoubleNewlineIndex(buffer);
+      while (sep.index >= 0) {
+        const rawEvent = buffer.slice(0, sep.index);
+        buffer = buffer.slice(sep.index + sep.separatorLen);
+        const event = parseSSEEvent(rawEvent);
+        if (event) {
+          applyEvent(event);
+          const toolNames = Array.from(pendingToolUses.values()).map((t) => t.name).filter(Boolean);
+          await emitAnthropicProgress(
+            phaseCharCount(currentPhase),
+            currentPhase,
+            pendingToolUses.size,
+            toolNames,
+            reasoning.length,
+            content.length
+          );
+        }
+        sep = findDoubleNewlineIndex(buffer);
+      }
+    }
+  } catch (e) {
+    if (e instanceof DOMException && e.name === "AbortError") throw e;
+    if (e instanceof Error && e.name === "AbortError") throw e;
+    throw e;
+  } finally {
+    signal?.removeEventListener("abort", onStreamAbort);
+  }
+  if (buffer.trim()) {
+    const event = parseSSEEvent(buffer);
+    if (event) {
+      applyEvent(event);
+      const toolNames = Array.from(pendingToolUses.values()).map((t) => t.name).filter(Boolean);
+      await emitAnthropicProgress(
+        phaseCharCount(currentPhase),
+        currentPhase,
+        pendingToolUses.size,
+        toolNames,
+        reasoning.length,
+        content.length
+      );
+    }
+  }
+  if (receivedMessageStart && !receivedMessageStop && !content && pendingToolUses.size === 0 && !reasoning) {
+    throw new Error("Anthropic stream ended incompletely: received message_start but no message_stop or content");
+  }
+  const toolCalls = finalizeToolCalls(pendingToolUses);
+  const thinkingBlocks = finalizeThinkingBlocks(pendingThinkingBlocks);
+  await emitAnthropicComplete(charCount);
+  return {
+    content,
+    ...toolCalls.length > 0 ? { toolCalls } : {},
+    ...reasoning ? { reasoning } : {},
+    ...thinkingBlocks.length > 0 ? { thinkingBlocks } : {},
+    ...usageInfo ? { usage: usageInfo } : {},
+    stopReason
+  };
+}
+function parseSSEEvent(rawEvent) {
+  const dataLines = rawEvent.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+  if (dataLines.length === 0) return null;
+  const data = dataLines.join("\n");
+  if (data === "[DONE]") return null;
+  try {
+    return JSON.parse(data);
+  } catch {
+    console.warn(`[Anthropic] Skipping malformed SSE event: ${data.slice(0, 200)}`);
+    return null;
+  }
+}
+function applyAnthropicStreamEvent(event, pendingThinkingBlocks, pendingToolUses, append, onUsage, onStopReason) {
+  switch (event.type) {
+    case "content_block_start": {
+      if (event.content_block?.type === "thinking" && typeof event.index === "number") {
+        pendingThinkingBlocks.set(event.index, {
+          thinking: event.content_block.thinking || "",
+          signature: event.content_block.signature || ""
+        });
+      }
+      if (event.content_block?.type === "tool_use" && typeof event.index === "number") {
+        pendingToolUses.set(event.index, {
+          id: event.content_block.id,
+          name: event.content_block.name,
+          // Always start with empty string — the API sends input: {} at
+          // content_block_start but actual content arrives via
+          // input_json_delta events.  Initializing with a stringified
+          // non-empty object would corrupt the accumulated JSON when
+          // deltas are appended.  (Matches Claude Code's approach.)
+          inputJson: ""
+        });
+      }
+      break;
+    }
+    case "content_block_delta": {
+      const deltaType = event.delta?.type;
+      if (deltaType === "text_delta") {
+        const text = event.delta?.text ?? "";
+        append({ content: text, reasoning: "", charCount: text.length, phase: "content" });
+      } else if (deltaType === "thinking_delta") {
+        const thinking = event.delta?.thinking ?? "";
+        if (typeof event.index === "number") {
+          const block = pendingThinkingBlocks.get(event.index) ?? { thinking: "", signature: "" };
+          block.thinking += thinking;
+          pendingThinkingBlocks.set(event.index, block);
+        }
+        append({ content: "", reasoning: thinking, charCount: thinking.length, phase: "thinking" });
+      } else if (deltaType === "signature_delta" && typeof event.index === "number") {
+        const block = pendingThinkingBlocks.get(event.index) ?? { thinking: "", signature: "" };
+        block.signature += event.delta.signature ?? "";
+        pendingThinkingBlocks.set(event.index, block);
+      } else if (deltaType === "input_json_delta" && typeof event.index === "number") {
+        const toolUse = pendingToolUses.get(event.index);
+        if (toolUse) {
+          const partial = event.delta?.partial_json ?? "";
+          toolUse.inputJson = mergeToolInputJson(toolUse.inputJson, partial);
+          append({ content: "", reasoning: "", charCount: 0, phase: "tool_calling" });
+        } else {
+          console.warn(`[Anthropic] input_json_delta for unknown content block index ${event.index}, skipping`);
+        }
+      }
+      break;
+    }
+    case "message_start": {
+      const usage = event.message?.usage;
+      if (usage && (usage.input_tokens !== void 0 || usage.output_tokens !== void 0)) {
+        const realInput = (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+        onUsage({
+          inputTokens: realInput,
+          outputTokens: usage.output_tokens || 0,
+          totalTokens: realInput + (usage.output_tokens || 0),
+          ...usage.cache_creation_input_tokens ? { cacheCreationTokens: usage.cache_creation_input_tokens } : {},
+          ...usage.cache_read_input_tokens ? { cacheReadTokens: usage.cache_read_input_tokens } : {}
+        });
+      }
+      break;
+    }
+    case "message_delta": {
+      if (event.delta?.stop_reason && onStopReason) {
+        onStopReason(event.delta.stop_reason);
+      }
+      const usage = event.usage;
+      if (usage && (usage.input_tokens !== void 0 || usage.output_tokens !== void 0)) {
+        const realInput = (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+        onUsage({
+          inputTokens: realInput,
+          outputTokens: usage.output_tokens || 0,
+          totalTokens: realInput + (usage.output_tokens || 0),
+          ...usage.cache_creation_input_tokens ? { cacheCreationTokens: usage.cache_creation_input_tokens } : {},
+          ...usage.cache_read_input_tokens ? { cacheReadTokens: usage.cache_read_input_tokens } : {}
+        });
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+async function emitAnthropicProgress(charCount, phase, toolCallCount, toolNames, thinkingChars, contentChars) {
+  try {
+    const { emitNotification, createLLMCharCount } = await import("@agentdevjs/core");
+    if (charCount > 0 || toolCallCount > 0) {
+      emitNotification(createLLMCharCount(charCount, phase, {
+        toolCallCount,
+        ...typeof thinkingChars === "number" ? { thinkingChars } : {},
+        ...typeof contentChars === "number" ? { contentChars } : {},
+        ...Array.isArray(toolNames) && toolNames.length > 0 ? { streamToolNames: toolNames } : {}
+      }));
+    }
+  } catch {
+  }
+}
+async function emitAnthropicComplete(charCount) {
+  try {
+    const { emitNotification, createLLMComplete } = await import("@agentdevjs/core");
+    emitNotification(createLLMComplete(charCount));
+  } catch {
+  }
+}
+function mergeToolInputJson(current, partial) {
+  if (!current.trim()) return partial;
+  return current + partial;
+}
+function finalizeThinkingBlocks(pendingThinkingBlocks) {
+  return Array.from(pendingThinkingBlocks.entries()).sort((a, b) => a[0] - b[0]).map(([, block]) => ({
+    signature: block.signature,
+    thinking: block.thinking
+  })).filter((block) => block.signature.length > 0 && block.thinking.length > 0);
+}
+function finalizeToolCalls(pendingToolUses) {
+  return Array.from(pendingToolUses.entries()).sort((a, b) => a[0] - b[0]).map(([, toolUse]) => ({
+    id: toolUse.id,
+    name: toolUse.name,
+    arguments: parseToolInput(toolUse.inputJson, toolUse.name)
+  }));
+}
+function stripBOM(str) {
+  return str.replace(/^/, "");
+}
+function safeParseJSON(json) {
+  if (!json) return null;
+  try {
+    return JSON.parse(stripBOM(json));
+  } catch {
+    return null;
+  }
+}
+function parseToolInput(inputJson, toolName) {
+  const trimmed = inputJson.trim();
+  if (!trimmed) return {};
+  const parsed = safeParseJSON(trimmed);
+  if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parsed;
+  }
+  const braceStart = trimmed.indexOf("{");
+  if (braceStart >= 0) {
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = braceStart; i < trimmed.length; i++) {
+      const ch = trimmed[i];
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        if (inString) escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
+      }
+      if (inString) continue;
+      if (ch === "{" || ch === "[") depth++;
+      else if (ch === "}" || ch === "]") {
+        depth--;
+        if (depth === 0) {
+          const candidate = trimmed.slice(braceStart, i + 1);
+          const recovered = safeParseJSON(candidate);
+          if (recovered !== null && typeof recovered === "object" && !Array.isArray(recovered)) {
+            return recovered;
+          }
+          break;
+        }
+      }
+    }
+  }
+  console.warn(
+    `[Anthropic] Failed to parse tool input JSON${toolName ? ` for tool "${toolName}"` : ""}. Input length: ${trimmed.length}, preview: ${trimmed.slice(0, 200)}`
+  );
+  return {};
+}
+function createAnthropicLLM(configOrApiKey, modelName, baseUrl) {
+  if (typeof configOrApiKey === "object" && "defaultModel" in configOrApiKey) {
+    return new AnthropicLLM(
+      configOrApiKey.defaultModel.apiKey,
+      configOrApiKey.defaultModel.model,
+      configOrApiKey.defaultModel.baseUrl,
+      configOrApiKey.defaultModel.maxTokens && configOrApiKey.defaultModel.maxTokens > 0 ? configOrApiKey.defaultModel.maxTokens : DEFAULT_MAX_TOKENS,
+      configOrApiKey.defaultModel.thinkingEffort,
+      configOrApiKey.defaultModel.thinkingBudgetTokens,
+      configOrApiKey.defaultModel.thinkingKeepTurns ?? 5,
+      configOrApiKey.defaultModel.customHeaders,
+      configOrApiKey.defaultModel.vision ?? false,
+      { maxRetries: configOrApiKey.defaultModel.maxRetries, timeoutMs: configOrApiKey.defaultModel.timeoutMs }
+    );
+  }
+  if (typeof configOrApiKey === "object") {
+    return new AnthropicLLM(
+      configOrApiKey.apiKey,
+      configOrApiKey.model,
+      configOrApiKey.baseUrl,
+      configOrApiKey.maxTokens && configOrApiKey.maxTokens > 0 ? configOrApiKey.maxTokens : DEFAULT_MAX_TOKENS,
+      configOrApiKey.thinkingEffort,
+      configOrApiKey.thinkingBudgetTokens,
+      configOrApiKey.thinkingKeepTurns ?? 5,
+      configOrApiKey.customHeaders,
+      configOrApiKey.vision ?? false,
+      { maxRetries: configOrApiKey.maxRetries, timeoutMs: configOrApiKey.timeoutMs }
+    );
+  }
+  return new AnthropicLLM(configOrApiKey, modelName, baseUrl);
+}
+
+// src/openai.ts
+import { OPENAI_THINKING_EFFORTS } from "@agentdevjs/core";
+import OpenAI from "openai";
+import { getRetryDelay as getRetryDelay2, parseRetryAfter as parseRetryAfter2, shouldRetry as shouldRetry2, resolveModelCallPolicy as resolveModelCallPolicy2, withDeadline as withDeadline2 } from "@agentdevjs/core";
+import { classifyAndWrapError as classifyAndWrapError2 } from "@agentdevjs/core";
+var httpClientInitPromise2 = null;
+function ensureHttpClientInitialized2() {
+  if (!httpClientInitPromise2) {
+    httpClientInitPromise2 = initHttpClient();
+  }
+  return httpClientInitPromise2;
+}
+function compileChatMessages(messages, visionEnabled = false) {
+  const systemPromptParts = [];
+  const compiled = [];
+  let seenFirstUser = false;
+  let pendingReminders = [];
+  const flushRemindersAsUserMessage = () => {
+    if (pendingReminders.length === 0) return;
+    compiled.push({ role: "user", content: pendingReminders.join("\n\n") });
+    pendingReminders = [];
+  };
+  for (const m of messages) {
+    if (m.role === "system") {
+      if (!seenFirstUser && !m.source) {
+        systemPromptParts.push(m.content);
+      } else {
+        pendingReminders.push(wrapReminder(m.content));
+      }
+      continue;
+    }
+    if (m.role === "tool") {
+      compiled.push({ role: "tool", content: m.content, tool_call_id: m.toolCallId });
+      if (m.images && m.images.length > 0) {
+        if (visionEnabled) {
+          const parts = [
+            { type: "text", text: `[Tool image result for ${m.toolCallId}]` }
+          ];
+          for (const img of m.images) {
+            const url = resolveImageDataUri(img) || img.source;
+            if (url) {
+              parts.push({ type: "image_url", image_url: { url } });
+            }
+          }
+          compiled.push({ role: "user", content: parts });
+        } else {
+          const placeholders = m.images.map((img) => `\u3010Image\u3011${img.source || "(inline image)"}`).join("\n");
+          compiled.push({ role: "user", content: `[Tool image placeholders]
+${placeholders}` });
+        }
+      }
+      continue;
+    }
+    if (m.role === "assistant" && Array.isArray(m.toolCalls) && m.toolCalls.length > 0) {
+      compiled.push({
+        role: "assistant",
+        content: m.content ?? "",
+        tool_calls: m.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: JSON.stringify(tc.arguments ?? {})
+          }
+        }))
+      });
+      continue;
+    }
+    if (m.role === "user" && m.images && m.images.length > 0) {
+      seenFirstUser = true;
+      const prefix = pendingReminders.length > 0 ? `${pendingReminders.join("\n\n")}
+
+` : "";
+      pendingReminders = [];
+      if (visionEnabled) {
+        const parts = [];
+        if (m.content) {
+          parts.push({ type: "text", text: `${prefix}${m.content}` });
+        } else if (prefix) {
+          parts.push({ type: "text", text: prefix.trimEnd() });
+        }
+        for (const img of m.images) {
+          const url = resolveImageDataUri(img) || img.source;
+          if (url) {
+            parts.push({ type: "image_url", image_url: { url } });
+          }
+        }
+        compiled.push({ role: "user", content: parts });
+      } else {
+        const placeholders = m.images.map((img) => `\u3010Image\u3011${img.source || "(inline image)"}`).join("\n");
+        compiled.push({ role: "user", content: `${prefix}${m.content}
+${placeholders}` });
+      }
+      continue;
+    }
+    if (m.role === "user") {
+      seenFirstUser = true;
+      if (pendingReminders.length > 0) {
+        compiled.push({ role: "user", content: `${pendingReminders.join("\n\n")}
+
+${m.content}` });
+        pendingReminders = [];
+      } else {
+        compiled.push({ role: "user", content: m.content });
+      }
+      continue;
+    }
+    compiled.push({ role: m.role, content: m.content });
+  }
+  flushRemindersAsUserMessage();
+  const result = [];
+  if (systemPromptParts.length > 0) {
+    result.push({ role: "system", content: systemPromptParts.join("\n\n") });
+  }
+  result.push(...compiled);
+  return result;
+}
+var OpenAILLM = class {
+  client;
+  _modelName;
+  maxTokens;
+  thinkingEffort;
+  providerOptions;
+  customHeaders;
+  visionEnabled;
+  initPromise;
+  maxRetries;
+  deadlineMs;
+  /** 返回当前 LLM 实例使用的模型名 */
+  get modelName() {
+    return this._modelName;
+  }
+  constructor(apiKey, modelName = "gpt-4o", baseUrl, maxTokens, thinkingEffort, providerOptions, customHeaders, visionEnabled = false, callPolicy) {
+    const resolved = resolveModelCallPolicy2(callPolicy);
+    this.maxRetries = resolved.maxRetries;
+    this.deadlineMs = resolved.timeoutMs;
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: baseUrl,
+      // 通过自定义 fetch 注入动态请求头，使 uuid / random 模式在每次请求时重新生成
+      ...customHeaders && customHeaders.length > 0 ? {
+        fetch: (input, init) => {
+          init = init || {};
+          const headers = new Headers(init.headers);
+          for (const [k, v] of Object.entries(resolveCustomHeaders(customHeaders))) {
+            headers.set(k, v);
+          }
+          headers.delete("content-length");
+          init.headers = headers;
+          return globalThis.fetch(input, init);
+        }
+      } : {}
+    });
+    this._modelName = modelName;
+    this.maxTokens = maxTokens;
+    this.thinkingEffort = thinkingEffort;
+    this.providerOptions = providerOptions;
+    this.customHeaders = customHeaders;
+    this.visionEnabled = visionEnabled;
+    this.initPromise = ensureHttpClientInitialized2();
+  }
+  /**
+   * 聊天 - 核心方法（内部使用流式处理，带重试）
+   */
+  async chat(messages, tools, options) {
+    await this.initPromise;
+    const signal = withDeadline2(options?.signal, this.deadlineMs);
+    const chatMessages = compileChatMessages(messages, this.visionEnabled);
+    const chatTools = tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: sanitizeToolSchema(t.parameters)
+      }
+    }));
+    const requestBody = {
+      model: this._modelName,
+      messages: chatMessages,
+      tools: chatTools.length > 0 ? chatTools : void 0,
+      stream: true,
+      stream_options: { include_usage: true },
+      ...this.maxTokens ? { max_tokens: this.maxTokens } : {},
+      ...this.thinkingEffort && OPENAI_THINKING_EFFORTS.includes(this.thinkingEffort) ? { reasoning_effort: this.thinkingEffort } : {},
+      ...this.providerOptions ?? {}
+    };
+    for (let attempt = 1; attempt <= this.maxRetries + 1; attempt++) {
+      try {
+        if (signal?.aborted) {
+          throw new DOMException("Aborted", "AbortError");
+        }
+        const stream = await this.client.chat.completions.create(requestBody, {
+          signal
+        });
+        let content = "";
+        let reasoning = "";
+        let currentPhase = "content";
+        const accumulatedToolCalls = /* @__PURE__ */ new Map();
+        let usageInfo = null;
+        let finishReason = null;
+        for await (const chunk of stream) {
+          if (signal?.aborted) {
+            throw new DOMException("Aborted", "AbortError");
+          }
+          if (chunk.usage) {
+            const u = chunk.usage;
+            const extendedDetails = u;
+            let reasoningTokens = 0;
+            if (extendedDetails.prompt_tokens_details?.reasoning_tokens) {
+              reasoningTokens += extendedDetails.prompt_tokens_details.reasoning_tokens;
+            }
+            if (extendedDetails.completion_tokens_details?.reasoning_tokens) {
+              reasoningTokens += extendedDetails.completion_tokens_details.reasoning_tokens;
+            }
+            usageInfo = {
+              inputTokens: u.prompt_tokens || 0,
+              outputTokens: u.completion_tokens || 0,
+              totalTokens: (u.prompt_tokens || 0) + (u.completion_tokens || 0),
+              ...reasoningTokens > 0 ? { reasoningTokens } : {}
+            };
+          }
+          const delta = chunk.choices[0]?.delta;
+          if (!delta) {
+            continue;
+          }
+          const rawDelta = delta;
+          if (rawDelta.reasoning_content) {
+            currentPhase = "thinking";
+            reasoning += rawDelta.reasoning_content;
+          }
+          if (delta.content) {
+            currentPhase = "content";
+            content += delta.content;
+          }
+          if (delta.tool_calls) {
+            currentPhase = "tool_calling";
+            for (const toolCall of delta.tool_calls) {
+              let index = toolCall.index;
+              if (index === void 0 || index === null) {
+                if (toolCall.id) {
+                  const existingIndex = Array.from(accumulatedToolCalls.entries()).find(([, v]) => v.id === toolCall.id)?.[0];
+                  index = existingIndex ?? accumulatedToolCalls.size;
+                } else {
+                  index = Math.max(accumulatedToolCalls.size - 1, 0);
+                }
+              }
+              if (!accumulatedToolCalls.has(index)) {
+                accumulatedToolCalls.set(index, {
+                  id: toolCall.id || "",
+                  name: toolCall.function?.name || "",
+                  arguments: toolCall.function?.arguments || ""
+                });
+              } else {
+                const accumulated = accumulatedToolCalls.get(index);
+                if (toolCall.id) accumulated.id = toolCall.id;
+                if (toolCall.function?.name) accumulated.name += toolCall.function.name;
+                if (toolCall.function?.arguments) accumulated.arguments += toolCall.function.arguments;
+              }
+            }
+          }
+          try {
+            const { emitNotification, createLLMCharCount } = await import("@agentdevjs/core");
+            const phaseCharCount = currentPhase === "thinking" ? reasoning.length : content.length;
+            if (phaseCharCount > 0 || accumulatedToolCalls.size > 0) {
+              const toolNames = Array.from(accumulatedToolCalls.values()).map((tc) => tc.name).filter(Boolean);
+              emitNotification(createLLMCharCount(phaseCharCount, currentPhase, {
+                thinkingChars: reasoning.length,
+                contentChars: content.length,
+                toolCallCount: accumulatedToolCalls.size,
+                ...toolNames.length > 0 ? { streamToolNames: toolNames } : {}
+              }));
+            }
+          } catch {
+          }
+          if (chunk.choices[0]?.finish_reason) {
+            finishReason = chunk.choices[0].finish_reason;
+          }
+        }
+        let toolCalls;
+        if (accumulatedToolCalls.size > 0) {
+          toolCalls = Array.from(accumulatedToolCalls.values()).map((tc) => {
+            let parsedArgs = {};
+            const argStr = tc.arguments.trim();
+            if (argStr) {
+              try {
+                parsedArgs = JSON.parse(argStr);
+              } catch {
+                console.warn(
+                  `[OpenAI] Failed to parse tool arguments for tool "${tc.name}". Arguments length: ${argStr.length}, preview: ${argStr.slice(0, 200)}`
+                );
+              }
+            }
+            return {
+              id: tc.id,
+              name: tc.name,
+              arguments: parsedArgs
+            };
+          });
+        }
+        return {
+          content,
+          toolCalls,
+          reasoning,
+          ...usageInfo ? { usage: usageInfo } : {},
+          stopReason: finishReason
+        };
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw error;
+        }
+        const status = error?.status;
+        if (attempt <= this.maxRetries && shouldRetry2(error, status)) {
+          const retryAfterMs = parseRetryAfter2(error?.headers);
+          const delayMs = getRetryDelay2(attempt, retryAfterMs);
+          await emitRetryObservability({
+            attempt,
+            maxRetries: this.maxRetries,
+            delayMs,
+            signal,
+            error,
+            status
+          });
+          continue;
+        }
+        throw classifyAndWrapError2(error, status);
+      }
+    }
+    throw new Error("OpenAI API call failed after all retries");
+  }
+};
+function createOpenAILLM(configOrApiKey, modelName, baseUrl) {
+  if (typeof configOrApiKey === "object" && "defaultModel" in configOrApiKey) {
+    return new OpenAILLM(
+      configOrApiKey.defaultModel.apiKey,
+      configOrApiKey.defaultModel.model,
+      configOrApiKey.defaultModel.baseUrl,
+      configOrApiKey.defaultModel.maxTokens,
+      configOrApiKey.defaultModel.thinkingEffort,
+      configOrApiKey.defaultModel.providerOptions,
+      configOrApiKey.defaultModel.customHeaders,
+      configOrApiKey.defaultModel.vision ?? false,
+      { maxRetries: configOrApiKey.defaultModel.maxRetries, timeoutMs: configOrApiKey.defaultModel.timeoutMs }
+    );
+  }
+  if (typeof configOrApiKey === "object") {
+    return new OpenAILLM(
+      configOrApiKey.apiKey,
+      configOrApiKey.model,
+      configOrApiKey.baseUrl,
+      configOrApiKey.maxTokens,
+      configOrApiKey.thinkingEffort,
+      configOrApiKey.providerOptions,
+      configOrApiKey.customHeaders,
+      configOrApiKey.vision ?? false,
+      { maxRetries: configOrApiKey.maxRetries, timeoutMs: configOrApiKey.timeoutMs }
+    );
+  }
+  return new OpenAILLM(configOrApiKey, modelName, baseUrl);
+}
+
+// src/openai-responses.ts
+import OpenAI2 from "openai";
+import { OPENAI_THINKING_EFFORTS as OPENAI_THINKING_EFFORTS2 } from "@agentdevjs/core";
+import { getRetryDelay as getRetryDelay3, parseRetryAfter as parseRetryAfter3, shouldRetry as shouldRetry3, resolveModelCallPolicy as resolveModelCallPolicy3, withDeadline as withDeadline3 } from "@agentdevjs/core";
+import { classifyAndWrapError as classifyAndWrapError3 } from "@agentdevjs/core";
+var httpClientInitPromise3 = null;
+function ensureHttpClientInitialized3() {
+  if (!httpClientInitPromise3) {
+    httpClientInitPromise3 = initHttpClient();
+  }
+  return httpClientInitPromise3;
+}
+var DEFAULT_CODEX_INSTRUCTIONS = "You are a helpful assistant.";
+var OpenAIResponsesLLM = class {
+  client;
+  _modelName;
+  maxTokens;
+  thinkingEffort;
+  thinkingBudgetTokens;
+  providerOptions;
+  customHeaders;
+  visionEnabled;
+  responsesProfile;
+  initPromise;
+  maxRetries;
+  deadlineMs;
+  /** 返回当前 LLM 实例使用的模型名 */
+  get modelName() {
+    return this._modelName;
+  }
+  constructor(apiKey, modelName = "gpt-4o", baseUrl, maxTokens, thinkingEffort, thinkingBudgetTokens, providerOptions, customHeaders, visionEnabled = false, responsesProfile = "standard", callPolicy) {
+    const resolved = resolveModelCallPolicy3(callPolicy);
+    this.maxRetries = resolved.maxRetries;
+    this.deadlineMs = resolved.timeoutMs;
+    this.client = new OpenAI2({
+      apiKey,
+      baseURL: baseUrl,
+      ...customHeaders && customHeaders.length > 0 ? {
+        fetch: (input, init) => {
+          init = init || {};
+          const headers = new Headers(init.headers);
+          for (const [k, v] of Object.entries(resolveCustomHeaders(customHeaders))) {
+            headers.set(k, v);
+          }
+          headers.delete("content-length");
+          init.headers = headers;
+          return globalThis.fetch(input, init);
+        }
+      } : {}
+    });
+    this._modelName = modelName;
+    this.maxTokens = maxTokens;
+    this.thinkingEffort = thinkingEffort;
+    this.thinkingBudgetTokens = thinkingBudgetTokens;
+    this.providerOptions = providerOptions;
+    this.customHeaders = customHeaders;
+    this.visionEnabled = visionEnabled;
+    this.responsesProfile = responsesProfile;
+    this.initPromise = ensureHttpClientInitialized3();
+  }
+  async chat(messages, tools, options) {
+    await this.initPromise;
+    const compiled = compileContextForOpenAIResponses(messages, tools, {
+      modelName: this._modelName,
+      maxTokens: this.maxTokens,
+      thinkingEffort: this.thinkingEffort,
+      thinkingBudgetTokens: this.thinkingBudgetTokens,
+      providerOptions: this.providerOptions,
+      visionEnabled: this.visionEnabled,
+      responsesProfile: this.responsesProfile
+    });
+    let preferNonStreaming = false;
+    const signal = withDeadline3(options?.signal, this.deadlineMs);
+    for (let attempt = 1; attempt <= this.maxRetries + 1; attempt++) {
+      let sawAnyStreamEvent = false;
+      try {
+        if (signal?.aborted) {
+          throw new DOMException("Aborted", "AbortError");
+        }
+        if (preferNonStreaming) {
+          return await this.createResponsesCompletion(compiled, options);
+        }
+        const stream = this.client.responses.stream(
+          {
+            ...compiled,
+            stream: true
+          },
+          { signal }
+        );
+        let content = "";
+        let reasoning = "";
+        let currentPhase = "content";
+        let stopReason = null;
+        let usageInfo = null;
+        let completedSnapshot = null;
+        let completedText = "";
+        const functionCalls = /* @__PURE__ */ new Map();
+        const reasoningItems = /* @__PURE__ */ new Map();
+        for await (const event of stream) {
+          sawAnyStreamEvent = true;
+          if (signal?.aborted) {
+            throw new DOMException("Aborted", "AbortError");
+          }
+          switch (event.type) {
+            case "response.output_text.delta": {
+              const delta = String(event.delta || "");
+              if (delta) {
+                currentPhase = "content";
+                content += delta;
+              }
+              break;
+            }
+            case "response.output_text.done": {
+              completedText = String(event.text || completedText || "");
+              break;
+            }
+            case "response.function_call_arguments.delta": {
+              const key = String(event.item_id || event.output_index);
+              currentPhase = "tool_calling";
+              if (!functionCalls.has(key)) {
+                functionCalls.set(key, {
+                  call_id: "",
+                  name: "",
+                  arguments: ""
+                });
+              }
+              functionCalls.get(key).arguments += String(event.delta || "");
+              break;
+            }
+            case "response.function_call_arguments.done": {
+              const key = String(event.item_id || event.output_index);
+              if (!functionCalls.has(key)) {
+                functionCalls.set(key, {
+                  call_id: "",
+                  name: "",
+                  arguments: ""
+                });
+              }
+              functionCalls.get(key).arguments = String(event.arguments || functionCalls.get(key).arguments || "");
+              break;
+            }
+            case "response.output_item.added":
+            case "response.output_item.done": {
+              const item = event.item || {};
+              if (item.type === "function_call") {
+                const key = String(item.id || event.output_index);
+                currentPhase = "tool_calling";
+                functionCalls.set(key, {
+                  call_id: String(item.call_id || ""),
+                  name: String(item.name || ""),
+                  arguments: String(item.arguments || "")
+                });
+              } else if (item.type === "reasoning") {
+                recordReasoningItem(reasoningItems, item);
+              } else if (item.type === "message" && event.type === "response.output_item.done") {
+                completedText = extractOutputMessageText(item) || completedText;
+              }
+              break;
+            }
+            case "response.reasoning_summary.delta":
+            case "response.reasoning_summary_text.delta": {
+              const key = String(event.item_id || event.output_index);
+              if (!reasoningItems.has(key)) {
+                reasoningItems.set(key, { id: String(event.item_id || ""), summary: [] });
+              }
+              const delta = extractTextDelta(event.delta);
+              if (delta) {
+                const entry = reasoningItems.get(key);
+                if (entry.summary.length === 0) {
+                  entry.summary.push(delta);
+                } else {
+                  entry.summary[entry.summary.length - 1] += delta;
+                }
+                currentPhase = "thinking";
+                reasoning += delta;
+              }
+              break;
+            }
+            case "response.reasoning_summary.done": {
+              const key = String(event.item_id || event.output_index);
+              const text = String(event.text || "");
+              if (!reasoningItems.has(key)) {
+                reasoningItems.set(key, { id: String(event.item_id || ""), summary: [] });
+              }
+              const entry = reasoningItems.get(key);
+              if (text) {
+                entry.summary = [text];
+                currentPhase = "thinking";
+                reasoning += text;
+              }
+              break;
+            }
+            case "response.reasoning_summary_text.done": {
+              const key = String(event.item_id || event.output_index);
+              const text = String(event.text || "");
+              if (!reasoningItems.has(key)) {
+                reasoningItems.set(key, { id: String(event.item_id || ""), summary: [] });
+              }
+              const entry = reasoningItems.get(key);
+              if (text) {
+                entry.summary = [text];
+                currentPhase = "thinking";
+                reasoning += text;
+              }
+              break;
+            }
+            case "response.completed": {
+              completedSnapshot = event.response;
+              stopReason = mapResponseStatusToStopReason(completedSnapshot);
+              break;
+            }
+            case "response.failed": {
+              completedSnapshot = event.response;
+              stopReason = "failed";
+              break;
+            }
+            case "response.incomplete": {
+              completedSnapshot = event.response;
+              stopReason = mapResponseStatusToStopReason(completedSnapshot);
+              break;
+            }
+            default:
+              break;
+          }
+          try {
+            const { emitNotification, createLLMCharCount } = await import("@agentdevjs/core");
+            const phaseCharCount = currentPhase === "thinking" ? reasoning.length : content.length;
+            if (phaseCharCount > 0 || functionCalls.size > 0) {
+              const toolNames = Array.from(functionCalls.values()).map((fc) => fc.name).filter(Boolean);
+              emitNotification(createLLMCharCount(phaseCharCount, currentPhase, {
+                thinkingChars: reasoning.length,
+                contentChars: content.length,
+                toolCallCount: functionCalls.size,
+                ...toolNames.length > 0 ? { streamToolNames: toolNames } : {}
+              }));
+            }
+          } catch {
+          }
+        }
+        const parsedSnapshot = completedSnapshot ? parseOpenAIResponsesSnapshot(completedSnapshot) : null;
+        if (parsedSnapshot?.usage) {
+          usageInfo = parsedSnapshot.usage;
+        }
+        const parsedToolCalls = parsedSnapshot?.toolCalls?.length ? parsedSnapshot.toolCalls : finalizeToolCalls2(functionCalls);
+        const parsedThinkingBlocks = parsedSnapshot?.thinkingBlocks?.length ? parsedSnapshot.thinkingBlocks : finalizeThinkingBlocks2(reasoningItems);
+        const finalContent = parsedSnapshot?.content || content || completedText;
+        const finalReasoning = parsedSnapshot?.reasoning || reasoning;
+        const finalStopReason = parsedSnapshot?.stopReason ?? stopReason;
+        return {
+          content: finalContent,
+          ...parsedToolCalls.length > 0 ? { toolCalls: parsedToolCalls } : {},
+          ...finalReasoning ? { reasoning: finalReasoning } : {},
+          ...parsedThinkingBlocks.length > 0 ? { thinkingBlocks: parsedThinkingBlocks } : {},
+          ...usageInfo ? { usage: usageInfo } : {},
+          stopReason: finalStopReason
+        };
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw error;
+        }
+        if (isEmptyResponsesStreamError(error) && !sawAnyStreamEvent) {
+          preferNonStreaming = true;
+          try {
+            return await this.createResponsesCompletion(compiled, options);
+          } catch (fallbackError) {
+            if (fallbackError instanceof DOMException && fallbackError.name === "AbortError") {
+              throw fallbackError;
+            }
+            if (fallbackError instanceof Error && fallbackError.name === "AbortError") {
+              throw fallbackError;
+            }
+            const fallbackStatus = fallbackError?.status;
+            if (attempt <= this.maxRetries && shouldRetry3(fallbackError, fallbackStatus)) {
+              const retryAfterMs = parseRetryAfter3(fallbackError?.headers);
+              const delayMs = getRetryDelay3(attempt, retryAfterMs);
+              await emitRetryObservability({
+                attempt,
+                maxRetries: this.maxRetries,
+                delayMs,
+                signal,
+                error: fallbackError,
+                status: fallbackStatus
+              });
+              continue;
+            }
+            throw classifyAndWrapError3(fallbackError, fallbackStatus);
+          }
+        }
+        const status = error?.status;
+        if (attempt <= this.maxRetries && shouldRetry3(error, status)) {
+          const retryAfterMs = parseRetryAfter3(error?.headers);
+          const delayMs = getRetryDelay3(attempt, retryAfterMs);
+          await emitRetryObservability({
+            attempt,
+            maxRetries: this.maxRetries,
+            delayMs,
+            signal,
+            error,
+            status
+          });
+          continue;
+        }
+        throw classifyAndWrapError3(error, status);
+      }
+    }
+    throw new Error("OpenAI Responses API call failed after all retries");
+  }
+  async createResponsesCompletion(compiled, options) {
+    const response = await this.client.responses.create(compiled, { signal: options?.signal });
+    const parsedSnapshot = parseOpenAIResponsesSnapshot(response);
+    return {
+      content: parsedSnapshot.content,
+      ...parsedSnapshot.toolCalls.length > 0 ? { toolCalls: parsedSnapshot.toolCalls } : {},
+      ...parsedSnapshot.reasoning ? { reasoning: parsedSnapshot.reasoning } : {},
+      ...parsedSnapshot.thinkingBlocks.length > 0 ? { thinkingBlocks: parsedSnapshot.thinkingBlocks } : {},
+      ...parsedSnapshot.usage ? { usage: parsedSnapshot.usage } : {},
+      stopReason: parsedSnapshot.stopReason
+    };
+  }
+};
+function compileContextForOpenAIResponses(messages, tools, options = {}) {
+  const input = [];
+  const responsesProfile = options.responsesProfile ?? "standard";
+  const codexInstructionParts = [];
+  let reachedConversation = false;
+  for (const message of messages) {
+    if (!message) continue;
+    if (message.role === "system") {
+      if (responsesProfile === "codex" && !reachedConversation && !message.source) {
+        const instruction = String(message.content ?? "").trim();
+        if (instruction) codexInstructionParts.push(instruction);
+        continue;
+      }
+      input.push({
+        type: "message",
+        // ChatGPT's Codex endpoint only accepts the stable, leading system
+        // identity through `instructions`. Runtime reminders can be injected
+        // after the conversation starts without a `source` marker, so every
+        // remaining system message must be replayed as user input.
+        role: responsesProfile === "codex" ? "user" : "system",
+        content: [
+          {
+            type: "input_text",
+            text: String(message.content ?? "")
+          }
+        ]
+      });
+      if (responsesProfile === "codex") reachedConversation = true;
+      continue;
+    }
+    reachedConversation = true;
+    if (message.role === "user") {
+      const visionEnabled = options.visionEnabled ?? false;
+      let textContent = String(message.content ?? "");
+      if (message.images && message.images.length > 0) {
+        if (visionEnabled) {
+          const contentParts = [
+            { type: "input_text", text: textContent }
+          ];
+          for (const img of message.images) {
+            const url = resolveImageDataUri(img) || img.source;
+            if (url) {
+              contentParts.push({ type: "input_image", image_url: url, detail: "auto" });
+            }
+          }
+          input.push({ type: "message", role: "user", content: contentParts });
+          continue;
+        }
+        const placeholders = message.images.map((img) => `\u3010Image\u3011${img.source || "(inline image)"}`).join("\n");
+        textContent = `${textContent}
+${placeholders}`;
+      }
+      input.push({
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: textContent }]
+      });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const assistantItems = compileAssistantMessageToResponsesItems(message, responsesProfile);
+      input.push(...assistantItems);
+      continue;
+    }
+    if (message.role === "tool") {
+      if (!message.toolCallId) {
+        throw new Error("OpenAI Responses compilation requires tool messages to include toolCallId");
+      }
+      input.push({
+        type: "function_call_output",
+        call_id: message.toolCallId,
+        output: String(message.content ?? "")
+      });
+      if (message.images && message.images.length > 0) {
+        const visionEnabled = options.visionEnabled ?? false;
+        if (visionEnabled) {
+          const contentParts = [
+            { type: "input_text", text: `[Tool image result for ${message.toolCallId}]` }
+          ];
+          for (const img of message.images) {
+            const url = resolveImageDataUri(img) || img.source;
+            if (url) {
+              contentParts.push({ type: "input_image", image_url: url, detail: "auto" });
+            }
+          }
+          input.push({ type: "message", role: "user", content: contentParts });
+        } else {
+          const placeholders = message.images.map((img) => `\u3010Image\u3011${img.source || "(inline image)"}`).join("\n");
+          input.push({
+            type: "message",
+            role: "user",
+            content: [{ type: "input_text", text: `[Tool image placeholders]
+${placeholders}` }]
+          });
+        }
+      }
+      continue;
+    }
+    input.push({
+      type: "message",
+      role: "user",
+      content: [
+        {
+          type: "input_text",
+          text: String(message.content ?? "")
+        }
+      ]
+    });
+  }
+  const compiledTools = tools.length > 0 ? tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: normalizeToolParameters(tool.parameters),
+    strict: false
+  })) : void 0;
+  const request = {
+    model: options.modelName || "gpt-4o",
+    input,
+    ...compiledTools ? { tools: compiledTools } : {},
+    ...responsesProfile !== "codex" && typeof options.maxTokens === "number" && Number.isFinite(options.maxTokens) && options.maxTokens > 0 ? { max_output_tokens: options.maxTokens } : {},
+    ...tools.length > 0 ? {
+      parallel_tool_calls: true,
+      ...responsesProfile === "codex" ? { tool_choice: "auto" } : {}
+    } : {},
+    ...options.thinkingEffort && OPENAI_THINKING_EFFORTS2.includes(options.thinkingEffort) ? {
+      reasoning: {
+        effort: options.thinkingEffort,
+        summary: "auto"
+      }
+    } : typeof options.thinkingBudgetTokens === "number" && options.thinkingBudgetTokens > 0 ? {
+      reasoning: {
+        effort: mapThinkingBudgetToEffort(options.thinkingBudgetTokens),
+        summary: "auto"
+      }
+    } : {},
+    ...options.providerOptions ?? {}
+  };
+  if (responsesProfile === "codex") {
+    request.model = options.modelName || "gpt-4o";
+    request.instructions = codexInstructionParts.join("\n\n").trim() || DEFAULT_CODEX_INSTRUCTIONS;
+    request.input = input;
+    request.store = false;
+  }
+  return request;
+}
+function compileAssistantMessageToResponsesItems(message, responsesProfile) {
+  const items = [];
+  const reasoningParts = [];
+  if (typeof message.reasoning === "string" && message.reasoning.trim()) {
+    reasoningParts.push(message.reasoning.trim());
+  }
+  if (Array.isArray(message.thinkingBlocks)) {
+    for (const block of message.thinkingBlocks) {
+      if (block?.thinking?.trim()) {
+        reasoningParts.push(block.thinking.trim());
+      }
+    }
+  }
+  if (reasoningParts.length > 0 && responsesProfile !== "codex") {
+    items.push({
+      type: "reasoning",
+      id: `reasoning-${items.length}`,
+      summary: reasoningParts.map((text) => ({
+        type: "summary_text",
+        text
+      })),
+      status: "completed"
+    });
+  }
+  if (typeof message.content === "string" && message.content.trim()) {
+    items.push({
+      type: "message",
+      role: "assistant",
+      content: [
+        {
+          type: "output_text",
+          text: message.content,
+          ...responsesProfile === "standard" ? { annotations: [] } : {}
+        }
+      ]
+    });
+  }
+  if (Array.isArray(message.toolCalls)) {
+    for (const toolCall of message.toolCalls) {
+      items.push({
+        type: "function_call",
+        call_id: toolCall.id,
+        name: toolCall.name,
+        arguments: JSON.stringify(toolCall.arguments ?? {})
+      });
+    }
+  }
+  if (items.length === 0 && responsesProfile === "standard") {
+    items.push({
+      type: "message",
+      role: "assistant",
+      content: []
+    });
+  }
+  return items;
+}
+function parseOpenAIResponsesSnapshot(snapshot) {
+  const output = Array.isArray(snapshot?.output) ? snapshot.output : [];
+  const contentParts = [];
+  const reasoningParts = [];
+  const toolCalls = [];
+  const thinkingBlocks = [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") continue;
+    if (item.type === "message" && Array.isArray(item.content)) {
+      for (const part of item.content) {
+        if (part?.type === "output_text" && typeof part.text === "string") {
+          contentParts.push(part.text);
+        }
+      }
+      continue;
+    }
+    if (item.type === "function_call") {
+      toolCalls.push({
+        id: String(item.call_id || item.id || ""),
+        name: String(item.name || ""),
+        arguments: parseToolArguments(String(item.arguments || ""), item.name)
+      });
+      continue;
+    }
+    if (item.type === "reasoning") {
+      const summaryText = Array.isArray(item.summary) ? item.summary.map((part) => String(part?.text || "")).filter(Boolean).join("\n").trim() : "";
+      if (summaryText) {
+        reasoningParts.push(summaryText);
+        thinkingBlocks.push({
+          signature: String(item.id || ""),
+          thinking: summaryText
+        });
+      }
+    }
+  }
+  const usage = snapshot.usage ? {
+    inputTokens: Number(snapshot.usage.input_tokens || 0),
+    outputTokens: Number(snapshot.usage.output_tokens || 0),
+    totalTokens: Number(snapshot.usage.total_tokens || 0),
+    ...Number(snapshot.usage.input_tokens_details?.cached_tokens || 0) > 0 ? { cacheReadTokens: Number(snapshot.usage.input_tokens_details?.cached_tokens || 0) } : {},
+    ...Number(snapshot.usage.output_tokens_details?.reasoning_tokens || 0) > 0 ? { reasoningTokens: Number(snapshot.usage.output_tokens_details?.reasoning_tokens || 0) } : {}
+  } : void 0;
+  const content = typeof snapshot.output_text === "string" && snapshot.output_text.trim() ? snapshot.output_text : contentParts.join("");
+  return {
+    content,
+    toolCalls,
+    ...reasoningParts.length > 0 ? { reasoning: reasoningParts.join("\n") } : {},
+    thinkingBlocks,
+    ...usage ? { usage } : {},
+    stopReason: mapResponseStatusToStopReason(snapshot)
+  };
+}
+function finalizeToolCalls2(functionCalls) {
+  return Array.from(functionCalls.values()).map((call) => ({
+    id: call.call_id || call.name || `tool-${Math.random().toString(36).slice(2, 8)}`,
+    name: call.name,
+    arguments: parseToolArguments(call.arguments, call.name)
+  })).filter((call) => Boolean(call.name));
+}
+function finalizeThinkingBlocks2(reasoningItems) {
+  return Array.from(reasoningItems.values()).map((item) => ({
+    signature: item.id,
+    thinking: item.summary.join("\n").trim()
+  })).filter((block) => Boolean(block.signature) && Boolean(block.thinking));
+}
+function recordReasoningItem(reasoningItems, item) {
+  const id = String(item?.id || "");
+  if (!id) return;
+  const summary = Array.isArray(item.summary) ? item.summary.map((part) => String(part?.text || "")).filter(Boolean) : [];
+  if (!reasoningItems.has(id)) {
+    reasoningItems.set(id, { id, summary: [] });
+  }
+  const entry = reasoningItems.get(id);
+  if (summary.length > 0) {
+    entry.summary = summary;
+  }
+}
+function extractTextDelta(delta) {
+  if (typeof delta === "string") return delta;
+  if (delta && typeof delta === "object" && "text" in delta && typeof delta.text === "string") {
+    return delta.text;
+  }
+  return "";
+}
+function extractOutputMessageText(item) {
+  if (!Array.isArray(item?.content)) return "";
+  return item.content.filter((part) => part?.type === "output_text" && typeof part.text === "string").map((part) => part.text).join("");
+}
+function mapThinkingBudgetToEffort(thinkingBudgetTokens) {
+  if (thinkingBudgetTokens >= 1e5) return "high";
+  if (thinkingBudgetTokens >= 1e4) return "medium";
+  return "low";
+}
+function normalizeToolParameters(parameters) {
+  if (!parameters || typeof parameters !== "object") {
+    return { type: "object", properties: {} };
+  }
+  return sanitizeToolSchema(parameters);
+}
+function parseToolArguments(raw, toolName) {
+  const trimmed = String(raw || "").trim();
+  if (!trimmed) return {};
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  console.warn(
+    `[OpenAI Responses] Failed to parse tool arguments${toolName ? ` for tool "${toolName}"` : ""}. Input length: ${trimmed.length}, preview: ${trimmed.slice(0, 200)}`
+  );
+  return {};
+}
+function isEmptyResponsesStreamError(error) {
+  return error instanceof Error && /request ended without sending any events/i.test(error.message);
+}
+function mapResponseStatusToStopReason(snapshot) {
+  if (!snapshot) return null;
+  if (snapshot.status === "incomplete") {
+    const reason = snapshot.incomplete_details?.reason || "incomplete";
+    return reason === "max_output_tokens" ? "max_tokens" : reason;
+  }
+  if (snapshot.status === "failed" || snapshot.status === "cancelled") {
+    return snapshot.status;
+  }
+  if (snapshot.status === "completed") {
+    if (Array.isArray(snapshot.output) && snapshot.output.some((item) => item?.type === "function_call")) {
+      return "tool_calls";
+    }
+    return "stop";
+  }
+  return snapshot.status || null;
+}
+function createOpenAIResponsesLLM(configOrApiKey, modelName, baseUrl) {
+  if (typeof configOrApiKey === "object" && "defaultModel" in configOrApiKey) {
+    return new OpenAIResponsesLLM(
+      configOrApiKey.defaultModel.apiKey,
+      configOrApiKey.defaultModel.model,
+      configOrApiKey.defaultModel.baseUrl,
+      configOrApiKey.defaultModel.maxTokens,
+      configOrApiKey.defaultModel.thinkingEffort,
+      configOrApiKey.defaultModel.thinkingBudgetTokens,
+      configOrApiKey.defaultModel.providerOptions,
+      configOrApiKey.defaultModel.customHeaders,
+      configOrApiKey.defaultModel.vision ?? false,
+      configOrApiKey.defaultModel.responsesProfile ?? "standard",
+      { maxRetries: configOrApiKey.defaultModel.maxRetries, timeoutMs: configOrApiKey.defaultModel.timeoutMs }
+    );
+  }
+  if (typeof configOrApiKey === "object") {
+    return new OpenAIResponsesLLM(
+      configOrApiKey.apiKey,
+      configOrApiKey.model,
+      configOrApiKey.baseUrl,
+      configOrApiKey.maxTokens,
+      configOrApiKey.thinkingEffort,
+      configOrApiKey.thinkingBudgetTokens,
+      configOrApiKey.providerOptions,
+      configOrApiKey.customHeaders,
+      configOrApiKey.vision ?? false,
+      configOrApiKey.responsesProfile ?? "standard",
+      { maxRetries: configOrApiKey.maxRetries, timeoutMs: configOrApiKey.timeoutMs }
+    );
+  }
+  return new OpenAIResponsesLLM(configOrApiKey, modelName, baseUrl);
+}
+
+// src/index.ts
+import { DEFAULT_MAX_RETRIES as DEFAULT_MAX_RETRIES3, getRetryDelay as getRetryDelay4, parseRetryAfter as parseRetryAfter4, shouldRetry as shouldRetry4, sleep } from "@agentdevjs/core";
+import { ClassifiedAPIError as ClassifiedAPIError4, classifyAPIError as classifyAPIError3, classifyAndWrapError as classifyAndWrapError4, extractConnectionErrorDetails, getUserFriendlyMessage } from "@agentdevjs/core";
+function createLLM(configOrApiKey, modelName, provider, baseUrl) {
+  if (typeof configOrApiKey === "string") {
+    return provider === "anthropic" ? createAnthropicLLM(configOrApiKey, modelName, baseUrl) : createOpenAILLM(configOrApiKey, modelName, baseUrl);
+  }
+  if ("defaultModel" in configOrApiKey) {
+    switch (configOrApiKey.defaultModel.provider) {
+      case "anthropic":
+        return createAnthropicLLM(configOrApiKey);
+      case "openai":
+        return configOrApiKey.defaultModel.apiSurface === "responses" ? createOpenAIResponsesLLM(configOrApiKey) : createOpenAILLM(configOrApiKey);
+      default:
+        return createOpenAILLM(configOrApiKey);
+    }
+  }
+  switch (configOrApiKey.provider) {
+    case "anthropic":
+      return createAnthropicLLM(configOrApiKey);
+    case "openai":
+      return configOrApiKey.apiSurface === "responses" ? createOpenAIResponsesLLM(configOrApiKey) : createOpenAILLM(configOrApiKey);
+    default:
+      return createOpenAILLM(configOrApiKey);
+  }
+}
+export {
+  AnthropicLLM,
+  ClassifiedAPIError4 as ClassifiedAPIError,
+  DEFAULT_MAX_RETRIES3 as DEFAULT_MAX_RETRIES,
+  OpenAILLM,
+  OpenAIResponsesLLM,
+  classifyAPIError3 as classifyAPIError,
+  classifyAndWrapError4 as classifyAndWrapError,
+  compileChatMessages,
+  compileContextForAnthropic,
+  compileContextForOpenAIResponses,
+  createAnthropicLLM,
+  createLLM,
+  createOpenAILLM,
+  createOpenAIResponsesLLM,
+  extractConnectionErrorDetails,
+  getGlobalDispatcher,
+  getRetryDelay4 as getRetryDelay,
+  getUserFriendlyMessage,
+  initHttpClient,
+  parseRetryAfter4 as parseRetryAfter,
+  sleep as retrySleep,
+  shouldRetry4 as shouldRetry
+};
+//# sourceMappingURL=index.js.map