@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/{core/remote → remote}/remote-agent-manager.js

@@ -1,100 +1,148 @@
 "use strict";
+/**
+ * Remote Agent Manager
+ *
+ * Manages communication with remote MCP agents.
+ * Migrated from sdk-bak/src/core/remote/remote-agent-manager.ts
+ * and adapted to use the new RemoteTransport interface.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoteAgentManager = void 0;
-const remote_transport_1 = require("./remote-transport");
+const remote_transport_js_1 = require("./remote-transport.js");
+/**
+ * Remote Agent Manager
+ *
+ * Manages communication with remote MCP agents.
+ * Each loaded agent config creates its own transport instance.
+ */
 class RemoteAgentManager {
+    logger;
+    configs = new Map();
+    transports = new Map();
     constructor(options = {}) {
-        this.configs = new Map();
-        this.transport = options.transport || new remote_transport_1.FetchRemoteTransport();
-        this.logger = options.logger || (() => { });
+        this.logger = options.logger ?? (() => { });
     }
+    /**
+     * Load configuration for a remote agent.
+     * Creates a transport instance for the agent.
+     */
     loadConfig(agentId, config) {
         this.validateConfig(config);
         this.configs.set(agentId, config);
+        this.transports.set(agentId, new remote_transport_js_1.McpHttpTransport({
+            url: config.url,
+            apiKey: config.apiKey,
+            headers: config.headers,
+            timeoutMs: config.timeoutMs,
+        }));
         this.logger(`Loaded remote agent config for: ${agentId}`, 'debug');
     }
-    loadConfigs(configs) {
-        const configMap = configs instanceof Map ? configs : new Map(Object.entries(configs));
-        for (const [agentId, config] of configMap) {
-            this.loadConfig(agentId, config);
-        }
+    /**
+     * Load configuration with a custom transport (e.g. for testing).
+     */
+    loadConfigWithTransport(agentId, config, transport) {
+        this.validateConfig(config);
+        this.configs.set(agentId, config);
+        this.transports.set(agentId, transport);
+        this.logger(`Loaded remote agent config for: ${agentId} (custom transport)`, 'debug');
     }
+    /** Get configuration for a remote agent. */
     getConfig(agentId) {
         return this.configs.get(agentId);
     }
+    /** Check if an agent is configured as remote. */
     isRemoteAgent(agentId) {
         return this.configs.has(agentId);
     }
+    /** Get all configured remote agent IDs. */
     getRemoteAgentIds() {
         return Array.from(this.configs.keys());
     }
+    /** Query a remote agent. */
     async query(agentId, request) {
-        const config = this.getConfig(agentId);
-        if (!config) {
-            throw new Error(`Agent ${agentId} is not configured as a remote agent`);
-        }
+        const config = this.requireConfig(agentId);
         const toolName = config.tools?.query ?? 'crewx_queryAgent';
         const remoteAgentId = config.agentId ?? agentId;
         const payload = {
             agentId: remoteAgentId,
             query: request.query,
         };
-        if (request.context) {
+        if (request.context)
             payload.context = request.context;
-        }
-        if (request.model) {
+        if (request.model)
             payload.model = request.model;
-        }
-        if (request.platform) {
+        if (request.platform)
             payload.platform = request.platform;
-        }
-        if (request.messages && request.messages.length > 0) {
+        if (request.messages?.length)
             payload.messages = request.messages;
-        }
         try {
-            const result = await this.callRemoteTool(config, toolName, payload);
+            const result = await this.callRemoteTool(agentId, toolName, payload);
             return this.normalizeResponse(result);
         }
         catch (error) {
-            this.logger(`Remote query failed for agent ${agentId}: ${error.message}`, 'error');
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger(`Remote query failed for agent ${agentId}: ${msg}`, 'error');
             throw error;
         }
     }
+    /** Execute a task on a remote agent. */
     async execute(agentId, request) {
-        const config = this.getConfig(agentId);
-        if (!config) {
-            throw new Error(`Agent ${agentId} is not configured as a remote agent`);
-        }
+        const config = this.requireConfig(agentId);
         const toolName = config.tools?.execute ?? 'crewx_executeAgent';
         const remoteAgentId = config.agentId ?? agentId;
         const payload = {
             agentId: remoteAgentId,
             task: request.task,
         };
-        if (request.context) {
+        if (request.context)
             payload.context = request.context;
-        }
-        if (request.model) {
+        if (request.model)
             payload.model = request.model;
-        }
-        if (request.platform) {
+        if (request.platform)
             payload.platform = request.platform;
-        }
-        if (request.messages && request.messages.length > 0) {
+        if (request.messages?.length)
             payload.messages = request.messages;
-        }
         try {
-            const result = await this.callRemoteTool(config, toolName, payload);
+            const result = await this.callRemoteTool(agentId, toolName, payload);
             return this.normalizeResponse(result);
         }
         catch (error) {
-            this.logger(`Remote execute failed for agent ${agentId}: ${error.message}`, 'error');
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger(`Remote execute failed for agent ${agentId}: ${msg}`, 'error');
             throw error;
         }
     }
-    async callRemoteTool(config, toolName, args) {
-        const baseUrl = this.normalizeUrl(config.url);
-        const url = `${baseUrl}/mcp`;
+    /** Map tool names for a remote agent. */
+    mapToolNames(agentId, mapping) {
+        const config = this.requireConfig(agentId);
+        config.tools = {
+            query: mapping.query ?? config.tools?.query ?? 'crewx_queryAgent',
+            execute: mapping.execute ?? config.tools?.execute ?? 'crewx_executeAgent',
+        };
+        this.logger(`Updated tool name mapping for agent ${agentId}`, 'debug');
+    }
+    /** Clear all configurations and close transports. */
+    async clearConfigs() {
+        for (const transport of this.transports.values()) {
+            await transport.close();
+        }
+        this.configs.clear();
+        this.transports.clear();
+        this.logger('Cleared all remote agent configurations', 'debug');
+    }
+    // ── Private ───────────────────────────────────────────────────────────────
+    requireConfig(agentId) {
+        const config = this.configs.get(agentId);
+        if (!config) {
+            throw new Error(`Agent ${agentId} is not configured as a remote agent`);
+        }
+        return config;
+    }
+    async callRemoteTool(agentId, toolName, args) {
+        const transport = this.transports.get(agentId);
+        if (!transport) {
+            throw new Error(`No transport available for agent ${agentId}`);
+        }
         const request = {
             jsonrpc: '2.0',
             id: `${toolName}-${Date.now()}`,
@@ -104,76 +152,35 @@ class RemoteAgentManager {
                 arguments: args,
             },
         };
-        const headers = {
-            ...(config.headers || {}),
-        };
-        if (config.apiKey) {
-            headers['Authorization'] = `Bearer ${config.apiKey}`;
-        }
-        this.logger(`Calling remote MCP tool ${toolName} on ${baseUrl}`, 'debug');
-        const response = await this.transport.request(url, {
-            method: 'POST',
-            headers,
-            body: request,
-            timeoutMs: config.timeoutMs,
-        });
+        this.logger(`Calling remote MCP tool ${toolName} for agent ${agentId}`, 'debug');
+        const response = await transport.send(request);
         if (response.error) {
             throw new Error(response.error.message || 'MCP server returned an error');
         }
         return response.result;
     }
+    /** Normalize remote agent response to consistent format. */
     normalizeResponse(result) {
         if (!result) {
             return {
                 success: false,
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Remote agent returned no response.',
-                    },
-                ],
+                content: [{ type: 'text', text: 'Remote agent returned no response.' }],
             };
         }
-        if (Array.isArray(result.content) && result.content.length > 0) {
-            return result;
+        const obj = result;
+        // Already has content array — return as-is
+        if (Array.isArray(obj.content) && obj.content.length > 0) {
+            return obj;
         }
-        const fallbackContent = result.response ?? result.implementation ?? result.message ?? result.output;
+        // Extract content from various possible fields
+        const fallbackContent = obj.response ?? obj.implementation ?? obj.message ?? obj.output;
         const text = typeof fallbackContent === 'string'
             ? fallbackContent
             : JSON.stringify(fallbackContent ?? result, null, 2);
         return {
-            ...result,
-            content: [
-                {
-                    type: 'text',
-                    text,
-                },
-            ],
-        };
-    }
-    normalizeUrl(url) {
-        if (!url) {
-            return url;
-        }
-        const trimmed = url.trim();
-        if (!trimmed) {
-            return trimmed;
-        }
-        const withoutTrailingSlash = trimmed.replace(/\/+$/, '');
-        return withoutTrailingSlash.toLowerCase().endsWith('/mcp')
-            ? withoutTrailingSlash.slice(0, -4)
-            : withoutTrailingSlash;
-    }
-    mapToolNames(agentId, mapping) {
-        const config = this.getConfig(agentId);
-        if (!config) {
-            throw new Error(`Agent ${agentId} is not configured as a remote agent`);
-        }
-        config.tools = {
-            query: mapping.query ?? config.tools?.query ?? 'crewx_queryAgent',
-            execute: mapping.execute ?? config.tools?.execute ?? 'crewx_executeAgent',
+            ...obj,
+            content: [{ type: 'text', text }],
         };
-        this.logger(`Updated tool name mapping for agent ${agentId}`, 'debug');
     }
     validateConfig(config) {
         if (!config.url) {
@@ -186,10 +193,6 @@ class RemoteAgentManager {
             throw new Error(`Unsupported remote agent type: ${config.type}`);
         }
     }
-    clearConfigs() {
-        this.configs.clear();
-        this.logger('Cleared all remote agent configurations', 'debug');
-    }
 }
 exports.RemoteAgentManager = RemoteAgentManager;
 //# sourceMappingURL=remote-agent-manager.js.map

package/dist/remote/remote-provider.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Remote Provider Runtime
+ *
+ * Implements ProviderRuntime for remote agents via MCP-HTTP transport.
+ *
+ * Resolution path:
+ *   - http(s):// → MCP-HTTP transport via RemoteAgentManager
+ *
+ * Note: file:// remote agents are handled at the CLI level by swapping the
+ * Crewx instance to the target crewx.yaml before calling query/execute.
+ * See packages/cli/src/commands/execute.ts and query.ts for details.
+ */
+import type { ProviderRuntime, ProviderQueryOptions } from '../provider/bridge.js';
+import type { RemoteProviderConfig } from './types.js';
+import type { AgentConfig } from '../types/index.js';
+export type ProviderFactoryFn = (providerStr: string) => ProviderRuntime;
+export interface FileRemoteResolution {
+    agent: AgentConfig;
+    provider: string;
+}
+/** Raw agent shape extracted from a remote crewx.yaml — minimal, lenient. */
+interface RawAgent {
+    id: string;
+    provider?: string | string[];
+    /** Newer crewx.yaml format: provider may live inside inline. */
+    inline?: {
+        provider?: string | string[];
+    };
+    working_directory?: string;
+    [key: string]: unknown;
+}
+export declare function resolveFileRemoteAgent(config: RemoteProviderConfig, yamlLoader?: (path: string) => {
+    agents?: RawAgent[];
+}, existsFn?: (path: string) => boolean): FileRemoteResolution;
+export interface FileRemoteResolver {
+    (config: RemoteProviderConfig): FileRemoteResolution;
+}
+export declare class RemoteProviderRuntime implements ProviderRuntime {
+    private readonly manager;
+    private readonly agentId;
+    constructor(remoteId: string, providerConfig: RemoteProviderConfig, _providerFactory?: ProviderFactoryFn);
+    query(message: string, options?: ProviderQueryOptions): Promise<string>;
+    execute(message: string, options?: ProviderQueryOptions): Promise<string>;
+}
+export declare function createRemoteProviderFactory(remoteConfigs: Map<string, RemoteProviderConfig>, providerFactory?: ProviderFactoryFn): (id: string, providerStr: string) => ProviderRuntime;
+export {};
+//# sourceMappingURL=remote-provider.d.ts.map

package/dist/remote/remote-provider.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Remote Provider Runtime
+ *
+ * Implements ProviderRuntime for remote agents via MCP-HTTP transport.
+ *
+ * Resolution path:
+ *   - http(s):// → MCP-HTTP transport via RemoteAgentManager
+ *
+ * Note: file:// remote agents are handled at the CLI level by swapping the
+ * Crewx instance to the target crewx.yaml before calling query/execute.
+ * See packages/cli/src/commands/execute.ts and query.ts for details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteProviderRuntime = void 0;
+exports.resolveFileRemoteAgent = resolveFileRemoteAgent;
+exports.createRemoteProviderFactory = createRemoteProviderFactory;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const js_yaml_1 = require("js-yaml");
+const bridge_js_1 = require("../provider/bridge.js");
+const remote_agent_manager_js_1 = require("./remote-agent-manager.js");
+/**
+ * Load a remote crewx.yaml without strict schema validation.
+ *
+ * Unlike loadYamlFile(), this does not run Zod validation so it tolerates
+ * schema variations in remote workspaces (e.g. provider nested in inline).
+ */
+function loadYamlFileLenient(filePath) {
+    const content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const raw = (0, js_yaml_1.load)(content);
+    const agents = Array.isArray(raw?.agents) ? raw.agents : undefined;
+    return { agents };
+}
+/**
+ * Extract provider string from an agent, handling both formats:
+ *  - top-level:  agent.provider = "cli/claude"
+ *  - inline:     agent.inline.provider = "cli/claude"
+ */
+function extractAgentProvider(agent) {
+    const direct = Array.isArray(agent.provider) ? agent.provider[0] : agent.provider;
+    if (direct)
+        return direct;
+    const fromInline = Array.isArray(agent.inline?.provider)
+        ? agent.inline.provider[0]
+        : agent.inline?.provider;
+    return fromInline;
+}
+function resolveFileRemoteAgent(config, yamlLoader = loadYamlFileLenient, existsFn = fs_1.existsSync) {
+    const configPath = config.location.replace('file://', '');
+    if (!existsFn(configPath)) {
+        throw new Error(`Remote config file not found: ${configPath}`);
+    }
+    if (!config.external_agent_id) {
+        throw new Error(`external_agent_id is required for file:// remote provider "${config.id}"`);
+    }
+    const targetConfig = yamlLoader(configPath);
+    const targetAgent = targetConfig.agents?.find((a) => a.id === config.external_agent_id);
+    if (!targetAgent) {
+        throw new Error(`Agent "${config.external_agent_id}" not found in ${configPath}`);
+    }
+    const targetProvider = extractAgentProvider(targetAgent);
+    if (!targetProvider) {
+        throw new Error(`Agent "${config.external_agent_id}" in ${configPath} has no provider configured`);
+    }
+    if (targetProvider.startsWith('remote/')) {
+        throw new Error(`Chained remotes not allowed: ${config.id} → ${targetProvider}`);
+    }
+    // Resolve working_directory relative to target config file's directory.
+    // path.resolve handles absolute paths transparently (absolute overrides base).
+    const resolvedDir = (0, path_1.resolve)((0, path_1.dirname)(configPath), targetAgent.working_directory ?? '.');
+    return {
+        agent: { ...targetAgent, working_directory: resolvedDir },
+        provider: targetProvider,
+    };
+}
+class RemoteProviderRuntime {
+    manager;
+    agentId;
+    constructor(remoteId, providerConfig, _providerFactory = bridge_js_1.createProvider) {
+        this.agentId = providerConfig.external_agent_id ?? remoteId;
+        this.manager = new remote_agent_manager_js_1.RemoteAgentManager();
+        const mcpConfig = toRemoteAgentConfig(remoteId, providerConfig);
+        this.manager.loadConfig(this.agentId, mcpConfig);
+    }
+    async query(message, options) {
+        const response = await this.manager.query(this.agentId, {
+            agentId: this.agentId,
+            query: message,
+            model: options?.model,
+            context: options?.context ?? options?.systemPrompt,
+        });
+        return response.content.map((c) => c.text).join('\n');
+    }
+    async execute(message, options) {
+        const response = await this.manager.execute(this.agentId, {
+            agentId: this.agentId,
+            task: message,
+            model: options?.model,
+            context: options?.context ?? options?.systemPrompt,
+        });
+        return response.content.map((c) => c.text).join('\n');
+    }
+}
+exports.RemoteProviderRuntime = RemoteProviderRuntime;
+// ── Factory ─────────────────────────────────────────────────────────────────
+function createRemoteProviderFactory(remoteConfigs, providerFactory = bridge_js_1.createProvider) {
+    return (id, _providerStr) => {
+        const config = remoteConfigs.get(id);
+        if (!config) {
+            throw new Error(`Remote provider "${id}" not found. Available: ${Array.from(remoteConfigs.keys()).join(', ') || '(none)'}`);
+        }
+        // file:// locations are handled at the CLI level (Crewx instance swap).
+        // RemoteProviderRuntime only supports http(s):// (MCP-HTTP).
+        if (config.location.startsWith('file://')) {
+            throw new Error(`Remote provider "${id}" uses file:// location which is not supported at the SDK level. ` +
+                'Use the CLI commands (crewx query / crewx execute) which handle file:// remotes automatically.');
+        }
+        return new RemoteProviderRuntime(id, config, providerFactory);
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function toRemoteAgentConfig(remoteId, config) {
+    const location = config.location;
+    if (!location) {
+        throw new Error('Remote provider config requires a location');
+    }
+    if (!location.startsWith('http://') &&
+        !location.startsWith('https://')) {
+        throw new Error(`Unsupported remote location protocol for MCP-HTTP: ${location}`);
+    }
+    return {
+        type: 'mcp-http',
+        url: location,
+        apiKey: config.apiKey,
+        headers: config.headers,
+        timeoutMs: config.timeout?.query ?? 30000,
+        agentId: config.external_agent_id ?? remoteId,
+    };
+}
+//# sourceMappingURL=remote-provider.js.map

package/dist/remote/remote-transport.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Remote Transport Implementations
+ *
+ * MCP-HTTP JSON-RPC 2.0 transport for communicating with remote MCP servers.
+ * Migrated from sdk-bak and adapted to the new RemoteTransport interface.
+ */
+import type { RemoteTransport, McpJsonRpcRequest, McpJsonRpcResponse } from './types.js';
+/** Options for creating an McpHttpTransport. */
+export interface McpHttpTransportOptions {
+    /** Base URL of the MCP server (e.g. "http://localhost:3030"). */
+    url: string;
+    /** Optional API key for Bearer authentication. */
+    apiKey?: string;
+    /** Optional custom headers. */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 30000). */
+    timeoutMs?: number;
+}
+/**
+ * MCP-HTTP transport — sends JSON-RPC 2.0 requests over HTTP POST.
+ *
+ * Endpoint: `${baseUrl}/mcp`
+ */
+export declare class McpHttpTransport implements RemoteTransport {
+    private readonly endpoint;
+    private readonly headers;
+    private readonly timeoutMs;
+    constructor(options: McpHttpTransportOptions);
+    send(request: McpJsonRpcRequest): Promise<McpJsonRpcResponse>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=remote-transport.d.ts.map

package/dist/remote/remote-transport.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Remote Transport Implementations
+ *
+ * MCP-HTTP JSON-RPC 2.0 transport for communicating with remote MCP servers.
+ * Migrated from sdk-bak and adapted to the new RemoteTransport interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpHttpTransport = void 0;
+/**
+ * MCP-HTTP transport — sends JSON-RPC 2.0 requests over HTTP POST.
+ *
+ * Endpoint: `${baseUrl}/mcp`
+ */
+class McpHttpTransport {
+    endpoint;
+    headers;
+    timeoutMs;
+    constructor(options) {
+        const baseUrl = normalizeUrl(options.url);
+        this.endpoint = `${baseUrl}/mcp`;
+        this.headers = {
+            'Content-Type': 'application/json',
+            ...(options.headers ?? {}),
+        };
+        if (options.apiKey) {
+            this.headers['Authorization'] = `Bearer ${options.apiKey}`;
+        }
+        this.timeoutMs = options.timeoutMs ?? 30000;
+    }
+    async send(request) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(this.endpoint, {
+                method: 'POST',
+                headers: this.headers,
+                body: JSON.stringify(request),
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                const text = await response.text();
+                throw new Error(`HTTP ${response.status}: ${response.statusText}${text ? ` - ${text}` : ''}`);
+            }
+            const contentType = response.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+                return (await response.json());
+            }
+            // Non-JSON response — wrap as error
+            const body = await response.text();
+            return {
+                jsonrpc: '2.0',
+                id: request.id,
+                error: { code: -32600, message: `Unexpected response content-type: ${contentType}`, data: body },
+            };
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`MCP-HTTP request timeout after ${this.timeoutMs}ms to ${this.endpoint}`);
+            }
+            throw error;
+        }
+    }
+    async close() {
+        // No persistent connection to close for HTTP transport.
+    }
+}
+exports.McpHttpTransport = McpHttpTransport;
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Normalize a URL: remove trailing slashes and redundant /mcp suffix.
+ */
+function normalizeUrl(url) {
+    if (!url)
+        return url;
+    const trimmed = url.trim().replace(/\/+$/, '');
+    return trimmed.toLowerCase().endsWith('/mcp')
+        ? trimmed.slice(0, -4)
+        : trimmed;
+}
+//# sourceMappingURL=remote-transport.js.map