@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.75

package/dist/provider/parse-usage.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Pure function to extract token usage from provider CLI stdout.
+ * Supports Claude / Codex / Gemini / Copilot / OpenCode JSONL formats.
+ * Uses last-match semantics: if multiple usage events are found, the last one wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUsage = parseUsage;
+function extractFromFlat(obj) {
+    // Pattern: { type: "usage", input_tokens, output_tokens, [cache_read_input_tokens], [cached_input_tokens] }
+    if (obj['type'] !== 'usage' || !('input_tokens' in obj))
+        return null;
+    const inputRaw = Number(obj['input_tokens'] ?? 0);
+    const outputTokens = Number(obj['output_tokens'] ?? 0);
+    // cache_read_input_tokens takes precedence over cached_input_tokens
+    const hasCacheRead = 'cache_read_input_tokens' in obj;
+    const cacheRead = hasCacheRead ? Number(obj['cache_read_input_tokens']) : undefined;
+    const cachedInput = 'cached_input_tokens' in obj ? Number(obj['cached_input_tokens']) : undefined;
+    const cachedInputTokens = cacheRead !== undefined ? cacheRead : (cachedInput ?? 0);
+    // For cache_read_input_tokens: normalize — input_tokens represents fresh-only, total = input + cache_read
+    const inputTokens = cacheRead !== undefined ? inputRaw + cacheRead : inputRaw;
+    return { inputTokens, outputTokens, cachedInputTokens };
+}
+function extractFromNested(obj) {
+    // Pattern: { usage: { input_tokens, output_tokens, [cache_read_input_tokens], [cached_input_tokens] } }
+    const usageRaw = obj['usage'];
+    if (!usageRaw || typeof usageRaw !== 'object' || Array.isArray(usageRaw))
+        return null;
+    const usage = usageRaw;
+    if (!('input_tokens' in usage))
+        return null;
+    const inputRaw = Number(usage['input_tokens'] ?? 0);
+    const outputTokens = Number(usage['output_tokens'] ?? 0);
+    const hasCacheRead = 'cache_read_input_tokens' in usage;
+    const cacheRead = hasCacheRead ? Number(usage['cache_read_input_tokens']) : undefined;
+    const cachedInput = 'cached_input_tokens' in usage ? Number(usage['cached_input_tokens']) : undefined;
+    const cachedInputTokens = cacheRead !== undefined ? cacheRead : (cachedInput ?? 0);
+    const inputTokens = cacheRead !== undefined ? inputRaw + cacheRead : inputRaw;
+    return { inputTokens, outputTokens, cachedInputTokens };
+}
+function extractFromOpencode(obj) {
+    // Pattern: { type: "step_finish", part: { tokens: { input, output, cache: { read, write } } } }
+    if (obj['type'] !== 'step_finish')
+        return null;
+    const part = obj['part'];
+    const tokens = part?.['tokens'];
+    if (!tokens)
+        return null;
+    const inputRaw = Number(tokens['input'] ?? 0);
+    const outputTokens = Number(tokens['output'] ?? 0);
+    const cache = tokens['cache'];
+    const cacheRead = cache ? Number(cache['read'] ?? 0) : 0;
+    // normalize: cached tokens are included in input total (same as claude cache_read handling)
+    const inputTokens = inputRaw + cacheRead;
+    return { inputTokens, outputTokens, cachedInputTokens: cacheRead };
+}
+/**
+ * Parse token usage from a provider CLI stdout string.
+ *
+ * Accepts JSONL (one JSON object per line) or a single JSON document.
+ * Returns the **last** usage found (last-match semantics).
+ * Returns `undefined` if no usage data is present.
+ */
+function parseUsage(stdout) {
+    if (!stdout || !stdout.trim())
+        return undefined;
+    let last = null;
+    for (const line of stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            const result = extractFromFlat(obj) ?? extractFromNested(obj) ?? extractFromOpencode(obj);
+            if (result)
+                last = result;
+        }
+        catch {
+            // non-JSON line — skip
+        }
+    }
+    return last ?? undefined;
+}
+//# sourceMappingURL=parse-usage.js.map

package/dist/provider/register-api.d.ts

@@ -0,0 +1,14 @@
+/**
+ * api/* namespace를 provider registry에 등록.
+ *
+ * crewx.yaml에서 provider: api/openrouter 등을 쓰면
+ * createProvider('api/openrouter') → VercelProviderRuntime 반환.
+ */
+export declare function registerApiProviders(globalConfig?: {
+    apiKeys?: Record<string, string>;
+    defaults?: {
+        maxSteps?: number;
+        temperature?: number;
+    };
+}): void;
+//# sourceMappingURL=register-api.d.ts.map

