@lowire/loop 0.0.8 → 0.0.10

package/lib/loop.d.ts

@@ -14,7 +14,34 @@
  * limitations under the License.
  */
 import type * as types from './types';
-export type LoopOptions = types.CompletionOptions & {
+type PromiseOrValue<T> = T | Promise<T>;
+export type LoopEvents = {
+    onBeforeTurn?: (params: {
+        conversation: types.Conversation;
+        totalUsage: types.Usage;
+        budgetTokens: number;
+    }) => PromiseOrValue<'continue' | 'break' | void>;
+    onAfterTurn?: (params: {
+        assistantMessage: types.AssistantMessage;
+        totalUsage: types.Usage;
+        budgetTokens: number;
+    }) => PromiseOrValue<'continue' | 'break' | void>;
+    onBeforeToolCall?: (params: {
+        assistantMessage: types.AssistantMessage;
+        toolCall: types.ToolCallContentPart;
+    }) => PromiseOrValue<'continue' | 'break' | 'disallow' | void>;
+    onAfterToolCall?: (params: {
+        assistantMessage: types.AssistantMessage;
+        toolCall: types.ToolCallContentPart;
+        result: types.ToolResult;
+    }) => PromiseOrValue<'continue' | 'break' | 'disallow' | void>;
+    onToolCallError?: (params: {
+        assistantMessage: types.AssistantMessage;
+        toolCall: types.ToolCallContentPart;
+        error: Error;
+    }) => PromiseOrValue<'continue' | 'break' | void>;
+};
+export type LoopOptions = types.CompletionOptions & LoopEvents & {
     tools?: types.Tool[];
     callTool?: types.ToolCallback;
     maxTurns?: number;
@@ -23,12 +50,6 @@ export type LoopOptions = types.CompletionOptions & {
         messages: types.ReplayCache;
         secrets: Record<string, string>;
     };
-    beforeTurn?: (params: {
-        turn: number;
-        conversation: types.Conversation;
-        summarizedConversation?: types.Conversation;
-        usage: types.Usage;
-    }) => 'break' | 'continue' | void;
     summarize?: boolean;
 };
 export declare class Loop {
@@ -42,7 +63,9 @@ export declare class Loop {
         result?: T;
         status: 'ok' | 'break';
         usage: types.Usage;
+        turns: number;
     }>;
     private _summarizeConversation;
     cache(): types.ReplayCache;
 }
+export {};

package/lib/loop.js

@@ -43,27 +43,37 @@ class Loop {
             tools: allTools,
         };
         const debug = options.debug;
+        let budgetTokens = options.maxTokens ?? 100_000;
         const totalUsage = { input: 0, output: 0 };
         debug?.('lowire:loop')(`Starting ${this._provider.name} loop`, task);
         const maxTurns = options.maxTurns || 100;
-        for (let turn = 0; turn < maxTurns; ++turn) {
-            debug?.('lowire:loop')(`Turn ${turn + 1} of (max ${maxTurns})`);
+        for (let turns = 0; turns < maxTurns; ++turns) {
+            if (budgetTokens <= 0)
+                throw new Error(`Budget tokens ${options.maxTokens} exhausted`);
+            debug?.('lowire:loop')(`Turn ${turns + 1} of (max ${maxTurns})`);
             const caches = options.cache ? {
                 input: options.cache.messages,
                 output: this._cacheOutput,
                 secrets: options.cache.secrets
             } : undefined;
             const summarizedConversation = options.summarize ? this._summarizeConversation(task, conversation, options) : conversation;
-            const status = options.beforeTurn?.({ turn, conversation, summarizedConversation, usage: totalUsage });
-            if (status === 'break')
-                return { status: 'break', usage: totalUsage };
+            const beforeStatus = await options.onBeforeTurn?.({ conversation: summarizedConversation, totalUsage, budgetTokens });
+            if (beforeStatus === 'break')
+                return { status: 'break', usage: totalUsage, turns };
             debug?.('lowire:loop')(`Request`, JSON.stringify({ ...summarizedConversation, tools: `${summarizedConversation.tools.length} tools` }, null, 2));
-            const { result: assistantMessage, usage } = await (0, cache_1.cachedComplete)(this._provider, summarizedConversation, caches, options);
+            const { result: assistantMessage, usage } = await (0, cache_1.cachedComplete)(this._provider, summarizedConversation, caches, {
+                ...options,
+                maxTokens: budgetTokens,
+            });
             const intent = assistantMessage.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
-            debug?.('lowire:loop')('Usage', `input: ${usage.input}, output: ${usage.output}`);
-            debug?.('lowire:loop')('Assistant', intent, JSON.stringify(assistantMessage.content, null, 2));
             totalUsage.input += usage.input;
             totalUsage.output += usage.output;
+            budgetTokens -= usage.input + usage.output;
+            debug?.('lowire:loop')('Usage', `input: ${usage.input}, output: ${usage.output}`);
+            debug?.('lowire:loop')('Assistant', intent, JSON.stringify(assistantMessage.content, null, 2));
+            const afterStatus = await options.onAfterTurn?.({ assistantMessage, totalUsage, budgetTokens });
+            if (afterStatus === 'break')
+                return { status: 'break', usage: totalUsage, turns };
             conversation.messages.push(assistantMessage);
             const toolCalls = assistantMessage.content.filter(part => part.type === 'tool_call');
             if (toolCalls.length === 0) {
@@ -74,7 +84,17 @@ class Loop {
                 const { name, arguments: args } = toolCall;
                 debug?.('lowire:loop')('Call tool', name, JSON.stringify(args, null, 2));
                 if (name === 'report_result')
-                    return { result: args, status: 'ok', usage: totalUsage };
+                    return { result: args, status: 'ok', usage: totalUsage, turns };
+                const status = await options.onBeforeToolCall?.({ assistantMessage, toolCall });
+                if (status === 'break')
+                    return { status: 'break', usage: totalUsage, turns };
+                if (status === 'disallow') {
+                    toolCall.result = {
+                        content: [{ type: 'text', text: 'Tool call is disallowed.' }],
+                        isError: true,
+                    };
+                    continue;
+                }
                 try {
                     const result = await options.callTool({
                         name,
@@ -89,23 +109,27 @@ class Loop {
                     });
                     const text = result.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
                     debug?.('lowire:loop')('Tool result', text, JSON.stringify(result, null, 2));
+                    const status = await options.onAfterToolCall?.({ assistantMessage, toolCall, result });
+                    if (status === 'break')
+                        return { status: 'break', usage: totalUsage, turns };
+                    if (status === 'disallow') {
+                        toolCall.result = {
+                            content: [{ type: 'text', text: 'Tool result is disallowed to be reported.' }],
+                            isError: true,
+                        };
+                        continue;
+                    }
                     toolCall.result = result;
                 }
                 catch (error) {
                     const errorMessage = `Error while executing tool "${name}": ${error instanceof Error ? error.message : String(error)}\n\nPlease try to recover and complete the task.`;
-                    debug?.('lowire:loop')('Tool error', errorMessage, String(error));
+                    const status = await options.onToolCallError?.({ assistantMessage, toolCall, error });
+                    if (status === 'break')
+                        return { status: 'break', usage: totalUsage, turns };
                     toolCall.result = {
                         content: [{ type: 'text', text: errorMessage }],
                         isError: true,
                     };
-                    // Skip remaining tool calls for this iteration
-                    for (const remainingToolCall of toolCalls.slice(toolCalls.indexOf(toolCall) + 1)) {
-                        remainingToolCall.result = {
-                            content: [{ type: 'text', text: `This tool call is skipped due to previous error.` }],
-                            isError: true,
-                        };
-                    }
-                    break;
                 }
             }
         }

package/lib/providers/anthropic.js

@@ -19,16 +19,17 @@ exports.Anthropic = void 0;
 class Anthropic {
     name = 'anthropic';
     async complete(conversation, options) {
+        const maxTokens = Math.min(options.maxTokens ?? 32768, 32768);
         const response = await create({
             model: options.model,
-            max_tokens: options.maxTokens ?? 32768,
+            max_tokens: maxTokens,
             temperature: options.temperature,
             system: systemPrompt(conversation.systemPrompt),
             messages: conversation.messages.map(toAnthropicMessageParts).flat(),
             tools: conversation.tools.map(toAnthropicTool),
             thinking: options.reasoning ? {
                 type: 'enabled',
-                budget_tokens: options.maxTokens ? Math.round(options.maxTokens / 10) : 1024,
+                budget_tokens: options.maxTokens ? Math.round(maxTokens / 10) : 1024,
             } : undefined,
         }, options);
         const result = toAssistantMessage(response);

package/lib/providers/github.js

@@ -52,16 +52,18 @@ class Github {
         if (!response || !response.choices.length)
             throw new Error('Failed to get response from GitHub Copilot');
         const result = { role: 'assistant', content: [] };
-        const message = response.choices[0].message;
-        if (message.content)
-            result.content.push({ type: 'text', text: message.content });
-        for (const entry of message.tool_calls || []) {
-            if (entry.type !== 'function')
-                continue;
-            const { toolCall, intent } = toToolCall(entry);
-            if (intent)
-                result.content.push({ type: 'text', text: intent, copilotToolCallId: toolCall.id });
-            result.content.push(toolCall);
+        for (const choice of response.choices) {
+            const message = choice.message;
+            if (message.content)
+                result.content.push({ type: 'text', text: message.content });
+            for (const entry of message.tool_calls || []) {
+                if (entry.type !== 'function')
+                    continue;
+                const { toolCall, intent } = toToolCall(entry);
+                if (intent)
+                    result.content.push({ type: 'text', text: intent, copilotToolCallId: toolCall.id });
+                result.content.push(toolCall);
+            }
         }
         const usage = {
             input: response.usage?.prompt_tokens ?? 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowire/loop",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Small agentic loop",
   "repository": {
     "type": "git",