@portel/photon-core 1.2.0 → 1.3.1

package/dist/mcp-client.js

@@ -0,0 +1,211 @@
+/**
+ * MCP Protocol Client for Photons
+ *
+ * Enables Photons to call external MCPs via the MCP protocol.
+ * This is runtime-agnostic - the actual transport is provided by the runtime (NCP, Lumina, etc.)
+ *
+ * Usage in Photon:
+ * ```typescript
+ * export default class MyPhoton extends PhotonMCP {
+ *   async doSomething() {
+ *     const github = this.mcp('github');
+ *     const issues = await github.call('list_issues', { repo: 'foo/bar' });
+ *   }
+ * }
+ * ```
+ */
+/**
+ * MCP Client - Protocol wrapper for calling external MCPs
+ *
+ * Provides a clean async interface for Photons to call MCP tools.
+ * The actual protocol communication is handled by the transport layer.
+ */
+export class MCPClient {
+    mcpName;
+    transport;
+    toolsCache = null;
+    constructor(mcpName, transport) {
+        this.mcpName = mcpName;
+        this.transport = transport;
+    }
+    /**
+     * Get the MCP server name
+     */
+    get name() {
+        return this.mcpName;
+    }
+    /**
+     * Call a tool on this MCP server
+     *
+     * @param toolName The tool to call
+     * @param parameters Tool parameters
+     * @returns Tool result (parsed from MCP response)
+     *
+     * @example
+     * ```typescript
+     * const github = this.mcp('github');
+     * const issues = await github.call('list_issues', { repo: 'owner/repo', state: 'open' });
+     * ```
+     */
+    async call(toolName, parameters = {}) {
+        // Check connection first
+        const connected = await this.transport.isConnected(this.mcpName);
+        if (!connected) {
+            throw new MCPNotConnectedError(this.mcpName);
+        }
+        try {
+            const result = await this.transport.callTool(this.mcpName, toolName, parameters);
+            if (result.isError) {
+                const errorText = result.content.find(c => c.type === 'text')?.text || 'Unknown error';
+                throw new MCPToolError(this.mcpName, toolName, errorText);
+            }
+            // Extract and parse the result
+            return this.parseResult(result);
+        }
+        catch (error) {
+            if (error instanceof MCPError) {
+                throw error;
+            }
+            throw new MCPToolError(this.mcpName, toolName, error instanceof Error ? error.message : String(error));
+        }
+    }
+    /**
+     * List all available tools on this MCP server
+     *
+     * @returns Array of tool information
+     *
+     * @example
+     * ```typescript
+     * const github = this.mcp('github');
+     * const tools = await github.list();
+     * // [{ name: 'list_issues', description: '...' }, ...]
+     * ```
+     */
+    async list() {
+        if (this.toolsCache) {
+            return this.toolsCache;
+        }
+        const connected = await this.transport.isConnected(this.mcpName);
+        if (!connected) {
+            throw new MCPNotConnectedError(this.mcpName);
+        }
+        this.toolsCache = await this.transport.listTools(this.mcpName);
+        return this.toolsCache;
+    }
+    /**
+     * Find tools matching a query
+     *
+     * @param query Search query (matches name or description)
+     * @returns Matching tools
+     *
+     * @example
+     * ```typescript
+     * const github = this.mcp('github');
+     * const issueTools = await github.find('issue');
+     * ```
+     */
+    async find(query) {
+        const tools = await this.list();
+        const lowerQuery = query.toLowerCase();
+        return tools.filter(t => t.name.toLowerCase().includes(lowerQuery) ||
+            t.description?.toLowerCase().includes(lowerQuery));
+    }
+    /**
+     * Check if this MCP server is connected
+     */
+    async isConnected() {
+        return this.transport.isConnected(this.mcpName);
+    }
+    /**
+     * Clear the tools cache (useful after reconnection)
+     */
+    clearCache() {
+        this.toolsCache = null;
+    }
+    /**
+     * Parse MCP tool result into a usable value
+     */
+    parseResult(result) {
+        if (!result.content || result.content.length === 0) {
+            return null;
+        }
+        // Single text result - try to parse as JSON
+        if (result.content.length === 1 && result.content[0].type === 'text') {
+            const text = result.content[0].text || '';
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        }
+        // Multiple results or non-text - return as-is
+        return result.content.map(c => {
+            if (c.type === 'text') {
+                try {
+                    return JSON.parse(c.text || '');
+                }
+                catch {
+                    return c.text;
+                }
+            }
+            return c;
+        });
+    }
+}
+/**
+ * Base class for MCP-related errors
+ */
+export class MCPError extends Error {
+    mcpName;
+    constructor(mcpName, message) {
+        super(message);
+        this.mcpName = mcpName;
+        this.name = 'MCPError';
+    }
+}
+/**
+ * Error thrown when MCP server is not connected
+ */
+export class MCPNotConnectedError extends MCPError {
+    constructor(mcpName) {
+        super(mcpName, `MCP server '${mcpName}' is not connected`);
+        this.name = 'MCPNotConnectedError';
+    }
+}
+/**
+ * Error thrown when MCP tool call fails
+ */
+export class MCPToolError extends MCPError {
+    toolName;
+    details;
+    constructor(mcpName, toolName, details) {
+        super(mcpName, `MCP tool '${mcpName}:${toolName}' failed: ${details}`);
+        this.toolName = toolName;
+        this.details = details;
+        this.name = 'MCPToolError';
+    }
+}
+/**
+ * Create a proxy-based MCP client that allows direct method calls
+ *
+ * This enables a more fluent API:
+ * ```typescript
+ * const github = this.mcp('github');
+ * // Instead of: await github.call('list_issues', { repo: 'foo/bar' })
+ * // You can do: await github.list_issues({ repo: 'foo/bar' })
+ * ```
+ */
+export function createMCPProxy(client) {
+    return new Proxy(client, {
+        get(target, prop) {
+            // Return existing methods
+            if (prop in target) {
+                return target[prop];
+            }
+            // Return a function that calls the tool
+            return (params = {}) => target.call(prop, params);
+        },
+    });
+}
+//# sourceMappingURL=mcp-client.js.map