package/dist/provider/register-api.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * api/* namespace를 provider registry에 등록.
+ *
+ * crewx.yaml에서 provider: api/openrouter 등을 쓰면
+ * createProvider('api/openrouter') → VercelProviderRuntime 반환.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerApiProviders = registerApiProviders;
+const bridge_1 = require("./bridge");
+const vercel_runtime_1 = require("./vercel-runtime");
+function registerApiProviders(globalConfig) {
+    (0, bridge_1.registerProviderFactory)('api', (id, providerStr) => {
+        const apiKey = globalConfig?.apiKeys?.[id];
+        return new vercel_runtime_1.VercelProviderRuntime({
+            provider: providerStr,
+            model: '', // query() 호출 시 options.model로 override
+            apiKey,
+            maxSteps: globalConfig?.defaults?.maxSteps,
+            temperature: globalConfig?.defaults?.temperature,
+        });
+    });
+}
+//# sourceMappingURL=register-api.js.map

package/dist/provider/vercel-runtime.d.ts

@@ -0,0 +1,54 @@
+/**
+ * VercelProviderRuntime — API 프로바이더를 위한 ProviderRuntime 구현.
+ *
+ * Vercel AI SDK의 generateText() + tool()을 직접 사용하여 tool calling loop를 처리한다.
+ * @ai-sdk/* 기반 모델 인스턴스를 생성하여 OpenRouter, OpenAI, Anthropic, Google 지원.
+ */
+import type { ProviderRuntime, ProviderQueryOptions, ContinuationState } from './bridge';
+export interface VercelProviderConfig {
+    /** Provider string (e.g. 'api/openrouter', 'api/anthropic'). */
+    provider: string;
+    /** Model identifier (e.g. 'anthropic/claude-sonnet-4-20250514'). */
+    model: string;
+    /** API key — falls back to environment variable if not set. */
+    apiKey?: string;
+    /** Custom base URL (e.g. OpenRouter endpoint). */
+    baseURL?: string;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Max output tokens. */
+    maxTokens?: number;
+    /** Default max steps for tool loop. */
+    maxSteps?: number;
+}
+export declare class VercelProviderRuntime implements ProviderRuntime {
+    private config;
+    constructor(config: VercelProviderConfig);
+    query(message: string, options?: ProviderQueryOptions): Promise<string>;
+    execute(message: string, options?: ProviderQueryOptions): Promise<string>;
+    private _run;
+    /**
+     * Resume a conversation after client-side tool results are provided.
+     * Reconstructs the message history and calls generateText() again.
+     */
+    continueWithToolResults(state: ContinuationState, toolResults: Array<{
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    }>, options?: ProviderQueryOptions): Promise<string>;
+    /**
+     * CrewX ToolDefinition[] → Vercel AI SDK tool Record 변환.
+     * execute가 없는 tool은 client tool로 처리 (Vercel AI SDK 네이티브 지원).
+     */
+    private convertTools;
+    /**
+     * JSON Schema → Zod 간이 변환.
+     */
+    private jsonSchemaToZod;
+    /**
+     * Vercel AI SDK model 인스턴스 생성.
+     * provider string에 따라 적절한 SDK 팩토리 사용.
+     */
+    private createModel;
+}
+//# sourceMappingURL=vercel-runtime.d.ts.map

package/dist/provider/vercel-runtime.js

