@keo-ai/axiom 0.1.7 → 0.1.9

package/README.md

@@ -172,16 +172,20 @@ for await (const chunk of LLM.streamPredict({ model: 'qwen3.7-max', prompt: '讲
 
 当前支持的模型（通过 `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`
-
+| 模型 | 推理深度 | 说明 |
+|------|----------|------|
+| `deepseek-v4-pro` | ✅ 原生支持 | `low`/`medium`/`high` 直接传递 |
+| `deepseek-v4-flash` | ✅ 原生支持 | `low`/`medium`/`high` 直接传递 |
+| `kimi-k2.6` | ✅ 原生支持 | `low`/`medium`/`high` 直接传递 |
+| `qwen-plus` | ✅ 映射支持 | `low` 关闭推理，`medium`/`high` 映射为 `enable_thinking` |
+| `qwen-turbo` | ✅ 映射支持 | 同上 |
+| `qwen3.7-max` | ✅ 映射支持 | 同上 |
+| `qwq-plus` | ❌ 不支持 | 固定推理行为，不可调节 |
+| `glm-5.1` | ❌ 不支持 | 不支持推理参数 |
+| `qwen-vl-plus` | ❌ 不支持 | 视觉模型，不支持推理参数 |
+
+> 推理深度的支持方式由 Provider 内部维护。百炼 Provider 中，Qwen 系列通过 `extra_body.enable_thinking` 映射实现，DeepSeek / Kimi 则原生透传 `reasoning_effort`。
+>
 > 目前所有模型均路由到百炼 Provider。后续接入其他厂商时，通过 `MODEL_REGISTRY` 扩展映射即可。
 
 ### 错误处理
@@ -260,6 +264,104 @@ console.log('Turns:', result.turns);
 console.log('Harness:', result.harness);
 ```
 
+> 💡 需要**流式输出**（实时展示 LLM 生成内容）？使用下方的 [`runLoopStream`](#流式调用runloopstream)。
+
+### 流式调用（runLoopStream）
+
+当需要实时展示 LLM 的思考过程或输出内容时，使用 `runLoopStream`：
+
+```ts
+import { FunctionCallLoop } from '@keo-ai/axiom';
+
+const stream = FunctionCallLoop.runLoopStream({
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'What is the weather in Beijing?' },
+  ],
+  tools: [
+    {
+      name: 'get_weather',
+      description: 'Get weather for a city',
+      parameters: { /* ... */ },
+      execute: async (args) => {
+        return { temperature: 25, condition: 'Sunny' };
+      },
+    },
+  ],
+  maxTurns: 5,
+});
+
+// 逐块消费流事件
+for await (const chunk of stream) {
+  switch (chunk.type) {
+    case 'turn_start':
+      console.log(`\n--- Turn ${chunk.turn} ---`);
+      break;
+    case 'reasoning':
+      // 实时流式输出模型的 reasoning content（思考过程）
+      process.stdout.write(chunk.delta);
+      break;
+    case 'content':
+      // 实时流式输出 content（正式回复内容）
+      process.stdout.write(chunk.delta);
+      break;
+    case 'tool_call':
+      console.log('\n[Tool Call]', chunk.toolCalls.map(t => t.function.name));
+      break;
+    case 'tool_result':
+      console.log(`[Result] ${chunk.toolName}: ${chunk.content} (${chunk.status})`);
+      break;
+    case 'turn_end':
+      console.log(`\n--- Turn ${chunk.turn} End ---`);
+      break;
+  }
+}
+```
+
+**获取最终返回值**：流结束后需要通过手动驱动迭代器获取 `LoopResult`：
+
+```ts
+const stream = FunctionCallLoop.runLoopStream(config);
+
+const chunks: FunctionCallLoop.LoopStreamChunk[] = [];
+let result: FunctionCallLoop.LoopResult | undefined;
+
+while (true) {
+  const { value, done } = await stream.next();
+  if (done) {
+    result = value as FunctionCallLoop.LoopResult;
+    break;
+  }
+  chunks.push(value as FunctionCallLoop.LoopStreamChunk);
+  // 实时消费...
+}
+
+console.log('Final:', result!.finalContent);
+console.log('Turns:', result!.turns);
+```
+
+#### 流式事件类型
+
+| 事件 | 触发时机 | 包含字段 |
+|---|---|---|
+| `turn_start` | 新一轮开始 | `turn` |
+| `reasoning` | LLM 输出 reasoning content（推理过程）增量 | `delta`, `turn` |
+| `content` | LLM 输出 content（正式回复）增量 | `delta`, `turn` |
+| `tool_call` | LLM 决定调用 tool（流结束、完整 tool_calls 解析完成） | `toolCalls`, `turn` |
+| `tool_result` | tool 执行完成 | `callId`, `toolName`, `content`, `status`, `turn` |
+| `turn_end` | 一轮结束（tool 全部执行完或 content 直接返回） | `turn` |
+
+#### 流式 vs 非流式的选择
+
+| 场景 | 推荐方式 |
+|---|---|
+| 需要实时展示 LLM 输出（打字机效果） | `runLoopStream` |
+| 需要实时展示模型 reasoning（思考）过程 | `runLoopStream`（通过 `reasoning` 事件独立透出） |
+| 后台静默执行，只关心最终结果 | `runLoop` |
+| 低延迟、简单场景 | `runLoop` |
+
+> **注意**：`runLoopStream` 需要 `LLMCaller` 支持 `stream` 方法。使用默认的 `createLLMCaller` 时自动支持。如果注入自定义 `llmCaller`，请确保实现了 `stream` 接口。
+
 ### 生命周期事件
 
 Loop 每处理一个 tool call，按顺序抛出两个事件：
@@ -497,7 +599,9 @@ const result = await promise;
 
 ### 配置项
 
-#### `runLoop` 配置
+#### `runLoop` / `runLoopStream` 配置
+
+两个函数共享同一套配置（`LoopConfig`），`runLoopStream` 额外要求 `llmCaller` 支持 `stream` 方法：
 
 **对话入口**
 
@@ -528,7 +632,7 @@ const result = await promise;
 | `maxTokens` | `number` | — | 单次 LLM 调用的最大输出 token 数 |
 | `temperature` | `number` | — | 采样温度，范围 0~2 |
 | `topP` | `number` | — | 核采样概率阈值，范围 0~1 |
-| `reasoningEffort` | `'low' \| 'medium' \| 'high'` | — | 推理深度。仅部分模型支持（如 o1、o3） |
+| `reasoningEffort` | `'low' \| 'medium' \| 'high'` | — | 推理深度。`low` 关闭推理，`medium`/`high` 开启推理。具体支持情况见「模型列表」 |
 
 ### 返回结果
 
@@ -541,6 +645,19 @@ interface LoopResult {
 }
 ```
 
+**Message 中的 reasoningContent**：当使用支持推理的模型（如 DeepSeek-R1、QwQ）时，`messages` 中 `role: 'assistant'` 的条目会包含 `reasoningContent` 字段，记录该轮模型的完整推理过程。该字段会自动保留在对话上下文中，供多轮对话回传。
+
+```ts
+const result = await FunctionCallLoop.runLoop(config);
+
+for (const msg of result.messages) {
+  if (msg.role === 'assistant' && msg.reasoningContent) {
+    console.log('[Reasoning]', msg.reasoningContent);
+    console.log('[Content]', msg.content);
+  }
+}
+```
+
 ### 错误处理
 
 同其他模块：**直接抛异常**。常见场景：

package/dist/function_call_loop/index.d.ts

@@ -11,4 +11,5 @@
  * - 系统 Prompt 完全由外部注入
  */
 export { runLoop } from './loop';
-export type { Message, ToolCall, ToolDefinition, HarnessRecord, HarnessRecordStatus, ToolExecutionStartEvent, ToolExecutionEndEvent, LoopEvent, ToolDiscoverResult, ToolExecuteContext, Tool, ApprovalConfig, TurnPolicyResult, TurnPolicy, CompactConfig, LLMCaller, LLMCallOptions, LoopConfig, LoopResult, PendingApprovalInfo, } from './types';
+export { runLoopStream } from './stream';
+export type { Message, ToolCall, ToolDefinition, HarnessRecord, HarnessRecordStatus, ToolExecutionStartEvent, ToolExecutionEndEvent, LoopEvent, ToolDiscoverResult, ToolExecuteContext, Tool, ApprovalConfig, TurnPolicyResult, TurnPolicy, CompactConfig, LLMCaller, LLMCallOptions, LLMStreamChunk, LoopConfig, LoopResult, LoopStreamChunk, PendingApprovalInfo, } from './types';

package/dist/function_call_loop/index.js

@@ -12,6 +12,8 @@
  * - 系统 Prompt 完全由外部注入
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runLoop = void 0;
+exports.runLoopStream = exports.runLoop = void 0;
 var loop_1 = require("./loop");
 Object.defineProperty(exports, "runLoop", { enumerable: true, get: function () { return loop_1.runLoop; } });
+var stream_1 = require("./stream");
+Object.defineProperty(exports, "runLoopStream", { enumerable: true, get: function () { return stream_1.runLoopStream; } });

package/dist/function_call_loop/loop.d.ts

@@ -1,2 +1,35 @@
-import type { LoopConfig, LoopResult } from './types';
+import type { LoopConfig, LoopResult, Message, ToolCall, ToolDiscoverResult, TurnPolicyResult, LoopEvent, HarnessRecord } from './types';
+import { Harness } from './harness';
 export declare function runLoop(config: LoopConfig): Promise<LoopResult>;
+/**
+ * 执行 Turn Policy。
+ */
+export declare function runTurnPolicy(config: LoopConfig, harness: Harness, turn: number): Promise<TurnPolicyResult>;
+/**
+ * Tool 发现。
+ */
+export declare function discoverTools(config: LoopConfig, harness: Harness): Promise<ToolDiscoverResult[]>;
+/**
+ * 将 Messages 按轮次分组（不含初始 system/user 消息）。
+ * 一轮 = 一个 assistant message + 其后的所有 tool messages。
+ */
+export declare function groupMessagesByRound(messages: ReadonlyArray<Message>): Message[][];
+/**
+ * 上下文压缩。
+ */
+export declare function compressMessages(config: LoopConfig, messages: Message[], _turn: number): Promise<Message[]>;
+export type ExecutionResult = {
+    toolCallId: string;
+    content: string;
+    record: HarnessRecord;
+    events: LoopEvent[];
+    pendingApproval?: {
+        ticketId: string;
+        toolName: string;
+        args: unknown;
+    };
+};
+/**
+ * 并行执行 tool。
+ */
+export declare function executeToolsInParallel(config: LoopConfig, harness: Harness, toolCalls: ReadonlyArray<ToolCall>, visibleToolNames: Set<string>, harnessSnapshot: ReadonlyArray<HarnessRecord>, turn: number): Promise<ExecutionResult[]>;

package/dist/function_call_loop/loop.js

@@ -10,6 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runLoop = runLoop;
+exports.runTurnPolicy = runTurnPolicy;
+exports.discoverTools = discoverTools;
+exports.groupMessagesByRound = groupMessagesByRound;
+exports.compressMessages = compressMessages;
+exports.executeToolsInParallel = executeToolsInParallel;
 const harness_1 = require("./harness");
 const provider_1 = require("./provider");
 /**
@@ -87,6 +92,7 @@ function runLoop(config) {
                 messages.push({
                     role: 'assistant',
                     content: (_f = llmResponse.content) !== null && _f !== void 0 ? _f : '',
+                    reasoningContent: llmResponse.reasoningContent,
                 });
                 return {
                     messages,
@@ -99,6 +105,7 @@ function runLoop(config) {
             messages.push({
                 role: 'assistant',
                 content: (_g = llmResponse.content) !== null && _g !== void 0 ? _g : '',
+                reasoningContent: llmResponse.reasoningContent,
                 tool_calls: llmResponse.tool_calls,
             });
             // 第七步：并行执行 tool
@@ -159,7 +166,7 @@ function runTurnPolicy(config, harness, turn) {
         if (turn < maxTurns - 1) {
             return {};
         }
-        if (turn === maxTurns - 1) {
+        if (turn === maxTurns - 1 && config.warningMessage) {
             return {
                 injectMessage: config.warningMessage,
             };

package/dist/function_call_loop/provider.d.ts

@@ -2,7 +2,7 @@
  * Function Call Loop 的 LLM Provider 适配器。
  * 基于 predict 模块的 `callChatCompletions` 构建，共用底层 OpenAI 协议 HTTP 层。
  */
-import type { Message, ToolCall, ToolDefinition, LLMCallOptions } from './types';
+import type { Message, ToolCall, ToolDefinition, LLMCallOptions, LLMStreamChunk } from './types';
 export interface ProviderOptions {
     readonly apiKey: string;
     readonly baseUrl: string;
@@ -14,6 +14,13 @@ export interface ProviderOptions {
 export declare function createLLMCaller(options: ProviderOptions): {
     call(messages: ReadonlyArray<Message>, tools: ReadonlyArray<ToolDefinition>, callOptions?: LLMCallOptions): Promise<{
         readonly content: string | null;
+        readonly reasoningContent?: string;
         readonly tool_calls?: ReadonlyArray<ToolCall>;
     }>;
+    /**
+     * 流式调用 LLM，支持 content 和 tool_calls 的增量输出。
+     *
+     * @yields 内容片段（`content`）或结束标记（`finish`，携带完整 content 和 tool_calls）
+     */
+    stream(messages: ReadonlyArray<Message>, tools: ReadonlyArray<ToolDefinition>, callOptions?: LLMCallOptions): AsyncGenerator<LLMStreamChunk, void, unknown>;
 };

package/dist/function_call_loop/provider.js

@@ -8,15 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLLMCaller = createLLMCaller;
 const llm_provider_1 = require("../llm_provider");
+const bailian_1 = require("../llm_provider/bailian");
 function toOpenAIMessages(messages) {
     return messages.map((m) => {
         var _a;
         return ({
             role: m.role,
             content: m.content,
+            reasoning_content: m.reasoningContent,
             tool_calls: (_a = m.tool_calls) === null || _a === void 0 ? void 0 : _a.map((tc) => ({
                 id: tc.id,
                 type: tc.type,
@@ -43,11 +58,17 @@ function toOpenAITools(tools) {
  * 基于 OpenAI 协议的 LLM 调用器。
  */
 function createLLMCaller(options) {
+    const provider = new bailian_1.BailianProvider({
+        name: 'bailian',
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+        defaultModel: options.defaultModel,
+    });
     return {
         call(messages, tools, callOptions) {
             return __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
-                const body = (0, llm_provider_1.adaptRequestForModel)({
+                const body = provider.adaptRequest({
                     model: (_a = callOptions === null || callOptions === void 0 ? void 0 : callOptions.model) !== null && _a !== void 0 ? _a : options.defaultModel,
                     messages: toOpenAIMessages(messages),
                     temperature: callOptions === null || callOptions === void 0 ? void 0 : callOptions.temperature,
@@ -60,6 +81,7 @@ function createLLMCaller(options) {
                 const choice = data.choices[0];
                 return {
                     content: choice.message.content,
+                    reasoningContent: choice.message.reasoning_content,
                     tool_calls: (_b = choice.message.tool_calls) === null || _b === void 0 ? void 0 : _b.map((tc) => ({
                         id: tc.id,
                         type: tc.type,
@@ -71,5 +93,164 @@ function createLLMCaller(options) {
                 };
             });
         },
+        /**
+         * 流式调用 LLM，支持 content 和 tool_calls 的增量输出。
+         *
+         * @yields 内容片段（`content`）或结束标记（`finish`，携带完整 content 和 tool_calls）
+         */
+        stream(messages, tools, callOptions) {
+            return __asyncGenerator(this, arguments, function* stream_1() {
+                var _a, _b, _c, _d, _e;
+                const body = provider.adaptRequest({
+                    model: (_a = callOptions === null || callOptions === void 0 ? void 0 : callOptions.model) !== null && _a !== void 0 ? _a : options.defaultModel,
+                    messages: toOpenAIMessages(messages),
+                    temperature: callOptions === null || callOptions === void 0 ? void 0 : callOptions.temperature,
+                    max_tokens: callOptions === null || callOptions === void 0 ? void 0 : callOptions.maxTokens,
+                    top_p: callOptions === null || callOptions === void 0 ? void 0 : callOptions.topP,
+                    tools: tools.length > 0 ? toOpenAITools(tools) : undefined,
+                    reasoning_effort: callOptions === null || callOptions === void 0 ? void 0 : callOptions.reasoningEffort,
+                    stream: true,
+                });
+                const url = `${options.baseUrl}/chat/completions`;
+                let response;
+                try {
+                    response = yield __await(fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: `Bearer ${options.apiKey}`,
+                        },
+                        body: JSON.stringify(body),
+                    }));
+                }
+                catch (cause) {
+                    throw new Error(`[llm] ${cause instanceof Error ? cause.message : String(cause)}`);
+                }
+                if (!response.ok) {
+                    const text = yield __await(response.text());
+                    throw new Error(`[llm] HTTP ${response.status}: ${text}`);
+                }
+                if (!response.body) {
+                    throw new Error(`[llm] Response body is null`);
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                // 用于增量收集 tool_calls
+                const toolCallAccumulators = [];
+                let fullContent = '';
+                let fullReasoningContent = '';
+                let hasYieldedFinish = false;
+                try {
+                    while (true) {
+                        const { done, value } = yield __await(reader.read());
+                        if (done)
+                            break;
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n');
+                        buffer = (_b = lines.pop()) !== null && _b !== void 0 ? _b : '';
+                        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 (_f) {
+                                continue;
+                            }
+                            const choice = (_c = parsed.choices) === null || _c === void 0 ? void 0 : _c[0];
+                            if (!choice)
+                                continue;
+                            const delta = choice.delta;
+                            // 收集 reasoning_content 增量
+                            if (delta.reasoning_content) {
+                                fullReasoningContent += delta.reasoning_content;
+                                yield yield __await({ type: 'reasoning', delta: delta.reasoning_content });
+                            }
+                            // 收集 content 增量
+                            if (delta.content) {
+                                fullContent += delta.content;
+                                yield yield __await({ type: 'content', delta: delta.content });
+                            }
+                            // 收集 tool_calls 增量
+                            if (delta.tool_calls) {
+                                for (const tcDelta of delta.tool_calls) {
+                                    const index = tcDelta.index;
+                                    if (!toolCallAccumulators[index]) {
+                                        toolCallAccumulators[index] = {
+                                            function: { arguments: '' },
+                                        };
+                                    }
+                                    const acc = toolCallAccumulators[index];
+                                    if (tcDelta.id)
+                                        acc.id = tcDelta.id;
+                                    if (tcDelta.type)
+                                        acc.type = tcDelta.type;
+                                    if ((_d = tcDelta.function) === null || _d === void 0 ? void 0 : _d.name) {
+                                        acc.function.name = tcDelta.function.name;
+                                    }
+                                    if ((_e = tcDelta.function) === null || _e === void 0 ? void 0 : _e.arguments) {
+                                        acc.function.arguments += tcDelta.function.arguments;
+                                    }
+                                }
+                            }
+                            // 流结束
+                            if (choice.finish_reason) {
+                                const toolCalls = [];
+                                for (const acc of toolCallAccumulators) {
+                                    if (acc.id && acc.type && acc.function.name) {
+                                        toolCalls.push({
+                                            id: acc.id,
+                                            type: acc.type,
+                                            function: {
+                                                name: acc.function.name,
+                                                arguments: acc.function.arguments,
+                                            },
+                                        });
+                                    }
+                                }
+                                yield yield __await({
+                                    type: 'finish',
+                                    content: fullContent || null,
+                                    reasoningContent: fullReasoningContent || undefined,
+                                    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                                });
+                                hasYieldedFinish = true;
+                            }
+                        }
+                    }
+                    // 兜底：如果流正常结束但没有收到 finish_reason，也 yield 一个 finish
+                    if (!hasYieldedFinish) {
+                        const toolCalls = [];
+                        for (const acc of toolCallAccumulators) {
+                            if (acc.id && acc.type && acc.function.name) {
+                                toolCalls.push({
+                                    id: acc.id,
+                                    type: acc.type,
+                                    function: {
+                                        name: acc.function.name,
+                                        arguments: acc.function.arguments,
+                                    },
+                                });
+                            }
+                        }
+                        yield yield __await({
+                            type: 'finish',
+                            content: fullContent || null,
+                            reasoningContent: fullReasoningContent || undefined,
+                            tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                        });
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            });
+        },
     };
 }

package/dist/function_call_loop/stream.d.ts

@@ -0,0 +1,24 @@
+import type { LoopConfig, LoopResult, LoopStreamChunk } from './types';
+/**
+ * 运行 Function Call Loop 的流式版本。
+ *
+ * 与非流式 `runLoop` 的区别：
+ * - 每轮 LLM 调用使用流式接口，content 增量实时通过 yield 透出
+ * - 支持 tool_calls 的增量收集；完整 tool_calls 在 finish chunk 中返回
+ * - 每轮开始/结束、tool 执行结果都会生成对应事件
+ *
+ * @param config - Loop 配置
+ * @yields 流式事件（content / tool_call / tool_result / turn_start / turn_end）
+ * @returns Loop 执行结果
+ *
+ * @example
+ * ```ts
+ * const stream = runLoopStream(config);
+ * for await (const chunk of stream) {
+ *   if (chunk.type === 'content') process.stdout.write(chunk.delta);
+ *   if (chunk.type === 'tool_call') console.log('调用工具:', chunk.toolCalls);
+ * }
+ * const result = await stream.return?.(); // 或使用 for await 之后的返回值
+ * ```
+ */
+export declare function runLoopStream(config: LoopConfig): AsyncGenerator<LoopStreamChunk, LoopResult, unknown>;

package/dist/function_call_loop/stream.js

@@ -0,0 +1,226 @@
+"use strict";
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoopStream = runLoopStream;
+const harness_1 = require("./harness");
+const provider_1 = require("./provider");
+const loop_1 = require("./loop");
+const DEFAULT_BAILIAN_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+const DEFAULT_BAILIAN_MODEL = 'qwen-max';
+function buildInitialMessages(config) {
+    return [...config.messages];
+}
+/**
+ * 运行 Function Call Loop 的流式版本。
+ *
+ * 与非流式 `runLoop` 的区别：
+ * - 每轮 LLM 调用使用流式接口，content 增量实时通过 yield 透出
+ * - 支持 tool_calls 的增量收集；完整 tool_calls 在 finish chunk 中返回
+ * - 每轮开始/结束、tool 执行结果都会生成对应事件
+ *
+ * @param config - Loop 配置
+ * @yields 流式事件（content / tool_call / tool_result / turn_start / turn_end）
+ * @returns Loop 执行结果
+ *
+ * @example
+ * ```ts
+ * const stream = runLoopStream(config);
+ * for await (const chunk of stream) {
+ *   if (chunk.type === 'content') process.stdout.write(chunk.delta);
+ *   if (chunk.type === 'tool_call') console.log('调用工具:', chunk.toolCalls);
+ * }
+ * const result = await stream.return?.(); // 或使用 for await 之后的返回值
+ * ```
+ */
+function runLoopStream(config) {
+    return __asyncGenerator(this, arguments, function* runLoopStream_1() {
+        var _a, e_1, _b, _c;
+        var _d, _e, _f, _g, _h, _j, _k;
+        const llmCaller = (_d = config.llmCaller) !== null && _d !== void 0 ? _d : (0, provider_1.createLLMCaller)({
+            apiKey: (_e = process.env.BAILIAN_API_KEY) !== null && _e !== void 0 ? _e : '',
+            baseUrl: (_f = process.env.BAILIAN_BASE_URL) !== null && _f !== void 0 ? _f : DEFAULT_BAILIAN_BASE_URL,
+            defaultModel: (_g = process.env.BAILIAN_DEFAULT_MODEL) !== null && _g !== void 0 ? _g : DEFAULT_BAILIAN_MODEL,
+        });
+        if (!config.llmCaller && !process.env.BAILIAN_API_KEY) {
+            throw new Error('BAILIAN_API_KEY environment variable is not set.');
+        }
+        if (!llmCaller.stream) {
+            throw new Error('LLMCaller does not support streaming. Please provide an LLMCaller with a stream method.');
+        }
+        const harness = new harness_1.Harness();
+        const messages = buildInitialMessages(config);
+        let turn = 0;
+        const signal = config.signal;
+        while (true) {
+            // 检查取消信号
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                break;
+            }
+            // 第一步：轮次加一
+            turn++;
+            yield yield __await({ type: 'turn_start', turn });
+            // 第二步：全局轮次策略
+            const decision = yield __await((0, loop_1.runTurnPolicy)(config, harness, turn));
+            if (decision.injectMessage) {
+                messages.push({ role: 'system', content: decision.injectMessage });
+            }
+            // 硬兜底检查
+            if (config.maxTurns !== undefined && turn >= config.maxTurns) {
+                messages.push({
+                    role: 'assistant',
+                    content: (_h = config.terminateMessage) !== null && _h !== void 0 ? _h : 'Max turns reached.',
+                });
+                yield yield __await({ type: 'turn_end', turn });
+                break;
+            }
+            // 第三步：Tool 发现
+            const discoverResult = yield __await((0, loop_1.discoverTools)(config, harness));
+            const visibleTools = discoverResult.filter((t) => t.visible);
+            const toolDefinitions = visibleTools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                },
+            }));
+            const visibleToolNames = new Set(visibleTools.map((t) => t.name));
+            // 第四步：上下文压缩
+            const messagesForLLM = yield __await((0, loop_1.compressMessages)(config, messages, turn));
+            // 第五步：流式调用 LLM
+            let fullContent = '';
+            let fullReasoningContent = '';
+            let finishChunk = null;
+            const stream = llmCaller.stream(messagesForLLM, toolDefinitions, {
+                model: config.model,
+                temperature: config.temperature,
+                maxTokens: config.maxTokens,
+                topP: config.topP,
+                reasoningEffort: config.reasoningEffort,
+            });
+            try {
+                for (var _l = true, stream_1 = (e_1 = void 0, __asyncValues(stream)), stream_1_1; stream_1_1 = yield __await(stream_1.next()), _a = stream_1_1.done, !_a; _l = true) {
+                    _c = stream_1_1.value;
+                    _l = false;
+                    const chunk = _c;
+                    if (chunk.type === 'content') {
+                        fullContent += chunk.delta;
+                        yield yield __await({ type: 'content', delta: chunk.delta, turn });
+                    }
+                    else if (chunk.type === 'reasoning') {
+                        fullReasoningContent += chunk.delta;
+                        yield yield __await({ type: 'reasoning', delta: chunk.delta, turn });
+                    }
+                    else if (chunk.type === 'finish') {
+                        finishChunk = chunk;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_l && !_a && (_b = stream_1.return)) yield __await(_b.call(stream_1));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (!finishChunk) {
+                throw new Error('LLM stream ended without a finish chunk');
+            }
+            // 使用 finish chunk 中的 content（优先级更高，可能包含完整格式化内容）
+            const assistantContent = (_j = finishChunk.content) !== null && _j !== void 0 ? _j : fullContent;
+            const assistantReasoningContent = (_k = finishChunk.reasoningContent) !== null && _k !== void 0 ? _k : (fullReasoningContent || undefined);
+            // 第六步：检查 LLM 回复
+            if (!finishChunk.tool_calls || finishChunk.tool_calls.length === 0) {
+                messages.push({
+                    role: 'assistant',
+                    content: assistantContent,
+                    reasoningContent: assistantReasoningContent,
+                });
+                yield yield __await({ type: 'turn_end', turn });
+                return yield __await({
+                    messages,
+                    harness: harness.getAll(),
+                    finalContent: assistantContent,
+                    turns: turn,
+                });
+            }
+            // 有 tool_calls，将 assistant message 加入 Messages
+            yield yield __await({
+                type: 'tool_call',
+                turn,
+                toolCalls: finishChunk.tool_calls,
+            });
+            messages.push({
+                role: 'assistant',
+                content: assistantContent,
+                reasoningContent: assistantReasoningContent,
+                tool_calls: finishChunk.tool_calls,
+            });
+            // 第七步：并行执行 tool
+            const harnessSnapshot = harness.snapshot();
+            const parallelResults = yield __await((0, loop_1.executeToolsInParallel)(config, harness, finishChunk.tool_calls, visibleToolNames, harnessSnapshot, turn));
+            // 将 tool result messages 加入 Messages，并 yield 事件
+            for (const result of parallelResults) {
+                messages.push({
+                    role: 'tool',
+                    content: result.content,
+                    tool_call_id: result.toolCallId,
+                });
+                yield yield __await({
+                    type: 'tool_result',
+                    turn,
+                    callId: result.toolCallId,
+                    toolName: result.record.toolName,
+                    content: result.content,
+                    status: result.record.status,
+                });
+            }
+            // 检查是否有待审批的 tool
+            const pending = parallelResults.find((r) => r.pendingApproval);
+            if (pending === null || pending === void 0 ? void 0 : pending.pendingApproval) {
+                yield yield __await({ type: 'turn_end', turn });
+                return yield __await({
+                    messages,
+                    harness: harness.getAll(),
+                    finalContent: null,
+                    turns: turn,
+                    pendingApproval: {
+                        ticketId: pending.pendingApproval.ticketId,
+                        toolName: pending.pendingApproval.toolName,
+                        args: pending.pendingApproval.args,
+                        callId: pending.toolCallId,
+                    },
+                });
+            }
+            yield yield __await({ type: 'turn_end', turn });
+            // 第八步：回到第一步继续下一轮
+        }
+        // Loop 被终止（Turn Policy 或硬限制）
+        const lastMessage = messages[messages.length - 1];
+        return yield __await({
+            messages,
+            harness: harness.getAll(),
+            finalContent: (lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'assistant' ? lastMessage.content : null,
+            turns: turn,
+        });
+    });
+}

package/dist/function_call_loop/types.d.ts

@@ -5,6 +5,7 @@
 export interface Message {
     readonly role: 'system' | 'user' | 'assistant' | 'tool';
     readonly content: string;
+    readonly reasoningContent?: string;
     readonly tool_calls?: ReadonlyArray<ToolCall>;
     readonly tool_call_id?: string;
 }
@@ -120,10 +121,9 @@ export interface Tool {
 /**
  * Turn Policy 决策结果。
  */
-export interface TurnPolicyResult {
-    /** 继续执行前作为 system 消息注入 */
-    readonly injectMessage?: string;
-}
+export type TurnPolicyResult = {
+    readonly injectMessage: string;
+} | Record<string, never>;
 /**
  * 全局轮次策略。
  */
@@ -145,14 +145,31 @@ export interface LLMCallOptions {
     readonly topP?: number;
     readonly reasoningEffort?: 'low' | 'medium' | 'high';
 }
+/**
+ * LLM 流式输出片段。
+ */
+export type LLMStreamChunk = {
+    readonly type: 'content';
+    readonly delta: string;
+} | {
+    readonly type: 'reasoning';
+    readonly delta: string;
+} | {
+    readonly type: 'finish';
+    readonly content: string | null;
+    readonly reasoningContent?: string;
+    readonly tool_calls?: ReadonlyArray<ToolCall>;
+};
 /**
  * LLM 调用接口。由外部注入，Loop 内部不绑定具体 Provider。
  */
 export interface LLMCaller {
     readonly call: (messages: ReadonlyArray<Message>, tools: ReadonlyArray<ToolDefinition>, options?: LLMCallOptions) => Promise<{
         readonly content: string | null;
+        readonly reasoningContent?: string;
         readonly tool_calls?: ReadonlyArray<ToolCall>;
     }>;
+    readonly stream?: (messages: ReadonlyArray<Message>, tools: ReadonlyArray<ToolDefinition>, options?: LLMCallOptions) => AsyncGenerator<LLMStreamChunk, void, unknown>;
 }
 /**
  * Loop 配置。
@@ -204,3 +221,32 @@ export interface LoopResult {
     readonly turns: number;
     readonly pendingApproval?: PendingApprovalInfo;
 }
+/**
+ * runLoopStream 的流式事件类型。
+ */
+export type LoopStreamChunk = {
+    readonly type: 'turn_start';
+    readonly turn: number;
+} | {
+    readonly type: 'content';
+    readonly delta: string;
+    readonly turn: number;
+} | {
+    readonly type: 'reasoning';
+    readonly delta: string;
+    readonly turn: number;
+} | {
+    readonly type: 'tool_call';
+    readonly turn: number;
+    readonly toolCalls: ReadonlyArray<ToolCall>;
+} | {
+    readonly type: 'tool_result';
+    readonly turn: number;
+    readonly callId: string;
+    readonly toolName: string;
+    readonly content: string;
+    readonly status: HarnessRecordStatus;
+} | {
+    readonly type: 'turn_end';
+    readonly turn: number;
+};

package/dist/llm_provider/bailian.d.ts

@@ -8,8 +8,10 @@ export declare class BailianProvider implements LLMProvider {
     readonly config: ProviderConfig;
     readonly name = "bailian";
     private static readonly SUPPORTED_MODELS;
+    private static readonly MODEL_CAPABILITIES;
     constructor(config: ProviderConfig);
     supports(model: string): boolean;
+    adaptRequest(body: import('./index').OpenAIChatRequest): import('./index').OpenAIChatRequest;
     /**
      * 发送非流式 chat completion 请求到百炼服务。
      * @param request - 标准化 LLM 请求

package/dist/llm_provider/bailian.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
@@ -36,6 +47,25 @@ class BailianProvider {
     supports(model) {
         return BailianProvider.SUPPORTED_MODELS.has(model);
     }
+    adaptRequest(body) {
+        var _a, _b, _c;
+        const caps = (_a = BailianProvider.MODEL_CAPABILITIES[body.model]) !== null && _a !== void 0 ? _a : { jsonMode: false, reasoningEffort: false };
+        if (body.reasoning_effort !== undefined && !caps.reasoningEffort) {
+            throw new Error(`[adapt] Model "${body.model}" does not support reasoning_effort`);
+        }
+        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
+        if (body.reasoning_effort !== undefined) {
+            if (['qwen-plus', 'qwen-turbo', 'qwen3.7-max'].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' }) });
+            }
+            // deepseek-v4-pro / deepseek-v4-flash / kimi-k2.6 原生支持，直接传递
+        }
+        return body;
+    }
     /**
      * 发送非流式 chat completion 请求到百炼服务。
      * @param request - 标准化 LLM 请求
@@ -45,11 +75,12 @@ class BailianProvider {
     generate(request) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const body = (0, index_1.adaptRequestForModel)(Object.assign(Object.assign({}, this.buildRequestBody(request)), { stream: false }));
+            const body = this.adaptRequest(Object.assign(Object.assign({}, this.buildRequestBody(request)), { stream: false }));
             const data = yield (0, index_1.callChatCompletions)(this.config.baseUrl, this.config.apiKey, body, this.name);
             const choice = data.choices[0];
             return {
                 content: choice.message.content,
+                reasoningContent: choice.message.reasoning_content,
                 usage: data.usage
                     ? {
                         promptTokens: data.usage.prompt_tokens,
@@ -71,7 +102,7 @@ class BailianProvider {
         return __asyncGenerator(this, arguments, function* stream_1() {
             var _a, _b;
             const url = `${this.config.baseUrl}/chat/completions`;
-            const body = (0, index_1.adaptRequestForModel)(Object.assign(Object.assign({}, this.buildRequestBody(request)), { stream: true }));
+            const body = this.adaptRequest(Object.assign(Object.assign({}, this.buildRequestBody(request)), { stream: true }));
             let response;
             try {
                 response = yield __await(fetch(url, {
@@ -122,6 +153,9 @@ class BailianProvider {
                         if (!choice)
                             continue;
                         const delta = choice.delta;
+                        if (delta.reasoning_content) {
+                            yield yield __await({ type: 'reasoning', delta: delta.reasoning_content });
+                        }
                         if (delta.content) {
                             yield yield __await({ type: 'content', delta: delta.content });
                         }
@@ -173,3 +207,15 @@ BailianProvider.SUPPORTED_MODELS = new Set([
     'glm-5.1',
     'qwen-vl-plus',
 ]);
+BailianProvider.MODEL_CAPABILITIES = {
+    'qwen-max': { jsonMode: true, reasoningEffort: false },
+    'qwen3.7-max': { jsonMode: true, reasoningEffort: true },
+    'qwen-plus': { jsonMode: true, reasoningEffort: true },
+    'qwen-turbo': { jsonMode: true, reasoningEffort: true },
+    'qwq-plus': { jsonMode: true, reasoningEffort: false },
+    'deepseek-v4-pro': { jsonMode: true, reasoningEffort: true },
+    'deepseek-v4-flash': { jsonMode: true, reasoningEffort: true },
+    'kimi-k2.6': { jsonMode: true, reasoningEffort: true },
+    'glm-5.1': { jsonMode: false, reasoningEffort: false },
+    'qwen-vl-plus': { jsonMode: true, reasoningEffort: false },
+};

package/dist/llm_provider/index.d.ts

@@ -5,6 +5,7 @@
 export interface OpenAIChatMessage {
     role: string;
     content: string | null;
+    reasoning_content?: string;
     tool_calls?: Array<{
         id: string;
         type: 'function';
@@ -35,11 +36,14 @@ export interface OpenAIChatRequest {
     };
     stream?: boolean;
     reasoning_effort?: 'low' | 'medium' | 'high';
+    /** 百炼等平台的扩展参数 */
+    extra_body?: Record<string, unknown>;
 }
 export interface OpenAIChatResponse {
     choices: Array<{
         message: {
             content: string | null;
+            reasoning_content?: string;
             tool_calls?: Array<{
                 id: string;
                 type: 'function';
@@ -64,14 +68,9 @@ export interface OpenAIChatResponse {
  * 业务层（请求体组装、结果转换）由调用方负责。
  */
 export declare function callChatCompletions(baseUrl: string, apiKey: string, body: OpenAIChatRequest, errorPrefix?: string): Promise<OpenAIChatResponse>;
-/**
- * 根据模型能力校验并适配 OpenAI 请求体。
- * 若调用方明确要求了模型不支持的能力，直接抛异常。
- */
-export declare function adaptRequestForModel(body: OpenAIChatRequest): OpenAIChatRequest;
 /** 模型枚举与注册表 */
 export type { Model, ModelConfig, ModelCapabilities } from './models';
-export { MODEL_REGISTRY, MODEL_CAPABILITIES, getModelCapabilities } from './models';
+export { MODEL_REGISTRY } from './models';
 /** 标准化类型 */
 export type { Message, LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
 /** Provider 接口与实现 */

package/dist/llm_provider/index.js

@@ -13,9 +13,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BailianProvider = exports.getModelCapabilities = exports.MODEL_CAPABILITIES = exports.MODEL_REGISTRY = void 0;
+exports.BailianProvider = exports.MODEL_REGISTRY = void 0;
 exports.callChatCompletions = callChatCompletions;
-exports.adaptRequestForModel = adaptRequestForModel;
 /**
  * 发送 OpenAI 兼容的 chat completions 请求。
  * 只做 HTTP 层：构造请求、fetch、错误处理、基础解析。
@@ -57,25 +56,7 @@ function callChatCompletions(baseUrl_1, apiKey_1, body_1) {
         return data;
     });
 }
-const models_1 = require("./models");
-/**
- * 根据模型能力校验并适配 OpenAI 请求体。
- * 若调用方明确要求了模型不支持的能力，直接抛异常。
- */
-function adaptRequestForModel(body) {
-    var _a;
-    const caps = (0, models_1.getModelCapabilities)(body.model);
-    if (body.reasoning_effort !== undefined && !caps.reasoningEffort) {
-        throw new Error(`[adapt] Model "${body.model}" does not support reasoning_effort`);
-    }
-    if (((_a = body.response_format) === null || _a === void 0 ? void 0 : _a.type) === 'json_object' && !caps.jsonMode) {
-        throw new Error(`[adapt] Model "${body.model}" does not support response_format json_object`);
-    }
-    return body;
-}
-var models_2 = require("./models");
-Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return models_2.MODEL_REGISTRY; } });
-Object.defineProperty(exports, "MODEL_CAPABILITIES", { enumerable: true, get: function () { return models_2.MODEL_CAPABILITIES; } });
-Object.defineProperty(exports, "getModelCapabilities", { enumerable: true, get: function () { return models_2.getModelCapabilities; } });
+var models_1 = require("./models");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return models_1.MODEL_REGISTRY; } });
 var bailian_1 = require("./bailian");
 Object.defineProperty(exports, "BailianProvider", { enumerable: true, get: function () { return bailian_1.BailianProvider; } });

package/dist/llm_provider/llm.d.ts

@@ -1,4 +1,5 @@
 import type { LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+import type { OpenAIChatRequest } from './index';
 /**
  * LLM Provider 抽象接口。每个 Provider 实现负责对接具体的模型服务
  *（如百炼、OpenAI、Anthropic 等），处理 HTTP 请求、流式解析和错误转换。
@@ -15,6 +16,13 @@ export interface LLMProvider {
      * @returns true 表示支持，false 表示不支持（将自动轮询下一个候选）
      */
     supports(model: string): boolean;
+    /**
+     * 根据当前 Provider 的模型能力校验并适配 OpenAI 请求体。
+     * @param body - OpenAI 兼容请求体
+     * @returns 适配后的请求体
+     * @throws 模型不支持请求中指定的能力时抛异常
+     */
+    adaptRequest(body: OpenAIChatRequest): OpenAIChatRequest;
     /**
      * 发送非流式请求，返回完整的模型响应。
      * @param request - LLM 请求参数

package/dist/llm_provider/models.d.ts

@@ -16,13 +16,11 @@ export declare const MODEL_REGISTRY: Readonly<Record<Model, ReadonlyArray<ModelC
 export interface ModelCapabilities {
     /** 是否原生支持 response_format: { type: 'json_object' } */
     readonly jsonMode: boolean;
-    /** 是否原生支持 reasoning_effort 参数 */
+    /** 是否支持 reasoning_effort 参数 */
     readonly reasoningEffort: boolean;
 }
 /**
  * 模型能力矩阵。
- * 未列出的模型默认视为不支持 jsonMode 和 reasoningEffort。
- */
-export declare const MODEL_CAPABILITIES: Readonly<Record<string, ModelCapabilities>>;
-/** 获取指定模型的能力配置 */
-export declare function getModelCapabilities(model: string): ModelCapabilities;
+ * 由各 Provider 自行维护，不再全局定义。
+ * 同一模型在不同 Provider 下可能有不同的能力表现。
+ */ 

package/dist/llm_provider/models.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MODEL_CAPABILITIES = exports.MODEL_REGISTRY = void 0;
-exports.getModelCapabilities = getModelCapabilities;
+exports.MODEL_REGISTRY = void 0;
 /**
  * 模型注册表。每个模型对应一个或多个 Provider 候选，按优先级排序。
  * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
@@ -19,22 +18,6 @@ exports.MODEL_REGISTRY = {
 };
 /**
  * 模型能力矩阵。
- * 未列出的模型默认视为不支持 jsonMode 和 reasoningEffort。
- */
-exports.MODEL_CAPABILITIES = {
-    'qwen-max': { jsonMode: true, reasoningEffort: false },
-    'qwen3.7-max': { jsonMode: true, reasoningEffort: false },
-    'qwen-plus': { jsonMode: true, reasoningEffort: false },
-    'qwen-turbo': { jsonMode: true, reasoningEffort: false },
-    'qwq-plus': { jsonMode: true, reasoningEffort: false },
-    'deepseek-v4-pro': { jsonMode: true, reasoningEffort: false },
-    'deepseek-v4-flash': { jsonMode: true, reasoningEffort: false },
-    'kimi-k2.6': { jsonMode: true, reasoningEffort: false },
-    'glm-5.1': { jsonMode: false, reasoningEffort: false },
-    'qwen-vl-plus': { jsonMode: true, reasoningEffort: false },
-};
-/** 获取指定模型的能力配置 */
-function getModelCapabilities(model) {
-    var _a;
-    return (_a = exports.MODEL_CAPABILITIES[model]) !== null && _a !== void 0 ? _a : { jsonMode: false, reasoningEffort: false };
-}
+ * 由各 Provider 自行维护，不再全局定义。
+ * 同一模型在不同 Provider 下可能有不同的能力表现。
+ */ 

package/dist/llm_provider/types.d.ts

@@ -22,6 +22,7 @@ export interface LLMRequest {
  */
 export interface LLMResponse {
     readonly content: string | null;
+    readonly reasoningContent?: string;
     readonly usage?: {
         readonly promptTokens: number;
         readonly completionTokens: number;
@@ -35,6 +36,9 @@ export interface LLMResponse {
 export type StreamChunk = {
     readonly type: 'content';
     readonly delta: string;
+} | {
+    readonly type: 'reasoning';
+    readonly delta: string;
 } | {
     readonly type: 'finish';
     usage?: LLMResponse['usage'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keo-ai/axiom",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "基于 LLM 的预测与推理库，支持多 Provider 切换",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",