package/dist/mcp-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.js","sourceRoot":"","sources":["../src/mcp-client.ts"],"names":[],"mappings":"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"}

package/dist/mcp-sdk-transport.d.ts

@@ -0,0 +1,88 @@
+/**
+ * MCP SDK Transport for Photon Core
+ *
+ * Uses the official @modelcontextprotocol/sdk for connecting to MCP servers.
+ * Supports multiple transports:
+ * - stdio: Local processes (command + args)
+ * - sse: Server-Sent Events over HTTP
+ * - streamable-http: HTTP streaming
+ * - websocket: WebSocket connections
+ *
+ * Configuration formats:
+ * 1. stdio (local process):
+ *    { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] }
+ *
+ * 2. sse (HTTP SSE):
+ *    { "url": "http://localhost:3000/mcp", "transport": "sse" }
+ *
+ * 3. streamable-http:
+ *    { "url": "http://localhost:3000/mcp", "transport": "streamable-http" }
+ *
+ * 4. websocket:
+ *    { "url": "ws://localhost:3000/mcp", "transport": "websocket" }
+ */
+import { MCPClient, MCPTransport, MCPClientFactory, MCPToolInfo, MCPToolResult, createMCPProxy } from './mcp-client.js';
+/**
+ * MCP Server configuration
+ * Supports multiple transport types
+ */
+export interface MCPServerConfig {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    url?: string;
+    transport?: 'stdio' | 'sse' | 'streamable-http' | 'websocket';
+    headers?: Record<string, string>;
+}
+/**
+ * Full MCP configuration file format
+ */
+export interface MCPConfig {
+    mcpServers: Record<string, MCPServerConfig>;
+}
+/**
+ * SDK-based MCP Transport using official @modelcontextprotocol/sdk
+ */
+export declare class SDKMCPTransport implements MCPTransport {
+    private config;
+    private verbose;
+    private connections;
+    constructor(config: MCPConfig, verbose?: boolean);
+    private log;
+    /**
+     * Get or create connection to an MCP server
+     */
+    private getConnection;
+    callTool(mcpName: string, toolName: string, parameters: Record<string, any>): Promise<MCPToolResult>;
+    listTools(mcpName: string): Promise<MCPToolInfo[]>;
+    isConnected(mcpName: string): Promise<boolean>;
+    listServers(): string[];
+    disconnectAll(): Promise<void>;
+}
+/**
+ * SDK-based MCP Client Factory
+ */
+export declare class SDKMCPClientFactory implements MCPClientFactory {
+    private transport;
+    constructor(config: MCPConfig, verbose?: boolean);
+    create(mcpName: string): MCPClient;
+    listServers(): Promise<string[]>;
+    disconnect(): Promise<void>;
+    getTransport(): SDKMCPTransport;
+}
+/**
+ * Resolve an MCP source to a runnable configuration
+ * Handles: GitHub shorthand, npm packages, URLs, local paths
+ */
+export declare function resolveMCPSource(name: string, source: string, sourceType: 'github' | 'npm' | 'url' | 'local'): MCPServerConfig;
+/**
+ * Load MCP configuration from standard locations
+ */
+export declare function loadMCPConfig(verbose?: boolean): Promise<MCPConfig>;
+/**
+ * Create an SDK-based MCP client factory from default config
+ */
+export declare function createSDKMCPClientFactory(verbose?: boolean): Promise<SDKMCPClientFactory>;
+export { MCPClient, createMCPProxy };
+//# sourceMappingURL=mcp-sdk-transport.d.ts.map

