@lowire/loop 0.0.1 → 0.0.3

package/lib/providers/github.js

@@ -0,0 +1,229 @@
+"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.kEditorHeaders = exports.Github = void 0;
+class Github {
+    name = 'github';
+    _apiKey;
+    async _bearer() {
+        if (!this._apiKey)
+            this._apiKey = await getCopilotToken();
+        return this._apiKey;
+    }
+    async complete(conversation, options) {
+        // Convert generic messages to OpenAI format
+        const systemMessage = {
+            role: 'system',
+            content: systemPrompt(conversation.systemPrompt)
+        };
+        const openaiMessages = [systemMessage, ...conversation.messages.map(toCopilotMessages).flat()];
+        const openaiTools = conversation.tools.map(t => toCopilotTool(t));
+        const bearer = await this._bearer();
+        let response;
+        // Github provider is unreliable, retry up to 3 times.
+        for (let i = 0; i < 3; ++i) {
+            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,
+                parallel_tool_calls: false,
+            }, bearer, options);
+            if (response.choices.length)
+                break;
+        }
+        if (!response || !response.choices.length)
+            throw new Error('Failed to get response from GitHub Copilot');
+        const result = { role: 'assistant', content: [] };
+        const message = response.choices[0].message;
+        if (message.content)
+            result.content.push({ type: 'text', text: message.content });
+        for (const entry of message.tool_calls || []) {
+            if (entry.type !== 'function')
+                continue;
+            const { toolCall, intent } = toToolCall(entry);
+            if (intent)
+                result.content.push({ type: 'text', text: intent, copilotToolCallId: toolCall.id });
+            result.content.push(toolCall);
+        }
+        const usage = {
+            input: response.usage?.prompt_tokens ?? 0,
+            output: response.usage?.completion_tokens ?? 0,
+        };
+        return { result, usage };
+    }
+}
+exports.Github = Github;
+async function create(createParams, bearer, options) {
+    const headers = {
+        'Authorization': `Bearer ${bearer}`,
+        ...exports.kEditorHeaders,
+    };
+    const debugBody = { ...createParams, tools: `${createParams.tools?.length ?? 0} tools` };
+    options.debug?.('lowire:github')('Request:', JSON.stringify(debugBody, null, 2));
+    const response = await fetch(`https://api.githubcopilot.com/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(createParams),
+    });
+    if (!response.ok) {
+        options.debug?.('lowire:github')('Response:', response.status);
+        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+    }
+    const responseBody = await response.json();
+    options.debug?.('lowire:github')('Response:', JSON.stringify(responseBody, null, 2));
+    return responseBody;
+}
+function toCopilotResultContentPart(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 toCopilotMessages(message) {
+    if (message.role === 'user') {
+        return [{
+                role: 'user',
+                content: message.content
+            }];
+    }
+    if (message.role === 'assistant') {
+        const assistantMessage = {
+            role: 'assistant'
+        };
+        const toolIntents = new Map();
+        for (const part of message.content) {
+            if (part.type === 'text' && part.copilotToolCallId)
+                toolIntents.set(part.copilotToolCallId, part.text);
+        }
+        const textParts = message.content.filter(part => part.type === 'text' && !part.copilotToolCallId);
+        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 = [];
+        const toolResultMessages = [];
+        for (const toolCall of toolCallParts) {
+            const args = { ...toolCall.arguments };
+            if (toolIntents.has(toolCall.id))
+                args['_intent'] = toolIntents.get(toolCall.id);
+            toolCalls.push({
+                id: toolCall.id,
+                type: 'function',
+                function: {
+                    name: toolCall.name,
+                    arguments: JSON.stringify(args)
+                }
+            });
+            if (toolCall.result) {
+                toolResultMessages.push({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: toolCall.result.content.map(toCopilotResultContentPart),
+                });
+            }
+        }
+        if (toolCalls.length > 0)
+            assistantMessage.tool_calls = toolCalls;
+        if (message.toolError) {
+            toolResultMessages.push({
+                role: 'user',
+                content: [{
+                        type: 'text',
+                        text: message.toolError,
+                    }]
+            });
+        }
+        return [assistantMessage, ...toolResultMessages];
+    }
+    throw new Error(`Unsupported message role: ${message.role}`);
+}
+// Copilot endpoint does not reply with content+tool_call, it instead
+// replies with the content and expects continuation. I.e. instead of navigating
+// to a page it will reply with "Navigating to <url>" w/o tool call. Mitigate it
+// via injecting a tool call intent and then converting it into the assistant
+// message content.
+function toCopilotTool(tool) {
+    const parameters = { ...tool.inputSchema };
+    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(entry) {
+    const toolCall = {
+        type: 'tool_call',
+        name: entry.type === 'function' ? entry.function.name : entry.custom.name,
+        arguments: JSON.parse(entry.type === 'function' ? entry.function.arguments : entry.custom.input),
+        id: entry.id,
+    };
+    const intent = toolCall.arguments['_intent'];
+    delete toolCall.arguments['_intent'];
+    return { toolCall, intent };
+}
+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.
+`;
+exports.kEditorHeaders = {
+    'Editor-Version': 'vscode/1.96.0',
+    'Editor-Plugin-Version': 'copilot-chat/0.24.0',
+    'User-Agent': 'GitHubCopilotChat/0.24.0',
+    'Accept': 'application/json',
+    'Content-Type': 'application/json',
+    'Copilot-Vision-Request': 'true',
+};
+async function getCopilotToken() {
+    const response = await fetch('https://api.github.com/copilot_internal/v2/token', {
+        method: 'GET',
+        headers: { 'Authorization': `token ${process.env.COPILOT_API_KEY}`, ...exports.kEditorHeaders }
+    });
+    const data = await response.json();
+    if (data.token)
+        return data.token;
+    throw new Error('Failed to get Copilot token');
+}

package/lib/providers/google.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 class Google implements types.Provider {
+    readonly name = "google";
+    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
+        result: types.AssistantMessage;
+        usage: types.Usage;
+    }>;
+}

package/lib/providers/google.js

@@ -0,0 +1,204 @@
+"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.Google = void 0;
+class Google {
+    name = 'google';
+    async complete(conversation, options) {
+        const contents = conversation.messages.map(toGeminiContent).flat();
+        const response = await create(options.model ?? 'gemini-2.5-pro', {
+            systemInstruction: {
+                role: 'system',
+                parts: [
+                    { text: systemPrompt(conversation.systemPrompt) }
+                ]
+            },
+            contents,
+            tools: conversation.tools.length > 0 ? [{ functionDeclarations: conversation.tools.map(toGeminiTool) }] : undefined,
+            generationConfig: { temperature: options.temperature },
+        }, options);
+        const [candidate] = response.candidates ?? [];
+        if (!candidate)
+            throw new Error('No candidates in response');
+        const usage = {
+            input: response.usageMetadata?.promptTokenCount ?? 0,
+            output: response.usageMetadata?.candidatesTokenCount ?? 0,
+        };
+        const result = toAssistantMessage(candidate);
+        return { result, usage };
+    }
+}
+exports.Google = Google;
+async function create(model, createParams, options) {
+    const apiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    if (!apiKey)
+        throw new Error('GEMINI_API_KEY or GOOGLE_API_KEY environment variable is required');
+    const debugBody = { ...createParams, tools: `${createParams.tools?.length ?? 0} tools` };
+    options.debug?.('lowire:google')('Request:', JSON.stringify(debugBody, null, 2));
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-goog-api-key': apiKey,
+        },
+        body: JSON.stringify(createParams)
+    });
+    if (!response.ok) {
+        options.debug?.('lowire:google')('Response:', response.status);
+        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+    }
+    const responseBody = await response.json();
+    options.debug?.('lowire:google')('Response:', JSON.stringify(responseBody, null, 2));
+    return responseBody;
+}
+function toGeminiTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: stripUnsupportedSchemaFields(tool.inputSchema),
+    };
+}
+function stripUnsupportedSchemaFields(schema) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    const cleaned = Array.isArray(schema) ? [...schema] : { ...schema };
+    delete cleaned.additionalProperties;
+    delete cleaned.$schema;
+    for (const key in cleaned) {
+        if (cleaned[key] && typeof cleaned[key] === 'object')
+            cleaned[key] = stripUnsupportedSchemaFields(cleaned[key]);
+    }
+    return cleaned;
+}
+function toAssistantMessage(candidate) {
+    return {
+        role: 'assistant',
+        content: candidate.content.parts.map(toContentPart).filter(Boolean),
+    };
+}
+function toContentPart(part) {
+    if (part.text) {
+        return {
+            type: 'text',
+            text: part.text,
+            googleThoughtSignature: part.thoughtSignature,
+        };
+    }
+    if (part.functionCall) {
+        return {
+            type: 'tool_call',
+            name: part.functionCall.name,
+            arguments: part.functionCall.args,
+            id: `call_${Math.random().toString(36).substring(2, 15)}`,
+            googleThoughtSignature: part.thoughtSignature,
+        };
+    }
+    return null;
+}
+function toGeminiContent(message) {
+    if (message.role === 'user') {
+        return [{
+                role: 'user',
+                parts: [{ text: message.content }]
+            }];
+    }
+    if (message.role === 'assistant') {
+        const parts = [];
+        const toolResults = [];
+        for (const part of message.content) {
+            if (part.type === 'text') {
+                parts.push({
+                    text: part.text,
+                    thoughtSignature: part.googleThoughtSignature,
+                });
+                continue;
+            }
+            if (part.type === 'tool_call') {
+                parts.push({
+                    functionCall: {
+                        name: part.name,
+                        args: part.arguments
+                    },
+                    thoughtSignature: part.googleThoughtSignature,
+                });
+                if (part.result)
+                    toolResults.push(...toGeminiToolResult(part, part.result));
+            }
+        }
+        if (message.toolError) {
+            toolResults.push({
+                role: 'user',
+                parts: [{
+                        text: message.toolError,
+                    }]
+            });
+        }
+        return [{
+                role: 'model',
+                parts
+            }, ...toolResults];
+    }
+    throw new Error(`Unsupported message role: ${message.role}`);
+}
+function toGeminiToolResult(call, toolResult) {
+    const responseContent = {};
+    const textParts = [];
+    const inlineDatas = [];
+    for (const part of toolResult.content) {
+        if (part.type === 'text') {
+            textParts.push(part.text);
+        }
+        else if (part.type === 'image') {
+            // Store image data for inclusion in response
+            inlineDatas.push({
+                inline_data: {
+                    mime_type: part.mimeType,
+                    data: part.data
+                }
+            });
+        }
+    }
+    if (textParts.length > 0)
+        responseContent.result = textParts.join('\n');
+    const result = [{
+            role: 'function',
+            parts: [{
+                    functionResponse: {
+                        name: call.name,
+                        response: responseContent
+                    }
+                }]
+        }];
+    if (inlineDatas.length > 0) {
+        result.push({
+            role: 'user',
+            parts: inlineDatas
+        });
+    }
+    return result;
+}
+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/openai.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 class OpenAI implements types.Provider {
+    readonly name: string;
+    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
+        result: types.AssistantMessage;
+        usage: types.Usage;
+    }>;
+}

package/lib/providers/openai.js

@@ -0,0 +1,186 @@
+"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,
+        }, 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 };
+    }
+}
+exports.OpenAI = OpenAI;
+async function create(createParams, options) {
+    const apiKey = process.env.OPENAI_API_KEY;
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'Copilot-Vision-Request': 'true',
+    };
+    const debugBody = { ...createParams, tools: `${createParams.tools?.length ?? 0} tools` };
+    options.debug?.('lowire:openai-responses')('Request:', JSON.stringify(debugBody, null, 2));
+    const response = await fetch(`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,
+    };
+}
+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/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;