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

package/dist/core/providers/base-ai.provider.js

@@ -1,1237 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseAIProvider = exports.ConsoleLogger = void 0;
-exports.resolveCallerAgentId = resolveCallerAgentId;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const timeout_config_1 = require("../../config/timeout.config");
-const log_config_1 = require("../../config/log.config");
-const parsers_1 = require("../../parsers");
-const id_1 = require("../../core/id");
-function resolveCallerAgentId(agentId) {
-    return agentId
-        || process.env.CREWX_CALLER_AGENT_ID
-        || (process.env.CLAUDECODE === '1' ? 'claude-code' : '')
-        || (process.env.CODEX_CI === '1' ? 'codex' : '');
-}
-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);
-    }
-}
-exports.ConsoleLogger = ConsoleLogger;
-class BaseAIProvider {
-    constructor(loggerContext, options = {}) {
-        this.cachedPath = null;
-        this.logger = options.logger ?? new ConsoleLogger(loggerContext);
-        this.toolCallHandler = options.toolCallHandler;
-        this.timeoutConfig = options.timeoutConfig ?? (0, timeout_config_1.getTimeoutConfig)();
-        this.logConfig = options.logConfig ?? (0, log_config_1.getLogConfig)();
-        this.logsDir = options.logsDir ?? (0, path_1.join)(process.cwd(), '.crewx', 'logs');
-        this.crewxVersion = options.crewxVersion ?? 'unknown';
-        this.taskLogHandler = options.taskLogHandler;
-        try {
-            (0, fs_1.mkdirSync)(this.logsDir, { recursive: true });
-        }
-        catch (error) {
-        }
-    }
-    getPromptInArgs() {
-        return false;
-    }
-    getDefaultQueryTimeout() {
-        const providerName = this.name.toLowerCase();
-        if (providerName.includes('claude'))
-            return this.timeoutConfig.claudeQuery;
-        if (providerName.includes('gemini'))
-            return this.timeoutConfig.geminiQuery;
-        if (providerName.includes('copilot'))
-            return this.timeoutConfig.copilotQuery;
-        return 600000;
-    }
-    getDefaultExecuteTimeout() {
-        const providerName = this.name.toLowerCase();
-        if (providerName.includes('claude'))
-            return this.timeoutConfig.claudeExecute;
-        if (providerName.includes('gemini'))
-            return this.timeoutConfig.geminiExecute;
-        if (providerName.includes('copilot'))
-            return this.timeoutConfig.copilotExecute;
-        return this.timeoutConfig.parallel;
-    }
-    getDefaultModel() {
-        return null;
-    }
-    getEnv() {
-        return {};
-    }
-    filterClaudePrefixedEnv(env) {
-        return Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith('CLAUDE')));
-    }
-    resolveRuntimeMode(options) {
-        const runtime = options?.runtime;
-        if (!runtime) {
-            return 'native';
-        }
-        if (typeof runtime === 'string') {
-            return (runtime === 'docker' || runtime === 'podman') ? 'container' : 'native';
-        }
-        return (runtime.type === 'docker' || runtime.type === 'podman') ? 'container' : 'native';
-    }
-    resolveContainerCommand(options) {
-        const runtime = options?.runtime;
-        if (typeof runtime === 'string') {
-            return runtime === 'podman' ? 'podman' : 'docker';
-        }
-        if (runtime && typeof runtime === 'object') {
-            return runtime.type === 'podman' ? 'podman' : 'docker';
-        }
-        return 'docker';
-    }
-    resolveDockerImage(options) {
-        const runtime = options?.runtime;
-        if (runtime && typeof runtime === 'object' && runtime.image?.trim()) {
-            return runtime.image.trim();
-        }
-        return process.env.CREWX_DOCKER_AGENT_IMAGE || 'crewx-agent:latest';
-    }
-    resolveDockerMountPath(options) {
-        const runtime = options?.runtime;
-        if (runtime && typeof runtime === 'object' && runtime.mountPath?.trim()) {
-            return runtime.mountPath.trim();
-        }
-        return '/workspace';
-    }
-    resolveDockerArgs(options) {
-        const runtime = options?.runtime;
-        if (runtime && typeof runtime === 'object' && Array.isArray(runtime.dockerArgs)) {
-            return runtime.dockerArgs;
-        }
-        return [];
-    }
-    ensureContainerCredentials() {
-        if (process.platform !== 'darwin')
-            return;
-        const homeDir = process.env.HOME || '';
-        if (!homeDir)
-            return;
-        const credFile = (0, path_1.join)(homeDir, '.claude', '.credentials.json');
-        try {
-            const creds = (0, child_process_1.execSync)('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf-8', timeout: 5000 }).trim();
-            if (creds) {
-                (0, fs_1.mkdirSync)((0, path_1.join)(homeDir, '.claude'), { recursive: true });
-                (0, fs_1.writeFileSync)(credFile, creds, { mode: 0o600 });
-                this.logger.log('Extracted CLI credentials from macOS Keychain for container use');
-            }
-        }
-        catch {
-        }
-    }
-    buildDockerSpawnArgs(executable, args, cwd, env, options) {
-        const image = this.resolveDockerImage(options);
-        const mountPath = this.resolveDockerMountPath(options);
-        const dockerArgs = this.resolveDockerArgs(options);
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        delete env.HOME;
-        delete env.USERPROFILE;
-        const envKeys = Object.keys(env).filter((key) => env[key] !== undefined);
-        const envFlags = envKeys.flatMap((key) => ['-e', `${key}=${env[key]}`]);
-        const homeMounts = homeDir
-            ? [
-                '-v', `${homeDir}/.claude:/root/.claude`,
-                '-v', `${homeDir}/.claude.json:/root/.claude.json`,
-            ]
-            : [];
-        return [
-            'run',
-            '--rm',
-            '-i',
-            ...dockerArgs,
-            '-v',
-            `${cwd}:${mountPath}`,
-            ...homeMounts,
-            '-w',
-            mountPath,
-            ...envFlags,
-            image,
-            executable,
-            ...args,
-        ];
-    }
-    substituteModelPlaceholders(args, model) {
-        return args.map(arg => arg.replace(/\{model\}/g, model));
-    }
-    setToolCallService(toolCallHandler) {
-        this.toolCallHandler = toolCallHandler;
-    }
-    setToolCallHandler(toolCallHandler) {
-        this.toolCallHandler = toolCallHandler;
-    }
-    parseToolUse(content) {
-        const xmlMatch = content.match(/<crew(?:code|x)_tool_call>\s*([\s\S]*?)\s*<\/crew(?:code|x)_tool_call>/);
-        if (xmlMatch && xmlMatch[1]) {
-            try {
-                const jsonContent = xmlMatch[1].trim();
-                const parsed = JSON.parse(jsonContent);
-                if (parsed.type === 'tool_use' && parsed.name && parsed.input !== undefined) {
-                    this.logger.log(`Tool use detected from XML: ${parsed.name}`);
-                    return {
-                        isToolUse: true,
-                        toolName: parsed.name,
-                        toolInput: parsed.input,
-                    };
-                }
-            }
-            catch (e) {
-            }
-        }
-        try {
-            const parsed = JSON.parse(content);
-            if (parsed.type === 'tool_use' && parsed.name && parsed.input !== undefined) {
-                this.logger.log(`Tool use detected from direct JSON: ${parsed.name}`);
-                return {
-                    isToolUse: true,
-                    toolName: parsed.name,
-                    toolInput: parsed.input,
-                };
-            }
-            if (parsed.content && Array.isArray(parsed.content)) {
-                const toolUse = parsed.content.find((c) => c.type === 'tool_use');
-                if (toolUse && toolUse.name && toolUse.input !== undefined) {
-                    this.logger.log(`Tool use detected from content array: ${toolUse.name}`);
-                    return {
-                        isToolUse: true,
-                        toolName: toolUse.name,
-                        toolInput: toolUse.input,
-                    };
-                }
-            }
-            const providerSpecific = this.parseToolUseProviderSpecific(parsed);
-            if (providerSpecific.isToolUse) {
-                return providerSpecific;
-            }
-        }
-        catch (e) {
-        }
-        const codeBlockMatch = content.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-        if (codeBlockMatch && codeBlockMatch[1]) {
-            try {
-                const jsonContent = codeBlockMatch[1].trim();
-                const parsed = JSON.parse(jsonContent);
-                if (parsed.type === 'tool_use' && parsed.name && parsed.input !== undefined) {
-                    this.logger.log(`Tool use detected from code block: ${parsed.name}`);
-                    return {
-                        isToolUse: true,
-                        toolName: parsed.name,
-                        toolInput: parsed.input,
-                    };
-                }
-            }
-            catch (e) {
-            }
-        }
-        const jsonObjectPattern = /\{[\s\S]*?"type"\s*:\s*"tool_use"[\s\S]*?\}/;
-        const jsonMatch = content.match(jsonObjectPattern);
-        if (jsonMatch) {
-            try {
-                const parsed = JSON.parse(jsonMatch[0]);
-                if (parsed.type === 'tool_use' && parsed.name && parsed.input !== undefined) {
-                    this.logger.log(`Tool use detected from plain text JSON: ${parsed.name}`);
-                    return {
-                        isToolUse: true,
-                        toolName: parsed.name,
-                        toolInput: parsed.input,
-                    };
-                }
-            }
-            catch (e) {
-            }
-        }
-        return { isToolUse: false };
-    }
-    parseToolUseProviderSpecific(_parsed) {
-        return { isToolUse: false };
-    }
-    parseUsage(stdout) {
-        if (!stdout || !stdout.trim()) {
-            return undefined;
-        }
-        let lastUsage;
-        try {
-            const lines = stdout.split('\n').filter(line => line.trim());
-            for (const line of lines) {
-                try {
-                    const parsed = JSON.parse(line);
-                    if (parsed.type === 'usage' && parsed.input_tokens !== undefined && parsed.output_tokens !== undefined) {
-                        const cacheRead = parsed.cache_read_input_tokens ?? 0;
-                        const cachedInput = parsed.cached_input_tokens ?? 0;
-                        lastUsage = {
-                            inputTokens: cacheRead ? parsed.input_tokens + cacheRead : parsed.input_tokens,
-                            outputTokens: parsed.output_tokens,
-                            cachedInputTokens: cacheRead || cachedInput,
-                        };
-                    }
-                    if (parsed.usage?.input_tokens !== undefined && parsed.usage?.output_tokens !== undefined) {
-                        const cacheRead = parsed.usage.cache_read_input_tokens ?? 0;
-                        const cachedInput = parsed.usage.cached_input_tokens ?? 0;
-                        lastUsage = {
-                            inputTokens: cacheRead ? parsed.usage.input_tokens + cacheRead : parsed.usage.input_tokens,
-                            outputTokens: parsed.usage.output_tokens,
-                            cachedInputTokens: cacheRead || cachedInput,
-                        };
-                    }
-                }
-                catch (e) {
-                }
-            }
-            if (lastUsage) {
-                return lastUsage;
-            }
-            const parsed = JSON.parse(stdout);
-            if (parsed.usage?.input_tokens !== undefined && parsed.usage?.output_tokens !== undefined) {
-                const cacheRead = parsed.usage.cache_read_input_tokens ?? 0;
-                const cachedInput = parsed.usage.cached_input_tokens ?? 0;
-                return {
-                    inputTokens: cacheRead ? parsed.usage.input_tokens + cacheRead : parsed.usage.input_tokens,
-                    outputTokens: parsed.usage.output_tokens,
-                    cachedInputTokens: cacheRead || cachedInput,
-                };
-            }
-        }
-        catch (e) {
-        }
-        return lastUsage;
-    }
-    extractAgentMessageFromJsonLines(content) {
-        if (!content) {
-            return null;
-        }
-        const trimmed = content.trim();
-        if (!trimmed) {
-            return null;
-        }
-        const hasJsonlMarkers = /"type"\s*:\s*"(?:thread\.started|item\.completed|turn\.completed|response\.completed)"/.test(trimmed)
-            || /"type"\s*:\s*"(?:agent_message|assistant_message)"/.test(trimmed)
-            || /"item_type"\s*:\s*"assistant_message"/.test(trimmed);
-        if (!hasJsonlMarkers) {
-            return null;
-        }
-        const lines = trimmed.split('\n').map(line => line.trim()).filter(Boolean);
-        let agentMessage = null;
-        for (const line of lines) {
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            const extracted = this.extractAgentMessageFromJsonItem(parsed);
-            if (extracted) {
-                agentMessage = extracted;
-            }
-        }
-        return agentMessage;
-    }
-    extractAgentMessageFromJsonItem(parsed) {
-        if (!parsed || typeof parsed !== 'object') {
-            return null;
-        }
-        if (parsed?.type === 'item.completed' &&
-            parsed?.item?.type === 'agent_message' &&
-            typeof parsed.item.text === 'string') {
-            return parsed.item.text.trim();
-        }
-        if (parsed?.type === 'item.completed' &&
-            parsed?.item?.item_type === 'assistant_message' &&
-            typeof parsed.item.text === 'string') {
-            return parsed.item.text.trim();
-        }
-        if (parsed?.item?.type === 'agent_message' &&
-            typeof parsed.item.text === 'string') {
-            return parsed.item.text.trim();
-        }
-        if (parsed?.item?.item_type === 'assistant_message' &&
-            typeof parsed.item.text === 'string') {
-            return parsed.item.text.trim();
-        }
-        if (Array.isArray(parsed?.response?.output)) {
-            const assistantEntries = parsed.response.output.filter((entry) => entry?.type === 'agent_message' || entry?.item_type === 'assistant_message');
-            if (assistantEntries.length > 0) {
-                const lastMessage = assistantEntries[assistantEntries.length - 1];
-                if (typeof lastMessage?.text === 'string') {
-                    return lastMessage.text.trim();
-                }
-            }
-        }
-        return null;
-    }
-    filterToolUseFromResponse(content) {
-        if (!content)
-            return content;
-        const jsonlMessage = this.extractAgentMessageFromJsonLines(content);
-        if (jsonlMessage) {
-            return jsonlMessage;
-        }
-        let filteredContent = content;
-        filteredContent = filteredContent.replace(/^\s*\{[^}]*"type"\s*:\s*"tool_use"[^}]*\}\s*$/gm, '');
-        filteredContent = filteredContent.replace(/(?:^\s*\{[^}]*"type"\s*:\s*"tool_use"[^}]*\}\s*\n?)+/gm, '');
-        filteredContent = filteredContent.replace(/\n{3,}/g, '\n\n');
-        if (filteredContent.trim() === '') {
-            return '[Tool operations completed]';
-        }
-        return filteredContent.trim();
-    }
-    filterRuntimeLogs(content) {
-        if (!content)
-            return content;
-        let filtered = content;
-        if (this.shouldStripPromptContainers(filtered)) {
-            const promptContainerPatterns = [
-                /<(?:crewx_)?system_prompt\b[^>]*>[\s\S]*?<\/(?:crewx_)?system_prompt>/gi,
-                /<conversation_history\b[^>]*>[\s\S]*?<\/conversation_history>/gi,
-                /<user_query\b[^>]*>[\s\S]*?<\/user_query>/gi,
-            ];
-            for (const pattern of promptContainerPatterns) {
-                filtered = filtered.replace(pattern, '');
-            }
-        }
-        const runtimeLogPatterns = [
-            /^\[AgentRuntime\].*$/gm,
-            /^Loaded layout:.*$/gm,
-            /^Loaded \d+ layouts? from.*$/gm,
-            /^\[dotenv@[^\]]+\].*$/gm,
-            /^Registered custom layout:.*$/gm,
-            /^Updated custom layout:.*$/gm,
-            /^\[Layout Fallback\].*$/gm,
-            /^(?:💬\s*)?Message:\s*$/gm,
-        ];
-        for (const pattern of runtimeLogPatterns) {
-            filtered = filtered.replace(pattern, '');
-        }
-        filtered = filtered
-            .split('\n')
-            .map((line) => line.trimEnd())
-            .join('\n');
-        filtered = filtered.replace(/\n{3,}/g, '\n\n');
-        return filtered.trim();
-    }
-    shouldStripPromptContainers(content) {
-        return (/^\s*<(?:crewx_)?system_prompt\b/i.test(content) ||
-            /^\s*<conversation_history\b/i.test(content) ||
-            /^\s*<user_query\b/i.test(content) ||
-            /^(?:💬\s*)?Message:\s*<(?:(?:crewx_)?system_prompt|conversation_history|user_query)\b/im.test(content) ||
-            /^\[AgentRuntime\].*$/m.test(content) ||
-            /^Loaded layout:.*$/m.test(content) ||
-            /^Loaded \d+ layouts? from.*$/m.test(content) ||
-            /^\[dotenv@[^\]]+\].*$/m.test(content) ||
-            /^Registered custom layout:.*$/m.test(content) ||
-            /^Updated custom layout:.*$/m.test(content) ||
-            /^\[Layout Fallback\].*$/m.test(content));
-    }
-    parseProviderError(stderr, stdout, exitCode) {
-        if (stderr && (stderr.toLowerCase().includes('unknown option') ||
-            stderr.toLowerCase().includes('invalid option'))) {
-            return {
-                error: true,
-                message: stderr.split('\n')[0]?.trim() || 'Invalid CLI option',
-            };
-        }
-        const knownWarningPatterns = [
-            'YOLO mode is enabled',
-            'Loaded cached credentials',
-            'MaxListenersExceededWarning',
-            'MaxListeners is',
-            'Use events.setMaxListeners()',
-            'Use `node --trace-warnings',
-        ];
-        if (exitCode === 0 && stderr && !stdout) {
-            const isOnlyWarnings = knownWarningPatterns.some(pattern => stderr.includes(pattern));
-            if (isOnlyWarnings) {
-                return { error: false, message: '' };
-            }
-        }
-        if (stderr && !stdout) {
-            return { error: true, message: stderr };
-        }
-        return { error: false, message: '' };
-    }
-    async getToolPath() {
-        if (this.cachedPath !== null) {
-            return this.cachedPath;
-        }
-        try {
-            const cliCommand = this.getCliCommand();
-            const isWindows = process.platform === 'win32';
-            const command = isWindows ? `where ${cliCommand}` : `which ${cliCommand}`;
-            const path = (0, child_process_1.execSync)(command, { encoding: 'utf-8' }).trim();
-            let finalPath;
-            if (isWindows) {
-                const paths = path.split('\n').map(p => p.trim()).filter(p => p);
-                const pathWithExt = paths.find(p => /\.(cmd|exe|bat|ps1)$/i.test(p));
-                finalPath = pathWithExt || paths[0] || '';
-            }
-            else {
-                finalPath = path;
-            }
-            this.logger.log(`✅ Found ${this.name} CLI at: ${finalPath}`);
-            this.cachedPath = finalPath;
-            return finalPath;
-        }
-        catch (error) {
-            this.logger.error(`❌ ${this.name} not found in PATH: ${error.message}`);
-            this.cachedPath = '';
-            return null;
-        }
-    }
-    wrapUserQueryWithSecurity(userQuery, securityKey) {
-        return `
-<user_query key="${securityKey}">
-${userQuery}
-</user_query>`;
-    }
-    extractUserQuery(wrappedQuery, securityKey) {
-        const regex = new RegExp(`<user_query key="${securityKey}">\\s*([\\s\\S]*?)\\s*</user_query>`, 'm');
-        const match = wrappedQuery.match(regex);
-        return match && match[1] ? match[1].trim() : wrappedQuery;
-    }
-    async isAvailable() {
-        const path = await this.getToolPath();
-        return path !== null && path !== '';
-    }
-    formatLogTimestamp(date) {
-        const pad = (n) => String(n).padStart(2, '0');
-        return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}T${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
-    }
-    createTaskLogFile(taskId, provider, command, agentId, model) {
-        if (this.taskLogHandler)
-            return '';
-        const safeTaskId = taskId.replace(/[\\/]/g, '_');
-        const now = new Date();
-        const ts = this.formatLogTimestamp(now);
-        const logFile = (0, path_1.join)(this.logsDir, `${ts}_${safeTaskId}.log`);
-        const safeAgentId = agentId ? agentId.replace(/[\\/]/g, '_') : 'N/A';
-        const timestamp = now.toLocaleString();
-        const header = `=== TASK LOG: ${taskId} ===
-CrewX Version: ${this.crewxVersion}
-Provider: ${provider}
-Agent: ${safeAgentId}
-${model ? `Model: ${model}\n` : ''}Command: ${command}
-Started: ${timestamp}
-
-`;
-        (0, fs_1.writeFileSync)(logFile, header, 'utf8');
-        return logFile;
-    }
-    appendTaskLog(taskId, level, message) {
-        const timestamp = new Date();
-        if (!this.taskLogHandler) {
-            const safeTaskId = taskId.replace(/[\\/]/g, '_');
-            const logFile = this.findTaskLogFile(safeTaskId);
-            if (logFile) {
-                const logEntry = `[${timestamp.toLocaleString()}] ${level}: ${message}\n`;
-                try {
-                    (0, fs_1.appendFileSync)(logFile, logEntry, 'utf8');
-                }
-                catch (error) {
-                    this.logger.error(`Failed to append to task log ${taskId}:`, error);
-                }
-            }
-        }
-        if (this.taskLogHandler) {
-            try {
-                this.taskLogHandler({
-                    taskId,
-                    timestamp: timestamp.toISOString(),
-                    level,
-                    message,
-                });
-            }
-            catch (error) {
-                this.logger.warn(`Task log handler failed for ${taskId}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    findTaskLogFile(safeTaskId) {
-        try {
-            if (!(0, fs_1.existsSync)(this.logsDir))
-                return null;
-            const files = (0, fs_1.readdirSync)(this.logsDir);
-            const match = files.find(f => f.endsWith(`_${safeTaskId}.log`));
-            if (match)
-                return (0, path_1.join)(this.logsDir, match);
-            const legacy = (0, path_1.join)(this.logsDir, `${safeTaskId}.log`);
-            if ((0, fs_1.existsSync)(legacy))
-                return legacy;
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async query(prompt, options = {}) {
-        const taskId = options.taskId || (0, id_1.generateId)('tsk');
-        const executablePath = this.getCliCommand();
-        const promptLength = prompt.length;
-        try {
-            const modelToUse = options.model || this.getDefaultModel();
-            let args = [
-                ...(options.additionalArgs || []),
-                ...this.getDefaultArgs(),
-            ];
-            if (modelToUse) {
-                args = this.substituteModelPlaceholders(args, modelToUse);
-            }
-            const isBuiltInProvider = this.name.startsWith('cli/');
-            const hasModelInArgs = args.some(arg => arg.includes('--model') || arg.includes('{model}'));
-            if (isBuiltInProvider && options.model && !hasModelInArgs) {
-                args.unshift(`--model=${options.model}`);
-            }
-            const promptInArgs = this.getPromptInArgs();
-            if (promptInArgs) {
-                args.push(prompt);
-            }
-            const runtimeMode = this.resolveRuntimeMode(options);
-            const command = runtimeMode === 'container'
-                ? `${this.resolveContainerCommand(options)} run --rm -i -v ${options.workingDirectory || process.cwd()}:${this.resolveDockerMountPath(options)} ${this.resolveDockerImage(options)} ${this.getCliCommand()} ...`
-                : (promptInArgs
-                    ? `${this.getCliCommand()} ${args.slice(0, -1).join(' ')} -p "<prompt>"`
-                    : `${this.getCliCommand()} ${args.join(' ')}`);
-            this.createTaskLogFile(taskId, this.name, command, options.agentId, modelToUse);
-            this.appendTaskLog(taskId, 'INFO', `Starting ${this.name} query mode`);
-            this.appendTaskLog(taskId, 'INFO', `Prompt length: ${promptLength} characters`);
-            this.appendTaskLog(taskId, 'INFO', `Prompt content:\n${prompt}`);
-            this.logger.log(`Executing ${this.name} with prompt (length: ${promptLength})`);
-            return new Promise((resolve) => {
-                const env = this.filterClaudePrefixedEnv({
-                    ...process.env,
-                    LANG: 'en_US.UTF-8',
-                    LC_ALL: 'en_US.UTF-8',
-                    CREWX_TASK_ID: taskId,
-                    CREWX_WORKSPACE: process.env.CREWX_WORKSPACE || process.cwd(),
-                    CREWX_AGENT_ID: options.agentId || '',
-                    CREWX_USER_ID: process.env.USER || process.env.USERNAME || 'unknown',
-                    CREWX_TRACE_ID: options.traceId || process.env.CREWX_TRACE_ID || '',
-                    CREWX_PARENT_TASK_ID: taskId,
-                    CREWX_CALLER_AGENT_ID: resolveCallerAgentId(options.agentId),
-                    ...this.getEnv(),
-                    ...(options.env || {}),
-                });
-                if (process.platform === 'win32') {
-                    env.PYTHONIOENCODING = 'utf-8';
-                }
-                let executable = executablePath;
-                let spawnArgs = args;
-                let useShell = false;
-                if (runtimeMode === 'container') {
-                    this.ensureContainerCredentials();
-                    delete env.CLAUDECODE;
-                    executable = this.resolveContainerCommand(options);
-                    spawnArgs = this.buildDockerSpawnArgs(executablePath, args, options.workingDirectory || process.cwd(), env, options);
-                    useShell = false;
-                }
-                else if (process.platform === 'win32') {
-                    useShell = true;
-                }
-                const startTime = Date.now();
-                let firstOutputAt = undefined;
-                const child = (0, child_process_1.spawn)(executable, spawnArgs, {
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                    cwd: options.workingDirectory || process.cwd(),
-                    env,
-                    shell: useShell,
-                });
-                const childPid = child.pid;
-                this.notifyProcessStart(options, childPid);
-                let stdout = '';
-                let stderr = '';
-                let exitCode = null;
-                const accumulatedLogs = [];
-                child.stdin.on('error', (err) => {
-                    if (err.code !== 'EPIPE') {
-                        this.logger.warn(`stdin error: ${err.message}`);
-                    }
-                });
-                let stdoutLineBuffer = '';
-                let stderrLineBuffer = '';
-                child.stdout.on('data', (data) => {
-                    const output = data.toString();
-                    if (firstOutputAt === undefined) {
-                        firstOutputAt = Date.now();
-                    }
-                    stdout += output;
-                    stdoutLineBuffer += output;
-                    const lines = stdoutLineBuffer.split('\n');
-                    stdoutLineBuffer = lines.pop() || '';
-                    for (const line of lines) {
-                        if (line.trim()) {
-                            this.appendTaskLog(taskId, 'STDOUT', line);
-                            const timestamp = new Date().toISOString();
-                            const entries = (0, parsers_1.parseStdoutEvent)(timestamp, line);
-                            if (entries.length > 0) {
-                                accumulatedLogs.push(...entries);
-                            }
-                        }
-                    }
-                });
-                child.stderr.on('data', (data) => {
-                    const output = data.toString();
-                    if (firstOutputAt === undefined) {
-                        firstOutputAt = Date.now();
-                    }
-                    stderr += output;
-                    stderrLineBuffer += output;
-                    const lines = stderrLineBuffer.split('\n');
-                    stderrLineBuffer = lines.pop() || '';
-                    for (const line of lines) {
-                        if (line.trim()) {
-                            this.appendTaskLog(taskId, 'STDERR', line);
-                        }
-                    }
-                });
-                child.on('close', (code) => {
-                    exitCode = code;
-                    const completedAt = Date.now();
-                    const durationMs = completedAt - startTime;
-                    const timeToFirstOutputMs = firstOutputAt !== undefined ? firstOutputAt - startTime : undefined;
-                    if (stdoutLineBuffer.trim()) {
-                        this.appendTaskLog(taskId, 'STDOUT', stdoutLineBuffer);
-                        const timestamp = new Date().toISOString();
-                        const entries = (0, parsers_1.parseStdoutEvent)(timestamp, stdoutLineBuffer);
-                        if (entries.length > 0) {
-                            accumulatedLogs.push(...entries);
-                        }
-                        stdoutLineBuffer = '';
-                    }
-                    if (stderrLineBuffer.trim()) {
-                        this.appendTaskLog(taskId, 'STDERR', stderrLineBuffer);
-                        stderrLineBuffer = '';
-                    }
-                    this.appendTaskLog(taskId, 'INFO', `Process closed with exit code: ${exitCode}`);
-                    if (stderr) {
-                        this.logger.warn(`[${taskId}] ${this.name} stderr: ${stderr}`);
-                    }
-                    if (exitCode === 0 && stdout && stdout.trim().length > 0) {
-                        const filteredContent = this.filterRuntimeLogs(this.filterToolUseFromResponse(stdout.trim()));
-                        const usage = this.parseUsage(stdout);
-                        this.appendTaskLog(taskId, 'INFO', `${this.name} query completed successfully`);
-                        resolve({
-                            content: filteredContent,
-                            provider: this.name,
-                            command,
-                            success: true,
-                            taskId,
-                            pid: childPid,
-                            exitCode,
-                            durationMs,
-                            timeToFirstOutputMs,
-                            promptLength,
-                            usage,
-                            logs: accumulatedLogs,
-                        });
-                        return;
-                    }
-                    const providerError = this.parseProviderError(stderr, stdout, exitCode);
-                    if (exitCode !== 0 || providerError.error) {
-                        const errorMessage = providerError.message || stderr || `Exit code ${exitCode}`;
-                        this.appendTaskLog(taskId, 'ERROR', `${this.name} CLI failed: ${errorMessage}`);
-                        resolve({
-                            content: '',
-                            provider: this.name,
-                            command,
-                            success: false,
-                            error: `${this.name} CLI failed: ${errorMessage}`,
-                            taskId,
-                            pid: childPid,
-                            exitCode,
-                            durationMs,
-                            timeToFirstOutputMs,
-                            promptLength,
-                        });
-                        return;
-                    }
-                    this.appendTaskLog(taskId, 'INFO', `${this.name} query completed successfully`);
-                    let parsedContent = stdout.trim();
-                    try {
-                        JSON.parse(stdout);
-                        parsedContent = stdout.trim();
-                        this.appendTaskLog(taskId, 'INFO', 'JSON output detected and validated');
-                    }
-                    catch (jsonError) {
-                        this.appendTaskLog(taskId, 'INFO', 'Plain text output (not JSON)');
-                    }
-                    const filteredContent = this.filterRuntimeLogs(this.filterToolUseFromResponse(parsedContent));
-                    const usage = this.parseUsage(stdout);
-                    resolve({
-                        content: filteredContent,
-                        provider: this.name,
-                        command,
-                        success: true,
-                        taskId,
-                        pid: childPid,
-                        exitCode,
-                        durationMs,
-                        timeToFirstOutputMs,
-                        promptLength,
-                        usage,
-                        logs: accumulatedLogs,
-                    });
-                });
-                child.on('error', (error) => {
-                    const durationMs = Date.now() - startTime;
-                    const timeToFirstOutputMs = firstOutputAt !== undefined ? firstOutputAt - startTime : undefined;
-                    this.appendTaskLog(taskId, 'ERROR', `Process error: ${error.message}`);
-                    resolve({
-                        content: '',
-                        provider: this.name,
-                        command,
-                        success: false,
-                        error: error.code === 'ENOENT' ? this.getNotInstalledMessage() : error.message,
-                        taskId,
-                        pid: childPid,
-                        exitCode: null,
-                        durationMs,
-                        timeToFirstOutputMs,
-                        promptLength,
-                    });
-                });
-                const pipedContext = this.buildPipedContext(prompt, options);
-                try {
-                    if (pipedContext && this.shouldPipeContext(options)) {
-                        child.stdin.write(pipedContext);
-                        if (!pipedContext.endsWith('\n')) {
-                            child.stdin.write('\n');
-                        }
-                    }
-                    if (!this.getPromptInArgs()) {
-                        child.stdin.write(prompt);
-                    }
-                }
-                catch (stdinError) {
-                    if (stdinError.code !== 'EPIPE') {
-                        this.logger.warn(`stdin write error: ${stdinError.message}`);
-                    }
-                }
-                finally {
-                    setImmediate(() => {
-                        try {
-                            child.stdin.end();
-                        }
-                        catch (endError) {
-                            if (endError.code !== 'EPIPE') {
-                                this.logger.warn(`stdin.end() error: ${endError.message}`);
-                            }
-                        }
-                    });
-                }
-                const timeout = setTimeout(() => {
-                    const durationMs = Date.now() - startTime;
-                    const timeToFirstOutputMs = firstOutputAt !== undefined ? firstOutputAt - startTime : undefined;
-                    child.kill();
-                    resolve({
-                        content: '',
-                        provider: this.name,
-                        command,
-                        success: false,
-                        error: `${this.name} CLI timeout`,
-                        taskId,
-                        pid: childPid,
-                        exitCode: null,
-                        durationMs,
-                        timeToFirstOutputMs,
-                        promptLength,
-                    });
-                }, options.timeout || this.getDefaultQueryTimeout());
-                child.on('close', () => clearTimeout(timeout));
-            });
-        }
-        catch (error) {
-            this.logger.error(`${this.name} execution failed: ${error.message}`, error.stack);
-            return {
-                content: '',
-                provider: this.name,
-                command: `${this.getCliCommand()} (error)`,
-                success: false,
-                error: error.message || 'Unknown error occurred',
-                taskId,
-                exitCode: null,
-                promptLength,
-            };
-        }
-    }
-    async execute(prompt, options = {}) {
-        const taskId = options.taskId || (0, id_1.generateId)('tsk');
-        const executablePath = this.getCliCommand();
-        const promptLength = prompt.length;
-        try {
-            const modelToUse = options.model || this.getDefaultModel();
-            let args = [
-                ...(options.additionalArgs || []),
-                ...this.getExecuteArgs(),
-            ];
-            if (modelToUse) {
-                args = this.substituteModelPlaceholders(args, modelToUse);
-            }
-            const isBuiltInProvider = this.name.startsWith('cli/');
-            const hasModelInArgs = args.some(arg => arg.includes('--model') || arg.includes('{model}'));
-            if (isBuiltInProvider && options.model && !hasModelInArgs) {
-                args.unshift(`--model=${options.model}`);
-            }
-            if (this.getPromptInArgs()) {
-                args.push(prompt);
-            }
-            const runtimeMode = this.resolveRuntimeMode(options);
-            const command = runtimeMode === 'container'
-                ? `${this.resolveContainerCommand(options)} run --rm -i -v ${options.workingDirectory || process.cwd()}:${this.resolveDockerMountPath(options)} ${this.resolveDockerImage(options)} ${this.getCliCommand()} ...`
-                : `${this.getCliCommand()} ${args.join(' ')}`;
-            this.createTaskLogFile(taskId, this.name, command, options.agentId, modelToUse);
-            this.appendTaskLog(taskId, 'INFO', `Additional Args: ${JSON.stringify(options.additionalArgs || [])}`);
-            this.appendTaskLog(taskId, 'INFO', `Execute Args: ${JSON.stringify(this.getExecuteArgs())}`);
-            this.appendTaskLog(taskId, 'INFO', `Final Args: ${JSON.stringify(args)}`);
-            this.appendTaskLog(taskId, 'INFO', `Starting ${this.name} execute mode`);
-            this.appendTaskLog(taskId, 'INFO', `Prompt length: ${promptLength} characters`);
-            const promptPreview = prompt.length > this.logConfig.promptMaxLength ?
-                prompt.substring(0, this.logConfig.promptMaxLength) + '...[truncated]' :
-                prompt;
-            this.appendTaskLog(taskId, 'INFO', `Prompt content:\n${promptPreview}`);
-            this.logger.log(`Executing ${this.name} in execute mode (length: ${promptLength})`);
-            return new Promise((resolve) => {
-                const env = this.filterClaudePrefixedEnv({
-                    ...process.env,
-                    LANG: 'en_US.UTF-8',
-                    LC_ALL: 'en_US.UTF-8',
-                    CREWX_TASK_ID: taskId,
-                    CREWX_WORKSPACE: process.env.CREWX_WORKSPACE || process.cwd(),
-                    CREWX_AGENT_ID: options.agentId || '',
-                    CREWX_USER_ID: process.env.USER || process.env.USERNAME || 'unknown',
-                    CREWX_TRACE_ID: options.traceId || process.env.CREWX_TRACE_ID || '',
-                    CREWX_PARENT_TASK_ID: taskId,
-                    CREWX_CALLER_AGENT_ID: resolveCallerAgentId(options.agentId),
-                    ...this.getEnv(),
-                    ...(options.env || {}),
-                });
-                if (process.platform === 'win32') {
-                    env.PYTHONIOENCODING = 'utf-8';
-                }
-                let executable = executablePath;
-                let spawnArgs = args;
-                let useShell = false;
-                if (runtimeMode === 'container') {
-                    this.ensureContainerCredentials();
-                    delete env.CLAUDECODE;
-                    executable = this.resolveContainerCommand(options);
-                    spawnArgs = this.buildDockerSpawnArgs(executablePath, args, options.workingDirectory || process.cwd(), env, options);
-                    useShell = false;
-                }
-                else if (process.platform === 'win32') {
-                    useShell = true;
-                }
-                const startTime = Date.now();
-                let firstOutputAt = undefined;
-                const child = (0, child_process_1.spawn)(executable, spawnArgs, {
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                    cwd: options.workingDirectory || process.cwd(),
-                    env,
-                    shell: useShell,
-                });
-                const childPid = child.pid;
-                this.notifyProcessStart(options, childPid);
-                let stdout = '';
-                let stderr = '';
-                let exitCode = null;
-                const accumulatedLogs = [];
-                child.stdin.on('error', (err) => {
-                    if (err.code !== 'EPIPE') {
-                        this.logger.warn(`stdin error: ${err.message}`);
-                    }
-                });
-                let stdoutLineBuffer = '';
-                let stderrLineBuffer = '';
-                child.stdout.on('data', (data) => {
-                    const output = data.toString();
-                    if (firstOutputAt === undefined) {
-                        firstOutputAt = Date.now();
-                    }
-                    stdout += output;
-                    stdoutLineBuffer += output;
-                    const lines = stdoutLineBuffer.split('\n');
-                    stdoutLineBuffer = lines.pop() || '';
-                    for (const line of lines) {
-                        if (line.trim()) {
-                            this.appendTaskLog(taskId, 'STDOUT', line);
-                            const timestamp = new Date().toISOString();
-                            const entries = (0, parsers_1.parseStdoutEvent)(timestamp, line);
-                            if (entries.length > 0) {
-                                accumulatedLogs.push(...entries);
-                            }
-                        }
-                    }
-                });
-                child.stderr.on('data', (data) => {
-                    const output = data.toString();
-                    if (firstOutputAt === undefined) {
-                        firstOutputAt = Date.now();
-                    }
-                    stderr += output;
-                    stderrLineBuffer += output;
-                    const lines = stderrLineBuffer.split('\n');
-                    stderrLineBuffer = lines.pop() || '';
-                    for (const line of lines) {
-                        if (line.trim()) {
-                            this.appendTaskLog(taskId, 'STDERR', line);
-                        }
-                    }
-                });
-                child.on('close', (code) => {
-                    exitCode = code;
-                    const completedAt = Date.now();
-                    const durationMs = completedAt - startTime;
-                    const timeToFirstOutputMs = firstOutputAt !== undefined ? firstOutputAt - startTime : undefined;
-                    if (stdoutLineBuffer.trim()) {
-                        this.appendTaskLog(taskId, 'STDOUT', stdoutLineBuffer);
-                        const timestamp = new Date().toISOString();
-                        const entries = (0, parsers_1.parseStdoutEvent)(timestamp, stdoutLineBuffer);
-                        if (entries.length > 0) {
-                            accumulatedLogs.push(...entries);
-                        }
-                        stdoutLineBuffer = '';
-                    }
-                    if (stderrLineBuffer.trim()) {
-                        this.appendTaskLog(taskId, 'STDERR', stderrLineBuffer);
-                        stderrLineBuffer = '';
-                    }
-                    this.appendTaskLog(taskId, 'INFO', `Process closed with exit code: ${exitCode}`);
-                    if (stderr) {
-                        this.logger.warn(`[${taskId}] ${this.name} stderr: ${stderr}`);
-                    }
-                    if (exitCode === 0 && stdout && stdout.trim().length > 0) {
-                        const filteredContent = this.filterRuntimeLogs(this.filterToolUseFromResponse(stdout.trim()));
-                        const usage = this.parseUsage(stdout);
-                        this.appendTaskLog(taskId, 'INFO', `${this.name} execution completed successfully`);
-                        resolve({
-                            content: filteredContent,
-                            provider: this.name,
-                            command,
-                            success: true,
-                            taskId,
-                            pid: childPid,
-                            exitCode,
-                            durationMs,
-                            timeToFirstOutputMs,
-                            promptLength,
-                            usage,
-                            logs: accumulatedLogs,
-                        });
-                        return;
-                    }
-                    const providerError = this.parseProviderError(stderr, stdout, exitCode);
-                    if (exitCode !== 0 || providerError.error) {
-                        const errorMessage = providerError.message || stderr || `Exit code ${exitCode}`;
-                        this.appendTaskLog(taskId, 'ERROR', `${this.name} CLI failed: ${errorMessage}`);
-                        resolve({
-                            content: '',
-                            provider: this.name,
-                            command,
-                            success: false,
-                            error: `${this.name} CLI execute failed: ${errorMessage}`,
-                            taskId,
-                            pid: childPid,
-                            exitCode,
-                            durationMs,
-                            timeToFirstOutputMs,
-                            promptLength,
-                        });
-                        return;
-                    }
-                    this.appendTaskLog(taskId, 'INFO', `${this.name} execute completed successfully`);
-                    let parsedContent = stdout.trim();
-                    try {
-                        JSON.parse(stdout);
-                        parsedContent = stdout.trim();
-                        this.appendTaskLog(taskId, 'INFO', 'JSON output detected and validated');
-                    }
-                    catch (jsonError) {
-                        this.appendTaskLog(taskId, 'INFO', 'Plain text output (not JSON)');
-                    }
-                    const filteredContent = this.filterRuntimeLogs(parsedContent);
-                    const usage = this.parseUsage(stdout);
-                    resolve({
-                        content: filteredContent,
-                        provider: this.name,
-                        command,
-                        success: true,
-                        taskId,
-                        pid: childPid,
-                        exitCode,
-                        durationMs,
-                        timeToFirstOutputMs,
-                        promptLength,
-                        usage,
-                        logs: accumulatedLogs,
-                    });
-                });
-                child.on('error', (error) => {
-                    const durationMs = Date.now() - startTime;
-                    const timeToFirstOutputMs = firstOutputAt !== undefined ? firstOutputAt - startTime : undefined;
-                    this.appendTaskLog(taskId, 'ERROR', `Process error: ${error.message}`);
-                    resolve({
-                        content: '',
-                        provider: this.name,
-                        command,
-                        success: false,
-                        error: error.code === 'ENOENT' ? this.getNotInstalledMessage() : error.message,
-                        taskId,
-                        pid: childPid,
-                        exitCode: null,
-                        durationMs,
-                        timeToFirstOutputMs,
-                        promptLength,
-                    });
-                });
-                const pipedContext = this.buildPipedContext(prompt, options);
-                try {
-                    if (pipedContext && this.shouldPipeContext(options)) {
-                        child.stdin.write(pipedContext);
-                        if (!pipedContext.endsWith('\n')) {
-                            child.stdin.write('\n');
-                        }
-                    }
-                    if (!this.getPromptInArgs()) {
-                        child.stdin.write(prompt);
-                    }
-                }
-                catch (stdinError) {
-                    if (stdinError.code !== 'EPIPE') {
-                        this.logger.warn(`stdin write error: ${stdinError.message}`);
-                    }
-                }
-                finally {
-                    setImmediate(() => {
-                        try {
-                            child.stdin.end();
-                        }
-                        catch (endError) {
-                            if (endError.code !== 'EPIPE') {
-                                this.logger.warn(`stdin.end() error: ${endError.message}`);
-                            }
-                        }
-                    });
-                }
-                const timeout = setTimeout(() => {
-                    const durationMs = Date.now() - startTime;
-                    const timeToFirstOutputMs = firstOutputAt !== undefined ? firstOutputAt - startTime : undefined;
-                    child.kill();
-                    resolve({
-                        content: '',
-                        provider: this.name,
-                        command,
-                        success: false,
-                        error: `${this.name} CLI execute timeout`,
-                        taskId,
-                        pid: childPid,
-                        exitCode: null,
-                        durationMs,
-                        timeToFirstOutputMs,
-                        promptLength,
-                    });
-                }, options.timeout || this.getDefaultExecuteTimeout());
-                child.on('close', () => clearTimeout(timeout));
-            });
-        }
-        catch (error) {
-            this.logger.error(`${this.name} execute failed: ${error.message}`, error.stack);
-            return {
-                content: '',
-                provider: this.name,
-                command: `${this.getCliCommand()} execute (error)`,
-                success: false,
-                error: error.message || 'Unknown error occurred',
-                taskId,
-                exitCode: null,
-                promptLength,
-            };
-        }
-    }
-    shouldPipeContext(_options) {
-        return true;
-    }
-    notifyProcessStart(options, pid) {
-        if (typeof options.onProcessStart !== 'function' || typeof pid !== 'number') {
-            return;
-        }
-        try {
-            options.onProcessStart(pid);
-        }
-        catch (error) {
-            this.logger.warn(`onProcessStart callback failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    buildPipedContext(prompt, options) {
-        const normalized = options?.pipedContext?.trim();
-        if (normalized) {
-            if (this.isStructuredPayload(normalized)) {
-                return normalized;
-            }
-            return this.createStructuredPayload(prompt, normalized, options);
-        }
-        if (options?.messages && options.messages.length > 0) {
-            return this.createStructuredPayload(prompt, null, options);
-        }
-        return null;
-    }
-    isStructuredPayload(value) {
-        try {
-            const parsed = JSON.parse(value);
-            return Boolean(parsed && typeof parsed === 'object' && 'prompt' in parsed && 'messages' in parsed);
-        }
-        catch {
-            return false;
-        }
-    }
-    createStructuredPayload(prompt, context, options) {
-        const safeMessages = Array.isArray(options?.messages) ? options.messages : [];
-        const fallbackHistory = safeMessages.length > 0
-            ? safeMessages
-                .map((msg, index) => {
-                const speaker = msg.isAssistant ? 'Assistant' : 'User';
-                return `${index + 1}. ${speaker}: ${msg.text}`;
-            })
-                .join('\n')
-            : '';
-        const normalizedContext = context?.trim() ?? '';
-        const payload = {
-            version: '1.0',
-            agent: {
-                id: options?.agentId ?? null,
-                provider: this.name,
-                mode: options?.additionalArgs?.includes('--execute') ? 'execute' : 'query',
-                model: options?.model ?? null,
-            },
-            prompt,
-            context: normalizedContext,
-            messages: safeMessages,
-            metadata: {
-                generatedAt: new Date().toISOString(),
-                messageCount: safeMessages.length,
-                formattedHistory: fallbackHistory,
-                originalContext: normalizedContext,
-            },
-        };
-        return JSON.stringify(payload);
-    }
-}
-exports.BaseAIProvider = BaseAIProvider;
-//# sourceMappingURL=base-ai.provider.js.map