@lowire/loop 0.0.1 → 0.0.2

package/lib/providers/anthropic.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 Anthropic implements types.Provider {
+    readonly name = "anthropic";
+    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
+        result: types.AssistantMessage;
+        usage: types.Usage;
+    }>;
+}

package/lib/providers/anthropic.js

@@ -0,0 +1,179 @@
+"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.Anthropic = void 0;
+class Anthropic {
+    name = 'anthropic';
+    async complete(conversation, options) {
+        const response = await create({
+            model: options.model,
+            max_tokens: options.maxTokens ?? 32768,
+            temperature: options.temperature,
+            system: systemPrompt(conversation.systemPrompt),
+            messages: conversation.messages.map(toAnthropicMessagePart),
+            tools: conversation.tools.map(toAnthropicTool),
+            thinking: options.reasoning ? {
+                type: 'enabled',
+                budget_tokens: options.maxTokens ? Math.round(options.maxTokens / 10) : 1024,
+            } : undefined,
+        });
+        const result = toAssistantMessage(response);
+        const usage = {
+            input: response.usage.input_tokens,
+            output: response.usage.output_tokens,
+        };
+        return { result, usage };
+    }
+}
+exports.Anthropic = Anthropic;
+async function create(body) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'x-api-key': process.env.ANTHROPIC_API_KEY,
+        'anthropic-version': '2023-06-01',
+    };
+    const response = await fetch(`https://api.anthropic.com/v1/messages`, {
+        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 toContentPart(block) {
+    if (block.type === 'text') {
+        return {
+            type: 'text',
+            text: block.text,
+        };
+    }
+    if (block.type === 'tool_use') {
+        return {
+            type: 'tool_call',
+            name: block.name,
+            arguments: block.input,
+            id: block.id,
+        };
+    }
+    if (block.type === 'thinking') {
+        return {
+            type: 'thinking',
+            thinking: block.thinking,
+            signature: block.signature,
+        };
+    }
+    return null;
+}
+function toAnthropicResultParam(part) {
+    if (part.type === 'text') {
+        return {
+            type: 'text',
+            text: part.text,
+        };
+    }
+    if (part.type === 'image') {
+        return {
+            type: 'image',
+            source: {
+                type: 'base64',
+                data: part.data,
+                media_type: part.mimeType
+            },
+        };
+    }
+    throw new Error(`Unsupported content part type: ${part.type}`);
+}
+function toAssistantMessage(message) {
+    return {
+        role: 'assistant',
+        content: message.content.map(toContentPart).filter(Boolean),
+    };
+}
+function toAnthropicTool(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchema,
+    };
+}
+function toAnthropicAssistantMessageParam(message) {
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === 'text') {
+            content.push({ ...part, citations: [] });
+            continue;
+        }
+        if (part.type === 'tool_call') {
+            content.push({
+                type: 'tool_use',
+                id: part.id,
+                name: part.name,
+                input: part.arguments
+            });
+            continue;
+        }
+        if (part.type === 'thinking') {
+            content.push({
+                type: 'thinking',
+                thinking: part.thinking,
+                signature: part.signature,
+            });
+            continue;
+        }
+    }
+    return {
+        role: 'assistant',
+        content
+    };
+}
+function toAnthropicToolResultMessage(message) {
+    const toolResult = {
+        type: 'tool_result',
+        tool_use_id: message.toolCallId,
+        content: message.result.content.map(toAnthropicResultParam),
+        is_error: message.result.isError,
+    };
+    return {
+        role: 'user',
+        content: [toolResult]
+    };
+}
+function toAnthropicMessagePart(message) {
+    if (message.role === 'user') {
+        return {
+            role: 'user',
+            content: message.content
+        };
+    }
+    if (message.role === 'assistant')
+        return toAnthropicAssistantMessageParam(message);
+    if (message.role === 'tool_result')
+        return toAnthropicToolResultMessage(message);
+    throw new Error(`Unsupported message role: ${message.role}`);
+}
+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/github.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 { OpenAICompletions } from './openaiCompletions';
+import type { Endpoint } from './openaiCompletions';
+import type * as types from '../types';
+export declare const kEditorHeaders: {
+    'Editor-Version': string;
+    'Editor-Plugin-Version': string;
+    'User-Agent': string;
+    Accept: string;
+    'Content-Type': string;
+};
+export declare class Github extends OpenAICompletions {
+    readonly name = "copilot";
+    connect(): Promise<Endpoint>;
+    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
+        result: types.AssistantMessage;
+        usage: types.Usage;
+    }>;
+}

package/lib/providers/github.js

@@ -0,0 +1,68 @@
+"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.Github = exports.kEditorHeaders = void 0;
+const openaiCompletions_1 = require("./openaiCompletions");
+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 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.
+class Github extends openaiCompletions_1.OpenAICompletions {
+    name = 'copilot';
+    async connect() {
+        return {
+            baseUrl: 'https://api.githubcopilot.com',
+            apiKey: await getCopilotToken(),
+            headers: exports.kEditorHeaders
+        };
+    }
+    async complete(conversation, options) {
+        const message = await super.complete(conversation, { ...options, injectIntent: true });
+        const textPart = message.result.content.find(part => part.type === 'text');
+        if (!textPart) {
+            const content = [];
+            const toolCalls = message.result.content.filter(part => part.type === 'tool_call');
+            for (const toolCall of toolCalls) {
+                content.push(toolCall.arguments?._intent ?? '');
+                delete toolCall.arguments._intent;
+            }
+            const text = content.join(' ').trim();
+            if (text.trim())
+                message.result.content.unshift({ type: 'text', text: content.join(' ') });
+        }
+        return message;
+    }
+}
+exports.Github = Github;
+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,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.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 },
+        });
+        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, body) {
+    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 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(body)
+    });
+    if (!response.ok)
+        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+    return await response.json();
+}
+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;
+    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 = [];
+        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,
+                });
+            }
+        }
+        return [{
+                role: 'model',
+                parts
+            }];
+    }
+    if (message.role === 'tool_result') {
+        const responseContent = {};
+        const textParts = [];
+        const inlineDatas = [];
+        for (const part of message.result.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: message.toolName,
+                            response: responseContent
+                        }
+                    }]
+            }];
+        if (inlineDatas.length > 0) {
+            result.push({
+                role: 'user',
+                parts: inlineDatas
+            });
+        }
+        return result;
+    }
+    throw new Error(`Unsupported message role: ${message.role}`);
+}
+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;
+    }>;
+}