@lowire/loop 0.0.1 → 0.0.2

package/lib/providers/openai.js

@@ -0,0 +1,172 @@
+"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.OpenAI = void 0;
+class OpenAI {
+    name = 'openai';
+    async 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,
+        });
+        // 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 };
+    }
+}
+exports.OpenAI = OpenAI;
+async function create(body) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'Copilot-Vision-Request': 'true',
+    };
+    const response = await fetch(`https://api.openai.com/v1/responses`, {
+        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 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);
+        }
+        items.push(...toolCallParts.map(toFunctionToolCall));
+        return items;
+    }
+    if (message.role === 'tool_result') {
+        return [{
+                type: 'function_call_output',
+                call_id: message.toolCallId,
+                output: message.result.content.map(toResultContentPart),
+            }];
+    }
+    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) {
+    return {
+        type: 'function_call',
+        call_id: toolCall.id,
+        name: toolCall.name,
+        arguments: JSON.stringify(toolCall.arguments),
+        id: toolCall.openaiId,
+        status: toolCall.openaiStatus,
+    };
+}
+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,
+    };
+}
+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

@@ -0,0 +1,33 @@
+/**
+ * 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 type Endpoint = {
+    baseUrl: string;
+    apiKey: string;
+    headers: Record<string, string>;
+};
+export declare class OpenAICompletions implements types.Provider {
+    readonly name: string;
+    private _endpoint;
+    endpoint(): Promise<Endpoint>;
+    connect(): Promise<Endpoint>;
+    complete(conversation: types.Conversation, options: types.CompletionOptions & {
+        injectIntent?: boolean;
+    }): Promise<{
+        result: types.AssistantMessage;
+        usage: types.Usage;
+    }>;
+}

package/lib/providers/openaiCompletions.js

@@ -0,0 +1,174 @@
+"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.
+`;

package/lib/providers/registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 * as types from '../types';
+export declare function getProvider(loopName: 'openai' | 'github' | 'anthropic' | 'google'): types.Provider;

package/lib/providers/registry.js

@@ -0,0 +1,33 @@
+"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.getProvider = getProvider;
+const openai_1 = require("./openai");
+const github_1 = require("./github");
+const anthropic_1 = require("./anthropic");
+const google_1 = require("./google");
+function getProvider(loopName) {
+    if (loopName === 'openai')
+        return new openai_1.OpenAI();
+    if (loopName === 'github')
+        return new github_1.Github();
+    if (loopName === 'anthropic')
+        return new anthropic_1.Anthropic();
+    if (loopName === 'google')
+        return new google_1.Google();
+    throw new Error(`Unknown loop LLM: ${loopName}`);
+}

package/lib/types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 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.
+ */
+export type Schema = {
+    type: 'object';
+    properties?: unknown | null;
+    required?: Array<string> | null;
+};
+export type Tool = {
+    name: string;
+    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';
+};
+export type UserMessage = BaseMessage & {
+    role: 'user';
+    content: string;
+};
+export type AssistantMessage = BaseMessage & {
+    role: 'assistant';
+    content: (TextContentPart | ToolCallPart | ThinkingContentPart)[];
+    openaiId?: string;
+    openaiStatus?: 'completed' | 'incomplete' | 'in_progress';
+};
+export type TextContentPart = {
+    type: 'text';
+    text: string;
+    googleThoughtSignature?: string;
+};
+export type ImageContentPart = {
+    type: 'image';
+    data: string;
+    mimeType: string;
+};
+export type ThinkingContentPart = {
+    type: 'thinking';
+    thinking: string;
+    signature: string;
+};
+export type ResultContentPart = TextContentPart | ImageContentPart;
+export type ToolResult = {
+    content: ResultContentPart[];
+    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 CompletionOptions = {
+    model: string;
+    maxTokens?: number;
+    reasoning?: boolean;
+    temperature?: number;
+};
+export interface Provider {
+    name: string;
+    complete(conversation: Conversation, options: CompletionOptions): Promise<{
+        result: AssistantMessage;
+        usage: Usage;
+    }>;
+}
+export type ReplayCache = Record<string, {
+    result: AssistantMessage;
+    usage: Usage;
+}>;
+export type ReplayCaches = {
+    before: ReplayCache;
+    after: ReplayCache;
+};

package/lib/types.js

@@ -0,0 +1,17 @@
+"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 });

package/package.json

@@ -1,12 +1,59 @@
 {
   "name": "@lowire/loop",
-  "version": "0.0.1",
-  "main": "index.js",
+  "version": "0.0.2",
+  "description": "Small agentic loop",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pavelfeldman/lowire.git"
+  },
+  "homepage": "https://github.com/pavelfeldman/lowire",
+  "engines": {
+    "node": ">=20"
+  },
+  "author": {
+    "name": "Microsoft Corporation"
+  },
+  "license": "Apache-2.0",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "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": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    }
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": ""
+  "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"
+  }
 }