repoburg 1.3.155 → 1.3.156

package/backend/dist/src/sub-agents/sub-agent-runner.service.js

@@ -1,690 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var SubAgentRunner_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubAgentRunner = void 0;
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const llm_provider_interface_1 = require("../llm-provider/llm-provider.interface");
-const sub_agents_service_1 = require("./sub-agents.service");
-const sub_agent_runs_service_1 = require("./sub-agent-runs.service");
-const sessions_service_1 = require("../sessions/sessions.service");
-const system_prompts_service_1 = require("../system-prompts/system-prompts.service");
-const tool_schema_service_1 = require("../llm-orchestration/tool-schema.service");
-const history_compression_service_1 = require("../llm-orchestration/history-compression.service");
-const application_state_service_1 = require("../application-state/application-state.service");
-const mcp_tool_action_handler_1 = require("../llm-orchestration/action-handlers/mcp-tool-action.handler");
-const mcp_service_1 = require("../mcp/mcp.service");
-const llm_orchestration_interfaces_1 = require("../llm-orchestration/llm-orchestration.interfaces");
-const typeorm_1 = require("@nestjs/typeorm");
-const typeorm_2 = require("typeorm");
-const session_input_entity_1 = require("../core-entities/session-input.entity");
-const ai_action_entity_1 = require("../core-entities/ai-action.entity");
-const ai_actions_service_1 = require("../ai-actions/ai-actions.service");
-const execution_logs_service_1 = require("../execution-logs/execution-logs.service");
-const events_gateway_1 = require("../events/events.gateway");
-const session_input_context_service_1 = require("../session-inputs/session-input-context.service");
-const MAX_ITERATIONS = 1000;
-let SubAgentRunner = SubAgentRunner_1 = class SubAgentRunner {
-    constructor(subAgentsService, subAgentRunsService, sessionsService, applicationStateService, executionLogsService, eventsGateway, llmProvider, moduleRef, sessionInputsRepository, aiActionsRepository) {
-        this.subAgentsService = subAgentsService;
-        this.subAgentRunsService = subAgentRunsService;
-        this.sessionsService = sessionsService;
-        this.applicationStateService = applicationStateService;
-        this.executionLogsService = executionLogsService;
-        this.eventsGateway = eventsGateway;
-        this.llmProvider = llmProvider;
-        this.moduleRef = moduleRef;
-        this.sessionInputsRepository = sessionInputsRepository;
-        this.aiActionsRepository = aiActionsRepository;
-        this.logger = new common_1.Logger(SubAgentRunner_1.name);
-    }
-    getHandlerRegistry() {
-        return this.moduleRef.get('ACTION_HANDLER_REGISTRY', { strict: false });
-    }
-    getToolSchemaService() {
-        return this.moduleRef.get(tool_schema_service_1.ToolSchemaService, { strict: false });
-    }
-    getHistoryCompressionService() {
-        return this.moduleRef.get(history_compression_service_1.HistoryCompressionService, { strict: false });
-    }
-    getSystemPromptsService() {
-        return this.moduleRef.get(system_prompts_service_1.SystemPromptsService, { strict: false });
-    }
-    getMcpService() {
-        return this.moduleRef.get(mcp_service_1.McpService, { strict: false });
-    }
-    getSessionInputContextService() {
-        return this.moduleRef.get(session_input_context_service_1.SessionInputContextService, { strict: false });
-    }
-    async runAgent(agentName, prompt, parentSessionId, options) {
-        this.logger.log(`runAgent called for "${agentName}" from parent session ${parentSessionId}`);
-        const subAgent = await this.subAgentsService.getAgentByName(agentName);
-        if (!subAgent) {
-            const availableAgents = (await this.subAgentsService.findActive())
-                .map((a) => a.name)
-                .join(', ');
-            return {
-                content: `Sub-agent "${agentName}" not found or not active. Available: ${availableAgents}`,
-                success: false,
-                iterations: 0,
-                childSessionId: '',
-            };
-        }
-        const startTime = Date.now();
-        const handlerRegistry = this.getHandlerRegistry();
-        const toolSchemaService = this.getToolSchemaService();
-        const historyCompressionService = this.getHistoryCompressionService();
-        const systemPromptsService = this.getSystemPromptsService();
-        const sessionInputContextService = this.getSessionInputContextService();
-        let childSession;
-        let existingHistory = [];
-        if (options?.sessionId) {
-            childSession = await this.sessionsService.findOne(options.sessionId);
-            if (!childSession) {
-                return {
-                    content: `Session "${options.sessionId}" not found. Cannot reuse a non-existent session.`,
-                    success: false,
-                    iterations: 0,
-                    childSessionId: options.sessionId,
-                };
-            }
-            this.logger.log(`Reusing existing session ${childSession.id} for sub-agent "${agentName}"`);
-            const existingInputs = await this.sessionInputsRepository.find({
-                where: { session: { id: childSession.id }, is_discarded: false },
-                order: { sequence_number: 'ASC' },
-            });
-            existingHistory = this.reconstructHistory(existingInputs);
-        }
-        else {
-            childSession = await this.sessionsService.create({
-                session_title: `Sub-Agent: ${agentName}`,
-                system_prompt_id: subAgent.system_prompt_id || undefined,
-                default_initial_context_template_id: subAgent.context_template_id || undefined,
-                default_followup_context_template_id: subAgent.followup_context_template_id || undefined,
-                model_id: subAgent.model_id || undefined,
-                sub_agent_id: subAgent.id,
-                parent_session_id: parentSessionId,
-            });
-            this.logger.log(`Created child session ${childSession.id} for sub-agent "${agentName}"`);
-        }
-        await this.subAgentRunsService.create({
-            parent_session_id: parentSessionId,
-            child_session_id: childSession.id,
-            sub_agent_id: subAgent.id,
-            agent_name: agentName,
-            initial_prompt: prompt,
-        });
-        let systemInstruction = '';
-        if (subAgent.system_prompt_id) {
-            const rendered = await systemPromptsService.findOneWithSession(subAgent.system_prompt_id, childSession.id, childSession.session_title);
-            systemInstruction = rendered?.prompt_content || '';
-        }
-        else {
-            const defaultPrompt = await systemPromptsService.findDefaultWithSession(childSession.id, childSession.session_title);
-            systemInstruction = defaultPrompt?.prompt_content || '';
-        }
-        const mcpService = this.getMcpService();
-        let tools;
-        this.logger.log(`Sub-agent "${agentName}" tool config: enabled_tools=${JSON.stringify(subAgent.enabled_tools)}, enabled_mcp_tools=${JSON.stringify(subAgent.enabled_mcp_tools)}`);
-        if (subAgent.enabled_tools === null) {
-            tools = toolSchemaService.generateToolDefinitions(handlerRegistry);
-            this.logger.log(`Sub-agent "${agentName}" using ALL built-in tools (${handlerRegistry.size} available).`);
-        }
-        else if (subAgent.enabled_tools.length > 0) {
-            const filteredHandlers = new Map();
-            for (const toolName of subAgent.enabled_tools) {
-                const handler = handlerRegistry.get(toolName);
-                if (handler) {
-                    filteredHandlers.set(toolName, handler);
-                }
-            }
-            tools = toolSchemaService.generateToolDefinitions(filteredHandlers);
-            this.logger.log(`Sub-agent "${agentName}" using ${filteredHandlers.size}/${subAgent.enabled_tools.length} filtered built-in tools.`);
-        }
-        else {
-            this.logger.log(`Sub-agent "${agentName}" has NO built-in tools (enabled_tools is empty array).`);
-        }
-        if (subAgent.enabled_mcp_tools !== null &&
-            subAgent.enabled_mcp_tools !== undefined) {
-            this.logger.log(`Sub-agent "${agentName}" entering MCP tool block (enabled_mcp_tools="${subAgent.enabled_mcp_tools}").`);
-            try {
-                const allMcpTools = await mcpService.getActiveMcpToolDefinitions();
-                this.logger.log(`Sub-agent "${agentName}" found ${allMcpTools.length} active MCP tool definitions: [${allMcpTools.map((t) => t.function.name).join(', ')}]`);
-                if (allMcpTools.length > 0) {
-                    let enabledMcpToolNames;
-                    if (subAgent.enabled_mcp_tools === 'all') {
-                        enabledMcpToolNames = allMcpTools.map((t) => t.function.name);
-                        this.logger.log(`Sub-agent "${agentName}" MCP mode: ALL — enabling ${enabledMcpToolNames.length} MCP tools.`);
-                    }
-                    else {
-                        const parsedMcpTools = this.subAgentsService.parseEnabledMcpTools(subAgent.enabled_mcp_tools) || [];
-                        const allToolNames = allMcpTools.map((t) => t.function.name);
-                        this.logger.log(`Sub-agent "${agentName}" MCP mode: SPECIFIC — parsedEnabledMcpTools="${subAgent.enabled_mcp_tools}" → parsed=${JSON.stringify(parsedMcpTools)}, allToolNames=${JSON.stringify(allToolNames)}`);
-                        enabledMcpToolNames = this.resolveMcpToolNames(parsedMcpTools, allToolNames);
-                        this.logger.log(`Sub-agent "${agentName}" MCP mode: SPECIFIC — resolved to ${enabledMcpToolNames.length} MCP tools: [${enabledMcpToolNames.join(', ')}]`);
-                    }
-                    const filteredMcpTools = allMcpTools.filter((tool) => enabledMcpToolNames.includes(tool.function.name));
-                    this.logger.log(`Sub-agent "${agentName}" filtered to ${filteredMcpTools.length} MCP tool definitions: [${filteredMcpTools.map((t) => t.function.name).join(', ')}]`);
-                    if (filteredMcpTools.length > 0) {
-                        tools = [...(tools || []), ...filteredMcpTools];
-                        this.logger.log(`Added ${filteredMcpTools.length} MCP tool definitions for sub-agent "${agentName}".`);
-                    }
-                    else {
-                        this.logger.warn(`Sub-agent "${agentName}" has MCP tools enabled but 0 matched after filtering. enabled_mcp_tools="${subAgent.enabled_mcp_tools}"`);
-                    }
-                }
-                else {
-                    this.logger.log(`Sub-agent "${agentName}" has MCP tools enabled but 0 active MCP tool definitions found on server.`);
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Failed to load MCP tool definitions for sub-agent "${agentName}": ${error.message}. Continuing without MCP tools.`);
-            }
-        }
-        else {
-            this.logger.log(`Sub-agent "${agentName}" skipping MCP tools (enabled_mcp_tools is ${subAgent.enabled_mcp_tools === null ? 'null' : 'undefined'}).`);
-        }
-        const builtInToolCount = tools
-            ? tools.filter((t) => !t.function.name.includes('__')).length
-            : 0;
-        const mcpToolCount = tools
-            ? tools.filter((t) => t.function.name.includes('__')).length
-            : 0;
-        this.logger.log(`Sub-agent "${agentName}" total tools for LLM: ${tools?.length ?? 0} (built-in: ${builtInToolCount}, MCP: ${mcpToolCount})`);
-        let initialUserMessage;
-        let generatedContextString = null;
-        let contextTemplate = null;
-        if (subAgent.context_template_id) {
-            try {
-                contextTemplate = subAgent.contextTemplate || null;
-                let adHocContextDefinition;
-                if (options?.masterContextDefinition) {
-                    adHocContextDefinition = JSON.stringify(options.masterContextDefinition);
-                }
-                else if (options?.contextFiles && options.contextFiles.length > 0) {
-                    adHocContextDefinition = JSON.stringify({
-                        files: options.contextFiles,
-                    });
-                }
-                const generatedContext = await sessionInputContextService.generateContext({
-                    user_prompt: prompt,
-                    context_template_id: subAgent.context_template_id,
-                    ad_hoc_context_definition: adHocContextDefinition,
-                    execution_strategy: 'auto_apply',
-                }, contextTemplate);
-                initialUserMessage = generatedContext;
-                generatedContextString = generatedContext;
-                this.logger.log(`Sub-agent "${agentName}" initial prompt rendered through context template "${contextTemplate?.template_name || subAgent.context_template_id}".`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to render context template for sub-agent "${agentName}": ${error.message}. Falling back to raw prompt.`, error.stack);
-                initialUserMessage = prompt;
-            }
-        }
-        else {
-            initialUserMessage = prompt;
-        }
-        const history = [
-            ...existingHistory,
-            { role: 'user', parts: [{ text: initialUserMessage }] },
-        ];
-        await this.sessionInputsRepository.save(this.sessionInputsRepository.create({
-            session: { id: childSession.id },
-            role: 'user',
-            user_prompt: prompt,
-            generated_context_string: generatedContextString,
-            execution_strategy: 'auto_apply',
-            context_template_id: subAgent.context_template_id || undefined,
-            ...(subAgent.context_template_id
-                ? { contextTemplate: { id: subAgent.context_template_id } }
-                : {}),
-        }));
-        this.eventsGateway.sendToAll('refresh-ui', {
-            sessionId: childSession.id,
-        });
-        this.eventsGateway.sendToAll('refresh-ui', {
-            sessionId: parentSessionId,
-        });
-        let iterations = 0;
-        let finalContent = '';
-        let success = true;
-        await this.sessionsService.update(childSession.id, { is_running: true });
-        this.eventsGateway.sendToAll('llm-generation-started', {
-            sessionInputId: `subagent-${childSession.id}`,
-            sessionId: childSession.id,
-            isStreaming: false,
-        });
-        try {
-            const abortController = new AbortController();
-            const executionStrategy = await this.applicationStateService.getExecutionStrategy();
-            while (iterations < MAX_ITERATIONS) {
-                iterations++;
-                this.logger.log(`Sub-agent "${agentName}" iteration ${iterations}/${MAX_ITERATIONS}`);
-                const compressedHistory = await historyCompressionService.compress(history);
-                const llmResponse = await this.callWithRetry({
-                    prompt: '',
-                    systemInstruction,
-                    history: compressedHistory,
-                    modelId: childSession.model_id || undefined,
-                    tools,
-                    abortController,
-                }, childSession.id);
-                if (!llmResponse.text &&
-                    (!llmResponse.tool_calls || llmResponse.tool_calls.length === 0)) {
-                    this.logger.log(`Sub-agent "${agentName}" returned empty response with no tool calls. Ending loop.`);
-                    finalContent = llmResponse.text || '(No response from sub-agent)';
-                    break;
-                }
-                const modelMessage = {
-                    role: 'model',
-                    parts: [{ text: llmResponse.text || '' }],
-                };
-                if (llmResponse.tool_calls && llmResponse.tool_calls.length > 0) {
-                    modelMessage.tool_calls = llmResponse.tool_calls;
-                }
-                if (llmResponse.thoughts) {
-                    modelMessage.thoughts = llmResponse.thoughts;
-                }
-                history.push(modelMessage);
-                const modelInput = this.sessionInputsRepository.create({
-                    session: { id: childSession.id },
-                    role: 'model',
-                    raw_llm_response: llmResponse.text || '',
-                    tool_calls: llmResponse.tool_calls
-                        ? JSON.stringify(llmResponse.tool_calls)
-                        : null,
-                    thoughts: llmResponse.thoughts || null,
-                    input_token_count: llmResponse.usage?.inputTokens || null,
-                    output_token_count: llmResponse.usage?.outputTokens || null,
-                    cached_token_count: llmResponse.usage?.cachedTokens || null,
-                    execution_strategy: 'auto_apply',
-                });
-                await this.sessionInputsRepository.save(modelInput);
-                this.eventsGateway.sendToAll('refresh-ui', {
-                    sessionId: childSession.id,
-                });
-                this.eventsGateway.sendToAll('refresh-ui', {
-                    sessionId: parentSessionId,
-                });
-                if (!llmResponse.tool_calls || llmResponse.tool_calls.length === 0) {
-                    this.logger.log(`Sub-agent "${agentName}" returned text with no tool calls. Ending loop.`);
-                    finalContent = llmResponse.text || '';
-                    break;
-                }
-                const executionContext = new llm_orchestration_interfaces_1.PlanExecutionContext();
-                executionContext.session_id = childSession.id;
-                executionContext.system_prompt_id = subAgent.system_prompt_id || null;
-                let shouldBreak = false;
-                const toolResults = [];
-                for (const toolCall of llmResponse.tool_calls) {
-                    const toolName = toolCall.function.name;
-                    const args = typeof toolCall.function.arguments === 'string'
-                        ? JSON.parse(toolCall.function.arguments)
-                        : toolCall.function.arguments;
-                    this.logger.log(`Sub-agent "${agentName}" calling tool: ${toolName}`);
-                    if (toolName === 'final') {
-                        const plainText = args.plain || args.content || '';
-                        finalContent = plainText;
-                        shouldBreak = true;
-                        const actionEntity = this.aiActionsRepository.create({
-                            input_id: modelInput.id,
-                            sessionInput: { id: modelInput.id },
-                            action_type: 'final',
-                            status: ai_actions_service_1.AIActionStatus.CONFIRMED_KEPT,
-                            order_of_execution: toolResults.length,
-                            original_content_for_revert: null,
-                            tool_call_id: toolCall.id || null,
-                            plain: plainText,
-                            selections: args.selections || null,
-                        });
-                        await this.aiActionsRepository.save(actionEntity);
-                        toolResults.push({
-                            toolCallId: toolCall.id || '',
-                            toolName,
-                            result: 'Task completed.',
-                        });
-                        continue;
-                    }
-                    let handler = handlerRegistry.get(toolName);
-                    if (!handler) {
-                        const mcpMatch = toolName.match(/^([^_]+)__(.+)$/);
-                        if (mcpMatch) {
-                            const [, serverName, toolNameRaw] = mcpMatch;
-                            handler = new mcp_tool_action_handler_1.McpToolActionHandler(serverName, toolNameRaw, mcpService, '');
-                        }
-                    }
-                    if (!handler) {
-                        this.logger.warn(`No handler found for tool: ${toolName}. Skipping.`);
-                        const errorMsg = `Tool '${toolName}' is not a valid tool. Please use a valid tool.`;
-                        toolResults.push({
-                            toolCallId: toolCall.id || '',
-                            toolName,
-                            result: errorMsg,
-                        });
-                        const actionEntity = this.aiActionsRepository.create({
-                            input_id: modelInput.id,
-                            sessionInput: { id: modelInput.id },
-                            action_type: toolName,
-                            status: ai_actions_service_1.AIActionStatus.EXECUTION_FAILED,
-                            order_of_execution: toolResults.length,
-                            original_content_for_revert: null,
-                            tool_call_id: toolCall.id || null,
-                        });
-                        await this.aiActionsRepository.save(actionEntity);
-                        continue;
-                    }
-                    let result;
-                    try {
-                        result = await handler.execute(args, executionContext);
-                    }
-                    catch (error) {
-                        this.logger.error(`Handler for ${toolName} failed: ${error.message}`);
-                        result = {
-                            status: 'FAILURE',
-                            summary: `An unexpected error occurred: ${error.message}`,
-                            error_message: error.message,
-                            persisted_args: args,
-                            execution_log: { output: '', error_message: error.message },
-                        };
-                    }
-                    const successStatus = this.getSuccessStatusForStrategy(executionStrategy);
-                    const actionEntity = this.aiActionsRepository.create({
-                        input_id: modelInput.id,
-                        sessionInput: { id: modelInput.id },
-                        action_type: toolName,
-                        status: result.status === 'SUCCESS'
-                            ? successStatus
-                            : ai_actions_service_1.AIActionStatus.EXECUTION_FAILED,
-                        order_of_execution: toolResults.length,
-                        original_content_for_revert: result.original_content_for_revert || null,
-                        tool_call_id: toolCall.id || null,
-                        ...result.persisted_args,
-                    });
-                    const savedAction = await this.aiActionsRepository.save(actionEntity);
-                    await this.executionLogsService.createLog({
-                        action_id: savedAction.id,
-                        output: result.execution_log.output,
-                        error_message: result.execution_log.error_message,
-                    });
-                    const output = result.execution_log?.output || '';
-                    const error = result.execution_log?.error_message || result.error_message || '';
-                    const combinedResult = error
-                        ? `${output}\n\nError: ${error}`.trim()
-                        : output;
-                    toolResults.push({
-                        toolCallId: toolCall.id || '',
-                        toolName,
-                        result: combinedResult,
-                    });
-                    if (executionContext.flags.should_halt) {
-                        this.logger.log(`Execution context halted. Ending sub-agent loop.`);
-                        shouldBreak = true;
-                        break;
-                    }
-                }
-                let followupUserMessage;
-                let followupGeneratedContext = null;
-                if (subAgent.followup_context_template_id && !shouldBreak) {
-                    try {
-                        const followupTemplate = subAgent.followupContextTemplate || null;
-                        const commandOutputs = toolResults.map((tr) => `// Tool: ${tr.toolName}\n\`\`\`\n${tr.result}\n\`\`\``);
-                        const adHocContextDefinition = JSON.stringify({
-                            command_outputs: commandOutputs,
-                        });
-                        followupGeneratedContext =
-                            await sessionInputContextService.generateContext({
-                                user_prompt: '',
-                                context_template_id: subAgent.followup_context_template_id,
-                                ad_hoc_context_definition: adHocContextDefinition,
-                                execution_strategy: 'auto_apply',
-                            }, followupTemplate);
-                        followupUserMessage = followupGeneratedContext;
-                        this.logger.log(`Sub-agent "${agentName}" follow-up rendered through context template "${followupTemplate?.template_name || subAgent.followup_context_template_id}".`);
-                    }
-                    catch (error) {
-                        this.logger.error(`Failed to render follow-up context template for sub-agent "${agentName}": ${error.message}. Using raw tool results.`, error.stack);
-                        followupUserMessage = toolResults
-                            .map((tr) => `Result from ${tr.toolName}:\n${tr.result}`)
-                            .join('\n\n');
-                    }
-                }
-                else {
-                    followupUserMessage = toolResults
-                        .map((tr) => `Result from ${tr.toolName}:\n${tr.result}`)
-                        .join('\n\n');
-                }
-                for (const tr of toolResults) {
-                    history.push({
-                        role: 'tool',
-                        tool_call_id: tr.toolCallId,
-                        tool_name: tr.toolName,
-                        parts: [{ text: tr.result }],
-                    });
-                }
-                if (subAgent.followup_context_template_id && followupUserMessage) {
-                    history.push({
-                        role: 'user',
-                        parts: [{ text: followupUserMessage }],
-                    });
-                }
-                await this.sessionInputsRepository.save(this.sessionInputsRepository.create({
-                    session: { id: childSession.id },
-                    role: 'user',
-                    user_prompt: '',
-                    generated_context_string: followupGeneratedContext,
-                    execution_strategy: 'auto_apply',
-                    raw_llm_response: null,
-                    tool_calls: JSON.stringify(toolResults.map((tr) => ({
-                        id: tr.toolCallId,
-                        type: 'function',
-                        function: { name: tr.toolName, arguments: '{}' },
-                    }))),
-                    ...(subAgent.followup_context_template_id
-                        ? { context_template_id: subAgent.followup_context_template_id }
-                        : {}),
-                }));
-                this.eventsGateway.sendToAll('refresh-ui', {
-                    sessionId: childSession.id,
-                });
-                this.eventsGateway.sendToAll('refresh-ui', {
-                    sessionId: parentSessionId,
-                });
-                if (shouldBreak) {
-                    break;
-                }
-            }
-            if (iterations >= MAX_ITERATIONS) {
-                this.logger.warn(`Sub-agent "${agentName}" reached max iterations (${MAX_ITERATIONS}).`);
-                if (!finalContent) {
-                    finalContent =
-                        'Sub-agent reached maximum iterations without completing.';
-                    success = false;
-                }
-            }
-            await this.subAgentRunsService.markCompleted(childSession.id, finalContent.substring(0, 5000));
-            await this.sessionsService.update(childSession.id, { is_running: false });
-            this.eventsGateway.sendToAll('llm-generation-ended', {
-                sessionInputId: `subagent-${childSession.id}`,
-                sessionId: childSession.id,
-            });
-            this.eventsGateway.sendToAll('refresh-ui', {
-                sessionId: childSession.id,
-            });
-            this.eventsGateway.sendToAll('refresh-ui', {
-                sessionId: parentSessionId,
-            });
-        }
-        catch (error) {
-            this.logger.error(`Sub-agent "${agentName}" failed: ${error.message}`, error.stack);
-            success = false;
-            finalContent = `Sub-agent "${agentName}" encountered an error: ${error.message}`;
-            await this.subAgentRunsService.markFailed(childSession.id, error.message);
-            await this.sessionsService.update(childSession.id, { is_running: false });
-            this.eventsGateway.sendToAll('llm-generation-ended', {
-                sessionInputId: `subagent-${childSession.id}`,
-                sessionId: childSession.id,
-                error: error.message,
-            });
-            this.eventsGateway.sendToAll('refresh-ui', {
-                sessionId: childSession.id,
-            });
-            this.eventsGateway.sendToAll('refresh-ui', {
-                sessionId: parentSessionId,
-            });
-        }
-        const durationMs = Date.now() - startTime;
-        this.logger.log(`Sub-agent "${agentName}" completed in ${durationMs}ms, ${iterations} iterations, success: ${success}`);
-        return {
-            content: finalContent,
-            success,
-            iterations,
-            childSessionId: childSession.id,
-        };
-    }
-    resolveMcpToolNames(entries, allActiveMcpToolNames) {
-        const result = [];
-        for (const entry of entries) {
-            for (const toolName of allActiveMcpToolNames) {
-                if (toolName === entry || toolName.startsWith(entry + '__')) {
-                    if (!result.includes(toolName)) {
-                        result.push(toolName);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    reconstructHistory(inputs) {
-        const history = [];
-        for (const input of inputs) {
-            if (input.role === 'user') {
-                const content = {
-                    role: 'user',
-                    parts: [
-                        {
-                            text: input.generated_context_string ||
-                                input.user_prompt ||
-                                input.raw_llm_response ||
-                                '',
-                        },
-                    ],
-                };
-                history.push(content);
-            }
-            else if (input.role === 'model') {
-                const content = {
-                    role: 'model',
-                    parts: [{ text: input.raw_llm_response || '' }],
-                };
-                if (input.tool_calls) {
-                    try {
-                        const parsed = JSON.parse(input.tool_calls);
-                        if (Array.isArray(parsed)) {
-                            content.tool_calls = parsed;
-                        }
-                    }
-                    catch {
-                    }
-                }
-                history.push(content);
-            }
-        }
-        return history;
-    }
-    async callWithRetry(request, sessionId) {
-        const retryEnabled = await this.applicationStateService.getLlmRetryEnabled();
-        const maxAttempts = await this.applicationStateService.getLlmRetryMaxAttempts();
-        let lastError;
-        let attempt = 1;
-        while (attempt <= maxAttempts) {
-            try {
-                if (attempt > 1) {
-                    this.logger.log(`Retry attempt ${attempt}/${maxAttempts} for sub-agent session ${sessionId}`);
-                }
-                return await this.llmProvider.generateContent({
-                    ...request,
-                    abortController: request.abortController,
-                });
-            }
-            catch (error) {
-                lastError = error;
-                if (error.name === 'AbortError' || error.code === 'ABORT_ERR') {
-                    throw error;
-                }
-                const shouldRetry = retryEnabled && attempt < maxAttempts && this.isRetryableError(error);
-                if (!shouldRetry) {
-                    throw error;
-                }
-                const backoffMs = Math.pow(2, attempt - 1) * 1000;
-                this.logger.log(`LLM call failed (attempt ${attempt}/${maxAttempts}): ${error.message}. Retrying in ${backoffMs}ms...`);
-                await new Promise((resolve) => setTimeout(resolve, backoffMs));
-                attempt++;
-            }
-        }
-        throw lastError;
-    }
-    isRetryableError(error) {
-        const errorMessage = error.message?.toLowerCase() || '';
-        const errorCode = error.code;
-        const status = error.status;
-        if (error.name === 'AbortError' || error.code === 'ABORT_ERR')
-            return false;
-        const networkErrors = [
-            'ECONNRESET',
-            'ETIMEDOUT',
-            'ENOTFOUND',
-            'ENETUNREACH',
-            'ECONNREFUSED',
-        ];
-        if (errorCode && networkErrors.includes(errorCode))
-            return true;
-        if (status === 429 ||
-            errorMessage.includes('rate limit') ||
-            errorMessage.includes('too many requests'))
-            return true;
-        if (status >= 500 && status < 600)
-            return true;
-        if (errorMessage.includes('empty response') ||
-            errorMessage.includes('timeout'))
-            return true;
-        return false;
-    }
-    getSuccessStatusForStrategy(strategy) {
-        switch (strategy) {
-            case 'auto_apply':
-                return ai_actions_service_1.AIActionStatus.CONFIRMED_KEPT;
-            case 'review_first':
-            case 'apply_revert':
-            default:
-                return ai_actions_service_1.AIActionStatus.APPLIED_PENDING_REVIEW;
-        }
-    }
-};
-exports.SubAgentRunner = SubAgentRunner;
-exports.SubAgentRunner = SubAgentRunner = SubAgentRunner_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(6, (0, common_1.Inject)(llm_provider_interface_1.LLM_PROVIDER)),
-    __param(8, (0, typeorm_1.InjectRepository)(session_input_entity_1.SessionInput)),
-    __param(9, (0, typeorm_1.InjectRepository)(ai_action_entity_1.AIAction)),
-    __metadata("design:paramtypes", [sub_agents_service_1.SubAgentsService,
-        sub_agent_runs_service_1.SubAgentRunsService,
-        sessions_service_1.SessionsService,
-        application_state_service_1.ApplicationStateService,
-        execution_logs_service_1.ExecutionLogsService,
-        events_gateway_1.EventsGateway, Object, core_1.ModuleRef,
-        typeorm_2.Repository,
-        typeorm_2.Repository])
-], SubAgentRunner);
-//# sourceMappingURL=sub-agent-runner.service.js.map