@codemieai/code 0.0.33 → 0.0.35

package/dist/agents/codemie-code/agent.js

@@ -3,21 +3,27 @@
  *
  * Core LangGraph ReAct agent using LangChain v1.0+ with streaming support
  */
+import { randomUUID } from 'node:crypto';
 import { createReactAgent } from '@langchain/langgraph/prebuilt';
 import { ChatOpenAI } from '@langchain/openai';
-import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { HumanMessage, SystemMessage, AIMessage } from '@langchain/core/messages';
+import { EVENT_TYPES, CodeMieAgentError } from './types.js';
 import { getSystemPrompt } from './prompts.js';
-import { CodeMieAgentError } from './types.js';
 import { extractToolMetadata } from './toolMetadata.js';
 import { extractTokenUsageFromStreamChunk, extractTokenUsageFromFinalState } from './tokenUtils.js';
 import { setGlobalToolEventCallback } from './tools/index.js';
 import { logger } from '../../utils/logger.js';
 import { sanitizeCookies, sanitizeAuthToken } from '../../utils/security.js';
 import { HookExecutor } from '../../hooks/executor.js';
+import { extractSkillPatterns } from '../../skills/utils/pattern-matcher.js';
+import { SkillManager } from '../../skills/core/SkillManager.js';
+import { parseAtMentionCommand } from './ui/mentions.js';
+import { loadRegisteredAssistants } from '../../utils/config.js';
 export class CodeMieAgent {
     agent;
     config;
     tools;
+    skills;
     conversationHistory = [];
     toolCallArgs = new Map(); // Store tool args by tool call ID
     currentExecutionSteps = [];
@@ -39,16 +45,19 @@ export class CodeMieAgent {
         llmCalls: 0,
         executionSteps: []
     };
-    constructor(config, tools) {
+    constructor(config, tools, skills = []) {
         this.config = config;
         this.tools = tools;
+        this.skills = skills;
+        const sessionId = randomUUID();
+        logger.setSessionId(sessionId);
         // Create the appropriate LLM based on provider
         const llm = this.createLLM();
-        // Create LangGraph ReAct agent with system prompt
+        // Create LangGraph ReAct agent with system prompt (including skills if loaded)
         this.agent = createReactAgent({
             llm,
             tools: this.tools,
-            messageModifier: getSystemPrompt(config.workingDirectory)
+            messageModifier: getSystemPrompt(config.workingDirectory, this.skills)
         });
         // Initialize hook executor if hooks are configured
         if (config.hooks) {
@@ -77,6 +86,27 @@ export class CodeMieAgent {
             logger.debug(`CodeMie Agent initialized with ${tools.length} tools`);
         }
     }
+    /**
+     * Update tools after initialization (needed for tools that require conversation history)
+     */
+    async updateTools(tools) {
+        this.tools = tools;
+        // Load registered assistants for system prompt
+        const assistants = await loadRegisteredAssistants();
+        // Recreate agent with new tools and assistant-aware prompt
+        const llm = this.createLLM();
+        this.agent = createReactAgent({
+            llm,
+            tools: this.tools,
+            messageModifier: getSystemPrompt(this.config.workingDirectory, [], assistants)
+        });
+        if (this.config.debug) {
+            logger.debug(`CodeMie Agent tools updated: ${tools.length} tools`);
+            if (assistants.length > 0) {
+                logger.debug(`Loaded ${assistants.length} assistants for system prompt:`, assistants.map(a => a.slug));
+            }
+        }
+    }
     /**
      * Create the appropriate LLM instance based on provider configuration
      */
@@ -151,7 +181,7 @@ export class CodeMieAgent {
                     model: this.config.model,
                     apiKey: this.config.authToken,
                     configuration: {
-                        baseURL: this.config.baseUrl !== 'bedrock' ? this.config.baseUrl : undefined,
+                        baseURL: this.config.baseUrl === 'bedrock' ? undefined : this.config.baseUrl,
                         // Add client tracking header to all Bedrock requests
                         fetch: async (input, init) => {
                             const updatedInit = {
@@ -179,7 +209,7 @@ export class CodeMieAgent {
                     baseURL
                 };
                 // Check if we have SSO cookies to inject (following codemie-ide-plugin pattern)
-                const ssoCookies = global.codemieSSOCookies;
+                const ssoCookies = globalThis.codemieSSOCookies;
                 if (this.config.debug) {
                     logger.debug(`SSO Cookies available:`, sanitizeCookies(ssoCookies));
                     logger.debug(`Auth token:`, sanitizeAuthToken(this.config.authToken));
@@ -285,6 +315,70 @@ export class CodeMieAgent {
             content: content
         });
     }
+    /**
+     * Handle @ mention invocation result by updating history and emitting events
+     * @param message - Original user message
+     * @param images - Optional images from user
+     * @param atMentionResult - Result from preprocessAtMention
+     * @param onEvent - Event callback
+     */
+    handleAtMentionResult(message, images, atMentionResult, onEvent) {
+        const userMessage = this.createHumanMessage(message, images);
+        this.conversationHistory.push(userMessage);
+        const assistantMessage = new AIMessage({
+            content: atMentionResult.response || 'No response from assistant'
+        });
+        this.conversationHistory.push(assistantMessage);
+        onEvent({ type: EVENT_TYPES.THINKING_END });
+        onEvent({ type: EVENT_TYPES.CONTENT_CHUNK, content: atMentionResult.response });
+        onEvent({ type: EVENT_TYPES.COMPLETE });
+    }
+    /**
+     * Preprocess message to detect @ mentions and invoke assistants directly
+     * Returns { handled: true, response: string, assistantSlug: string } if @ mention was processed,
+     * or { handled: false } if no @ mention found
+     */
+    async preprocessAtMention(message, onEvent) {
+        // Use shared mention pattern from mentions module
+        const parsed = parseAtMentionCommand(message);
+        if (!parsed) {
+            return { handled: false };
+        }
+        const { assistantSlug, message: assistantMessage } = parsed;
+        try {
+            // Find the invoke_assistant tool
+            const invokeTool = this.tools.find(tool => tool.name === 'invoke_assistant');
+            if (!invokeTool) {
+                if (this.config.debug) {
+                    logger.debug('@ mention detected but invoke_assistant tool not available');
+                }
+                return { handled: false };
+            }
+            if (this.config.debug) {
+                logger.debug(`Preprocessing @ mention: @${assistantSlug} "${assistantMessage.substring(0, 50)}..."`);
+            }
+            // Emit thinking_start with assistant info
+            onEvent({ type: EVENT_TYPES.THINKING_START });
+            // Invoke the assistant tool directly
+            const response = await invokeTool.invoke({
+                assistantSlug,
+                message: assistantMessage,
+                includeHistory: false // Default to no history for @ mentions (can be made configurable)
+            });
+            return { handled: true, response: String(response), assistantSlug };
+        }
+        catch (error) {
+            if (this.config.debug) {
+                logger.debug('@ mention preprocessing failed:', error);
+            }
+            // Return error as response but mark as handled
+            return {
+                handled: true,
+                response: `Failed to invoke assistant @${assistantSlug}: ${error instanceof Error ? error.message : String(error)}`,
+                assistantSlug
+            };
+        }
+    }
     /**
      * Stream a chat interaction with the agent
      */
@@ -304,7 +398,7 @@ export class CodeMieAgent {
         // Set up global tool event callback for progress reporting
         setGlobalToolEventCallback((event) => {
             onEvent({
-                type: 'tool_call_progress',
+                type: EVENT_TYPES.TOOL_CALL_PROGRESS,
                 toolName: event.toolName,
                 toolProgress: event.progress
             });
@@ -319,193 +413,220 @@ export class CodeMieAgent {
             }
             streamAborted = true;
             abortController.abort();
-            onEvent({ type: 'error', error: 'Stream interrupted by user (Ctrl+C)' });
+            onEvent({ type: EVENT_TYPES.ERROR, error: 'Stream interrupted by user (Ctrl+C)' });
         };
         process.once('SIGINT', sigintHandler);
-        try {
-            if (this.config.debug) {
-                logger.debug(`Processing message: ${message.substring(0, 100)}...`);
-            }
-            // Execute SessionStart hooks (only on first message)
-            if (this.hookExecutor && this.conversationHistory.length === 0) {
-                try {
-                    const sessionStartResult = await this.hookExecutor.executeSessionStart();
-                    // Handle blocking decision
-                    if (sessionStartResult.decision === 'block') {
-                        const reason = sessionStartResult.reason || 'Session blocked by SessionStart hook';
-                        const context = sessionStartResult.additionalContext;
-                        // Check if we should retry (exit code 2 behavior)
-                        if (context && this.hookLoopCounter < (this.getMaxHookRetries())) {
-                            this.hookLoopCounter++;
-                            logger.warn(`SessionStart hook blocked (attempt ${this.hookLoopCounter}/${this.getMaxHookRetries()})`);
-                            // Build feedback message
-                            const hookFeedback = [reason, context].filter(Boolean).join('\n\n');
-                            // Clear hook cache for retry
-                            this.hookExecutor.clearCache();
-                            // Retry with feedback
-                            return this.chatStream(`[Hook feedback]: ${hookFeedback}`, onEvent, images);
+        if (this.config.debug) {
+            logger.debug(`Processing message: ${message.substring(0, 100)}...`);
+        }
+        // Execute SessionStart hooks (only on first message)
+        if (this.hookExecutor && this.conversationHistory.length === 0) {
+            try {
+                const sessionStartResult = await this.hookExecutor.executeSessionStart();
+                // Handle blocking decision
+                if (sessionStartResult.decision === 'block') {
+                    const reason = sessionStartResult.reason || 'Session blocked by SessionStart hook';
+                    const context = sessionStartResult.additionalContext;
+                    // Check if we should retry (exit code 2 behavior)
+                    if (context && this.hookLoopCounter < (this.getMaxHookRetries())) {
+                        this.hookLoopCounter++;
+                        logger.warn(`SessionStart hook blocked (attempt ${this.hookLoopCounter}/${this.getMaxHookRetries()})`);
+                        // Build feedback message
+                        const hookFeedback = [reason, context].filter(Boolean).join('\n\n');
+                        // Clear hook cache for retry
+                        this.hookExecutor.clearCache();
+                        // Retry with feedback
+                        return this.chatStream(`[Hook feedback]: ${hookFeedback}`, onEvent, images);
+                    }
+                    else {
+                        // Max retries reached or no feedback - block session
+                        if (this.hookLoopCounter >= this.getMaxHookRetries()) {
+                            logger.error(`SessionStart hook blocked after ${this.hookLoopCounter} attempts - aborting session`);
+                            onEvent({
+                                type: 'error',
+                                error: `Session blocked after ${this.hookLoopCounter} attempts: ${reason}`
+                            });
                         }
                         else {
-                            // Max retries reached or no feedback - block session
-                            if (this.hookLoopCounter >= this.getMaxHookRetries()) {
-                                logger.error(`SessionStart hook blocked after ${this.hookLoopCounter} attempts - aborting session`);
-                                onEvent({
-                                    type: 'error',
-                                    error: `Session blocked after ${this.hookLoopCounter} attempts: ${reason}`
-                                });
-                            }
-                            else {
-                                logger.warn('SessionStart hook blocked session start');
-                                onEvent({
-                                    type: 'error',
-                                    error: reason
-                                });
-                            }
-                            return; // Exit without starting session
-                        }
-                    }
-                    // Inject hook output as system context
-                    if (sessionStartResult.additionalContext) {
-                        if (this.config.debug) {
-                            logger.debug('SessionStart hook provided context, injecting into conversation');
+                            logger.warn('SessionStart hook blocked session start');
+                            onEvent({
+                                type: 'error',
+                                error: reason
+                            });
                         }
-                        // Add SessionStart output as system message before user message
-                        const systemMessage = new SystemMessage(`[SessionStart Hook Output]:\n${sessionStartResult.additionalContext}`);
-                        this.conversationHistory.push(systemMessage);
+                        return; // Exit without starting session
                     }
                 }
-                catch (error) {
-                    logger.error(`SessionStart hook failed: ${error}`);
-                    // Continue session start (fail open)
-                }
-            }
-            // Execute UserPromptSubmit hooks
-            if (this.hookExecutor && message.trim()) {
-                try {
-                    const hookResult = await this.hookExecutor.executeUserPromptSubmit(message);
-                    // Handle blocking decision
-                    if (hookResult.decision === 'block') {
-                        logger.warn('UserPromptSubmit hook blocked prompt');
-                        onEvent({
-                            type: 'error',
-                            error: hookResult.reason || 'Prompt blocked by hook'
-                        });
-                        return; // Exit without processing
-                    }
-                    // Add context to conversation
-                    if (hookResult.additionalContext) {
-                        if (this.config.debug) {
-                            logger.debug('UserPromptSubmit hook provided context');
-                        }
-                        // Prepend context to the message
-                        message = `${hookResult.additionalContext}\n\n${message}`;
+                // Inject hook output as system context
+                if (sessionStartResult.additionalContext) {
+                    if (this.config.debug) {
+                        logger.debug('SessionStart hook provided context, injecting into conversation');
                     }
-                }
-                catch (error) {
-                    logger.error(`UserPromptSubmit hook failed: ${error}`);
-                    // Continue execution
+                    // Add SessionStart output as system message before user message
+                    const systemMessage = new SystemMessage(`[SessionStart Hook Output]:\n${sessionStartResult.additionalContext}`);
+                    this.conversationHistory.push(systemMessage);
                 }
             }
-            // Add user message to conversation history (with optional images)
-            const userMessage = this.createHumanMessage(message, images);
-            this.conversationHistory.push(userMessage);
-            // Notify start of thinking
-            onEvent({ type: 'thinking_start' });
-            // Start the first LLM call step
-            currentStep = this.startLLMStep();
-            // Create the stream with conversation history
-            const stream = await this.agent.stream({ messages: this.conversationHistory }, {
-                streamMode: 'updates',
-                recursionLimit: 50,
-                signal: abortController.signal // Add abort signal for stream cancellation
-            });
-            let hasContent = false;
-            // Process stream chunks with interruption handling
-            for await (const chunk of stream) {
-                // Check if stream was aborted
-                if (streamAborted || abortController.signal.aborted) {
+            catch (error) {
+                logger.error(`SessionStart hook failed: ${error}`);
+                // Continue session start (fail open)
+            }
+        }
+        // Execute UserPromptSubmit hooks
+        if (this.hookExecutor && message.trim()) {
+            try {
+                const hookResult = await this.hookExecutor.executeUserPromptSubmit(message);
+                // Handle blocking decision
+                if (hookResult.decision === 'block') {
+                    logger.warn('UserPromptSubmit hook blocked prompt');
+                    onEvent({
+                        type: 'error',
+                        error: hookResult.reason || 'Prompt blocked by hook'
+                    });
+                    return; // Exit without processing
+                }
+                // Add context to conversation
+                if (hookResult.additionalContext) {
                     if (this.config.debug) {
-                        logger.debug('Stream processing aborted');
+                        logger.debug('UserPromptSubmit hook provided context');
                     }
-                    break;
+                    // Prepend context to the message
+                    message = `${hookResult.additionalContext}\n\n${message}`;
                 }
-                // Try to extract token usage from stream chunk
-                const tokenUsage = extractTokenUsageFromStreamChunk(chunk, this.config.model, this.config.provider);
-                if (tokenUsage && currentStep && currentStep.type === 'llm_call') {
-                    // Update current step with token usage
-                    currentStep.tokenUsage = tokenUsage;
-                    this.updateStatsWithTokenUsage(tokenUsage);
-                    // Store token usage to associate with next tool call
-                    this.currentLLMTokenUsage = tokenUsage;
+            }
+            catch (error) {
+                logger.error(`UserPromptSubmit hook failed: ${error}`);
+                // Continue execution
+            }
+        }
+        // Detect skill patterns in message
+        const patternResult = extractSkillPatterns(message);
+        if (patternResult.hasPatterns) {
+            try {
+                // Load skills with inventory
+                const skillsWithInventory = await this.loadDetectedSkills(patternResult.patterns);
+                if (skillsWithInventory.length > 0) {
+                    // Format and inject as system message
+                    const skillContent = this.formatSkillsForInjection(skillsWithInventory);
+                    const skillSystemMessage = new SystemMessage(`[Skill Invocation Detected]\n\n${skillContent}`);
+                    this.conversationHistory.push(skillSystemMessage);
                     if (this.config.debug) {
-                        logger.debug(`Token usage: ${tokenUsage.inputTokens} in, ${tokenUsage.outputTokens} out`);
+                        logger.debug(`Injected ${skillsWithInventory.length} skills: ${skillsWithInventory.map((s) => s.skill.metadata.name).join(', ')}`);
                     }
                 }
-                await this.processStreamChunk(chunk, onEvent, (toolStarted) => {
-                    if (toolStarted) {
-                        // Complete current LLM step if it exists
-                        if (currentStep && currentStep.type === 'llm_call') {
-                            this.completeStep(currentStep);
-                            currentStep = null;
-                        }
-                        // Start tool execution step
-                        currentStep = this.startToolStep(toolStarted);
-                        currentToolCall = toolStarted;
-                        this.stats.toolCalls++;
-                    }
-                    else if (currentToolCall && currentStep) {
-                        // Complete tool step
-                        currentStep.toolSuccess = true;
+            }
+            catch (error) {
+                // Non-blocking: Log error but continue
+                logger.warn('Failed to load skills for pattern injection:', error);
+            }
+        }
+        // Preprocess @ mentions before normal agent processing
+        const atMentionResult = await this.preprocessAtMention(message, onEvent);
+        if (atMentionResult.handled) {
+            this.handleAtMentionResult(message, images, atMentionResult, onEvent);
+            return;
+        }
+        // Add user message to conversation history (with optional images)
+        const userMessage = this.createHumanMessage(message, images);
+        this.conversationHistory.push(userMessage);
+        // Notify start of thinking
+        onEvent({ type: EVENT_TYPES.THINKING_START });
+        // Start the first LLM call step
+        currentStep = this.startLLMStep();
+        // Create the stream with conversation history
+        const stream = await this.agent.stream({ messages: this.conversationHistory }, {
+            streamMode: 'updates',
+            recursionLimit: 50,
+            signal: abortController.signal // Add abort signal for stream cancellation
+        });
+        let hasContent = false;
+        // Process stream chunks with interruption handling
+        for await (const chunk of stream) {
+            // Check if stream was aborted
+            if (streamAborted || abortController.signal.aborted) {
+                if (this.config.debug) {
+                    logger.debug('Stream processing aborted');
+                }
+                break;
+            }
+            // Try to extract token usage from stream chunk
+            const tokenUsage = extractTokenUsageFromStreamChunk(chunk, this.config.model, this.config.provider);
+            if (tokenUsage && currentStep?.type === 'llm_call') {
+                // Update current step with token usage
+                currentStep.tokenUsage = tokenUsage;
+                this.updateStatsWithTokenUsage(tokenUsage);
+                // Store token usage to associate with next tool call
+                this.currentLLMTokenUsage = tokenUsage;
+                if (this.config.debug) {
+                    logger.debug(`Token usage: ${tokenUsage.inputTokens} in, ${tokenUsage.outputTokens} out`);
+                }
+            }
+            await this.processStreamChunk(chunk, onEvent, (toolStarted) => {
+                if (toolStarted) {
+                    // Complete current LLM step if it exists
+                    if (currentStep?.type === 'llm_call') {
                         this.completeStep(currentStep);
                         currentStep = null;
-                        this.stats.successfulTools++;
-                        currentToolCall = null;
-                        // Start new LLM step for next reasoning cycle (processing tool result)
-                        currentStep = this.startLLMStep();
-                    }
-                });
-                // Check if we have content
-                if (chunk.agent?.messages) {
-                    const lastMessage = chunk.agent.messages.at(-1);
-                    if (lastMessage?.content && !hasContent) {
-                        hasContent = true;
                     }
+                    // Start tool execution step
+                    currentStep = this.startToolStep(toolStarted);
+                    currentToolCall = toolStarted;
+                    this.stats.toolCalls++;
+                }
+                else if (currentToolCall && currentStep) {
+                    // Complete tool step
+                    currentStep.toolSuccess = true;
+                    this.completeStep(currentStep);
+                    currentStep = null;
+                    this.stats.successfulTools++;
+                    currentToolCall = null;
+                    // Start new LLM step for next reasoning cycle (processing tool result)
+                    currentStep = this.startLLMStep();
+                }
+            });
+            // Check if we have content
+            if (chunk.agent?.messages) {
+                const lastMessage = chunk.agent.messages.at(-1);
+                if (lastMessage?.content && !hasContent) {
+                    hasContent = true;
                 }
             }
-            // Complete any remaining step
-            if (currentStep) {
-                this.completeStep(currentStep);
-            }
-            // Update conversation history with final messages and try to extract any missed token usage
-            try {
-                const finalState = await this.agent.getState();
-                if (finalState?.messages) {
-                    this.conversationHistory = finalState.messages;
-                    // Try to extract token usage from final state if we missed it during streaming
-                    const finalTokenUsage = extractTokenUsageFromFinalState(finalState, this.config.model, this.config.provider);
-                    if (finalTokenUsage && this.currentExecutionSteps.length > 0) {
-                        // Find the last LLM step that doesn't have token usage
-                        for (let i = this.currentExecutionSteps.length - 1; i >= 0; i--) {
-                            const step = this.currentExecutionSteps[i];
-                            if (step.type === 'llm_call' && !step.tokenUsage) {
-                                step.tokenUsage = finalTokenUsage;
-                                this.updateStatsWithTokenUsage(finalTokenUsage);
-                                break;
-                            }
+        }
+        // Complete any remaining step
+        if (currentStep) {
+            this.completeStep(currentStep);
+        }
+        // Update conversation history with final messages and try to extract any missed token usage
+        try {
+            const finalState = await this.agent.getState();
+            if (finalState?.messages) {
+                this.conversationHistory = finalState.messages;
+                // Try to extract token usage from final state if we missed it during streaming
+                const finalTokenUsage = extractTokenUsageFromFinalState(finalState, this.config.model, this.config.provider);
+                if (finalTokenUsage && this.currentExecutionSteps.length > 0) {
+                    // Find the last LLM step that doesn't have token usage
+                    for (let i = this.currentExecutionSteps.length - 1; i >= 0; i--) {
+                        const step = this.currentExecutionSteps[i];
+                        if (step.type === 'llm_call' && !step.tokenUsage) {
+                            step.tokenUsage = finalTokenUsage;
+                            this.updateStatsWithTokenUsage(finalTokenUsage);
+                            break;
                         }
                     }
                 }
             }
-            catch {
-                // If getState fails, continue without updating history
-                if (this.config.debug) {
-                    logger.debug('Could not get final state, continuing...');
-                }
+        }
+        catch {
+            // If getState fails, continue without updating history
+            if (this.config.debug) {
+                logger.debug('Could not get final state, continuing...');
             }
-            // Finalize execution statistics
-            this.stats.executionTime = Date.now() - startTime;
-            this.stats.executionSteps = [...this.currentExecutionSteps];
-            // Execute Stop hooks
+        }
+        // Finalize execution statistics
+        this.stats.executionTime = Date.now() - startTime;
+        this.stats.executionSteps = [...this.currentExecutionSteps];
+        // Execute Stop hooks
+        try {
             if (this.hookExecutor) {
                 try {
                     const stopHookResult = await this.hookExecutor.executeStop(this.currentExecutionSteps, {
@@ -568,8 +689,8 @@ export class CodeMieAgent {
                 }
             }
             // Notify thinking end and completion
-            onEvent({ type: 'thinking_end' });
-            onEvent({ type: 'complete' });
+            onEvent({ type: EVENT_TYPES.THINKING_END });
+            onEvent({ type: EVENT_TYPES.COMPLETE });
             if (this.config.debug) {
                 logger.debug(`Agent completed in ${this.stats.executionTime}ms`);
                 logger.debug(`Total tokens: ${this.stats.totalTokens} (${this.stats.inputTokens} in, ${this.stats.outputTokens} out)`);
@@ -588,7 +709,7 @@ export class CodeMieAgent {
                     logger.debug('Stream aborted by user');
                 }
                 onEvent({
-                    type: 'error',
+                    type: EVENT_TYPES.ERROR,
                     error: 'Operation interrupted by user'
                 });
                 return; // Don't throw error for user interruptions
@@ -601,7 +722,7 @@ export class CodeMieAgent {
                 logger.debug(`Model: ${this.config.model}`);
             }
             onEvent({
-                type: 'error',
+                type: EVENT_TYPES.ERROR,
                 error: errorMessage
             });
             throw new CodeMieAgentError(`Agent execution failed: ${errorMessage}`, 'EXECUTION_ERROR', { originalError: error, stats: this.stats });
@@ -631,7 +752,7 @@ export class CodeMieAgent {
                 // Stream content chunks
                 if (lastMessage?.content && typeof lastMessage.content === 'string') {
                     onEvent({
-                        type: 'content_chunk',
+                        type: EVENT_TYPES.CONTENT_CHUNK,
                         content: lastMessage.content
                     });
                 }
@@ -672,7 +793,7 @@ export class CodeMieAgent {
                         // Use tool name as key since LangGraph may not preserve IDs consistently
                         this.toolCallArgs.set(toolCall.name, toolCall.args);
                         onEvent({
-                            type: 'tool_call_start',
+                            type: EVENT_TYPES.TOOL_CALL_START,
                             toolName: toolCall.name,
                             toolArgs: toolCall.args
                         });
@@ -733,7 +854,7 @@ export class CodeMieAgent {
                         }
                     }
                     onEvent({
-                        type: 'tool_call_result',
+                        type: EVENT_TYPES.TOOL_CALL_RESULT,
                         toolName,
                         result,
                         toolMetadata
@@ -750,7 +871,7 @@ export class CodeMieAgent {
             }
             // Don't throw here, just log - let the main stream continue
             onEvent({
-                type: 'error',
+                type: EVENT_TYPES.ERROR,
                 error: `Stream processing error: ${error instanceof Error ? error.message : String(error)}`
             });
         }
@@ -878,7 +999,7 @@ export class CodeMieAgent {
         }
         else {
             // Check if the previous step was a tool execution
-            const prevStep = this.currentExecutionSteps[this.currentExecutionSteps.length - 1];
+            const prevStep = this.currentExecutionSteps.at(-1);
             llmContext = (prevStep?.type === 'tool_execution') ? 'processing_tool_result' : 'final_response';
         }
         const step = {
@@ -942,5 +1063,39 @@ export class CodeMieAgent {
             this.stats.estimatedTotalCost += tokenUsage.estimatedCost;
         }
     }
+    /**
+     * Load detected skills with file inventory
+     *
+     * @param patterns - Detected skill patterns
+     * @returns Skills with inventory and formatted content
+     */
+    async loadDetectedSkills(patterns) {
+        // Extract unique skill names (preserve order)
+        const skillNames = Array.from(new Set(patterns.map((p) => p.name)));
+        // Get skills from manager
+        const manager = SkillManager.getInstance();
+        const skillsWithInventory = await manager.getSkillsByNames(skillNames, {
+            cwd: this.config.workingDirectory,
+            agentName: 'codemie-code',
+        });
+        return skillsWithInventory;
+    }
+    /**
+     * Format skills for prompt injection
+     *
+     * @param skills - Skills with inventory
+     * @returns Formatted content for system message
+     */
+    formatSkillsForInjection(skills) {
+        const parts = [
+            'The user has invoked the following skills. Follow their guidance for this request.',
+            '',
+        ];
+        for (const { formattedContent } of skills) {
+            parts.push('---', '', formattedContent, '');
+        }
+        parts.push('---', '', 'IMPORTANT: These skills provide specialized knowledge for this task. Prioritize their guidance over general instructions.');
+        return parts.join('\n');
+    }
 }
 //# sourceMappingURL=agent.js.map