@keo-ai/axiom 0.2.7 → 0.2.9

package/README.md

@@ -177,14 +177,17 @@ for await (const chunk of LLM.streamPredict({ model: 'qwen-max', prompt: '讲个
   if (chunk.type === 'reasoning') {
     process.stdout.write(chunk.delta);  // 推理过程
   }
-  if (chunk.type === 'finish' && chunk.usage) {
+  if (chunk.type === 'finish') {
+    console.log('Finish:', chunk.finishReason, chunk.sawDone);
     console.log('Token usage:', chunk.usage);
-    // { promptTokens, completionTokens, totalTokens, cachedPromptTokens? }
   }
 }
 ```
 
-> 💡 流式调用自动启用 `stream_options: { include_usage: true }`，`finish` 事件携带完整的 token 消耗统计。usage 可能与 `finish_reason` 在同一个 SSE chunk，也可能在独立的 chunk（`choices: []`）中返回，两种情况均已兼容。
+> 💡 流式调用自动启用 `stream_options: { include_usage: true }`。`finish` 事件会返回 `finishReason`、
+> `sawDone`、`sawFinishReason` 和 token 消耗统计。usage 可能与 `finish_reason` 在同一个 SSE chunk，也可能在独立的
+> chunk（`choices: []`）中返回，两种情况均已兼容。若连接结束前既没有 `[DONE]` 也没有非空
+> `finish_reason`，流会抛出异常，避免把提前 EOF 当作成功响应。
 
 ### 模型列表
 
@@ -194,16 +197,21 @@ for await (const chunk of LLM.streamPredict({ model: 'qwen-max', prompt: '讲个
 |------|----------|-----------|------|
 | `qwen-max` | ❌ 不支持 | ✅ | **默认模型** |
 | `qwen3.7-max` | ✅ 映射支持 | ✅ | `low`/`medium`/`high` 映射为 `enable_thinking` |
+| `qwen3.7-flash` | ✅ 映射支持 | ✅ | 同上 |
 | `qwen-plus` | ✅ 映射支持 | ✅ | 同上 |
 | `qwen-turbo` | ✅ 映射支持 | ✅ | 同上 |
-| `deepseek-v4-pro` | ✅ 原生支持 | ✅ | `low`/`medium`/`high` 直接传递 |
-| `deepseek-v4-flash` | ✅ 原生支持 | ✅ | 同上 |
-| `kimi-k2.6` | ✅ 原生支持 | ✅ | 同上 |
+| `deepseek-v4-pro` | ✅ 映射支持 | ✅ | 同上（百炼走「混合思考模式」，由 `enable_thinking` 控制） |
+| `deepseek-v4-flash` | ✅ 映射支持 | ✅ | 同上 |
+| `kimi-k2.6` | ✅ 映射支持 | ✅ | `low`/`medium`/`high` 映射为 `extra_body.thinking.type` |
 | `qwq-plus` | ❌ 不支持 | ✅ | 固定推理行为，不可调节 |
 | `glm-5.1` | ❌ 不支持 | ❌ | 不支持推理参数，不支持 json 模式 |
 | `qwen-vl-plus` | ❌ 不支持 | ✅ | 视觉模型，不支持推理参数 |
 
-> 推理深度的支持方式由 Provider 内部维护。百炼 Provider 中，Qwen 系列通过 `extra_body.enable_thinking` 映射实现（`low` 关闭，`medium`/`high` 开启），DeepSeek / Kimi 则原生透传 `reasoning_effort`。
+> 推理深度的支持方式由 Provider 内部维护。百炼 Provider 中：
+> - Qwen 系列与 DeepSeek v4 系列均通过 `extra_body.enable_thinking` 映射实现（`low` 关闭，`medium`/`high` 开启）；
+> - Kimi 则通过 `extra_body.thinking.type` 映射（`low` 关闭，`medium`/`high` 开启）。
+>
+> 两种模式在百炼兼容接口下都退化为布尔开关，`medium` / `high` 之间的差异无法体现。
 >
 > 目前所有模型均路由到百炼 Provider。后续接入其他厂商时，通过 `MODEL_REGISTRY` 扩展映射即可。
 

package/dist/llm_provider/bailian.js

@@ -56,10 +56,11 @@ class BailianProvider {
         if (((_b = body.response_format) === null || _b === void 0 ? void 0 : _b.type) === 'json_object' && !caps.jsonMode) {
             throw new Error(`[adapt] Model "${body.model}" does not support response_format json_object`);
         }
-        // 百炼平台：Qwen 系列通过 enable_thinking 实现 reasoning_effort
-        // Kimi（Moonshot）通过 extra_body.thinking.type 实现（默认开启）
+        // 百炼平台：Qwen 系列与 DeepSeek v4 系列均为「混合思考模式」，
+        // 通过 extra_body.enable_thinking 控制思考开关（low 关闭，medium/high 开启）；
+        // Kimi（Moonshot）则通过 extra_body.thinking.type 实现（默认开启）。
         if (body.reasoning_effort !== undefined) {
-            if (['qwen-plus', 'qwen-turbo', 'qwen3.7-max'].includes(body.model)) {
+            if (['qwen-plus', 'qwen-turbo', 'qwen3.8-flash', 'qwen3.7-max', 'qwen3.7-flash', 'deepseek-v4-pro', 'deepseek-v4-flash'].includes(body.model)) {
                 const { reasoning_effort } = body, rest = __rest(body, ["reasoning_effort"]);
                 return Object.assign(Object.assign({}, rest), { extra_body: Object.assign(Object.assign({}, ((_c = rest.extra_body) !== null && _c !== void 0 ? _c : {})), { enable_thinking: reasoning_effort !== 'low' }) });
             }
@@ -69,7 +70,7 @@ class BailianProvider {
                 // 需要显式传 thinking.type：low 禁用，medium/high 显式开启
                 return Object.assign(Object.assign({}, rest), { extra_body: Object.assign(Object.assign({}, ((_d = rest.extra_body) !== null && _d !== void 0 ? _d : {})), { thinking: { type: reasoning_effort === 'low' ? 'disabled' : 'enabled' } }) });
             }
-            // deepseek-v4-pro / deepseek-v4-flash 原生支持 reasoning_effort，直接传递
+            // 其它不支持 reasoning_effort 的模型会由前面的能力校验抛异常
         }
         return body;
     }
@@ -108,7 +109,7 @@ class BailianProvider {
      */
     stream(request) {
         return __asyncGenerator(this, arguments, function* stream_1() {
-            var _a, _b, _c;
+            var _a;
             const url = `${this.config.baseUrl}/chat/completions`;
             const body = this.adaptRequest(Object.assign(Object.assign({}, this.buildRequestBody(request)), { stream: true, stream_options: { include_usage: true } }));
             let response;
@@ -139,6 +140,53 @@ class BailianProvider {
             // usage 可能与 finish_reason 在同一个 chunk，也可能在独立的 chunk（choices: []）中返回。
             // 统一在此收集，流结束后一次性 yield finish 事件。
             let streamUsage;
+            let finishReason;
+            let sawDone = false;
+            let sawFinishReason = false;
+            function* processSseLine(line) {
+                var _a, _b;
+                const trimmed = line.trim();
+                if (!trimmed || !trimmed.startsWith('data:'))
+                    return;
+                const data = trimmed.slice(5).trimStart();
+                if (!data)
+                    return;
+                if (data === '[DONE]') {
+                    sawDone = true;
+                    return;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch (cause) {
+                    const message = cause instanceof Error ? cause.message : String(cause);
+                    throw new Error(`[bailian] Malformed SSE JSON: ${message}`);
+                }
+                // 从任意 chunk 中收集 usage（包括 choices 为空的独立 usage chunk）
+                if (parsed.usage) {
+                    streamUsage = {
+                        promptTokens: parsed.usage.prompt_tokens,
+                        completionTokens: parsed.usage.completion_tokens,
+                        totalTokens: parsed.usage.total_tokens,
+                        cachedPromptTokens: (_a = parsed.usage.prompt_tokens_details) === null || _a === void 0 ? void 0 : _a.cached_tokens,
+                    };
+                }
+                const choice = (_b = parsed.choices) === null || _b === void 0 ? void 0 : _b[0];
+                if (!choice)
+                    return;
+                const delta = choice.delta;
+                if (delta.reasoning_content) {
+                    yield { type: 'reasoning', delta: delta.reasoning_content };
+                }
+                if (delta.content) {
+                    yield { type: 'content', delta: delta.content };
+                }
+                if (choice.finish_reason) {
+                    finishReason = choice.finish_reason;
+                    sawFinishReason = true;
+                }
+            }
             try {
                 while (true) {
                     const { done, value } = yield __await(reader.read());
@@ -148,41 +196,31 @@ class BailianProvider {
                     const lines = buffer.split('\n');
                     buffer = (_a = lines.pop()) !== null && _a !== void 0 ? _a : '';
                     for (const line of lines) {
-                        const trimmed = line.trim();
-                        if (!trimmed || !trimmed.startsWith('data: '))
-                            continue;
-                        const data = trimmed.slice(6);
-                        if (data === '[DONE]')
-                            continue;
-                        let parsed;
-                        try {
-                            parsed = JSON.parse(data);
-                        }
-                        catch (_d) {
-                            continue;
-                        }
-                        // 从任意 chunk 中收集 usage（包括 choices 为空的独立 usage chunk）
-                        if (parsed.usage) {
-                            streamUsage = {
-                                promptTokens: parsed.usage.prompt_tokens,
-                                completionTokens: parsed.usage.completion_tokens,
-                                totalTokens: parsed.usage.total_tokens,
-                                cachedPromptTokens: (_b = parsed.usage.prompt_tokens_details) === null || _b === void 0 ? void 0 : _b.cached_tokens,
-                            };
-                        }
-                        const choice = (_c = parsed.choices) === null || _c === void 0 ? void 0 : _c[0];
-                        if (!choice)
-                            continue;
-                        const delta = choice.delta;
-                        if (delta.reasoning_content) {
-                            yield yield __await({ type: 'reasoning', delta: delta.reasoning_content });
+                        for (const chunk of processSseLine(line)) {
+                            yield yield __await(chunk);
                         }
-                        if (delta.content) {
-                            yield yield __await({ type: 'content', delta: delta.content });
+                    }
+                }
+                // TextDecoder 的流式模式可能仍持有不完整的多字节字符；EOF 时必须 flush。
+                buffer += decoder.decode();
+                if (buffer) {
+                    const finalLines = buffer.split('\n');
+                    for (const line of finalLines) {
+                        for (const chunk of processSseLine(line)) {
+                            yield yield __await(chunk);
                         }
                     }
                 }
-                yield yield __await({ type: 'finish', usage: streamUsage });
+                if (!sawDone && !sawFinishReason) {
+                    throw new Error(`[${this.name}] SSE stream ended before [DONE] or finish_reason`);
+                }
+                yield yield __await({
+                    type: 'finish',
+                    finishReason,
+                    sawDone,
+                    sawFinishReason,
+                    usage: streamUsage,
+                });
             }
             finally {
                 reader.releaseLock();
@@ -211,7 +249,9 @@ class BailianProvider {
 }
 exports.BailianProvider = BailianProvider;
 BailianProvider.SUPPORTED_MODELS = new Set([
+    'qwen3.8-flash',
     'qwen3.7-max',
+    'qwen3.7-flash',
     'qwen-plus',
     'qwen-turbo',
     'qwq-plus',
@@ -223,10 +263,14 @@ BailianProvider.SUPPORTED_MODELS = new Set([
 ]);
 BailianProvider.MODEL_CAPABILITIES = {
     'qwen-max': { jsonMode: true, reasoningEffort: false },
+    'qwen3.8-flash': { jsonMode: true, reasoningEffort: true },
     'qwen3.7-max': { jsonMode: true, reasoningEffort: true },
+    'qwen3.7-flash': { jsonMode: true, reasoningEffort: true },
     'qwen-plus': { jsonMode: true, reasoningEffort: true },
     'qwen-turbo': { jsonMode: true, reasoningEffort: true },
     'qwq-plus': { jsonMode: true, reasoningEffort: false },
+    // DeepSeek v4 系列在百炼走「混合思考模式」：由 enable_thinking 控制开关，
+    // 通过 adaptRequest 映射为 extra_body.enable_thinking（与 Qwen 同一分支）。
     'deepseek-v4-pro': { jsonMode: true, reasoningEffort: true },
     'deepseek-v4-flash': { jsonMode: true, reasoningEffort: true },
     'kimi-k2.6': { jsonMode: true, reasoningEffort: true },

package/dist/llm_provider/models.d.ts

@@ -1,7 +1,7 @@
 /**
  * 支持的模型枚举。项目层通过此枚举选择模型，Axiom 内部路由到对应 Provider。
  */
-export type Model = 'qwen3.7-max' | 'qwen-plus' | 'qwen-turbo' | 'qwq-plus' | 'deepseek-v4-pro' | 'deepseek-v4-flash' | 'kimi-k2.6' | 'glm-5.1' | 'qwen-vl-plus';
+export type Model = 'qwen3.8-flash' | 'qwen3.7-max' | 'qwen3.7-flash' | 'qwen-plus' | 'qwen-turbo' | 'qwq-plus' | 'deepseek-v4-pro' | 'deepseek-v4-flash' | 'kimi-k2.6' | 'glm-5.1' | 'qwen-vl-plus';
 /** 模型到 Provider 的映射配置 */
 export interface ModelConfig {
     readonly model: string;
@@ -16,7 +16,10 @@ export declare const MODEL_REGISTRY: Readonly<Record<Model, ReadonlyArray<ModelC
 export interface ModelCapabilities {
     /** 是否原生支持 response_format: { type: 'json_object' } */
     readonly jsonMode: boolean;
-    /** 是否支持 reasoning_effort 参数 */
+    /**
+     * 是否支持调节推理深度。开启后由 Provider 的 `adaptRequest` 决定如何映射到底层字段
+     * （如 Qwen / DeepSeek → `extra_body.enable_thinking`、Kimi → `extra_body.thinking.type`）。
+     */
     readonly reasoningEffort: boolean;
 }
 /**

package/dist/llm_provider/models.js

@@ -6,7 +6,9 @@ exports.MODEL_REGISTRY = void 0;
  * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
  */
 exports.MODEL_REGISTRY = {
+    'qwen3.8-flash': [{ model: 'qwen3.8-flash', provider: 'bailian' }],
     'qwen3.7-max': [{ model: 'qwen3.7-max', provider: 'bailian' }],
+    'qwen3.7-flash': [{ model: 'qwen3.7-flash', provider: 'bailian' }],
     'qwen-plus': [{ model: 'qwen-plus', provider: 'bailian' }],
     'qwen-turbo': [{ model: 'qwen-turbo', provider: 'bailian' }],
     'qwq-plus': [{ model: 'qwq-plus', provider: 'bailian' }],

package/dist/llm_provider/types.d.ts

@@ -52,7 +52,13 @@ export type StreamChunk = {
     readonly delta: string;
 } | {
     readonly type: 'finish';
-    usage?: LLMResponse['usage'];
+    /** 上游返回的生成结束原因，例如 `stop`、`length` 或 `content_filter`。 */
+    readonly finishReason?: string;
+    /** SSE 流是否收到显式的 `data: [DONE]` 终止标记；未提供表示 Provider 不支持该观测。 */
+    readonly sawDone?: boolean;
+    /** SSE 流是否收到非空的 `finish_reason`；未提供表示 Provider 不支持该观测。 */
+    readonly sawFinishReason?: boolean;
+    readonly usage?: LLMResponse['usage'];
 };
 /**
  * Provider 配置。每个 Provider 实例需要一组连接参数。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keo-ai/axiom",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "基于 LLM 的预测与推理库，支持多 Provider 切换",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,9 @@
   "license": "MIT",
   "scripts": {
     "build": "tsc",
-    "test": "vitest run --exclude '**/*.integration.test.ts'"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --exclude '**/*.integration.test.ts'",
+    "test:integration": "vitest run --config vitest.integration.config.ts"
   },
   "dependencies": {
     "dotenv": "^17.4.2"