@lowire/loop 0.0.13 → 0.0.15

package/lib/providers/anthropic.js

@@ -27,7 +27,7 @@ class Anthropic {
             system: systemPrompt(conversation.systemPrompt),
             messages: conversation.messages.map(toAnthropicMessageParts).flat(),
             tools: conversation.tools.map(toAnthropicTool),
-            thinking: options.reasoning !== 'none' ? {
+            thinking: options.reasoning && options.reasoning !== 'none' ? {
                 type: 'enabled',
                 budget_tokens: options.maxTokens ? Math.round(maxTokens / 10) : 1024,
             } : undefined,

package/lib/providers/openai.js

@@ -16,14 +16,183 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAI = void 0;
-const openaiCompletions_1 = require("./openaiCompletions");
-const openaiResponses_1 = require("./openaiResponses");
 class OpenAI {
     name = 'openai';
     async complete(conversation, options) {
-        if (options.apiVersion === 'v1/chat/completions')
-            return (0, openaiCompletions_1.complete)(conversation, options);
-        return (0, openaiResponses_1.complete)(conversation, options);
+        return complete(conversation, options);
     }
 }
 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({
+        model: options.model,
+        temperature: options.temperature,
+        input: inputItems,
+        instructions: systemPrompt(conversation.systemPrompt),
+        tools: tools.length > 0 ? tools : undefined,
+        tool_choice: conversation.tools.length > 0 ? 'auto' : undefined,
+        parallel_tool_calls: false,
+        reasoning: toOpenAIReasoning(options.reasoning),
+    }, options);
+    // Parse response output items
+    const result = { role: 'assistant', content: [] };
+    for (const item of response.output) {
+        if (item.type === 'message' && item.role === 'assistant') {
+            result.openaiId = item.id;
+            result.openaiStatus = item.status;
+            for (const contentPart of item.content) {
+                if (contentPart.type === 'output_text') {
+                    result.content.push({
+                        type: 'text',
+                        text: contentPart.text,
+                    });
+                }
+            }
+        }
+        else if (item.type === 'function_call') {
+            // Add tool call
+            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) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${options.apiKey}`,
+    };
+    const debugBody = { ...createParams, tools: `${createParams.tools?.length ?? 0} tools` };
+    options.debug?.('lowire:openai-responses')('Request:', JSON.stringify(debugBody, null, 2));
+    const response = await fetch(options.apiEndpoint ?? `https://api.openai.com/v1/responses`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(createParams)
+    });
+    if (!response.ok) {
+        options.debug?.('lowire:openai-responses')('Response:', response.status);
+        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+    }
+    const responseBody = await response.json();
+    options.debug?.('lowire:openai-responses')('Response:', JSON.stringify(responseBody, null, 2));
+    return responseBody;
+}
+function toResultContentPart(part) {
+    if (part.type === 'text') {
+        return {
+            type: 'input_text',
+            text: part.text,
+        };
+    }
+    if (part.type === 'image') {
+        return {
+            type: 'input_image',
+            image_url: `data:${part.mimeType};base64,${part.data}`,
+            detail: 'auto',
+        };
+    }
+    throw new Error(`Cannot convert content part of type ${part.type} to response content part`);
+}
+function toResponseInputItems(message) {
+    if (message.role === 'user') {
+        return [{
+                type: 'message',
+                role: 'user',
+                content: message.content
+            }];
+    }
+    if (message.role === 'assistant') {
+        const textParts = message.content.filter(part => part.type === 'text');
+        const toolCallParts = message.content.filter(part => part.type === 'tool_call');
+        const items = [];
+        // Add assistant message with text content
+        if (textParts.length > 0) {
+            const outputMessage = {
+                id: message.openaiId,
+                status: message.openaiStatus,
+                type: 'message',
+                role: 'assistant',
+                content: textParts.map(part => ({
+                    type: 'output_text',
+                    text: part.text,
+                    annotations: [],
+                    logprobs: []
+                }))
+            };
+            items.push(outputMessage);
+        }
+        if (message.toolError) {
+            items.push({
+                type: 'message',
+                role: 'user',
+                content: message.toolError
+            });
+        }
+        items.push(...toolCallParts.map(toFunctionToolCall).flat());
+        return items;
+    }
+    throw new Error(`Unsupported message role: ${message.role}`);
+}
+function toOpenAIFunctionTool(tool) {
+    return {
+        type: 'function',
+        name: tool.name,
+        description: tool.description ?? null,
+        parameters: tool.inputSchema,
+        strict: null,
+    };
+}
+function toFunctionToolCall(toolCall) {
+    const result = [{
+            type: 'function_call',
+            call_id: toolCall.id,
+            name: toolCall.name,
+            arguments: JSON.stringify(toolCall.arguments),
+            id: toolCall.openaiId,
+            status: toolCall.openaiStatus,
+        }];
+    if (toolCall.result) {
+        result.push({
+            type: 'function_call_output',
+            call_id: toolCall.id,
+            output: toolCall.result.content.map(toResultContentPart),
+        });
+    }
+    return result;
+}
+function toToolCall(functionCall) {
+    return {
+        type: 'tool_call',
+        name: functionCall.name,
+        arguments: JSON.parse(functionCall.arguments),
+        id: functionCall.call_id,
+        openaiId: functionCall.id,
+        openaiStatus: functionCall.status,
+    };
+}
+function toOpenAIReasoning(reasoning) {
+    switch (reasoning) {
+        case 'none':
+            return { effort: 'none' };
+        case 'medium':
+            return { effort: 'medium' };
+        case 'high':
+            return { effort: 'high' };
+    }
+}
+const systemPrompt = (prompt) => `
+### System instructions
+
+${prompt}
+
+### Tool calling instructions
+- Make sure every message contains a tool call.
+- When you use a tool, you may provide a brief thought or explanation in the content field
+  immediately before the tool_call. Do not split this into separate messages.
+- Every reply must include a tool call.
+`;

