@keo-ai/axiom 0.1.4 → 0.1.5

package/README.md

@@ -213,9 +213,7 @@ Function Call Loop 是 Axiom 的底层 Function Call 引擎。它负责把 **LLM
 
 ### 快速开始
 
-#### 方式一：直接传模型参数（推荐）
-
-像 predict 模块一样，设置环境变量后一行调用：
+设置环境变量后一行调用：
 
 ```bash
 export BAILIAN_API_KEY="your-api-key"
@@ -224,12 +222,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 +241,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
         },
         required: ['city'],
       },
-      execute: async (args) => {
+      execute: async (args, context) => {
         return { temperature: 25, condition: 'Sunny' };
       },
     },
@@ -266,7 +264,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 +313,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 +331,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
           return { ticketId: ticket.id };
         },
       },
-      execute: async (args) => {
+      execute: async (args, context) => {
         // 审批通过后才会执行到这里
         return await doTransfer(args);
       },
@@ -357,7 +355,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 +373,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 +404,7 @@ const tool = {
       visible: isAdmin,
     };
   },
-  execute: async (args) => { /* ... */ },
+  execute: async (args, context) => { /* ... */ },
 };
 ```
 
@@ -419,17 +417,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 +441,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 +472,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
 
 | 规则 | 说明 |
 |---|---|
-| 压缩只影响 Messages | Harness 始终完整保留 |
+| compact 只影响 Messages | Harness 始终完整保留 |
 | 系统消息和初始输入不参与压缩 | 始终保留 |
 | `compress` 抛异常 | 视为不压缩，使用原始 Messages 继续执行 |
 