package/dist/mcp-sdk-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-sdk-transport.d.ts","sourceRoot":"","sources":["../src/mcp-sdk-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAUH,OAAO,EACL,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,aAAa,EAGb,cAAc,EACf,MAAM,iBAAiB,CAAC;AAEzB;;;GAGG;AACH,MAAM,WAAW,eAAe;IAE9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAG7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,iBAAiB,GAAG,WAAW,CAAC;IAG9D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC7C;AAoLD;;GAEG;AACH,qBAAa,eAAgB,YAAW,YAAY;IAIhD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,OAAO;IAJjB,OAAO,CAAC,WAAW,CAA4C;gBAGrD,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE,OAAe;IAGlC,OAAO,CAAC,GAAG;IAMX;;OAEG;YACW,aAAa;IAmBrB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC;IAKpG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAKlD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQpD,WAAW,IAAI,MAAM,EAAE;IAIjB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;CAMrC;AAED;;GAEG;AACH,qBAAa,mBAAoB,YAAW,gBAAgB;IAC1D,OAAO,CAAC,SAAS,CAAkB;gBAEvB,MAAM,EAAE,SAAS,EAAE,OAAO,GAAE,OAAe;IAIvD,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS;IAI5B,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,YAAY,IAAI,eAAe;CAGhC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAC7C,eAAe,CAkDjB;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,GAAE,OAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CA6BhF;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE,OAAe,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAG9B;AAGD,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,CAAC"}

package/dist/mcp-sdk-transport.js

