gong-code 0.1.0

package/dist/chunk-j7qv3hvm.js

@@ -0,0 +1,1635 @@
+// @bun
+import {
+  __esm,
+  __export,
+  __require,
+  __toCommonJS,
+  __toESM
+} from "./chunk-eta5aekm.js";
+import {
+  getActiveProvider,
+  init_registry,
+  providerRegistry,
+  registerProviderFactory,
+  setActiveProvider
+} from "./chunk-d3hb1qdr.js";
+import {
+  __INVALID__REF__
+} from "./chunk-ccyg9ap9.js";
+
+// src/services/api/providers/types.ts
+var exports_types = {};
+__export(exports_types, {
+  ProviderError: () => ProviderError
+});
+var ProviderError;
+var init_types = __esm(() => {
+  ProviderError = class ProviderError extends Error {
+    type;
+    statusCode;
+    providerName;
+    cause;
+    constructor(message, type, statusCode, providerName, cause) {
+      super(message);
+      this.type = type;
+      this.statusCode = statusCode;
+      this.providerName = providerName;
+      this.cause = cause;
+      this.name = "ProviderError";
+    }
+  };
+});
+
+// src/services/api/providers/BaseAdapter.ts
+class BaseAdapter {
+  apiKey;
+  baseUrl;
+  model;
+  timeout;
+  maxRetries;
+  constructor(config = {}) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl;
+    this.model = config.model;
+    this.timeout = config.timeout ?? 600000;
+    this.maxRetries = config.maxRetries ?? 2;
+  }
+  extractTextContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    return content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+  }
+  extractToolUses(content) {
+    return content.filter((c) => c.type === "tool_use");
+  }
+  extractToolResults(content) {
+    return content.filter((c) => c.type === "tool_result");
+  }
+  systemPromptToString(systemPrompt) {
+    if (!systemPrompt)
+      return "";
+    if (typeof systemPrompt === "string")
+      return systemPrompt;
+    return systemPrompt.join(`
+`);
+  }
+  toolsToOpenAIFormat(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  messagesToOpenAIFormat(messages, systemPrompt) {
+    const result = [];
+    const sysPrompt = this.systemPromptToString(systemPrompt);
+    if (sysPrompt) {
+      result.push({ role: "system", content: sysPrompt });
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        result.push({
+          role: "system",
+          content: this.extractTextContent(msg.content)
+        });
+      } else if (msg.role === "user") {
+        if (typeof msg.content !== "string") {
+          const toolResults = this.extractToolResults(msg.content);
+          if (toolResults.length > 0) {
+            for (const toolResult of toolResults) {
+              result.push({
+                role: "tool",
+                tool_call_id: toolResult.toolUseId,
+                content: typeof toolResult.content === "string" ? toolResult.content : this.extractTextContent(toolResult.content)
+              });
+            }
+            continue;
+          }
+        }
+        result.push({
+          role: "user",
+          content: this.extractTextContent(msg.content)
+        });
+      } else if (msg.role === "assistant") {
+        const toolUses = typeof msg.content === "string" ? [] : this.extractToolUses(msg.content);
+        const text = this.extractTextContent(msg.content);
+        if (toolUses.length > 0) {
+          result.push({
+            role: "assistant",
+            content: text || undefined,
+            tool_calls: toolUses.map((tu) => ({
+              id: tu.id,
+              type: "function",
+              function: {
+                name: tu.name,
+                arguments: JSON.stringify(tu.input)
+              }
+            }))
+          });
+        } else {
+          result.push({
+            role: "assistant",
+            content: text
+          });
+        }
+      }
+    }
+    return result;
+  }
+  contentFromOpenAIResponse(response) {
+    const choice = response.choices[0];
+    if (!choice) {
+      return {
+        content: [],
+        stopReason: "end_turn",
+        usage: { inputTokens: 0, outputTokens: 0 }
+      };
+    }
+    const content = [];
+    const message = choice.message;
+    if (message.content) {
+      content.push({ type: "text", text: message.content });
+    }
+    if (message.tool_calls) {
+      for (const toolCall of message.tool_calls) {
+        if (toolCall.type === "function") {
+          content.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments || "{}")
+          });
+        }
+      }
+    }
+    let stopReason = "end_turn";
+    switch (choice.finish_reason) {
+      case "stop":
+        stopReason = "end_turn";
+        break;
+      case "length":
+        stopReason = "max_tokens";
+        break;
+      case "tool_calls":
+      case "function_call":
+        stopReason = "tool_use";
+        break;
+    }
+    return {
+      content,
+      stopReason,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        outputTokens: response.usage?.completion_tokens ?? 0
+      }
+    };
+  }
+  wrapError(error, defaultMessage) {
+    const { ProviderError: ProviderError2 } = (init_types(), __toCommonJS(exports_types));
+    if (error instanceof ProviderError2) {
+      return error;
+    }
+    if (error instanceof Error) {
+      const statusCode = error.status;
+      let errorType = "unknown_error";
+      if (statusCode === 401 || statusCode === 403) {
+        errorType = "authentication_error";
+      } else if (statusCode === 429) {
+        errorType = "rate_limit_error";
+      } else if (statusCode === 400) {
+        errorType = "invalid_request_error";
+      } else if (statusCode && statusCode >= 500) {
+        errorType = "api_error";
+      } else if (error.message.includes("ECONNREFUSED") || error.message.includes("ENOTFOUND")) {
+        errorType = "connection_error";
+      } else if (error.message.includes("timeout") || error.message.includes("ETIMEDOUT")) {
+        errorType = "timeout_error";
+      }
+      return new ProviderError2(error.message || defaultMessage, errorType, statusCode, this.name, error);
+    }
+    return new ProviderError2(defaultMessage, "unknown_error", undefined, this.name);
+  }
+  async validateApiKey(apiKey) {
+    return true;
+  }
+  async listModels() {
+    return [];
+  }
+}
+
+// src/services/api/providers/AnthropicAdapter.ts
+var exports_AnthropicAdapter = {};
+__export(exports_AnthropicAdapter, {
+  AnthropicAdapter: () => AnthropicAdapter
+});
+var AnthropicAdapter;
+var init_AnthropicAdapter = __esm(() => {
+  AnthropicAdapter = class AnthropicAdapter extends BaseAdapter {
+    name = "anthropic";
+    displayName = "Anthropic Claude";
+    capabilities = {
+      streaming: true,
+      toolUse: true,
+      vision: true,
+      thinking: true,
+      systemPrompt: true,
+      maxContextLength: 200000,
+      maxOutputTokens: 128000
+    };
+    client = null;
+    constructor(config = {}) {
+      super(config);
+      this.model = config.model ?? "claude-sonnet-4-20250514";
+    }
+    async getClient() {
+      if (this.client) {
+        return this.client;
+      }
+      const { default: AnthropicSDK } = await import("./chunk-0sbddf6m.js");
+      this.client = new AnthropicSDK({
+        apiKey: this.apiKey || process.env.ANTHROPIC_API_KEY,
+        baseURL: this.baseUrl || process.env.ANTHROPIC_BASE_URL,
+        timeout: this.timeout,
+        maxRetries: this.maxRetries
+      });
+      return this.client;
+    }
+    toAnthropicMessages(messages) {
+      return messages.filter((msg) => msg.role !== "system").map((msg) => ({
+        role: msg.role,
+        content: this.toAnthropicContent(msg.content)
+      }));
+    }
+    toAnthropicContent(content) {
+      if (typeof content === "string") {
+        return content;
+      }
+      return content.map((c) => {
+        switch (c.type) {
+          case "text":
+            return { type: "text", text: c.text };
+          case "image":
+            return {
+              type: "image",
+              source: {
+                type: c.source.type,
+                media_type: c.source.mediaType || "image/png",
+                data: c.source.data || ""
+              }
+            };
+          case "tool_use":
+            return {
+              type: "tool_use",
+              id: c.id,
+              name: c.name,
+              input: c.input
+            };
+          case "tool_result":
+            return {
+              type: "tool_result",
+              tool_use_id: c.toolUseId,
+              content: typeof c.content === "string" ? c.content : this.toAnthropicContent(c.content),
+              is_error: c.isError
+            };
+          case "thinking":
+            return {
+              type: "thinking",
+              thinking: c.thinking
+            };
+          default:
+            return { type: "text", text: "" };
+        }
+      });
+    }
+    toAnthropicTools(tools) {
+      return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchema
+      }));
+    }
+    fromAnthropicContent(content) {
+      return content.map((c) => {
+        switch (c.type) {
+          case "text":
+            return { type: "text", text: c.text };
+          case "tool_use":
+            return {
+              type: "tool_use",
+              id: c.id,
+              name: c.name,
+              input: c.input
+            };
+          case "thinking":
+            return {
+              type: "thinking",
+              thinking: c.thinking
+            };
+          default:
+            return { type: "text", text: "" };
+        }
+      });
+    }
+    async* chat(params) {
+      const client = await this.getClient();
+      const model = params.model || this.model || "claude-sonnet-4-20250514";
+      try {
+        const response = await client.messages.stream({
+          model,
+          max_tokens: params.maxTokens || 8192,
+          messages: this.toAnthropicMessages(params.messages),
+          system: this.systemPromptToString(params.systemPrompt),
+          tools: params.tools ? this.toAnthropicTools(params.tools) : undefined,
+          temperature: params.temperature,
+          top_p: params.topP,
+          stop_sequences: params.stopSequences
+        });
+        for await (const event of response) {
+          yield this.convertStreamEvent(event);
+        }
+      } catch (error) {
+        throw this.wrapError(error, "Anthropic API request failed");
+      }
+    }
+    convertStreamEvent(event) {
+      const e = event;
+      switch (e.type) {
+        case "message_start":
+          return {
+            type: "message_start",
+            message: e.message
+          };
+        case "content_block_start":
+          return {
+            type: "content_block_start",
+            index: e.index,
+            contentBlock: e.content_block
+          };
+        case "content_block_delta":
+          return {
+            type: "content_block_delta",
+            index: e.index,
+            delta: e.delta
+          };
+        case "content_block_stop":
+          return {
+            type: "content_block_stop",
+            index: e.index
+          };
+        case "message_delta":
+          return {
+            type: "message_delta",
+            usage: e.usage
+          };
+        case "message_stop":
+          return { type: "message_stop" };
+        default:
+          return { type: "message_stop" };
+      }
+    }
+    async chatSync(params) {
+      const client = await this.getClient();
+      const model = params.model || this.model || "claude-sonnet-4-20250514";
+      try {
+        const response = await client.messages.create({
+          model,
+          max_tokens: params.maxTokens || 8192,
+          messages: this.toAnthropicMessages(params.messages),
+          system: this.systemPromptToString(params.systemPrompt),
+          tools: params.tools ? this.toAnthropicTools(params.tools) : undefined,
+          temperature: params.temperature,
+          top_p: params.topP,
+          stop_sequences: params.stopSequences
+        });
+        return {
+          id: response.id,
+          model: response.model,
+          role: "assistant",
+          content: this.fromAnthropicContent(response.content),
+          stopReason: this.convertStopReason(response.stop_reason),
+          usage: {
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens
+          }
+        };
+      } catch (error) {
+        throw this.wrapError(error, "Anthropic API request failed");
+      }
+    }
+    convertStopReason(reason) {
+      switch (reason) {
+        case "end_turn":
+          return "end_turn";
+        case "max_tokens":
+          return "max_tokens";
+        case "stop_sequence":
+          return "stop_sequence";
+        case "tool_use":
+          return "tool_use";
+        default:
+          return null;
+      }
+    }
+    async validateApiKey(apiKey) {
+      try {
+        const { default: AnthropicSDK } = await import("./chunk-0sbddf6m.js");
+        const tempClient = new AnthropicSDK({
+          apiKey,
+          baseURL: this.baseUrl,
+          timeout: 1e4,
+          maxRetries: 0
+        });
+        await tempClient.messages.create({
+          model: "claude-3-haiku-20240307",
+          max_tokens: 1,
+          messages: [{ role: "user", content: "test" }]
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    async listModels() {
+      return [
+        "claude-sonnet-4-20250514",
+        "claude-opus-4-20250514",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307"
+      ];
+    }
+  };
+});
+
+// src/services/api/providers/OpenAICompatAdapter.ts
+var exports_OpenAICompatAdapter = {};
+__export(exports_OpenAICompatAdapter, {
+  OpenAICompatAdapter: () => OpenAICompatAdapter
+});
+var OpenAICompatAdapter;
+var init_OpenAICompatAdapter = __esm(() => {
+  init_types();
+  OpenAICompatAdapter = class OpenAICompatAdapter extends BaseAdapter {
+    name = "openai-compat";
+    displayName = "OpenAI Compatible";
+    capabilities = {
+      streaming: true,
+      toolUse: true,
+      vision: true,
+      thinking: false,
+      systemPrompt: true,
+      maxContextLength: 128000,
+      maxOutputTokens: 16384
+    };
+    constructor(config = {}) {
+      super(config);
+      this.baseUrl = config.baseUrl || process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+      this.apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+      this.model = config.model || process.env.OPENAI_MODEL || "gpt-4o";
+    }
+    getHeaders() {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.apiKey) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      return headers;
+    }
+    async* chat(params) {
+      const model = params.model || this.model || "gpt-4o";
+      const url = `${this.baseUrl}/chat/completions`;
+      const body = {
+        model,
+        messages: this.messagesToOpenAIFormat(params.messages, params.systemPrompt),
+        max_tokens: params.maxTokens || 4096,
+        temperature: params.temperature,
+        top_p: params.topP,
+        stop: params.stopSequences,
+        stream: true,
+        ...params.tools && params.tools.length > 0 && {
+          tools: this.toolsToOpenAIFormat(params.tools),
+          tool_choice: "auto"
+        }
+      };
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(body),
+          signal: params.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ProviderError(`OpenAI API error: ${errorText}`, response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status === 400 ? "invalid_request_error" : "api_error", response.status, this.name);
+        }
+        if (!response.body) {
+          throw new ProviderError("No response body", "api_error", undefined, this.name);
+        }
+        yield {
+          type: "message_start",
+          message: { id: "", model, role: "assistant", content: [], stopReason: null, usage: { inputTokens: 0, outputTokens: 0 } }
+        };
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let contentIndex = 0;
+        let currentContent = "";
+        const toolCalls = new Map;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") {
+                if (currentContent) {
+                  yield { type: "content_block_stop", index: contentIndex };
+                }
+                for (const [idx, tc] of toolCalls) {
+                  yield {
+                    type: "content_block_start",
+                    index: idx + 1,
+                    contentBlock: {
+                      type: "tool_use",
+                      id: tc.id,
+                      name: tc.name,
+                      input: JSON.parse(tc.arguments || "{}")
+                    }
+                  };
+                  yield { type: "content_block_stop", index: idx + 1 };
+                }
+                yield { type: "message_stop" };
+                return;
+              }
+              try {
+                const chunk = JSON.parse(data);
+                const choice = chunk.choices[0];
+                if (!choice)
+                  continue;
+                const delta = choice.delta;
+                if (delta.content) {
+                  if (!currentContent) {
+                    yield {
+                      type: "content_block_start",
+                      index: contentIndex,
+                      contentBlock: { type: "text", text: "" }
+                    };
+                  }
+                  currentContent += delta.content;
+                  yield {
+                    type: "content_block_delta",
+                    index: contentIndex,
+                    delta: { type: "text_delta", text: delta.content }
+                  };
+                }
+                if (delta.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const existing = toolCalls.get(tc.index) || { id: "", name: "", arguments: "" };
+                    if (tc.id)
+                      existing.id = tc.id;
+                    if (tc.function?.name)
+                      existing.name = tc.function.name;
+                    if (tc.function?.arguments)
+                      existing.arguments += tc.function.arguments;
+                    toolCalls.set(tc.index, existing);
+                  }
+                }
+                if (choice.finish_reason) {
+                  yield {
+                    type: "message_delta",
+                    usage: { inputTokens: 0, outputTokens: 0 }
+                  };
+                }
+              } catch {}
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof ProviderError) {
+          throw error;
+        }
+        throw this.wrapError(error, "OpenAI compatible API request failed");
+      }
+    }
+    async chatSync(params) {
+      const model = params.model || this.model || "gpt-4o";
+      const url = `${this.baseUrl}/chat/completions`;
+      const body = {
+        model,
+        messages: this.messagesToOpenAIFormat(params.messages, params.systemPrompt),
+        max_tokens: params.maxTokens || 4096,
+        temperature: params.temperature,
+        top_p: params.topP,
+        stop: params.stopSequences,
+        stream: false,
+        ...params.tools && params.tools.length > 0 && {
+          tools: this.toolsToOpenAIFormat(params.tools),
+          tool_choice: "auto"
+        }
+      };
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(body),
+          signal: params.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ProviderError(`OpenAI API error: ${errorText}`, response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status === 400 ? "invalid_request_error" : "api_error", response.status, this.name);
+        }
+        const data = await response.json();
+        const { content, stopReason, usage } = this.contentFromOpenAIResponse(data);
+        return {
+          id: data.id,
+          model: data.model,
+          role: "assistant",
+          content,
+          stopReason,
+          usage
+        };
+      } catch (error) {
+        if (error instanceof ProviderError) {
+          throw error;
+        }
+        throw this.wrapError(error, "OpenAI compatible API request failed");
+      }
+    }
+    async validateApiKey(apiKey) {
+      try {
+        const url = `${this.baseUrl}/models`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${apiKey}`
+          }
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+    async listModels() {
+      try {
+        const url = `${this.baseUrl}/models`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: this.getHeaders()
+        });
+        if (!response.ok) {
+          return [];
+        }
+        const data = await response.json();
+        return data.data.map((m) => m.id);
+      } catch {
+        return [];
+      }
+    }
+  };
+});
+
+// src/services/api/providers/MiniMaxAdapter.ts
+var exports_MiniMaxAdapter = {};
+__export(exports_MiniMaxAdapter, {
+  MiniMaxAdapter: () => MiniMaxAdapter
+});
+var MiniMaxAdapter;
+var init_MiniMaxAdapter = __esm(() => {
+  init_types();
+  MiniMaxAdapter = class MiniMaxAdapter extends BaseAdapter {
+    name = "minimax";
+    displayName = "MiniMax";
+    capabilities = {
+      streaming: true,
+      toolUse: true,
+      vision: true,
+      thinking: true,
+      systemPrompt: true,
+      maxContextLength: 1e6,
+      maxOutputTokens: 16384
+    };
+    groupId;
+    constructor(config = {}) {
+      super(config);
+      this.baseUrl = config.baseUrl || process.env.MINIMAX_BASE_URL || "https://api.minimaxi.com/v1";
+      this.apiKey = config.apiKey || process.env.MINIMAX_API_KEY;
+      this.model = config.model || process.env.MINIMAX_MODEL || "MiniMax-M2.7";
+      this.groupId = config.groupId || process.env.MINIMAX_GROUP_ID;
+    }
+    getHeaders() {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.apiKey) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      return headers;
+    }
+    toMiniMaxMessages(messages, systemPrompt) {
+      const result = [];
+      const sysPrompt = this.systemPromptToString(systemPrompt);
+      if (sysPrompt) {
+        result.push({ role: "system", content: sysPrompt });
+      }
+      for (const msg of messages) {
+        if (msg.role === "system") {
+          result.push({
+            role: "system",
+            content: this.extractTextContent(msg.content)
+          });
+        } else if (msg.role === "user") {
+          if (typeof msg.content !== "string") {
+            const toolResults = this.extractToolResults(msg.content);
+            if (toolResults.length > 0) {
+              for (const toolResult of toolResults) {
+                result.push({
+                  role: "tool",
+                  tool_call_id: toolResult.toolUseId,
+                  content: typeof toolResult.content === "string" ? toolResult.content : this.extractTextContent(toolResult.content)
+                });
+              }
+              continue;
+            }
+          }
+          result.push({
+            role: "user",
+            content: this.extractTextContent(msg.content)
+          });
+        } else if (msg.role === "assistant") {
+          const toolUses = typeof msg.content === "string" ? [] : this.extractToolUses(msg.content);
+          const text = this.extractTextContent(msg.content);
+          if (toolUses.length > 0) {
+            result.push({
+              role: "assistant",
+              content: text || undefined,
+              tool_calls: toolUses.map((tu) => ({
+                id: tu.id,
+                type: "function",
+                function: {
+                  name: tu.name,
+                  arguments: JSON.stringify(tu.input)
+                }
+              }))
+            });
+          } else {
+            result.push({
+              role: "assistant",
+              content: text
+            });
+          }
+        }
+      }
+      return result;
+    }
+    toMiniMaxTools(tools) {
+      return tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      }));
+    }
+    async* chat(params) {
+      const model = params.model || this.model || "MiniMax-M2.7";
+      const url = `${this.baseUrl}/chat/completions`;
+      const body = {
+        model,
+        messages: this.toMiniMaxMessages(params.messages, params.systemPrompt),
+        max_tokens: params.maxTokens || 4096,
+        temperature: params.temperature ?? 0.7,
+        top_p: params.topP ?? 0.9,
+        stream: true
+      };
+      if (params.tools && params.tools.length > 0) {
+        body.tools = this.toMiniMaxTools(params.tools);
+        body.tool_choice = "auto";
+      }
+      if (params.thinking?.type === "enabled" && model.includes("M2")) {
+        body.thinking = {
+          type: "enabled",
+          budget_tokens: params.thinking.budgetTokens || 1e4
+        };
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(body),
+          signal: params.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ProviderError(`MiniMax API error: ${errorText}`, response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status === 400 ? "invalid_request_error" : "api_error", response.status, this.name);
+        }
+        if (!response.body) {
+          throw new ProviderError("No response body", "api_error", undefined, this.name);
+        }
+        yield {
+          type: "message_start",
+          message: {
+            id: "",
+            model,
+            role: "assistant",
+            content: [],
+            stopReason: null,
+            usage: { inputTokens: 0, outputTokens: 0 }
+          }
+        };
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let contentIndex = 0;
+        let currentContent = "";
+        const toolCalls = new Map;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") {
+                if (currentContent) {
+                  yield { type: "content_block_stop", index: contentIndex };
+                }
+                for (const [idx, tc] of toolCalls) {
+                  yield {
+                    type: "content_block_start",
+                    index: idx + 1,
+                    contentBlock: {
+                      type: "tool_use",
+                      id: tc.id,
+                      name: tc.name,
+                      input: JSON.parse(tc.arguments || "{}")
+                    }
+                  };
+                  yield { type: "content_block_stop", index: idx + 1 };
+                }
+                yield { type: "message_stop" };
+                return;
+              }
+              try {
+                const chunk = JSON.parse(data);
+                const choice = chunk.choices[0];
+                if (!choice)
+                  continue;
+                const delta = choice.delta;
+                if (delta.content) {
+                  if (!currentContent) {
+                    yield {
+                      type: "content_block_start",
+                      index: contentIndex,
+                      contentBlock: { type: "text", text: "" }
+                    };
+                  }
+                  currentContent += delta.content;
+                  yield {
+                    type: "content_block_delta",
+                    index: contentIndex,
+                    delta: { type: "text_delta", text: delta.content }
+                  };
+                }
+                if (delta.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const existing = toolCalls.get(tc.index) || { id: "", name: "", arguments: "" };
+                    if (tc.id)
+                      existing.id = tc.id;
+                    if (tc.function?.name)
+                      existing.name = tc.function.name;
+                    if (tc.function?.arguments)
+                      existing.arguments += tc.function.arguments;
+                    toolCalls.set(tc.index, existing);
+                  }
+                }
+                if (chunk.usage) {
+                  yield {
+                    type: "message_delta",
+                    usage: {
+                      inputTokens: chunk.usage.prompt_tokens,
+                      outputTokens: chunk.usage.completion_tokens
+                    }
+                  };
+                }
+              } catch {}
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof ProviderError) {
+          throw error;
+        }
+        throw this.wrapError(error, "MiniMax API request failed");
+      }
+    }
+    async chatSync(params) {
+      const model = params.model || this.model || "MiniMax-M2.7";
+      const url = `${this.baseUrl}/chat/completions`;
+      const body = {
+        model,
+        messages: this.toMiniMaxMessages(params.messages, params.systemPrompt),
+        max_tokens: params.maxTokens || 4096,
+        temperature: params.temperature ?? 0.7,
+        top_p: params.topP ?? 0.9,
+        stream: false
+      };
+      if (params.tools && params.tools.length > 0) {
+        body.tools = this.toMiniMaxTools(params.tools);
+        body.tool_choice = "auto";
+      }
+      if (params.thinking?.type === "enabled" && model.includes("M2")) {
+        body.thinking = {
+          type: "enabled",
+          budget_tokens: params.thinking.budgetTokens || 1e4
+        };
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(body),
+          signal: params.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ProviderError(`MiniMax API error: ${errorText}`, response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status === 400 ? "invalid_request_error" : "api_error", response.status, this.name);
+        }
+        const data = await response.json();
+        if (data.base_resp && data.base_resp.status_code !== 0) {
+          throw new ProviderError(`MiniMax API error: ${data.base_resp.status_msg}`, "api_error", data.base_resp.status_code, this.name);
+        }
+        const choice = data.choices[0];
+        if (!choice) {
+          return {
+            id: data.id,
+            model: data.model,
+            role: "assistant",
+            content: [],
+            stopReason: "end_turn",
+            usage: {
+              inputTokens: data.usage?.prompt_tokens || 0,
+              outputTokens: data.usage?.completion_tokens || 0
+            }
+          };
+        }
+        const content = [];
+        const message = choice.message;
+        if (message.content) {
+          content.push({ type: "text", text: message.content });
+        }
+        if (message.tool_calls) {
+          for (const toolCall of message.tool_calls) {
+            content.push({
+              type: "tool_use",
+              id: toolCall.id,
+              name: toolCall.function.name,
+              input: JSON.parse(toolCall.function.arguments || "{}")
+            });
+          }
+        }
+        let stopReason = "end_turn";
+        switch (choice.finish_reason) {
+          case "stop":
+            stopReason = "end_turn";
+            break;
+          case "length":
+            stopReason = "max_tokens";
+            break;
+          case "tool_calls":
+            stopReason = "tool_use";
+            break;
+        }
+        return {
+          id: data.id,
+          model: data.model,
+          role: "assistant",
+          content,
+          stopReason,
+          usage: {
+            inputTokens: data.usage?.prompt_tokens || 0,
+            outputTokens: data.usage?.completion_tokens || 0
+          }
+        };
+      } catch (error) {
+        if (error instanceof ProviderError) {
+          throw error;
+        }
+        throw this.wrapError(error, "MiniMax API request failed");
+      }
+    }
+    async validateApiKey(apiKey) {
+      try {
+        const url = `${this.baseUrl}/models`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${apiKey}`
+          }
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+    async listModels() {
+      return [
+        "MiniMax-M1",
+        "MiniMax-M2",
+        "MiniMax-M2.7",
+        "abab6.5s-chat",
+        "abab6.5g-chat",
+        "abab6.5t-chat",
+        "abab5.5s-chat",
+        "abab5.5-chat"
+      ];
+    }
+  };
+});
+
+// src/services/api/providers/GLMAdapter.ts
+var exports_GLMAdapter = {};
+__export(exports_GLMAdapter, {
+  GLMAdapter: () => GLMAdapter
+});
+var GLMAdapter;
+var init_GLMAdapter = __esm(() => {
+  init_types();
+  GLMAdapter = class GLMAdapter extends BaseAdapter {
+    name = "glm";
+    displayName = "\u667A\u8C31 GLM";
+    capabilities = {
+      streaming: true,
+      toolUse: true,
+      vision: true,
+      thinking: false,
+      systemPrompt: true,
+      maxContextLength: 128000,
+      maxOutputTokens: 4096
+    };
+    constructor(config = {}) {
+      super(config);
+      this.baseUrl = config.baseUrl || process.env.GLM_BASE_URL || "https://open.bigmodel.cn/api/paas/v4";
+      this.apiKey = config.apiKey || process.env.GLM_API_KEY || process.env.ZHIPU_API_KEY;
+      this.model = config.model || process.env.GLM_MODEL || "glm-4-plus";
+    }
+    getHeaders() {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.apiKey) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      return headers;
+    }
+    toGLMMessages(messages, systemPrompt) {
+      const result = [];
+      const sysPrompt = this.systemPromptToString(systemPrompt);
+      if (sysPrompt) {
+        result.push({ role: "system", content: sysPrompt });
+      }
+      for (const msg of messages) {
+        if (msg.role === "system") {
+          result.push({
+            role: "system",
+            content: this.extractTextContent(msg.content)
+          });
+        } else if (msg.role === "user") {
+          if (typeof msg.content !== "string") {
+            const toolResults = this.extractToolResults(msg.content);
+            if (toolResults.length > 0) {
+              for (const toolResult of toolResults) {
+                result.push({
+                  role: "tool",
+                  tool_call_id: toolResult.toolUseId,
+                  content: typeof toolResult.content === "string" ? toolResult.content : this.extractTextContent(toolResult.content)
+                });
+              }
+              continue;
+            }
+            const hasImage = msg.content.some((c) => c.type === "image");
+            if (hasImage) {
+              const contentArray = [];
+              for (const c of msg.content) {
+                if (c.type === "text") {
+                  contentArray.push({ type: "text", text: c.text });
+                } else if (c.type === "image") {
+                  const imageUrl = c.source.url || (c.source.data ? `data:${c.source.mediaType || "image/png"};base64,${c.source.data}` : "");
+                  contentArray.push({ type: "image_url", image_url: { url: imageUrl } });
+                }
+              }
+              result.push({ role: "user", content: contentArray });
+              continue;
+            }
+          }
+          result.push({
+            role: "user",
+            content: this.extractTextContent(msg.content)
+          });
+        } else if (msg.role === "assistant") {
+          const toolUses = typeof msg.content === "string" ? [] : this.extractToolUses(msg.content);
+          const text = this.extractTextContent(msg.content);
+          if (toolUses.length > 0) {
+            result.push({
+              role: "assistant",
+              content: text || undefined,
+              tool_calls: toolUses.map((tu) => ({
+                id: tu.id,
+                type: "function",
+                function: {
+                  name: tu.name,
+                  arguments: JSON.stringify(tu.input)
+                }
+              }))
+            });
+          } else {
+            result.push({
+              role: "assistant",
+              content: text
+            });
+          }
+        }
+      }
+      return result;
+    }
+    toGLMTools(tools) {
+      return tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      }));
+    }
+    async* chat(params) {
+      const model = params.model || this.model || "glm-4-plus";
+      const url = `${this.baseUrl}/chat/completions`;
+      const body = {
+        model,
+        messages: this.toGLMMessages(params.messages, params.systemPrompt),
+        max_tokens: params.maxTokens || 4096,
+        temperature: params.temperature ?? 0.7,
+        top_p: params.topP ?? 0.9,
+        stream: true
+      };
+      if (params.tools && params.tools.length > 0) {
+        body.tools = this.toGLMTools(params.tools);
+        body.tool_choice = "auto";
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(body),
+          signal: params.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ProviderError(`GLM API error: ${errorText}`, response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status === 400 ? "invalid_request_error" : "api_error", response.status, this.name);
+        }
+        if (!response.body) {
+          throw new ProviderError("No response body", "api_error", undefined, this.name);
+        }
+        yield {
+          type: "message_start",
+          message: {
+            id: "",
+            model,
+            role: "assistant",
+            content: [],
+            stopReason: null,
+            usage: { inputTokens: 0, outputTokens: 0 }
+          }
+        };
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder;
+        let buffer = "";
+        let contentIndex = 0;
+        let currentContent = "";
+        const toolCalls = new Map;
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") {
+                if (currentContent) {
+                  yield { type: "content_block_stop", index: contentIndex };
+                }
+                for (const [idx, tc] of toolCalls) {
+                  yield {
+                    type: "content_block_start",
+                    index: idx + 1,
+                    contentBlock: {
+                      type: "tool_use",
+                      id: tc.id,
+                      name: tc.name,
+                      input: JSON.parse(tc.arguments || "{}")
+                    }
+                  };
+                  yield { type: "content_block_stop", index: idx + 1 };
+                }
+                yield { type: "message_stop" };
+                return;
+              }
+              try {
+                const chunk = JSON.parse(data);
+                const choice = chunk.choices[0];
+                if (!choice)
+                  continue;
+                const delta = choice.delta;
+                if (delta.content && typeof delta.content === "string") {
+                  if (!currentContent) {
+                    yield {
+                      type: "content_block_start",
+                      index: contentIndex,
+                      contentBlock: { type: "text", text: "" }
+                    };
+                  }
+                  currentContent += delta.content;
+                  yield {
+                    type: "content_block_delta",
+                    index: contentIndex,
+                    delta: { type: "text_delta", text: delta.content }
+                  };
+                }
+                if (delta.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const existing = toolCalls.get(tc.index) || { id: "", name: "", arguments: "" };
+                    if (tc.id)
+                      existing.id = tc.id;
+                    if (tc.function?.name)
+                      existing.name = tc.function.name;
+                    if (tc.function?.arguments)
+                      existing.arguments += tc.function.arguments;
+                    toolCalls.set(tc.index, existing);
+                  }
+                }
+                if (chunk.usage) {
+                  yield {
+                    type: "message_delta",
+                    usage: {
+                      inputTokens: chunk.usage.prompt_tokens,
+                      outputTokens: chunk.usage.completion_tokens
+                    }
+                  };
+                }
+              } catch {}
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof ProviderError) {
+          throw error;
+        }
+        throw this.wrapError(error, "GLM API request failed");
+      }
+    }
+    async chatSync(params) {
+      const model = params.model || this.model || "glm-4-plus";
+      const url = `${this.baseUrl}/chat/completions`;
+      const body = {
+        model,
+        messages: this.toGLMMessages(params.messages, params.systemPrompt),
+        max_tokens: params.maxTokens || 4096,
+        temperature: params.temperature ?? 0.7,
+        top_p: params.topP ?? 0.9,
+        stream: false
+      };
+      if (params.tools && params.tools.length > 0) {
+        body.tools = this.toGLMTools(params.tools);
+        body.tool_choice = "auto";
+      }
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body: JSON.stringify(body),
+          signal: params.signal
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new ProviderError(`GLM API error: ${errorText}`, response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status === 400 ? "invalid_request_error" : "api_error", response.status, this.name);
+        }
+        const data = await response.json();
+        const choice = data.choices[0];
+        if (!choice) {
+          return {
+            id: data.id,
+            model: data.model,
+            role: "assistant",
+            content: [],
+            stopReason: "end_turn",
+            usage: {
+              inputTokens: data.usage?.prompt_tokens || 0,
+              outputTokens: data.usage?.completion_tokens || 0
+            }
+          };
+        }
+        const content = [];
+        const message = choice.message;
+        if (message.content) {
+          if (typeof message.content === "string") {
+            content.push({ type: "text", text: message.content });
+          }
+        }
+        if (message.tool_calls) {
+          for (const toolCall of message.tool_calls) {
+            content.push({
+              type: "tool_use",
+              id: toolCall.id,
+              name: toolCall.function.name,
+              input: JSON.parse(toolCall.function.arguments || "{}")
+            });
+          }
+        }
+        let stopReason = "end_turn";
+        switch (choice.finish_reason) {
+          case "stop":
+            stopReason = "end_turn";
+            break;
+          case "length":
+            stopReason = "max_tokens";
+            break;
+          case "tool_calls":
+            stopReason = "tool_use";
+            break;
+        }
+        return {
+          id: data.id,
+          model: data.model,
+          role: "assistant",
+          content,
+          stopReason,
+          usage: {
+            inputTokens: data.usage?.prompt_tokens || 0,
+            outputTokens: data.usage?.completion_tokens || 0
+          }
+        };
+      } catch (error) {
+        if (error instanceof ProviderError) {
+          throw error;
+        }
+        throw this.wrapError(error, "GLM API request failed");
+      }
+    }
+    async validateApiKey(apiKey) {
+      try {
+        const url = `${this.baseUrl}/chat/completions`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model: "glm-4-flash",
+            messages: [{ role: "user", content: "hi" }],
+            max_tokens: 1
+          })
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+    async listModels() {
+      return [
+        "glm-5",
+        "glm-5-plus",
+        "glm-4",
+        "glm-4-plus",
+        "glm-4-air",
+        "glm-4-airx",
+        "glm-4-flash",
+        "glm-4-long",
+        "glm-4v",
+        "glm-4v-plus",
+        "codegeex-4",
+        "embedding-2",
+        "embedding-3"
+      ];
+    }
+  };
+});
+
+// src/services/api/providers/config.ts
+function ensureModelProviderEnv() {
+  if (!process.env.MODEL_PROVIDER) {
+    process.env.MODEL_PROVIDER = DEFAULT_PROVIDER;
+  }
+}
+function getProviderConfigFromEnv() {
+  const providerType = process.env.MODEL_PROVIDER?.toLowerCase() || DEFAULT_PROVIDER;
+  switch (providerType) {
+    case "openai":
+    case "openai-compat":
+    case "openai_compat":
+      return {
+        provider: "openai-compat",
+        apiKey: process.env.OPENAI_API_KEY,
+        baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
+        model: process.env.OPENAI_MODEL || "gpt-4o",
+        timeout: parseInt(process.env.API_TIMEOUT_MS || "600000", 10),
+        maxRetries: parseInt(process.env.API_MAX_RETRIES || "2", 10)
+      };
+    case "minimax":
+      return {
+        provider: "minimax",
+        apiKey: process.env.MINIMAX_API_KEY,
+        baseUrl: process.env.MINIMAX_BASE_URL || "https://api.minimaxi.com/v1",
+        model: process.env.MINIMAX_MODEL || DEFAULT_MINIMAX_MODEL,
+        groupId: process.env.MINIMAX_GROUP_ID,
+        timeout: parseInt(process.env.API_TIMEOUT_MS || "600000", 10),
+        maxRetries: parseInt(process.env.API_MAX_RETRIES || "2", 10)
+      };
+    case "glm":
+    case "zhipu":
+      return {
+        provider: "glm",
+        apiKey: process.env.GLM_API_KEY || process.env.ZHIPU_API_KEY,
+        baseUrl: process.env.GLM_BASE_URL || "https://open.bigmodel.cn/api/paas/v4",
+        model: process.env.GLM_MODEL || "glm-4-plus",
+        timeout: parseInt(process.env.API_TIMEOUT_MS || "600000", 10),
+        maxRetries: parseInt(process.env.API_MAX_RETRIES || "2", 10)
+      };
+    case "anthropic":
+    default:
+      return {
+        provider: "anthropic",
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        baseUrl: process.env.ANTHROPIC_BASE_URL,
+        model: process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514",
+        timeout: parseInt(process.env.API_TIMEOUT_MS || "600000", 10),
+        maxRetries: parseInt(process.env.API_MAX_RETRIES || "2", 10)
+      };
+  }
+}
+function parseProviderConfig(config) {
+  const providerType = config.modelProvider?.toLowerCase() || "anthropic";
+  switch (providerType) {
+    case "openai":
+    case "openai-compat":
+    case "openai_compat": {
+      const openaiConfig = config.openaiCompat || config.openai || {};
+      return {
+        provider: "openai-compat",
+        apiKey: openaiConfig.apiKey,
+        baseUrl: openaiConfig.baseUrl || "https://api.openai.com/v1",
+        model: openaiConfig.model || "gpt-4o",
+        timeout: openaiConfig.timeout,
+        maxRetries: openaiConfig.maxRetries
+      };
+    }
+    case "minimax": {
+      const minimaxConfig = config.minimax || {};
+      return {
+        provider: "minimax",
+        apiKey: minimaxConfig.apiKey,
+        baseUrl: minimaxConfig.baseUrl || "https://api.minimaxi.com/v1",
+        model: minimaxConfig.model || "MiniMax-M1",
+        groupId: minimaxConfig.groupId,
+        timeout: minimaxConfig.timeout,
+        maxRetries: minimaxConfig.maxRetries
+      };
+    }
+    case "glm":
+    case "zhipu": {
+      const glmConfig = config.glm || config.zhipu || {};
+      return {
+        provider: "glm",
+        apiKey: glmConfig.apiKey,
+        baseUrl: glmConfig.baseUrl || "https://open.bigmodel.cn/api/paas/v4",
+        model: glmConfig.model || "glm-4-plus",
+        timeout: glmConfig.timeout,
+        maxRetries: glmConfig.maxRetries
+      };
+    }
+    case "anthropic":
+    default: {
+      const anthropicConfig = config.anthropic || {};
+      return {
+        provider: "anthropic",
+        apiKey: anthropicConfig.apiKey,
+        baseUrl: anthropicConfig.baseUrl,
+        model: anthropicConfig.model || "claude-sonnet-4-20250514",
+        timeout: anthropicConfig.timeout,
+        maxRetries: anthropicConfig.maxRetries
+      };
+    }
+  }
+}
+async function initializeBuiltinAdapters() {
+  if (adaptersInitialized) {
+    return;
+  }
+  registerProviderFactory("anthropic", (config) => {
+    const { AnthropicAdapter: AnthropicAdapter2 } = (init_AnthropicAdapter(), __toCommonJS(exports_AnthropicAdapter));
+    return new AnthropicAdapter2({
+      apiKey: config?.apiKey,
+      baseUrl: config?.baseUrl,
+      model: config?.model,
+      timeout: config?.timeout,
+      maxRetries: config?.maxRetries
+    });
+  });
+  registerProviderFactory("openai-compat", (config) => {
+    const { OpenAICompatAdapter: OpenAICompatAdapter2 } = (init_OpenAICompatAdapter(), __toCommonJS(exports_OpenAICompatAdapter));
+    return new OpenAICompatAdapter2({
+      apiKey: config?.apiKey,
+      baseUrl: config?.baseUrl,
+      model: config?.model,
+      timeout: config?.timeout,
+      maxRetries: config?.maxRetries
+    });
+  });
+  registerProviderFactory("minimax", (config) => {
+    const { MiniMaxAdapter: MiniMaxAdapter2 } = (init_MiniMaxAdapter(), __toCommonJS(exports_MiniMaxAdapter));
+    const minimaxConfig = config;
+    return new MiniMaxAdapter2({
+      apiKey: config?.apiKey,
+      baseUrl: config?.baseUrl,
+      model: config?.model,
+      groupId: minimaxConfig?.groupId,
+      timeout: config?.timeout,
+      maxRetries: config?.maxRetries
+    });
+  });
+  registerProviderFactory("glm", (config) => {
+    const { GLMAdapter: GLMAdapter2 } = (init_GLMAdapter(), __toCommonJS(exports_GLMAdapter));
+    return new GLMAdapter2({
+      apiKey: config?.apiKey,
+      baseUrl: config?.baseUrl,
+      model: config?.model,
+      timeout: config?.timeout,
+      maxRetries: config?.maxRetries
+    });
+  });
+  adaptersInitialized = true;
+}
+async function initializeProviderFromEnv() {
+  await initializeBuiltinAdapters();
+  const config = getProviderConfigFromEnv();
+  providerRegistry.get(config.provider, config);
+  setActiveProvider(config.provider);
+}
+async function initializeProviderFromConfig(config) {
+  await initializeBuiltinAdapters();
+  const providerConfig = parseProviderConfig(config);
+  providerRegistry.get(providerConfig.provider, providerConfig);
+  setActiveProvider(providerConfig.provider);
+}
+function getCurrentProviderName() {
+  return providerRegistry.getActiveProviderName();
+}
+function isUsingAnthropic() {
+  return getCurrentProviderName() === "anthropic";
+}
+function isUsingThirdPartyProvider() {
+  return !isUsingAnthropic();
+}
+var adaptersInitialized = false, DEFAULT_PROVIDER = "minimax", DEFAULT_MINIMAX_MODEL = "MiniMax-M2.7";
+var init_config = __esm(() => {
+  init_registry();
+  ensureModelProviderEnv();
+});
+init_config();
+
+export {
+  parseProviderConfig,
+  isUsingThirdPartyProvider,
+  isUsingAnthropic,
+  initializeProviderFromEnv,
+  initializeProviderFromConfig,
+  initializeBuiltinAdapters,
+  getProviderConfigFromEnv,
+  getCurrentProviderName,
+  getActiveProvider,
+  ensureModelProviderEnv
+};
+
+export { initializeProviderFromEnv, getCurrentProviderName, init_config };