@lowire/loop 0.0.2 → 0.0.4

package/lib/types.d.ts

@@ -23,73 +23,79 @@ export type Tool = {
     description?: string;
     inputSchema: Schema;
 };
-export type ToolCallPart = {
-    type: 'tool_call';
-    name: string;
-    arguments: any;
-    id: string;
-    googleThoughtSignature?: string;
-    openaiId?: string;
-    openaiStatus?: 'completed' | 'incomplete' | 'in_progress';
-};
 export type ToolCallback = (params: {
     name: string;
     arguments: any;
 }) => Promise<ToolResult>;
-export type Usage = {
-    input: number;
-    output: number;
-};
 export type BaseMessage = {
-    role: 'user' | 'assistant' | 'tool_result';
+    role: 'user' | 'assistant';
 };
+export type Message = UserMessage | AssistantMessage;
 export type UserMessage = BaseMessage & {
     role: 'user';
     content: string;
 };
 export type AssistantMessage = BaseMessage & {
     role: 'assistant';
-    content: (TextContentPart | ToolCallPart | ThinkingContentPart)[];
+    content: (TextContentPart | ToolCallContentPart | ThinkingContentPart)[];
     openaiId?: string;
     openaiStatus?: 'completed' | 'incomplete' | 'in_progress';
+    toolError?: string;
 };
 export type TextContentPart = {
     type: 'text';
     text: string;
     googleThoughtSignature?: string;
-};
-export type ImageContentPart = {
-    type: 'image';
-    data: string;
-    mimeType: string;
+    copilotToolCallId?: string;
 };
 export type ThinkingContentPart = {
     type: 'thinking';
     thinking: string;
     signature: string;
 };
-export type ResultContentPart = TextContentPart | ImageContentPart;
+export type ToolCallContentPart = {
+    type: 'tool_call';
+    name: string;
+    arguments: any;
+    id: string;
+    googleThoughtSignature?: string;
+    openaiId?: string;
+    openaiStatus?: 'completed' | 'incomplete' | 'in_progress';
+    result?: ToolResult;
+};
+export type TextResultPart = {
+    type: 'text';
+    text: string;
+};
+export type ImageResultPart = {
+    type: 'image';
+    data: string;
+    mimeType: string;
+};
+export type ResultPart = TextResultPart | ImageResultPart;
 export type ToolResult = {
-    content: ResultContentPart[];
+    _meta?: {
+        'dev.lowire/history'?: {
+            category: string;
+            content: string;
+        }[];
+        'dev.lowire/state'?: Record<string, string>;
+    };
+    content: ResultPart[];
     isError?: boolean;
 };
-export type ToolResultMessage = BaseMessage & {
-    role: 'tool_result';
-    toolName: string;
-    toolCallId: string;
-    result: ToolResult;
-};
-export type Message = UserMessage | AssistantMessage | ToolResultMessage;
 export type Conversation = {
     systemPrompt: string;
     messages: Message[];
     tools: Tool[];
 };
+export type Debug = (category: string) => (...args: any[]) => void;
 export type CompletionOptions = {
     model: string;
     maxTokens?: number;
     reasoning?: boolean;
     temperature?: number;
+    debug?: Debug;
 };
 export interface Provider {
     name: string;
@@ -98,11 +104,11 @@ export interface Provider {
         usage: Usage;
     }>;
 }
+export type Usage = {
+    input: number;
+    output: number;
+};
 export type ReplayCache = Record<string, {
     result: AssistantMessage;
     usage: Usage;
 }>;
-export type ReplayCaches = {
-    before: ReplayCache;
-    after: ReplayCache;
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowire/loop",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Small agentic loop",
   "repository": {
     "type": "git",
@@ -15,14 +15,6 @@
   },
   "license": "Apache-2.0",
   "scripts": {
-    "build": "tsc --project tsconfig.src.json",
-    "lint": "eslint . && tsc --project tsconfig.src.json --noEmit && tsc --project tsconfig.tests.json --noEmit",
-    "lint-fix": "eslint . --fix",
-    "watch": "tsc --project tsconfig.src.json --watch",
-    "clean": "rm -rf ./lib",
-    "test": "playwright test",
-    "ctest": "playwright test --project=copilot",
-    "deploy": "npm run clean && npm run build && npm publish"
   },
   "exports": {
     ".": {
@@ -30,30 +22,5 @@
       "require": "./index.js",
       "types": "./index.d.ts"
     }
-  },
-  "devDependencies": {
-    "@anthropic-ai/sdk": "^0.70.0",
-    "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.19.0",
-    "@google/generative-ai": "^0.24.1",
-    "@modelcontextprotocol/sdk": "^1.17.5",
-    "@playwright/test": "^1.56.1",
-    "@stylistic/eslint-plugin": "^3.0.1",
-    "@types/colors": "^1.1.3",
-    "@types/debug": "^4.1.12",
-    "@types/dotenv": "^6.1.1",
-    "@types/glob": "^8.1.0",
-    "@types/node": "^22.13.10",
-    "@typescript-eslint/eslint-plugin": "^8.26.1",
-    "@typescript-eslint/parser": "^8.26.1",
-    "@typescript-eslint/utils": "^8.26.1",
-    "colors": "^1.4.0",
-    "debug": "^4.4.3",
-    "dotenv": "^17.2.3",
-    "eslint": "^9.19.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-notice": "^1.0.0",
-    "openai": "^6.9.1",
-    "typescript": "^5.8.2"
   }
 }