@@ -0,0 +1,360 @@
+/**
+ * MCP SDK Transport for Photon Core
+ *
+ * Uses the official @modelcontextprotocol/sdk for connecting to MCP servers.
+ * Supports multiple transports:
+ * - stdio: Local processes (command + args)
+ * - sse: Server-Sent Events over HTTP
+ * - streamable-http: HTTP streaming
+ * - websocket: WebSocket connections
+ *
+ * Configuration formats:
+ * 1. stdio (local process):
+ *    { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] }
+ *
+ * 2. sse (HTTP SSE):
+ *    { "url": "http://localhost:3000/mcp", "transport": "sse" }
+ *
+ * 3. streamable-http:
+ *    { "url": "http://localhost:3000/mcp", "transport": "streamable-http" }
+ *
+ * 4. websocket:
+ *    { "url": "ws://localhost:3000/mcp", "transport": "websocket" }
+ */
+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 { WebSocketClientTransport } from '@modelcontextprotocol/sdk/client/websocket.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { MCPClient, MCPNotConnectedError, MCPToolError, createMCPProxy, } from './mcp-client.js';
+/**
+ * Manages a single MCP server connection using official SDK
+ */
+class SDKMCPConnection {
+    name;
+    config;
+    verbose;
+    client = null;
+    transport = null;
+    tools = [];
+    initialized = false;
+    constructor(name, config, verbose = false) {
+        this.name = name;
+        this.config = config;
+        this.verbose = verbose;
+    }
+    log(message) {
+        if (this.verbose) {
+            console.error(`[MCP:${this.name}] ${message}`);
+        }
+    }
+    /**
+     * Create appropriate transport based on config
+     */
+    createTransport() {
+        const transportType = this.config.transport || (this.config.command ? 'stdio' : 'sse');
+        switch (transportType) {
+            case 'stdio': {
+                if (!this.config.command) {
+                    throw new Error(`stdio transport requires 'command' in config for ${this.name}`);
+                }
+                this.log(`Creating stdio transport: ${this.config.command} ${(this.config.args || []).join(' ')}`);
+                return new StdioClientTransport({
+                    command: this.config.command,
+                    args: this.config.args,
+                    cwd: this.config.cwd,
+                    env: this.config.env,
+                });
+            }
+            case 'sse': {
+                if (!this.config.url) {
+                    throw new Error(`sse transport requires 'url' in config for ${this.name}`);
+                }
+                this.log(`Creating SSE transport: ${this.config.url}`);
+                return new SSEClientTransport(new URL(this.config.url), {
+                    requestInit: this.config.headers ? { headers: this.config.headers } : undefined,
+                });
+            }
+            case 'streamable-http': {
+                if (!this.config.url) {
+                    throw new Error(`streamable-http transport requires 'url' in config for ${this.name}`);
+                }
+                this.log(`Creating streamable HTTP transport: ${this.config.url}`);
+                return new StreamableHTTPClientTransport(new URL(this.config.url), {
+                    requestInit: this.config.headers ? { headers: this.config.headers } : undefined,
+                });
+            }
+            case 'websocket': {
+                if (!this.config.url) {
+                    throw new Error(`websocket transport requires 'url' in config for ${this.name}`);
+                }
+                this.log(`Creating WebSocket transport: ${this.config.url}`);
+                return new WebSocketClientTransport(new URL(this.config.url));
+            }
+            default:
+                throw new Error(`Unknown transport type: ${transportType}`);
+        }
+    }
+    /**
+     * Connect to the MCP server
+     */
+    async connect() {
+        if (this.client) {
+            return; // Already connected
+        }
+        this.transport = this.createTransport();
+        this.client = new Client({
+            name: 'photon-core',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                roots: { listChanged: false },
+            },
+        });
+        this.log('Connecting...');
+        await this.client.connect(this.transport);
+        this.log('Connected');
+        // List available tools
+        const toolsResult = await this.client.listTools();
+        this.tools = (toolsResult.tools || []).map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+        this.log(`Loaded ${this.tools.length} tools`);
+        this.initialized = true;
+    }
+    /**
+     * Call a tool
+     */
+    async callTool(toolName, parameters) {
+        if (!this.client || !this.initialized) {
+            throw new MCPNotConnectedError(this.name);
+        }
+        try {
+            const result = await this.client.callTool({
+                name: toolName,
+                arguments: parameters,
+            });
+            // Convert to MCPToolResult format
+            if (result?.content && Array.isArray(result.content)) {
+                return {
+                    content: result.content.map((c) => ({
+                        type: c.type || 'text',
+                        text: c.text,
+                        data: c.data,
+                        mimeType: c.mimeType,
+                    })),
+                    isError: result.isError,
+                };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: typeof result === 'string' ? result : JSON.stringify(result),
+                    }],
+                isError: false,
+            };
+        }
+        catch (error) {
+            throw new MCPToolError(this.name, toolName, error.message);
+        }
+    }
+    /**
+     * List available tools
+     */
+    listTools() {
+        return this.tools;
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.initialized && this.client !== null;
+    }
+    /**
+     * Disconnect
+     */
+    async disconnect() {
+        if (this.client) {
+            this.log('Disconnecting...');
+            await this.client.close();
+            this.client = null;
+            this.transport = null;
+            this.initialized = false;
+        }
+    }
+}
+/**
+ * SDK-based MCP Transport using official @modelcontextprotocol/sdk
+ */
+export class SDKMCPTransport {
+    config;
+    verbose;
+    connections = new Map();
+    constructor(config, verbose = false) {
+        this.config = config;
+        this.verbose = verbose;
+    }
+    log(message) {
+        if (this.verbose) {
+            console.error(`[MCPTransport] ${message}`);
+        }
+    }
+    /**
+     * Get or create connection to an MCP server
+     */
+    async getConnection(mcpName) {
+        let connection = this.connections.get(mcpName);
+        if (connection?.isConnected()) {
+            return connection;
+        }
+        const serverConfig = this.config.mcpServers[mcpName];
+        if (!serverConfig) {
+            throw new MCPNotConnectedError(mcpName);
+        }
+        connection = new SDKMCPConnection(mcpName, serverConfig, this.verbose);
+        await connection.connect();
+        this.connections.set(mcpName, connection);
+        return connection;
+    }
+    async callTool(mcpName, toolName, parameters) {
+        const connection = await this.getConnection(mcpName);
+        return connection.callTool(toolName, parameters);
+    }
+    async listTools(mcpName) {
+        const connection = await this.getConnection(mcpName);
+        return connection.listTools();
+    }
+    async isConnected(mcpName) {
+        if (!this.config.mcpServers[mcpName]) {
+            return false;
+        }
+        const connection = this.connections.get(mcpName);
+        return connection?.isConnected() ?? false;
+    }
+    listServers() {
+        return Object.keys(this.config.mcpServers);
+    }
+    async disconnectAll() {
+        for (const connection of this.connections.values()) {
+            await connection.disconnect();
+        }
+        this.connections.clear();
+    }
+}
+/**
+ * SDK-based MCP Client Factory
+ */
+export class SDKMCPClientFactory {
+    transport;
+    constructor(config, verbose = false) {
+        this.transport = new SDKMCPTransport(config, verbose);
+    }
+    create(mcpName) {
+        return new MCPClient(mcpName, this.transport);
+    }
+    async listServers() {
+        return this.transport.listServers();
+    }
+    async disconnect() {
+        await this.transport.disconnectAll();
+    }
+    getTransport() {
+        return this.transport;
+    }
+}
+/**
+ * Resolve an MCP source to a runnable configuration
+ * Handles: GitHub shorthand, npm packages, URLs, local paths
+ */
+export function resolveMCPSource(name, source, sourceType) {
+    switch (sourceType) {
+        case 'npm': {
+            // npm:@scope/package or npm:package
+            const packageName = source.replace(/^npm:/, '');
+            return {
+                command: 'npx',
+                args: ['-y', packageName],
+                transport: 'stdio',
+            };
+        }
+        case 'github': {
+            // GitHub shorthand: owner/repo
+            // Try to run via npx assuming it's published to npm
+            return {
+                command: 'npx',
+                args: ['-y', `@${source}`],
+                transport: 'stdio',
+            };
+        }
+        case 'url': {
+            // Full URL - determine transport from protocol
+            if (source.startsWith('ws://') || source.startsWith('wss://')) {
+                return {
+                    url: source,
+                    transport: 'websocket',
+                };
+            }
+            // Default to SSE for HTTP URLs
+            return {
+                url: source,
+                transport: 'sse',
+            };
+        }
+        case 'local': {
+            // Local path - run directly with node
+            const resolvedPath = source.replace(/^~/, process.env.HOME || '');
+            return {
+                command: 'node',
+                args: [resolvedPath],
+                transport: 'stdio',
+            };
+        }
+        default:
+            throw new Error(`Unknown MCP source type: ${sourceType}`);
+    }
+}
+/**
+ * Load MCP configuration from standard locations
+ */
+export async function loadMCPConfig(verbose = false) {
+    const log = verbose ? (msg) => console.error(`[MCPConfig] ${msg}`) : () => { };
+    const configPaths = [
+        process.env.PHOTON_MCP_CONFIG,
+        path.join(process.cwd(), 'photon.mcp.json'),
+        path.join(os.homedir(), '.config', 'photon', 'mcp.json'),
+        path.join(os.homedir(), '.photon', 'mcp.json'),
+    ].filter(Boolean);
+    for (const configPath of configPaths) {
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            if (config.mcpServers && typeof config.mcpServers === 'object') {
+                log(`Loaded MCP config from ${configPath}`);
+                log(`Found ${Object.keys(config.mcpServers).length} MCP servers`);
+                return config;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                log(`Failed to load ${configPath}: ${error.message}`);
+            }
+        }
+    }
+    log('No MCP config found, MCP access will be unavailable');
+    return { mcpServers: {} };
+}
+/**
+ * Create an SDK-based MCP client factory from default config
+ */
+export async function createSDKMCPClientFactory(verbose = false) {
+    const config = await loadMCPConfig(verbose);
+    return new SDKMCPClientFactory(config, verbose);
+}
+// Re-export for convenience
+export { MCPClient, createMCPProxy };
+//# sourceMappingURL=mcp-sdk-transport.js.map