@archon-claw/cli 0.0.2

package/dist/eval/types.js

@@ -0,0 +1 @@
+export {};

package/dist/llm.d.ts

@@ -0,0 +1,7 @@
+import OpenAI from "openai";
+import type { ModelConfig, ToolSchema } from "./types.js";
+export declare function createClient(config: ModelConfig): OpenAI;
+/** Convert ToolSchema[] to OpenAI function tools format */
+export declare function toOpenAITools(tools: ToolSchema[]): OpenAI.Chat.Completions.ChatCompletionFunctionTool[];
+/** Stream a chat completion, returns the raw stream */
+export declare function streamChat(client: OpenAI, config: ModelConfig, messages: OpenAI.ChatCompletionMessageParam[], tools?: OpenAI.Chat.Completions.ChatCompletionFunctionTool[]): AsyncGenerator<OpenAI.ChatCompletionChunk>;

package/dist/llm.js

@@ -0,0 +1,52 @@
+import OpenAI from "openai";
+const BAILIAN_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+export function createClient(config) {
+    let baseURL;
+    let apiKey;
+    if (config.baseURL) {
+        baseURL = config.baseURL;
+        apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    }
+    else if (config.provider === "bailian") {
+        baseURL = BAILIAN_BASE_URL;
+        apiKey = config.apiKey ?? process.env.DASHSCOPE_API_KEY;
+    }
+    else if (config.provider === "openai") {
+        apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
+    }
+    else {
+        // Provider-specific env var: ANTHROPIC_API_KEY, DEEPSEEK_API_KEY, etc.
+        const envKey = `${config.provider.toUpperCase()}_API_KEY`;
+        apiKey = config.apiKey ?? process.env[envKey] ?? process.env.OPENAI_API_KEY;
+    }
+    if (!apiKey) {
+        throw new Error(`No API key found for provider "${config.provider}". ` +
+            `Set apiKey in model.json or the corresponding environment variable.`);
+    }
+    return new OpenAI({ apiKey, baseURL });
+}
+/** Convert ToolSchema[] to OpenAI function tools format */
+export function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+        },
+    }));
+}
+/** Stream a chat completion, returns the raw stream */
+export async function* streamChat(client, config, messages, tools) {
+    const stream = await client.chat.completions.create({
+        model: config.model,
+        messages,
+        max_tokens: config.maxTokens ?? 4096,
+        temperature: config.temperature ?? 0.7,
+        stream: true,
+        ...(tools && tools.length > 0 ? { tools } : {}),
+    });
+    for await (const chunk of stream) {
+        yield chunk;
+    }
+}

package/dist/mcp-manager.d.ts

@@ -0,0 +1,51 @@
+import type { McpConfig, ToolSchema } from "./schemas.js";
+/**
+ * Manages MCP server connections and tool discovery.
+ *
+ * Responsibilities:
+ * - Creates transport + client for each enabled server
+ * - Discovers tools via listTools (with pagination)
+ * - Applies include/exclude/rename filters
+ * - Converts MCP tool schemas to internal ToolSchema format
+ * - Routes callTool to the correct MCP client
+ */
+export declare class McpManager {
+    private config;
+    private connections;
+    private toolEntries;
+    private toolRoutes;
+    constructor(config: McpConfig);
+    initialize(): Promise<void>;
+    private connectServer;
+    /**
+     * Create a Client + Transport pair and connect.
+     */
+    private createAndConnect;
+    /**
+     * Connect to an MCP server, with automatic streamable-http → SSE fallback
+     * when transport is not explicitly specified and url is provided.
+     */
+    private connectWithFallback;
+    private createTransport;
+    private resolveEnvVars;
+    private listAllTools;
+    private filterTools;
+    private resolveToolName;
+    /** Normalize name to match ^[a-z][a-z0-9_]*$ */
+    private normalizeName;
+    private convertToToolSchema;
+    private convertProperty;
+    /** Get all discovered tool schemas */
+    getTools(): ToolSchema[];
+    /** Get server names that were successfully connected */
+    getServerNames(): string[];
+    /** Get tools grouped by server name */
+    getToolsByServer(): Record<string, {
+        name: string;
+        description: string;
+    }[]>;
+    /** Call an MCP tool by its normalized name */
+    callTool(name: string, args: Record<string, unknown>): Promise<unknown>;
+    /** Shut down all MCP connections */
+    shutdown(): Promise<void>;
+}

package/dist/mcp-manager.js

