@lowire/loop 0.0.9 → 0.0.11

package/lib/loop.d.ts

@@ -14,31 +14,32 @@
  * limitations under the License.
  */
 import type * as types from './types';
+type PromiseOrValue<T> = T | Promise<T>;
 export type LoopEvents = {
     onBeforeTurn?: (params: {
         conversation: types.Conversation;
         totalUsage: types.Usage;
-        budgetTokens: number;
-    }) => Promise<'break' | 'continue' | void>;
+        budgetTokens?: number;
+    }) => PromiseOrValue<'continue' | 'break' | void>;
     onAfterTurn?: (params: {
         assistantMessage: types.AssistantMessage;
         totalUsage: types.Usage;
-        budgetTokens: number;
-    }) => Promise<'break' | 'continue' | void>;
+        budgetTokens?: number;
+    }) => PromiseOrValue<'continue' | 'break' | void>;
     onBeforeToolCall?: (params: {
         assistantMessage: types.AssistantMessage;
         toolCall: types.ToolCallContentPart;
-    }) => Promise<'allowed' | 'disallowed' | void>;
+    }) => PromiseOrValue<'continue' | 'break' | 'disallow' | void>;
     onAfterToolCall?: (params: {
         assistantMessage: types.AssistantMessage;
         toolCall: types.ToolCallContentPart;
         result: types.ToolResult;
-    }) => Promise<'allowed' | 'disallowed' | void>;
+    }) => PromiseOrValue<'continue' | 'break' | 'disallow' | void>;
     onToolCallError?: (params: {
         assistantMessage: types.AssistantMessage;
         toolCall: types.ToolCallContentPart;
         error: Error;
-    }) => Promise<void>;
+    }) => PromiseOrValue<'continue' | 'break' | void>;
 };
 export type LoopOptions = types.CompletionOptions & LoopEvents & {
     tools?: types.Tool[];
@@ -67,3 +68,4 @@ export declare class Loop {
     private _summarizeConversation;
     cache(): types.ReplayCache;
 }
+export {};

package/lib/loop.js

@@ -43,12 +43,12 @@ class Loop {
             tools: allTools,
         };
         const debug = options.debug;
-        let budgetTokens = options.maxTokens ?? 100_000;
+        let budgetTokens = options.maxTokens;
         const totalUsage = { input: 0, output: 0 };
         debug?.('lowire:loop')(`Starting ${this._provider.name} loop`, task);
         const maxTurns = options.maxTurns || 100;
         for (let turns = 0; turns < maxTurns; ++turns) {
-            if (budgetTokens <= 0)
+            if (options.maxTokens && budgetTokens !== undefined && budgetTokens <= 0)
                 throw new Error(`Budget tokens ${options.maxTokens} exhausted`);
             debug?.('lowire:loop')(`Turn ${turns + 1} of (max ${maxTurns})`);
             const caches = options.cache ? {
@@ -68,7 +68,8 @@ class Loop {
             const intent = assistantMessage.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
             totalUsage.input += usage.input;
             totalUsage.output += usage.output;
-            budgetTokens -= usage.input + usage.output;
+            if (budgetTokens !== undefined)
+                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 });
@@ -86,7 +87,9 @@ class Loop {
                 if (name === 'report_result')
                     return { result: args, status: 'ok', usage: totalUsage, turns };
                 const status = await options.onBeforeToolCall?.({ assistantMessage, toolCall });
-                if (status === 'disallowed') {
+                if (status === 'break')
+                    return { status: 'break', usage: totalUsage, turns };
+                if (status === 'disallow') {
                     toolCall.result = {
                         content: [{ type: 'text', text: 'Tool call is disallowed.' }],
                         isError: true,
@@ -108,7 +111,9 @@ 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 === 'disallowed') {
+                    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,
@@ -119,7 +124,9 @@ class Loop {
                 }
                 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.`;
-                    await options.onToolCallError?.({ assistantMessage, toolCall, 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,

package/lib/providers/anthropic.js

@@ -19,7 +19,7 @@ exports.Anthropic = void 0;
 class Anthropic {
     name = 'anthropic';
     async complete(conversation, options) {
-        const maxTokens = Math.min(options.maxTokens ?? 32768, 32768);
+        const maxTokens = Math.min(options.maxTokens ?? 32_768, 32_768);
         const response = await create({
             model: options.model,
             max_tokens: maxTokens,

package/package.json

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