package/lib/providers/{openaiCompletions.d.ts → openaiCompatible.d.ts}

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 import type * as types from '../types';
-export declare function complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
-    result: types.AssistantMessage;
-    usage: types.Usage;
-}>;
+export declare class OpenAICompatible implements types.Provider {
+    readonly name: string;
+    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
+        result: types.AssistantMessage;
+        usage: types.Usage;
+    }>;
+}

package/lib/providers/{openaiCompletions.js → openaiCompatible.js}

@@ -15,7 +15,14 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.complete = complete;
+exports.OpenAICompatible = void 0;
+class OpenAICompatible {
+    name = 'openai-compatible';
+    async complete(conversation, options) {
+        return complete(conversation, options);
+    }
+}
+exports.OpenAICompatible = OpenAICompatible;
 async function complete(conversation, options) {
     // Convert generic messages to OpenAI format
     const systemMessage = {

package/lib/providers/registry.d.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 import type * as types from '../types';
-export declare function getProvider(api: 'openai' | 'anthropic' | 'google'): types.Provider;
+export declare function getProvider(api: 'openai' | 'openai-compatible' | 'anthropic' | 'google'): types.Provider;

package/lib/providers/registry.js

@@ -19,9 +19,12 @@ exports.getProvider = getProvider;
 const anthropic_1 = require("./anthropic");
 const google_1 = require("./google");
 const openai_1 = require("./openai");
+const openaiCompatible_1 = require("./openaiCompatible");
 function getProvider(api) {
     if (api === 'openai')
         return new openai_1.OpenAI();
+    if (api === 'openai-compatible')
+        return new openaiCompatible_1.OpenAICompatible();
     if (api === 'anthropic')
         return new anthropic_1.Anthropic();
     if (api === 'google')

package/lib/types.d.ts

@@ -90,10 +90,9 @@ export type Conversation = {
 };
 export type Debug = (category: string) => (...args: any[]) => void;
 export type CompletionOptions = {
-    api: 'openai' | 'anthropic' | 'google';
+    api: 'openai' | 'openai-compatible' | 'anthropic' | 'google';
     apiEndpoint?: string;
     apiKey: string;
-    apiVersion?: string;
     model: string;
     maxTokens?: number;
     reasoning?: 'none' | 'medium' | 'high';

package/package.json

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

package/lib/providers/openaiResponses.d.ts

@@ -1,20 +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.
- */
-import type * as types from '../types';
-export declare function complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
-    result: types.AssistantMessage;
-    usage: types.Usage;
-}>;

package/lib/providers/openaiResponses.js

@@ -1,191 +0,0 @@
-"use strict";
-/**
- * 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.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.complete = complete;
-async function complete(conversation, options) {
-    const inputItems = conversation.messages.map(toResponseInputItems).flat();
-    const tools = conversation.tools.map(toOpenAIFunctionTool);
-    const response = await create({
-        model: options.model,
-        temperature: options.temperature,
-        input: inputItems,
-        instructions: systemPrompt(conversation.systemPrompt),
-        tools: tools.length > 0 ? tools : undefined,
-        tool_choice: conversation.tools.length > 0 ? 'auto' : undefined,
-        parallel_tool_calls: false,
-        reasoning: toOpenAIReasoning(options.reasoning),
-    }, options);
-    // Parse response output items
-    const result = { role: 'assistant', content: [] };
-    for (const item of response.output) {
-        if (item.type === 'message' && item.role === 'assistant') {
-            result.openaiId = item.id;
-            result.openaiStatus = item.status;
-            for (const contentPart of item.content) {
-                if (contentPart.type === 'output_text') {
-                    result.content.push({
-                        type: 'text',
-                        text: contentPart.text,
-                    });
-                }
-            }
-        }
-        else if (item.type === 'function_call') {
-            // Add tool call
-            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) {
-    const headers = {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${options.apiKey}`,
-    };
-    const debugBody = { ...createParams, tools: `${createParams.tools?.length ?? 0} tools` };
-    options.debug?.('lowire:openai-responses')('Request:', JSON.stringify(debugBody, null, 2));
-    const response = await fetch(options.apiEndpoint ?? `https://api.openai.com/v1/responses`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(createParams)
-    });
-    if (!response.ok) {
-        options.debug?.('lowire:openai-responses')('Response:', response.status);
-        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
-    }
-    const responseBody = await response.json();
-    options.debug?.('lowire:openai-responses')('Response:', JSON.stringify(responseBody, null, 2));
-    return responseBody;
-}
-function toResultContentPart(part) {
-    if (part.type === 'text') {
-        return {
-            type: 'input_text',
-            text: part.text,
-        };
-    }
-    if (part.type === 'image') {
-        return {
-            type: 'input_image',
-            image_url: `data:${part.mimeType};base64,${part.data}`,
-            detail: 'auto',
-        };
-    }
-    throw new Error(`Cannot convert content part of type ${part.type} to response content part`);
-}
-function toResponseInputItems(message) {
-    if (message.role === 'user') {
-        return [{
-                type: 'message',
-                role: 'user',
-                content: message.content
-            }];
-    }
-    if (message.role === 'assistant') {
-        const textParts = message.content.filter(part => part.type === 'text');
-        const toolCallParts = message.content.filter(part => part.type === 'tool_call');
-        const items = [];
-        // Add assistant message with text content
-        if (textParts.length > 0) {
-            const outputMessage = {
-                id: message.openaiId,
-                status: message.openaiStatus,
-                type: 'message',
-                role: 'assistant',
-                content: textParts.map(part => ({
-                    type: 'output_text',
-                    text: part.text,
-                    annotations: [],
-                    logprobs: []
-                }))
-            };
-            items.push(outputMessage);
-        }
-        if (message.toolError) {
-            items.push({
-                type: 'message',
-                role: 'user',
-                content: message.toolError
-            });
-        }
-        items.push(...toolCallParts.map(toFunctionToolCall).flat());
-        return items;
-    }
-    throw new Error(`Unsupported message role: ${message.role}`);
-}
-function toOpenAIFunctionTool(tool) {
-    return {
-        type: 'function',
-        name: tool.name,
-        description: tool.description ?? null,
-        parameters: tool.inputSchema,
-        strict: null,
-    };
-}
-function toFunctionToolCall(toolCall) {
-    const result = [{
-            type: 'function_call',
-            call_id: toolCall.id,
-            name: toolCall.name,
-            arguments: JSON.stringify(toolCall.arguments),
-            id: toolCall.openaiId,
-            status: toolCall.openaiStatus,
-        }];
-    if (toolCall.result) {
-        result.push({
-            type: 'function_call_output',
-            call_id: toolCall.id,
-            output: toolCall.result.content.map(toResultContentPart),
-        });
-    }
-    return result;
-}
-function toToolCall(functionCall) {
-    return {
-        type: 'tool_call',
-        name: functionCall.name,
-        arguments: JSON.parse(functionCall.arguments),
-        id: functionCall.call_id,
-        openaiId: functionCall.id,
-        openaiStatus: functionCall.status,
-    };
-}
-function toOpenAIReasoning(reasoning) {
-    switch (reasoning) {
-        case 'none':
-            return { effort: 'none' };
-        case 'medium':
-            return { effort: 'medium' };
-        case 'high':
-            return { effort: 'high' };
-    }
-}
-const systemPrompt = (prompt) => `
-### System instructions
-
-${prompt}
-
-### Tool calling instructions
-- Make sure every message contains a tool call.
-- When you use a tool, you may provide a brief thought or explanation in the content field
-  immediately before the tool_call. Do not split this into separate messages.
-- Every reply must include a tool call.
-`;