@robota-sdk/agent-core 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/services/execution-service.js

@@ -1,29 +1,17 @@
-import { ToolExecutionService, TOOL_EVENT_PREFIX } from './tool-execution-service';
+import { ToolExecutionService } from './tool-execution-service';
 import { createLogger } from '../utils/logger';
-import { isDefaultEventService, bindWithOwnerPath } from './event-service';
+// Re-export constants for public API compatibility
+export { EXECUTION_EVENTS, EXECUTION_EVENT_PREFIX } from './execution-constants';
+import { EXECUTION_EVENTS } from './execution-constants';
+import { PREVIEW_LENGTH, ID_RADIX, ID_RANDOM_LENGTH, } from './execution-types';
+import { ExecutionEventEmitter } from './execution-event-emitter';
+import { callPluginHook } from './plugin-hook-dispatcher';
+import { executeStream as executeStreamFn } from './execution-stream';
+import { executeRound } from './execution-round';
 /**
- * ExecutionService owned events
- * Local event names only (no dots). Full names are composed at emit time.
- */
-export const EXECUTION_EVENTS = {
-    START: 'start',
-    COMPLETE: 'complete',
-    ERROR: 'error',
-    ASSISTANT_MESSAGE_START: 'assistant_message_start',
-    ASSISTANT_MESSAGE_COMPLETE: 'assistant_message_complete',
-    USER_MESSAGE: 'user_message',
-    TOOL_RESULTS_TO_LLM: 'tool_results_to_llm',
-    TOOL_RESULTS_READY: 'tool_results_ready'
-};
-export const EXECUTION_EVENT_PREFIX = 'execution';
-// Type guard to check if error has execution properties
-function isExecutionError(error) {
-    return 'executionId' in error || 'toolName' in error;
-}
-/**
- * Service that orchestrates the entire execution pipeline
- * Coordinates AI provider execution, tool execution service, and plugin lifecycle
- * Uses centralized conversation history management
+ * Service that orchestrates the entire execution pipeline.
+ * Coordinates AI provider execution, tool execution service, and plugin lifecycle.
+ * Uses centralized conversation history management.
  */
 export class ExecutionService {
     toolExecutionService;
@@ -32,15 +20,9 @@ export class ExecutionService {
     conversationHistory;
     plugins = [];
     logger;
-    baseEventService;
-    executionContext; // 🎯 [CONTEXT-INJECTION] Parent execution context
-    ownerPathBase;
-    toolEventServices;
-    agentOwnerPathBase;
-    // Path-only: remove lastResponseExecutionId tracking
-    lastResponseExecutionId;
-    constructor(aiProviders, tools, conversationHistory, eventService, executionContext // 🎯 [CONTEXT-INJECTION] Accept parent context
-    ) {
+    eventEmitter;
+    cacheService;
+    constructor(aiProviders, tools, conversationHistory, eventService, executionContext, cacheService) {
         this.toolExecutionService = new ToolExecutionService(tools);
         this.aiProviders = aiProviders;
         this.tools = tools;
@@ -50,30 +32,31 @@ export class ExecutionService {
         if (!eventService) {
             throw new Error('[EXECUTION] EventService is required');
         }
-        this.baseEventService = eventService;
-        this.executionContext = executionContext; // 🎯 [CONTEXT-INJECTION] Store parent context
-        this.ownerPathBase = this.buildBaseOwnerPath(executionContext);
-        this.toolEventServices = new Map();
-        this.agentOwnerPathBase = [];
+        this.eventEmitter = new ExecutionEventEmitter(eventService, this.logger, executionContext);
+        this.cacheService = cacheService;
     }
-    /**
-     * Register a plugin
-     */
+    /** Register a plugin */
     registerPlugin(plugin) {
-        this.plugins.push(plugin);
+        const pluginPriority = plugin.priority ?? 0;
+        const insertIndex = this.plugins.findIndex((p) => (p.priority ?? 0) < pluginPriority);
+        if (insertIndex === -1) {
+            this.plugins.push(plugin);
+        }
+        else {
+            this.plugins.splice(insertIndex, 0, plugin);
+        }
         this.logger.debug('Plugin registered', {
             pluginName: plugin.name,
+            priority: pluginPriority,
             hasBeforeRun: typeof plugin.beforeRun,
             hasAfterRun: typeof plugin.afterRun,
             hasBeforeProviderCall: typeof plugin.beforeProviderCall,
-            hasAfterProviderCall: typeof plugin.afterProviderCall
+            hasAfterProviderCall: typeof plugin.afterProviderCall,
         });
     }
-    /**
-     * Remove a plugin
-     */
+    /** Remove a plugin */
     removePlugin(pluginName) {
-        const index = this.plugins.findIndex(p => p.name === pluginName);
+        const index = this.plugins.findIndex((p) => p.name === pluginName);
         if (index !== -1) {
             this.plugins.splice(index, 1);
             this.logger.debug('Plugin removed', { pluginName });
@@ -81,24 +64,16 @@ export class ExecutionService {
         }
         return false;
     }
-    /**
-     * Get a plugin by name
-     */
+    /** Get a plugin by name */
     getPlugin(pluginName) {
-        return this.plugins.find(p => p.name === pluginName) ?? null;
+        return this.plugins.find((p) => p.name === pluginName);
     }
-    /**
-     * Get all registered plugins
-     */
+    /** Get all registered plugins */
     getPlugins() {
         return [...this.plugins];
     }
-    /**
-     * Execute the full pipeline with centralized history management
-     */
+    /** Execute the full pipeline with centralized history management */
     async execute(input, messages, config, context) {
-        // [EXECUTION-DEBUG] ExecutionService.execute entrypoint
-        // Avoid console usage; use injected logger only.
         const executionId = this.generateExecutionId();
         const startTime = new Date();
         const conversationId = this.requireConversationId(context, 'execute');
@@ -110,1128 +85,246 @@ export class ExecutionService {
             conversationId,
             ...(context?.sessionId && { sessionId: context.sessionId }),
             ...(context?.userId && { userId: context.userId }),
-            ...(context?.metadata && { metadata: context.metadata })
+            ...(context?.metadata && { metadata: context.metadata }),
         };
-        this.prepareOwnerPathBases(conversationId);
+        this.eventEmitter.prepareOwnerPathBases(conversationId);
         this.logger.debug('Starting execution pipeline', {
             executionId,
             conversationId,
             messageCount: messages.length,
-            hasContext: !!context
+            hasContext: !!context,
         });
-        // Get current provider info and tools for rich data
-        const currentInfo = this.aiProviders.getCurrentProvider();
-        const provider = currentInfo ? this.aiProviders.getProvider(currentInfo.provider) : null;
-        if (!currentInfo || !currentInfo.provider || !provider) {
-            throw new Error('[EXECUTION] Provider is required');
-        }
-        const availableTools = this.tools.getTools();
-        // Emit execution start event
-        const rootId = conversationId;
-        const aiProviderInfo = {
-            providerName: currentInfo.provider,
-            model: config.defaultModel.model,
-            temperature: config.defaultModel.temperature,
-            maxTokens: config.defaultModel.maxTokens
-        };
-        const toolsInfo = availableTools.map((tool) => {
-            const paramSchema = tool.parameters;
-            const props = paramSchema?.properties;
-            if (!tool.description || tool.description.length === 0) {
-                throw new Error(`[EXECUTION] Tool "${tool.name}" is missing description`);
-            }
-            return {
-                name: tool.name,
-                description: tool.description,
-                parameters: props && typeof props === 'object' ? Object.keys(props) : []
-            };
-        });
-        this.emitExecution(EXECUTION_EVENTS.START, {
-            parameters: {
-                input,
-                agentConfiguration: aiProviderInfo,
-                availableTools: toolsInfo,
-                toolCount: toolsInfo.length,
-                hasTools: toolsInfo.length > 0,
-                systemMessage: config.defaultModel.systemMessage,
-                provider: config.defaultModel.provider,
-                model: config.defaultModel.model,
-                temperature: config.defaultModel.temperature,
-                maxTokens: config.defaultModel.maxTokens
-            },
-            metadata: {
-                method: 'execute',
-                inputLength: input.length,
-                messageCount: messages.length,
-                aiProvider: aiProviderInfo.providerName,
-                model: aiProviderInfo.model,
-                toolsAvailable: toolsInfo.map((t) => t.name),
-                agentCapabilities: {
-                    canUseTools: toolsInfo.length > 0,
-                    supportedActions: toolsInfo.map((t) => t.name)
-                }
-            }
-        }, rootId, executionId);
+        const resolved = this.resolveProviderAndTools(config);
+        this.eventEmitter.emitExecutionStartEvent(input, config, messages, resolved, conversationId, executionId);
         try {
-            // Get conversation session for this conversation
-            const conversationSession = this.conversationHistory.getConversationSession(conversationId);
-            // Initialize conversation history with existing messages if this is first time
-            if (conversationSession.getMessageCount() === 0 && messages.length > 0) {
-                // Add all messages in the order they appear in the messages array
-                // This preserves the original order including multiple system messages
-                messages.forEach(msg => {
-                    if (msg.role === 'user') {
-                        conversationSession.addUserMessage(msg.content, msg.metadata);
-                    }
-                    else if (msg.role === 'assistant') {
-                        conversationSession.addAssistantMessage(msg.content, msg.toolCalls, msg.metadata);
-                    }
-                    else if (msg.role === 'system') {
-                        conversationSession.addSystemMessage(msg.content, msg.metadata);
-                    }
-                    else if (msg.role === 'tool') {
-                        const toolName = msg.metadata?.['toolName'];
-                        if (typeof toolName !== 'string' || toolName.length === 0) {
-                            throw new Error('[EXECUTION] Tool message missing toolName metadata');
-                        }
-                        conversationSession.addToolMessageWithId(msg.content, msg.toolCallId, toolName, msg.metadata);
-                    }
-                });
-            }
-            // Add system message from config if provided and not already present
-            // This allows for additional system messages during execution but prevents duplicates
-            if (config.systemMessage) {
-                const existingMessages = conversationSession.getMessages();
-                const hasConfigSystemMessage = existingMessages.some(msg => msg.role === 'system' && msg.content === config.systemMessage);
-                if (!hasConfigSystemMessage) {
-                    conversationSession.addSystemMessage(config.systemMessage, { executionId });
-                }
-            }
-            // Only add the current input if it's not already the last message in the conversation
-            const existingMessages = conversationSession.getMessages();
-            const lastMessage = existingMessages[existingMessages.length - 1];
-            const shouldAddInput = !lastMessage ||
-                lastMessage.role !== 'user' ||
-                lastMessage.content !== input;
-            if (shouldAddInput) {
-                conversationSession.addUserMessage(input, { executionId });
-                const rootId = conversationId;
-                this.emitExecution(EXECUTION_EVENTS.USER_MESSAGE, {
-                    parameters: {
-                        input,
-                        userPrompt: input,
-                        userMessageContent: input,
-                        messageLength: input.length,
-                        wordCount: input.split(/\s+/).filter(word => word.length > 0).length,
-                        characterCount: input.length
-                    },
-                    metadata: {
-                        messageRole: 'user',
-                        inputLength: input.length,
-                        messageType: 'user_message',
-                        hasQuestions: input.includes('?'),
-                        containsUrgency: /urgent|asap|critical|emergency/i.test(input),
-                        estimatedComplexity: input.length > 200 ? 'high' : input.length > 50 ? 'medium' : 'low'
-                    }
-                }, rootId, executionId);
-            }
-            // Call beforeRun hook on all plugins
-            await this.callPluginHook('beforeRun', {
+            const conversationSession = this.initializeConversationSession(conversationId, messages, config, executionId);
+            conversationSession.addUserMessage(input, { executionId });
+            this.eventEmitter.emitUserMessageEvent(input, conversationId, executionId);
+            await callPluginHook(this.plugins, 'beforeRun', {
                 input,
-                ...(context?.metadata ? { metadata: context.metadata } : {})
-            });
-            // Use already retrieved provider info from rich data collection above
-            if (!currentInfo) {
-                throw new Error('No AI provider configured');
-            }
-            if (!provider) {
-                throw new Error(`AI provider '${currentInfo.provider}' not found`);
-            }
-            // Provider implements IAIProvider, so chat() must exist.
-            if (typeof provider.chat !== 'function') {
-                throw new Error('Provider must have chat method to support execution');
-            }
-            // Process with conversation loop - now delegated to provider
-            let toolsExecuted = [];
-            let maxRounds = 10; // Increased limit for complex team delegation scenarios
-            let currentRound = 0;
-            while (currentRound < maxRounds) {
-                currentRound++;
-                // [ROUND-DEBUG] Round start logging
-                this.logger.info(`🔄 [ROUND-DEBUG] Starting Round ${currentRound} for agent ${fullContext.conversationId}`);
-                this.logger.debug(`🔄 [ROUND-${currentRound}] Starting execution round ${currentRound}`, {
-                    executionId,
-                    conversationId: fullContext.conversationId,
-                    round: currentRound,
-                    maxRounds: maxRounds
-                });
-                // Generate the thinking node id for this round at round start.
-                const rootId = conversationId;
-                // Path-only stable thinking id: conversation-level round (next assistant turn)
-                const historyMessages = conversationSession.getMessages();
-                if (!Array.isArray(historyMessages)) {
-                    throw new Error('[EXECUTION] Conversation messages must be an array');
-                }
-                const assistantMessages = historyMessages.filter((message) => message.role === 'assistant');
-                const assistantMessageCount = assistantMessages.length;
-                const latestAssistantMessage = assistantMessages.length > 0
-                    ? assistantMessages[assistantMessages.length - 1]
-                    : undefined;
-                const shouldChainFromPreviousToolResult = Array.isArray(latestAssistantMessage?.toolCalls) &&
-                    latestAssistantMessage.toolCalls.length > 0;
-                const thinkingNodeId = `thinking_${rootId}_round${assistantMessageCount + 1}`;
-                const previousThinkingNodeId = shouldChainFromPreviousToolResult
-                    ? `thinking_${rootId}_round${assistantMessageCount}`
-                    : undefined;
-                // Get messages from conversation history
-                const conversationMessages = historyMessages;
-                this.logger.debug('Current conversation messages', {
-                    round: currentRound,
-                    messageCount: conversationMessages.length,
-                    fullHistory: conversationMessages.map((m, index) => ({
-                        index,
-                        role: m.role,
-                        content: m.content?.substring(0, 100),
-                        hasToolCalls: 'toolCalls' in m ? !!m.toolCalls?.length : false,
-                        toolCallId: 'toolCallId' in m ? m.toolCallId : undefined,
-                        toolCallsCount: 'toolCalls' in m ? m.toolCalls?.length : 0
-                    }))
-                });
-                // Call beforeProviderCall hook
-                await this.callPluginHook('beforeProviderCall', {
-                    messages: conversationMessages
-                });
-                this.logger.debug('Sending messages to AI provider', {
-                    round: currentRound,
-                    messageCount: conversationMessages.length,
-                    lastFewMessages: conversationMessages.slice(-5).map(m => ({
-                        role: m.role,
-                        content: m.content?.substring(0, 50),
-                        hasToolCalls: 'toolCalls' in m ? !!m.toolCalls?.length : false,
-                        toolCallId: 'toolCallId' in m ? m.toolCallId : undefined
-                    }))
-                });
-                // Validate required model configuration - use new defaultModel format
-                if (!config.defaultModel?.model) {
-                    throw new Error('Model is required in defaultModel configuration. Please specify a model.');
-                }
-                if (typeof config.defaultModel.model !== 'string' || config.defaultModel.model.trim() === '') {
-                    throw new Error('Model must be a non-empty string in defaultModel configuration.');
-                }
-                // Delegate entire execution to provider
-                const availableTools = this.tools.getTools();
-                const chatOptions = {
-                    model: config.defaultModel.model,
-                    ...(config.defaultModel.maxTokens !== undefined && { maxTokens: config.defaultModel.maxTokens }),
-                    ...(config.defaultModel.temperature !== undefined && { temperature: config.defaultModel.temperature }),
-                    ...(availableTools.length > 0 && { tools: availableTools })
-                };
-                // Emit assistant message start event for each thinking phase.
-                // Absolute path-only: the path tail must be the thinking node id for this round.
-                this.emitWithContext(EXECUTION_EVENTS.ASSISTANT_MESSAGE_START, {
-                    parameters: {
-                        round: currentRound,
-                        messageCount: conversationMessages.length
-                    },
-                    metadata: {
-                        round: currentRound,
-                        thinkingNodeId
-                    }
-                }, () => this.buildThinkingOwnerContext(rootId, executionId, thinkingNodeId, previousThinkingNodeId), ctx => {
-                    if (!ctx.ownerType || !ctx.ownerId) {
-                        throw new Error('[EXECUTION] Missing owner context for thinking event');
-                    }
-                    return bindWithOwnerPath(this.baseEventService, {
-                        ownerType: ctx.ownerType,
-                        ownerId: ctx.ownerId,
-                        ownerPath: ctx.ownerPath
-                    });
-                });
-                const response = await provider.chat(conversationMessages, chatOptions);
-                const assistantToolCallsFromResponse = response.role === 'assistant'
-                    ? response.toolCalls
-                    : undefined;
-                if (typeof response.content !== 'string') {
-                    throw new Error('[EXECUTION] Provider response content is required');
-                }
-                if (assistantToolCallsFromResponse && !Array.isArray(assistantToolCallsFromResponse)) {
-                    throw new Error('[EXECUTION] assistant toolCalls must be an array');
-                }
-                this.logger.debug(`🤖 [ROUND-${currentRound}] Provider response completed`, {
-                    executionId,
-                    conversationId: fullContext.conversationId,
-                    round: currentRound,
-                    responseLength: response.content.length,
-                    hasToolCalls: Array.isArray(assistantToolCallsFromResponse) && assistantToolCallsFromResponse.length > 0,
-                    toolCallsCount: Array.isArray(assistantToolCallsFromResponse) ? assistantToolCallsFromResponse.length : 0
-                });
-                // Call afterProviderCall hook
-                await this.callPluginHook('afterProviderCall', {
-                    messages: conversationMessages,
-                    responseMessage: response
-                });
-                // Add assistant response to history
-                // Response from AI provider should always be assistant message
-                if (response.role !== 'assistant') {
-                    throw new Error(`Unexpected response role: ${response.role}`);
-                }
-                const assistantResponse = response;
-                if (typeof assistantResponse.content !== 'string') {
-                    throw new Error('[EXECUTION] assistant response content is required');
-                }
-                const assistantToolCalls = assistantResponse.toolCalls ?? [];
-                if (!Array.isArray(assistantToolCalls)) {
-                    throw new Error('[EXECUTION] assistantResponse.toolCalls must be an array');
-                }
-                conversationSession.addAssistantMessage(assistantResponse.content, assistantToolCalls, {
-                    round: currentRound,
-                    ...(assistantResponse.metadata?.['usage'] && { usage: assistantResponse.metadata['usage'] })
-                });
-                this.logger.debug(`[RULE-9-DEBUG] Round ${currentRound} response check: toolCalls=${assistantToolCalls.length}`, {
-                    round: currentRound,
-                    hasToolCalls: assistantToolCalls.length > 0,
-                    toolCallsLength: assistantToolCalls.length,
-                    responseContent: assistantResponse.content.substring(0, 100) + '...'
-                });
-                // [ROUND2-DEBUG] Extra diagnostics for Round 2 response
-                if (currentRound === 2) {
-                    this.logger.info(`🔍 [ROUND2-DEBUG] Round 2 AI Response for agent ${fullContext.conversationId}:`);
-                    this.logger.info(`🔍 [ROUND2-DEBUG] - Content: ${assistantResponse.content.substring(0, 200)}...`);
-                    this.logger.info(`🔍 [ROUND2-DEBUG] - Tool Calls: ${assistantToolCalls.length}`);
-                    if (assistantToolCalls.length > 0) {
-                        this.logger.info(`🔍 [ROUND2-DEBUG] - Tool Call Details: ${JSON.stringify(assistantToolCalls.map(tc => ({ id: tc.id, name: tc.function?.name })))}`);
-                    }
-                }
-                if (assistantToolCalls.length === 0) {
-                    // No tools to execute, we're done
-                    this.logger.info(`🔄 [ROUND-DEBUG] Round ${currentRound} ENDING - no tool calls for agent ${fullContext.conversationId}`);
-                    this.logger.debug(`[AGENT-FLOW-CONTROL] Round ${currentRound} completed - no tool calls, execution finished for agent ${fullContext.conversationId}`);
-                    // [VERIFICATION] Validate ExecutionService flow-control logic
-                    this.logger.info(`🔍 [EXECUTION-VERIFICATION] Agent ${fullContext.conversationId} - Round ${currentRound} - No tool calls detected`);
-                    this.logger.info(`🔍 [EXECUTION-VERIFICATION] ExecutionContext exists: ${!!this.executionContext}`);
-                    if (this.executionContext) {
-                        this.logger.info(`🔍 [EXECUTION-VERIFICATION] Parent ID: ${this.executionContext.parentExecutionId}`);
-                        this.logger.info(`🔍 [EXECUTION-VERIFICATION] Execution Level: ${this.executionContext.executionLevel}`);
-                    }
-                    // [EVENT-ORTHODOXY] Emit events consistently; do not conditionally suppress emission.
-                    // The handler decides whether to process the event based on context.
-                    this.logger.info(`🔧 [EVENT-ORTHODOXY] Emitting assistant_message_complete for Round ${currentRound} completion (no tool calls)`);
-                    if (typeof assistantResponse.content !== 'string' || assistantResponse.content.length === 0) {
-                        throw new Error('[EXECUTION] assistant response content is required');
-                    }
-                    if (!(assistantResponse.timestamp instanceof Date)) {
-                        throw new Error('[EXECUTION] assistant response timestamp is required');
-                    }
-                    const responseContent = assistantResponse.content;
-                    const responseStartTime = assistantResponse.timestamp;
-                    const responseDuration = new Date().getTime() - responseStartTime.getTime();
-                    this.emitWithContext(EXECUTION_EVENTS.ASSISTANT_MESSAGE_COMPLETE, {
-                        parameters: {
-                            assistantMessage: responseContent,
-                            responseLength: responseContent.length,
-                            wordCount: responseContent.split(/\s+/).filter(word => word.length > 0).length,
-                            responseTime: responseDuration,
-                            contentPreview: responseContent.length > 200
-                                ? responseContent.substring(0, 200) + '...'
-                                : responseContent
-                        },
-                        result: {
-                            success: true,
-                            data: responseContent.substring(0, 100) + '...',
-                            fullResponse: responseContent,
-                            responseMetrics: {
-                                length: responseContent.length,
-                                estimatedReadTime: Math.ceil(responseContent.split(/\s+/).length / 200),
-                                hasCodeBlocks: /```/.test(responseContent),
-                                hasLinks: /https?:\/\//.test(responseContent),
-                                complexity: responseContent.length > 1000 ? 'high' : responseContent.length > 300 ? 'medium' : 'low'
-                            }
-                        },
-                        metadata: {
-                            executionId,
-                            round: currentRound,
-                            completed: true,
-                            reason: 'no_tool_calls',
-                            responseCharacteristics: {
-                                hasQuestions: responseContent.includes('?'),
-                                isError: /error|fail|wrong/i.test(responseContent),
-                                isComplete: /complete|done|finish/i.test(responseContent),
-                                containsNumbers: /\d/.test(responseContent)
-                            }
-                        }
-                    }, () => this.buildResponseOwnerContext(rootId, executionId, thinkingNodeId, previousThinkingNodeId), ctx => {
-                        if (!ctx.ownerType || !ctx.ownerId) {
-                            throw new Error('[EXECUTION] Missing owner context for response event');
-                        }
-                        return bindWithOwnerPath(this.baseEventService, {
-                            ownerType: ctx.ownerType,
-                            ownerId: ctx.ownerId,
-                            ownerPath: ctx.ownerPath
-                        });
-                    });
-                    this.logger.info(`🔍 [EXECUTION-VERIFICATION] Breaking execution loop - should prevent Round ${currentRound + 1}`);
-                    break;
-                }
-                else {
-                    // Tools are triggered in this round. Do not emit assistant_message_complete yet.
-                    // Completion will be emitted when a subsequent assistant turn finishes without tool calls.
-                }
-                // [ROUND-DEBUG] Continue round: tool calls present
-                this.logger.info(`🔄 [ROUND-DEBUG] Round ${currentRound} CONTINUING - ${assistantToolCalls.length} tool calls for agent ${fullContext.conversationId}`);
-                this.logger.info(`🔄 [ROUND-DEBUG] Agent instance conversationId=${fullContext.conversationId}`);
-                this.logger.debug('Tool calls detected, executing tools', {
-                    toolCallCount: assistantToolCalls.length,
-                    round: currentRound,
-                    toolCalls: assistantToolCalls.map((tc) => ({ id: tc.id, name: tc.function?.name }))
-                });
-                // Execute tools
-                // Ensure proper ID hierarchy for tool execution
-                const toolRootId = conversationId;
-                const rootForTools = toolRootId;
-                // Absolute path-only: tool calls must be children of the thinking node (fork point).
-                const toolOwnerPathBase = this.buildThinkingOwnerContext(rootForTools, executionId, thinkingNodeId, previousThinkingNodeId).ownerPath;
-                const expectedCountForBatch = assistantToolCalls.length;
-                const batchId = `${thinkingNodeId}`;
-                const toolRequestsBase = this.toolExecutionService.createExecutionRequestsWithContext(assistantToolCalls, {
-                    ownerPathBase: toolOwnerPathBase,
-                    metadataFactory: toolCall => ({
-                        conversationId: toolRootId,
-                        round: currentRound,
-                        directParentId: thinkingNodeId,
-                        batchId,
-                        expectedCount: expectedCountForBatch,
-                        toolCallId: toolCall.id
-                    })
-                });
-                const toolRequests = toolRequestsBase.map(request => {
-                    if (!request.ownerId) {
-                        throw new Error('[EXECUTION] Tool request missing ownerId');
-                    }
-                    return {
-                        ...request,
-                        eventService: this.ensureToolEventService(request.ownerId, request.ownerPath),
-                        baseEventService: this.baseEventService
-                    };
-                });
-                const toolContext = {
-                    requests: toolRequests,
-                    mode: 'parallel',
-                    maxConcurrency: 5,
-                    continueOnError: true
-                };
-                const toolSummary = await this.toolExecutionService.executeTools(toolContext);
-                toolsExecuted.push(...toolSummary.results.map(r => {
-                    if (!r.toolName || r.toolName.length === 0) {
-                        throw new Error('[EXECUTION] Tool result missing toolName');
-                    }
-                    return r.toolName;
-                }));
-                // Add tool results to history in the order they were called
-                // This ensures proper conversation flow and prevents any duplicate entries
-                for (const toolCall of assistantToolCalls) {
-                    if (!toolCall.id) {
-                        throw new Error(`Tool call missing ID: ${JSON.stringify(toolCall)}`);
-                    }
-                    const toolCallName = toolCall.function?.name;
-                    if (!toolCallName || toolCallName.length === 0) {
-                        throw new Error(`[EXECUTION] Tool call "${toolCall.id}" missing function name`);
-                    }
-                    // Find the corresponding result for this tool call
-                    const result = toolSummary.results.find(r => r.executionId === toolCall.id);
-                    const error = toolSummary.errors.find(e => isExecutionError(e) && e.executionId === toolCall.id);
-                    let content;
-                    let metadata = { round: currentRound };
-                    if (result && result.success) {
-                        if (typeof result.result === 'undefined') {
-                            throw new Error('[EXECUTION] Tool result missing result payload');
-                        }
-                        content = typeof result.result === 'string'
-                            ? result.result
-                            : JSON.stringify(result.result);
-                        metadata['success'] = true;
-                        if (result.toolName) {
-                            metadata['toolName'] = result.toolName;
-                        }
-                    }
-                    else if (result && !result.success) {
-                        // Tool execution failed (result is still present to preserve deterministic ordering)
-                        if (!result.error || result.error.length === 0) {
-                            throw new Error('[EXECUTION] Tool result missing error message');
-                        }
-                        content = `Error: ${result.error}`;
-                        metadata['success'] = false;
-                        metadata['error'] = result.error;
-                        if (result.toolName) {
-                            metadata['toolName'] = result.toolName;
-                        }
-                    }
-                    else if (error) {
-                        // Tool execution failed
-                        const execError = error;
-                        const execMessage = (() => {
-                            if (execError.error?.message)
-                                return execError.error.message;
-                            if (execError.message)
-                                return execError.message;
-                            return '';
-                        })();
-                        if (!execMessage || execMessage.length === 0) {
-                            throw new Error('[EXECUTION] Tool execution error missing message');
-                        }
-                        content = `Error: ${execMessage}`;
-                        metadata['success'] = false;
-                        metadata['error'] = execMessage;
-                        if (execError.toolName) {
-                            metadata['toolName'] = execError.toolName;
-                        }
-                    }
-                    else {
-                        // No result found for this tool call
-                        throw new Error(`No execution result found for tool call ID: ${toolCall.id}`);
-                    }
-                    // Add tool result to conversation history
-                    // This will throw an error if duplicate toolCallId is detected
-                    this.logger.debug('Adding tool result to conversation', {
-                        toolCallId: toolCall.id,
-                        toolName: toolCallName,
-                        content: content.substring(0, 100),
-                        round: currentRound,
-                        currentHistoryLength: conversationSession.getMessages().length
-                    });
-                    conversationSession.addToolMessageWithId(content, toolCall.id, toolCallName, metadata);
-                    this.logger.debug('Tool result added to history', {
-                        toolCallId: toolCall.id,
-                        newHistoryLength: conversationSession.getMessages().length,
-                        round: currentRound
-                    });
-                }
-                // Emit tool results ready (join trigger) and then delivery to LLM
-                const toolResultsRootId = rootId;
-                const toolCallIds = assistantToolCalls.map(toolCall => {
-                    if (!toolCall.id || toolCall.id.length === 0) {
-                        throw new Error('[EXECUTION] Tool call missing id for tool results ready payload');
-                    }
-                    return toolCall.id;
-                });
-                if (toolCallIds.length === 0) {
-                    throw new Error('[EXECUTION] Tool results ready requires toolCallIds');
+                ...(context?.metadata ? { metadata: context.metadata } : {}),
+            }, this.logger);
+            this.validateProvider(resolved);
+            const roundState = {
+                toolsExecuted: [],
+                currentRound: 0,
+                runningAssistantCount: 0,
+                lastTrackedAssistantMessage: undefined,
+                cumulativeInputTokens: 0,
+            };
+            const initialMessages = conversationSession.getMessages();
+            for (const msg of initialMessages) {
+                if (msg.role === 'assistant') {
+                    roundState.runningAssistantCount++;
+                    roundState.lastTrackedAssistantMessage = msg;
                 }
-                this.emitWithContext(EXECUTION_EVENTS.TOOL_RESULTS_READY, {
-                    parameters: {
-                        toolCallIds,
-                        round: currentRound
-                    },
-                    metadata: {
-                        round: currentRound
-                    }
-                }, () => this.buildThinkingOwnerContext(rootId, executionId, thinkingNodeId, previousThinkingNodeId), ctx => {
-                    if (!ctx.ownerType || !ctx.ownerId) {
-                        throw new Error('[EXECUTION] Missing owner context for tool results ready');
-                    }
-                    return bindWithOwnerPath(this.baseEventService, {
-                        ownerType: ctx.ownerType,
-                        ownerId: ctx.ownerId,
-                        ownerPath: ctx.ownerPath
-                    });
-                });
-                this.emitWithContext(EXECUTION_EVENTS.TOOL_RESULTS_TO_LLM, {
-                    parameters: {
-                        toolsExecuted: toolsExecuted.length,
-                        round: currentRound
-                    },
-                    metadata: {
-                        toolsExecuted: toolSummary.results.map(r => {
-                            if (!r.toolName || r.toolName.length === 0) {
-                                throw new Error('[EXECUTION] Tool result missing toolName');
-                            }
-                            return r.toolName;
-                        }),
-                        round: currentRound
-                    }
-                }, () => this.buildThinkingOwnerContext(toolResultsRootId, executionId, thinkingNodeId, previousThinkingNodeId), ctx => {
-                    if (!ctx.ownerType || !ctx.ownerId) {
-                        throw new Error('[EXECUTION] Missing owner context for tool results to llm');
-                    }
-                    return bindWithOwnerPath(this.baseEventService, {
-                        ownerType: ctx.ownerType,
-                        ownerId: ctx.ownerId,
-                        ownerPath: ctx.ownerPath
-                    });
-                });
-                // Continue to next round - let the AI decide if more tools are needed
-                // The AI will see the tool results and can either:
-                // 1. Call more tools if needed
-                // 2. Provide a final response without tool calls
-                this.logger.info(`🔄 [ROUND-DEBUG] Round ${currentRound} COMPLETED - continuing to Round ${currentRound + 1} for agent ${fullContext.conversationId}`);
             }
-            // Check if we hit the round limit
-            if (currentRound >= maxRounds) {
-                this.logger.warn('Maximum execution rounds reached', {
-                    maxRounds,
-                    conversationId
-                });
+            const maxRounds = 10;
+            const roundDeps = {
+                toolExecutionService: this.toolExecutionService,
+                plugins: this.plugins,
+                logger: this.logger,
+                eventEmitter: this.eventEmitter,
+                cacheService: this.cacheService,
+            };
+            while (roundState.currentRound < maxRounds) {
+                roundState.currentRound++;
+                const shouldBreak = await executeRound(roundState, maxRounds, conversationSession, conversationId, executionId, fullContext, config, resolved, roundDeps);
+                if (shouldBreak)
+                    break;
             }
-            // Get final messages from history
-            const finalMessages = conversationSession.getMessages();
-            const lastAssistantMessage = finalMessages
-                .filter(msg => msg.role === 'assistant')
-                .pop();
-            if (!lastAssistantMessage || typeof lastAssistantMessage.content !== 'string' || lastAssistantMessage.content.length === 0) {
-                throw new Error('[EXECUTION] Final assistant message is required');
+            if (roundState.currentRound >= maxRounds) {
+                this.logger.warn('Maximum execution rounds reached', { maxRounds, conversationId });
             }
-            const duration = Date.now() - startTime.getTime();
-            const result = {
-                response: lastAssistantMessage.content,
-                messages: finalMessages.map(msg => {
-                    if (typeof msg.content !== 'string') {
-                        throw new Error('[EXECUTION] Message content is required');
-                    }
-                    return {
-                        role: msg.role,
-                        content: msg.content,
-                        timestamp: msg.timestamp,
-                        metadata: msg.metadata,
-                        ...(msg.role === 'assistant' && 'toolCalls' in msg ? { toolCalls: msg.toolCalls } : {}),
-                        ...(msg.role === 'tool' && 'toolCallId' in msg ? { toolCallId: msg.toolCallId } : {})
-                    };
-                }),
-                executionId,
-                duration,
-                tokensUsed: finalMessages
-                    .filter(msg => msg.metadata?.['usage'])
-                    .reduce((sum, msg) => {
-                    const usage = msg.metadata?.['usage'];
-                    if (usage && typeof usage === 'object' && 'totalTokens' in usage) {
-                        const totalTokens = Number(usage.totalTokens);
-                        if (Number.isNaN(totalTokens)) {
-                            throw new Error('[EXECUTION] totalTokens must be a number');
-                        }
-                        return sum + totalTokens;
-                    }
-                    return sum;
-                }, 0),
-                toolsExecuted,
-                success: true
-            };
-            // Call afterRun hook on all plugins
-            await this.callPluginHook('afterRun', { input, response: result.response, metadata: context?.metadata });
+            const result = this.buildFinalResult(conversationSession, executionId, startTime, roundState.toolsExecuted);
+            await callPluginHook(this.plugins, 'afterRun', {
+                input,
+                response: result.response,
+                metadata: context?.metadata,
+            }, this.logger);
             this.logger.debug('Execution pipeline completed successfully', {
                 executionId,
                 conversationId,
-                duration,
+                duration: result.duration,
                 tokensUsed: result.tokensUsed,
                 toolsExecuted: result.toolsExecuted.length,
-                rounds: currentRound
+                rounds: roundState.currentRound,
             });
-            // Emit assistant message complete event
-            // execution.assistant_message_complete emission is handled in the main execution loop.
-            // Emit execution complete event
-            const rootIdComplete = conversationId;
-            this.emitExecution(EXECUTION_EVENTS.COMPLETE, {
+            this.eventEmitter.emitExecution(EXECUTION_EVENTS.COMPLETE, {
                 result: {
                     success: true,
-                    data: result.response.substring(0, 100) + '...'
+                    data: result.response.substring(0, PREVIEW_LENGTH) + '...',
                 },
                 metadata: {
                     method: 'execute',
                     success: true,
-                    duration,
+                    duration: result.duration,
                     tokensUsed: result.tokensUsed,
-                    toolsExecuted: result.toolsExecuted
-                }
-            }, rootIdComplete, executionId);
+                    toolsExecuted: result.toolsExecuted,
+                },
+            }, conversationId, executionId);
             return result;
         }
         catch (error) {
-            const duration = Date.now() - startTime.getTime();
-            // Call onError hook on all plugins
-            await this.callPluginHook('onError', {
-                error: error,
-                executionContext: this.convertExecutionContextToPluginFormat(fullContext)
-            });
-            this.logger.error('Execution pipeline failed', {
-                executionId,
-                conversationId,
-                duration,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            // Emit execution error event
-            this.emitExecution(EXECUTION_EVENTS.ERROR, {
-                error: error instanceof Error ? error.message : String(error),
-                metadata: {
-                    method: 'execute',
-                    success: false,
-                    duration,
-                    // Identity/hierarchy fields are derived from EventContext.ownerPath.
-                }
-            }, conversationId, executionId);
+            await this.handleExecutionError(error, fullContext, startTime, conversationId, executionId);
             throw error;
         }
         finally {
-            this.resetOwnerPathBases();
+            this.eventEmitter.resetOwnerPathBases();
         }
     }
-    /**
-     * Execute with streaming response
-     */
+    /** Execute with streaming response */
     async *executeStream(input, messages, config, context) {
-        this.logger.debug('ExecutionService.executeStream called');
-        const executionId = this.generateExecutionId();
-        const startTime = Date.now();
-        if (!context?.conversationId || context.conversationId.length === 0) {
-            throw new Error('[EXECUTION] conversationId is required for streaming');
-        }
-        const streamingConversationId = this.requireConversationId(context, 'streaming');
-        this.prepareOwnerPathBases(streamingConversationId);
-        try {
-            // Create conversation session for this execution
-            const conversationSession = this.conversationHistory.getConversationSession(context.conversationId);
-            // Add user input to conversation
-            if (input) {
-                conversationSession.addUserMessage(input, { executionId });
-            }
-            // Call beforeRun hook on all plugins
-            await this.callPluginHook('beforeRun', {
-                input,
-                ...(context?.metadata ? { metadata: context.metadata } : {})
-            });
-            // Get current provider info
-            const currentInfo = this.aiProviders.getCurrentProvider();
-            if (!currentInfo) {
-                throw new Error('No AI provider configured');
-            }
-            // Get actual provider instance
-            const provider = this.aiProviders.getProvider(currentInfo.provider);
-            if (!provider) {
-                throw new Error(`AI provider '${currentInfo.provider}' not found`);
-            }
-            // Ensure provider has chatStream method (streaming is optional on IAIProvider)
-            if (typeof provider.chatStream !== 'function') {
-                throw new Error('Provider must have chatStream method to support streaming execution');
-            }
-            this.logger.debug('ExecutionService calling provider.chatStream');
-            // Get conversation messages for provider
-            const conversationMessages = conversationSession.getMessages();
-            // Create chat options
-            const configToolsLength = Array.isArray(config.tools) ? config.tools.length : undefined;
-            this.logger.debug('🔍 [EXECUTION-SERVICE] config.tools:', { length: configToolsLength });
-            const toolSchemas = this.tools.getTools();
-            const toolSchemasLength = Array.isArray(toolSchemas) ? toolSchemas.length : undefined;
-            this.logger.debug('🔍 [EXECUTION-SERVICE] this.tools.getTools():', { length: toolSchemasLength });
-            this.logger.debug('🔍 [EXECUTION-SERVICE] config.tools exists:', { exists: !!config.tools });
-            this.logger.debug('🔍 [EXECUTION-SERVICE] config.tools.length > 0:', { hasTools: config.tools && config.tools.length > 0 });
-            const chatOptions = {
-                model: config.defaultModel.model,
-                ...(config.tools && config.tools.length > 0 && { tools: this.tools.getTools() })
-            };
-            this.logger.debug('🔍 [EXECUTION-SERVICE] Final chatOptions has tools:', { hasTools: !!chatOptions.tools });
-            const chatOptionsToolsLength = Array.isArray(chatOptions.tools) ? chatOptions.tools.length : undefined;
-            this.logger.debug('🔍 [EXECUTION-SERVICE] Final chatOptions.tools length:', { length: chatOptionsToolsLength });
-            const chatStream = provider.chatStream;
-            if (!chatStream) {
-                throw new Error('Provider does not support streaming');
-            }
-            const stream = chatStream.call(provider, conversationMessages, chatOptions);
-            let fullResponse = '';
-            let toolCalls = [];
-            let currentToolCallIndex = -1; // Index of the currently active tool call during streaming
-            // Collect streaming chunks and tool calls
-            for await (const chunk of stream) {
-                if (chunk.content) {
-                    fullResponse += chunk.content;
-                    yield { chunk: chunk.content, isComplete: false };
-                }
-                // Collect tool calls from streaming chunks (type assertion for AssistantMessage)
-                if (chunk.role === 'assistant') {
-                    const assistantChunk = chunk;
-                    if (Array.isArray(assistantChunk.toolCalls) && assistantChunk.toolCalls.length > 0) {
-                        // Manage tool call state while streaming
-                        for (const chunkToolCall of assistantChunk.toolCalls) {
-                            if (chunkToolCall.id && chunkToolCall.id !== '') {
-                                // ✅ Tool call id present: start a new tool call
-                                if (!chunkToolCall.type || chunkToolCall.type.length === 0) {
-                                    throw new Error(`[EXECUTION] Tool call "${chunkToolCall.id}" missing type in stream`);
-                                }
-                                if (!chunkToolCall.function?.name || chunkToolCall.function.name.length === 0) {
-                                    throw new Error(`[EXECUTION] Tool call "${chunkToolCall.id}" missing function name in stream`);
-                                }
-                                if (typeof chunkToolCall.function.arguments !== 'string') {
-                                    throw new Error(`[EXECUTION] Tool call "${chunkToolCall.id}" missing arguments in stream`);
-                                }
-                                currentToolCallIndex = toolCalls.length;
-                                toolCalls.push({
-                                    id: chunkToolCall.id,
-                                    type: chunkToolCall.type,
-                                    function: {
-                                        name: chunkToolCall.function.name,
-                                        arguments: chunkToolCall.function.arguments
-                                    }
-                                });
-                                this.logger.debug(`🆕 [TOOL-STREAM] New tool call started: ${chunkToolCall.id} (${chunkToolCall.function?.name})`);
-                            }
-                            else if (currentToolCallIndex >= 0) {
-                                // ✅ Tool call id missing: append fragments to the current tool call
-                                const hasNameFragment = typeof chunkToolCall.function?.name === 'string' && chunkToolCall.function.name.length > 0;
-                                const hasArgumentsFragment = typeof chunkToolCall.function?.arguments === 'string' && chunkToolCall.function.arguments.length > 0;
-                                if (!hasNameFragment && !hasArgumentsFragment) {
-                                    throw new Error(`[EXECUTION] Tool call fragment missing name/arguments for ${toolCalls[currentToolCallIndex].id}`);
-                                }
-                                if (hasNameFragment) {
-                                    toolCalls[currentToolCallIndex].function.name += chunkToolCall.function.name;
-                                }
-                                if (hasArgumentsFragment) {
-                                    toolCalls[currentToolCallIndex].function.arguments += chunkToolCall.function.arguments;
-                                }
-                                const fragmentPreview = hasArgumentsFragment
-                                    ? chunkToolCall.function.arguments
-                                    : chunkToolCall.function.name;
-                                this.logger.debug(`📝 [TOOL-STREAM] Adding fragment to tool ${toolCalls[currentToolCallIndex].id}: "${fragmentPreview}"`);
-                            }
-                        }
-                    }
-                }
-            }
-            this.logger.debug('🔥 [EXECUTION-SERVICE-STREAM] Stream completed, toolCalls detected:', { count: toolCalls.length });
-            if (typeof fullResponse !== 'string') {
-                throw new Error('[EXECUTION] Streaming response content is required');
-            }
-            conversationSession.addAssistantMessage(fullResponse, toolCalls, { executionId });
-            // Execute tools if detected
-            if (toolCalls.length > 0) {
-                this.logger.debug('🔥 [EXECUTION-SERVICE-STREAM] Executing tools:', { tools: toolCalls.map(tc => tc.function.name) });
-                // Execute tools with hierarchical context
-                const streamingRootId = streamingConversationId;
-                // Generate thinking node ID for streaming mode (direct provision)
-                const streamingThinkingNodeId = `thinking_${streamingRootId}_${Date.now()}_${executionId}`;
-                const streamingOwnerPathBase = [...this.buildExecutionOwnerContext(streamingRootId, executionId).ownerPath, { type: 'thinking', id: streamingThinkingNodeId }];
-                const toolRequests = this.toolExecutionService.createExecutionRequestsWithContext(toolCalls, {
-                    ownerPathBase: streamingOwnerPathBase
-                });
-                const toolContext = {
-                    requests: toolRequests,
-                    mode: 'parallel',
-                    maxConcurrency: 5,
-                    continueOnError: true
-                };
-                const toolSummary = await this.toolExecutionService.executeTools(toolContext);
-                // Add tool results to conversation in the order they were called
-                for (const toolCall of toolCalls) {
-                    if (!toolCall.id) {
-                        throw new Error('[EXECUTION] Tool call missing id in streaming mode');
-                    }
-                    if (!toolCall.function?.name || toolCall.function.name.length === 0) {
-                        throw new Error(`[EXECUTION] Tool call "${toolCall.id}" missing function name in streaming mode`);
-                    }
-                    // Find the corresponding result for this tool call
-                    const result = toolSummary.results.find(r => r.executionId === toolCall.id);
-                    const error = toolSummary.errors.find(e => isExecutionError(e) && e.executionId === toolCall.id);
-                    let content;
-                    let metadata = { executionId };
-                    if (result && result.success) {
-                        if (typeof result.result === 'undefined') {
-                            throw new Error('[EXECUTION] Tool result missing result payload in streaming mode');
-                        }
-                        content = typeof result.result === 'string'
-                            ? result.result
-                            : JSON.stringify(result.result);
-                        metadata['success'] = true;
-                        if (result.toolName) {
-                            metadata['toolName'] = result.toolName;
-                        }
-                        // Yield tool result as streaming chunk
-                        yield { chunk: `\n[Tool: ${toolCall.function.name} executed successfully]`, isComplete: false };
-                    }
-                    else if (error) {
-                        // Tool execution failed
-                        const execError = error;
-                        const execMessage = (() => {
-                            if (execError.error?.message)
-                                return execError.error.message;
-                            if (execError.message)
-                                return execError.message;
-                            return '';
-                        })();
-                        if (!execMessage || execMessage.length === 0) {
-                            throw new Error('[EXECUTION] Tool execution error missing message in streaming mode');
-                        }
-                        content = `Error: ${execMessage}`;
-                        metadata['success'] = false;
-                        metadata['error'] = execMessage;
-                        if (execError.toolName) {
-                            metadata['toolName'] = execError.toolName;
-                        }
-                        // Yield error as streaming chunk
-                        yield { chunk: `\n[Tool: ${toolCall.function.name} failed: ${execMessage}]`, isComplete: false };
-                    }
-                    else {
-                        throw new Error(`[EXECUTION] Missing tool result for tool call "${toolCall.id}" in streaming mode`);
-                    }
-                    // Add tool result to conversation history
-                    conversationSession.addToolMessageWithId(content, toolCall.id, toolCall.function.name, metadata);
-                }
-                // After all tool responses are emitted and recorded, trigger aggregation join
-                const streamingRoot = streamingConversationId;
-                const streamingToolCallIds = toolCalls.map(toolCall => {
-                    if (!toolCall.id || toolCall.id.length === 0) {
-                        throw new Error('[EXECUTION] Tool call missing id for streaming tool results ready payload');
-                    }
-                    return toolCall.id;
-                });
-                if (streamingToolCallIds.length === 0) {
-                    throw new Error('[EXECUTION] Tool results ready requires toolCallIds in streaming mode');
-                }
-                this.emitExecution(EXECUTION_EVENTS.TOOL_RESULTS_READY, {
-                    parameters: {
-                        toolCallIds: streamingToolCallIds,
-                        round: 1
-                    },
-                    metadata: {
-                        toolsExecuted: toolSummary.results.map(r => {
-                            if (!r.toolName || r.toolName.length === 0) {
-                                throw new Error('[EXECUTION] Tool result missing toolName');
-                            }
-                            return r.toolName;
-                        }),
-                        round: 1,
-                    }
-                }, streamingRoot, executionId);
-            }
-            // Call afterRun hook
-            await this.callPluginHook('afterRun', {
-                input,
-                response: fullResponse,
-                ...(context?.metadata ? { metadata: context.metadata } : {})
-            });
-            yield { chunk: '', isComplete: true };
-        }
-        catch (error) {
-            this.logger.error('ExecutionService streaming execution failed', {
-                error: error instanceof Error ? error.message : String(error),
-                executionTime: Date.now() - startTime
-            });
-            // Call error hook
-            await this.callPluginHook('onError', {
-                input,
-                error: error instanceof Error ? error : new Error(String(error)),
-                ...(context?.metadata ? { metadata: context.metadata } : {})
-            });
-            throw error;
-        }
-        finally {
-            this.resetOwnerPathBases();
-        }
-    }
-    /**
-     * Generate a unique execution ID
-     */
-    generateExecutionId() {
-        return `exec_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        yield* executeStreamFn(input, messages, config, context, {
+            aiProviders: this.aiProviders,
+            tools: this.tools,
+            conversationHistory: this.conversationHistory,
+            toolExecutionService: this.toolExecutionService,
+            plugins: this.plugins,
+            logger: this.logger,
+            eventEmitter: this.eventEmitter,
+            generateExecutionId: () => this.generateExecutionId(),
+        });
     }
-    /**
-     * Get execution statistics from plugins
-     */
+    /** Get execution statistics from plugins */
     async getStats() {
-        const stats = {
+        return {
             pluginCount: this.plugins.length,
-            pluginNames: this.plugins.map(p => p.name),
-            historyStats: this.conversationHistory.getStats()
+            pluginNames: this.plugins.map((p) => p.name),
+            historyStats: this.conversationHistory.getStats(),
         };
-        // Note: Plugin-specific stats are not included here to avoid type conflicts
-        // Plugins can implement their own getStats() method returning their specific stat types
-        return stats;
     }
-    /**
-     * Clear all plugins
-     */
+    /** Clear all plugins */
     clearPlugins() {
         this.plugins = [];
         this.logger.debug('All plugins cleared');
     }
-    /**
-     * Call a hook method on all plugins that implement it
-     * Handles different hook signatures properly
-     */
-    async callPluginHook(hookName, context) {
-        for (const plugin of this.plugins) {
-            try {
-                // Use type assertion to access the hook methods
-                const pluginWithHooks = plugin;
-                // Call the appropriate hook method with correct parameters
-                switch (hookName) {
-                    case 'beforeRun':
-                        if (pluginWithHooks.beforeRun && context.input) {
-                            await pluginWithHooks.beforeRun(context.input, context.metadata);
-                        }
-                        break;
-                    case 'afterRun':
-                        if (pluginWithHooks.afterRun && context.input && context.response) {
-                            await pluginWithHooks.afterRun(context.input, context.response, context.metadata);
-                        }
-                        break;
-                    case 'beforeProviderCall':
-                        if (pluginWithHooks.beforeProviderCall && context.messages) {
-                            await pluginWithHooks.beforeProviderCall(context.messages);
-                        }
-                        break;
-                    case 'afterProviderCall':
-                        if (pluginWithHooks.afterProviderCall && context.messages && context.responseMessage) {
-                            await pluginWithHooks.afterProviderCall(context.messages, context.responseMessage);
-                        }
-                        break;
-                    case 'onError':
-                        if (pluginWithHooks.onError && context.error) {
-                            const errorContext = {
-                                action: `${EXECUTION_EVENT_PREFIX}.${EXECUTION_EVENTS.ERROR}`,
-                                metadata: {}
-                            };
-                            const executionIdValue = context.executionContext?.['executionId'];
-                            if (typeof executionIdValue === 'string' && executionIdValue.length > 0) {
-                                errorContext.executionId = executionIdValue;
-                            }
-                            const sessionIdValue = context.executionContext?.['sessionId'];
-                            if (typeof sessionIdValue === 'string' && sessionIdValue.length > 0) {
-                                errorContext.sessionId = sessionIdValue;
-                            }
-                            const userIdValue = context.executionContext?.['userId'];
-                            if (typeof userIdValue === 'string' && userIdValue.length > 0) {
-                                errorContext.userId = userIdValue;
-                            }
-                            await pluginWithHooks.onError(context.error, errorContext);
-                        }
-                        break;
-                }
-            }
-            catch (error) {
-                this.logger.warn('Plugin hook failed', {
-                    pluginName: plugin.name,
-                    hookName,
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-        }
-    }
-    ensureToolEventService(ownerId, ownerPath) {
-        if (isDefaultEventService(this.baseEventService)) {
-            return this.baseEventService;
-        }
-        if (!ownerId) {
-            throw new Error('[EVENT-SERVICE] Missing ownerId for tool event context');
-        }
-        if (!ownerPath || ownerPath.length === 0) {
-            throw new Error('[EVENT-SERVICE] Missing ownerPath for tool event context');
-        }
-        if (this.toolEventServices.has(ownerId)) {
-            return this.toolEventServices.get(ownerId);
+    // --- Private helpers ---
+    resolveProviderAndTools(config) {
+        const currentInfo = this.aiProviders.getCurrentProvider();
+        const provider = currentInfo ? this.aiProviders.getProvider(currentInfo.provider) : null;
+        if (!currentInfo || !currentInfo.provider || !provider) {
+            throw new Error('[EXECUTION] Provider is required');
         }
-        const scoped = bindWithOwnerPath(this.baseEventService, {
-            ownerType: TOOL_EVENT_PREFIX,
-            ownerId,
-            ownerPath: ownerPath.map(segment => ({ ...segment })),
+        const availableTools = this.tools.getTools();
+        const aiProviderInfo = {
+            providerName: currentInfo.provider,
+            model: config.defaultModel.model,
+            temperature: config.defaultModel.temperature,
+            maxTokens: config.defaultModel.maxTokens,
+        };
+        const toolsInfo = availableTools.map((tool) => {
+            const paramSchema = tool.parameters;
+            const props = paramSchema?.properties;
+            if (!tool.description || tool.description.length === 0) {
+                throw new Error(`[EXECUTION] Tool "${tool.name}" is missing description`);
+            }
+            return {
+                name: tool.name,
+                description: tool.description,
+                parameters: props && typeof props === 'object' ? Object.keys(props) : [],
+            };
         });
-        this.toolEventServices.set(ownerId, scoped);
-        return scoped;
-    }
-    prepareOwnerPathBases(conversationId) {
-        this.toolEventServices.clear();
-        const ownerPath = [...this.ownerPathBase, { type: 'agent', id: conversationId }];
-        this.agentOwnerPathBase = ownerPath;
-    }
-    resetOwnerPathBases() {
-        this.toolEventServices.clear();
-        this.agentOwnerPathBase = [];
-    }
-    buildBaseOwnerPath(executionContext) {
-        if (!executionContext?.ownerPath?.length) {
-            return [];
-        }
-        return executionContext.ownerPath.map(segment => ({ ...segment }));
+        return { provider, currentInfo, aiProviderInfo, toolsInfo, availableTools };
     }
-    buildExecutionOwnerContext(rootId, executionId) {
-        if (!rootId || rootId.length === 0) {
-            throw new Error('[EXECUTION] Missing rootId for execution owner context');
+    validateProvider(resolved) {
+        if (!resolved.currentInfo)
+            throw new Error('No AI provider configured');
+        if (!resolved.provider)
+            throw new Error(`AI provider '${resolved.currentInfo.provider}' not found`);
+        if (typeof resolved.provider.chat !== 'function') {
+            throw new Error('Provider must have chat method to support execution');
         }
-        if (!executionId || executionId.length === 0) {
-            throw new Error('[EXECUTION] Missing executionId for execution owner context');
-        }
-        const basePath = this.agentOwnerPathBase.length ? this.agentOwnerPathBase : this.ownerPathBase;
-        const path = [...basePath];
-        if (rootId && !path.some(segment => segment.type === 'agent' && segment.id === rootId)) {
-            path.push({ type: 'agent', id: rootId });
-        }
-        path.push({ type: 'execution', id: executionId });
-        return {
-            ownerType: EXECUTION_EVENT_PREFIX,
-            ownerId: executionId,
-            ownerPath: path
-        };
     }
-    buildThinkingOwnerContext(rootId, executionId, thinkingNodeId, previousThinkingNodeId) {
-        if (!thinkingNodeId || thinkingNodeId.length === 0) {
-            throw new Error('[EXECUTION] Missing thinkingNodeId for thinking owner context');
-        }
-        const base = this.buildExecutionOwnerContext(rootId, executionId).ownerPath;
-        const path = [...base];
-        if (previousThinkingNodeId) {
-            path.push({ type: 'thinking', id: previousThinkingNodeId });
-            path.push({ type: 'tool_result', id: `tool_result_${previousThinkingNodeId}` });
+    initializeConversationSession(conversationId, messages, config, executionId) {
+        const session = this.conversationHistory.getConversationSession(conversationId);
+        if (session.getMessageCount() === 0 && messages.length > 0) {
+            for (const msg of messages) {
+                if (msg.role === 'user') {
+                    session.addUserMessage(msg.content, msg.metadata, msg.parts);
+                }
+                else if (msg.role === 'assistant') {
+                    session.addAssistantMessage(msg.content, msg.toolCalls, msg.metadata, msg.parts);
+                }
+                else if (msg.role === 'system') {
+                    session.addSystemMessage(msg.content, msg.metadata, msg.parts);
+                }
+                else if (msg.role === 'tool') {
+                    const toolName = msg.metadata?.['toolName'];
+                    if (typeof toolName !== 'string' || toolName.length === 0) {
+                        throw new Error('[EXECUTION] Tool message missing toolName metadata');
+                    }
+                    session.addToolMessageWithId(msg.content, msg.toolCallId, toolName, msg.metadata, msg.parts);
+                }
+            }
         }
-        path.push({ type: 'thinking', id: thinkingNodeId });
-        return {
-            ownerType: EXECUTION_EVENT_PREFIX,
-            ownerId: executionId,
-            ownerPath: path
-        };
-    }
-    buildToolOwnerContext(rootId, executionId, toolCallId) {
-        // Tool calls are always children of a specific thinking phase (fork point).
-        // The caller must provide an ownerPathBase that already includes `{ type: 'thinking', id }`.
-        if (!toolCallId || toolCallId.length === 0) {
-            throw new Error('[EXECUTION] Missing toolCallId for tool owner context');
+        if (config.systemMessage) {
+            session.addSystemMessage(config.systemMessage, { executionId });
         }
-        const base = this.buildExecutionOwnerContext(rootId, executionId).ownerPath;
-        const path = [...base, { type: 'tool', id: toolCallId }];
-        return {
-            ownerType: TOOL_EVENT_PREFIX,
-            ownerId: toolCallId,
-            ownerPath: path
-        };
+        return session;
     }
-    buildResponseOwnerContext(rootId, executionId, thinkingNodeId, previousThinkingNodeId) {
-        const thinkingPath = this.buildThinkingOwnerContext(rootId, executionId, thinkingNodeId, previousThinkingNodeId).ownerPath;
-        const responseNodeId = `response_${thinkingNodeId}`;
-        const path = [...thinkingPath, { type: 'response', id: responseNodeId }];
+    buildFinalResult(conversationSession, executionId, startTime, toolsExecuted) {
+        const finalMessages = conversationSession.getMessages();
+        const lastAssistantMessage = finalMessages.filter((msg) => msg.role === 'assistant').pop();
+        const hasValidResponse = !!lastAssistantMessage &&
+            typeof lastAssistantMessage.content === 'string' &&
+            lastAssistantMessage.content.length > 0;
+        const response = hasValidResponse
+            ? lastAssistantMessage.content
+            : '(execution interrupted: no final assistant response — possible context overflow or max turn limit)';
+        const duration = Date.now() - startTime.getTime();
         return {
-            ownerType: EXECUTION_EVENT_PREFIX,
-            ownerId: executionId,
-            ownerPath: path
+            response,
+            messages: finalMessages.map((msg) => {
+                if (typeof msg.content !== 'string')
+                    throw new Error('[EXECUTION] Message content is required');
+                return {
+                    role: msg.role,
+                    content: msg.content,
+                    timestamp: msg.timestamp,
+                    metadata: msg.metadata,
+                    ...(msg.role === 'assistant' && 'toolCalls' in msg ? { toolCalls: msg.toolCalls } : {}),
+                    ...(msg.role === 'tool' && 'toolCallId' in msg ? { toolCallId: msg.toolCallId } : {}),
+                };
+            }),
+            executionId,
+            duration,
+            tokensUsed: finalMessages
+                .filter((msg) => msg.metadata?.['usage'])
+                .reduce((sum, msg) => {
+                const usage = msg.metadata?.['usage'];
+                if (usage && typeof usage === 'object' && 'totalTokens' in usage) {
+                    const totalTokens = Number(usage.totalTokens);
+                    if (Number.isNaN(totalTokens))
+                        throw new Error('[EXECUTION] totalTokens must be a number');
+                    return sum + totalTokens;
+                }
+                return sum;
+            }, 0),
+            toolsExecuted,
+            success: hasValidResponse,
         };
     }
-    emitExecution(eventType, data, rootId, executionId) {
-        this.emitWithContext(eventType, data, () => this.buildExecutionOwnerContext(rootId, executionId), context => {
-            if (!context.ownerType || !context.ownerId) {
-                throw new Error('[EXECUTION] Missing owner context for execution event');
-            }
-            return bindWithOwnerPath(this.baseEventService, {
-                ownerType: context.ownerType,
-                ownerId: context.ownerId,
-                ownerPath: context.ownerPath
-            });
+    async handleExecutionError(error, fullContext, startTime, conversationId, executionId) {
+        const duration = Date.now() - startTime.getTime();
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        await callPluginHook(this.plugins, 'onError', {
+            error: normalizedError,
+            executionContext: this.convertExecutionContextToPluginFormat(fullContext),
+        }, this.logger);
+        this.logger.error('Execution pipeline failed', {
+            executionId,
+            conversationId,
+            duration,
+            error: error instanceof Error ? error.message : String(error),
         });
+        this.eventEmitter.emitExecution(EXECUTION_EVENTS.ERROR, {
+            error: error instanceof Error ? error.message : String(error),
+            metadata: { method: 'execute', success: false, duration },
+        }, conversationId, executionId);
     }
-    emitTool(eventType, data, rootId, executionId, toolCallId) {
-        this.emitWithContext(eventType, data, () => this.buildToolOwnerContext(rootId, executionId, toolCallId), context => this.ensureToolEventService(context.ownerId, context.ownerPath));
-    }
-    emitWithContext(eventType, data, buildContext, resolveService) {
-        if (isDefaultEventService(this.baseEventService)) {
-            return;
-        }
-        const context = buildContext();
-        const service = resolveService(context);
-        const payload = {
-            timestamp: new Date(),
-            ...data,
-        };
-        service.emit(eventType, payload, context);
+    generateExecutionId() {
+        return `exec_${Date.now()}_${Math.random().toString(ID_RADIX).substr(2, ID_RANDOM_LENGTH)}`;
     }
     requireConversationId(context, label) {
         if (!context?.conversationId || context.conversationId.length === 0) {
@@ -1239,23 +332,18 @@ export class ExecutionService {
         }
         return context.conversationId;
     }
-    /**
-     * Convert IExecutionContext to IPluginContext compatible format
-     */
     convertExecutionContextToPluginFormat(context) {
         const conversationId = this.requireConversationId(context, 'plugin-context');
         const payload = {
-            conversationId: conversationId,
+            conversationId,
             executionId: context.executionId,
             startTime: context.startTime.toISOString(),
-            messageCount: context.messages.length
+            messageCount: context.messages.length,
         };
-        if (context.sessionId) {
+        if (context.sessionId)
             payload.sessionId = context.sessionId;
-        }
-        if (context.userId) {
+        if (context.userId)
             payload.userId = context.userId;
-        }
         return payload;
     }
 }