@@ -0,0 +1,268 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import picomatch from "picomatch";
+/**
+ * Manages MCP server connections and tool discovery.
+ *
+ * Responsibilities:
+ * - Creates transport + client for each enabled server
+ * - Discovers tools via listTools (with pagination)
+ * - Applies include/exclude/rename filters
+ * - Converts MCP tool schemas to internal ToolSchema format
+ * - Routes callTool to the correct MCP client
+ */
+export class McpManager {
+    config;
+    connections = [];
+    toolEntries = [];
+    toolRoutes = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    async initialize() {
+        const entries = Object.entries(this.config.mcpServers);
+        const results = await Promise.allSettled(entries.map(([name, serverConfig]) => this.connectServer(name, serverConfig)));
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.status === "rejected") {
+                console.warn(`[mcp] Failed to connect to "${entries[i][0]}": ${result.reason}`);
+            }
+        }
+    }
+    async connectServer(serverName, serverConfig) {
+        if (serverConfig.enabled === false)
+            return;
+        const { client, transport } = await this.connectWithFallback(serverName, serverConfig);
+        const connection = { client, transport, serverName };
+        this.connections.push(connection);
+        // Discover tools (with pagination)
+        const tools = await this.listAllTools(client);
+        // Apply filters
+        const filtered = this.filterTools(tools, serverConfig);
+        // Convert and register
+        for (const tool of filtered) {
+            const name = this.resolveToolName(serverName, tool.name, serverConfig);
+            const schema = this.convertToToolSchema(name, tool);
+            const entry = {
+                name,
+                originalName: tool.name,
+                serverName,
+                schema,
+            };
+            this.toolEntries.push(entry);
+            this.toolRoutes.set(name, { connection, originalName: tool.name });
+        }
+        console.log(`[mcp] Connected to "${serverName}": ${filtered.length} tool(s) registered`);
+    }
+    /**
+     * Create a Client + Transport pair and connect.
+     */
+    async createAndConnect(config, transportType) {
+        const transport = this.createTransport(config, transportType);
+        const client = new Client({ name: "archon-claw", version: "1.0.0" });
+        await client.connect(transport);
+        return { client, transport };
+    }
+    /**
+     * Connect to an MCP server, with automatic streamable-http → SSE fallback
+     * when transport is not explicitly specified and url is provided.
+     */
+    async connectWithFallback(serverName, config) {
+        const explicit = config.transport ?? (config.command ? "stdio" : undefined);
+        // Explicit transport or stdio — no fallback needed
+        if (explicit) {
+            return this.createAndConnect(config, explicit);
+        }
+        // URL-based with no explicit transport: try streamable-http first, fallback to SSE
+        try {
+            const result = await this.createAndConnect(config, "streamable-http");
+            console.log(`[mcp] "${serverName}": connected via streamable-http`);
+            return result;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`[mcp] "${serverName}": streamable-http failed (${msg}), falling back to SSE`);
+            return this.createAndConnect(config, "sse");
+        }
+    }
+    createTransport(config, transport) {
+        const env = config.env ? this.resolveEnvVars(config.env) : undefined;
+        switch (transport) {
+            case "stdio": {
+                if (!config.command)
+                    throw new Error("stdio transport requires 'command'");
+                return new StdioClientTransport({
+                    command: config.command,
+                    args: config.args,
+                    env: env ? { ...process.env, ...env } : undefined,
+                    cwd: config.cwd,
+                });
+            }
+            case "sse": {
+                if (!config.url)
+                    throw new Error("sse transport requires 'url'");
+                return new SSEClientTransport(new URL(config.url), {
+                    requestInit: config.headers ? { headers: config.headers } : undefined,
+                });
+            }
+            case "streamable-http": {
+                if (!config.url)
+                    throw new Error("streamable-http transport requires 'url'");
+                return new StreamableHTTPClientTransport(new URL(config.url), {
+                    requestInit: config.headers ? { headers: config.headers } : undefined,
+                });
+            }
+            default:
+                throw new Error(`Unknown transport: ${transport}`);
+        }
+    }
+    resolveEnvVars(env) {
+        const resolved = {};
+        for (const [key, val] of Object.entries(env)) {
+            resolved[key] = val.replace(/\$\{(\w+)\}/g, (_, name) => {
+                if (!(name in process.env)) {
+                    console.warn(`[mcp] Environment variable "\${${name}}" is not set (used in env.${key})`);
+                    return "";
+                }
+                return process.env[name];
+            });
+        }
+        return resolved;
+    }
+    async listAllTools(client) {
+        const tools = [];
+        let cursor;
+        do {
+            const result = await client.listTools(cursor ? { cursor } : undefined);
+            for (const t of result.tools) {
+                tools.push(t);
+            }
+            cursor = result.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    filterTools(tools, config) {
+        const filter = config.tools;
+        if (!filter)
+            return tools;
+        let result = tools;
+        if (filter.include?.length) {
+            const matcher = picomatch(filter.include);
+            result = result.filter((t) => matcher(t.name));
+        }
+        if (filter.exclude?.length) {
+            const matcher = picomatch(filter.exclude);
+            result = result.filter((t) => !matcher(t.name));
+        }
+        return result;
+    }
+    resolveToolName(serverName, toolName, config) {
+        // If renamed, use the rename value directly (no prefix)
+        const renamed = config.tools?.rename?.[toolName];
+        if (renamed)
+            return this.normalizeName(renamed);
+        // Default: normalize parts separately, then join with __
+        return `${this.normalizeName(serverName)}__${this.normalizeName(toolName)}`;
+    }
+    /** Normalize name to match ^[a-z][a-z0-9_]*$ */
+    normalizeName(name) {
+        return name
+            .toLowerCase()
+            .replace(/[^a-z0-9_]/g, "_")
+            .replace(/^([^a-z])/, "x$1")
+            .replace(/_+/g, "_");
+    }
+    convertToToolSchema(name, tool) {
+        const inputSchema = tool.inputSchema ?? { type: "object", properties: {} };
+        // Convert MCP's inputSchema properties to our JSONSchemaProperty format
+        const properties = {};
+        if (inputSchema.properties) {
+            for (const [key, val] of Object.entries(inputSchema.properties)) {
+                properties[key] = this.convertProperty(val);
+            }
+        }
+        return {
+            name,
+            description: tool.description ?? `MCP tool: ${tool.name}`,
+            input_schema: {
+                type: "object",
+                properties: properties,
+                required: inputSchema.required,
+            },
+        };
+    }
+    convertProperty(prop) {
+        const result = {};
+        const type = prop.type;
+        result.type = type ?? "string";
+        if (prop.description)
+            result.description = prop.description;
+        if (prop.enum)
+            result.enum = prop.enum;
+        if (type === "array" && prop.items) {
+            result.items = this.convertProperty(prop.items);
+        }
+        if (type === "object" && prop.properties) {
+            const nested = {};
+            for (const [k, v] of Object.entries(prop.properties)) {
+                nested[k] = this.convertProperty(v);
+            }
+            result.properties = nested;
+            if (prop.required)
+                result.required = prop.required;
+        }
+        return result;
+    }
+    /** Get all discovered tool schemas */
+    getTools() {
+        return this.toolEntries.map((e) => e.schema);
+    }
+    /** Get server names that were successfully connected */
+    getServerNames() {
+        return this.connections.map((c) => c.serverName);
+    }
+    /** Get tools grouped by server name */
+    getToolsByServer() {
+        const grouped = {};
+        for (const entry of this.toolEntries) {
+            const list = (grouped[entry.serverName] ??= []);
+            list.push({ name: entry.name, description: entry.schema.description });
+        }
+        return grouped;
+    }
+    /** Call an MCP tool by its normalized name */
+    async callTool(name, args) {
+        const route = this.toolRoutes.get(name);
+        if (!route)
+            throw new Error(`Unknown MCP tool: ${name}`);
+        const serverConfig = this.config.mcpServers[route.connection.serverName];
+        const timeout = serverConfig?.timeout ?? 30_000;
+        const result = await route.connection.client.callTool({ name: route.originalName, arguments: args }, undefined, { signal: AbortSignal.timeout(timeout) });
+        // Extract value from MCP response
+        if ("toolResult" in result)
+            return result.toolResult;
+        const content = result.content;
+        if (!content || content.length === 0)
+            return null;
+        // Single text content → return the text string
+        if (content.length === 1 && content[0].type === "text") {
+            return content[0].text;
+        }
+        // Multiple content items → return the array
+        return content;
+    }
+    /** Shut down all MCP connections */
+    async shutdown() {
+        const results = await Promise.allSettled(this.connections.map((conn) => conn.transport.close()));
+        for (let i = 0; i < results.length; i++) {
+            if (results[i].status === "rejected") {
+                console.warn(`[mcp] Error closing "${this.connections[i].serverName}"`);
+            }
+        }
+        this.connections = [];
+        this.toolEntries = [];
+        this.toolRoutes.clear();
+    }
+}

package/dist/pending-tool-results.d.ts

@@ -0,0 +1,4 @@
+export declare function waitForToolResult(toolCallId: string): Promise<unknown>;
+export declare function resolveToolResult(toolCallId: string, result: unknown): boolean;
+export declare function rejectToolResult(toolCallId: string, error: string): boolean;
+export declare function cancelAllPending(toolCallIds: string[]): void;

package/dist/pending-tool-results.js

@@ -0,0 +1,39 @@
+const TIMEOUT_MS = 120_000; // 2 minutes
+const pending = new Map();
+export function waitForToolResult(toolCallId) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(toolCallId);
+            reject(new Error(`Tool result timeout after ${TIMEOUT_MS / 1000}s for ${toolCallId}`));
+        }, TIMEOUT_MS);
+        pending.set(toolCallId, { resolve, reject, timer });
+    });
+}
+export function resolveToolResult(toolCallId, result) {
+    const entry = pending.get(toolCallId);
+    if (!entry)
+        return false;
+    clearTimeout(entry.timer);
+    pending.delete(toolCallId);
+    entry.resolve(result);
+    return true;
+}
+export function rejectToolResult(toolCallId, error) {
+    const entry = pending.get(toolCallId);
+    if (!entry)
+        return false;
+    clearTimeout(entry.timer);
+    pending.delete(toolCallId);
+    entry.reject(new Error(error));
+    return true;
+}
+export function cancelAllPending(toolCallIds) {
+    for (const id of toolCallIds) {
+        const entry = pending.get(id);
+        if (entry) {
+            clearTimeout(entry.timer);
+            pending.delete(id);
+            entry.reject(new Error("Client disconnected"));
+        }
+    }
+}