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

package/dist/esm/provider/vercel-runtime.js

@@ -0,0 +1,310 @@
+/**
+ * VercelProviderRuntime — API 프로바이더를 위한 ProviderRuntime 구현.
+ *
+ * Vercel AI SDK의 generateText() + tool()을 직접 사용하여 tool calling loop를 처리한다.
+ * @ai-sdk/* 기반 모델 인스턴스를 생성하여 OpenRouter, OpenAI, Anthropic, Google 지원.
+ */
+import { ProviderError, ClientToolCallRequiredError } from './bridge';
+const DEFAULT_MAX_STEPS = 10;
+const MAX_STEPS_LIMIT = 50;
+export class VercelProviderRuntime {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async query(message, options) {
+        return this._run(message, 'query', options);
+    }
+    async execute(message, options) {
+        return this._run(message, 'execute', options);
+    }
+    async _run(message, _mode, options) {
+        const { generateText, tool } = await import('ai');
+        // 1. Vercel AI SDK tools 변환
+        const vercelTools = this.convertTools(options?.tools ?? [], tool);
+        // 2. Model 인스턴스 생성 (Vercel AI SDK)
+        const model = this.createModel(options?.model);
+        // 3. maxSteps 계산
+        const maxSteps = Math.min(options?.maxSteps ?? this.config.maxSteps ?? DEFAULT_MAX_STEPS, MAX_STEPS_LIMIT);
+        try {
+            // 4. generateText() — tool loop 자동 실행
+            let stepIndex = 0;
+            const result = await generateText({
+                model,
+                system: options?.systemPrompt ?? undefined,
+                prompt: message,
+                tools: vercelTools,
+                maxSteps,
+                ...(this.config.temperature !== undefined && { temperature: this.config.temperature }),
+                ...(this.config.maxTokens !== undefined && { maxTokens: this.config.maxTokens }),
+                onStepFinish: (event) => {
+                    stepIndex++;
+                    if (!options?.onOutput)
+                        return;
+                    // tool call 기록 — Claude stream-json 호환 포맷
+                    if (event.toolCalls && event.toolCalls.length > 0) {
+                        for (const tc of event.toolCalls) {
+                            options.onOutput(JSON.stringify({
+                                type: 'assistant',
+                                message: {
+                                    content: [{ type: 'tool_use', id: tc.toolCallId, name: tc.toolName, input: tc.args }],
+                                },
+                            }), 'stdout');
+                        }
+                    }
+                    // tool result 기록 — Claude stream-json 호환 포맷
+                    if (event.toolResults && event.toolResults.length > 0) {
+                        for (const tr of event.toolResults) {
+                            const output = typeof tr.result === 'string'
+                                ? tr.result
+                                : JSON.stringify(tr.result);
+                            options.onOutput(JSON.stringify({
+                                type: 'user',
+                                message: {
+                                    content: [{ type: 'tool_result', tool_use_id: tr.toolCallId, output, is_error: false }],
+                                },
+                            }), 'stdout');
+                        }
+                    }
+                },
+            });
+            // 5. Client tool detection — if generateText stopped because of a tool without execute
+            const clientToolNames = new Set((options?.tools ?? []).filter(t => !t.execute).map(t => t.name));
+            if (result.finishReason === 'tool-calls' &&
+                Array.isArray(result.toolCalls) &&
+                result.toolCalls.length > 0) {
+                const pendingCalls = result.toolCalls
+                    .filter(tc => clientToolNames.has(tc.toolName));
+                if (pendingCalls.length > 0) {
+                    const tc = pendingCalls[0];
+                    throw new ClientToolCallRequiredError({ toolCallId: tc.toolCallId, toolName: tc.toolName, args: tc.args }, {
+                        userMessage: message,
+                        responseMessages: result.response?.messages ?? [],
+                        toolDefinitions: options?.tools ?? [],
+                        maxSteps,
+                        systemPrompt: options?.systemPrompt,
+                        modelOverride: options?.model,
+                    });
+                }
+            }
+            // 6. Usage 콜백
+            if (options?.onUsage && result.usage) {
+                const usage = {
+                    inputTokens: result.usage.promptTokens ?? 0,
+                    outputTokens: result.usage.completionTokens ?? 0,
+                    cachedInputTokens: 0,
+                    costUsd: 0,
+                };
+                options.onUsage(usage);
+            }
+            // 7. Model 콜백
+            if (options?.onModel) {
+                options.onModel(options.model ?? this.config.model);
+            }
+            return result.text ?? '';
+        }
+        catch (error) {
+            // Re-throw ClientToolCallRequiredError as-is (not a provider error)
+            if (error instanceof ClientToolCallRequiredError)
+                throw error;
+            if (error.status === 401) {
+                throw new ProviderError(`Authentication failed for ${this.config.provider}. Check your API key.`, this.config.provider);
+            }
+            if (error.status === 429) {
+                throw new ProviderError(`Rate limit exceeded for ${this.config.provider}.`, this.config.provider);
+            }
+            throw new ProviderError(`Provider error: ${error.message}`, this.config.provider);
+        }
+    }
+    /**
+     * Resume a conversation after client-side tool results are provided.
+     * Reconstructs the message history and calls generateText() again.
+     */
+    async continueWithToolResults(state, toolResults, options) {
+        const { generateText, tool: toolFn } = await import('ai');
+        const vercelTools = this.convertTools(state.toolDefinitions, toolFn);
+        const model = this.createModel(state.modelOverride);
+        const maxSteps = Math.min(state.maxSteps ?? this.config.maxSteps ?? DEFAULT_MAX_STEPS, MAX_STEPS_LIMIT);
+        // Build messages: original user message + previous response + new tool results
+        const messages = [
+            { role: 'user', content: state.userMessage },
+            ...state.responseMessages,
+            {
+                role: 'tool',
+                content: toolResults.map(tr => ({
+                    type: 'tool-result',
+                    toolCallId: tr.toolCallId,
+                    toolName: tr.toolName,
+                    result: typeof tr.result === 'string' ? tr.result : JSON.stringify(tr.result),
+                })),
+            },
+        ];
+        try {
+            const result = await generateText({
+                model,
+                system: state.systemPrompt ?? undefined,
+                messages: messages,
+                tools: vercelTools,
+                maxSteps,
+                ...(this.config.temperature !== undefined && { temperature: this.config.temperature }),
+                ...(this.config.maxTokens !== undefined && { maxTokens: this.config.maxTokens }),
+            });
+            // Check again for client tool calls
+            const clientToolNames = new Set(state.toolDefinitions.filter(t => !t.execute).map(t => t.name));
+            if (result.finishReason === 'tool-calls' &&
+                Array.isArray(result.toolCalls) &&
+                result.toolCalls.length > 0) {
+                const pendingCalls = result.toolCalls
+                    .filter(tc => clientToolNames.has(tc.toolName));
+                if (pendingCalls.length > 0) {
+                    const tc = pendingCalls[0];
+                    // Update continuation state with new messages
+                    throw new ClientToolCallRequiredError({ toolCallId: tc.toolCallId, toolName: tc.toolName, args: tc.args }, {
+                        userMessage: state.userMessage,
+                        responseMessages: [
+                            ...state.responseMessages,
+                            {
+                                role: 'tool',
+                                content: toolResults.map(tr => ({
+                                    type: 'tool-result',
+                                    toolCallId: tr.toolCallId,
+                                    toolName: tr.toolName,
+                                    result: typeof tr.result === 'string' ? tr.result : JSON.stringify(tr.result),
+                                })),
+                            },
+                            ...(result.response?.messages ?? []),
+                        ],
+                        toolDefinitions: state.toolDefinitions,
+                        maxSteps: state.maxSteps,
+                        systemPrompt: state.systemPrompt,
+                        modelOverride: state.modelOverride,
+                    });
+                }
+            }
+            // Usage/model callbacks
+            if (options?.onUsage && result.usage) {
+                options.onUsage({
+                    inputTokens: result.usage.promptTokens ?? 0,
+                    outputTokens: result.usage.completionTokens ?? 0,
+                    cachedInputTokens: 0,
+                    costUsd: 0,
+                });
+            }
+            if (options?.onModel) {
+                options.onModel(state.modelOverride ?? this.config.model);
+            }
+            return result.text ?? '';
+        }
+        catch (error) {
+            if (error instanceof ClientToolCallRequiredError)
+                throw error;
+            throw new ProviderError(`Provider error: ${error.message}`, this.config.provider);
+        }
+    }
+    /**
+     * CrewX ToolDefinition[] → Vercel AI SDK tool Record 변환.
+     * execute가 없는 tool은 client tool로 처리 (Vercel AI SDK 네이티브 지원).
+     */
+    convertTools(tools, toolFn) {
+        const { z } = require('zod');
+        const vercelTools = {};
+        for (const td of tools) {
+            const parameters = this.jsonSchemaToZod(td.parameters ?? {}, z);
+            if (td.execute) {
+                // Server tool — execute 함수 있음
+                vercelTools[td.name] = toolFn({
+                    description: td.description,
+                    parameters,
+                    execute: async (args) => {
+                        return td.execute(args);
+                    },
+                });
+            }
+            else {
+                // Client tool — execute 없음 (Vercel AI SDK가 tool_result를 기다림)
+                vercelTools[td.name] = toolFn({
+                    description: td.description,
+                    parameters,
+                });
+            }
+        }
+        return vercelTools;
+    }
+    /**
+     * JSON Schema → Zod 간이 변환.
+     */
+    jsonSchemaToZod(schema, z) {
+        if (!schema || !schema.properties)
+            return z.object({});
+        const shape = {};
+        const props = schema.properties;
+        const required = schema.required ?? [];
+        for (const [key, prop] of Object.entries(props)) {
+            let field;
+            switch (prop.type) {
+                case 'string':
+                    field = z.string();
+                    break;
+                case 'number':
+                    field = z.number();
+                    break;
+                case 'integer':
+                    field = z.number().int();
+                    break;
+                case 'boolean':
+                    field = z.boolean();
+                    break;
+                case 'array':
+                    field = z.array(z.any());
+                    break;
+                default: field = z.any();
+            }
+            if (prop.description)
+                field = field.describe(prop.description);
+            if (!required.includes(key))
+                field = field.optional();
+            shape[key] = field;
+        }
+        return z.object(shape);
+    }
+    /**
+     * Vercel AI SDK model 인스턴스 생성.
+     * provider string에 따라 적절한 SDK 팩토리 사용.
+     */
+    createModel(modelOverride) {
+        const { provider, apiKey, baseURL } = this.config;
+        const model = modelOverride || this.config.model;
+        switch (provider) {
+            case 'api/openrouter': {
+                const { createOpenAI } = require('@ai-sdk/openai');
+                return createOpenAI({
+                    apiKey: apiKey || process.env.OPENROUTER_API_KEY,
+                    baseURL: baseURL || 'https://openrouter.ai/api/v1',
+                })(model);
+            }
+            case 'api/openai': {
+                const { createOpenAI } = require('@ai-sdk/openai');
+                return createOpenAI({
+                    apiKey: apiKey || process.env.OPENAI_API_KEY,
+                    ...(baseURL && { baseURL }),
+                })(model);
+            }
+            case 'api/anthropic': {
+                const { createAnthropic } = require('@ai-sdk/anthropic');
+                return createAnthropic({
+                    apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
+                    ...(baseURL && { baseURL }),
+                })(model);
+            }
+            case 'api/google': {
+                const { createGoogleGenerativeAI } = require('@ai-sdk/google');
+                return createGoogleGenerativeAI({
+                    apiKey: apiKey || process.env.GOOGLE_API_KEY,
+                })(model);
+            }
+            default:
+                throw new ProviderError(`Unsupported API provider: ${provider}`, provider);
+        }
+    }
+}
+//# sourceMappingURL=vercel-runtime.js.map

