@lowire/loop 0.0.2 → 0.0.4

package/README.md

@@ -1 +1 @@
-## tiny loop
+## lowire agentic loop

package/index.d.ts

@@ -14,5 +14,6 @@
  * limitations under the License.
  */
 
-export * from './lib/loop';
 export * from './lib/types';
+export * from './lib/loop';
+export * from './lib/mcp/index';

package/index.js

@@ -14,4 +14,5 @@
  * limitations under the License.
  */
 
-module.exports = require('./lib/loop');
+module.exports.Loop = require('./lib/loop').Loop;
+module.exports.createMcpTools = require('./lib/mcp/index').createMcpTools;

package/index.mjs

@@ -15,3 +15,4 @@
  */
 
 export * from './lib/loop.js';
+export * from './lib/mcp/index.js';

package/lib/cache.d.ts

@@ -14,5 +14,10 @@
  * limitations under the License.
  */
 import type * as types from './types';
-import type { LoopOptions } from './loop';
-export declare function cachedComplete(provider: types.Provider, conversation: types.Conversation, options: LoopOptions): ReturnType<types.Provider['complete']>;
+type ReplayCaches = {
+    input: types.ReplayCache;
+    output: types.ReplayCache;
+    secrets: Record<string, string>;
+};
+export declare function cachedComplete(provider: types.Provider, conversation: types.Conversation, caches: ReplayCaches | undefined, options: types.CompletionOptions): ReturnType<types.Provider['complete']>;
+export {};

package/lib/cache.js

@@ -20,23 +20,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cachedComplete = cachedComplete;
 const crypto_1 = __importDefault(require("crypto"));
