@weisiren000/oiiai 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -1,34 +1,369 @@
 // src/providers/openrouter.ts
 import { OpenRouter } from "@openrouter/sdk";
 
+// src/providers/__model-detection__.ts
+var THINKING_MODEL_PATTERNS = [
+  // 明确的思考/推理标识
+  /[-_]think(?:ing)?(?:[-_:]|$)/i,
+  // *-think, *-thinking
+  /[-_]reason(?:ing)?(?:[-_:]|$)/i,
+  // *-reason, *-reasoning
+  /[-_]cot(?:[-_:]|$)/i,
+  // chain-of-thought
+  /[-_]reflect(?:ion)?(?:[-_:]|$)/i,
+  // reflection models
+  // 知名推理模型系列
+  /\bo1[-_]?/i,
+  // OpenAI o1 系列
+  /\bo3[-_]?/i,
+  // OpenAI o3 系列
+  /\br1[-_]?/i,
+  // DeepSeek R1 等
+  /\bqwq\b/i,
+  // Qwen QwQ
+  /\bn1[-_]?/i,
+  // nex-n1 等
+  // 通用思考关键词（较低优先级）
+  /think/i
+  // 包含 think
+];
+var DIRECT_ANSWER_PATTERNS = [
+  /[-_]chat$/i,
+  // *-chat (结尾)
+  /[-_]instruct/i,
+  // *-instruct
+  /[-_]turbo/i,
+  // *-turbo
+  /[-_]flash/i,
+  // gemini-flash 等快速模型
+  /[-_]lite[-_v]/i,
+  // lite 版本（但不匹配 lite 结尾，避免误判）
+  /[-_]fast/i
+  // fast 模型
+];
+var PROBLEMATIC_MODEL_PATTERNS = [
+  /nova[-_]?\d*[-_]lite/i
+  // Amazon Nova Lite 系列
+];
+function isProblematicModel(modelId) {
+  return PROBLEMATIC_MODEL_PATTERNS.some((pattern) => pattern.test(modelId));
+}
+function detectByModelName(modelId) {
+  const normalizedId = modelId.toLowerCase();
+  const isThinkingPattern = THINKING_MODEL_PATTERNS.some(
+    (pattern) => pattern.test(normalizedId)
+  );
+  const isDirectPattern = DIRECT_ANSWER_PATTERNS.some(
+    (pattern) => pattern.test(normalizedId)
+  );
+  const isProblematic = isProblematicModel(normalizedId);
+  if (isThinkingPattern) {
+    return {
+      behavior: "thinking-first",
+      supportsReasoningConfig: true,
+      recommendedMinTokens: 500,
+      confidence: 0.7,
+      detectedBy: "pattern"
+    };
+  }
+  if (isDirectPattern) {
+    return {
+      behavior: "direct-answer",
+      supportsReasoningConfig: false,
+      // 问题模型需要更多 token
+      recommendedMinTokens: isProblematic ? 300 : 100,
+      confidence: 0.6,
+      detectedBy: "pattern"
+    };
+  }
+  return {
+    behavior: "unknown",
+    supportsReasoningConfig: false,
+    recommendedMinTokens: isProblematic ? 300 : 200,
+    confidence: 0.3,
+    detectedBy: "pattern"
+  };
+}
+var modelCharacteristicsCache = /* @__PURE__ */ new Map();
+function detectByResponse(modelId, result) {
+  const hasReasoning = !!result.reasoning && result.reasoning.length > 0;
+  const hasContent = !!result.content && result.content.trim().length > 0;
+  const reasoningLength = result.reasoning?.length ?? 0;
+  const contentLength = result.content?.length ?? 0;
+  let behavior;
+  let supportsReasoningConfig = false;
+  let recommendedMinTokens = 200;
+  if (hasReasoning && !hasContent) {
+    behavior = "thinking-first";
+    supportsReasoningConfig = true;
+    recommendedMinTokens = Math.max(500, reasoningLength + 200);
+  } else if (hasReasoning && hasContent) {
+    if (reasoningLength > contentLength * 2) {
+      behavior = "thinking-first";
+      supportsReasoningConfig = true;
+      recommendedMinTokens = 500;
+    } else {
+      behavior = "hybrid";
+      supportsReasoningConfig = true;
+      recommendedMinTokens = 300;
+    }
+  } else if (hasContent && !hasReasoning) {
+    behavior = "direct-answer";
+    supportsReasoningConfig = false;
+    recommendedMinTokens = 100;
+  } else {
+    behavior = "unknown";
+    recommendedMinTokens = 500;
+  }
+  const characteristics = {
+    behavior,
+    supportsReasoningConfig,
+    recommendedMinTokens,
+    confidence: 0.9,
+    detectedBy: "runtime"
+  };
+  modelCharacteristicsCache.set(modelId, characteristics);
+  return characteristics;
+}
+function getModelCharacteristics(modelId) {
+  const cached = modelCharacteristicsCache.get(modelId);
+  if (cached) {
+    return { ...cached, detectedBy: "cache" };
+  }
+  return detectByModelName(modelId);
+}
+var DEFAULT_FALLBACK_CONFIG = {
+  enabled: true,
+  returnReasoningAsContent: true,
+  extractConclusionFromReasoning: true,
+  autoRetryWithMoreTokens: false,
+  // 默认关闭自动重试，避免额外消耗
+  retryTokenIncrement: 300,
+  maxRetries: 2
+};
+function extractConclusionFromReasoning(reasoning) {
+  if (!reasoning) return null;
+  const conclusionPatterns = [
+    /(?:therefore|thus|so|hence|finally|in conclusion|the answer is|result is)[:\s]*(.+?)(?:\n|$)/i,
+    /(?:答案是|结论是|因此|所以|最终)[：:\s]*(.+?)(?:\n|$)/,
+    /(?:\*\*answer\*\*|\*\*result\*\*)[:\s]*(.+?)(?:\n|$)/i,
+    /=\s*(.+?)(?:\n|$)/
+    // 数学等式结果
+  ];
+  for (const pattern of conclusionPatterns) {
+    const match = reasoning.match(pattern);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  const paragraphs = reasoning.split(/\n\n+/).filter((p) => p.trim());
+  if (paragraphs.length > 0) {
+    const lastParagraph = paragraphs[paragraphs.length - 1].trim();
+    if (lastParagraph.length < 500) {
+      return lastParagraph;
+    }
+  }
+  return null;
+}
+function applyFallbackStrategy(result, config = {}) {
+  const finalConfig = { ...DEFAULT_FALLBACK_CONFIG, ...config };
+  if (result.content && result.content.trim().length > 0) {
+    return {
+      content: result.content,
+      didFallback: false,
+      originalReasoning: result.reasoning
+    };
+  }
+  if (!finalConfig.enabled) {
+    return {
+      content: "",
+      didFallback: false,
+      originalReasoning: result.reasoning
+    };
+  }
+  if (finalConfig.extractConclusionFromReasoning && result.reasoning) {
+    const conclusion = extractConclusionFromReasoning(result.reasoning);
+    if (conclusion) {
+      return {
+        content: conclusion,
+        didFallback: true,
+        fallbackReason: "extracted_conclusion_from_reasoning",
+        originalReasoning: result.reasoning
+      };
+    }
+  }
+  if (finalConfig.returnReasoningAsContent && result.reasoning) {
+    return {
+      content: result.reasoning,
+      didFallback: true,
+      fallbackReason: "returned_reasoning_as_content",
+      originalReasoning: result.reasoning
+    };
+  }
+  return {
+    content: "",
+    didFallback: false,
+    fallbackReason: "no_fallback_available",
+    originalReasoning: result.reasoning
+  };
+}
+function adjustOptionsForModel(modelId, options) {
+  const characteristics = getModelCharacteristics(modelId);
+  if (characteristics.behavior === "thinking-first" && (!options.maxTokens || options.maxTokens < characteristics.recommendedMinTokens)) {
+    return {
+      ...options,
+      maxTokens: Math.max(
+        options.maxTokens ?? 0,
+        characteristics.recommendedMinTokens
+      )
+    };
+  }
+  return options;
+}
+function getRecommendedConfig(modelId, scenario = "simple") {
+  const characteristics = getModelCharacteristics(modelId);
+  if (characteristics.behavior !== "thinking-first") {
+    return {};
+  }
+  const configs = {
+    simple: {
+      maxTokens: 300,
+      reasoning: { effort: "low" }
+    },
+    math: {
+      maxTokens: 600,
+      reasoning: { effort: "high" }
+    },
+    reasoning: {
+      maxTokens: 800,
+      reasoning: { effort: "medium" }
+    },
+    fast: {
+      maxTokens: 200,
+      reasoning: { effort: "off" }
+    }
+  };
+  return configs[scenario] ?? configs.simple;
+}
+var ModelDetection = {
+  detectByModelName,
+  detectByResponse,
+  getModelCharacteristics,
+  applyFallbackStrategy,
+  adjustOptionsForModel,
+  getRecommendedConfig,
+  extractConclusionFromReasoning,
+  isProblematicModel,
+  clearCache: () => modelCharacteristicsCache.clear()
+};
+
 // src/providers/__base__.ts
 var BaseProvider = class {
+  /** 降级策略配置 */
+  fallbackConfig = DEFAULT_FALLBACK_CONFIG;
+  /** 是否启用自动参数调整 */
+  autoAdjustEnabled = true;
+  /**
+   * 配置降级策略
+   */
+  configureFallback(config) {
+    this.fallbackConfig = { ...this.fallbackConfig, ...config };
+    return this;
+  }
+  /**
+   * 启用/禁用自动参数调整
+   */
+  setAutoAdjust(enabled) {
+    this.autoAdjustEnabled = enabled;
+    return this;
+  }
+  /**
+   * 获取模型特性信息
+   */
+  getModelCharacteristics(modelId) {
+    return ModelDetection.getModelCharacteristics(modelId);
+  }
+  /**
+   * 智能聊天：自动检测模型特性并应用降级策略
+   */
+  async chatSmart(options) {
+    const adjustedOptions = this.autoAdjustEnabled ? ModelDetection.adjustOptionsForModel(options.model, options) : options;
+    const result = await this.chat(adjustedOptions);
+    ModelDetection.detectByResponse(options.model, result);
+    return result;
+  }
   /**
    * 简单对话：单轮问答（默认实现）
-   * 对于思考模型，如果 content 为空则返回 reasoning
+   *
+   * 智能处理思考模型：
+   * 1. 自动检测模型类型
+   * 2. 为思考模型自动调整 maxTokens
+   * 3. 如果 content 为空，智能降级（提取结论或返回 reasoning）
    */
   async ask(model, question, options) {
-    const result = await this.chat({
+    const { fallback, autoAdjust = this.autoAdjustEnabled, ...chatOptions } = options ?? {};
+    let finalOptions = {
       model,
       messages: [{ role: "user", content: question }],
-      ...options
+      ...chatOptions
+    };
+    if (autoAdjust) {
+      finalOptions = ModelDetection.adjustOptionsForModel(model, finalOptions);
+    }
+    const result = await this.chat(finalOptions);
+    ModelDetection.detectByResponse(model, result);
+    const fallbackResult = ModelDetection.applyFallbackStrategy(result, {
+      ...this.fallbackConfig,
+      ...fallback
     });
-    return result.content || result.reasoning || "";
+    return fallbackResult.content;
   }
   /**
    * 带系统提示的对话（默认实现）
-   * 对于思考模型，如果 content 为空则返回 reasoning
+   *
+   * 智能处理思考模型：
+   * 1. 自动检测模型类型
+   * 2. 为思考模型自动调整 maxTokens
+   * 3. 如果 content 为空，智能降级（提取结论或返回 reasoning）
    */
   async askWithSystem(model, systemPrompt, userMessage, options) {
-    const result = await this.chat({
+    const { fallback, autoAdjust = this.autoAdjustEnabled, ...chatOptions } = options ?? {};
+    let finalOptions = {
       model,
       messages: [
         { role: "system", content: systemPrompt },
         { role: "user", content: userMessage }
       ],
+      ...chatOptions
+    };
+    if (autoAdjust) {
+      finalOptions = ModelDetection.adjustOptionsForModel(model, finalOptions);
+    }
+    const result = await this.chat(finalOptions);
+    ModelDetection.detectByResponse(model, result);
+    const fallbackResult = ModelDetection.applyFallbackStrategy(result, {
+      ...this.fallbackConfig,
+      ...fallback
+    });
+    return fallbackResult.content;
+  }
+  /**
+   * 场景化问答：根据场景自动配置参数
+   *
+   * @param model 模型 ID
+   * @param question 问题
+   * @param scenario 场景类型
+   *   - 'simple': 简单问答（默认）
+   *   - 'math': 数学计算
+   *   - 'reasoning': 逻辑推理
+   *   - 'fast': 快速回答（关闭思考）
+   */
+  async askWithScenario(model, question, scenario = "simple", options) {
+    const recommendedConfig = ModelDetection.getRecommendedConfig(model, scenario);
+    return this.ask(model, question, {
+      ...recommendedConfig,
       ...options
     });
-    return result.content || result.reasoning || "";
   }
 };
 
@@ -527,9 +862,13 @@ var HuggingFaceProvider = class extends BaseProvider {
   }
   /**
    * 发送聊天请求（非流式）
+   *
+   * reasoning 参数说明：
+   * - HuggingFace 是模型聚合平台，thinking 支持取决于具体模型
+   * - 如果模型支持，会返回 reasoning_content
    */
   async chat(options) {
-    const { model, messages, temperature = 0.7, maxTokens } = options;
+    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
     const body = {
       model,
       messages,
@@ -539,6 +878,9 @@ var HuggingFaceProvider = class extends BaseProvider {
     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: {
@@ -574,7 +916,7 @@ var HuggingFaceProvider = class extends BaseProvider {
    * 发送流式聊天请求
    */
   async *chatStream(options) {
-    const { model, messages, temperature = 0.7, maxTokens } = options;
+    const { model, messages, temperature = 0.7, maxTokens, reasoning } = options;
     const body = {
       model,
       messages,
@@ -584,6 +926,9 @@ var HuggingFaceProvider = class extends BaseProvider {
     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: {
@@ -808,18 +1153,6 @@ var ModelScopeProvider = class extends BaseProvider {
 
 // src/providers/deepseek.ts
 var BASE_URL5 = "https://api.deepseek.com";
-function getReasoningMaxTokens(reasoning, userMaxTokens) {
-  if (!reasoning || reasoning.effort === "off") {
-    return userMaxTokens;
-  }
-  if (reasoning.budgetTokens !== void 0) {
-    return reasoning.budgetTokens;
-  }
-  if (reasoning.effort) {
-    return EFFORT_TOKEN_MAP[reasoning.effort];
-  }
-  return userMaxTokens;
-}
 function extractTextContent6(content) {
   if (typeof content === "string") {
     return content;
@@ -847,6 +1180,10 @@ var DeepSeekProvider = class extends BaseProvider {
   }
   /**
    * 发送聊天请求（非流式）
+   *
+   * reasoning 参数说明：
+   * - effort 不为 'off' 时启用 thinking 模式
+   * - maxTokens 独立控制输出长度，不受 effort 影响
    */
   async chat(options) {
     const {
@@ -856,15 +1193,14 @@ var DeepSeekProvider = class extends BaseProvider {
       maxTokens,
       reasoning
     } = options;
-    const effectiveMaxTokens = getReasoningMaxTokens(reasoning, maxTokens);
     const body = {
       model,
       messages,
       temperature,
       stream: false
     };
-    if (effectiveMaxTokens) {
-      body.max_tokens = effectiveMaxTokens;
+    if (maxTokens) {
+      body.max_tokens = maxTokens;
     }
     if (reasoning?.effort && reasoning.effort !== "off") {
       body.thinking = { type: "enabled" };
@@ -911,15 +1247,14 @@ var DeepSeekProvider = class extends BaseProvider {
       maxTokens,
       reasoning
     } = options;
-    const effectiveMaxTokens = getReasoningMaxTokens(reasoning, maxTokens);
     const body = {
       model,
       messages,
       temperature,
       stream: true
     };
-    if (effectiveMaxTokens) {
-      body.max_tokens = effectiveMaxTokens;
+    if (maxTokens) {
+      body.max_tokens = maxTokens;
     }
     if (reasoning?.effort && reasoning.effort !== "off") {
       body.thinking = { type: "enabled" };
@@ -979,6 +1314,432 @@ var DeepSeekProvider = class extends BaseProvider {
   }
 };
 
+// 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;
+  }
+  const extraBody = {};
+  if (reasoning.effort) {
+    extraBody.reasoning_effort = reasoning.effort;
+  }
+  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];
+  }
+  return Object.keys(extraBody).length > 0 ? extraBody : void 0;
+}
+var PoeProvider = class extends BaseProvider {
+  name = "poe";
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    super();
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.baseUrl = BASE_URL6;
+    } else {
+      this.apiKey = config.apiKey;
+      this.baseUrl = config.baseUrl ?? BASE_URL6;
+    }
+  }
+  /**
+   * 发送聊天请求（非流式）
+   */
+  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
+    };
+  }
+  /**
+   * 发送流式聊天请求
+   */
+  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 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 reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    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();
+    }
+  }
+};
+
+// src/providers/nova.ts
+var BASE_URL7 = "https://api.nova.amazon.com/v1";
+function extractTextContent8(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 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;
+    }
+  }
+  /**
+   * 发送聊天请求（非流式）
+   *
+   * 注意：
+   * - Nova API 的 temperature 范围是 0-1（不是 0-2）
+   * - Nova 2 Lite 支持 extended thinking (reasoningConfig)
+   * - effort 映射为 maxReasoningEffort
+   */
+  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.reasoningConfig = {
+        type: "enabled",
+        maxReasoningEffort: reasoning.effort
+        // low/medium/high
+      };
+    }
+    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}`);
+    }
+    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: 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
+    };
+  }
+  /**
+   * 发送流式聊天请求
+   */
+  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.reasoningConfig = {
+        type: "enabled",
+        maxReasoningEffort: 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(`Nova 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: extractTextContent8(delta.reasoning_content)
+              };
+            }
+            if (delta.content) {
+              yield {
+                type: "content",
+                text: extractTextContent8(delta.content)
+              };
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
 // src/providers/__factory__.ts
 function createProvider(config) {
   const { provider, apiKey, baseUrl } = config;
@@ -995,6 +1756,10 @@ function createProvider(config) {
       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}`);
   }
@@ -1005,7 +1770,9 @@ var ai = {
   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 })
+  deepseek: (apiKey, baseUrl) => createProvider({ provider: "deepseek", apiKey, baseUrl }),
+  poe: (apiKey, baseUrl) => createProvider({ provider: "poe", apiKey, baseUrl }),
+  nova: (apiKey, baseUrl) => createProvider({ provider: "nova", apiKey, baseUrl })
 };
 export {
   BaseProvider,