loopengine 0.0.1 → 0.0.2

package/dist/load-agent.js

@@ -1,27 +0,0 @@
-// Resolves an AgentConfig's mcpServers (if any) into real tools. This is
-// what makes MCP support config-driven instead of one bespoke async
-// builder function per server: an agent that declares mcpServers and one
-// that doesn't both go through loadAgent() the same way — it's a no-op
-// passthrough for the latter. agent-registry.ts calls this for every
-// agent, so adding a new MCP-backed agent means writing an AgentConfig,
-// not a new .ts file with its own connection-handling logic.
-import { connectMcpTools } from './mcp-tools.js';
-export async function loadAgent(config) {
-    if (!config.mcpServers?.length) {
-        return { config: { ...config, tools: config.tools ?? [] }, close: async () => { } };
-    }
-    const connections = await Promise.all(config.mcpServers.map(connectMcpTools));
-    const mcpTools = connections.flatMap((c) => c.tools);
-    // Last-one-wins on name collisions (hand-written tool vs. MCP tool, or
-    // two MCP servers exposing the same name) — same resolution run-agent.ts
-    // itself uses when it builds its own tool map. Sending the model a
-    // duplicate tool name in its schema list would be a live API error, so
-    // this dedupes before it gets that far.
-    const byName = new Map([...(config.tools ?? []), ...mcpTools].map((t) => [t.name, t]));
-    return {
-        config: { ...config, tools: [...byName.values()] },
-        close: async () => {
-            await Promise.all(connections.map((c) => c.close()));
-        },
-    };
-}

package/dist/mcp-tools.d.ts

@@ -1,11 +0,0 @@
-import { type StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
-import type { ToolDefinition } from './agent-config.js';
-export interface McpConnection {
-    tools: ToolDefinition[];
-    close: () => Promise<void>;
-}
-/** Spawns an MCP server over stdio, discovers its tools via listTools(),
- * and wraps each one so execute() forwards to callTool() on the real
- * server. Call close() when the agent is done with it (or on process
- * shutdown) to kill the child process. */
-export declare function connectMcpTools(serverParams: StdioServerParameters): Promise<McpConnection>;

package/dist/mcp-tools.js

@@ -1,31 +0,0 @@
-// Wraps a real MCP server's tools as ToolDefinition[] — the same shape as
-// any hand-written tool (agent-config.ts), so they drop straight into
-// AgentConfig.tools. Neither run-agent.ts nor ActAuth nor ToolLane know or
-// care that these particular tools proxy to a subprocess speaking MCP
-// instead of running in-process; permission gating and execution still go
-// through the exact same path as lookup_order or read_file.
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-/** Spawns an MCP server over stdio, discovers its tools via listTools(),
- * and wraps each one so execute() forwards to callTool() on the real
- * server. Call close() when the agent is done with it (or on process
- * shutdown) to kill the child process. */
-export async function connectMcpTools(serverParams) {
-    const client = new Client({ name: 'loopengine', version: '0.0.1' });
-    await client.connect(new StdioClientTransport(serverParams));
-    const { tools } = await client.listTools();
-    const toolDefs = tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description ?? tool.name,
-        input_schema: tool.inputSchema,
-        execute: async (input) => {
-            const result = await client.callTool({ name: tool.name, arguments: input });
-            const text = result.content
-                .filter((block) => block.type === 'text')
-                .map((block) => block.text)
-                .join('\n');
-            return result.isError ? { error: text } : text;
-        },
-    }));
-    return { tools: toolDefs, close: () => client.close() };
-}