@minko-ai/minko 0.1.0 → 0.1.1

package/dist/mcp/client.js

@@ -0,0 +1,469 @@
+import { spawn } from 'node:child_process';
+import { readVersion } from "../util/version.js";
+const INIT_TIMEOUT_MS = 15_000;
+const CALL_TIMEOUT_MS = 120_000;
+/** Minimal MCP client over stdio, using newline-delimited JSON-RPC 2.0. */
+export class McpStdioClient {
+    name;
+    config;
+    child = null;
+    buffer = '';
+    nextId = 0;
+    pending = new Map();
+    toolDefs = [];
+    resourceDefs = [];
+    promptDefs = [];
+    templateDefs = [];
+    stderr = '';
+    closed = false;
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+    }
+    tools() {
+        return this.toolDefs.slice();
+    }
+    resources() {
+        return this.resourceDefs.slice();
+    }
+    async listResources() {
+        try {
+            const listed = await this.request('resources/list', {}, CALL_TIMEOUT_MS);
+            this.resourceDefs = parseResourceList(listed);
+        }
+        catch {
+            // Servers without resource support keep the cached/empty list.
+        }
+        return this.resourceDefs.slice();
+    }
+    async readResource(uri) {
+        const result = await this.request('resources/read', { uri }, CALL_TIMEOUT_MS);
+        return renderResourceContents(result);
+    }
+    prompts() {
+        return this.promptDefs.slice();
+    }
+    async listPrompts() {
+        try {
+            const listed = await this.request('prompts/list', {}, CALL_TIMEOUT_MS);
+            this.promptDefs = parsePromptList(listed);
+        }
+        catch {
+            // Prompts are optional.
+        }
+        return this.promptDefs.slice();
+    }
+    async getPrompt(name, args) {
+        const result = await this.request('prompts/get', { name, arguments: args }, CALL_TIMEOUT_MS);
+        return renderPrompt(result);
+    }
+    resourceTemplates() {
+        return this.templateDefs.slice();
+    }
+    async listResourceTemplates() {
+        try {
+            const listed = await this.request('resources/templates/list', {}, CALL_TIMEOUT_MS);
+            this.templateDefs = parseResourceTemplateList(listed);
+        }
+        catch {
+            // Templates are optional.
+        }
+        return this.templateDefs.slice();
+    }
+    async start() {
+        const command = this.config.command;
+        if (!command) {
+            throw new Error('MCP stdio server 缺少 command');
+        }
+        const launch = chooseSpawn(command);
+        const child = spawn(launch.command, this.config.args ?? [], {
+            cwd: this.config.cwd,
+            env: { ...process.env, ...(this.config.env ?? {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+            shell: launch.shell,
+        });
+        this.child = child;
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.onData(chunk));
+        child.stdin.on('error', () => {
+            // A server may exit while a request is still being written.
+        });
+        child.stderr.on('data', (chunk) => {
+            this.stderr = (this.stderr + chunk).slice(-4_000);
+        });
+        child.on('error', (error) => {
+            this.failAll('MCP 进程启动失败：' + error.message);
+        });
+        child.on('exit', (code) => {
+            if (!this.closed) {
+                const detail = this.stderr.trim();
+                this.failAll('MCP 进程退出（code ' + String(code) + '）' + (detail ? '：' + detail : ''));
+            }
+        });
+        try {
+            await this.request('initialize', {
+                protocolVersion: '2024-11-05',
+                capabilities: {},
+                clientInfo: { name: 'minko', version: readVersion() },
+            }, INIT_TIMEOUT_MS);
+            this.notify('notifications/initialized', {});
+            const listed = await this.request('tools/list', {}, INIT_TIMEOUT_MS);
+            this.toolDefs = parseToolList(listed);
+            try {
+                const resources = await this.request('resources/list', {}, INIT_TIMEOUT_MS);
+                this.resourceDefs = parseResourceList(resources);
+            }
+            catch {
+                // Resource support is optional.
+            }
+            try {
+                const prompts = await this.request('prompts/list', {}, INIT_TIMEOUT_MS);
+                this.promptDefs = parsePromptList(prompts);
+            }
+            catch {
+                // Prompt support is optional.
+            }
+            try {
+                const templates = await this.request('resources/templates/list', {}, INIT_TIMEOUT_MS);
+                this.templateDefs = parseResourceTemplateList(templates);
+            }
+            catch {
+                // Resource templates are optional.
+            }
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async callTool(name, args) {
+        const result = await this.request('tools/call', {
+            name,
+            arguments: args,
+        }, CALL_TIMEOUT_MS);
+        const text = renderContent(result.content);
+        if (result.isError === true) {
+            throw new Error(text.length > 0 ? text : 'MCP 工具返回错误');
+        }
+        return text;
+    }
+    async close() {
+        this.closed = true;
+        this.failAll('MCP 连接已关闭');
+        const child = this.child;
+        this.child = null;
+        if (!child || child.exitCode !== null) {
+            return;
+        }
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* already gone */ }
+                resolve();
+            }, 1_000);
+            child.once('exit', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            try {
+                child.kill();
+            }
+            catch {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+    }
+    request(method, params, timeoutMs) {
+        if (!this.child || this.closed) {
+            return Promise.reject(new Error('MCP 未连接：' + this.name));
+        }
+        const id = this.nextId + 1;
+        this.nextId = id;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error('MCP 请求超时：' + method));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.write({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.write({ jsonrpc: '2.0', method, params });
+    }
+    write(message) {
+        const child = this.child;
+        if (!child || this.closed) {
+            return;
+        }
+        child.stdin.write(JSON.stringify(message) + '\n');
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        for (;;) {
+            const index = this.buffer.indexOf('\n');
+            if (index < 0) {
+                break;
+            }
+            const line = this.buffer.slice(0, index).trim();
+            this.buffer = this.buffer.slice(index + 1);
+            if (line.length > 0) {
+                this.onMessage(line);
+            }
+        }
+    }
+    onMessage(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (typeof message.id === 'number' && this.pending.has(message.id)) {
+            const entry = this.pending.get(message.id);
+            if (!entry) {
+                return;
+            }
+            this.pending.delete(message.id);
+            clearTimeout(entry.timer);
+            if (message.error) {
+                entry.reject(new Error('MCP 错误：' + message.error.message));
+            }
+            else {
+                entry.resolve(message.result);
+            }
+            return;
+        }
+        // A server-to-client request must get a response or it may hang.
+        if (message.method !== undefined && message.id !== undefined) {
+            this.write({
+                jsonrpc: '2.0',
+                id: message.id,
+                error: { code: -32601, message: 'method not found' },
+            });
+        }
+    }
+    failAll(message) {
+        for (const [id, entry] of this.pending) {
+            clearTimeout(entry.timer);
+            entry.reject(new Error(message));
+            this.pending.delete(id);
+        }
+    }
+}
+export function parseResourceList(value) {
+    if (value === null || typeof value !== 'object') {
+        return [];
+    }
+    const resources = value.resources;
+    if (!Array.isArray(resources)) {
+        return [];
+    }
+    const out = [];
+    for (const raw of resources) {
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const record = raw;
+        if (typeof record.uri !== 'string' || record.uri.length === 0) {
+            continue;
+        }
+        out.push({
+            uri: record.uri,
+            name: typeof record.name === 'string' ? record.name : undefined,
+            description: typeof record.description === 'string' ? record.description : undefined,
+            mimeType: typeof record.mimeType === 'string' ? record.mimeType : undefined,
+        });
+    }
+    return out;
+}
+export function parsePromptList(value) {
+    if (value === null || typeof value !== 'object') {
+        return [];
+    }
+    const prompts = value.prompts;
+    if (!Array.isArray(prompts)) {
+        return [];
+    }
+    const out = [];
+    for (const raw of prompts) {
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const record = raw;
+        if (typeof record.name !== 'string' || record.name.length === 0) {
+            continue;
+        }
+        const args = [];
+        if (Array.isArray(record.arguments)) {
+            for (const rawArg of record.arguments) {
+                if (rawArg === null || typeof rawArg !== 'object') {
+                    continue;
+                }
+                const arg = rawArg;
+                if (typeof arg.name !== 'string' || arg.name.length === 0) {
+                    continue;
+                }
+                args.push({
+                    name: arg.name,
+                    description: typeof arg.description === 'string' ? arg.description : undefined,
+                    required: arg.required === true,
+                });
+            }
+        }
+        out.push({
+            name: record.name,
+            description: typeof record.description === 'string' ? record.description : undefined,
+            ...(args.length > 0 ? { arguments: args } : {}),
+        });
+    }
+    return out;
+}
+export function renderPrompt(value) {
+    if (value === null || typeof value !== 'object') {
+        return '';
+    }
+    const record = value;
+    const parts = [];
+    if (typeof record.description === 'string' && record.description.length > 0) {
+        parts.push(record.description);
+    }
+    const messages = record.messages;
+    if (Array.isArray(messages)) {
+        for (const raw of messages) {
+            if (raw === null || typeof raw !== 'object') {
+                continue;
+            }
+            const message = raw;
+            const role = typeof message.role === 'string' ? message.role : 'user';
+            const content = message.content;
+            let text = '';
+            if (content !== null && typeof content === 'object') {
+                const block = content;
+                text = typeof block.text === 'string' ? block.text : JSON.stringify(block);
+            }
+            else if (typeof content === 'string') {
+                text = content;
+            }
+            parts.push('[' + role + '] ' + text);
+        }
+    }
+    return parts.join('\n\n');
+}
+export function parseResourceTemplateList(value) {
+    if (value === null || typeof value !== 'object') {
+        return [];
+    }
+    const templates = value.resourceTemplates;
+    if (!Array.isArray(templates)) {
+        return [];
+    }
+    const out = [];
+    for (const raw of templates) {
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const record = raw;
+        if (typeof record.uriTemplate !== 'string' || record.uriTemplate.length === 0) {
+            continue;
+        }
+        out.push({
+            uriTemplate: record.uriTemplate,
+            name: typeof record.name === 'string' ? record.name : undefined,
+            description: typeof record.description === 'string' ? record.description : undefined,
+            mimeType: typeof record.mimeType === 'string' ? record.mimeType : undefined,
+        });
+    }
+    return out;
+}
+export function renderResourceContents(value) {
+    if (value === null || typeof value !== 'object') {
+        return '';
+    }
+    const contents = value.contents;
+    if (!Array.isArray(contents)) {
+        return '';
+    }
+    const parts = [];
+    for (const raw of contents) {
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const record = raw;
+        const uri = typeof record.uri === 'string' ? record.uri : '';
+        const mime = typeof record.mimeType === 'string' ? record.mimeType : '';
+        if (typeof record.text === 'string') {
+            parts.push('URI: ' + uri + (mime ? '\nMIME: ' + mime : '') + '\n' + record.text);
+        }
+        else if (typeof record.blob === 'string') {
+            parts.push('URI: ' + uri + (mime ? '\nMIME: ' + mime : '')
+                + '\n（二进制内容，base64 长度 ' + record.blob.length + '）');
+        }
+    }
+    return parts.join('\n\n');
+}
+export function parseToolList(value) {
+    if (value === null || typeof value !== 'object') {
+        return [];
+    }
+    const tools = value.tools;
+    if (!Array.isArray(tools)) {
+        return [];
+    }
+    const out = [];
+    for (const raw of tools) {
+        if (raw === null || typeof raw !== 'object') {
+            continue;
+        }
+        const record = raw;
+        if (typeof record.name !== 'string' || record.name.length === 0) {
+            continue;
+        }
+        out.push({
+            name: record.name,
+            description: typeof record.description === 'string' ? record.description : undefined,
+            inputSchema: record.inputSchema,
+        });
+    }
+    return out;
+}
+export function renderContent(content) {
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    const parts = [];
+    for (const block of content) {
+        if (block !== null && typeof block === 'object') {
+            const record = block;
+            if (record.type === 'text' && typeof record.text === 'string') {
+                parts.push(record.text);
+            }
+            else {
+                parts.push(JSON.stringify(record));
+            }
+        }
+        else if (typeof block === 'string') {
+            parts.push(block);
+        }
+    }
+    return parts.join('\n');
+}
+function chooseSpawn(command) {
+    if (process.platform !== 'win32') {
+        return { command, shell: false };
+    }
+    // `.cmd` shims and bare PATH commands (npx, uvx) need cmd.exe on Windows.
+    if (/\.(cmd|bat)$/i.test(command)) {
+        return { command, shell: true };
+    }
+    if (!command.includes('/') && !command.includes('\\')) {
+        return { command, shell: true };
+    }
+    return { command, shell: false };
+}

package/dist/mcp/httpClient.js

@@ -0,0 +1,191 @@
+import { HttpError } from "../util/errors.js";
+import { readVersion } from "../util/version.js";
+import { sseEvents } from "../providers/sse.js";
+import { parsePromptList, parseResourceList, parseResourceTemplateList, parseToolList, renderContent, renderPrompt, renderResourceContents, } from "./client.js";
+const REQUEST_TIMEOUT_MS = 30_000;
+/** Minimal MCP Streamable HTTP client with optional Bearer auth. */
+export class McpHttpClient {
+    name;
+    config;
+    url;
+    token;
+    nextId = 0;
+    sessionId = null;
+    toolDefs = [];
+    resourceDefs = [];
+    promptDefs = [];
+    templateDefs = [];
+    closed = false;
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+        this.url = config.url ?? '';
+        this.token = config.token ?? '';
+    }
+    tools() {
+        return this.toolDefs.slice();
+    }
+    resources() {
+        return this.resourceDefs.slice();
+    }
+    async start() {
+        if (!this.url) {
+            throw new Error('MCP HTTP server 缺少 url');
+        }
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'minko', version: readVersion() },
+        });
+        await this.notify('notifications/initialized', {});
+        const listed = await this.request('tools/list', {});
+        this.toolDefs = parseToolList(listed);
+        try {
+            const resources = await this.request('resources/list', {});
+            this.resourceDefs = parseResourceList(resources);
+        }
+        catch {
+            // Resource support is optional.
+        }
+        try {
+            const prompts = await this.request('prompts/list', {});
+            this.promptDefs = parsePromptList(prompts);
+        }
+        catch {
+            // Prompt support is optional.
+        }
+        try {
+            const templates = await this.request('resources/templates/list', {});
+            this.templateDefs = parseResourceTemplateList(templates);
+        }
+        catch {
+            // Resource templates are optional.
+        }
+    }
+    async callTool(name, args) {
+        const result = await this.request('tools/call', { name, arguments: args });
+        const text = renderContent(result.content);
+        if (result.isError === true) {
+            throw new Error(text.length > 0 ? text : 'MCP 工具返回错误');
+        }
+        return text;
+    }
+    async listResources() {
+        try {
+            const listed = await this.request('resources/list', {});
+            this.resourceDefs = parseResourceList(listed);
+        }
+        catch {
+            // Keep cached/empty.
+        }
+        return this.resourceDefs.slice();
+    }
+    async readResource(uri) {
+        const result = await this.request('resources/read', { uri });
+        return renderResourceContents(result);
+    }
+    prompts() {
+        return this.promptDefs.slice();
+    }
+    async listPrompts() {
+        try {
+            const listed = await this.request('prompts/list', {});
+            this.promptDefs = parsePromptList(listed);
+        }
+        catch {
+            // Optional.
+        }
+        return this.promptDefs.slice();
+    }
+    async getPrompt(name, args) {
+        const result = await this.request('prompts/get', { name, arguments: args });
+        return renderPrompt(result);
+    }
+    resourceTemplates() {
+        return this.templateDefs.slice();
+    }
+    async listResourceTemplates() {
+        try {
+            const listed = await this.request('resources/templates/list', {});
+            this.templateDefs = parseResourceTemplateList(listed);
+        }
+        catch {
+            // Optional.
+        }
+        return this.templateDefs.slice();
+    }
+    async close() {
+        this.closed = true;
+    }
+    async request(method, params) {
+        if (this.closed) {
+            throw new Error('MCP 连接已关闭');
+        }
+        const id = this.nextId + 1;
+        this.nextId = id;
+        const response = await this.post({ jsonrpc: '2.0', id, method, params });
+        if (!response) {
+            throw new Error('MCP HTTP 返回为空');
+        }
+        if (response.error) {
+            throw new Error('MCP 错误：' + response.error.message);
+        }
+        return response.result;
+    }
+    async notify(method, params) {
+        await this.post({ jsonrpc: '2.0', method, params });
+    }
+    async post(message) {
+        const headers = {
+            'content-type': 'application/json',
+            accept: 'application/json, text/event-stream',
+        };
+        if (this.token.length > 0) {
+            headers.authorization = 'Bearer ' + this.token;
+        }
+        if (this.sessionId) {
+            headers['mcp-session-id'] = this.sessionId;
+        }
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(message),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        const session = response.headers.get('mcp-session-id');
+        if (session) {
+            this.sessionId = session;
+        }
+        if (!response.ok) {
+            throw new HttpError(response.status, await response.text());
+        }
+        if (message.id === undefined || message.id === null) {
+            await response.body?.cancel().catch(() => { });
+            return null;
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('text/event-stream')) {
+            if (!response.body) {
+                throw new Error('MCP HTTP 没有返回可读的流');
+            }
+            for await (const event of sseEvents(response.body)) {
+                let payload;
+                try {
+                    payload = JSON.parse(event.data);
+                }
+                catch {
+                    continue;
+                }
+                if (payload.id === message.id) {
+                    return payload;
+                }
+            }
+            throw new Error('MCP HTTP 流没有返回匹配的响应');
+        }
+        const payload = await response.json().catch(() => null);
+        if (!payload) {
+            throw new Error('MCP HTTP 响应不是合法 JSON');
+        }
+        return payload;
+    }
+}