-async function cachedComplete(provider, conversation, options) {
-    const caches = options.caches;
-    const secrets = options.secrets || {};
+async function cachedComplete(provider, conversation, caches, options) {
     if (!caches)
         return await provider.complete(conversation, options);
+    const secrets = caches.secrets || {};
     const c = hideSecrets(conversation, secrets);
     const key = calculateSha1(JSON.stringify(c));
-    if (!process.env.TL_NO_CACHE && caches.before[key]) {
-        caches.after[key] = caches.before[key];
-        return unhideSecrets(caches.before[key] ?? caches.after[key], secrets);
+    if (!process.env.LOWIRE_NO_CACHE && caches.input[key]) {
+        caches.output[key] = caches.input[key];
+        return unhideSecrets(caches.input[key] ?? caches.output[key], secrets);
     }
-    if (!process.env.TL_NO_CACHE && caches.after[key])
-        return unhideSecrets(caches.after[key], secrets);
-    if (process.env.TL_FORCE_CACHE)
+    if (!process.env.LOWIRE_NO_CACHE && caches.output[key])
+        return unhideSecrets(caches.output[key], secrets);
+    if (process.env.LOWIRE_FORCE_CACHE)
         throw new Error('Cache missing but TL_FORCE_CACHE is set' + JSON.stringify(conversation, null, 2));
     const result = await provider.complete(conversation, options);
-    caches.after[key] = hideSecrets(result, secrets);
+    caches.output[key] = hideSecrets(result, secrets);
     return result;
 }
 function hideSecrets(conversation, secrets) {

package/lib/jsx/jsx-runtime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function jsx(tag: string, props: Record<string, any> | null): string;
+export declare const jsxs: typeof jsx;

package/lib/jsx/jsx-runtime.js

@@ -0,0 +1,33 @@
+"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.jsxs = void 0;
+exports.jsx = jsx;
+function jsx(tag, props) {
+    const { children, ...rest } = props || {};
+    const attrs = Object.entries(rest);
+    const childArray = (Array.isArray(children) ? children.flat() : (children ? [children] : [])).filter(a => a && !!a.trim());
+    const lines = [`${tag}:`];
+    for (const [k, v] of attrs)
+        lines.push(`  ${k}: ${v}`);
+    for (const child of childArray) {
+        const indented = child.split('\n').map((line) => `  ${line}`).join('\n');
+        lines.push(indented);
+    }
+    return lines.join('\n');
+}
+exports.jsxs = jsx;

package/lib/loop.d.ts

@@ -14,34 +14,25 @@
  * limitations under the License.
  */
 import type * as types from './types';
-export type Logger = (category: string, text: string, details?: string) => void;
-type Sizes = {
-    headers: number;
-    messages: number;
-    toolsResults: number;
-};
 export type LoopOptions = types.CompletionOptions & {
     tools?: types.Tool[];
     callTool?: types.ToolCallback;
     maxTurns?: number;
     resultSchema?: types.Schema;
-    logger?: Logger;
-    caches?: types.ReplayCaches;
-    secrets?: Record<string, string>;
-    onBeforeTurn?: (parms: {
-        turn: number;
-        conversation: types.Conversation;
-        sizes: Sizes;
-        totalUsage: types.Usage;
-    }) => Promise<'stop' | undefined | void>;
+    cache?: {
+        messages: types.ReplayCache;
+        secrets: Record<string, string>;
+    };
+    summarize?: boolean;
 };
 export declare class Loop {
     private _provider;
     private _loopOptions;
+    private _cacheOutput;
     constructor(loopName: 'openai' | 'github' | 'anthropic' | 'google', options: LoopOptions);
     run<T>(task: string, runOptions?: Omit<LoopOptions, 'model'> & {
         model?: string;
-    }): Promise<T | undefined>;
-    private _sizes;
+    }): Promise<T>;
+    private _summarizeConversation;
+    cache(): types.ReplayCache;
 }
-export {};

package/lib/loop.js

@@ -18,23 +18,23 @@ 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 || []),
-            {
-                name: 'report_result',
-                description: 'Report the result of the task.',
-                inputSchema: options.resultSchema ?? defaultResultSchema,
-            },
-        ];
+        const allTools = [...options.tools || []];
+        allTools.push({
+            name: 'report_result',
+            description: 'Report the result of the task.',
+            inputSchema: options.resultSchema ?? defaultResultSchema,
+        });
         const conversation = {
             systemPrompt,
             messages: [
@@ -42,98 +42,86 @@ class Loop {
             ],
             tools: allTools,
         };
-        const log = options.logger ?? (() => { });
+        const debug = options.debug;
         const totalUsage = { input: 0, output: 0 };
-        log('loop:loop', `Starting ${this._provider.name} loop`, task);
+        debug?.('lowire:loop')(`Starting ${this._provider.name} loop`, task);
         const maxTurns = options.maxTurns || 100;
         for (let turn = 0; turn < maxTurns; ++turn) {
-            log('loop:turn', `${turn + 1} of (max ${maxTurns})`);
-            const status = await options.onBeforeTurn?.({ turn, conversation, sizes: this._sizes(conversation), totalUsage });
-            if (status === 'stop')
-                return undefined;
-            const { result: assistantMessage, usage } = await (0, cache_1.cachedComplete)(this._provider, conversation, options);
+            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 text = assistantMessage.content.filter(part => part.type === 'text').map(part => part.text).join('\n');
             const toolCalls = assistantMessage.content.filter(part => part.type === 'tool_call');
-            log('loop:usage', `input: ${usage.input}, output: ${usage.output}`);
-            log('loop:assistant', text, JSON.stringify(assistantMessage.content, null, 2));
             if (toolCalls.length === 0) {
-                conversation.messages.push({
-                    role: 'user',
-                    content: `Tool call expected. Call the "report_result" tool when the task is complete.`,
-                });
+                assistantMessage.toolError = 'Error: tool call is expected in every assistant message. Call the "report_result" tool when the task is complete.';
                 continue;
             }
-            const toolResults = [];
             for (const toolCall of toolCalls) {
-                const { name, arguments: args, id } = toolCall;
-                log('loop:call-tool', name, JSON.stringify(args, null, 2));
+                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,
+                        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');
-                    log('loop:tool-result', text, JSON.stringify(result, null, 2));
-                    toolResults.push({
-                        toolName: name,
-                        toolCallId: id,
-                        result,
-                    });
+                    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.`;
-                    log('loop:tool-error', errorMessage, String(error));
-                    toolResults.push({
-                        toolName: name,
-                        toolCallId: id,
-                        result: {
-                            content: [{ type: 'text', text: errorMessage }],
-                            isError: true,
-                        }
-                    });
+                    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)) {
-                        toolResults.push({
-                            toolName: remainingToolCall.name,
-                            toolCallId: remainingToolCall.id,
-                            result: {
-                                content: [{ type: 'text', text: `This tool call is skipped due to previous error.` }],
-                                isError: true,
-                            }
-                        });
+                        remainingToolCall.result = {
+                            content: [{ type: 'text', text: `This tool call is skipped due to previous error.` }],
+                            isError: true,
+                        };
                     }
                     break;
                 }
             }
-            for (const toolResult of toolResults) {
-                conversation.messages.push({
-                    role: 'tool_result',
-                    ...toolResult,
-                });
-            }
         }
+        if (options.summarize)
+            return this._summarizeConversation(task, conversation, options);
         throw new Error('Failed to perform step, max attempts reached');
     }
-    _sizes(conversation) {
-        const headers = conversation.systemPrompt.length + JSON.stringify(conversation.tools).length;
-        const messages = JSON.stringify(conversation.messages).length;
-        let toolsResults = 0;
-        for (const message of conversation.messages) {
-            if (message.role !== 'tool_result')
-                continue;
-            toolsResults += JSON.stringify(message.result).length;
-        }
+    _summarizeConversation(task, conversation, options) {
+        const { summary, lastMessage } = (0, summary_1.summarizeConversation)(task, conversation, options);
         return {
-            headers,
-            messages,
-            toolsResults,
+            ...conversation,
+            messages: [
+                { role: 'user', content: summary },
+                ...lastMessage ? [lastMessage] : [],
+            ],
         };
     }
+    cache() {
+        return this._cacheOutput;
+    }
 }
 exports.Loop = Loop;
 const defaultResultSchema = {

package/lib/{providers/openaiCompletions.d.ts → mcp/index.d.ts}

@@ -14,20 +14,21 @@
  * limitations under the License.
  */
 import type * as types from '../types';
-export type Endpoint = {
-    baseUrl: string;
-    apiKey: string;
-    headers: Record<string, string>;
+export type McpServer = {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    stderr?: 'pipe' | 'inherit' | 'ignore';
+    env?: Record<string, string>;
 };
-export declare class OpenAICompletions implements types.Provider {
-    readonly name: string;
-    private _endpoint;
-    endpoint(): Promise<Endpoint>;
-    connect(): Promise<Endpoint>;
-    complete(conversation: types.Conversation, options: types.CompletionOptions & {
-        injectIntent?: boolean;
-    }): Promise<{
-        result: types.AssistantMessage;
-        usage: types.Usage;
-    }>;
-}
+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.js

@@ -24,13 +24,13 @@ class Anthropic {
             max_tokens: options.maxTokens ?? 32768,
             temperature: options.temperature,
             system: systemPrompt(conversation.systemPrompt),
-            messages: conversation.messages.map(toAnthropicMessagePart),
+            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,
@@ -40,20 +40,26 @@ class Anthropic {
     }
 }
 exports.Anthropic = Anthropic;
-async function create(body) {
+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(body)
+        body: JSON.stringify(createParams)
     });
-    if (!response.ok)
+    if (!response.ok) {
+        options.debug?.('lowire:anthropic')('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:anthropic')('Response:', JSON.stringify(responseBody, null, 2));
+    return responseBody;
 }
 function toContentPart(block) {
     if (block.type === 'text') {
@@ -113,6 +119,7 @@ function toAnthropicTool(tool) {
 }
 function toAnthropicAssistantMessageParam(message) {
     const content = [];
+    const toolResults = [];
     for (const part of message.content) {
         if (part.type === 'text') {
             content.push({ ...part, citations: [] });
@@ -125,6 +132,8 @@ function toAnthropicAssistantMessageParam(message) {
                 name: part.name,
                 input: part.arguments
             });
+            if (part.result)
+                toolResults.push(toAnthropicToolResultMessage(part, part.result));
             continue;
         }
         if (part.type === 'thinking') {
@@ -136,34 +145,41 @@ function toAnthropicAssistantMessageParam(message) {
             continue;
         }
     }
-    return {
-        role: 'assistant',
-        content
-    };
+    if (message.toolError) {
+        toolResults.push({
+            role: 'user',
+            content: [{
+                    type: 'text',
+                    text: message.toolError,
+                }]
+        });
+    }
+    return [{
+            role: 'assistant',
+            content
+        }, ...toolResults];
 }
-function toAnthropicToolResultMessage(message) {
+function toAnthropicToolResultMessage(call, result) {
     const toolResult = {
         type: 'tool_result',
-        tool_use_id: message.toolCallId,
-        content: message.result.content.map(toAnthropicResultParam),
-        is_error: message.result.isError,
+        tool_use_id: call.id,
+        content: result.content.map(toAnthropicResultParam),
+        is_error: result.isError,
     };
     return {
         role: 'user',
         content: [toolResult]
     };
 }
-function toAnthropicMessagePart(message) {
+function toAnthropicMessageParts(message) {
     if (message.role === 'user') {
-        return {
-            role: 'user',
-            content: message.content
-        };
+        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) => `

package/lib/providers/github.d.ts

@@ -13,21 +13,21 @@
  * 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 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 class Github extends OpenAICompletions {
-    readonly name = "copilot";
-    connect(): Promise<Endpoint>;
-    complete(conversation: types.Conversation, options: types.CompletionOptions): Promise<{
-        result: types.AssistantMessage;
-        usage: types.Usage;
-    }>;
-}