@@ -486,7 +483,7 @@ const result = await FunctionCallLoop.runLoopWithModel({
 ```ts
 const controller = new AbortController();
 
-const promise = FunctionCallLoop.runLoopWithModel({
+const promise = FunctionCallLoop.runLoop({
   // ...
   signal: controller.signal,
 });
@@ -499,7 +496,7 @@ const result = await promise;
 
 ### 配置项
 
-#### `runLoopWithModel` 配置
+#### `runLoop` 配置
 
 **对话入口**
 
@@ -512,9 +509,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,7 +523,7 @@ 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 |

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,7 +75,7 @@ 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,
@@ -81,7 +86,7 @@ function runLoop(config) {
             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 {
                     messages,
@@ -93,7 +98,7 @@ function runLoop(config) {
             // 有 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 +145,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 +164,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 +230,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 +240,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 +436,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,19 @@ 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,
-                            },
-                        }))
-                        : 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');
-                }
+                    tools: tools.length > 0 ? toOpenAITools(tools) : undefined,
+                }, '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[]>;
 }
@@ -163,10 +161,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 +175,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 数 */

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; } });

package/dist/llm_provider/bailian.d.ts

@@ -0,0 +1,28 @@
+import type { LLMProvider } from './llm';
+import type { LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+/**
+ * 阿里云百炼（兼容 OpenAI 协议）Provider 实现。
+ * 支持非流式调用和流式 SSE 输出。
+ */
+export declare class BailianProvider implements LLMProvider {
+    readonly config: ProviderConfig;
+    readonly name = "bailian";
+    private static readonly SUPPORTED_MODELS;
+    constructor(config: ProviderConfig);
+    supports(model: string): boolean;
+    /**
+     * 发送非流式 chat completion 请求到百炼服务。
+     * @param request - 标准化 LLM 请求
+     * @returns 解析后的模型响应（含 content、usage、model）
+     * @throws Error - 网络异常时抛 `[bailian] ...`；HTTP 非 2xx 时抛 `[bailian] HTTP {status}: ...`
+     */
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * 发送流式 chat completion 请求，解析 SSE 响应逐块返回。
+     * @param request - 标准化 LLM 请求
+     * @yields 内容片段（`content`）或结束标记（`finish`）
+     * @throws Error - 网络异常或 HTTP 错误时抛出
+     */
+    stream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    private buildRequestBody;
+}

package/dist/llm_provider/bailian.js

@@ -0,0 +1,174 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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.BailianProvider = void 0;
+const index_1 = require("./index");
+/**
+ * 阿里云百炼（兼容 OpenAI 协议）Provider 实现。
+ * 支持非流式调用和流式 SSE 输出。
+ */
+class BailianProvider {
+    constructor(config) {
+        this.config = config;
+        this.name = 'bailian';
+    }
+    supports(model) {
+        return BailianProvider.SUPPORTED_MODELS.has(model);
+    }
+    /**
+     * 发送非流式 chat completion 请求到百炼服务。
+     * @param request - 标准化 LLM 请求
+     * @returns 解析后的模型响应（含 content、usage、model）
+     * @throws Error - 网络异常时抛 `[bailian] ...`；HTTP 非 2xx 时抛 `[bailian] HTTP {status}: ...`
+     */
+    generate(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const body = this.buildRequestBody(request);
+            const data = yield (0, index_1.callChatCompletions)(this.config.baseUrl, this.config.apiKey, Object.assign(Object.assign({}, body), { stream: false }), this.name);
+            const choice = data.choices[0];
+            return {
+                content: choice.message.content,
+                usage: data.usage
+                    ? {
+                        promptTokens: data.usage.prompt_tokens,
+                        completionTokens: data.usage.completion_tokens,
+                        totalTokens: data.usage.total_tokens,
+                    }
+                    : undefined,
+                model: (_a = data.model) !== null && _a !== void 0 ? _a : body.model,
+            };
+        });
+    }
+    /**
+     * 发送流式 chat completion 请求，解析 SSE 响应逐块返回。
+     * @param request - 标准化 LLM 请求
+     * @yields 内容片段（`content`）或结束标记（`finish`）
+     * @throws Error - 网络异常或 HTTP 错误时抛出
+     */
+    stream(request) {
+        return __asyncGenerator(this, arguments, function* stream_1() {
+            var _a, _b;
+            const url = `${this.config.baseUrl}/chat/completions`;
+            const body = this.buildRequestBody(request);
+            let response;
+            try {
+                response = yield __await(fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.config.apiKey}`,
+                    },
+                    body: JSON.stringify(Object.assign(Object.assign({}, body), { stream: true })),
+                }));
+            }
+            catch (cause) {
+                throw new Error(`[${this.name}] ${cause instanceof Error ? cause.message : String(cause)}`);
+            }
+            if (!response.ok) {
+                const text = yield __await(response.text());
+                throw new Error(`[${this.name}] HTTP ${response.status}: ${text}`);
+            }
+            if (!response.body) {
+                throw new Error(`[${this.name}] Response body is null`);
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            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 = (_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 (_c) {
+                            continue;
+                        }
+                        const choice = (_b = parsed.choices) === null || _b === void 0 ? void 0 : _b[0];
+                        if (!choice)
+                            continue;
+                        const delta = choice.delta;
+                        if (delta.content) {
+                            yield yield __await({ type: 'content', delta: delta.content });
+                        }
+                        if (choice.finish_reason && parsed.usage) {
+                            yield yield __await({
+                                type: 'finish',
+                                usage: {
+                                    promptTokens: parsed.usage.prompt_tokens,
+                                    completionTokens: parsed.usage.completion_tokens,
+                                    totalTokens: parsed.usage.total_tokens,
+                                },
+                            });
+                        }
+                    }
+                }
+                yield yield __await({ type: 'finish' });
+            }
+            finally {
+                reader.releaseLock();
+            }
+        });
+    }
+    buildRequestBody(request) {
+        var _a;
+        return {
+            model: (_a = request.model) !== null && _a !== void 0 ? _a : this.config.defaultModel,
+            messages: request.messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+            })),
+            temperature: request.temperature,
+            max_tokens: request.maxTokens,
+            top_p: request.topP,
+            response_format: request.responseFormat
+                ? { type: request.responseFormat === 'json' ? 'json_object' : 'text' }
+                : undefined,
+        };
+    }
+}
+exports.BailianProvider = BailianProvider;
+BailianProvider.SUPPORTED_MODELS = new Set([
+    'qwen3.7-max',
+    'qwen-plus',
+    'qwen-turbo',
+    'qwq-plus',
+    'deepseek-v4-pro',
+    'deepseek-v4-flash',
+    'kimi-k2.6',
+    'qwen-vl-plus',
+]);

