@lowire/loop 0.0.1 → 0.0.3

package/lib/loop.js

@@ -0,0 +1,138 @@
+"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.Loop = void 0;
+const registry_1 = require("./providers/registry");
+const cache_1 = require("./cache");
+const summary_1 = require("./summary");
+class Loop {
+    _provider;
+    _loopOptions;
+    _cacheOutput = {};
+    constructor(loopName, options) {
+        this._provider = (0, registry_1.getProvider)(loopName);
+        this._loopOptions = options;
+    }
+    async run(task, runOptions = {}) {
+        const options = { ...this._loopOptions, ...runOptions };
+        const allTools = [...options.tools || []];
+        allTools.push({
+            name: 'report_result',
+            description: 'Report the result of the task.',
+            inputSchema: options.resultSchema ?? defaultResultSchema,
+        });
+        const conversation = {
+            systemPrompt,
+            messages: [
+                { role: 'user', content: task },
+            ],
+            tools: allTools,
+        };
+        const debug = options.debug;
+        const totalUsage = { input: 0, output: 0 };
+        debug?.('lowire:loop')(`Starting ${this._provider.name} loop`, task);
+        const maxTurns = options.maxTurns || 100;
+        for (let turn = 0; turn < maxTurns; ++turn) {
+            debug?.('lowire:loop')(`Turn ${turn + 1} of (max ${maxTurns})`);
+            const caches = options.cache ? {
+                input: options.cache.messages,
+                output: this._cacheOutput,
+                secrets: options.cache.secrets
+            } : undefined;
+            const summarizedConversation = options.summarize ? this._summarizeConversation(task, conversation, options) : conversation;
+            debug?.('lowire:loop')(`Request`, JSON.stringify({ ...summarizedConversation, tools: `${summarizedConversation.tools.length} tools` }, null, 2));
+            const { result: assistantMessage, usage } = await (0, cache_1.cachedComplete)(this._provider, summarizedConversation, caches, options);
+            const text = assistantMessage.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
+            debug?.('lowire:loop')('Usage', `input: ${usage.input}, output: ${usage.output}`);
+            debug?.('lowire:loop')('Assistant', text, JSON.stringify(assistantMessage.content, null, 2));
+            totalUsage.input += usage.input;
+            totalUsage.output += usage.output;
+            conversation.messages.push(assistantMessage);
+            const toolCalls = assistantMessage.content.filter(part => part.type === 'tool_call');
+            if (toolCalls.length === 0) {
+                assistantMessage.toolError = 'Error: tool call is expected in every assistant message. Call the "report_result" tool when the task is complete.';
+                continue;
+            }
+            for (const toolCall of toolCalls) {
+                const { name, arguments: args } = toolCall;
+                debug?.('lowire:loop')('Call tool', name, JSON.stringify(args, null, 2));
+                if (name === 'report_result')
+                    return args;
+                try {
+                    const result = await options.callTool({
+                        name,
+                        arguments: {
+                            ...args,
+                            _meta: {
+                                'dev.lowire/history': true,
+                                'dev.lowire/state': true,
+                            }
+                        }
+                    });
+                    const text = result.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
+                    debug?.('lowire:loop')('Tool result', text, JSON.stringify(result, null, 2));
+                    toolCall.result = result;
+                }
+                catch (error) {
+                    const errorMessage = `Error while executing tool "${name}": ${error instanceof Error ? error.message : String(error)}\n\nPlease try to recover and complete the task.`;
+                    debug?.('lowire:loop')('Tool error', errorMessage, String(error));
+                    toolCall.result = {
+                        content: [{ type: 'text', text: errorMessage }],
+                        isError: true,
+                    };
+                    // Skip remaining tool calls for this iteration
+                    for (const remainingToolCall of toolCalls.slice(toolCalls.indexOf(toolCall) + 1)) {
+                        remainingToolCall.result = {
+                            content: [{ type: 'text', text: `This tool call is skipped due to previous error.` }],
+                            isError: true,
+                        };
+                    }
+                    break;
+                }
+            }
+        }
+        if (options.summarize)
+            return this._summarizeConversation(task, conversation, options);
+        throw new Error('Failed to perform step, max attempts reached');
+    }
+    _summarizeConversation(task, conversation, options) {
+        const { summary, lastMessage } = (0, summary_1.summarizeConversation)(task, conversation, options);
+        return {
+            ...conversation,
+            messages: [
+                { role: 'user', content: summary },
+                ...lastMessage ? [lastMessage] : [],
+            ],
+        };
+    }
+    cache() {
+        return this._cacheOutput;
+    }
+}
+exports.Loop = Loop;
+const defaultResultSchema = {
+    type: 'object',
+    properties: {
+        result: {
+            type: 'string',
+        },
+    },
+    required: ['result'],
+};
+const systemPrompt = `
+You are an autonomous agent designed to complete tasks by interacting with tools. Perform the user task.
+`;

