@keo-ai/axiom 0.1.4 → 0.1.6

package/README.md

@@ -179,6 +179,7 @@ for await (const chunk of LLM.streamPredict({ model: 'qwen3.7-max', prompt: '讲
 - `deepseek-v4-pro`
 - `deepseek-v4-flash`
 - `kimi-k2.6`
+- `glm-5.1`
 - `qwen-vl-plus`
 
 > 目前所有模型均路由到百炼 Provider。后续接入其他厂商时，通过 `MODEL_REGISTRY` 扩展映射即可。
@@ -213,9 +214,7 @@ Function Call Loop 是 Axiom 的底层 Function Call 引擎。它负责把 **LLM
 
 ### 快速开始
 
-#### 方式一：直接传模型参数（推荐）
-
-像 predict 模块一样，设置环境变量后一行调用：
+设置环境变量后一行调用：
 
 ```bash
 export BAILIAN_API_KEY="your-api-key"
@@ -224,12 +223,12 @@ export BAILIAN_API_KEY="your-api-key"
 ```ts
 import { FunctionCallLoop } from '@keo-ai/axiom';
 
-const result = await FunctionCallLoop.runLoopWithModel({
+const result = await FunctionCallLoop.runLoop({
   messages: [
     { role: 'system', content: 'You are a helpful assistant.' },
     { role: 'user', content: 'What is the weather in Beijing?' },
   ],
-  model: 'qwen-max',
+  model: 'qwen3.7-max',
   temperature: 0.7,
   maxTokens: 2048,
   tools: [
@@ -243,7 +242,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
         },
         required: ['city'],
       },
-      execute: async (args) => {
+      execute: async (args, context) => {
         return { temperature: 25, condition: 'Sunny' };
       },
     },
@@ -266,7 +265,7 @@ console.log('Harness:', result.harness);
 Loop 每处理一个 tool call，按顺序抛出两个事件：
 
 ```ts
-const result = await FunctionCallLoop.runLoopWithModel({
+const result = await FunctionCallLoop.runLoop({
   // ...
   onEvent: (event) => {
     if (event.type === 'execution:start') {
@@ -315,7 +314,7 @@ console.log(result.harness);
 对于敏感操作（转账、删除数据等），可以给 tool 配置 `approval`，Loop 会在执行前暂停并返回 `pendingApproval`：
 
 ```ts
-const result = await FunctionCallLoop.runLoopWithModel({
+const result = await FunctionCallLoop.runLoop({
   messages: [
     { role: 'system', content: 'You are a helpful assistant.' },
     { role: 'user', content: 'Transfer 1000 to Alice' },
@@ -333,7 +332,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
           return { ticketId: ticket.id };
         },
       },
-      execute: async (args) => {
+      execute: async (args, context) => {
         // 审批通过后才会执行到这里
         return await doTransfer(args);
       },
@@ -357,7 +356,7 @@ if (result.pendingApproval) {
 ```ts
 const record = await db.findByTicketId(ticketId);
 
-const result = await FunctionCallLoop.runLoopWithModel({
+const result = await FunctionCallLoop.runLoop({
   messages: record.messages,
   metadata: { userId: 'u-123', orgId: 'o-456' },
   tools: [
@@ -375,7 +374,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
           return { ticketId: ticket.id };
         },
       },
-      execute: async (args) => await doTransfer(args),
+      execute: async (args, context) => await doTransfer(args),
     },
   ],
 });
@@ -406,7 +405,7 @@ const tool = {
       visible: isAdmin,
     };
   },
-  execute: async (args) => { /* ... */ },
+  execute: async (args, context) => { /* ... */ },
 };
 ```
 
@@ -419,17 +418,17 @@ const tool = {
 
 ### Turn Policy（全局轮次策略）
 
-每轮开始时，Loop 先执行 Turn Policy 决定是继续还是终止：
+每轮开始时，Loop 先执行 Turn Policy，可注入一条 system 消息干预本轮：
 
 ```ts
-const result = await FunctionCallLoop.runLoopWithModel({
+const result = await FunctionCallLoop.runLoop({
   // ...
   turnPolicy: async (harness, turn, metadata) => {
-    // 连续失败降级
+    // 连续失败时注入提醒
     const failCount = harness.filter((r) => r.status === 'error').length;
     if (failCount >= 3) {
       return {
-        message: 'Too many failures, please try again later.',
+        injectMessage: 'Previous calls failed, please try a different approach.',
       };
     }
     return {};
@@ -443,21 +442,20 @@ const result = await FunctionCallLoop.runLoopWithModel({
 |---|---|
 | `turn < maxTurns - 1` | 继续执行 |
 | `turn === maxTurns - 1` | 注入 `warningMessage`，继续执行 |
-| `turn >= maxTurns` | 注入 `terminateMessage`，终止 Loop |
+| `turn >= maxTurns` | 交由硬兜底处理 |
 
 | 边界情况 | 行为 |
 |---|---|
-| `turnPolicy` 抛异常 | 视为 `continue`，记录异常 |
-| 返回 `terminate` | 向 Messages 塞入 `fallbackMessage`，结束 Loop，不再调 LLM |
+| `turnPolicy` 抛异常 | 视为无注入，继续执行 |
 
-### 上下文压缩
+### 上下文 compact
 
 控制给 LLM 的历史消息长度，只动 Messages，不动 Harness：
 
 ```ts
-const result = await FunctionCallLoop.runLoopWithModel({
+const result = await FunctionCallLoop.runLoop({
   // ...
-  compression: {
+  compact: {
     keepRounds: 3, // 最近 3 轮保持完整
     compress: async (oldRounds) => {
       // oldRounds: 需要压缩的轮次数组，每轮是一个 Message 数组
@@ -475,7 +473,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
 
 | 规则 | 说明 |
 |---|---|
-| 压缩只影响 Messages | Harness 始终完整保留 |
+| compact 只影响 Messages | Harness 始终完整保留 |
 | 系统消息和初始输入不参与压缩 | 始终保留 |
 | `compress` 抛异常 | 视为不压缩，使用原始 Messages 继续执行 |
 
@@ -486,7 +484,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
 ```ts
 const controller = new AbortController();
 
-const promise = FunctionCallLoop.runLoopWithModel({
+const promise = FunctionCallLoop.runLoop({
   // ...
   signal: controller.signal,
 });
@@ -499,7 +497,7 @@ const result = await promise;
 
 ### 配置项
 
-#### `runLoopWithModel` 配置
+#### `runLoop` 配置
 
 **对话入口**
 
@@ -512,9 +510,10 @@ const result = await promise;
 | 配置项 | 类型 | 必填 | 说明 |
 |---|---|---|---|
 | `tools` | `Tool[]` | ✅ | 注册的 tool 列表 |
+| `llmCaller` | `LLMCaller` | — | 自定义 LLM 调用器。未设置时从环境变量自动创建 |
 | `maxTurns` | `number` | — | 最大轮次，默认无限制 |
 | `turnPolicy` | `TurnPolicy` | — | 自定义轮次策略 |
-| `compression` | `CompressionConfig` | — | 上下文压缩配置 |
+| `compact` | `CompactConfig` | — | 上下文 compact 配置 |
 | `metadata` | `unknown` | — | 传递给 Tool 和 Turn Policy 的元数据 |
 | `warningMessage` | `string` | — | 默认策略在 `maxTurns - 1` 时注入的告警文本 |
 | `terminateMessage` | `string` | — | 默认策略在 `maxTurns` 时注入的终止文本 |
@@ -525,11 +524,12 @@ const result = await promise;
 
 | 配置项 | 类型 | 必填 | 说明 |
 |---|---|---|---|
-| `model` | `string` | — | 模型名称。默认从 `BAILIAN_DEFAULT_MODEL` 环境变量读取，否则 `qwen-max` |
+| `model` | `Model` | — | 模型枚举值。默认从 `BAILIAN_DEFAULT_MODEL` 环境变量读取，否则 `qwen-max` |
 | `maxTokens` | `number` | — | 单次 LLM 调用的最大输出 token 数 |
 | `temperature` | `number` | — | 采样温度，范围 0~2 |
 | `topP` | `number` | — | 核采样概率阈值，范围 0~1 |
 | `reasoningEffort` | `'low' \| 'medium' \| 'high'` | — | 推理深度。仅部分模型支持（如 o1、o3） |
+| `responseFormat` | `'text' \| 'json'` | — | 响应格式。`json` 时模型输出会被内部 `JSON.parse`，解析结果存到 `parsedContent` |
 
 ### 返回结果
 
@@ -537,8 +537,9 @@ const result = await promise;
 interface LoopResult {
   messages: Message[];              // 完整的对话历史
   harness: HarnessRecord[];         // 执行历史
-  finalContent: string | null;      // 最终回复内容
+  finalContent: string | null;      // 最终回复内容（原始字符串）
   turns: number;                    // 实际执行轮数
+  parsedContent?: unknown;          // 仅当 responseFormat === 'json' 时存在，JSON.parse 后的结果
 }
 ```
 

package/dist/function_call_loop/index.d.ts

@@ -5,10 +5,10 @@
  * - 每次 tool 执行向上层回传执行前、执行后两个事件
  * - 维护跨轮次的执行历史（Harness），tool 之间能互相看见
  * - 每次调 LLM 之前动态决定暴露哪些 tool
- * - 支持自定义上下文压缩
+ * - 支持自定义上下文 compact
  * - 每轮全局策略判断，决定继续执行还是终止降级
  * - 单轮支持多个 tool 并行执行（Plan and Execute）
  * - 系统 Prompt 完全由外部注入
  */
-export { runLoopWithModel } from './loop';
-export type { Message, ToolCall, ToolDefinition, HarnessRecord, HarnessRecordStatus, ToolExecutionStartEvent, ToolExecutionEndEvent, LoopEvent, ToolDiscoverResult, ToolExecuteContext, Tool, ApprovalConfig, TurnPolicyResult, TurnPolicy, CompressionConfig, LLMCaller, LLMCallOptions, LoopConfig, LoopResult, PendingApprovalInfo, } from './types';
+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';

package/dist/function_call_loop/index.js

@@ -6,12 +6,12 @@
  * - 每次 tool 执行向上层回传执行前、执行后两个事件
  * - 维护跨轮次的执行历史（Harness），tool 之间能互相看见
  * - 每次调 LLM 之前动态决定暴露哪些 tool
- * - 支持自定义上下文压缩
+ * - 支持自定义上下文 compact
  * - 每轮全局策略判断，决定继续执行还是终止降级
  * - 单轮支持多个 tool 并行执行（Plan and Execute）
  * - 系统 Prompt 完全由外部注入
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runLoopWithModel = void 0;
+exports.runLoop = void 0;
 var loop_1 = require("./loop");
-Object.defineProperty(exports, "runLoopWithModel", { enumerable: true, get: function () { return loop_1.runLoopWithModel; } });
+Object.defineProperty(exports, "runLoop", { enumerable: true, get: function () { return loop_1.runLoop; } });

package/dist/function_call_loop/loop.d.ts

@@ -1,23 +1,2 @@
 import type { LoopConfig, LoopResult } from './types';
 export declare function runLoop(config: LoopConfig): Promise<LoopResult>;
-/**
- * 便捷入口：直接指定模型运行 Function Call Loop。
- * 内部自动创建 LLM Caller，无需手动实现 llmCaller.call。
- *
- * 环境变量配置：
- * - `BAILIAN_API_KEY` — 必填
- * - `BAILIAN_BASE_URL` — 可选，默认百炼兼容地址
- * - `BAILIAN_DEFAULT_MODEL` — 可选，默认 `qwen-max`
- *
- * @example
- * ```ts
- * const result = await runLoopWithModel({
- *   messages: [
- *     { role: 'system', content: 'You are helpful' },
- *     { role: 'user', content: 'What is the weather?' },
- *   ],
- *   tools: [...],
- * });
- * ```
- */
-export declare function runLoopWithModel(config: Omit<LoopConfig, 'llmCaller'>): Promise<LoopResult>;

package/dist/function_call_loop/loop.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runLoop = runLoop;
-exports.runLoopWithModel = runLoopWithModel;
 const harness_1 = require("./harness");
 const provider_1 = require("./provider");
 /**
@@ -24,9 +23,19 @@ const provider_1 = require("./provider");
 function buildInitialMessages(config) {
     return [...config.messages];
 }
+const DEFAULT_BAILIAN_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
+const DEFAULT_BAILIAN_MODEL = 'qwen-max';
 function runLoop(config) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
+        const llmCaller = (_a = config.llmCaller) !== null && _a !== void 0 ? _a : (0, provider_1.createLLMCaller)({
+            apiKey: (_b = process.env.BAILIAN_API_KEY) !== null && _b !== void 0 ? _b : '',
+            baseUrl: (_c = process.env.BAILIAN_BASE_URL) !== null && _c !== void 0 ? _c : DEFAULT_BAILIAN_BASE_URL,
+            defaultModel: (_d = process.env.BAILIAN_DEFAULT_MODEL) !== null && _d !== void 0 ? _d : DEFAULT_BAILIAN_MODEL,
+        });
+        if (!config.llmCaller && !process.env.BAILIAN_API_KEY) {
+            throw new Error('BAILIAN_API_KEY environment variable is not set.');
+        }
         const harness = new harness_1.Harness();
         const messages = buildInitialMessages(config);
         let turn = 0;
@@ -40,10 +49,6 @@ function runLoop(config) {
             turn++;
             // 第二步：全局轮次策略
             const decision = yield runTurnPolicy(config, harness, turn);
-            if (decision.message) {
-                messages.push({ role: 'assistant', content: decision.message });
-                break;
-            }
             if (decision.injectMessage) {
                 messages.push({ role: 'system', content: decision.injectMessage });
             }
@@ -51,7 +56,7 @@ function runLoop(config) {
             if (config.maxTurns !== undefined && turn >= config.maxTurns) {
                 messages.push({
                     role: 'assistant',
-                    content: (_a = config.terminateMessage) !== null && _a !== void 0 ? _a : 'Max turns reached.',
+                    content: (_e = config.terminateMessage) !== null && _e !== void 0 ? _e : 'Max turns reached.',
                 });
                 break;
             }
@@ -70,30 +75,40 @@ function runLoop(config) {
             // 第四步：上下文压缩
             const messagesForLLM = yield compressMessages(config, messages, turn);
             // 第五步：调用 LLM
-            const llmResponse = yield config.llmCaller.call(messagesForLLM, toolDefinitions, {
+            const llmResponse = yield llmCaller.call(messagesForLLM, toolDefinitions, {
                 model: config.model,
                 temperature: config.temperature,
                 maxTokens: config.maxTokens,
                 topP: config.topP,
                 reasoningEffort: config.reasoningEffort,
+                responseFormat: config.responseFormat,
             });
             // 第六步：检查 LLM 回复
             if (!llmResponse.tool_calls || llmResponse.tool_calls.length === 0) {
                 messages.push({
                     role: 'assistant',
-                    content: (_b = llmResponse.content) !== null && _b !== void 0 ? _b : '',
+                    content: (_f = llmResponse.content) !== null && _f !== void 0 ? _f : '',
                 });
-                return {
+                const result = {
                     messages,
                     harness: harness.getAll(),
                     finalContent: llmResponse.content,
                     turns: turn,
                 };
+                if (config.responseFormat === 'json' && llmResponse.content) {
+                    try {
+                        Object.assign(result, { parsedContent: JSON.parse(llmResponse.content) });
+                    }
+                    catch (_h) {
+                        // JSON 解析失败时保持 parsedContent 未定义，finalContent 仍为原始字符串
+                    }
+                }
+                return result;
             }
             // 有 tool_calls，将 assistant message 加入 Messages
             messages.push({
                 role: 'assistant',
-                content: (_c = llmResponse.content) !== null && _c !== void 0 ? _c : '',
+                content: (_g = llmResponse.content) !== null && _g !== void 0 ? _g : '',
                 tool_calls: llmResponse.tool_calls,
             });
             // 第七步：并行执行 tool
@@ -140,12 +155,12 @@ function runLoop(config) {
  */
 function runTurnPolicy(config, harness, turn) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a;
         if (config.turnPolicy) {
             try {
                 return yield config.turnPolicy(harness.getAll(), turn, config.metadata);
             }
-            catch (_c) {
+            catch (_b) {
                 return {};
             }
         }
@@ -159,9 +174,7 @@ function runTurnPolicy(config, harness, turn) {
                 injectMessage: config.warningMessage,
             };
         }
-        return {
-            message: (_b = config.terminateMessage) !== null && _b !== void 0 ? _b : 'Max turns reached.',
-        };
+        return {};
     });
 }
 /**
@@ -227,7 +240,7 @@ function groupMessagesByRound(messages) {
  */
 function compressMessages(config, messages, _turn) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (!config.compression) {
+        if (!config.compact) {
             return messages;
         }
         const firstAssistantIndex = messages.findIndex((m) => m.role === 'assistant');
@@ -237,14 +250,14 @@ function compressMessages(config, messages, _turn) {
         const initialMessages = messages.slice(0, firstAssistantIndex);
         const restMessages = messages.slice(firstAssistantIndex);
         const rounds = groupMessagesByRound(restMessages);
-        if (rounds.length <= config.compression.keepRounds) {
+        if (rounds.length <= config.compact.keepRounds) {
             return messages;
         }
-        const keepCount = config.compression.keepRounds;
+        const keepCount = config.compact.keepRounds;
         const oldRounds = rounds.slice(0, rounds.length - keepCount);
         const recentRounds = rounds.slice(rounds.length - keepCount);
         try {
-            const compressed = yield config.compression.compress(oldRounds);
+            const compressed = yield config.compact.compress(oldRounds);
             return [...initialMessages, ...compressed, ...recentRounds.flat()];
         }
         catch (_a) {
@@ -433,40 +446,3 @@ function executeToolsInParallel(config, harness, toolCalls, visibleToolNames, ha
         return results;
     });
 }
-const DEFAULT_BAILIAN_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
-const DEFAULT_BAILIAN_MODEL = 'qwen-max';
-/**
- * 便捷入口：直接指定模型运行 Function Call Loop。
- * 内部自动创建 LLM Caller，无需手动实现 llmCaller.call。
- *
- * 环境变量配置：
- * - `BAILIAN_API_KEY` — 必填
- * - `BAILIAN_BASE_URL` — 可选，默认百炼兼容地址
- * - `BAILIAN_DEFAULT_MODEL` — 可选，默认 `qwen-max`
- *
- * @example
- * ```ts
- * const result = await runLoopWithModel({
- *   messages: [
- *     { role: 'system', content: 'You are helpful' },
- *     { role: 'user', content: 'What is the weather?' },
- *   ],
- *   tools: [...],
- * });
- * ```
- */
-function runLoopWithModel(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const apiKey = process.env.BAILIAN_API_KEY;
-        if (!apiKey) {
-            throw new Error('BAILIAN_API_KEY environment variable is not set.');
-        }
-        const llmCaller = (0, provider_1.createLLMCaller)({
-            apiKey,
-            baseUrl: (_a = process.env.BAILIAN_BASE_URL) !== null && _a !== void 0 ? _a : DEFAULT_BAILIAN_BASE_URL,
-            defaultModel: (_b = process.env.BAILIAN_DEFAULT_MODEL) !== null && _b !== void 0 ? _b : DEFAULT_BAILIAN_MODEL,
-        });
-        return runLoop(Object.assign(Object.assign({}, config), { llmCaller }));
-    });
-}

package/dist/function_call_loop/provider.d.ts

@@ -1,6 +1,6 @@
 /**
- * Function Call Loop 独立的 LLM Provider 实现。
- * 兼容 OpenAI 协议，不依赖 predict 模块。
+ * Function Call Loop 的 LLM Provider 适配器。
+ * 基于 predict 模块的 `callChatCompletions` 构建，共用底层 OpenAI 协议 HTTP 层。
  */
 import type { Message, ToolCall, ToolDefinition, LLMCallOptions } from './types';
 export interface ProviderOptions {

package/dist/function_call_loop/provider.js

@@ -10,6 +10,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLLMCaller = createLLMCaller;
+const llm_provider_1 = require("../llm_provider");
+function toOpenAIMessages(messages) {
+    return messages.map((m) => {
+        var _a;
+        return ({
+            role: m.role,
+            content: m.content,
+            tool_calls: (_a = m.tool_calls) === null || _a === void 0 ? void 0 : _a.map((tc) => ({
+                id: tc.id,
+                type: tc.type,
+                function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                },
+            })),
+            tool_call_id: m.tool_call_id,
+        });
+    });
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: t.type,
+        function: {
+            name: t.function.name,
+            description: t.function.description,
+            parameters: t.function.parameters,
+        },
+    }));
+}
 /**
  * 基于 OpenAI 协议的 LLM 调用器。
  */
@@ -17,66 +46,22 @@ function createLLMCaller(options) {
     return {
         call(messages, tools, callOptions) {
             return __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
-                const url = `${options.baseUrl}/chat/completions`;
-                const body = {
+                var _a, _b;
+                const data = yield (0, llm_provider_1.callChatCompletions)(options.baseUrl, options.apiKey, {
                     model: (_a = callOptions === null || callOptions === void 0 ? void 0 : callOptions.model) !== null && _a !== void 0 ? _a : options.defaultModel,
-                    messages: messages.map((m) => {
-                        var _a;
-                        return ({
-                            role: m.role,
-                            content: m.content,
-                            tool_calls: (_a = m.tool_calls) === null || _a === void 0 ? void 0 : _a.map((tc) => ({
-                                id: tc.id,
-                                type: tc.type,
-                                function: {
-                                    name: tc.function.name,
-                                    arguments: tc.function.arguments,
-                                },
-                            })),
-                            tool_call_id: m.tool_call_id,
-                        });
-                    }),
+                    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
-                        ? tools.map((t) => ({
-                            type: t.type,
-                            function: {
-                                name: t.function.name,
-                                description: t.function.description,
-                                parameters: t.function.parameters,
-                            },
-                        }))
+                    tools: tools.length > 0 ? toOpenAITools(tools) : undefined,
+                    response_format: (callOptions === null || callOptions === void 0 ? void 0 : callOptions.responseFormat)
+                        ? { type: callOptions.responseFormat === 'json' ? 'json_object' : 'text' }
                         : undefined,
-                };
-                let response;
-                try {
-                    response = yield 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 response.text();
-                    throw new Error(`[llm] HTTP ${response.status}: ${text}`);
-                }
-                const data = (yield response.json());
-                const choice = (_b = data.choices) === null || _b === void 0 ? void 0 : _b[0];
-                if (!choice) {
-                    throw new Error('[llm] No choice in response');
-                }
+                }, 'llm');
+                const choice = data.choices[0];
                 return {
                     content: choice.message.content,
-                    tool_calls: (_c = choice.message.tool_calls) === null || _c === void 0 ? void 0 : _c.map((tc) => ({
+                    tool_calls: (_b = choice.message.tool_calls) === null || _b === void 0 ? void 0 : _b.map((tc) => ({
                         id: tc.id,
                         type: tc.type,
                         function: {

package/dist/function_call_loop/types.d.ts

@@ -121,8 +121,6 @@ export interface Tool {
  * Turn Policy 决策结果。
  */
 export interface TurnPolicyResult {
-    /** 终止 Loop，此消息作为 assistant 回复写入历史 */
-    readonly message?: string;
     /** 继续执行前作为 system 消息注入 */
     readonly injectMessage?: string;
 }
@@ -133,7 +131,7 @@ export type TurnPolicy = (harness: ReadonlyArray<HarnessRecord>, turn: number, m
 /**
  * 上下文压缩配置。
  */
-export interface CompressionConfig {
+export interface CompactConfig {
     readonly keepRounds: number;
     readonly compress: (messages: ReadonlyArray<ReadonlyArray<Message>>) => Message[] | Promise<Message[]>;
 }
@@ -146,6 +144,7 @@ export interface LLMCallOptions {
     readonly maxTokens?: number;
     readonly topP?: number;
     readonly reasoningEffort?: 'low' | 'medium' | 'high';
+    readonly responseFormat?: 'text' | 'json';
 }
 /**
  * LLM 调用接口。由外部注入，Loop 内部不绑定具体 Provider。
@@ -163,10 +162,10 @@ export interface LoopConfig {
     /** 初始消息列表，直接作为对话起点 */
     readonly messages: ReadonlyArray<Message>;
     readonly tools: ReadonlyArray<Tool>;
-    readonly llmCaller: LLMCaller;
+    readonly llmCaller?: LLMCaller;
     readonly maxTurns?: number;
     readonly turnPolicy?: TurnPolicy;
-    readonly compression?: CompressionConfig;
+    readonly compact?: CompactConfig;
     readonly metadata?: unknown;
     /** 告警文本：当 turnPolicy 未自定义且当前轮次等于 maxTurns - 1 时塞入 Messages */
     readonly warningMessage?: string;
@@ -177,7 +176,7 @@ export interface LoopConfig {
     /** 取消信号 */
     readonly signal?: AbortSignal;
     /** 模型名称。未设置时从环境变量或 Provider 默认值读取 */
-    readonly model?: string;
+    readonly model?: import('../llm_provider/models').Model;
     /** 采样温度，范围 0~2 */
     readonly temperature?: number;
     /** 单次 LLM 调用的最大输出 token 数 */
@@ -186,6 +185,8 @@ export interface LoopConfig {
     readonly topP?: number;
     /** 推理深度。仅部分模型支持 */
     readonly reasoningEffort?: 'low' | 'medium' | 'high';
+    /** 响应格式。默认 text */
+    readonly responseFormat?: 'text' | 'json';
 }
 /**
  * 待审批信息。
@@ -205,4 +206,6 @@ export interface LoopResult {
     readonly finalContent: string | null;
     readonly turns: number;
     readonly pendingApproval?: PendingApprovalInfo;
+    /** 当 responseFormat === 'json' 时，finalContent 经 JSON.parse 后的结果 */
+    readonly parsedContent?: unknown;
 }

package/dist/index.d.ts

@@ -26,9 +26,10 @@ export type { LLMProvider, PredictorOptions } from './predict';
 export { Predictor } from './predict';
 /** 百炼 Provider 实现 */
 export { BailianProvider } from './predict';
-/** 模型注册表，定义模型与 Provider 的映射关系 */
-export { MODEL_REGISTRY } from './predict';
-export type { Model, PredictConfig, PredictWithMessagesConfig } from './predict';
+/** 模型注册表与枚举，定义模型与 Provider 的映射关系 */
+export { MODEL_REGISTRY } from './llm_provider';
+export type { Model } from './llm_provider';
+export type { PredictConfig, PredictWithMessagesConfig } from './predict';
 /** 向量检索（Embedding + pgvector + Rerank） */
 export { EmbeddingSearch, embed } from './embedding_search';
 export type { EmbeddingSearchConfig, SearchResult } from './embedding_search';

package/dist/index.js

@@ -63,9 +63,9 @@ Object.defineProperty(exports, "Predictor", { enumerable: true, get: function ()
 /** 百炼 Provider 实现 */
 var predict_3 = require("./predict");
 Object.defineProperty(exports, "BailianProvider", { enumerable: true, get: function () { return predict_3.BailianProvider; } });
-/** 模型注册表，定义模型与 Provider 的映射关系 */
-var predict_4 = require("./predict");
-Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return predict_4.MODEL_REGISTRY; } });
+/** 模型注册表与枚举，定义模型与 Provider 的映射关系 */
+var llm_provider_1 = require("./llm_provider");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return llm_provider_1.MODEL_REGISTRY; } });
 /** 向量检索（Embedding + pgvector + Rerank） */
 var embedding_search_1 = require("./embedding_search");
 Object.defineProperty(exports, "EmbeddingSearch", { enumerable: true, get: function () { return embedding_search_1.EmbeddingSearch; } });