@lowire/loop 0.0.18 → 0.0.20

package/lib/cache.js

@@ -36,7 +36,7 @@ async function cachedCompleteNoSecrets(provider, conversation, caches, options)
     if (!process.env.LOWIRE_NO_CACHE && caches.output[key])
         return caches.output[key];
     if (process.env.LOWIRE_FORCE_CACHE)
-        throw new Error('Cache missing but TL_FORCE_CACHE is set' + JSON.stringify(conversation, null, 2));
+        throw new Error('Cache missing but LOWIRE_FORCE_CACHE is set' + JSON.stringify(conversation, null, 2));
     const result = await provider.complete(conversation, options);
     caches.output[key] = result;
     return result;

package/lib/loop.d.ts

@@ -20,31 +20,33 @@ export type LoopEvents = {
         conversation: types.Conversation;
         totalUsage: types.Usage;
         budgetTokens?: number;
-    }) => PromiseOrValue<'continue' | 'break' | void>;
+    }) => PromiseOrValue<void>;
     onAfterTurn?: (params: {
         assistantMessage: types.AssistantMessage;
         totalUsage: types.Usage;
         budgetTokens?: number;
-    }) => PromiseOrValue<'continue' | 'break' | void>;
+    }) => PromiseOrValue<void>;
     onBeforeToolCall?: (params: {
         assistantMessage: types.AssistantMessage;
         toolCall: types.ToolCallContentPart;
-    }) => PromiseOrValue<'continue' | 'break' | 'disallow' | void>;
+    }) => PromiseOrValue<'disallow' | void>;
     onAfterToolCall?: (params: {
         assistantMessage: types.AssistantMessage;
         toolCall: types.ToolCallContentPart;
         result: types.ToolResult;
-    }) => PromiseOrValue<'continue' | 'break' | 'disallow' | void>;
+    }) => PromiseOrValue<'disallow' | void>;
     onToolCallError?: (params: {
         assistantMessage: types.AssistantMessage;
         toolCall: types.ToolCallContentPart;
         error: Error;
-    }) => PromiseOrValue<'continue' | 'break' | void>;
+    }) => PromiseOrValue<void>;
 };
 export type LoopOptions = types.CompletionOptions & LoopEvents & {
     tools?: types.Tool[];
     callTool?: types.ToolCallback;
     maxTurns?: number;
+    maxToolCalls?: number;
+    maxToolCallRetries?: number;
     cache?: types.ReplayCache;
     secrets?: Record<string, string>;
     summarize?: boolean;
@@ -56,6 +58,7 @@ export declare class Loop {
     constructor(options: LoopOptions);
     run(task: string, runOptions?: Omit<LoopOptions, 'model' | 'api' | 'apiKey'> & {
         model?: string;
+        abortController?: AbortController;
     }): Promise<{
         result?: types.ToolResult;
         status: 'ok' | 'break';

package/lib/loop.js

@@ -29,6 +29,7 @@ class Loop {
     }
     async run(task, runOptions = {}) {
         const options = { ...this._loopOptions, ...runOptions };
+        const abortController = runOptions.abortController;
         const allTools = [...(options.tools || []).map(wrapToolWithIsDone)];
         const conversation = {
             systemPrompt,
@@ -38,12 +39,16 @@ class Loop {
             tools: allTools,
         };
         const debug = options.debug;
-        let budgetTokens = options.maxTokens;
+        const budget = {
+            tokens: options.maxTokens,
+            toolCalls: options.maxToolCalls,
+            toolCallRetries: options.maxToolCallRetries,
+        };
         const totalUsage = { input: 0, output: 0 };
-        debug?.('lowire:loop')(`Starting ${this._provider.name} loop`, task);
+        debug?.('lowire:loop')(`Starting ${this._provider.name} loop\n${task}`);
         const maxTurns = options.maxTurns || 100;
         for (let turns = 0; turns < maxTurns; ++turns) {
-            if (options.maxTokens && budgetTokens !== undefined && budgetTokens <= 0)
+            if (options.maxTokens && budget.tokens !== undefined && budget.tokens <= 0)
                 throw new Error(`Budget tokens ${options.maxTokens} exhausted`);
             debug?.('lowire:loop')(`Turn ${turns + 1} of (max ${maxTurns})`);
             const caches = options.cache ? {
@@ -51,23 +56,24 @@ class Loop {
                 output: this._cacheOutput,
             } : undefined;
             const summarizedConversation = options.summarize ? this._summarizeConversation(task, conversation, options) : conversation;
-            const beforeStatus = await options.onBeforeTurn?.({ conversation: summarizedConversation, totalUsage, budgetTokens });
-            if (beforeStatus === 'break')
+            await options.onBeforeTurn?.({ conversation: summarizedConversation, totalUsage, budgetTokens: budget.tokens });
+            if (abortController?.signal.aborted)
                 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,
-                maxTokens: budgetTokens,
+                maxTokens: budget.tokens,
+                signal: abortController?.signal,
             });
             const intent = assistantMessage.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
             totalUsage.input += usage.input;
             totalUsage.output += usage.output;
-            if (budgetTokens !== undefined)
-                budgetTokens -= usage.input + usage.output;
+            if (budget.tokens !== undefined)
+                budget.tokens -= 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')
+            await options.onAfterTurn?.({ assistantMessage, totalUsage, budgetTokens: budget.tokens });
+            if (abortController?.signal.aborted)
                 return { status: 'break', usage: totalUsage, turns };
             conversation.messages.push(assistantMessage);
             const toolCalls = assistantMessage.content.filter(part => part.type === 'tool_call');
@@ -76,10 +82,12 @@ class Loop {
                 continue;
             }
             for (const toolCall of toolCalls) {
+                if (budget.toolCalls !== undefined && --budget.toolCalls < 0)
+                    throw new Error(`Failed to perform step, max tool calls (${options.maxToolCalls}) reached`);
                 const { name, arguments: args } = toolCall;
                 debug?.('lowire:loop')('Call tool', name, JSON.stringify(args, null, 2));
                 const status = await options.onBeforeToolCall?.({ assistantMessage, toolCall });
-                if (status === 'break')
+                if (abortController?.signal.aborted)
                     return { status: 'break', usage: totalUsage, turns };
                 if (status === 'disallow') {
                     toolCall.result = {
@@ -103,7 +111,7 @@ 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')
+                    if (abortController?.signal.aborted)
                         return { status: 'break', usage: totalUsage, turns };
                     if (status === 'disallow') {
                         toolCall.result = {
@@ -118,8 +126,8 @@ 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.`;
-                    const status = await options.onToolCallError?.({ assistantMessage, toolCall, error });
-                    if (status === 'break')
+                    await options.onToolCallError?.({ assistantMessage, toolCall, error });
+                    if (abortController?.signal.aborted)
                         return { status: 'break', usage: totalUsage, turns };
                     toolCall.result = {
                         content: [{ type: 'text', text: errorMessage }],
@@ -127,6 +135,11 @@ class Loop {
                     };
                 }
             }
+            const hasErrors = toolCalls.some(toolCall => toolCall.result?.isError);
+            if (!hasErrors)
+                budget.toolCallRetries = options.maxToolCallRetries;
+            if (hasErrors && budget.toolCallRetries !== undefined && --budget.toolCallRetries < 0)
+                throw new Error(`Failed to perform action after ${options.maxToolCallRetries} tool call retries`);
         }
         throw new Error('Failed to perform step, max attempts reached');
     }

package/lib/providers/anthropic.js

@@ -52,7 +52,8 @@ async function create(createParams, options) {
     const response = await fetch(options.apiEndpoint ?? `https://api.anthropic.com/v1/messages`, {
         method: 'POST',
         headers,
-        body: JSON.stringify(createParams)
+        body: JSON.stringify(createParams),
+        signal: options.signal,
     });
     if (!response.ok) {
         options.debug?.('lowire:anthropic')('Response:', response.status);

package/lib/providers/google.js

@@ -52,7 +52,8 @@ async function create(model, createParams, options) {
             'Content-Type': 'application/json',
             'x-goog-api-key': options.apiKey,
         },
-        body: JSON.stringify(createParams)
+        body: JSON.stringify(createParams),
+        signal: options.signal,
     });
     if (!response.ok) {
         options.debug?.('lowire:google')('Response:', response.status);

package/lib/providers/openai.js

@@ -72,7 +72,8 @@ async function create(createParams, options) {
     const response = await fetch(options.apiEndpoint ?? `https://api.openai.com/v1/responses`, {
         method: 'POST',
         headers,
-        body: JSON.stringify(createParams)
+        body: JSON.stringify(createParams),
+        signal: options.signal,
     });
     if (!response.ok) {
         options.debug?.('lowire:openai-responses')('Response:', response.status);

package/lib/providers/openaiCompatible.js

@@ -71,6 +71,7 @@ async function create(createParams, options) {
         method: 'POST',
         headers,
         body: JSON.stringify(createParams),
+        signal: options.signal,
     });
     if (!response.ok) {
         options.debug?.('lowire:openai')('Response:', response.status);

package/lib/types.d.ts

@@ -97,6 +97,7 @@ export type CompletionOptions = {
     maxTokens?: number;
     reasoning?: 'none' | 'medium' | 'high';
     temperature?: number;
+    signal?: AbortSignal;
     debug?: Debug;
 };
 export interface Provider {

package/package.json

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