package/dist/llm_provider/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * LLM Provider 底层 HTTP 调用层。
+ * Predict 模块和 Function Call Loop 模块共用，只负责纯粹的请求/响应/错误处理。
+ */
+export interface OpenAIChatMessage {
+    role: string;
+    content: string | null;
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    tool_call_id?: string;
+}
+export interface OpenAIChatTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: unknown;
+    };
+}
+export interface OpenAIChatRequest {
+    model: string;
+    messages: OpenAIChatMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    tools?: OpenAIChatTool[];
+    response_format?: {
+        type: 'text' | 'json_object';
+    };
+    stream?: boolean;
+}
+export interface OpenAIChatResponse {
+    choices: Array<{
+        message: {
+            content: string | null;
+            tool_calls?: Array<{
+                id: string;
+                type: 'function';
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+            }>;
+        };
+        finish_reason: string | null;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    model?: string;
+}
+/**
+ * 发送 OpenAI 兼容的 chat completions 请求。
+ * 只做 HTTP 层：构造请求、fetch、错误处理、基础解析。
+ * 业务层（请求体组装、结果转换）由调用方负责。
+ */
+export declare function callChatCompletions(baseUrl: string, apiKey: string, body: OpenAIChatRequest, errorPrefix?: string): Promise<OpenAIChatResponse>;
+/** 模型枚举与注册表 */
+export type { Model, ModelConfig } from './models';
+export { MODEL_REGISTRY } from './models';
+/** 标准化类型 */
+export type { Message, LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+/** Provider 接口与实现 */
+export type { LLMProvider } from './llm';
+export { BailianProvider } from './bailian';

package/dist/llm_provider/index.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * LLM Provider 底层 HTTP 调用层。
+ * Predict 模块和 Function Call Loop 模块共用，只负责纯粹的请求/响应/错误处理。
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BailianProvider = exports.MODEL_REGISTRY = void 0;
+exports.callChatCompletions = callChatCompletions;
+/**
+ * 发送 OpenAI 兼容的 chat completions 请求。
+ * 只做 HTTP 层：构造请求、fetch、错误处理、基础解析。
+ * 业务层（请求体组装、结果转换）由调用方负责。
+ */
+function callChatCompletions(baseUrl_1, apiKey_1, body_1) {
+    return __awaiter(this, arguments, void 0, function* (baseUrl, apiKey, body, errorPrefix = 'llm') {
+        var _a;
+        const url = `${baseUrl}/chat/completions`;
+        let response;
+        try {
+            response = yield fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (cause) {
+            throw new Error(`[${errorPrefix}] ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+        if (!response.ok) {
+            const text = yield response.text();
+            throw new Error(`[${errorPrefix}] HTTP ${response.status}: ${text}`);
+        }
+        let data;
+        try {
+            data = (yield response.json());
+        }
+        catch (cause) {
+            throw new Error(`[${errorPrefix}] Failed to parse response: ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+        const choice = (_a = data.choices) === null || _a === void 0 ? void 0 : _a[0];
+        if (!choice) {
+            throw new Error(`[${errorPrefix}] No choice in response`);
+        }
+        return data;
+    });
+}
+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

@@ -0,0 +1,32 @@
+import type { LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+/**
+ * LLM Provider 抽象接口。每个 Provider 实现负责对接具体的模型服务
+ *（如百炼、OpenAI、Anthropic 等），处理 HTTP 请求、流式解析和错误转换。
+ */
+export interface LLMProvider {
+    /** Provider 标识名，用于路由和故障转移日志 */
+    readonly name: string;
+    /** Provider 配置（API Key、Base URL、默认模型等） */
+    readonly config: ProviderConfig;
+    /**
+     * 校验当前 Provider 是否支持指定模型。
+     * 框架层在 MODEL_REGISTRY 候选过滤后，再调用此方法做二次确认。
+     * @param model - 模型标识名
+     * @returns true 表示支持，false 表示不支持（将自动轮询下一个候选）
+     */
+    supports(model: string): boolean;
+    /**
+     * 发送非流式请求，返回完整的模型响应。
+     * @param request - LLM 请求参数
+     * @returns 模型生成的完整响应
+     * @throws 网络异常、HTTP 错误、解析失败等均抛 {@link Error}
+     */
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * 发送流式请求，逐块返回模型输出。
+     * @param request - LLM 请求参数
+     * @yields 内容片段或结束标记
+     * @throws 网络异常、HTTP 错误等均抛 {@link Error}
+     */
+    stream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+}

package/dist/llm_provider/llm.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/llm_provider/models.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 支持的模型枚举。项目层通过此枚举选择模型，Axiom 内部路由到对应 Provider。
+ */
+export type Model = 'qwen3.7-max' | 'qwen-plus' | 'qwen-turbo' | 'qwq-plus' | 'deepseek-v4-pro' | 'deepseek-v4-flash' | 'kimi-k2.6' | 'qwen-vl-plus';
+/** 模型到 Provider 的映射配置 */
+export interface ModelConfig {
+    readonly model: string;
+    readonly provider: string;
+}
+/**
+ * 模型注册表。每个模型对应一个或多个 Provider 候选，按优先级排序。
+ * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
+ */
+export declare const MODEL_REGISTRY: Readonly<Record<Model, ReadonlyArray<ModelConfig>>>;

package/dist/llm_provider/models.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_REGISTRY = void 0;
+/**
+ * 模型注册表。每个模型对应一个或多个 Provider 候选，按优先级排序。
+ * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
+ */
+exports.MODEL_REGISTRY = {
+    'qwen3.7-max': [{ model: 'qwen3.7-max', provider: 'bailian' }],
+    'qwen-plus': [{ model: 'qwen-plus', provider: 'bailian' }],
+    'qwen-turbo': [{ model: 'qwen-turbo', provider: 'bailian' }],
+    'qwq-plus': [{ model: 'qwq-plus', provider: 'bailian' }],
+    'deepseek-v4-pro': [{ model: 'deepseek-v4-pro', provider: 'bailian' }],
+    'deepseek-v4-flash': [{ model: 'deepseek-v4-flash', provider: 'bailian' }],
+    'kimi-k2.6': [{ model: 'kimi-k2.6', provider: 'bailian' }],
+    'qwen-vl-plus': [{ model: 'qwen-vl-plus', provider: 'bailian' }],
+};

package/dist/llm_provider/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * LLM 对话消息。支持 system、user、assistant 三种角色。
+ */
+export interface Message {
+    readonly role: 'system' | 'user' | 'assistant';
+    readonly content: string;
+}
+/**
+ * 标准化 LLM 请求参数。各 Provider 据此构建自身的协议请求。
+ */
+export interface LLMRequest {
+    readonly messages: ReadonlyArray<Message>;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly topP?: number;
+    readonly stream?: boolean;
+    readonly model?: string;
+    readonly responseFormat?: 'text' | 'json';
+}
+/**
+ * 标准化 LLM 响应。各 Provider 将原始响应解析为此格式后返回。
+ */
+export interface LLMResponse {
+    readonly content: string | null;
+    readonly usage?: {
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+        readonly totalTokens: number;
+    };
+    readonly model: string;
+}
+/**
+ * 流式输出片段。迭代器每次 yield 一个 chunk。
+ */
+export type StreamChunk = {
+    readonly type: 'content';
+    readonly delta: string;
+} | {
+    readonly type: 'finish';
+    usage?: LLMResponse['usage'];
+};
+/**
+ * Provider 配置。每个 Provider 实例需要一组连接参数。
+ */
+export interface ProviderConfig {
+    readonly name: string;
+    readonly apiKey: string;
+    readonly baseUrl: string;
+    readonly defaultModel: string;
+    readonly timeoutMs?: number;
+}

package/dist/llm_provider/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/predict/config.d.ts

@@ -1,5 +1,5 @@
-import type { Message } from './types';
-import type { Model } from './models';
+import type { Message } from '../llm_provider/types';
+import type { Model } from '../llm_provider/models';
 /**
  * `predict()` 的配置参数。用于单轮快速调用场景，内部自动构建 user message。
  */

package/dist/predict/index.d.ts

@@ -1,8 +1,9 @@
-export type { LLMRequest, LLMResponse, Message, ProviderConfig, StreamChunk, } from './types';
-export type { LLMProvider, PredictorOptions } from './llm';
+export type { LLMRequest, LLMResponse, Message, ProviderConfig, StreamChunk, } from '../llm_provider/types';
+export type { LLMProvider } from '../llm_provider/llm';
+export type { PredictorOptions } from './llm';
 export { Predictor } from './llm';
-export { BailianProvider } from './providers/bailian';
-export type { Model } from './models';
-export { MODEL_REGISTRY } from './models';
+export { BailianProvider } from '../llm_provider/bailian';
+export type { Model } from '../llm_provider/models';
+export { MODEL_REGISTRY } from '../llm_provider/models';
 export type { PredictConfig, PredictWithMessagesConfig } from './config';
 export { LLM } from './predict';

package/dist/predict/index.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLM = exports.MODEL_REGISTRY = exports.BailianProvider = exports.Predictor = void 0;
 var llm_1 = require("./llm");
 Object.defineProperty(exports, "Predictor", { enumerable: true, get: function () { return llm_1.Predictor; } });
-var bailian_1 = require("./providers/bailian");
+var bailian_1 = require("../llm_provider/bailian");
 Object.defineProperty(exports, "BailianProvider", { enumerable: true, get: function () { return bailian_1.BailianProvider; } });
-var models_1 = require("./models");
+var models_1 = require("../llm_provider/models");
 Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return models_1.MODEL_REGISTRY; } });
 var predict_1 = require("./predict");
 Object.defineProperty(exports, "LLM", { enumerable: true, get: function () { return predict_1.LLM; } });

package/dist/predict/llm.d.ts

@@ -1,36 +1,6 @@
-import type { LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
-import type { Model } from './models';
-/**
- * LLM Provider 抽象接口。每个 Provider 实现负责对接具体的模型服务
- *（如百炼、OpenAI、Anthropic 等），处理 HTTP 请求、流式解析和错误转换。
- */
-export interface LLMProvider {
-    /** Provider 标识名，用于路由和故障转移日志 */
-    readonly name: string;
-    /** Provider 配置（API Key、Base URL、默认模型等） */
-    readonly config: ProviderConfig;
-    /**
-     * 校验当前 Provider 是否支持指定模型。
-     * 框架层在 MODEL_REGISTRY 候选过滤后，再调用此方法做二次确认。
-     * @param model - 模型标识名
-     * @returns true 表示支持，false 表示不支持（将自动轮询下一个候选）
-     */
-    supports(model: string): boolean;
-    /**
-     * 发送非流式请求，返回完整的模型响应。
-     * @param request - LLM 请求参数
-     * @returns 模型生成的完整响应
-     * @throws 网络异常、HTTP 错误、解析失败等均抛 {@link Error}
-     */
-    generate(request: LLMRequest): Promise<LLMResponse>;
-    /**
-     * 发送流式请求，逐块返回模型输出。
-     * @param request - LLM 请求参数
-     * @yields 内容片段或结束标记
-     * @throws 网络异常、HTTP 错误等均抛 {@link Error}
-     */
-    stream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
-}
+import type { LLMRequest, LLMResponse, StreamChunk } from '../llm_provider/types';
+import type { LLMProvider } from '../llm_provider/llm';
+import type { Model } from '../llm_provider/models';
 /** Predictor 构造选项 */
 export interface PredictorOptions {
     /** Provider 列表，按优先级排序 */

package/dist/predict/llm.js

@@ -30,7 +30,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Predictor = void 0;
-const models_1 = require("./models");
+const models_1 = require("../llm_provider/models");
 /**
  * 预测器核心类。负责按模型路由到对应 Provider，执行故障转移和重试。
  * 对外透明：调用方只需指定模型，无需关心底层是哪个 Provider。

package/dist/predict/models.d.ts

@@ -1,14 +1,2 @@
-/**
- * 支持的模型枚举。项目层通过此枚举选择模型，Axiom 内部路由到对应 Provider。
- */
-export type Model = 'qwen3.7-max' | 'qwen-plus' | 'qwen-turbo' | 'qwq-plus' | 'deepseek-v4-pro' | 'deepseek-v4-flash' | 'kimi-k2.6' | 'qwen-vl-plus';
-/** 模型到 Provider 的映射配置 */
-export interface ModelConfig {
-    readonly model: string;
-    readonly provider: string;
-}
-/**
- * 模型注册表。每个模型对应一个或多个 Provider 候选，按优先级排序。
- * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
- */
-export declare const MODEL_REGISTRY: Readonly<Record<Model, ReadonlyArray<ModelConfig>>>;
+export type { Model, ModelConfig } from '../llm_provider/models';
+export { MODEL_REGISTRY } from '../llm_provider/models';

package/dist/predict/models.js

@@ -1,17 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MODEL_REGISTRY = void 0;
-/**
- * 模型注册表。每个模型对应一个或多个 Provider 候选，按优先级排序。
- * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
- */
-exports.MODEL_REGISTRY = {
-    'qwen3.7-max': [{ model: 'qwen3.7-max', provider: 'bailian' }],
-    'qwen-plus': [{ model: 'qwen-plus', provider: 'bailian' }],
-    'qwen-turbo': [{ model: 'qwen-turbo', provider: 'bailian' }],
-    'qwq-plus': [{ model: 'qwq-plus', provider: 'bailian' }],
-    'deepseek-v4-pro': [{ model: 'deepseek-v4-pro', provider: 'bailian' }],
-    'deepseek-v4-flash': [{ model: 'deepseek-v4-flash', provider: 'bailian' }],
-    'kimi-k2.6': [{ model: 'kimi-k2.6', provider: 'bailian' }],
-    'qwen-vl-plus': [{ model: 'qwen-vl-plus', provider: 'bailian' }],
-};
+var models_1 = require("../llm_provider/models");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return models_1.MODEL_REGISTRY; } });

package/dist/predict/predict.d.ts

@@ -1,4 +1,4 @@
-import type { Message, StreamChunk } from './types';
+import type { Message, StreamChunk } from '../llm_provider/types';
 import type { PredictConfig, PredictWithMessagesConfig } from './config';
 /**
  * LLM 静态类。封装 Provider 连接、请求组装、故障转移和返回解析。

package/dist/predict/predict.js

@@ -37,7 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLM = void 0;
 const llm_1 = require("./llm");
 const config_1 = require("./config");
-const bailian_1 = require("./providers/bailian");
+const bailian_1 = require("../llm_provider/bailian");
 const DEFAULT_BAILIAN_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
 const DEFAULT_BAILIAN_MODEL = 'qwen-max';
 function createBailianProvider() {

package/dist/predict/types.d.ts

@@ -1,51 +1 @@
-/**
- * LLM 对话消息。支持 system、user、assistant 三种角色。
- */
-export interface Message {
-    readonly role: 'system' | 'user' | 'assistant';
-    readonly content: string;
-}
-/**
- * 标准化 LLM 请求参数。各 Provider 据此构建自身的协议请求。
- */
-export interface LLMRequest {
-    readonly messages: ReadonlyArray<Message>;
-    readonly temperature?: number;
-    readonly maxTokens?: number;
-    readonly topP?: number;
-    readonly stream?: boolean;
-    readonly model?: string;
-    readonly responseFormat?: 'text' | 'json';
-}
-/**
- * 标准化 LLM 响应。各 Provider 将原始响应解析为此格式后返回。
- */
-export interface LLMResponse {
-    readonly content: string | null;
-    readonly usage?: {
-        readonly promptTokens: number;
-        readonly completionTokens: number;
-        readonly totalTokens: number;
-    };
-    readonly model: string;
-}
-/**
- * 流式输出片段。迭代器每次 yield 一个 chunk。
- */
-export type StreamChunk = {
-    readonly type: 'content';
-    readonly delta: string;
-} | {
-    readonly type: 'finish';
-    readonly usage?: LLMResponse['usage'];
-};
-/**
- * Provider 配置。每个 Provider 实例需要一组连接参数。
- */
-export interface ProviderConfig {
-    readonly name: string;
-    readonly apiKey: string;
-    readonly baseUrl: string;
-    readonly defaultModel: string;
-    readonly timeoutMs?: number;
-}
+export type { Message, LLMRequest, LLMResponse, ProviderConfig, StreamChunk, } from '../llm_provider/types';

package/package.json

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