@keo-ai/axiom 0.2.2 → 0.2.3

package/README.md

@@ -473,6 +473,37 @@ for await (const chunk of stream) {
 
 **向后兼容**：返回普通值（非 `ToolResult`）时行为完全不变，仍按原有逻辑 `JSON.stringify` 后透给 LLM。
 
+#### 用 ToolResult 终止 Loop（end tool）
+
+当某个 tool 的执行结果就是最终答案、不需要再调 LLM 时，可以设置 `endLoop: true`：
+
+```ts
+const finalAnswerTool = {
+  name: 'get_answer',
+  description: 'Get final answer',
+  parameters: { /* ... */ },
+  execute: async (args) => {
+    const answer = await computeAnswer(args);
+    return {
+      forLLM: '已找到最终答案',
+      forFrontend: answer,
+      endLoop: true,
+      finalContent: answer.summary,
+    };
+  },
+};
+```
+
+| 字段 | 说明 |
+|---|---|
+| `endLoop` | 为 `true` 时，该 tool 执行完成后直接结束 Loop，不再进入下一轮 LLM 调用 |
+| `finalContent` | 可选。设置后作为 `LoopResult.finalContent` 返回；不设置则使用 `forLLM` |
+
+**行为规则**：
+- `endLoop` 仅在 execute 成功返回 `ToolResult` 时生效
+- 若一轮并行调用中有多个 tool 都设置 `endLoop`，取第一个完成的结果作为最终输出
+- `pendingApproval` 的优先级高于 `endLoop`：未审批时先返回 `pendingApproval`
+
 ### Tool 审批拦截
 
 对于敏感操作（转账、删除数据等），可以给 tool 配置 `approval`，Loop 会在执行前暂停并返回 `pendingApproval`：

package/dist/function_call_loop/loop.d.ts

@@ -29,6 +29,8 @@ export type ExecutionResult = {
         toolName: string;
         args: unknown;
     };
+    endLoop?: boolean;
+    finalContent?: string;
 };
 /**
  * 并行执行 tool。

package/dist/function_call_loop/loop.js

@@ -32,7 +32,7 @@ const DEFAULT_BAILIAN_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode
 const DEFAULT_BAILIAN_MODEL = 'qwen-max';
 function runLoop(config) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         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,
@@ -157,6 +157,18 @@ function runLoop(config) {
                     totalUsage: computeTotalUsage(),
                 };
             }
+            // 检查是否有 tool 要求结束 Loop
+            const endLoopResult = parallelResults.find((r) => r.endLoop);
+            if (endLoopResult === null || endLoopResult === void 0 ? void 0 : endLoopResult.endLoop) {
+                return {
+                    messages,
+                    harness: harness.getAll(),
+                    finalContent: (_h = endLoopResult.finalContent) !== null && _h !== void 0 ? _h : endLoopResult.content,
+                    turns: turn,
+                    usageHistory,
+                    totalUsage: computeTotalUsage(),
+                };
+            }
             // 第八步：回到第一步继续下一轮
         }
         // Loop 被终止（Turn Policy 或硬限制）
@@ -399,10 +411,14 @@ function executeToolsInParallel(config, harness, toolCalls, visibleToolNames, ha
             };
             let content;
             let frontendData;
+            let endLoop;
+            let finalContent;
             if (status === 'success') {
                 if (isToolResult(result)) {
                     content = result.forLLM;
                     frontendData = result.forFrontend;
+                    endLoop = result.endLoop;
+                    finalContent = result.finalContent;
                 }
                 else {
                     content =
@@ -418,6 +434,8 @@ function executeToolsInParallel(config, harness, toolCalls, visibleToolNames, ha
                 toolCallId: callId,
                 content,
                 frontendData,
+                endLoop,
+                finalContent,
                 record: finalRecord,
                 events: [endEvent],
                 pendingApproval: typeof result === 'object' &&

package/dist/function_call_loop/stream.js

@@ -54,7 +54,7 @@ function buildInitialMessages(config) {
 function runLoopStream(config) {
     return __asyncGenerator(this, arguments, function* runLoopStream_1() {
         var _a, e_1, _b, _c;
-        var _d, _e, _f, _g, _h, _j, _k;
+        var _d, _e, _f, _g, _h, _j, _k, _l;
         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,
@@ -135,9 +135,9 @@ function runLoopStream(config) {
                 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) {
+                for (var _m = 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; _m = true) {
                     _c = stream_1_1.value;
-                    _l = false;
+                    _m = false;
                     const chunk = _c;
                     if (chunk.type === 'content') {
                         fullContent += chunk.delta;
@@ -155,7 +155,7 @@ function runLoopStream(config) {
             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));
+                    if (!_m && !_a && (_b = stream_1.return)) yield __await(_b.call(stream_1));
                 }
                 finally { if (e_1) throw e_1.error; }
             }
@@ -234,6 +234,19 @@ function runLoopStream(config) {
                     totalUsage: computeTotalUsage(),
                 });
             }
+            // 检查是否有 tool 要求结束 Loop
+            const endLoopResult = parallelResults.find((r) => r.endLoop);
+            if (endLoopResult === null || endLoopResult === void 0 ? void 0 : endLoopResult.endLoop) {
+                yield yield __await({ type: 'turn_end', turn, usage: finishChunk.usage });
+                return yield __await({
+                    messages,
+                    harness: harness.getAll(),
+                    finalContent: (_l = endLoopResult.finalContent) !== null && _l !== void 0 ? _l : endLoopResult.content,
+                    turns: turn,
+                    usageHistory,
+                    totalUsage: computeTotalUsage(),
+                });
+            }
             yield yield __await({ type: 'turn_end', turn, usage: finishChunk.usage });
             // 第八步：回到第一步继续下一轮
         }

package/dist/function_call_loop/types.d.ts

@@ -113,10 +113,15 @@ export interface ApprovalConfig {
  * Tool 执行结果的分流包装。
  * 当 execute 返回此类型时，forLLM 进入 messages[] 给 LLM 上下文，
  * forFrontend 通过 SSE tool_result 事件透给前端渲染。
+ * 设置 endLoop 为 true 可让 Loop 在执行完该 tool 后直接终止，不再调用 LLM。
  */
 export interface ToolResult {
     readonly forLLM: string;
     readonly forFrontend?: unknown;
+    /** 为 true 时，tool 执行完成后直接结束 Loop，不再进入下一轮 LLM 调用 */
+    readonly endLoop?: boolean;
+    /** endLoop 为 true 时，作为 LoopResult.finalContent 返回；不设置则使用 forLLM */
+    readonly finalContent?: string;
 }
 /**
  * 注册到 Loop 中的 Tool。

package/package.json

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