@lowire/loop 0.0.12 → 0.0.13

package/lib/loop.d.ts

@@ -55,8 +55,8 @@ export declare class Loop {
     private _provider;
     private _loopOptions;
     private _cacheOutput;
-    constructor(loopName: 'openai' | 'github' | 'anthropic' | 'google', options: LoopOptions);
-    run(task: string, runOptions?: Omit<LoopOptions, 'model'> & {
+    constructor(options: LoopOptions);
+    run(task: string, runOptions?: Omit<LoopOptions, 'model' | 'api' | 'apiKey'> & {
         model?: string;
     }): Promise<{
         result?: types.ToolResult;

package/lib/loop.js

@@ -23,8 +23,8 @@ class Loop {
     _provider;
     _loopOptions;
     _cacheOutput = {};
-    constructor(loopName, options) {
-        this._provider = (0, registry_1.getProvider)(loopName);
+    constructor(options) {
+        this._provider = (0, registry_1.getProvider)(options.api);
         this._loopOptions = options;
     }
     async run(task, runOptions = {}) {

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 ? {
+            thinking: options.reasoning !== 'none' ? {
                 type: 'enabled',
                 budget_tokens: options.maxTokens ? Math.round(maxTokens / 10) : 1024,
             } : undefined,
@@ -44,12 +44,12 @@ exports.Anthropic = Anthropic;
 async function create(createParams, options) {
     const headers = {
         'Content-Type': 'application/json',
-        'x-api-key': process.env.ANTHROPIC_API_KEY,
+        'x-api-key': options.apiKey,
         'anthropic-version': '2023-06-01',
     };
     const debugBody = { ...createParams, tools: `${createParams.tools?.length ?? 0} tools` };
     options.debug?.('lowire:anthropic')('Request:', JSON.stringify(debugBody, null, 2));
-    const response = await fetch(`https://api.anthropic.com/v1/messages`, {
+    const response = await fetch(options.apiEndpoint ?? `https://api.anthropic.com/v1/messages`, {
         method: 'POST',
         headers,
         body: JSON.stringify(createParams)

package/lib/providers/google.js

@@ -44,16 +44,13 @@ class Google {
 }
 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`, {
+    const response = await fetch(options.apiEndpoint ?? `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
-            'x-goog-api-key': apiKey,
+            'x-goog-api-key': options.apiKey,
         },
         body: JSON.stringify(createParams)
     });

package/lib/providers/openai.js

@@ -16,171 +16,14 @@
  */
 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) {
-        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 };
+        if (options.apiVersion === 'v1/chat/completions')
+            return (0, openaiCompletions_1.complete)(conversation, options);
+        return (0, openaiResponses_1.complete)(conversation, options);
     }
 }
 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/{auth/githubAuth.d.ts → providers/openaiCompletions.d.ts}

@@ -13,4 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export {};
+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/openaiCompletions.js

@@ -0,0 +1,182 @@
+"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) {
+    // Convert generic messages to OpenAI format
+    const systemMessage = {
+        role: 'system',
+        content: systemPrompt(conversation.systemPrompt)
+    };
+    const openaiMessages = [systemMessage, ...conversation.messages.map(toCompletionsMessages).flat()];
+    const openaiTools = conversation.tools.map(t => toCompletionsTool(t));
+    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: toCompletionsReasoning(options.reasoning),
+        parallel_tool_calls: false,
+    }, options);
+    if (!response || !response.choices.length)
+        throw new Error('Failed to get response from OpenAI completions');
+    const result = { role: 'assistant', content: [] };
+    for (const choice of response.choices) {
+        const message = choice.message;
+        if (message.content)
+            result.content.push({ type: 'text', text: message.content });
+        for (const entry of message.tool_calls || []) {
+            if (entry.type !== 'function')
+                continue;
+            result.content.push(toToolCall(entry));
+        }
+    }
+    const usage = {
+        input: response.usage?.prompt_tokens ?? 0,
+        output: response.usage?.completion_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')('Request:', JSON.stringify(debugBody, null, 2));
+    const response = await fetch(options.apiEndpoint ?? `https://api.openai.com/v1/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(createParams),
+    });
+    if (!response.ok) {
+        options.debug?.('lowire:openai')('Response:', response.status);
+        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+    }
+    const responseBody = await response.json();
+    options.debug?.('lowire:openai')('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 toCompletionsMessages(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 = [];
+        const toolResultMessages = [];
+        for (const toolCall of toolCallParts) {
+            toolCalls.push({
+                id: toolCall.id,
+                type: 'function',
+                function: {
+                    name: toolCall.name,
+                    arguments: JSON.stringify(toolCall.arguments)
+                }
+            });
+            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}`);
+}
+function toCompletionsTool(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+        },
+    };
+}
+function toToolCall(entry) {
+    return {
+        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,
+    };
+}
+function toCompletionsReasoning(reasoning) {
+    switch (reasoning) {
+        case 'none':
+            return 'none';
+        case 'medium':
+            return 'medium';
+        case 'high':
+            return '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/{github.d.ts → openaiResponses.d.ts}

@@ -14,20 +14,7 @@
  * limitations under the License.
  */
 import type * as types from '../types';
-export declare class Github implements types.Provider {
-    readonly name: string;
-    private _apiKey;
-    private _bearer;
-    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
-        result: types.AssistantMessage;
-        usage: types.Usage;
-    }>;
-}
-export declare const kEditorHeaders: {
-    'Editor-Version': string;
-    'Editor-Plugin-Version': string;
-    'User-Agent': string;
-    Accept: string;
-    'Content-Type': string;
-    'Copilot-Vision-Request': string;
-};
+export declare function complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
+    result: types.AssistantMessage;
+    usage: types.Usage;
+}>;

package/lib/providers/openaiResponses.js

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

package/lib/providers/registry.d.ts

@@ -13,5 +13,5 @@
  * 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;
+import type * as types from '../types';
+export declare function getProvider(api: 'openai' | 'anthropic' | 'google'): types.Provider;

package/lib/providers/registry.js

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

package/lib/types.d.ts

@@ -46,7 +46,6 @@ export type TextContentPart = {
     type: 'text';
     text: string;
     googleThoughtSignature?: string;
-    copilotToolCallId?: string;
 };
 export type ThinkingContentPart = {
     type: 'thinking';
@@ -91,9 +90,13 @@ export type Conversation = {
 };
 export type Debug = (category: string) => (...args: any[]) => void;
 export type CompletionOptions = {
+    api: 'openai' | 'anthropic' | 'google';
+    apiEndpoint?: string;
+    apiKey: string;
+    apiVersion?: string;
     model: string;
     maxTokens?: number;
-    reasoning?: boolean;
+    reasoning?: 'none' | 'medium' | 'high';
     temperature?: number;
     debug?: Debug;
 };

package/package.json

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

package/lib/auth/githubAuth.js

@@ -1,81 +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 });
-const github_1 = require("../providers/github");
-/* eslint-disable no-console */
-// The Client ID for VS Code. This is public knowledge but technically "internal" to VS Code.
-// Using this ID allows the script to impersonate VS Code to get the correct scopes.
-const CLIENT_ID = 'Iv1.b507a08c87ecfe98';
-const SCOPE = 'read:user share:copilot';
-async function initiateDeviceFlow() {
-    const response = await fetch('https://github.com/login/device/code', {
-        method: 'POST',
-        headers: github_1.kEditorHeaders,
-        body: JSON.stringify({
-            client_id: CLIENT_ID,
-            scope: SCOPE
-        })
-    });
-    return await response.json();
-}
-async function pollForToken(deviceCode, interval) {
-    console.log('Waiting for user authorization...');
-    return new Promise((resolve, reject) => {
-        const pollInterval = setInterval(async () => {
-            try {
-                const response = await fetch('https://github.com/login/oauth/access_token', {
-                    method: 'POST',
-                    headers: github_1.kEditorHeaders,
-                    body: JSON.stringify({
-                        client_id: CLIENT_ID,
-                        device_code: deviceCode,
-                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code'
-                    })
-                });
-                const data = await response.json();
-                if ('access_token' in data) {
-                    clearInterval(pollInterval);
-                    resolve(data.access_token);
-                }
-                else if (data.error === 'authorization_pending') {
-                    process.stdout.write('.');
-                }
-                else if (data.error === 'slow_down') {
-                    console.log('(slow down)');
-                }
-                else {
-                    clearInterval(pollInterval);
-                    reject(new Error(data.error_description || data.error));
-                }
-            }
-            catch (error) {
-                clearInterval(pollInterval);
-                reject(error);
-            }
-        }, (interval + 1) * 1000);
-    });
-}
-void (async () => {
-    const deviceData = await initiateDeviceFlow();
-    console.log('\n**************************************************');
-    console.log(`Please go to: ${deviceData.verification_uri}`);
-    console.log(`And enter code: ${deviceData.user_code}`);
-    console.log('**************************************************\n');
-    const oauthToken = await pollForToken(deviceData.device_code, deviceData.interval);
-    console.log('\n✔ Authentication successful!');
-    console.log(`COPILOT_API_KEY=${oauthToken}`);
-})();

package/lib/providers/github.js

@@ -1,231 +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.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: [] };
-        for (const choice of response.choices) {
-            const message = choice.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');
-}