@crewx/sdk 0.8.0-rc.58

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

@@ -0,0 +1,1183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAIProvider = exports.ConsoleLogger = void 0;
+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");
+class ConsoleLogger {
+    constructor(context) {
+        this.context = context;
+    }
+    log(message, ...optionalParams) {
+        console.log(`[${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;
+        }
+        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) {
+                        return {
+                            inputTokens: parsed.input_tokens,
+                            outputTokens: parsed.output_tokens,
+                        };
+                    }
+                    if (parsed.usage?.input_tokens !== undefined && parsed.usage?.output_tokens !== undefined) {
+                        return {
+                            inputTokens: parsed.usage.input_tokens,
+                            outputTokens: parsed.usage.output_tokens,
+                        };
+                    }
+                }
+                catch (e) {
+                }
+            }
+            const parsed = JSON.parse(stdout);
+            if (parsed.usage?.input_tokens !== undefined && parsed.usage?.output_tokens !== undefined) {
+                return {
+                    inputTokens: parsed.usage.input_tokens,
+                    outputTokens: parsed.usage.output_tokens,
+                };
+            }
+        }
+        catch (e) {
+        }
+        return undefined;
+    }
+    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 !== '';
+    }
+    createTaskLogFile(taskId, provider, command, agentId, model) {
+        const safeTaskId = taskId.replace(/[\\/]/g, '_');
+        const logFile = (0, path_1.join)(this.logsDir, `${safeTaskId}.log`);
+        const safeAgentId = agentId ? agentId.replace(/[\\/]/g, '_') : 'N/A';
+        const timestamp = new Date().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 safeTaskId = taskId.replace(/[\\/]/g, '_');
+        const logFile = (0, path_1.join)(this.logsDir, `${safeTaskId}.log`);
+        const timestamp = new Date();
+        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)}`);
+            }
+        }
+    }
+    async query(prompt, options = {}) {
+        const taskId = options.taskId || `${this.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        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_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: options.agentId || process.env.CREWX_CALLER_AGENT_ID || '',
+                    ...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 || `${this.name}_execute_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        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_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: options.agentId || process.env.CREWX_CALLER_AGENT_ID || '',
+                    ...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