@weisiren000/oiiai 0.1.4 → 0.2.0

package/dist/index.js

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,23 +20,2238 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/providers/__types__.ts
+var EFFORT_TOKEN_MAP;
+var init_types = __esm({
+  "src/providers/__types__.ts"() {
+    "use strict";
+    EFFORT_TOKEN_MAP = {
+      off: 0,
+      low: 1024,
+      medium: 4096,
+      high: 16384
+    };
+  }
+});
+
+// src/utils/request-builder.ts
+var RequestBuilder;
+var init_request_builder = __esm({
+  "src/utils/request-builder.ts"() {
+    "use strict";
+    init_types();
+    RequestBuilder = class {
+      /**
+       * 构建聊天请求的基础参数
+       * 生成标准化的 OpenAI 兼容格式请求体
+       *
+       * @param options - 聊天选项
+       * @param stream - 是否为流式请求
+       * @returns 请求体对象
+       *
+       * @example
+       * ```ts
+       * const body = RequestBuilder.buildChatBody({
+       *   model: 'gpt-4',
+       *   messages: [{ role: 'user', content: 'Hello' }],
+       *   temperature: 0.7
+       * });
+       * ```
+       */
+      static buildChatBody(options, stream = false) {
+        const { model, messages, temperature = 0.7, maxTokens } = options;
+        const body = {
+          model,
+          messages,
+          temperature,
+          stream
+        };
+        if (maxTokens !== void 0) {
+          body.max_tokens = maxTokens;
+        }
+        return body;
+      }
+      /**
+       * 构建 OpenRouter 格式的 reasoning 参数
+       *
+       * @param config - 推理配置
+       * @returns OpenRouter 格式的 reasoning 参数，或 undefined
+       *
+       * @example
+       * ```ts
+       * const reasoning = RequestBuilder.buildOpenRouterReasoning({ effort: 'high' });
+       * // => { effort: 'high', max_tokens: 16384 }
+       * ```
+       */
+      static buildOpenRouterReasoning(config) {
+        if (!config) return void 0;
+        if (config.effort === "off") return void 0;
+        const param = {};
+        if (config.effort) {
+          param.effort = config.effort;
+        }
+        if (config.budgetTokens !== void 0) {
+          param.max_tokens = config.budgetTokens;
+        } else if (config.effort && EFFORT_TOKEN_MAP[config.effort]) {
+          param.max_tokens = EFFORT_TOKEN_MAP[config.effort];
+        }
+        if (config.exclude !== void 0) {
+          param.exclude = config.exclude;
+        }
+        return Object.keys(param).length > 0 ? param : void 0;
+      }
+      /**
+       * 构建 Gemini 格式的 reasoning 参数
+       * Gemini 2.5+ 模型使用 reasoning_effort 控制思考
+       *
+       * @param config - 推理配置
+       * @returns Gemini 格式的参数对象
+       *
+       * @example
+       * ```ts
+       * const params = RequestBuilder.buildGeminiReasoning({ effort: 'high' });
+       * // => { reasoning_effort: 'high' }
+       * ```
+       */
+      static buildGeminiReasoning(config) {
+        if (!config || !config.effort || config.effort === "off") {
+          return {};
+        }
+        return {
+          reasoning_effort: config.effort
+        };
+      }
+      /**
+       * 构建 Groq 格式的 reasoning 参数
+       * Groq 使用 reasoning_format 参数控制推理输出
+       *
+       * @param config - 推理配置
+       * @returns Groq 格式的参数对象
+       *
+       * @example
+       * ```ts
+       * const params = RequestBuilder.buildGroqReasoning({ effort: 'high' });
+       * // => { reasoning_format: 'parsed' }
+       * ```
+       */
+      static buildGroqReasoning(config) {
+        if (!config) {
+          return {};
+        }
+        if (config.effort === "off") {
+          return { include_reasoning: false };
+        }
+        if (config.effort) {
+          return { reasoning_format: "parsed" };
+        }
+        return {};
+      }
+      /**
+       * 构建 DeepSeek 格式的 reasoning 参数
+       * DeepSeek 使用 thinking 参数启用思考模式
+       *
+       * @param config - 推理配置
+       * @returns DeepSeek 格式的参数对象
+       */
+      static buildDeepSeekReasoning(config) {
+        if (!config || !config.effort || config.effort === "off") {
+          return {};
+        }
+        return {
+          thinking: { type: "enabled" }
+        };
+      }
+      /**
+       * 构建 Nova 格式的 reasoning 参数
+       * Nova 使用 reasoningConfig 控制 extended thinking
+       *
+       * @param config - 推理配置
+       * @returns Nova 格式的参数对象
+       */
+      static buildNovaReasoning(config) {
+        if (!config || !config.effort || config.effort === "off") {
+          return {};
+        }
+        return {
+          reasoningConfig: {
+            type: "enabled",
+            maxReasoningEffort: config.effort
+          }
+        };
+      }
+      /**
+       * 构建 HTTP 请求头
+       *
+       * @param apiKey - API 密钥
+       * @param additionalHeaders - 额外的请求头
+       * @returns 请求头对象
+       *
+       * @example
+       * ```ts
+       * const headers = RequestBuilder.buildHeaders('sk-xxx', {
+       *   'X-Custom-Header': 'value'
+       * });
+       * ```
+       */
+      static buildHeaders(apiKey, additionalHeaders) {
+        return {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+          ...additionalHeaders
+        };
+      }
+    };
+  }
+});
+
+// src/client/types.ts
+var ProviderError, APIError, NetworkError, TimeoutError;
+var init_types2 = __esm({
+  "src/client/types.ts"() {
+    "use strict";
+    ProviderError = class extends Error {
+      constructor(message, code, provider, cause) {
+        super(message);
+        this.code = code;
+        this.provider = provider;
+        this.cause = cause;
+        this.name = "ProviderError";
+      }
+    };
+    APIError = class extends ProviderError {
+      constructor(message, provider, statusCode, responseBody) {
+        super(message, "API_ERROR", provider);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "APIError";
+      }
+    };
+    NetworkError = class extends ProviderError {
+      constructor(message, provider, cause) {
+        super(message, "NETWORK_ERROR", provider, cause);
+        this.name = "NetworkError";
+      }
+    };
+    TimeoutError = class extends ProviderError {
+      constructor(message, provider, timeoutMs) {
+        super(message, "TIMEOUT_ERROR", provider);
+        this.timeoutMs = timeoutMs;
+        this.name = "TimeoutError";
+      }
+    };
+  }
+});
+
+// src/client/http-provider-client.ts
+var http_provider_client_exports = {};
+__export(http_provider_client_exports, {
+  HttpProviderClient: () => HttpProviderClient
+});
+var DEFAULT_TIMEOUT, HttpProviderClient;
+var init_http_provider_client = __esm({
+  "src/client/http-provider-client.ts"() {
+    "use strict";
+    init_request_builder();
+    init_types2();
+    DEFAULT_TIMEOUT = 3e4;
+    HttpProviderClient = class {
+      config;
+      /**
+       * 创建 HTTP Provider 客户端实例
+       *
+       * @param config - 客户端配置
+       *
+       * @example
+       * ```ts
+       * const client = new HttpProviderClient({
+       *   apiKey: 'sk-xxx',
+       *   baseUrl: 'https://api.openai.com/v1',
+       *   timeout: 60000
+       * });
+       * ```
+       */
+      constructor(config) {
+        this.config = {
+          ...config,
+          timeout: config.timeout ?? DEFAULT_TIMEOUT
+        };
+      }
+      /**
+       * 获取 Provider 名称（从 baseUrl 推断）
+       */
+      getProviderName() {
+        try {
+          const url = new URL(this.config.baseUrl);
+          return url.hostname;
+        } catch {
+          return "unknown";
+        }
+      }
+      /**
+       * 构建完整的请求 URL
+       */
+      buildUrl(endpoint) {
+        const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+        const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+        return `${baseUrl}${path}`;
+      }
+      /**
+       * 构建请求头
+       */
+      buildHeaders() {
+        return RequestBuilder.buildHeaders(this.config.apiKey, this.config.headers);
+      }
+      /**
+       * 创建带超时的 AbortController
+       */
+      createAbortController() {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+          controller.abort();
+        }, this.config.timeout ?? DEFAULT_TIMEOUT);
+        return { controller, timeoutId };
+      }
+      /**
+       * 处理 HTTP 错误响应
+       */
+      async handleErrorResponse(response) {
+        const provider = this.getProviderName();
+        let responseBody;
+        try {
+          responseBody = await response.text();
+        } catch {
+        }
+        let message;
+        switch (response.status) {
+          case 400:
+            message = "\u8BF7\u6C42\u53C2\u6570\u9519\u8BEF";
+            break;
+          case 401:
+            message = "API \u5BC6\u94A5\u65E0\u6548\u6216\u5DF2\u8FC7\u671F";
+            break;
+          case 403:
+            message = "\u6CA1\u6709\u6743\u9650\u8BBF\u95EE\u6B64\u8D44\u6E90";
+            break;
+          case 404:
+            message = "\u8BF7\u6C42\u7684\u8D44\u6E90\u4E0D\u5B58\u5728";
+            break;
+          case 429:
+            message = "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+            break;
+          case 500:
+            message = "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF";
+            break;
+          case 502:
+            message = "\u7F51\u5173\u9519\u8BEF";
+            break;
+          case 503:
+            message = "\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528";
+            break;
+          default:
+            message = `HTTP \u9519\u8BEF: ${response.status} ${response.statusText}`;
+        }
+        throw new APIError(message, provider, response.status, responseBody);
+      }
+      /**
+       * 发送聊天请求（非流式）
+       *
+       * @param endpoint - API 端点路径
+       * @param body - 请求体
+       * @returns 响应数据
+       */
+      async chat(endpoint, body) {
+        const url = this.buildUrl(endpoint);
+        const headers = this.buildHeaders();
+        const { controller, timeoutId } = this.createAbortController();
+        const provider = this.getProviderName();
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            await this.handleErrorResponse(response);
+          }
+          const data = await response.json();
+          return data;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error instanceof APIError) {
+            throw error;
+          }
+          if (error instanceof Error && error.name === "AbortError") {
+            throw new TimeoutError(
+              `\u8BF7\u6C42\u8D85\u65F6\uFF08${this.config.timeout}ms\uFF09`,
+              provider,
+              this.config.timeout ?? DEFAULT_TIMEOUT
+            );
+          }
+          if (error instanceof TypeError) {
+            throw new NetworkError("\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8BBE\u7F6E", provider, error);
+          }
+          throw new NetworkError(
+            error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF",
+            provider,
+            error instanceof Error ? error : void 0
+          );
+        }
+      }
+      /**
+       * 发送流式聊天请求
+       *
+       * @param endpoint - API 端点路径
+       * @param body - 请求体
+       * @returns fetch Response 对象
+       */
+      async chatStream(endpoint, body) {
+        const url = this.buildUrl(endpoint);
+        const headers = this.buildHeaders();
+        const { controller, timeoutId } = this.createAbortController();
+        const provider = this.getProviderName();
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            await this.handleErrorResponse(response);
+          }
+          return response;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error instanceof APIError) {
+            throw error;
+          }
+          if (error instanceof Error && error.name === "AbortError") {
+            throw new TimeoutError(
+              `\u8BF7\u6C42\u8D85\u65F6\uFF08${this.config.timeout}ms\uFF09`,
+              provider,
+              this.config.timeout ?? DEFAULT_TIMEOUT
+            );
+          }
+          if (error instanceof TypeError) {
+            throw new NetworkError("\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8BBE\u7F6E", provider, error);
+          }
+          throw new NetworkError(
+            error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF",
+            provider,
+            error instanceof Error ? error : void 0
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/utils/stream-processor.ts
+var stream_processor_exports = {};
+__export(stream_processor_exports, {
+  StreamProcessor: () => StreamProcessor
+});
+var StreamProcessor;
+var init_stream_processor = __esm({
+  "src/utils/stream-processor.ts"() {
+    "use strict";
+    StreamProcessor = class _StreamProcessor {
+      /**
+       * 从响应内容中提取文本
+       * 支持字符串和数组格式的 content
+       *
+       * @param content - 响应内容，可以是字符串、数组或其他类型
+       * @returns 提取的文本内容
+       *
+       * @example
+       * ```ts
+       * // 字符串格式
+       * StreamProcessor.extractTextContent('Hello') // => 'Hello'
+       *
+       * // 数组格式
+       * StreamProcessor.extractTextContent([
+       *   { type: 'text', text: 'Hello' },
+       *   { type: 'text', text: ' World' }
+       * ]) // => 'Hello World'
+       * ```
+       */
+      static extractTextContent(content) {
+        if (typeof content === "string") {
+          return content;
+        }
+        if (Array.isArray(content)) {
+          return content.filter(
+            (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
+          ).map((item) => item.text).join("");
+        }
+        return "";
+      }
+      /**
+       * 解析 SSE 数据行
+       *
+       * @param line - SSE 数据行（如 "data: {...}"）
+       * @returns 解析后的 JSON 对象，或 null（如果是 [DONE] 或无效数据）
+       *
+       * @example
+       * ```ts
+       * StreamProcessor.parseSSELine('data: {"content": "Hello"}')
+       * // => { content: 'Hello' }
+       *
+       * StreamProcessor.parseSSELine('data: [DONE]')
+       * // => null
+       * ```
+       */
+      static parseSSELine(line) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "data: [DONE]") {
+          return null;
+        }
+        if (!trimmed.startsWith("data: ")) {
+          return null;
+        }
+        try {
+          const jsonStr = trimmed.slice(6);
+          return JSON.parse(jsonStr);
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * 创建流式响应处理器
+       * 处理 SSE 格式的流式响应，提取并生成 StreamChunk
+       *
+       * @param response - fetch Response 对象
+       * @param deltaExtractor - 从 delta 中提取 StreamChunk 的函数
+       * @returns AsyncGenerator<StreamChunk>
+       *
+       * @example
+       * ```ts
+       * const response = await fetch(url, { ... });
+       * const extractor = (delta) => {
+       *   if (delta.content) {
+       *     return { type: 'content', text: delta.content };
+       *   }
+       *   return null;
+       * };
+       *
+       * for await (const chunk of StreamProcessor.processStream(response, extractor)) {
+       *   console.log(chunk.type, chunk.text);
+       * }
+       * ```
+       */
+      static async *processStream(response, deltaExtractor) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+          throw new Error("No response body");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const data = _StreamProcessor.parseSSELine(line);
+              if (!data) continue;
+              const choices = data.choices;
+              const delta = choices?.[0]?.delta;
+              if (!delta) continue;
+              const chunk = deltaExtractor(delta);
+              if (chunk) {
+                yield chunk;
+              }
+            }
+          }
+        } finally {
+          reader.releaseLock();
+        }
+      }
+      /**
+       * 创建默认的 delta 提取器
+       * 支持 reasoning_content、reasoning、thoughts 和 content 字段
+       *
+       * @returns DeltaExtractor 函数
+       */
+      static createDefaultExtractor() {
+        return (delta) => {
+          const reasoningContent = delta.reasoning_content ?? delta.reasoning ?? delta.thoughts;
+          if (reasoningContent) {
+            return {
+              type: "reasoning",
+              text: _StreamProcessor.extractTextContent(reasoningContent)
+            };
+          }
+          if (delta.content) {
+            return {
+              type: "content",
+              text: _StreamProcessor.extractTextContent(delta.content)
+            };
+          }
+          return null;
+        };
+      }
+    };
+  }
+});
+
+// src/fluent/chat-session.ts
+var chat_session_exports = {};
+__export(chat_session_exports, {
+  ChatSessionImpl: () => ChatSessionImpl
+});
+var ChatSessionImpl;
+var init_chat_session = __esm({
+  "src/fluent/chat-session.ts"() {
+    "use strict";
+    ChatSessionImpl = class {
+      /** 预设实例引用 */
+      preset;
+      /** 模型 ID */
+      model;
+      /** 会话配置 */
+      options;
+      /** 对话历史 */
+      history = [];
+      /**
+       * 创建对话会话
+       * @param preset - 预设实例
+       * @param model - 模型 ID
+       * @param options - 会话配置
+       */
+      constructor(preset, model, options) {
+        this.preset = preset;
+        this.model = model;
+        this.options = options ?? {};
+        if (this.options.system) {
+          this.history.push({
+            role: "system",
+            content: this.options.system
+          });
+        }
+      }
+      /**
+       * 发送消息并获取响应（非流式）
+       * @param message - 用户消息
+       * @returns 助手响应内容
+       */
+      async send(message) {
+        this.history.push({
+          role: "user",
+          content: message
+        });
+        try {
+          const response = await this.preset.ask(this.model, message, {
+            system: this.buildSystemContext(),
+            temperature: this.options.temperature,
+            maxTokens: this.options.maxTokens,
+            reasoning: this.options.reasoning
+          });
+          this.history.push({
+            role: "assistant",
+            content: response
+          });
+          return response;
+        } catch (error) {
+          this.history.pop();
+          throw error;
+        }
+      }
+      /**
+       * 发送消息并获取流式响应
+       * @param message - 用户消息
+       * @returns 流式数据块生成器
+       */
+      async *sendStream(message) {
+        this.history.push({
+          role: "user",
+          content: message
+        });
+        let responseContent = "";
+        try {
+          const stream = this.preset.stream(this.model, message, {
+            system: this.buildSystemContext(),
+            temperature: this.options.temperature,
+            maxTokens: this.options.maxTokens,
+            reasoning: this.options.reasoning
+          });
+          for await (const chunk of stream) {
+            if (chunk.type === "content") {
+              responseContent += chunk.text;
+            }
+            yield chunk;
+          }
+          this.history.push({
+            role: "assistant",
+            content: responseContent
+          });
+        } catch (error) {
+          this.history.pop();
+          throw error;
+        }
+      }
+      /**
+       * 获取对话历史
+       * @returns 按发送顺序排列的消息列表
+       */
+      getHistory() {
+        return [...this.history];
+      }
+      /**
+       * 清空对话历史
+       */
+      clearHistory() {
+        this.history = [];
+        if (this.options.system) {
+          this.history.push({
+            role: "system",
+            content: this.options.system
+          });
+        }
+      }
+      /**
+       * 构建系统上下文
+       * 将对话历史转换为系统提示词的一部分
+       * @returns 系统上下文字符串
+       */
+      buildSystemContext() {
+        const conversationHistory = this.history.filter(
+          (msg, index) => msg.role !== "system" && index < this.history.length - 1
+        );
+        if (conversationHistory.length === 0) {
+          return this.options.system;
+        }
+        const historyContext = conversationHistory.map((msg) => `${msg.role === "user" ? "\u7528\u6237" : "\u52A9\u624B"}: ${msg.content}`).join("\n");
+        const baseSystem = this.options.system ?? "";
+        return `${baseSystem}
+
+\u4EE5\u4E0B\u662F\u4E4B\u524D\u7684\u5BF9\u8BDD\u5386\u53F2\uFF1A
+${historyContext}`.trim();
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  APIError: () => APIError,
+  BaseAdapter: () => BaseAdapter,
   BaseProvider: () => BaseProvider,
+  CONFIG_DEFAULTS: () => CONFIG_DEFAULTS,
+  ConfigManager: () => ConfigManager,
+  ConfigValidator: () => ConfigValidator,
+  ConfigurationError: () => ConfigurationError,
+  DeepSeekAdapter: () => DeepSeekAdapter,
   EFFORT_TOKEN_MAP: () => EFFORT_TOKEN_MAP,
+  FluentValidationError: () => ValidationError,
+  GeminiAdapter: () => GeminiAdapter,
   GeminiProvider: () => GeminiProvider,
+  GroqAdapter: () => GroqAdapter,
   GroqProvider: () => GroqProvider,
+  HttpProviderClient: () => HttpProviderClient,
+  HuggingFaceAdapter: () => HuggingFaceAdapter,
   HuggingFaceProvider: () => HuggingFaceProvider,
+  ModelScopeAdapter: () => ModelScopeAdapter,
   ModelScopeProvider: () => ModelScopeProvider,
+  NetworkError: () => NetworkError,
+  NovaAdapter: () => NovaAdapter,
+  OpenRouterAdapter: () => OpenRouterAdapter,
   OpenRouterProvider: () => OpenRouterProvider,
+  PoeAdapter: () => PoeAdapter,
+  ProviderError: () => ProviderError,
+  ProviderRegistry: () => ProviderRegistry,
+  RegistryError: () => RegistryError,
+  RequestBuilder: () => RequestBuilder,
+  StreamProcessor: () => StreamProcessor,
+  TimeoutError: () => TimeoutError,
+  VALID_PROVIDERS: () => VALID_PROVIDERS,
   ai: () => ai,
-  createProvider: () => createProvider
+  createBuilder: () => createBuilder,
+  createBuiltInAdapters: () => createBuiltInAdapters,
+  createProvider: () => createProvider,
+  deepseek: () => deepseek,
+  gemini: () => gemini,
+  groq: () => groq,
+  huggingface: () => huggingface,
+  modelscope: () => modelscope,
+  nova: () => nova,
+  oiiai: () => oiiai,
+  openrouter: () => openrouter,
+  poe: () => poe
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/providers/openrouter.ts
-var import_sdk = require("@openrouter/sdk");
+// src/adapters/types.ts
+var BaseAdapter = class {
+  /**
+   * 创建 Provider 客户端
+   * 默认实现：需要在运行时导入 HttpProviderClient 以避免循环依赖
+   */
+  createClient(config) {
+    const { HttpProviderClient: HttpProviderClient2 } = (init_http_provider_client(), __toCommonJS(http_provider_client_exports));
+    return new HttpProviderClient2(config);
+  }
+  /**
+   * 构建聊天请求体
+   * 默认实现：构建 OpenAI 兼容格式的请求体
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 reasoning 参数
+   * 默认实现：返回空对象，子类应覆盖此方法
+   */
+  buildReasoningParams(_config) {
+    return {};
+  }
+  /**
+   * 解析聊天响应
+   * 默认实现：解析 OpenAI 兼容格式的响应
+   */
+  parseChatResponse(response, model) {
+    const choices = response.choices;
+    const choice = choices?.[0];
+    if (!choice) {
+      throw new Error("No response from model");
+    }
+    const msg = choice.message;
+    const reasoningContent = msg?.reasoning_content ?? msg?.reasoning ?? null;
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    const usage = response.usage;
+    return {
+      content: StreamProcessor2.extractTextContent(msg?.content),
+      reasoning: reasoningContent ? StreamProcessor2.extractTextContent(reasoningContent) : null,
+      model: response.model ?? model,
+      usage: {
+        promptTokens: usage?.prompt_tokens ?? usage?.promptTokens ?? 0,
+        completionTokens: usage?.completion_tokens ?? usage?.completionTokens ?? 0,
+        totalTokens: usage?.total_tokens ?? usage?.totalTokens ?? 0
+      },
+      finishReason: choice.finish_reason ?? choice.finishReason ?? null
+    };
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   * 默认实现：支持 reasoning_content、reasoning、thoughts 和 content 字段
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    const reasoningContent = delta.reasoning_content ?? delta.reasoning ?? delta.thoughts;
+    if (reasoningContent) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(reasoningContent)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   * 默认实现：返回 /chat/completions 端点
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/openrouter-adapter.ts
+init_request_builder();
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var OpenRouterAdapter = class extends BaseAdapter {
+  name = "openrouter";
+  defaultBaseUrl = DEFAULT_BASE_URL;
+  /**
+   * 构建聊天请求体
+   * OpenRouter 使用 OpenAI 兼容格式，但有特殊的 reasoning 参数
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParam = this.buildReasoningParams(reasoning);
+    if (reasoningParam && Object.keys(reasoningParam).length > 0) {
+      body.reasoning = reasoningParam;
+    }
+    return body;
+  }
+  /**
+   * 构建 OpenRouter 格式的 reasoning 参数
+   *
+   * OpenRouter reasoning 参数格式：
+   * {
+   *   effort: 'low' | 'medium' | 'high',
+   *   max_tokens: number,
+   *   exclude: boolean
+   * }
+   */
+  buildReasoningParams(config) {
+    return RequestBuilder.buildOpenRouterReasoning(config) ?? {};
+  }
+  /**
+   * 获取 API 端点 URL
+   * OpenRouter 使用标准的 /chat/completions 端点
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/gemini-adapter.ts
+init_request_builder();
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com/v1beta/openai";
+var GeminiAdapter = class extends BaseAdapter {
+  name = "gemini";
+  defaultBaseUrl = DEFAULT_BASE_URL2;
+  /**
+   * 构建聊天请求体
+   * Gemini 使用 OpenAI 兼容格式，reasoning_effort 直接放在请求体中
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 Gemini 格式的 reasoning 参数
+   *
+   * Gemini 2.5+ 模型使用 reasoning_effort 参数：
+   * - 'low': 快速思考
+   * - 'medium': 平衡模式
+   * - 'high': 深度思考
+   */
+  buildReasoningParams(config) {
+    return RequestBuilder.buildGeminiReasoning(config);
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   * Gemini 可能使用 reasoning_content 或 thoughts 字段
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    const reasoningContent = delta.reasoning_content ?? delta.thoughts;
+    if (reasoningContent) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(reasoningContent)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/groq-adapter.ts
+init_request_builder();
+var DEFAULT_BASE_URL3 = "https://api.groq.com/openai/v1";
+var GroqAdapter = class extends BaseAdapter {
+  name = "groq";
+  defaultBaseUrl = DEFAULT_BASE_URL3;
+  /**
+   * 构建聊天请求体
+   * Groq 使用 OpenAI 兼容格式，但有一些特殊参数
+   */
+  buildChatRequest(options, stream = false) {
+    const { model, messages, temperature = 1, maxTokens, reasoning } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream,
+      top_p: 1
+    };
+    if (maxTokens !== void 0) {
+      body.max_completion_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 Groq 格式的 reasoning 参数
+   *
+   * Groq 使用 reasoning_format 参数：
+   * - 'raw': 原始格式
+   * - 'parsed': 解析格式（推荐）
+   *
+   * 注意：不能同时使用 include_reasoning 和 reasoning_format
+   */
+  buildReasoningParams(config) {
+    return RequestBuilder.buildGroqReasoning(config);
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   * Groq 使用 reasoning_content 或 reasoning 字段
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    const reasoningContent = delta.reasoning_content ?? delta.reasoning;
+    if (reasoningContent) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(reasoningContent)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/huggingface-adapter.ts
+var DEFAULT_BASE_URL4 = "https://router.huggingface.co/v1";
+var HuggingFaceAdapter = class extends BaseAdapter {
+  name = "huggingface";
+  defaultBaseUrl = DEFAULT_BASE_URL4;
+  /**
+   * 构建聊天请求体
+   * HuggingFace 使用标准 OpenAI 兼容格式
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 HuggingFace 格式的 reasoning 参数
+   * HuggingFace 使用 reasoning_effort 参数（取决于具体模型是否支持）
+   */
+  buildReasoningParams(config) {
+    if (!config || !config.effort || config.effort === "off") {
+      return {};
+    }
+    return {
+      reasoning_effort: config.effort
+    };
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    if (delta.reasoning_content) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(delta.reasoning_content)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/modelscope-adapter.ts
+var DEFAULT_BASE_URL5 = "https://api-inference.modelscope.cn/v1";
+var ModelScopeAdapter = class extends BaseAdapter {
+  name = "modelscope";
+  defaultBaseUrl = DEFAULT_BASE_URL5;
+  /**
+   * 构建聊天请求体
+   * ModelScope 使用 OpenAI 兼容格式
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 ModelScope 格式的 reasoning 参数
+   * ModelScope 使用 enable_thinking 参数控制思考模式
+   */
+  buildReasoningParams(config) {
+    if (!config || !config.effort) {
+      return {};
+    }
+    if (config.effort === "off") {
+      return { enable_thinking: false };
+    }
+    return { enable_thinking: true };
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    if (delta.reasoning_content) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(delta.reasoning_content)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/deepseek-adapter.ts
+init_request_builder();
+var DEFAULT_BASE_URL6 = "https://api.deepseek.com";
+var DeepSeekAdapter = class extends BaseAdapter {
+  name = "deepseek";
+  defaultBaseUrl = DEFAULT_BASE_URL6;
+  /**
+   * 构建聊天请求体
+   * DeepSeek 使用 OpenAI 兼容格式
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 DeepSeek 格式的 reasoning 参数
+   * DeepSeek 使用 thinking 参数启用思考模式
+   */
+  buildReasoningParams(config) {
+    return RequestBuilder.buildDeepSeekReasoning(config);
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   * DeepSeek R1 使用 reasoning_content 返回思考过程
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    if (delta.reasoning_content) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(delta.reasoning_content)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/poe-adapter.ts
+init_types();
+var DEFAULT_BASE_URL7 = "https://api.poe.com/v1";
+function extractThinkingFromContent(content) {
+  const thinkMatch = content.match(/<think>([\s\S]*?)<\/think>/);
+  if (thinkMatch) {
+    const thinking = thinkMatch[1].trim();
+    const cleanContent = content.replace(/<think>[\s\S]*?<\/think>/, "").trim();
+    return { thinking, content: cleanContent };
+  }
+  const thinkingMatch = content.match(
+    /^\*Thinking\.{0,3}\*\s*\n((?:>.*(?:\n|$))+)/
+  );
+  if (thinkingMatch) {
+    const thinking = thinkingMatch[1].split("\n").map((line) => line.replace(/^>\s?/, "")).join("\n").trim();
+    const cleanContent = content.replace(thinkingMatch[0], "").trim();
+    return { thinking, content: cleanContent };
+  }
+  return { thinking: "", content };
+}
+var PoeAdapter = class extends BaseAdapter {
+  name = "poe";
+  defaultBaseUrl = DEFAULT_BASE_URL7;
+  /**
+   * 构建聊天请求体
+   * Poe 使用 OpenAI 兼容格式，通过 extra_body 传递自定义参数
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 Poe 格式的 reasoning 参数
+   * Poe 通过 extra_body 传递 reasoning_effort 和 thinking_budget
+   */
+  buildReasoningParams(config) {
+    if (!config || config.effort === "off") {
+      return {};
+    }
+    const params = {};
+    if (config.effort) {
+      params.reasoning_effort = config.effort;
+    }
+    if (config.budgetTokens !== void 0) {
+      params.thinking_budget = config.budgetTokens;
+    } else if (config.effort && EFFORT_TOKEN_MAP[config.effort]) {
+      params.thinking_budget = EFFORT_TOKEN_MAP[config.effort];
+    }
+    return params;
+  }
+  /**
+   * 解析聊天响应
+   * Poe 可能返回 reasoning_content，或者需要从 <think> 标签提取
+   */
+  parseChatResponse(response, model) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    const choices = response.choices;
+    const choice = choices?.[0];
+    if (!choice) {
+      throw new Error("No response from model");
+    }
+    const msg = choice.message;
+    let reasoningContent = msg?.reasoning_content ?? null;
+    let contentText = StreamProcessor2.extractTextContent(msg?.content);
+    if (!reasoningContent && contentText) {
+      const extracted = extractThinkingFromContent(contentText);
+      if (extracted.thinking) {
+        reasoningContent = extracted.thinking;
+        contentText = extracted.content;
+      }
+    }
+    const usage = response.usage;
+    return {
+      content: contentText,
+      reasoning: reasoningContent ? StreamProcessor2.extractTextContent(reasoningContent) : null,
+      model: response.model ?? model,
+      usage: {
+        promptTokens: usage?.prompt_tokens ?? usage?.promptTokens ?? 0,
+        completionTokens: usage?.completion_tokens ?? usage?.completionTokens ?? 0,
+        totalTokens: usage?.total_tokens ?? usage?.totalTokens ?? 0
+      },
+      finishReason: choice.finish_reason ?? choice.finishReason ?? null
+    };
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   * Poe 的流式响应处理比较复杂，需要处理多种思考格式
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    if (delta.reasoning_content) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(delta.reasoning_content)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/nova-adapter.ts
+init_request_builder();
+var DEFAULT_BASE_URL8 = "https://api.nova.amazon.com/v1";
+var NovaAdapter = class extends BaseAdapter {
+  name = "nova";
+  defaultBaseUrl = DEFAULT_BASE_URL8;
+  /**
+   * 构建聊天请求体
+   * Nova 使用 OpenAI 兼容格式
+   */
+  buildChatRequest(options, stream = false) {
+    const {
+      model,
+      messages,
+      temperature = 0.7,
+      maxTokens,
+      reasoning
+    } = options;
+    const body = {
+      model,
+      messages,
+      temperature,
+      stream
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    const reasoningParams = this.buildReasoningParams(reasoning);
+    Object.assign(body, reasoningParams);
+    return body;
+  }
+  /**
+   * 构建 Nova 格式的 reasoning 参数
+   * Nova 使用 reasoningConfig 控制 extended thinking
+   */
+  buildReasoningParams(config) {
+    return RequestBuilder.buildNovaReasoning(config);
+  }
+  /**
+   * 从 delta 中提取 StreamChunk
+   * Nova 返回 reasoning_content 作为思考过程
+   */
+  extractStreamChunk(delta) {
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    if (delta.reasoning_content) {
+      return {
+        type: "reasoning",
+        text: StreamProcessor2.extractTextContent(delta.reasoning_content)
+      };
+    }
+    if (delta.content) {
+      return {
+        type: "content",
+        text: StreamProcessor2.extractTextContent(delta.content)
+      };
+    }
+    return null;
+  }
+  /**
+   * 获取 API 端点 URL
+   */
+  getEndpointUrl(baseUrl) {
+    return `${baseUrl}/chat/completions`;
+  }
+};
+
+// src/adapters/index.ts
+function createBuiltInAdapters() {
+  const adapters = /* @__PURE__ */ new Map();
+  adapters.set("openrouter", new OpenRouterAdapter());
+  adapters.set("gemini", new GeminiAdapter());
+  adapters.set("groq", new GroqAdapter());
+  adapters.set("huggingface", new HuggingFaceAdapter());
+  adapters.set("modelscope", new ModelScopeAdapter());
+  adapters.set("deepseek", new DeepSeekAdapter());
+  adapters.set("poe", new PoeAdapter());
+  adapters.set("nova", new NovaAdapter());
+  return adapters;
+}
+
+// src/registry/provider-registry.ts
+var RegistryError = class extends Error {
+  constructor(message, provider, code = "REGISTRY_ERROR") {
+    super(message);
+    this.provider = provider;
+    this.code = code;
+    this.name = "RegistryError";
+  }
+};
+var ProviderRegistry = class {
+  /** 适配器映射表 */
+  static adapters = /* @__PURE__ */ new Map();
+  /** 是否已初始化内置适配器 */
+  static initialized = false;
+  /**
+   * 注册 Provider 适配器
+   *
+   * @param adapter - 要注册的适配器实例
+   * @throws RegistryError 如果适配器无效
+   *
+   * @example
+   * ```typescript
+   * const myAdapter = new MyCustomAdapter();
+   * ProviderRegistry.register(myAdapter);
+   * ```
+   */
+  static register(adapter) {
+    if (!adapter) {
+      throw new RegistryError("\u9002\u914D\u5668\u4E0D\u80FD\u4E3A\u7A7A", void 0, "INVALID_ADAPTER");
+    }
+    if (!adapter.name) {
+      throw new RegistryError(
+        "\u9002\u914D\u5668\u5FC5\u987B\u6709 name \u5C5E\u6027",
+        void 0,
+        "INVALID_ADAPTER"
+      );
+    }
+    this.adapters.set(adapter.name, adapter);
+  }
+  /**
+   * 获取 Provider 适配器
+   *
+   * @param type - Provider 类型
+   * @returns 对应的适配器实例
+   * @throws RegistryError 如果 Provider 未注册
+   *
+   * @example
+   * ```typescript
+   * const adapter = ProviderRegistry.getAdapter('openrouter');
+   * const client = adapter.createClient(config);
+   * ```
+   */
+  static getAdapter(type) {
+    this.initializeBuiltIn();
+    const adapter = this.adapters.get(type);
+    if (!adapter) {
+      const supported = this.listSupported();
+      throw new RegistryError(
+        `Provider "${type}" \u672A\u6CE8\u518C\u3002\u53EF\u7528\u7684 Provider: ${supported.join(", ")}`,
+        type,
+        "PROVIDER_NOT_FOUND"
+      );
+    }
+    return adapter;
+  }
+  /**
+   * 检查 Provider 是否已注册
+   *
+   * @param type - Provider 类型
+   * @returns 是否已注册
+   *
+   * @example
+   * ```typescript
+   * if (ProviderRegistry.hasAdapter('gemini')) {
+   *   console.log('Gemini 已注册');
+   * }
+   * ```
+   */
+  static hasAdapter(type) {
+    this.initializeBuiltIn();
+    return this.adapters.has(type);
+  }
+  /**
+   * 获取所有已注册的 Provider 类型
+   *
+   * @returns Provider 类型数组
+   *
+   * @example
+   * ```typescript
+   * const providers = ProviderRegistry.listSupported();
+   * console.log('支持的 Provider:', providers);
+   * ```
+   */
+  static listSupported() {
+    this.initializeBuiltIn();
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * 从配置文件加载并注册 Provider
+   *
+   * @param config - 注册表配置
+   * @throws RegistryError 如果配置无效或加载失败
+   *
+   * @example
+   * ```typescript
+   * const config: RegistryConfig = {
+   *   providers: {
+   *     'custom-provider': {
+   *       adapter: './my-adapter',
+   *       config: {
+   *         apiKey: 'xxx',
+   *         baseUrl: 'https://api.example.com'
+   *       }
+   *     }
+   *   }
+   * };
+   * ProviderRegistry.loadFromConfig(config);
+   * ```
+   */
+  static loadFromConfig(config) {
+    if (!config || !config.providers) {
+      throw new RegistryError(
+        "\u914D\u7F6E\u65E0\u6548\uFF1A\u7F3A\u5C11 providers \u5B57\u6BB5",
+        void 0,
+        "INVALID_CONFIG"
+      );
+    }
+    this.initializeBuiltIn();
+    for (const [providerName, providerConfig] of Object.entries(
+      config.providers
+    )) {
+      if (providerConfig.adapter) {
+        try {
+          const CustomAdapter = require(providerConfig.adapter);
+          const AdapterClass = CustomAdapter.default || CustomAdapter;
+          const adapter = new AdapterClass();
+          if (typeof adapter.name !== "string" || typeof adapter.createClient !== "function") {
+            throw new RegistryError(
+              `\u81EA\u5B9A\u4E49\u9002\u914D\u5668 "${providerConfig.adapter}" \u672A\u6B63\u786E\u5B9E\u73B0 ProviderAdapter \u63A5\u53E3`,
+              providerName,
+              "INVALID_ADAPTER"
+            );
+          }
+          this.adapters.set(providerName, adapter);
+        } catch (error) {
+          if (error instanceof RegistryError) {
+            throw error;
+          }
+          throw new RegistryError(
+            `\u52A0\u8F7D\u81EA\u5B9A\u4E49\u9002\u914D\u5668\u5931\u8D25: ${providerConfig.adapter}`,
+            providerName,
+            "ADAPTER_LOAD_ERROR"
+          );
+        }
+      } else if (!this.adapters.has(providerName)) {
+        throw new RegistryError(
+          `Provider "${providerName}" \u672A\u6CE8\u518C\u4E14\u672A\u6307\u5B9A\u81EA\u5B9A\u4E49\u9002\u914D\u5668`,
+          providerName,
+          "PROVIDER_NOT_FOUND"
+        );
+      }
+    }
+  }
+  /**
+   * 初始化内置 Provider
+   * 在首次使用时自动调用
+   *
+   * @example
+   * ```typescript
+   * // 通常不需要手动调用，会在首次使用时自动初始化
+   * ProviderRegistry.initializeBuiltIn();
+   * ```
+   */
+  static initializeBuiltIn() {
+    if (this.initialized) {
+      return;
+    }
+    const builtInAdapters = createBuiltInAdapters();
+    for (const [type, adapter] of builtInAdapters) {
+      if (!this.adapters.has(type)) {
+        this.adapters.set(type, adapter);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * 重置注册表（主要用于测试）
+   * 清除所有已注册的适配器并重置初始化状态
+   */
+  static reset() {
+    this.adapters.clear();
+    this.initialized = false;
+  }
+  /**
+   * 获取适配器数量（主要用于测试）
+   *
+   * @returns 已注册的适配器数量
+   */
+  static get size() {
+    this.initializeBuiltIn();
+    return this.adapters.size;
+  }
+};
+
+// src/config/types.ts
+var CONFIG_DEFAULTS = {
+  /** 默认超时时间（毫秒） */
+  timeout: 3e4,
+  /** 默认重试次数 */
+  retries: 3,
+  /** 默认功能开关 */
+  features: {
+    streaming: true,
+    reasoning: false
+  }
+};
+var VALID_PROVIDERS = [
+  "openrouter",
+  "gemini",
+  "groq",
+  "huggingface",
+  "modelscope",
+  "deepseek",
+  "poe",
+  "nova"
+];
+
+// src/utils/config-validator.ts
+var VALID_PROVIDERS2 = [
+  "openrouter",
+  "gemini",
+  "groq",
+  "huggingface",
+  "modelscope",
+  "deepseek",
+  "poe",
+  "nova"
+];
+var ConfigValidator = class _ConfigValidator {
+  /**
+   * 验证 Provider 配置
+   *
+   * @param config - 要验证的配置对象
+   * @returns 验证结果
+   *
+   * @example
+   * ```ts
+   * const result = ConfigValidator.validate({
+   *   provider: 'openrouter',
+   *   credentials: { apiKey: 'sk-xxx' }
+   * });
+   *
+   * if (!result.valid) {
+   *   console.error(result.errors);
+   * }
+   * ```
+   */
+  static validate(config) {
+    const errors = [];
+    if (!config || typeof config !== "object") {
+      return {
+        valid: false,
+        errors: [
+          {
+            field: "",
+            message: "\u914D\u7F6E\u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61",
+            code: "INVALID_CONFIG_TYPE"
+          }
+        ]
+      };
+    }
+    const cfg = config;
+    if (!cfg.provider) {
+      errors.push({
+        field: "provider",
+        message: "provider \u5B57\u6BB5\u662F\u5FC5\u586B\u7684",
+        code: "MISSING_PROVIDER"
+      });
+    } else if (typeof cfg.provider !== "string") {
+      errors.push({
+        field: "provider",
+        message: "provider \u5FC5\u987B\u662F\u5B57\u7B26\u4E32",
+        code: "INVALID_PROVIDER_TYPE"
+      });
+    } else if (!VALID_PROVIDERS2.includes(cfg.provider)) {
+      errors.push({
+        field: "provider",
+        message: `\u65E0\u6548\u7684 provider: ${cfg.provider}\uFF0C\u6709\u6548\u503C\u4E3A: ${VALID_PROVIDERS2.join(", ")}`,
+        code: "INVALID_PROVIDER"
+      });
+    }
+    if (!cfg.credentials) {
+      errors.push({
+        field: "credentials",
+        message: "credentials \u5B57\u6BB5\u662F\u5FC5\u586B\u7684",
+        code: "MISSING_CREDENTIALS"
+      });
+    } else if (typeof cfg.credentials !== "object") {
+      errors.push({
+        field: "credentials",
+        message: "credentials \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61",
+        code: "INVALID_CREDENTIALS_TYPE"
+      });
+    } else {
+      const creds = cfg.credentials;
+      if (!creds.apiKey) {
+        errors.push({
+          field: "credentials.apiKey",
+          message: "apiKey \u5B57\u6BB5\u662F\u5FC5\u586B\u7684",
+          code: "MISSING_API_KEY"
+        });
+      } else if (typeof creds.apiKey !== "string") {
+        errors.push({
+          field: "credentials.apiKey",
+          message: "apiKey \u5FC5\u987B\u662F\u5B57\u7B26\u4E32",
+          code: "INVALID_API_KEY_TYPE"
+        });
+      } else if (creds.apiKey.trim() === "") {
+        errors.push({
+          field: "credentials.apiKey",
+          message: "apiKey \u4E0D\u80FD\u4E3A\u7A7A",
+          code: "EMPTY_API_KEY"
+        });
+      }
+      if (creds.baseUrl !== void 0) {
+        const urlResult = _ConfigValidator.validateUrl(creds.baseUrl);
+        if (!urlResult.valid) {
+          errors.push(
+            ...urlResult.errors.map((e) => ({
+              ...e,
+              field: "credentials.baseUrl"
+            }))
+          );
+        }
+      }
+    }
+    if (cfg.options !== void 0) {
+      if (typeof cfg.options !== "object") {
+        errors.push({
+          field: "options",
+          message: "options \u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61",
+          code: "INVALID_OPTIONS_TYPE"
+        });
+      } else {
+        const opts = cfg.options;
+        if (opts.timeout !== void 0) {
+          if (typeof opts.timeout !== "number" || opts.timeout <= 0) {
+            errors.push({
+              field: "options.timeout",
+              message: "timeout \u5FC5\u987B\u662F\u6B63\u6570",
+              code: "INVALID_TIMEOUT"
+            });
+          }
+        }
+        if (opts.retries !== void 0) {
+          if (typeof opts.retries !== "number" || opts.retries < 0 || !Number.isInteger(opts.retries)) {
+            errors.push({
+              field: "options.retries",
+              message: "retries \u5FC5\u987B\u662F\u975E\u8D1F\u6574\u6570",
+              code: "INVALID_RETRIES"
+            });
+          }
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * 验证 API Key 格式
+   * 不同 Provider 可能有不同的 API Key 格式要求
+   *
+   * @param apiKey - API 密钥
+   * @param provider - Provider 类型
+   * @returns 验证结果
+   */
+  static validateApiKey(apiKey, provider) {
+    const errors = [];
+    if (!apiKey || typeof apiKey !== "string") {
+      errors.push({
+        field: "apiKey",
+        message: "apiKey \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32",
+        code: "INVALID_API_KEY"
+      });
+      return { valid: false, errors };
+    }
+    const trimmed = apiKey.trim();
+    if (trimmed === "") {
+      errors.push({
+        field: "apiKey",
+        message: "apiKey \u4E0D\u80FD\u4E3A\u7A7A",
+        code: "EMPTY_API_KEY"
+      });
+      return { valid: false, errors };
+    }
+    switch (provider) {
+      case "openrouter":
+        if (!trimmed.startsWith("sk-")) {
+          errors.push({
+            field: "apiKey",
+            message: "OpenRouter API Key \u5E94\u4EE5 sk- \u5F00\u5934",
+            code: "INVALID_API_KEY_FORMAT"
+          });
+        }
+        break;
+      case "gemini":
+        if (!trimmed.startsWith("AI")) {
+          errors.push({
+            field: "apiKey",
+            message: "Gemini API Key \u683C\u5F0F\u53EF\u80FD\u4E0D\u6B63\u786E",
+            code: "INVALID_API_KEY_FORMAT"
+          });
+        }
+        break;
+      // 其他 Provider 暂不做特定格式验证
+      default:
+        break;
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * 验证 URL 格式
+   *
+   * @param url - 要验证的 URL
+   * @returns 验证结果
+   */
+  static validateUrl(url) {
+    const errors = [];
+    if (typeof url !== "string") {
+      errors.push({
+        field: "url",
+        message: "URL \u5FC5\u987B\u662F\u5B57\u7B26\u4E32",
+        code: "INVALID_URL_TYPE"
+      });
+      return { valid: false, errors };
+    }
+    const trimmed = url.trim();
+    if (trimmed === "") {
+      errors.push({
+        field: "url",
+        message: "URL \u4E0D\u80FD\u4E3A\u7A7A",
+        code: "EMPTY_URL"
+      });
+      return { valid: false, errors };
+    }
+    try {
+      const parsed = new URL(trimmed);
+      if (!["http:", "https:"].includes(parsed.protocol)) {
+        errors.push({
+          field: "url",
+          message: "URL \u5FC5\u987B\u4F7F\u7528 http \u6216 https \u534F\u8BAE",
+          code: "INVALID_URL_PROTOCOL"
+        });
+      }
+    } catch {
+      errors.push({
+        field: "url",
+        message: "URL \u683C\u5F0F\u65E0\u6548",
+        code: "INVALID_URL_FORMAT"
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/config/config-manager.ts
+var ConfigManager = class _ConfigManager {
+  /**
+   * 验证配置
+   * 检查配置是否符合 UnifiedProviderConfig 格式要求
+   *
+   * @param config - 要验证的配置对象
+   * @returns 验证结果
+   *
+   * @example
+   * ```ts
+   * const result = ConfigManager.validate({
+   *   provider: 'openrouter',
+   *   credentials: { apiKey: 'sk-xxx' }
+   * });
+   *
+   * if (!result.valid) {
+   *   console.error(result.errors);
+   * }
+   * ```
+   */
+  static validate(config) {
+    return ConfigValidator.validate(config);
+  }
+  /**
+   * 应用默认值
+   * 为缺失的可选字段填充默认值
+   *
+   * @param config - 部分配置对象
+   * @returns 填充默认值后的完整配置
+   *
+   * @example
+   * ```ts
+   * const fullConfig = ConfigManager.applyDefaults({
+   *   provider: 'openrouter',
+   *   credentials: { apiKey: 'sk-xxx' }
+   * });
+   * // fullConfig.options.timeout === 30000
+   * // fullConfig.options.retries === 3
+   * ```
+   */
+  static applyDefaults(config) {
+    if (!config.provider || !config.credentials?.apiKey) {
+      throw new Error("\u914D\u7F6E\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5: provider \u548C credentials.apiKey");
+    }
+    return {
+      provider: config.provider,
+      adapter: config.adapter,
+      credentials: {
+        apiKey: config.credentials.apiKey,
+        baseUrl: config.credentials.baseUrl
+      },
+      options: {
+        timeout: config.options?.timeout ?? CONFIG_DEFAULTS.timeout,
+        retries: config.options?.retries ?? CONFIG_DEFAULTS.retries,
+        headers: config.options?.headers ?? {}
+      },
+      features: {
+        streaming: config.features?.streaming ?? CONFIG_DEFAULTS.features.streaming,
+        reasoning: config.features?.reasoning ?? CONFIG_DEFAULTS.features.reasoning
+      }
+    };
+  }
+  /**
+   * 合并环境变量
+   * 将 ${ENV_VAR} 格式的占位符替换为实际环境变量值
+   *
+   * @param config - 包含环境变量占位符的配置
+   * @returns 替换后的配置
+   *
+   * @example
+   * ```ts
+   * // 假设 process.env.OPENROUTER_API_KEY = 'sk-xxx'
+   * const config = ConfigManager.mergeWithEnv({
+   *   provider: 'openrouter',
+   *   credentials: { apiKey: '${OPENROUTER_API_KEY}' }
+   * });
+   * // config.credentials.apiKey === 'sk-xxx'
+   * ```
+   */
+  static mergeWithEnv(config) {
+    const result = JSON.parse(JSON.stringify(config));
+    const replaceEnvVars = (obj) => {
+      for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (typeof value === "string") {
+          obj[key] = _ConfigManager.replaceEnvPlaceholders(value);
+        } else if (value && typeof value === "object" && !Array.isArray(value)) {
+          replaceEnvVars(value);
+        }
+      }
+    };
+    replaceEnvVars(result);
+    return result;
+  }
+  /**
+   * 替换字符串中的环境变量占位符
+   * 支持 ${ENV_VAR} 格式
+   *
+   * @param str - 包含占位符的字符串
+   * @returns 替换后的字符串
+   */
+  static replaceEnvPlaceholders(str) {
+    const envVarPattern = /\$\{([^}]+)\}/g;
+    return str.replace(envVarPattern, (match, envVarName) => {
+      const envValue = process.env[envVarName];
+      return envValue !== void 0 ? envValue : match;
+    });
+  }
+  /**
+   * 从旧格式配置转换为新格式
+   * 保持向后兼容性
+   *
+   * @param config - 旧格式的 Provider 配置
+   * @returns 新格式的统一配置
+   *
+   * @example
+   * ```ts
+   * const newConfig = ConfigManager.fromLegacyConfig({
+   *   provider: 'openrouter',
+   *   apiKey: 'sk-xxx',
+   *   baseUrl: 'https://api.example.com'
+   * });
+   * // newConfig.credentials.apiKey === 'sk-xxx'
+   * // newConfig.credentials.baseUrl === 'https://api.example.com'
+   * ```
+   */
+  static fromLegacyConfig(config) {
+    if (!config.provider) {
+      throw new Error("\u65E7\u683C\u5F0F\u914D\u7F6E\u7F3A\u5C11 provider \u5B57\u6BB5");
+    }
+    if (!config.apiKey) {
+      throw new Error("\u65E7\u683C\u5F0F\u914D\u7F6E\u7F3A\u5C11 apiKey \u5B57\u6BB5");
+    }
+    if (!VALID_PROVIDERS.includes(config.provider)) {
+      throw new Error(
+        `\u65E0\u6548\u7684 provider: ${config.provider}\uFF0C\u6709\u6548\u503C\u4E3A: ${VALID_PROVIDERS.join(", ")}`
+      );
+    }
+    return _ConfigManager.applyDefaults({
+      provider: config.provider,
+      credentials: {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      }
+    });
+  }
+  /**
+   * 检查配置是否为旧格式
+   *
+   * @param config - 要检查的配置对象
+   * @returns 是否为旧格式
+   */
+  static isLegacyConfig(config) {
+    if (!config || typeof config !== "object") {
+      return false;
+    }
+    const cfg = config;
+    return typeof cfg.provider === "string" && typeof cfg.apiKey === "string" && cfg.credentials === void 0;
+  }
+  /**
+   * 智能转换配置
+   * 自动检测配置格式并转换为统一格式
+   *
+   * @param config - 任意格式的配置
+   * @returns 统一格式的配置
+   */
+  static normalize(config) {
+    if (_ConfigManager.isLegacyConfig(config)) {
+      return _ConfigManager.fromLegacyConfig(config);
+    }
+    return _ConfigManager.applyDefaults(
+      config
+    );
+  }
+  /**
+   * 获取指定 Provider 的默认基础 URL
+   *
+   * @param provider - Provider 类型
+   * @returns 默认基础 URL
+   */
+  static getDefaultBaseUrl(provider) {
+    const defaultUrls = {
+      openrouter: "https://openrouter.ai/api/v1",
+      gemini: "https://generativelanguage.googleapis.com/v1beta",
+      groq: "https://api.groq.com/openai/v1",
+      huggingface: "https://api-inference.huggingface.co",
+      modelscope: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      deepseek: "https://api.deepseek.com/v1",
+      poe: "https://api.poe.com/bot",
+      nova: "https://bedrock-runtime.us-east-1.amazonaws.com"
+    };
+    return defaultUrls[provider];
+  }
+};
+
+// src/providers/__factory__.ts
+var AdapterBasedProvider = class {
+  constructor(adapter, apiKey, baseUrl) {
+    this.adapter = adapter;
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.name = adapter.name;
+  }
+  name;
+  /**
+   * 获取客户端实例
+   */
+  getClient() {
+    return this.adapter.createClient({
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl ?? this.adapter.defaultBaseUrl
+    });
+  }
+  /**
+   * 发送聊天请求（非流式）
+   */
+  async chat(options) {
+    const client = this.getClient();
+    const baseUrl = this.baseUrl ?? this.adapter.defaultBaseUrl;
+    const endpoint = this.adapter.getEndpointUrl(baseUrl);
+    const endpointPath = endpoint.replace(baseUrl, "");
+    const body = this.adapter.buildChatRequest(options, false);
+    const response = await client.chat(endpointPath, body);
+    return this.adapter.parseChatResponse(response, options.model);
+  }
+  /**
+   * 发送流式聊天请求
+   */
+  async *chatStream(options) {
+    const client = this.getClient();
+    const baseUrl = this.baseUrl ?? this.adapter.defaultBaseUrl;
+    const endpoint = this.adapter.getEndpointUrl(baseUrl);
+    const endpointPath = endpoint.replace(baseUrl, "");
+    const body = this.adapter.buildChatRequest(options, true);
+    const response = await client.chatStream(endpointPath, body);
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    yield* StreamProcessor2.processStream(
+      response,
+      (delta) => this.adapter.extractStreamChunk(delta)
+    );
+  }
+  /**
+   * 简单对话：单轮问答
+   */
+  async ask(model, question, options) {
+    const result = await this.chat({
+      model,
+      messages: [{ role: "user", content: question }],
+      ...options
+    });
+    return result.content;
+  }
+  /**
+   * 带系统提示的对话
+   */
+  async askWithSystem(model, systemPrompt, userMessage, options) {
+    const result = await this.chat({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userMessage }
+      ],
+      ...options
+    });
+    return result.content;
+  }
+};
+function createProvider(config) {
+  const unifiedConfig = ConfigManager.fromLegacyConfig(config);
+  const adapter = ProviderRegistry.getAdapter(unifiedConfig.provider);
+  return new AdapterBasedProvider(
+    adapter,
+    unifiedConfig.credentials.apiKey,
+    unifiedConfig.credentials.baseUrl
+  );
+}
+var ai = {
+  openrouter: (apiKey, baseUrl) => createProvider({ provider: "openrouter", apiKey, baseUrl }),
+  gemini: (apiKey, baseUrl) => createProvider({ provider: "gemini", apiKey, baseUrl }),
+  groq: (apiKey, baseUrl) => createProvider({ provider: "groq", apiKey, baseUrl }),
+  huggingface: (apiKey, baseUrl) => createProvider({ provider: "huggingface", apiKey, baseUrl }),
+  modelscope: (apiKey, baseUrl) => createProvider({ provider: "modelscope", apiKey, baseUrl }),
+  deepseek: (apiKey, baseUrl) => createProvider({ provider: "deepseek", apiKey, baseUrl }),
+  poe: (apiKey, baseUrl) => createProvider({ provider: "poe", apiKey, baseUrl }),
+  nova: (apiKey, baseUrl) => createProvider({ provider: "nova", apiKey, baseUrl })
+};
 
 // src/providers/__model-detection__.ts
 var THINKING_MODEL_PATTERNS = [
@@ -335,7 +2553,11 @@ var BaseProvider = class {
    * 3. 如果 content 为空，智能降级（提取结论或返回 reasoning）
    */
   async ask(model, question, options) {
-    const { fallback, autoAdjust = this.autoAdjustEnabled, ...chatOptions } = options ?? {};
+    const {
+      fallback,
+      autoAdjust = this.autoAdjustEnabled,
+      ...chatOptions
+    } = options ?? {};
     let finalOptions = {
       model,
       messages: [{ role: "user", content: question }],
@@ -361,7 +2583,11 @@ var BaseProvider = class {
    * 3. 如果 content 为空，智能降级（提取结论或返回 reasoning）
    */
   async askWithSystem(model, systemPrompt, userMessage, options) {
-    const { fallback, autoAdjust = this.autoAdjustEnabled, ...chatOptions } = options ?? {};
+    const {
+      fallback,
+      autoAdjust = this.autoAdjustEnabled,
+      ...chatOptions
+    } = options ?? {};
     let finalOptions = {
       model,
       messages: [
@@ -392,1432 +2618,796 @@ var BaseProvider = class {
    *   - 'reasoning': 逻辑推理
    *   - 'fast': 快速回答（关闭思考）
    */
-  async askWithScenario(model, question, scenario = "simple", options) {
-    const recommendedConfig = ModelDetection.getRecommendedConfig(model, scenario);
-    return this.ask(model, question, {
-      ...recommendedConfig,
-      ...options
-    });
-  }
-};
-
-// src/providers/__types__.ts
-var EFFORT_TOKEN_MAP = {
-  off: 0,
-  low: 1024,
-  medium: 4096,
-  high: 16384
-};
-
-// src/providers/openrouter.ts
-function extractTextContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
-function buildReasoningParam(config) {
-  if (!config) return void 0;
-  if (config.effort === "off") return void 0;
-  const param = {};
-  if (config.effort) {
-    param.effort = config.effort;
-  }
-  if (config.budgetTokens !== void 0) {
-    param.max_tokens = config.budgetTokens;
-  } else if (config.effort && EFFORT_TOKEN_MAP[config.effort]) {
-    param.max_tokens = EFFORT_TOKEN_MAP[config.effort];
-  }
-  if (config.exclude !== void 0) {
-    param.exclude = config.exclude;
-  }
-  return Object.keys(param).length > 0 ? param : void 0;
-}
-var OpenRouterProvider = class extends BaseProvider {
-  name = "openrouter";
-  client;
-  constructor(apiKey) {
-    super();
-    this.client = new import_sdk.OpenRouter({ apiKey });
-  }
-  /**
-   * 发送聊天请求（非流式）
-   */
-  async chat(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const reasoningParam = buildReasoningParam(reasoning);
-    const requestParams = {
-      model,
-      messages,
-      temperature,
-      maxTokens,
-      stream: false
-    };
-    if (reasoningParam) {
-      requestParams.reasoning = reasoningParam;
-    }
-    const result = await this.client.chat.send(requestParams);
-    const choice = result.choices[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    const reasoningContent = msg.reasoning_content ?? msg.reasoning ?? null;
-    return {
-      content: extractTextContent(msg.content),
-      reasoning: reasoningContent ? extractTextContent(reasoningContent) : null,
-      model: result.model,
-      usage: {
-        promptTokens: result.usage?.promptTokens ?? 0,
-        completionTokens: result.usage?.completionTokens ?? 0,
-        totalTokens: result.usage?.totalTokens ?? 0
-      },
-      finishReason: choice.finishReason
-    };
-  }
-  /**
-   * 发送流式聊天请求
-   */
-  async *chatStream(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const reasoningParam = buildReasoningParam(reasoning);
-    const requestParams = {
-      model,
-      messages,
-      temperature,
-      maxTokens,
-      stream: true
-    };
-    if (reasoningParam) {
-      requestParams.reasoning = reasoningParam;
-    }
-    const stream = await this.client.chat.send(
-      requestParams
-    );
-    for await (const chunk of stream) {
-      const delta = chunk.choices?.[0]?.delta;
-      if (!delta) continue;
-      const reasoningContent = delta.reasoning_content ?? delta.reasoning;
-      if (reasoningContent) {
-        yield { type: "reasoning", text: extractTextContent(reasoningContent) };
-      }
-      if (delta.content) {
-        yield { type: "content", text: extractTextContent(delta.content) };
-      }
-    }
-  }
-  /**
-   * 获取可用模型列表
-   */
-  async listModels() {
-    const result = await this.client.models.list();
-    return (result.data ?? []).map((m) => ({
-      id: m.id,
-      canonicalSlug: m.canonical_slug ?? m.id,
-      name: m.name,
-      description: m.description ?? "",
-      created: m.created ?? 0,
-      pricing: {
-        prompt: m.pricing?.prompt ?? "0",
-        completion: m.pricing?.completion ?? "0",
-        request: m.pricing?.request ?? "0",
-        image: m.pricing?.image ?? "0"
-      },
-      contextLength: m.context_length ?? 0,
-      architecture: {
-        modality: m.architecture?.modality ?? "",
-        inputModalities: m.architecture?.input_modalities ?? [],
-        outputModalities: m.architecture?.output_modalities ?? [],
-        tokenizer: m.architecture?.tokenizer ?? "",
-        instructType: m.architecture?.instruct_type ?? ""
-      },
-      supportedParameters: m.supported_parameters ?? []
-    }));
-  }
-};
-
-// src/providers/gemini.ts
-var BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
-function extractTextContent2(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
-var GeminiProvider = class extends BaseProvider {
-  name = "gemini";
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    super();
-    if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL;
-    } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL;
-    }
-  }
-  /**
-   * 发送聊天请求（非流式）
-   */
-  async chat(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoning_effort = reasoning.effort;
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    const reasoningContent = msg?.reasoning_content ?? null;
-    return {
-      content: extractTextContent2(msg?.content),
-      reasoning: reasoningContent ? extractTextContent2(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
-  }
-  /**
-   * 发送流式聊天请求
-   */
-  async *chatStream(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: true
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoning_effort = reasoning.effort;
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} ${error}`);
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            const thought = delta.reasoning_content ?? delta.thoughts;
-            if (thought) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent2(thought)
-              };
-            }
-            if (delta.content) {
-              yield {
-                type: "content",
-                text: extractTextContent2(delta.content)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-};
-
-// src/providers/groq.ts
-var BASE_URL2 = "https://api.groq.com/openai/v1";
-function extractTextContent3(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
-var GroqProvider = class extends BaseProvider {
-  name = "groq";
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    super();
-    if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL2;
-    } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL2;
-    }
-  }
-  /**
-   * 发送聊天请求（非流式）
-   */
-  async chat(options) {
-    const { model, messages, temperature = 1, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false,
-      top_p: 1
-    };
-    if (maxTokens) {
-      body.max_completion_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoning_format = "parsed";
-    } else if (reasoning?.effort === "off") {
-      body.include_reasoning = false;
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Groq API error: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    const reasoningContent = msg?.reasoning_content ?? msg?.reasoning ?? null;
-    return {
-      content: extractTextContent3(msg?.content),
-      reasoning: reasoningContent ? extractTextContent3(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
-  }
-  /**
-   * 发送流式聊天请求
-   */
-  async *chatStream(options) {
-    const { model, messages, temperature = 1, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: true,
-      top_p: 1
-    };
-    if (maxTokens) {
-      body.max_completion_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoning_format = "parsed";
-    } else if (reasoning?.effort === "off") {
-      body.include_reasoning = false;
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Groq API error: ${response.status} ${error}`);
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            const reasoningContent = delta.reasoning_content ?? delta.reasoning;
-            if (reasoningContent) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent3(reasoningContent)
-              };
-            }
-            if (delta.content) {
-              yield {
-                type: "content",
-                text: extractTextContent3(delta.content)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
+  async askWithScenario(model, question, scenario = "simple", options) {
+    const recommendedConfig = ModelDetection.getRecommendedConfig(
+      model,
+      scenario
+    );
+    return this.ask(model, question, {
+      ...recommendedConfig,
+      ...options
+    });
   }
 };
 
-// src/providers/huggingface.ts
-var BASE_URL3 = "https://router.huggingface.co/v1";
-function extractTextContent4(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
-var HuggingFaceProvider = class extends BaseProvider {
-  name = "huggingface";
-  apiKey;
+// src/providers/__index__.ts
+init_types();
+
+// src/providers/openrouter.ts
+init_http_provider_client();
+init_stream_processor();
+var OpenRouterProvider = class extends BaseProvider {
+  name = "openrouter";
+  adapter;
+  client;
   baseUrl;
-  constructor(config) {
+  apiKey;
+  constructor(apiKey, baseUrl) {
     super();
-    if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL3;
-    } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL3;
-    }
+    this.apiKey = apiKey;
+    this.adapter = new OpenRouterAdapter();
+    this.baseUrl = baseUrl ?? this.adapter.defaultBaseUrl;
+    this.client = new HttpProviderClient({
+      apiKey,
+      baseUrl: this.baseUrl
+    });
   }
   /**
    * 发送聊天请求（非流式）
-   *
-   * reasoning 参数说明：
-   * - HuggingFace 是模型聚合平台，thinking 支持取决于具体模型
-   * - 如果模型支持，会返回 reasoning_content
    */
   async chat(options) {
-    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoning_effort = reasoning.effort;
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`HuggingFace API error: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    const reasoningContent = msg?.reasoning_content ?? null;
-    return {
-      content: extractTextContent4(msg?.content),
-      reasoning: reasoningContent ? extractTextContent4(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
+    const body = this.adapter.buildChatRequest(options, false);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chat(endpointPath, body);
+    return this.adapter.parseChatResponse(response, options.model);
   }
   /**
    * 发送流式聊天请求
    */
   async *chatStream(options) {
-    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: true
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoning_effort = reasoning.effort;
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
+    const body = this.adapter.buildChatRequest(options, true);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chatStream(endpointPath, body);
+    yield* StreamProcessor.processStream(
+      response,
+      (delta) => this.adapter.extractStreamChunk(delta)
+    );
+  }
+  /**
+   * 获取可用模型列表
+   * 注意：此方法直接调用 OpenRouter API，不使用适配器
+   */
+  async listModels() {
+    const response = await fetch(`${this.baseUrl}/models`, {
       headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      }
     });
     if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`HuggingFace API error: ${response.status} ${error}`);
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            if (delta.reasoning_content) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent4(delta.reasoning_content)
-              };
-            }
-            if (delta.content) {
-              yield {
-                type: "content",
-                text: extractTextContent4(delta.content)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
+      throw new Error(
+        `Failed to fetch models: ${response.status} ${response.statusText}`
+      );
     }
+    const result = await response.json();
+    return (result.data ?? []).map((m) => ({
+      id: m.id,
+      canonicalSlug: m.canonical_slug ?? m.id,
+      name: m.name,
+      description: m.description ?? "",
+      created: m.created ?? 0,
+      pricing: {
+        prompt: m.pricing?.prompt ?? "0",
+        completion: m.pricing?.completion ?? "0",
+        request: m.pricing?.request ?? "0",
+        image: m.pricing?.image ?? "0"
+      },
+      contextLength: m.context_length ?? 0,
+      architecture: {
+        modality: m.architecture?.modality ?? "",
+        inputModalities: m.architecture?.input_modalities ?? [],
+        outputModalities: m.architecture?.output_modalities ?? [],
+        tokenizer: m.architecture?.tokenizer ?? "",
+        instructType: m.architecture?.instruct_type ?? ""
+      },
+      supportedParameters: m.supported_parameters ?? []
+    }));
   }
 };
 
 // src/providers/modelscope.ts
-var BASE_URL4 = "https://api-inference.modelscope.cn/v1";
-function extractTextContent5(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
+init_http_provider_client();
+init_stream_processor();
 var ModelScopeProvider = class extends BaseProvider {
   name = "modelscope";
-  apiKey;
+  adapter;
+  client;
   baseUrl;
   constructor(config) {
     super();
+    this.adapter = new ModelScopeAdapter();
     if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL4;
+      this.baseUrl = this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config,
+        baseUrl: this.baseUrl
+      });
     } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL4;
+      this.baseUrl = config.baseUrl ?? this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config.apiKey,
+        baseUrl: this.baseUrl
+      });
     }
   }
   /**
    * 发送聊天请求（非流式）
    */
   async chat(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort) {
-      if (reasoning.effort === "off") {
-        body.enable_thinking = false;
-      } else {
-        body.enable_thinking = true;
-      }
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`ModelScope API error: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    const reasoningContent = msg?.reasoning_content ?? null;
-    return {
-      content: extractTextContent5(msg?.content),
-      reasoning: reasoningContent ? extractTextContent5(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
+    const body = this.adapter.buildChatRequest(options, false);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chat(endpointPath, body);
+    return this.adapter.parseChatResponse(response, options.model);
   }
   /**
    * 发送流式聊天请求
    */
   async *chatStream(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: true
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort) {
-      if (reasoning.effort === "off") {
-        body.enable_thinking = false;
-      } else {
-        body.enable_thinking = true;
-      }
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`ModelScope API error: ${response.status} ${error}`);
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            if (delta.reasoning_content) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent5(delta.reasoning_content)
-              };
-            }
-            if (delta.content) {
-              yield {
-                type: "content",
-                text: extractTextContent5(delta.content)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
+    const body = this.adapter.buildChatRequest(options, true);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chatStream(endpointPath, body);
+    yield* StreamProcessor.processStream(
+      response,
+      (delta) => this.adapter.extractStreamChunk(delta)
+    );
   }
 };
 
-// src/providers/deepseek.ts
-var BASE_URL5 = "https://api.deepseek.com";
-function extractTextContent6(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
-var DeepSeekProvider = class extends BaseProvider {
-  name = "deepseek";
-  apiKey;
+// src/providers/huggingface.ts
+init_http_provider_client();
+init_stream_processor();
+var HuggingFaceProvider = class extends BaseProvider {
+  name = "huggingface";
+  adapter;
+  client;
   baseUrl;
   constructor(config) {
     super();
+    this.adapter = new HuggingFaceAdapter();
     if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL5;
+      this.baseUrl = this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config,
+        baseUrl: this.baseUrl
+      });
     } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL5;
+      this.baseUrl = config.baseUrl ?? this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config.apiKey,
+        baseUrl: this.baseUrl
+      });
     }
   }
   /**
    * 发送聊天请求（非流式）
    *
    * reasoning 参数说明：
-   * - effort 不为 'off' 时启用 thinking 模式
-   * - maxTokens 独立控制输出长度，不受 effort 影响
+   * - HuggingFace 是模型聚合平台，thinking 支持取决于具体模型
+   * - 如果模型支持，会返回 reasoning_content
    */
   async chat(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.thinking = { type: "enabled" };
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`DeepSeek API error: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    const reasoningContent = msg?.reasoning_content ?? null;
-    return {
-      content: extractTextContent6(msg?.content),
-      reasoning: reasoningContent ? extractTextContent6(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
+    const body = this.adapter.buildChatRequest(options, false);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chat(endpointPath, body);
+    return this.adapter.parseChatResponse(response, options.model);
   }
   /**
    * 发送流式聊天请求
    */
   async *chatStream(options) {
-    const {
-      model,
-      messages,
-      temperature = 0.7,
-      maxTokens,
-      reasoning
-    } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: true
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.thinking = { type: "enabled" };
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`DeepSeek API error: ${response.status} ${error}`);
-    }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
-    }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            if (delta.reasoning_content) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent6(delta.reasoning_content)
-              };
-            }
-            if (delta.content) {
-              yield {
-                type: "content",
-                text: extractTextContent6(delta.content)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
+    const body = this.adapter.buildChatRequest(options, true);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chatStream(endpointPath, body);
+    yield* StreamProcessor.processStream(
+      response,
+      (delta) => this.adapter.extractStreamChunk(delta)
+    );
   }
 };
 
-// src/providers/poe.ts
-var BASE_URL6 = "https://api.poe.com/v1";
-function extractTextContent7(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
-  }
-  return "";
-}
-function extractThinkingFromContent(content) {
-  const thinkMatch = content.match(/<think>([\s\S]*?)<\/think>/);
-  if (thinkMatch) {
-    const thinking = thinkMatch[1].trim();
-    const cleanContent = content.replace(/<think>[\s\S]*?<\/think>/, "").trim();
-    return { thinking, content: cleanContent };
-  }
-  const thinkingMatch = content.match(
-    /^\*Thinking\.{0,3}\*\s*\n((?:>.*(?:\n|$))+)/
-  );
-  if (thinkingMatch) {
-    const thinking = thinkingMatch[1].split("\n").map((line) => line.replace(/^>\s?/, "")).join("\n").trim();
-    const cleanContent = content.replace(thinkingMatch[0], "").trim();
-    return { thinking, content: cleanContent };
-  }
-  return { thinking: "", content };
-}
-function buildExtraBody(reasoning) {
-  if (!reasoning || reasoning.effort === "off") {
-    return void 0;
+// src/providers/groq.ts
+init_http_provider_client();
+init_stream_processor();
+var GroqProvider = class extends BaseProvider {
+  name = "groq";
+  adapter;
+  client;
+  baseUrl;
+  constructor(config) {
+    super();
+    this.adapter = new GroqAdapter();
+    if (typeof config === "string") {
+      this.baseUrl = this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config,
+        baseUrl: this.baseUrl
+      });
+    } else {
+      this.baseUrl = config.baseUrl ?? this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config.apiKey,
+        baseUrl: this.baseUrl
+      });
+    }
   }
-  const extraBody = {};
-  if (reasoning.effort) {
-    extraBody.reasoning_effort = reasoning.effort;
+  /**
+   * 发送聊天请求（非流式）
+   */
+  async chat(options) {
+    const body = this.adapter.buildChatRequest(options, false);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chat(endpointPath, body);
+    return this.adapter.parseChatResponse(response, options.model);
   }
-  if (reasoning.budgetTokens !== void 0) {
-    extraBody.thinking_budget = reasoning.budgetTokens;
-  } else if (reasoning.effort && EFFORT_TOKEN_MAP[reasoning.effort]) {
-    extraBody.thinking_budget = EFFORT_TOKEN_MAP[reasoning.effort];
+  /**
+   * 发送流式聊天请求
+   */
+  async *chatStream(options) {
+    const body = this.adapter.buildChatRequest(options, true);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chatStream(endpointPath, body);
+    yield* StreamProcessor.processStream(
+      response,
+      (delta) => this.adapter.extractStreamChunk(delta)
+    );
   }
-  return Object.keys(extraBody).length > 0 ? extraBody : void 0;
-}
-var PoeProvider = class extends BaseProvider {
-  name = "poe";
-  apiKey;
+};
+
+// src/providers/gemini.ts
+init_http_provider_client();
+init_stream_processor();
+var GeminiProvider = class extends BaseProvider {
+  name = "gemini";
+  adapter;
+  client;
   baseUrl;
   constructor(config) {
     super();
+    this.adapter = new GeminiAdapter();
     if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL6;
+      this.baseUrl = this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config,
+        baseUrl: this.baseUrl
+      });
     } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL6;
+      this.baseUrl = config.baseUrl ?? this.adapter.defaultBaseUrl;
+      this.client = new HttpProviderClient({
+        apiKey: config.apiKey,
+        baseUrl: this.baseUrl
+      });
     }
   }
   /**
    * 发送聊天请求（非流式）
    */
   async chat(options) {
-    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    const extraBody = buildExtraBody(reasoning);
-    if (extraBody) {
-      Object.assign(body, extraBody);
-    }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Poe API error: ${response.status} ${error}`);
-    }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
-    }
-    const msg = choice.message;
-    let reasoningContent = msg?.reasoning_content ?? null;
-    let contentText = extractTextContent7(msg?.content);
-    if (!reasoningContent && contentText) {
-      const extracted = extractThinkingFromContent(contentText);
-      if (extracted.thinking) {
-        reasoningContent = extracted.thinking;
-        contentText = extracted.content;
-      }
-    }
-    return {
-      content: contentText,
-      reasoning: reasoningContent ? extractTextContent7(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
+    const body = this.adapter.buildChatRequest(options, false);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chat(endpointPath, body);
+    return this.adapter.parseChatResponse(response, options.model);
   }
   /**
    * 发送流式聊天请求
    */
   async *chatStream(options) {
-    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: true
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
+    const body = this.adapter.buildChatRequest(options, true);
+    const endpoint = this.adapter.getEndpointUrl(this.baseUrl);
+    const endpointPath = endpoint.replace(this.baseUrl, "");
+    const response = await this.client.chatStream(endpointPath, body);
+    yield* StreamProcessor.processStream(
+      response,
+      (delta) => this.adapter.extractStreamChunk(delta)
+    );
+  }
+};
+
+// src/providers/deepseek.ts
+init_http_provider_client();
+init_stream_processor();
+
+// src/providers/poe.ts
+init_http_provider_client();
+init_stream_processor();
+
+// src/providers/nova.ts
+init_http_provider_client();
+init_stream_processor();
+
+// src/utils/index.ts
+init_stream_processor();
+init_request_builder();
+
+// src/client/index.ts
+init_types2();
+init_http_provider_client();
+
+// src/fluent/errors.ts
+var ConfigurationError = class _ConfigurationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+    Object.setPrototypeOf(this, _ConfigurationError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+
+// src/fluent/builder.ts
+var OiiaiBuilderImpl = class _OiiaiBuilderImpl {
+  /** 内部配置状态 */
+  config = {};
+  /**
+   * 创建构建器实例
+   * @param initialConfig - 可选的初始配置
+   */
+  constructor(initialConfig) {
+    if (initialConfig) {
+      this.config = { ...initialConfig };
     }
-    const extraBody = buildExtraBody(reasoning);
-    if (extraBody) {
-      Object.assign(body, extraBody);
+  }
+  /**
+   * 选择服务提供商
+   * @param provider - Provider 类型
+   * @returns this 支持链式调用
+   */
+  use(provider) {
+    if (!ProviderRegistry.hasAdapter(provider)) {
+      const supported = ProviderRegistry.listSupported();
+      throw new ValidationError(
+        `\u4E0D\u652F\u6301\u7684 Provider: ${provider}\uFF0C\u652F\u6301\u7684 Provider: ${supported.join(", ")}`
+      );
+    }
+    this.config.provider = provider;
+    return this;
+  }
+  /**
+   * 指定模型
+   * @param modelId - 模型 ID
+   * @returns this 支持链式调用
+   */
+  model(modelId) {
+    this.config.model = modelId;
+    return this;
+  }
+  /**
+   * 设置系统提示词
+   * @param prompt - 系统提示词
+   * @returns this 支持链式调用
+   */
+  system(prompt) {
+    this.config.system = prompt;
+    return this;
+  }
+  /**
+   * 设置温度参数
+   * @param value - 温度值 (0-2)
+   * @returns this 支持链式调用
+   */
+  temperature(value) {
+    if (value < 0 || value > 2) {
+      throw new ValidationError("temperature \u5FC5\u987B\u5728 0-2 \u4E4B\u95F4");
     }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
+    this.config.temperature = value;
+    return this;
+  }
+  /**
+   * 设置最大输出 token 数
+   * @param value - token 数量
+   * @returns this 支持链式调用
+   */
+  maxTokens(value) {
+    this.config.maxTokens = value;
+    return this;
+  }
+  /**
+   * 配置思考/推理模式
+   * @param config - 推理配置
+   * @returns this 支持链式调用
+   */
+  reasoning(config) {
+    this.config.reasoning = config;
+    return this;
+  }
+  /**
+   * 设置 API Key
+   * @param apiKey - API Key
+   * @returns this 支持链式调用
+   */
+  key(apiKey) {
+    this.config.apiKey = apiKey;
+    return this;
+  }
+  /**
+   * 设置基础 URL
+   * @param url - 基础 URL
+   * @returns this 支持链式调用
+   */
+  baseUrl(url) {
+    this.config.baseUrl = url;
+    return this;
+  }
+  /**
+   * 标记为流式请求
+   * 调用后 ask() 将返回 AsyncGenerator
+   * @returns StreamBuilder 类型
+   */
+  stream() {
+    this.config.isStream = true;
+    return this;
+  }
+  ask(question) {
+    this.validateConfig();
+    const adapter = ProviderRegistry.getAdapter(this.config.provider);
+    const client = adapter.createClient({
+      apiKey: this.config.apiKey,
+      baseUrl: this.config.baseUrl ?? adapter.defaultBaseUrl
     });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Poe API error: ${response.status} ${error}`);
+    const messages = [];
+    if (this.config.system) {
+      messages.push({ role: "system", content: this.config.system });
     }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
+    messages.push({ role: "user", content: question });
+    const chatOptions = {
+      model: this.config.model,
+      messages,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      reasoning: this.config.reasoning
+    };
+    if (this.config.isStream) {
+      return this.executeStreamRequest(adapter, client, chatOptions);
     }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let thinkingMode = "none";
-    let contentBuffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            if (delta.reasoning_content) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent7(delta.reasoning_content)
-              };
-              continue;
-            }
-            if (delta.content) {
-              const text = extractTextContent7(delta.content);
-              contentBuffer += text;
-              while (true) {
-                if (thinkingMode === "none") {
-                  const thinkStart = contentBuffer.indexOf("<think>");
-                  if (thinkStart !== -1) {
-                    if (thinkStart > 0) {
-                      yield { type: "content", text: contentBuffer.slice(0, thinkStart) };
-                    }
-                    contentBuffer = contentBuffer.slice(thinkStart + 7);
-                    thinkingMode = "think_tag";
-                    continue;
-                  }
-                  const thinkingMatch = contentBuffer.match(/^\*Thinking\.{0,3}\*\s*\n/);
-                  if (thinkingMatch) {
-                    contentBuffer = contentBuffer.slice(thinkingMatch[0].length);
-                    thinkingMode = "markdown_thinking";
-                    continue;
-                  }
-                  if (contentBuffer.length > 0) {
-                    const keepLen = Math.min(15, contentBuffer.length);
-                    const output = contentBuffer.slice(0, -keepLen) || "";
-                    if (output) {
-                      yield { type: "content", text: output };
-                      contentBuffer = contentBuffer.slice(-keepLen);
-                    }
-                  }
-                  break;
-                } else if (thinkingMode === "think_tag") {
-                  const endIdx = contentBuffer.indexOf("</think>");
-                  if (endIdx !== -1) {
-                    yield { type: "reasoning", text: contentBuffer.slice(0, endIdx) };
-                    contentBuffer = contentBuffer.slice(endIdx + 8);
-                    thinkingMode = "none";
-                    continue;
-                  }
-                  if (contentBuffer.length > 8) {
-                    yield { type: "reasoning", text: contentBuffer.slice(0, -8) };
-                    contentBuffer = contentBuffer.slice(-8);
-                  }
-                  break;
-                } else if (thinkingMode === "markdown_thinking") {
-                  if (contentBuffer.startsWith(">")) {
-                    thinkingMode = "markdown_quote";
-                    continue;
-                  }
-                  if (contentBuffer.length > 0 && !contentBuffer.startsWith(">")) {
-                    thinkingMode = "none";
-                    continue;
-                  }
-                  break;
-                } else if (thinkingMode === "markdown_quote") {
-                  const newlineIdx = contentBuffer.indexOf("\n");
-                  if (newlineIdx !== -1) {
-                    const quoteLine = contentBuffer.slice(0, newlineIdx);
-                    contentBuffer = contentBuffer.slice(newlineIdx + 1);
-                    if (quoteLine.startsWith(">")) {
-                      const thinkText = quoteLine.replace(/^>\s?/, "");
-                      yield { type: "reasoning", text: thinkText + "\n" };
-                      continue;
-                    }
-                    if (quoteLine.trim() === "") {
-                      yield { type: "reasoning", text: "\n" };
-                      continue;
-                    }
-                    thinkingMode = "none";
-                    yield { type: "content", text: quoteLine + "\n" };
-                    continue;
-                  }
-                  break;
-                }
-              }
-            }
-          } catch {
-          }
-        }
-      }
-      if (contentBuffer.length > 0) {
-        if (thinkingMode === "think_tag" || thinkingMode === "markdown_quote") {
-          yield { type: "reasoning", text: contentBuffer };
-        } else {
-          yield { type: "content", text: contentBuffer };
-        }
-      }
-    } finally {
-      reader.releaseLock();
+    return this.executeNonStreamRequest(adapter, client, chatOptions);
+  }
+  /**
+   * 执行非流式请求
+   * @param adapter - Provider 适配器
+   * @param client - Provider 客户端
+   * @param chatOptions - 聊天选项
+   * @returns 响应内容
+   */
+  async executeNonStreamRequest(adapter, client, chatOptions) {
+    const baseUrl = this.config.baseUrl ?? adapter.defaultBaseUrl;
+    const endpoint = adapter.getEndpointUrl(baseUrl);
+    const endpointPath = endpoint.replace(baseUrl, "");
+    const body = adapter.buildChatRequest(chatOptions, false);
+    const response = await client.chat(endpointPath, body);
+    const result = adapter.parseChatResponse(response, this.config.model);
+    return result.content;
+  }
+  /**
+   * 执行流式请求
+   * @param adapter - Provider 适配器
+   * @param client - Provider 客户端
+   * @param chatOptions - 聊天选项
+   * @returns 流式数据块生成器
+   */
+  async *executeStreamRequest(adapter, client, chatOptions) {
+    const baseUrl = this.config.baseUrl ?? adapter.defaultBaseUrl;
+    const endpoint = adapter.getEndpointUrl(baseUrl);
+    const endpointPath = endpoint.replace(baseUrl, "");
+    const body = adapter.buildChatRequest(chatOptions, true);
+    const response = await client.chatStream(endpointPath, body);
+    const { StreamProcessor: StreamProcessor2 } = (init_stream_processor(), __toCommonJS(stream_processor_exports));
+    yield* StreamProcessor2.processStream(
+      response,
+      (delta) => adapter.extractStreamChunk(delta)
+    );
+  }
+  /**
+   * 验证配置是否完整
+   * @throws ConfigurationError 如果缺少必需参数
+   */
+  validateConfig() {
+    if (!this.config.provider) {
+      throw new ConfigurationError("\u8BF7\u5148\u8C03\u7528 use(provider) \u9009\u62E9\u670D\u52A1\u63D0\u4F9B\u5546");
+    }
+    if (!this.config.model) {
+      throw new ConfigurationError("\u8BF7\u5148\u8C03\u7528 model(modelId) \u6307\u5B9A\u6A21\u578B");
+    }
+    if (!this.config.apiKey) {
+      throw new ConfigurationError(
+        "\u8BF7\u5148\u914D\u7F6E API Key\uFF1A\u8C03\u7528 key(apiKey) \u6216\u901A\u8FC7\u9884\u8BBE\u5B9E\u4F8B\u914D\u7F6E"
+      );
     }
   }
-};
-
-// src/providers/nova.ts
-var BASE_URL7 = "https://api.nova.amazon.com/v1";
-function extractTextContent8(content) {
-  if (typeof content === "string") {
-    return content;
+  /**
+   * 获取当前配置（用于测试）
+   * @returns 当前配置的副本
+   */
+  getConfig() {
+    return { ...this.config };
   }
-  if (Array.isArray(content)) {
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && item.type === "text" && typeof item.text === "string"
-    ).map((item) => item.text).join("");
+  /**
+   * 克隆构建器（用于创建新实例）
+   * @returns 新的构建器实例
+   */
+  clone() {
+    return new _OiiaiBuilderImpl({ ...this.config });
   }
-  return "";
+};
+function createBuilder(initialConfig) {
+  return new OiiaiBuilderImpl(initialConfig);
 }
-var NovaProvider = class extends BaseProvider {
-  name = "nova";
-  apiKey;
-  baseUrl;
-  constructor(config) {
-    super();
-    if (typeof config === "string") {
-      this.apiKey = config;
-      this.baseUrl = BASE_URL7;
-    } else {
-      this.apiKey = config.apiKey;
-      this.baseUrl = config.baseUrl ?? BASE_URL7;
+var oiiai = new Proxy({}, {
+  get(_target, prop) {
+    const builder = new OiiaiBuilderImpl();
+    const value = builder[prop];
+    if (typeof value === "function") {
+      return value.bind(builder);
     }
+    return value;
   }
+});
+
+// src/fluent/preset-provider.ts
+var PresetProviderImpl = class _PresetProviderImpl {
+  /** Provider 名称 */
+  name;
+  /** 内部配置状态 */
+  config = {};
+  /** 环境变量名称映射 */
+  static ENV_KEY_MAP = {
+    deepseek: "DEEPSEEK_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+    gemini: "GEMINI_API_KEY",
+    groq: "GROQ_API_KEY",
+    huggingface: "HUGGINGFACE_API_KEY",
+    modelscope: "MODELSCOPE_API_KEY",
+    poe: "POE_API_KEY",
+    nova: "NOVA_API_KEY"
+  };
   /**
-   * 发送聊天请求（非流式）
-   *
-   * 注意：
-   * - Nova API 的 temperature 范围是 0-1（不是 0-2）
-   * - Nova 2 Lite 支持 extended thinking (reasoningConfig)
-   * - effort 映射为 maxReasoningEffort
+   * 创建预设实例
+   * @param providerType - Provider 类型
    */
-  async chat(options) {
-    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
-    const body = {
-      model,
-      messages,
-      temperature,
-      stream: false
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
+  constructor(providerType) {
+    if (!ProviderRegistry.hasAdapter(providerType)) {
+      const supported = ProviderRegistry.listSupported();
+      throw new ValidationError(
+        `\u4E0D\u652F\u6301\u7684 Provider: ${providerType}\uFF0C\u652F\u6301\u7684 Provider: ${supported.join(", ")}`
+      );
     }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoningConfig = {
-        type: "enabled",
-        maxReasoningEffort: reasoning.effort
-        // low/medium/high
-      };
+    this.name = providerType;
+  }
+  /**
+   * 配置 API Key 和其他选项
+   * @param options - 配置选项
+   * @returns this 支持链式调用
+   */
+  configure(options) {
+    this.config.apiKey = options.apiKey;
+    if (options.baseUrl) {
+      this.config.baseUrl = options.baseUrl;
     }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Nova API error: ${response.status} ${error}`);
+    return this;
+  }
+  /**
+   * 从环境变量读取配置
+   * 环境变量名格式: {PROVIDER}_API_KEY (如 DEEPSEEK_API_KEY)
+   * @returns this 支持链式调用
+   */
+  fromEnv() {
+    const envKey = _PresetProviderImpl.ENV_KEY_MAP[this.name];
+    const apiKey = process.env[envKey];
+    if (!apiKey) {
+      throw new ConfigurationError(`\u73AF\u5883\u53D8\u91CF ${envKey} \u672A\u8BBE\u7F6E`);
     }
-    const result = await response.json();
-    const choice = result.choices?.[0];
-    if (!choice) {
-      throw new Error("No response from model");
+    this.config.apiKey = apiKey;
+    return this;
+  }
+  /**
+   * 简单问答（非流式）
+   * @param model - 模型 ID
+   * @param question - 问题
+   * @param options - 可选配置
+   * @returns 响应内容
+   */
+  async ask(model, question, options) {
+    this.validateApiKey();
+    const builder = this.createConfiguredBuilder(model, options);
+    const result = builder.ask(question);
+    return result;
+  }
+  /**
+   * 流式问答
+   * @param model - 模型 ID
+   * @param question - 问题
+   * @param options - 可选配置
+   * @returns 流式数据块生成器
+   */
+  async *stream(model, question, options) {
+    this.validateApiKey();
+    const builder = this.createConfiguredBuilder(model, options);
+    const streamBuilder = builder.stream();
+    yield* streamBuilder.ask(question);
+  }
+  /**
+   * 带回调的流式问答
+   * @param model - 模型 ID
+   * @param question - 问题
+   * @param callbacks - 回调函数
+   * @returns Promise，完成时 resolve
+   */
+  async streamWithCallbacks(model, question, callbacks) {
+    this.validateApiKey();
+    let reasoningContent = "";
+    let contentText = "";
+    const builder = this.createConfiguredBuilder(model);
+    const streamBuilder = builder.stream();
+    for await (const chunk of streamBuilder.ask(question)) {
+      if (chunk.type === "reasoning") {
+        reasoningContent += chunk.text;
+        callbacks.onReasoning?.(chunk.text);
+      } else if (chunk.type === "content") {
+        contentText += chunk.text;
+        callbacks.onContent?.(chunk.text);
+      }
     }
-    const msg = choice.message;
-    const reasoningContent = msg?.reasoning_content ?? null;
-    return {
-      content: extractTextContent8(msg?.content),
-      reasoning: reasoningContent ? extractTextContent8(reasoningContent) : null,
-      model: result.model ?? model,
-      usage: {
-        promptTokens: result.usage?.prompt_tokens ?? 0,
-        completionTokens: result.usage?.completion_tokens ?? 0,
-        totalTokens: result.usage?.total_tokens ?? 0
-      },
-      finishReason: choice.finish_reason ?? null
-    };
+    callbacks.onDone?.({
+      reasoning: reasoningContent,
+      content: contentText
+    });
   }
   /**
-   * 发送流式聊天请求
+   * 获取构建器（预配置 provider 和 model）
+   * @param model - 模型 ID
+   * @returns 预配置的构建器
    */
-  async *chatStream(options) {
-    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
-    const body = {
+  builder(model) {
+    this.validateApiKey();
+    const adapter = ProviderRegistry.getAdapter(this.name);
+    const builder = new OiiaiBuilderImpl({
+      provider: this.name,
       model,
-      messages,
-      temperature,
-      stream: true
-    };
-    if (maxTokens) {
-      body.max_tokens = maxTokens;
-    }
-    if (reasoning?.effort && reasoning.effort !== "off") {
-      body.reasoningConfig = {
-        type: "enabled",
-        maxReasoningEffort: reasoning.effort
-      };
+      apiKey: this.config.apiKey,
+      baseUrl: this.config.baseUrl ?? adapter.defaultBaseUrl
+    });
+    return builder;
+  }
+  /**
+   * 创建多轮对话会话
+   * @param model - 模型 ID
+   * @param options - 会话配置
+   * @returns 对话会话实例
+   */
+  chat(model, options) {
+    this.validateApiKey();
+    const { ChatSessionImpl: ChatSessionImpl2 } = (init_chat_session(), __toCommonJS(chat_session_exports));
+    return new ChatSessionImpl2(this, model, options);
+  }
+  /**
+   * 验证 API Key 是否已配置
+   * @throws ConfigurationError 如果未配置 API Key
+   */
+  validateApiKey() {
+    if (!this.config.apiKey) {
+      throw new ConfigurationError(
+        `\u8BF7\u5148\u914D\u7F6E API Key\uFF1A\u8C03\u7528 configure({ apiKey: 'xxx' }) \u6216 fromEnv()`
+      );
     }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify(body)
+  }
+  /**
+   * 创建已配置的构建器
+   * @param model - 模型 ID
+   * @param options - 可选配置
+   * @returns 配置好的构建器
+   */
+  createConfiguredBuilder(model, options) {
+    const adapter = ProviderRegistry.getAdapter(this.name);
+    const builder = new OiiaiBuilderImpl({
+      provider: this.name,
+      model,
+      apiKey: this.config.apiKey,
+      baseUrl: this.config.baseUrl ?? adapter.defaultBaseUrl
     });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Nova API error: ${response.status} ${error}`);
+    if (options?.system) {
+      builder.system(options.system);
     }
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("No response body");
+    if (options?.temperature !== void 0) {
+      builder.temperature(options.temperature);
     }
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-          if (!trimmed.startsWith("data: ")) continue;
-          try {
-            const data = JSON.parse(trimmed.slice(6));
-            const delta = data.choices?.[0]?.delta;
-            if (!delta) continue;
-            if (delta.reasoning_content) {
-              yield {
-                type: "reasoning",
-                text: extractTextContent8(delta.reasoning_content)
-              };
-            }
-            if (delta.content) {
-              yield {
-                type: "content",
-                text: extractTextContent8(delta.content)
-              };
-            }
-          } catch {
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
+    if (options?.maxTokens !== void 0) {
+      builder.maxTokens(options.maxTokens);
+    }
+    if (options?.reasoning) {
+      builder.reasoning(options.reasoning);
     }
+    return builder;
   }
-};
-
-// src/providers/__factory__.ts
-function createProvider(config) {
-  const { provider, apiKey, baseUrl } = config;
-  switch (provider) {
-    case "openrouter":
-      return new OpenRouterProvider(apiKey);
-    case "gemini":
-      return new GeminiProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    case "groq":
-      return new GroqProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    case "huggingface":
-      return new HuggingFaceProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    case "modelscope":
-      return new ModelScopeProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    case "deepseek":
-      return new DeepSeekProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    case "poe":
-      return new PoeProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    case "nova":
-      return new NovaProvider(baseUrl ? { apiKey, baseUrl } : apiKey);
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
+  /**
+   * 获取当前配置（用于测试）
+   * @returns 当前配置的副本
+   */
+  getConfig() {
+    return { ...this.config };
   }
-}
-var ai = {
-  openrouter: (apiKey, baseUrl) => createProvider({ provider: "openrouter", apiKey, baseUrl }),
-  gemini: (apiKey, baseUrl) => createProvider({ provider: "gemini", apiKey, baseUrl }),
-  groq: (apiKey, baseUrl) => createProvider({ provider: "groq", apiKey, baseUrl }),
-  huggingface: (apiKey, baseUrl) => createProvider({ provider: "huggingface", apiKey, baseUrl }),
-  modelscope: (apiKey, baseUrl) => createProvider({ provider: "modelscope", apiKey, baseUrl }),
-  deepseek: (apiKey, baseUrl) => createProvider({ provider: "deepseek", apiKey, baseUrl }),
-  poe: (apiKey, baseUrl) => createProvider({ provider: "poe", apiKey, baseUrl }),
-  nova: (apiKey, baseUrl) => createProvider({ provider: "nova", apiKey, baseUrl })
 };
+
+// src/fluent/index.ts
+init_chat_session();
+
+// src/fluent/preset-instances.ts
+var deepseek = new PresetProviderImpl("deepseek");
+var openrouter = new PresetProviderImpl("openrouter");
+var gemini = new PresetProviderImpl("gemini");
+var groq = new PresetProviderImpl("groq");
+var huggingface = new PresetProviderImpl(
+  "huggingface"
+);
+var modelscope = new PresetProviderImpl("modelscope");
+var poe = new PresetProviderImpl("poe");
+var nova = new PresetProviderImpl("nova");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APIError,
+  BaseAdapter,
   BaseProvider,
+  CONFIG_DEFAULTS,
+  ConfigManager,
+  ConfigValidator,
+  ConfigurationError,
+  DeepSeekAdapter,
   EFFORT_TOKEN_MAP,
+  FluentValidationError,
+  GeminiAdapter,
   GeminiProvider,
+  GroqAdapter,
   GroqProvider,
+  HttpProviderClient,
+  HuggingFaceAdapter,
   HuggingFaceProvider,
+  ModelScopeAdapter,
   ModelScopeProvider,
+  NetworkError,
+  NovaAdapter,
+  OpenRouterAdapter,
   OpenRouterProvider,
+  PoeAdapter,
+  ProviderError,
+  ProviderRegistry,
+  RegistryError,
+  RequestBuilder,
+  StreamProcessor,
+  TimeoutError,
+  VALID_PROVIDERS,
   ai,
-  createProvider
+  createBuilder,
+  createBuiltInAdapters,
+  createProvider,
+  deepseek,
+  gemini,
+  groq,
+  huggingface,
+  modelscope,
+  nova,
+  oiiai,
+  openrouter,
+  poe
 });
 //# sourceMappingURL=index.js.map