@@ -0,0 +1,347 @@
+"use strict";
+/**
+ * VercelProviderRuntime — API 프로바이더를 위한 ProviderRuntime 구현.
+ *
+ * Vercel AI SDK의 generateText() + tool()을 직접 사용하여 tool calling loop를 처리한다.
+ * @ai-sdk/* 기반 모델 인스턴스를 생성하여 OpenRouter, OpenAI, Anthropic, Google 지원.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelProviderRuntime = void 0;
+const bridge_1 = require("./bridge");
+const DEFAULT_MAX_STEPS = 10;
+const MAX_STEPS_LIMIT = 50;
+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 Promise.resolve().then(() => __importStar(require('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 bridge_1.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 bridge_1.ClientToolCallRequiredError)
+                throw error;
+            if (error.status === 401) {
+                throw new bridge_1.ProviderError(`Authentication failed for ${this.config.provider}. Check your API key.`, this.config.provider);
+            }
+            if (error.status === 429) {
+                throw new bridge_1.ProviderError(`Rate limit exceeded for ${this.config.provider}.`, this.config.provider);
+            }
+            throw new bridge_1.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 Promise.resolve().then(() => __importStar(require('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 bridge_1.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 bridge_1.ClientToolCallRequiredError)
+                throw error;
+            throw new bridge_1.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 bridge_1.ProviderError(`Unsupported API provider: ${provider}`, provider);
+        }
+    }
+}
+exports.VercelProviderRuntime = VercelProviderRuntime;
+//# sourceMappingURL=vercel-runtime.js.map

package/dist/remote/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Remote Agent Module
+ *
+ * SDK core module for remote agent communication via MCP protocol.
+ */
+export * from './types.js';
+export { McpHttpTransport } from './remote-transport.js';
+export type { McpHttpTransportOptions } from './remote-transport.js';
+export { RemoteAgentManager } from './remote-agent-manager.js';
+export type { RemoteAgentManagerOptions } from './remote-agent-manager.js';
+export { RemoteProviderRuntime, createRemoteProviderFactory, resolveFileRemoteAgent } from './remote-provider.js';
+export type { ProviderFactoryFn, FileRemoteResolution, FileRemoteResolver } from './remote-provider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/remote/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Remote Agent Module
+ *
+ * SDK core module for remote agent communication via MCP protocol.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFileRemoteAgent = exports.createRemoteProviderFactory = exports.RemoteProviderRuntime = exports.RemoteAgentManager = exports.McpHttpTransport = void 0;
+__exportStar(require("./types.js"), exports);
+var remote_transport_js_1 = require("./remote-transport.js");
+Object.defineProperty(exports, "McpHttpTransport", { enumerable: true, get: function () { return remote_transport_js_1.McpHttpTransport; } });
+var remote_agent_manager_js_1 = require("./remote-agent-manager.js");
+Object.defineProperty(exports, "RemoteAgentManager", { enumerable: true, get: function () { return remote_agent_manager_js_1.RemoteAgentManager; } });
+var remote_provider_js_1 = require("./remote-provider.js");
+Object.defineProperty(exports, "RemoteProviderRuntime", { enumerable: true, get: function () { return remote_provider_js_1.RemoteProviderRuntime; } });
+Object.defineProperty(exports, "createRemoteProviderFactory", { enumerable: true, get: function () { return remote_provider_js_1.createRemoteProviderFactory; } });
+Object.defineProperty(exports, "resolveFileRemoteAgent", { enumerable: true, get: function () { return remote_provider_js_1.resolveFileRemoteAgent; } });
+//# sourceMappingURL=index.js.map

package/dist/remote/remote-agent-manager.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 type { RemoteAgentConfig, RemoteTransport, RemoteAgentQueryRequest, RemoteAgentExecuteRequest, RemoteAgentResponse, ToolNameMapping } from './types.js';
+/** Options for creating a RemoteAgentManager. */
+export interface RemoteAgentManagerOptions {
+    /** Optional logger function. */
+    logger?: (message: string, level?: 'debug' | 'info' | 'warn' | 'error') => void;
+}
+/**
+ * Remote Agent Manager
+ *
+ * Manages communication with remote MCP agents.
+ * Each loaded agent config creates its own transport instance.
+ */
+export declare class RemoteAgentManager {
+    private readonly logger;
+    private readonly configs;
+    private readonly transports;
+    constructor(options?: RemoteAgentManagerOptions);
+    /**
+     * Load configuration for a remote agent.
+     * Creates a transport instance for the agent.
+     */
+    loadConfig(agentId: string, config: RemoteAgentConfig): void;
+    /**
+     * Load configuration with a custom transport (e.g. for testing).
+     */
+    loadConfigWithTransport(agentId: string, config: RemoteAgentConfig, transport: RemoteTransport): void;
+    /** Get configuration for a remote agent. */
+    getConfig(agentId: string): RemoteAgentConfig | undefined;
+    /** Check if an agent is configured as remote. */
+    isRemoteAgent(agentId: string): boolean;
+    /** Get all configured remote agent IDs. */
+    getRemoteAgentIds(): string[];
+    /** Query a remote agent. */
+    query(agentId: string, request: RemoteAgentQueryRequest): Promise<RemoteAgentResponse>;
+    /** Execute a task on a remote agent. */
+    execute(agentId: string, request: RemoteAgentExecuteRequest): Promise<RemoteAgentResponse>;
+    /** Map tool names for a remote agent. */
+    mapToolNames(agentId: string, mapping: Partial<ToolNameMapping>): void;
+    /** Clear all configurations and close transports. */
+    clearConfigs(): Promise<void>;
+    private requireConfig;
+    private callRemoteTool;
+    /** Normalize remote agent response to consistent format. */
+    normalizeResponse(result: unknown): RemoteAgentResponse;
+    private validateConfig;
+}
+//# sourceMappingURL=remote-agent-manager.d.ts.map