@lowire/loop 0.0.2 → 0.0.4

package/lib/providers/github.js

@@ -15,47 +15,208 @@
  * 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() {
+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 {
-            baseUrl: 'https://api.githubcopilot.com',
-            apiKey: await getCopilotToken(),
-            headers: exports.kEditorHeaders
+            type: 'text',
+            text: part.text,
         };
     }
-    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;
+    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),
+                });
             }
-            const text = content.join(' ').trim();
-            if (text.trim())
-                message.result.content.unshift({ type: 'text', text: content.join(' ') });
         }
-        return message;
+        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}`);
 }
-exports.Github = Github;
+// 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',

package/lib/providers/google.js

@@ -30,7 +30,7 @@ class Google {
             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');
@@ -43,21 +43,27 @@ class Google {
     }
 }
 exports.Google = Google;
-async function create(model, body) {
+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(body)
+        body: JSON.stringify(createParams)
     });
-    if (!response.ok)
+    if (!response.ok) {
+        options.debug?.('lowire:google')('Response:', response.status);
         throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
-    return await response.json();
+    }
+    const responseBody = await response.json();
+    options.debug?.('lowire:google')('Response:', JSON.stringify(responseBody, null, 2));
+    return responseBody;
 }
 function toGeminiTool(tool) {
     return {
@@ -71,6 +77,7 @@ function stripUnsupportedSchemaFields(schema) {
         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]);
@@ -111,6 +118,7 @@ function toGeminiContent(message) {
     }
     if (message.role === 'assistant') {
         const parts = [];
+        const toolResults = [];
         for (const part of message.content) {
             if (part.type === 'text') {
                 parts.push({
@@ -127,51 +135,61 @@ function toGeminiContent(message) {
                     },
                     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];
     }
-    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
-                    }
-                });
-            }
+    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);
         }
-        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
+        else if (part.type === 'image') {
+            // Store image data for inclusion in response
+            inlineDatas.push({
+                inline_data: {
+                    mime_type: part.mimeType,
+                    data: part.data
+                }
             });
         }
-        return result;
     }
-    throw new Error(`Unsupported message role: ${message.role}`);
+    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

package/lib/providers/openai.js

@@ -29,7 +29,7 @@ class OpenAI {
             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) {
@@ -58,21 +58,27 @@ class OpenAI {
     }
 }
 exports.OpenAI = OpenAI;
-async function create(body) {
+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(body)
+        body: JSON.stringify(createParams)
     });
-    if (!response.ok)
+    if (!response.ok) {
+        options.debug?.('lowire:openai-responses')('Response:', response.status);
         throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
-    return await response.json();
+    }
+    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') {
@@ -118,16 +124,16 @@ function toResponseInputItems(message) {
             };
             items.push(outputMessage);
         }
-        items.push(...toolCallParts.map(toFunctionToolCall));
+        if (message.toolError) {
+            items.push({
+                type: 'message',
+                role: 'user',
+                content: message.toolError
+            });
+        }
+        items.push(...toolCallParts.map(toFunctionToolCall).flat());
         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) {
@@ -140,14 +146,22 @@ function toOpenAIFunctionTool(tool) {
     };
 }
 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,
-    };
+    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 {

package/lib/summary.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 function summarizeConversation(task: string, conversation: types.Conversation, options: Pick<types.CompletionOptions, 'debug'>): {
+    summary: string;
+    lastMessage: types.AssistantMessage;
+};

package/lib/summary.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeConversation = summarizeConversation;
+const jsx_runtime_1 = require("./jsx/jsx-runtime");
+/**
+ * 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.
+ */
+const jsx_runtime_2 = require("./jsx/jsx-runtime");
+function summarizeConversation(task, conversation, options) {
+    const summary = ['## Task', task];
+    const combinedState = {};
+    const assistantMessages = conversation.messages.filter(message => message.role === 'assistant');
+    for (let turn = 0; turn < assistantMessages.length - 1; ++turn) {
+        if (turn === 0) {
+            summary.push('');
+            summary.push('## History');
+        }
+        summary.push(``);
+        const text = assistantMessages[turn].content.filter(part => part.type === 'text').map(part => part.text).join('\n');
+        const toolCalls = assistantMessages[turn].content.filter(part => part.type === 'tool_call');
+        for (const toolCall of toolCalls) {
+            if (toolCall.result) {
+                for (const [name, state] of Object.entries(toolCall.result._meta?.['dev.lowire/state'] || {}))
+                    combinedState[name] = state;
+            }
+        }
+        const message = assistantMessages[turn];
+        summary.push((0, jsx_runtime_1.jsxs)("step", { turn: turn + 1, children: [(0, jsx_runtime_1.jsx)("title", { children: text }), toolCalls.map(toolCall => (0, jsx_runtime_1.jsxs)("tool-call", { children: [(0, jsx_runtime_1.jsx)("name", { children: toolCall.name }), Object.keys(toolCall.arguments).length > 0 && (0, jsx_runtime_1.jsx)("arguments", { children: Object.entries(toolCall.arguments).map(([key, value]) => (0, jsx_runtime_2.jsx)(key, { children: [JSON.stringify(value)] })) })] })), toolCalls.map(toolCall => toolCall.result?._meta?.['dev.lowire/history'] || []).flat().map(h => (0, jsx_runtime_2.jsx)(h.category, { children: [h.content] })), message.toolError && (0, jsx_runtime_1.jsx)("error", { children: message.toolError })] }));
+    }
+    const lastMessage = assistantMessages[assistantMessages.length - 1];
+    if (lastMessage) { // Remove state from combined state as it'll be a part of the last assistant message.
+        for (const part of lastMessage.content.filter(part => part.type === 'tool_call')) {
+            for (const name of Object.keys(part.result?._meta?.['dev.lowire/state'] || {}))
+                delete combinedState[name];
+        }
+    }
+    for (const [name, state] of Object.entries(combinedState)) {
+        summary.push('');
+        summary.push((0, jsx_runtime_1.jsx)("state", { name: name, children: state }));
+    }
+    options.debug?.('lowire:summary')(summary.join('\n'));
+    options.debug?.('lowire:summary')(JSON.stringify(lastMessage, null, 2));
+    return { summary: summary.join('\n'), lastMessage };
+}