package/lib/providers/openaiCompletions.js

@@ -1,174 +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.OpenAICompletions = void 0;
-class OpenAICompletions {
-    name = 'openai';
-    _endpoint;
-    async endpoint() {
-        if (!this._endpoint)
-            this._endpoint = await this.connect();
-        return this._endpoint;
-    }
-    async connect() {
-        return {
-            baseUrl: 'https://api.openai.com/v1',
-            apiKey: process.env.OPENAI_API_KEY,
-            headers: {}
-        };
-    }
-    async complete(conversation, options) {
-        // Convert generic messages to OpenAI format
-        const systemMessage = {
-            role: 'system',
-            content: systemPrompt(conversation.systemPrompt)
-        };
-        const openaiMessages = [systemMessage, ...conversation.messages.map(toOpenAIMessage)];
-        const openaiTools = conversation.tools.map(t => toOpenAITool(t, options));
-        const endpoint = await this.endpoint();
-        const response = await create({
-            model: options.model,
-            max_tokens: options.maxTokens,
-            temperature: options.temperature,
-            messages: openaiMessages,
-            tools: openaiTools,
-            tool_choice: conversation.tools.length > 0 ? 'auto' : undefined,
-            reasoning_effort: options.reasoning ? 'medium' : undefined,
-        }, endpoint);
-        const result = { role: 'assistant', content: [] };
-        const message = response.choices[0].message;
-        if (message.content)
-            result.content.push({ type: 'text', text: message.content });
-        result.content.push(...(message.tool_calls || []).map(toToolCall));
-        const usage = {
-            input: response.usage?.prompt_tokens ?? 0,
-            output: response.usage?.completion_tokens ?? 0,
-        };
-        return { result, usage };
-    }
-}
-exports.OpenAICompletions = OpenAICompletions;
-async function create(body, endpoint) {
-    const headers = {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${endpoint.apiKey}`,
-        'Copilot-Vision-Request': 'true',
-        ...endpoint.headers
-    };
-    const response = await fetch(`${endpoint.baseUrl}/chat/completions`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body)
-    });
-    if (!response.ok)
-        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
-    return await response.json();
-}
-function toOpenAIResultContentPart(part) {
-    if (part.type === 'text') {
-        return {
-            type: 'text',
-            text: part.text,
-        };
-    }
-    if (part.type === 'image') {
-        return {
-            type: 'image_url',
-            image_url: {
-                url: `data:${part.mimeType};base64,${part.data}`,
-            },
-        };
-    }
-    throw new Error(`Cannot convert content part of type ${part.type} to text content part`);
-}
-function toOpenAIMessage(message) {
-    if (message.role === 'user') {
-        return {
-            role: 'user',
-            content: message.content
-        };
-    }
-    if (message.role === 'assistant') {
-        const assistantMessage = {
-            role: 'assistant'
-        };
-        const textParts = message.content.filter(part => part.type === 'text');
-        const toolCallParts = message.content.filter(part => part.type === 'tool_call');
-        if (textParts.length === 1)
-            assistantMessage.content = textParts[0].text;
-        else
-            assistantMessage.content = textParts;
-        const toolCalls = [];
-        for (const toolCall of toolCallParts) {
-            toolCalls.push({
-                id: toolCall.id,
-                type: 'function',
-                function: {
-                    name: toolCall.name,
-                    arguments: JSON.stringify(toolCall.arguments)
-                }
-            });
-        }
-        if (toolCalls.length > 0)
-            assistantMessage.tool_calls = toolCalls;
-        return assistantMessage;
-    }
-    if (message.role === 'tool_result') {
-        return {
-            role: 'tool',
-            tool_call_id: message.toolCallId,
-            content: message.result.content.map(toOpenAIResultContentPart),
-        };
-    }
-    throw new Error(`Unsupported message role: ${message.role}`);
-}
-function toOpenAITool(tool, options) {
-    const parameters = { ...tool.inputSchema };
-    if (options.injectIntent) {
-        parameters.properties = {
-            _intent: { type: 'string', description: 'Describe the intent of this tool call' },
-            ...parameters.properties || {},
-        };
-    }
-    return {
-        type: 'function',
-        function: {
-            name: tool.name,
-            description: tool.description,
-            parameters,
-        },
-    };
-}
-function toToolCall(toolCall) {
-    return {
-        type: 'tool_call',
-        name: toolCall.type === 'function' ? toolCall.function.name : toolCall.custom.name,
-        arguments: JSON.parse(toolCall.type === 'function' ? toolCall.function.arguments : toolCall.custom.input),
-        id: toolCall.id,
-    };
-}
-const systemPrompt = (prompt) => `
-### System instructions
-
-${prompt}
-
-### Tool calling instructions
-- Your reply MUST be a tool call and nothing but the tool call.
-- NEVER respond with text content, only tool calls.
-- Do NOT describe your plan, do NOT explain what you are doing, do NOT describe what you see, call tools.
-- Provide thoughts in the '_intent' property of the tool calls instead.
-`;