package/dist/esm/remote/index.js

@@ -0,0 +1,10 @@
+/**
+ * Remote Agent Module
+ *
+ * SDK core module for remote agent communication via MCP protocol.
+ */
+export * from './types.js';
+export { McpHttpTransport } from './remote-transport.js';
+export { RemoteAgentManager } from './remote-agent-manager.js';
+export { RemoteProviderRuntime, createRemoteProviderFactory } from './remote-provider.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/remote/remote-agent-manager.js

@@ -0,0 +1,194 @@
+/**
+ * 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.
+ */
+import { McpHttpTransport } from './remote-transport.js';
+/**
+ * Remote Agent Manager
+ *
+ * Manages communication with remote MCP agents.
+ * Each loaded agent config creates its own transport instance.
+ */
+export class RemoteAgentManager {
+    logger;
+    configs = new Map();
+    transports = new Map();
+    constructor(options = {}) {
+        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 McpHttpTransport({
+            url: config.url,
+            apiKey: config.apiKey,
+            headers: config.headers,
+            timeoutMs: config.timeoutMs,
+        }));
+        this.logger(`Loaded remote agent config for: ${agentId}`, 'debug');
+    }
+    /**
+     * 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.requireConfig(agentId);
+        const toolName = config.tools?.query ?? 'crewx_queryAgent';
+        const remoteAgentId = config.agentId ?? agentId;
+        const payload = {
+            agentId: remoteAgentId,
+            query: request.query,
+        };
+        if (request.context)
+            payload.context = request.context;
+        if (request.model)
+            payload.model = request.model;
+        if (request.platform)
+            payload.platform = request.platform;
+        if (request.messages?.length)
+            payload.messages = request.messages;
+        try {
+            const result = await this.callRemoteTool(agentId, toolName, payload);
+            return this.normalizeResponse(result);
+        }
+        catch (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.requireConfig(agentId);
+        const toolName = config.tools?.execute ?? 'crewx_executeAgent';
+        const remoteAgentId = config.agentId ?? agentId;
+        const payload = {
+            agentId: remoteAgentId,
+            task: request.task,
+        };
+        if (request.context)
+            payload.context = request.context;
+        if (request.model)
+            payload.model = request.model;
+        if (request.platform)
+            payload.platform = request.platform;
+        if (request.messages?.length)
+            payload.messages = request.messages;
+        try {
+            const result = await this.callRemoteTool(agentId, toolName, payload);
+            return this.normalizeResponse(result);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger(`Remote execute failed for agent ${agentId}: ${msg}`, 'error');
+            throw error;
+        }
+    }
+    /** 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()}`,
+            method: 'tools/call',
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+        };
+        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.' }],
+            };
+        }
+        const obj = result;
+        // Already has content array — return as-is
+        if (Array.isArray(obj.content) && obj.content.length > 0) {
+            return obj;
+        }
+        // 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 {
+            ...obj,
+            content: [{ type: 'text', text }],
+        };
+    }
+    validateConfig(config) {
+        if (!config.url) {
+            throw new Error('Remote agent configuration requires a URL');
+        }
+        if (!config.url.startsWith('http://') && !config.url.startsWith('https://')) {
+            throw new Error('Remote agent URL must start with http:// or https://');
+        }
+        if (config.type !== 'mcp-http') {
+            throw new Error(`Unsupported remote agent type: ${config.type}`);
+        }
+    }
+}
+//# sourceMappingURL=remote-agent-manager.js.map

package/dist/esm/remote/remote-provider.js

@@ -0,0 +1,98 @@
+/**
+ * Remote Provider Runtime
+ *
+ * Implements ProviderRuntime for remote agents.
+ * Bridges crewx.yaml remote provider config → RemoteAgentManager → MCP-HTTP transport.
+ */
+import { RemoteAgentManager } from './remote-agent-manager.js';
+/**
+ * ProviderRuntime implementation for remote agents.
+ *
+ * Created by the `remote` namespace factory when `createProvider('remote/remote_cto')` is called.
+ * Wraps RemoteAgentManager to translate ProviderRuntime.query/execute into MCP-HTTP calls.
+ */
+export class RemoteProviderRuntime {
+    manager;
+    agentId;
+    constructor(remoteId, providerConfig) {
+        this.agentId = providerConfig.external_agent_id ?? remoteId;
+        this.manager = new 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');
+    }
+}
+// ── Factory ─────────────────────────────────────────────────────────────────
+/**
+ * Create a provider factory function for the `remote` namespace.
+ *
+ * @param remoteConfigs - Map of remote provider ID → config (from crewx.yaml `providers:` section)
+ * @returns ProviderFactory function to register via registerProviderFactory('remote', factory)
+ */
+export function createRemoteProviderFactory(remoteConfigs) {
+    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)'}`);
+        }
+        return new RemoteProviderRuntime(id, config);
+    };
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Convert crewx.yaml RemoteProviderConfig to SDK-internal RemoteAgentConfig.
+ */
+function toRemoteAgentConfig(remoteId, config) {
+    const url = resolveLocation(config.location);
+    return {
+        type: 'mcp-http',
+        url,
+        apiKey: config.apiKey,
+        headers: config.headers,
+        timeoutMs: config.timeout?.query ?? 30000,
+        agentId: config.external_agent_id ?? remoteId,
+    };
+}
+/**
+ * Resolve a `location` field to an MCP-HTTP URL.
+ *
+ * - `http://` / `https://` → used directly as MCP endpoint.
+ * - `file://` → not a network endpoint; the MCP server must be started separately.
+ *   Falls back to a conventional localhost URL for the workspace.
+ */
+function resolveLocation(location) {
+    if (!location) {
+        throw new Error('Remote provider config requires a location');
+    }
+    // Direct HTTP(S) endpoint
+    if (location.startsWith('http://') || location.startsWith('https://')) {
+        return location;
+    }
+    // file:// protocol — remote workspace reference.
+    // The MCP server for this workspace needs to be running.
+    // We derive a conventional localhost endpoint; the actual call may fail,
+    // which is acceptable (connection failure ≠ provider namespace error).
+    if (location.startsWith('file://')) {
+        // Convention: workspace MCP server at http://localhost:3030
+        return `http://localhost:3030`;
+    }
+    throw new Error(`Unsupported remote location protocol: ${location}`);
+}
+//# sourceMappingURL=remote-provider.js.map

package/dist/esm/remote/remote-transport.js

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ */
+/**
+ * MCP-HTTP transport — sends JSON-RPC 2.0 requests over HTTP POST.
+ *
+ * Endpoint: `${baseUrl}/mcp`
+ */
+export 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.
+    }
+}
+// ── 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