@lowire/loop 0.0.21 → 0.0.23

package/lib/cache.js

@@ -28,7 +28,8 @@ async function cachedComplete(provider, conversation, caches, options) {
 async function cachedCompleteNoSecrets(provider, conversation, caches, options) {
     if (!caches)
         return await provider.complete(conversation, options);
-    const key = calculateSha1(JSON.stringify(conversation));
+    const { maxTokens, reasoning, temperature } = options;
+    const key = calculateSha1(JSON.stringify({ conversation, maxTokens, reasoning, temperature }));
     if (!process.env.LOWIRE_NO_CACHE && caches.input[key]) {
         caches.output[key] = caches.input[key];
         return caches.input[key] ?? caches.output[key];

package/lib/loop.d.ts

@@ -61,7 +61,8 @@ export declare class Loop {
         abortController?: AbortController;
     }): Promise<{
         result?: types.ToolResult;
-        status: 'ok' | 'break';
+        status: 'ok' | 'break' | 'error';
+        error?: string;
         usage: types.Usage;
         turns: number;
     }>;

package/lib/loop.js

@@ -49,7 +49,7 @@ class Loop {
         const maxTurns = options.maxTurns || 100;
         for (let turns = 0; turns < maxTurns; ++turns) {
             if (options.maxTokens && budget.tokens !== undefined && budget.tokens <= 0)
-                throw new Error(`Budget tokens ${options.maxTokens} exhausted`);
+                return { status: 'error', error: `Budget tokens ${options.maxTokens} exhausted`, usage: totalUsage, turns };
             debug?.('lowire:loop')(`Turn ${turns + 1} of (max ${maxTurns})`);
             const caches = options.cache ? {
                 input: options.cache,
@@ -60,11 +60,18 @@ class Loop {
             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 tokenEstimate = Math.floor(JSON.stringify(summarizedConversation).length / 4);
+            if (budget.tokens !== undefined && tokenEstimate >= budget.tokens)
+                return { status: 'error', error: `Input token estimate ${tokenEstimate} exceeds budget ${budget.tokens}`, usage: totalUsage, turns };
             const { result: assistantMessage, usage } = await (0, cache_1.cachedComplete)(this._provider, summarizedConversation, caches, {
                 ...options,
-                maxTokens: budget.tokens,
+                maxTokens: budget.tokens !== undefined ? budget.tokens - tokenEstimate : undefined,
                 signal: abortController?.signal,
             });
+            if (assistantMessage.stopReason.code === 'max_tokens')
+                return { status: 'error', error: `Max tokens exhausted`, usage: totalUsage, turns };
+            if (assistantMessage.stopReason.code === 'other')
+                return { status: 'error', error: assistantMessage.stopReason.message, usage: totalUsage, turns };
             const intent = assistantMessage.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
             totalUsage.input += usage.input;
             totalUsage.output += usage.output;
@@ -83,7 +90,7 @@ class Loop {
             }
             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`);
+                    return { status: 'error', error: `Failed to perform step, max tool calls (${options.maxToolCalls}) reached`, usage: totalUsage, turns };
                 const { name, arguments: args } = toolCall;
                 debug?.('lowire:loop')('Call tool', name, JSON.stringify(args, null, 2));
                 const status = await options.onBeforeToolCall?.({ assistantMessage, toolCall });
@@ -139,9 +146,9 @@ class Loop {
             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`);
+                return { status: 'error', error: `Failed to perform action after ${options.maxToolCallRetries} tool call retries`, usage: totalUsage, turns };
         }
-        throw new Error('Failed to perform step, max attempts reached');
+        return { status: 'error', error: `Failed to perform step, max attempts reached`, usage: totalUsage, turns: maxTurns };
     }
     _summarizeConversation(task, conversation, options) {
         const { summary, lastMessage } = (0, summary_1.summarizeConversation)(task, conversation, options);

package/lib/providers/anthropic.js

@@ -109,9 +109,21 @@ function toAnthropicResultParam(part) {
     throw new Error(`Unsupported content part type: ${part.type}`);
 }
 function toAssistantMessage(message) {
+    const stopReason = { code: 'ok' };
+    if (message.stop_reason === 'max_tokens') {
+        stopReason.code = 'max_tokens';
+    }
+    else if (message.stop_reason === 'tool_use') {
+        stopReason.code = 'ok';
+    }
+    else {
+        stopReason.code = 'other';
+        stopReason.message = `Unexpected stop reason: ${message.stop_reason}`;
+    }
     return {
         role: 'assistant',
         content: message.content.map(toContentPart).filter(Boolean),
+        stopReason,
     };
 }
 function toAnthropicTool(tool) {

package/lib/providers/google.js

@@ -30,7 +30,10 @@ class Google {
             },
             contents,
             tools: conversation.tools.length > 0 ? [{ functionDeclarations: conversation.tools.map(toGeminiTool) }] : undefined,
-            generationConfig: { temperature: options.temperature },
+            generationConfig: {
+                temperature: options.temperature,
+                maxOutputTokens: options.maxTokens
+            },
         }, options);
         const [candidate] = response.candidates ?? [];
         if (!candidate)
@@ -85,9 +88,25 @@ function stripUnsupportedSchemaFields(schema) {
     return cleaned;
 }
 function toAssistantMessage(candidate) {
+    const stopReason = { code: 'ok' };
+    const finishReason = candidate.finishReason;
+    if (finishReason === 'MAX_TOKENS') {
+        stopReason.code = 'max_tokens';
+    }
+    else if (!finishReason || finishReason === 'STOP') {
+        stopReason.code = 'ok';
+    }
+    else if (finishReason.includes('FUNCTION') || finishReason.includes('TOOL')) {
+        stopReason.code = 'ok';
+    }
+    else {
+        stopReason.code = 'other';
+        stopReason.message = `Unexpected finish reason: ${finishReason}`;
+    }
     return {
         role: 'assistant',
-        content: candidate.content.parts.map(toContentPart).filter(Boolean),
+        content: (candidate.content.parts || []).map(toContentPart).filter(Boolean),
+        stopReason,
     };
 }
 function toContentPart(part) {

package/lib/providers/openai.js

@@ -27,7 +27,7 @@ exports.OpenAI = OpenAI;
 async function complete(conversation, options) {
     const inputItems = conversation.messages.map(toResponseInputItems).flat();
     const tools = conversation.tools.map(toOpenAIFunctionTool);
-    const response = await create({
+    const { response, error } = await create({
         model: options.model,
         temperature: options.temperature,
         input: inputItems,
@@ -35,10 +35,31 @@ async function complete(conversation, options) {
         tools: tools.length > 0 ? tools : undefined,
         tool_choice: conversation.tools.length > 0 ? 'auto' : undefined,
         parallel_tool_calls: false,
+        max_output_tokens: options.maxTokens,
         reasoning: toOpenAIReasoning(options.reasoning),
     }, options);
+    if (!response || error)
+        return { result: { role: 'assistant', content: [], stopReason: { code: 'other', message: error } }, usage: { input: 0, output: 0 } };
     // Parse response output items
-    const result = { role: 'assistant', content: [] };
+    const stopReason = { code: 'ok' };
+    if (response.incomplete_details?.reason === 'max_output_tokens') {
+        stopReason.code = 'max_tokens';
+    }
+    else if (response.incomplete_details?.reason === 'content_filter') {
+        stopReason.code = 'other';
+        stopReason.message = 'Content filter triggered';
+    }
+    else if (response.incomplete_details?.reason) {
+        stopReason.code = 'other';
+        stopReason.message = `Unexpected incomplete reason: ${response.incomplete_details.reason}`;
+    }
+    const result = { role: 'assistant', content: [], stopReason };
+    const usage = {
+        input: response.usage?.input_tokens ?? 0,
+        output: response.usage?.output_tokens ?? 0,
+    };
+    if (stopReason.code !== 'ok')
+        return { result, usage };
     for (const item of response.output) {
         if (item.type === 'message' && item.role === 'assistant') {
             result.openaiId = item.id;
@@ -57,10 +78,6 @@ async function complete(conversation, options) {
             result.content.push(toToolCall(item));
         }
     }
-    const usage = {
-        input: response.usage?.input_tokens ?? 0,
-        output: response.usage?.output_tokens ?? 0,
-    };
     return { result, usage };
 }
 async function create(createParams, options) {
@@ -77,13 +94,18 @@ async function create(createParams, options) {
         signal: options.signal,
         timeout: options.apiTimeout
     });
+    const responseText = await response.text();
+    const responseBody = JSON.parse(responseText);
     if (!response.ok) {
-        options.debug?.('lowire:openai-responses')('Response:', response.status);
-        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+        try {
+            return { error: responseBody.error.message };
+        }
+        catch {
+            return { error: responseText };
+        }
     }
-    const responseBody = await response.json();
     options.debug?.('lowire:openai-responses')('Response:', JSON.stringify(responseBody, null, 2));
-    return responseBody;
+    return { response: responseBody };
 }
 function toResultContentPart(part) {
     if (part.type === 'text') {

package/lib/providers/openaiCompatible.js

@@ -32,9 +32,9 @@ async function complete(conversation, options) {
     };
     const openaiMessages = [systemMessage, ...conversation.messages.map(toCompletionsMessages).flat()];
     const openaiTools = conversation.tools.map(t => toCompletionsTool(t));
-    const response = await create({
+    const { response, error } = await create({
         model: options.model,
-        max_tokens: options.maxTokens,
+        max_completion_tokens: options.maxTokens,
         temperature: options.temperature,
         messages: openaiMessages,
         tools: openaiTools,
@@ -42,9 +42,15 @@ async function complete(conversation, options) {
         reasoning_effort: toCompletionsReasoning(options.reasoning),
         parallel_tool_calls: false,
     }, options);
+    if (error) {
+        if (error.type === 'invalid_request_error')
+            return { result: { role: 'assistant', content: [], stopReason: { code: 'max_tokens' } }, usage: { input: 0, output: 0 } };
+        return { result: { role: 'assistant', content: [], stopReason: { code: 'other', message: response.error.message } }, usage: { input: 0, output: 0 } };
+    }
     if (!response || !response.choices.length)
-        throw new Error('Failed to get response from OpenAI completions');
-    const result = { role: 'assistant', content: [] };
+        return { result: { role: 'assistant', content: [], stopReason: { code: 'other', message: 'Failed to get response from OpenAI completions' } }, usage: { input: 0, output: 0 } };
+    const result = { role: 'assistant', content: [], stopReason: { code: 'ok' } };
+    const finishReason = response.choices[0]?.finish_reason;
     for (const choice of response.choices) {
         const message = choice.message;
         if (message.content)
@@ -55,6 +61,10 @@ async function complete(conversation, options) {
             result.content.push(toToolCall(entry));
         }
     }
+    if (finishReason === 'length')
+        result.stopReason = { code: 'max_tokens' };
+    else if (finishReason !== 'tool_calls' && finishReason !== 'function_call' && finishReason !== 'stop')
+        result.stopReason = { code: 'other', message: `Unexpected finish reason: ${finishReason}` };
     const usage = {
         input: response.usage?.prompt_tokens ?? 0,
         output: response.usage?.completion_tokens ?? 0,
@@ -75,13 +85,18 @@ async function create(createParams, options) {
         signal: options.signal,
         timeout: options.apiTimeout
     });
+    const responseText = await response.text();
+    const responseBody = JSON.parse(responseText);
     if (!response.ok) {
-        options.debug?.('lowire:openai')('Response:', response.status);
-        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+        try {
+            return { error: responseBody };
+        }
+        catch {
+            return { error: { type: 'unknown', message: responseText } };
+        }
     }
-    const responseBody = await response.json();
     options.debug?.('lowire:openai')('Response:', JSON.stringify(responseBody, null, 2));
-    return responseBody;
+    return { response: responseBody };
 }
 function toCopilotResultContentPart(part) {
     if (part.type === 'text') {

package/lib/types.d.ts

@@ -38,6 +38,10 @@ export type UserMessage = BaseMessage & {
 export type AssistantMessage = BaseMessage & {
     role: 'assistant';
     content: (TextContentPart | ToolCallContentPart | ThinkingContentPart)[];
+    stopReason: {
+        code: 'max_tokens' | 'ok' | 'other';
+        message?: string;
+    };
     openaiId?: string;
     openaiStatus?: 'completed' | 'incomplete' | 'in_progress';
     toolError?: string;

package/package.json

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

package/githubAuth.js

@@ -1,17 +0,0 @@
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-require('./lib/auth/githubAuth');