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

package/dist/core/providers/dynamic-provider.factory.js

@@ -1,645 +0,0 @@
-"use strict";
-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.BaseDynamicProviderFactory = void 0;
-const base_ai_provider_1 = require("./base-ai.provider");
-const ai_provider_interface_1 = require("./ai-provider.interface");
-const timeout_config_1 = require("../../config/timeout.config");
-const api_provider_types_1 = require("../../types/api-provider.types");
-class ConsoleLogger {
-    constructor(context) {
-        this.context = context;
-    }
-    log(message, ...optionalParams) {
-        if (process.env.CREWX_VERBOSE === '1') {
-            console.error(`[${this.context}]`, message, ...optionalParams);
-        }
-    }
-    warn(message, ...optionalParams) {
-        console.warn(`[${this.context}]`, message, ...optionalParams);
-    }
-    error(message, ...optionalParams) {
-        const resolved = message instanceof Error ? message.message : message;
-        console.error(`[${this.context}]`, resolved, ...optionalParams);
-    }
-}
-class BaseDynamicProviderFactory {
-    constructor(options = {}) {
-        this.timeoutConfig = (0, timeout_config_1.getTimeoutConfig)();
-        this.logger = options.logger ?? new ConsoleLogger('DynamicProviderFactory');
-        this.crewxVersion = options.crewxVersion ?? 'unknown';
-        this.taskLogHandler = options.taskLogHandler;
-    }
-    createProvider(config) {
-        const providerId = config.type === 'api' ? config.provider : config.id;
-        this.logger.log(`Creating dynamic provider: ${providerId}`);
-        if (config.type === 'plugin') {
-            return this.createPluginProvider(config);
-        }
-        if (config.type === 'remote') {
-            return this.createRemoteProvider(config);
-        }
-        if (config.type === 'api') {
-            return this.createAPIProvider(config);
-        }
-        throw new Error(`Unknown provider type: ${config.type}`);
-    }
-    validateConfig(config) {
-        if (!config || typeof config !== 'object') {
-            return false;
-        }
-        const base = config;
-        if (base.type === 'plugin') {
-            if (!base.id || typeof base.id !== 'string') {
-                return false;
-            }
-            return (typeof base.cli_command === 'string' &&
-                Array.isArray(base.query_args) &&
-                Array.isArray(base.execute_args) &&
-                typeof base.prompt_in_args === 'boolean');
-        }
-        if (base.type === 'remote') {
-            if (!base.id || typeof base.id !== 'string') {
-                return false;
-            }
-            return (typeof base.location === 'string' &&
-                typeof base.external_agent_id === 'string');
-        }
-        if (base.type === 'api') {
-            return (typeof base.provider === 'string' &&
-                api_provider_types_1.API_PROVIDER_TYPES.includes(base.provider) &&
-                typeof base.model === 'string');
-        }
-        return false;
-    }
-    createPluginProvider(config) {
-        this.validateCliCommand(config.cli_command);
-        this.validateCliArgs(config.query_args);
-        this.validateCliArgs(config.execute_args);
-        this.validateErrorPatterns(config.error_patterns);
-        this.validateEnv(config.env);
-        const factory = this;
-        class DynamicAIProvider extends base_ai_provider_1.BaseAIProvider {
-            constructor() {
-                super(`DynamicProvider:${ai_provider_interface_1.ProviderNamespace.PLUGIN}/${config.id}`, {
-                    crewxVersion: factory.crewxVersion,
-                    taskLogHandler: factory.taskLogHandler,
-                });
-                this.name = `${ai_provider_interface_1.ProviderNamespace.PLUGIN}/${config.id}`;
-            }
-            getCliCommand() {
-                return config.cli_command;
-            }
-            getDefaultArgs() {
-                return config.query_args || [];
-            }
-            getExecuteArgs() {
-                return config.execute_args || [];
-            }
-            getDefaultModel() {
-                return config.default_model || 'default';
-            }
-            getPromptInArgs() {
-                return config.prompt_in_args ?? false;
-            }
-            shouldPipeContext() {
-                if (this.getPromptInArgs()) {
-                    return false;
-                }
-                return super.shouldPipeContext();
-            }
-            getNotInstalledMessage() {
-                return (config.not_installed_message ||
-                    `${config.display_name || config.id} CLI is not installed.`);
-            }
-            getDefaultQueryTimeout() {
-                return config.timeout?.query ?? 600000;
-            }
-            getDefaultExecuteTimeout() {
-                return config.timeout?.execute ?? factory.timeoutConfig.parallel;
-            }
-            getEnv() {
-                return config.env || {};
-            }
-            async isAvailable() {
-                const cliCommand = this.getCliCommand();
-                if (cliCommand.includes('/') || cliCommand.includes('\\')) {
-                    try {
-                        const { access } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-                        const { constants } = await Promise.resolve().then(() => __importStar(require('fs')));
-                        const { resolve } = await Promise.resolve().then(() => __importStar(require('path')));
-                        const absolutePath = resolve(process.cwd(), cliCommand);
-                        await access(absolutePath, constants.X_OK);
-                        return true;
-                    }
-                    catch {
-                        return false;
-                    }
-                }
-                return super.isAvailable();
-            }
-            parseProviderError(stderr, stdout) {
-                if (!config.error_patterns) {
-                    return super.parseProviderError(stderr, stdout);
-                }
-                const combinedOutput = stderr || stdout;
-                for (const errorPattern of config.error_patterns) {
-                    if (combinedOutput.includes(errorPattern.pattern)) {
-                        return {
-                            error: true,
-                            message: errorPattern.message,
-                        };
-                    }
-                }
-                return super.parseProviderError(stderr, stdout);
-            }
-        }
-        return new DynamicAIProvider();
-    }
-    createRemoteProvider(config) {
-        this.logger.log(`Creating remote provider: ${config.id}`);
-        this.validateRemoteConfig(config);
-        const factory = this;
-        class RemoteAIProvider extends base_ai_provider_1.BaseAIProvider {
-            constructor() {
-                super(`RemoteProvider:${ai_provider_interface_1.ProviderNamespace.REMOTE}/${config.id}`, {
-                    crewxVersion: factory.crewxVersion,
-                    taskLogHandler: factory.taskLogHandler,
-                });
-                this.name = `${ai_provider_interface_1.ProviderNamespace.REMOTE}/${config.id}`;
-            }
-            getCliCommand() {
-                if (config.location.startsWith('file://')) {
-                    return 'crewx';
-                }
-                return 'curl';
-            }
-            getDefaultArgs() {
-                if (config.location.startsWith('file://')) {
-                    const configPath = config.location.replace('file://', '');
-                    return [
-                        'query',
-                        '--raw',
-                        `--config=${configPath}`,
-                    ];
-                }
-                const args = [
-                    '-X', 'POST',
-                    `${config.location}/mcp/query`,
-                    '-H', 'Content-Type: application/json',
-                ];
-                const authHeader = this.getAuthHeader();
-                if (authHeader) {
-                    args.push('-H', `Authorization: ${authHeader}`);
-                }
-                return args;
-            }
-            getExecuteArgs() {
-                if (config.location.startsWith('file://')) {
-                    const configPath = config.location.replace('file://', '');
-                    return [
-                        'execute',
-                        '--raw',
-                        `--config=${configPath}`,
-                    ];
-                }
-                const args = [
-                    '-X', 'POST',
-                    `${config.location}/mcp/execute`,
-                    '-H', 'Content-Type: application/json',
-                ];
-                const authHeader = this.getAuthHeader();
-                if (authHeader) {
-                    args.push('-H', `Authorization: ${authHeader}`);
-                }
-                return args;
-            }
-            getDefaultModel() {
-                return config.default_model || 'default';
-            }
-            getPromptInArgs() {
-                return true;
-            }
-            getNotInstalledMessage() {
-                if (config.location.startsWith('file://')) {
-                    const configPath = config.location.replace('file://', '');
-                    return `Remote CrewX configuration not found: ${configPath}`;
-                }
-                return `Remote CrewX server not accessible: ${config.location}`;
-            }
-            getDefaultQueryTimeout() {
-                return config.timeout?.query ?? 300000;
-            }
-            getDefaultExecuteTimeout() {
-                return config.timeout?.execute ?? 600000;
-            }
-            getAuthHeader() {
-                if (!config.auth || config.auth.type === 'none') {
-                    return '';
-                }
-                if (config.auth.type === 'bearer' && config.auth.token) {
-                    return `Bearer ${config.auth.token}`;
-                }
-                if (config.auth.type === 'api_key' && config.auth.token) {
-                    return `Api-Key ${config.auth.token}`;
-                }
-                return '';
-            }
-            getAuthHeaders() {
-                const headers = {};
-                if (!config.auth || config.auth.type === 'none') {
-                    return headers;
-                }
-                if (config.auth.token) {
-                    if (config.auth.type === 'bearer') {
-                        headers['Authorization'] = `Bearer ${config.auth.token}`;
-                    }
-                    else if (config.auth.type === 'api_key') {
-                        headers['Api-Key'] = config.auth.token;
-                    }
-                }
-                return headers;
-            }
-            async isAvailable() {
-                if (config.location.startsWith('file://')) {
-                    try {
-                        const { access } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-                        const { constants } = await Promise.resolve().then(() => __importStar(require('fs')));
-                        const configPath = config.location.replace('file://', '');
-                        await access(configPath, constants.R_OK);
-                        const cliAvailable = await super.isAvailable();
-                        return cliAvailable;
-                    }
-                    catch {
-                        return false;
-                    }
-                }
-                try {
-                    const controller = new AbortController();
-                    const timeoutId = setTimeout(() => controller.abort(), 5000);
-                    const healthHeaders = {
-                        ...(config.headers || {}),
-                        ...this.getAuthHeaders(),
-                    };
-                    const response = await fetch(`${config.location}/health`, {
-                        method: 'GET',
-                        signal: controller.signal,
-                        headers: healthHeaders,
-                    });
-                    clearTimeout(timeoutId);
-                    return response.ok;
-                }
-                catch {
-                    return false;
-                }
-            }
-            async query(prompt, options) {
-                if (config.location.startsWith('http')) {
-                    return this.httpQuery(prompt, options);
-                }
-                const validated = await this.ensureFileConfigExists(options);
-                if (!validated.ok) {
-                    return validated.response;
-                }
-                const userQuery = this.parseUserQueryForRemote(prompt);
-                const formattedPrompt = userQuery
-                    ? `@${config.external_agent_id} ${userQuery}`
-                    : `@${config.external_agent_id}`;
-                const structuredPayload = this.normalizeStructuredPayload(prompt, options);
-                const extendedOptions = {
-                    ...options,
-                };
-                if (structuredPayload) {
-                    extendedOptions.pipedContext = structuredPayload;
-                }
-                else {
-                    delete extendedOptions.pipedContext;
-                }
-                return super.query(formattedPrompt, extendedOptions);
-            }
-            async execute(prompt, options) {
-                if (config.location.startsWith('http')) {
-                    return super.execute(prompt, options);
-                }
-                const validated = await this.ensureFileConfigExists(options);
-                if (!validated.ok) {
-                    return validated.response;
-                }
-                const userQuery = this.parseUserQueryForRemote(prompt);
-                const formattedPrompt = userQuery
-                    ? `@${config.external_agent_id} ${userQuery}`
-                    : `@${config.external_agent_id}`;
-                const structuredPayload = this.normalizeStructuredPayload(prompt, options);
-                const extendedOptions = {
-                    ...options,
-                };
-                if (structuredPayload) {
-                    extendedOptions.pipedContext = structuredPayload;
-                }
-                else {
-                    delete extendedOptions.pipedContext;
-                }
-                return super.execute(formattedPrompt, extendedOptions);
-            }
-            async httpQuery(prompt, options) {
-                const requestBody = {
-                    prompt,
-                    agent_id: config.external_agent_id,
-                    task_id: options?.taskId,
-                    model: options?.model || this.getDefaultModel(),
-                    working_directory: options?.workingDirectory,
-                };
-                const structuredPayload = this.normalizeStructuredPayload(prompt, options);
-                if (structuredPayload) {
-                    requestBody.structured_payload = structuredPayload;
-                }
-                if (options?.messages && options.messages.length > 0) {
-                    requestBody.messages = options.messages;
-                }
-                if (options?.pipedContext) {
-                    const trimmed = options.pipedContext.trim();
-                    if (!this.isStructuredPayload(trimmed)) {
-                        requestBody.context = trimmed;
-                    }
-                }
-                try {
-                    const controller = new AbortController();
-                    const timeoutMs = options?.timeout || this.getDefaultQueryTimeout();
-                    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-                    const response = await fetch(`${config.location}/mcp/query`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            ...this.getAuthHeaders(),
-                            ...(config.headers || {}),
-                        },
-                        body: JSON.stringify(requestBody),
-                        signal: controller.signal,
-                    });
-                    clearTimeout(timeoutId);
-                    if (!response.ok) {
-                        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                    }
-                    const result = await response.json();
-                    return {
-                        content: result.content,
-                        provider: this.name,
-                        command: `remote query to ${config.location}`,
-                        success: result.success !== false,
-                        error: result.error,
-                        taskId: result.task_id,
-                        toolCall: result.tool_call,
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: '',
-                        provider: this.name,
-                        command: `remote query to ${config.location}`,
-                        success: false,
-                        error: error.message,
-                        taskId: options?.taskId,
-                    };
-                }
-            }
-            parseUserQueryForRemote(prompt) {
-                if (!prompt) {
-                    return '';
-                }
-                const match = prompt.match(/<user_query[^>]*>\s*([\s\S]*?)\s*<\/user_query>/i);
-                if (match && match[1]) {
-                    return match[1].trim();
-                }
-                return prompt.trim();
-            }
-            normalizeStructuredPayload(prompt, options) {
-                const existing = options?.pipedContext?.trim();
-                if (existing) {
-                    if (this.isStructuredPayload(existing)) {
-                        return existing;
-                    }
-                    return this.createStructuredPayload(prompt, existing, options);
-                }
-                if (options?.messages && options.messages.length > 0) {
-                    return this.createStructuredPayload(prompt, null, options);
-                }
-                return null;
-            }
-            async ensureFileConfigExists(options) {
-                if (!config.location.startsWith('file://')) {
-                    return { ok: true };
-                }
-                const configPath = config.location.replace('file://', '');
-                try {
-                    const { access } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-                    const { constants } = await Promise.resolve().then(() => __importStar(require('fs')));
-                    await access(configPath, constants.R_OK);
-                    return { ok: true };
-                }
-                catch {
-                    return {
-                        ok: false,
-                        response: {
-                            content: `Remote CrewX configuration not found: ${configPath}`,
-                            provider: this.name,
-                            command: `crewx --config=${configPath}`,
-                            success: false,
-                            error: `Remote CrewX configuration not found: ${configPath}`,
-                            taskId: options?.taskId,
-                        },
-                    };
-                }
-            }
-        }
-        return new RemoteAIProvider();
-    }
-    createAPIProvider(config) {
-        this.logger.log(`Creating API provider: ${config.provider}`);
-        this.validateAPIProviderConfig(config);
-        const factory = this;
-        class DynamicAPIProvider extends base_ai_provider_1.BaseAIProvider {
-            constructor() {
-                super(`APIProvider:${config.provider}`, {
-                    taskLogHandler: factory.taskLogHandler,
-                });
-                this.name = config.provider;
-            }
-            getCliCommand() {
-                return 'echo';
-            }
-            getDefaultArgs() {
-                return [];
-            }
-            getExecuteArgs() {
-                return [];
-            }
-            getDefaultModel() {
-                return config.model;
-            }
-            getPromptInArgs() {
-                return false;
-            }
-            getNotInstalledMessage() {
-                return `API provider ${config.provider} requires API key configuration`;
-            }
-            getDefaultQueryTimeout() {
-                return 60000;
-            }
-            getDefaultExecuteTimeout() {
-                return factory.timeoutConfig.parallel;
-            }
-            async isAvailable() {
-                return !!config.model;
-            }
-            async query(_prompt, options) {
-                factory.logger.warn(`API provider ${config.provider} query() called but not implemented. ` +
-                    'Extend this factory to provide actual API implementation.');
-                return {
-                    content: `[API Provider ${config.provider}] Implementation required. Model: ${config.model}`,
-                    provider: this.name,
-                    command: `API call to ${config.provider}`,
-                    success: false,
-                    error: 'API provider not implemented - extend BaseDynamicProviderFactory',
-                    taskId: options?.taskId,
-                };
-            }
-            async execute(_prompt, options) {
-                factory.logger.warn(`API provider ${config.provider} execute() called but not implemented. ` +
-                    'Extend this factory to provide actual API implementation.');
-                return {
-                    content: `[API Provider ${config.provider}] Implementation required. Model: ${config.model}`,
-                    provider: this.name,
-                    command: `API call to ${config.provider}`,
-                    success: false,
-                    error: 'API provider not implemented - extend BaseDynamicProviderFactory',
-                    taskId: options?.taskId,
-                };
-            }
-            getAPIConfig() {
-                return config;
-            }
-        }
-        return new DynamicAPIProvider();
-    }
-    validateAPIProviderConfig(config) {
-        if (!config.provider || typeof config.provider !== 'string') {
-            throw new Error('API provider requires a provider field (e.g., api/openai)');
-        }
-        if (!api_provider_types_1.API_PROVIDER_TYPES.includes(config.provider)) {
-            throw new Error(`Invalid API provider '${config.provider}'. Valid providers: ${api_provider_types_1.API_PROVIDER_TYPES.join(', ')}`);
-        }
-        if (!config.model || typeof config.model !== 'string') {
-            throw new Error('API provider requires a model field');
-        }
-        if (config.temperature !== undefined) {
-            if (typeof config.temperature !== 'number' || config.temperature < 0 || config.temperature > 2) {
-                throw new Error(`Temperature must be a number between 0 and 2, got: ${config.temperature}`);
-            }
-        }
-        if (config.maxTokens !== undefined) {
-            if (typeof config.maxTokens !== 'number' || config.maxTokens < 1 || !Number.isInteger(config.maxTokens)) {
-                throw new Error(`maxTokens must be a positive integer, got: ${config.maxTokens}`);
-            }
-        }
-    }
-    validateCliCommand(cliCommand) {
-        if (!cliCommand || typeof cliCommand !== 'string') {
-            throw new Error('Plugin provider requires a CLI command');
-        }
-    }
-    validateCliArgs(args) {
-        if (!Array.isArray(args)) {
-            throw new Error('CLI arguments must be an array');
-        }
-        for (const arg of args) {
-            if (typeof arg !== 'string') {
-                throw new Error('CLI argument must be a string');
-            }
-        }
-    }
-    validateErrorPatterns(patterns) {
-        if (!patterns) {
-            return;
-        }
-        for (const { pattern } of patterns) {
-            try {
-                new RegExp(pattern);
-            }
-            catch (error) {
-                throw new Error(`Invalid regex pattern '${pattern}': ${error.message}`);
-            }
-        }
-    }
-    validateEnv(env) {
-        if (!env) {
-            return;
-        }
-        for (const [key, value] of Object.entries(env)) {
-            if (typeof key !== 'string' || typeof value !== 'string') {
-                throw new Error('Environment variables must be string key/value pairs');
-            }
-        }
-    }
-    validateRemoteConfig(config) {
-        if (!config.location) {
-            throw new Error('Remote provider requires a location (file:// or http(s):// URL)');
-        }
-        if (!config.external_agent_id) {
-            throw new Error('Remote provider requires an external_agent_id');
-        }
-        if (!config.location.startsWith('file://') &&
-            !config.location.startsWith('http://') &&
-            !config.location.startsWith('https://')) {
-            throw new Error('Remote location must start with file://, http://, or https://');
-        }
-        if (config.location.startsWith('file://')) {
-            const filePath = config.location.replace('file://', '');
-            if (filePath.includes('..')) {
-                throw new Error('Path traversal (..) is not allowed in remote file locations');
-            }
-        }
-        if (config.auth) {
-            const validAuthTypes = ['bearer', 'api_key', 'none'];
-            if (!validAuthTypes.includes(config.auth.type)) {
-                throw new Error(`Invalid auth type: ${config.auth.type}. Must be one of: ${validAuthTypes.join(', ')}`);
-            }
-            if (config.auth.type !== 'none' && !config.auth.token) {
-                throw new Error(`Auth type '${config.auth.type}' requires a token`);
-            }
-        }
-    }
-}
-exports.BaseDynamicProviderFactory = BaseDynamicProviderFactory;
-//# sourceMappingURL=dynamic-provider.factory.js.map