package/lib/mcp/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type * as types from '../types';
+export type McpServer = {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    stderr?: 'pipe' | 'inherit' | 'ignore';
+    env?: Record<string, string>;
+};
+type ToolFilter = (string | RegExp)[];
+type ToolSupport = {
+    close: () => Promise<void>;
+    tools: types.Tool[];
+    callTool: types.ToolCallback;
+};
+export declare function createMcpTools(servers: Record<string, McpServer>, options?: {
+    rootDir?: string;
+    toolFilter?: ToolFilter;
+}): Promise<ToolSupport>;
+export {};

package/lib/mcp/index.js

@@ -0,0 +1,109 @@
+"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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpTools = createMcpTools;
+const url_1 = __importDefault(require("url"));
+async function connectToMcpServer(server, options) {
+    const { Client } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/index.js')));
+    const { StdioClientTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/client/stdio.js')));
+    const { ListRootsRequestSchema } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/types.js')));
+    const transport = new StdioClientTransport(server);
+    const capabilities = {};
+    if (options?.rootDir)
+        capabilities['roots'] = {};
+    const client = new Client({ name: 'test', version: '1.0.0' }, { capabilities });
+    if (options?.rootDir) {
+        client.setRequestHandler(ListRootsRequestSchema, async () => {
+            return {
+                roots: [{ name: 'workspace', uri: url_1.default.pathToFileURL(options.rootDir).toString() }],
+            };
+        });
+    }
+    await client.connect(transport);
+    return client;
+}
+async function mcpTools(server, options) {
+    const client = await connectToMcpServer(server, options);
+    const { tools } = await client.listTools();
+    const filteredTools = options?.toolFilter ? tools.filter(tool => options.toolFilter.some(filter => typeof filter === 'string' ? tool.name === filter : filter.test(tool.name))) : tools;
+    const callTool = async (params) => {
+        return await client.callTool({ name: params.name, arguments: params.arguments });
+    };
+    return { tools: filteredTools, callTool, close: () => client.close() };
+}
+async function createMcpTools(servers, options) {
+    const allTools = [];
+    const callTools = new Map();
+    const closes = [];
+    for (const [name, server] of Object.entries(servers)) {
+        const { tools, callTool, close } = await mcpTools(server, options);
+        for (const tool of tools) {
+            const fullName = `${name}__${tool.name}`;
+            allTools.push({ ...tool, name: fullName });
+            callTools.set(fullName, params => callTool({ name: tool.name, arguments: params.arguments }));
+        }
+        closes.push(close);
+    }
+    return {
+        close: async () => {
+            await Promise.all(closes.map(c => c()));
+        },
+        tools: allTools,
+        callTool: async (params) => {
+            const callTool = callTools.get(params.name);
+            if (!callTool)
+                throw new Error(`Tool not found: ${params.name}`);
+            return callTool(params);
+        }
+    };
+}

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,195 @@
+"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(toAnthropicMessageParts).flat(),
+            tools: conversation.tools.map(toAnthropicTool),
+            thinking: options.reasoning ? {
+                type: 'enabled',
+                budget_tokens: options.maxTokens ? Math.round(options.maxTokens / 10) : 1024,
+            } : undefined,
+        }, options);
+        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(createParams, options) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'x-api-key': process.env.ANTHROPIC_API_KEY,
+        '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`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(createParams)
+    });
+    if (!response.ok) {
+        options.debug?.('lowire:anthropic')('Response:', response.status);
+        throw new Error(`API error: ${response.status} ${response.statusText} ${await response.text()}`);
+    }
+    const responseBody = await response.json();
+    options.debug?.('lowire:anthropic')('Response:', JSON.stringify(responseBody, null, 2));
+    return responseBody;
+}
+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 = [];
+    const toolResults = [];
+    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
+            });
+            if (part.result)
+                toolResults.push(toAnthropicToolResultMessage(part, part.result));
+            continue;
+        }
+        if (part.type === 'thinking') {
+            content.push({
+                type: 'thinking',
+                thinking: part.thinking,
+                signature: part.signature,
+            });
+            continue;
+        }
+    }
+    if (message.toolError) {
+        toolResults.push({
+            role: 'user',
+            content: [{
+                    type: 'text',
+                    text: message.toolError,
+                }]
+        });
+    }
+    return [{
+            role: 'assistant',
+            content
+        }, ...toolResults];
+}
+function toAnthropicToolResultMessage(call, result) {
+    const toolResult = {
+        type: 'tool_result',
+        tool_use_id: call.id,
+        content: result.content.map(toAnthropicResultParam),
+        is_error: result.isError,
+    };
+    return {
+        role: 'user',
+        content: [toolResult]
+    };
+}
+function toAnthropicMessageParts(message) {
+    if (message.role === 'user') {
+        return [{
+                role: 'user',
+                content: message.content
+            }];
+    }
+    if (message.role === 'assistant')
+        return toAnthropicAssistantMessageParam(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 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;
+};