snow-flow 4.6.9 → 5.0.1

package/dist/monitoring/performance-tracker.js

@@ -117,11 +117,11 @@ class PerformanceTracker extends events_1.EventEmitter {
      * Get metrics for a specific session
      */
     async getSessionMetrics(sessionId) {
-        const metrics = await this.memory.query(`
-      SELECT * FROM performance_metrics 
-      WHERE session_id = ?
+        const metrics = await this.memory.query?.(`
+      SELECT * FROM performance_metrics
+      WHERE session_id = '${sessionId}'
       ORDER BY start_time
-    `, [sessionId]);
+    `) || [];
         if (metrics.length === 0) {
             return {
                 sessionId,
@@ -160,11 +160,11 @@ class PerformanceTracker extends events_1.EventEmitter {
      */
     async getAggregateMetrics(operation, timeframe) {
         const since = timeframe ? Date.now() - timeframe : 0;
-        const metrics = await this.memory.query(`
-      SELECT * FROM performance_metrics 
-      WHERE operation = ? AND start_time > ?
+        const metrics = await this.memory.query?.(`
+      SELECT * FROM performance_metrics
+      WHERE operation = '${operation}' AND start_time > ${since}
       ORDER BY duration
-    `, [operation, since]);
+    `) || [];
         if (metrics.length === 0) {
             return {
                 operation,
@@ -206,10 +206,10 @@ class PerformanceTracker extends events_1.EventEmitter {
         const timeframe = this.getTimeframe(period);
         const since = Date.now() - timeframe;
         // Get all metrics for the period
-        const allMetrics = await this.memory.query(`
-      SELECT * FROM performance_metrics 
-      WHERE start_time > ?
-    `, [since]);
+        const allMetrics = await this.memory.query?.(`
+      SELECT * FROM performance_metrics
+      WHERE start_time > ${since}
+    `) || [];
         // Get unique operations
         const operations = [...new Set(allMetrics.map(m => m.operation))];
         // Calculate operation metrics
@@ -415,10 +415,11 @@ class PerformanceTracker extends events_1.EventEmitter {
     }
     async aggregateMetrics() {
         // Aggregate metrics for different time periods
-        const operations = await this.memory.query(`
+        const cutoff = Date.now() - this.config.aggregationInterval;
+        const operations = await this.memory.query?.(`
       SELECT DISTINCT operation FROM performance_metrics
-      WHERE start_time > ?
-    `, [Date.now() - this.config.aggregationInterval]);
+      WHERE start_time > ${cutoff}
+    `) || [];
         for (const { operation } of operations) {
             const aggregate = await this.getAggregateMetrics(operation, this.config.aggregationInterval);
             await this.memory.insert('performance_aggregates', {
@@ -434,12 +435,12 @@ class PerformanceTracker extends events_1.EventEmitter {
     }
     async cleanupOldMetrics() {
         const cutoff = Date.now() - this.config.metricsRetention;
-        await this.memory.execute(`
-      DELETE FROM performance_metrics WHERE start_time < ?
-    `, [cutoff]);
-        await this.memory.execute(`
-      DELETE FROM performance_aggregates WHERE timestamp < ?
-    `, [cutoff]);
+        await this.memory.execute?.(`
+      DELETE FROM performance_metrics WHERE start_time < ${cutoff}
+    `);
+        await this.memory.execute?.(`
+      DELETE FROM performance_aggregates WHERE timestamp < ${cutoff}
+    `);
     }
     checkPerformanceThresholds(metric) {
         // Check for slow operations
@@ -508,10 +509,10 @@ class PerformanceTracker extends events_1.EventEmitter {
         return peak;
     }
     async countSessionArtifacts(sessionId) {
-        const result = await this.memory.query(`
-      SELECT COUNT(*) as count FROM servicenow_artifacts 
-      WHERE session_id = ?
-    `, [sessionId]);
+        const result = await this.memory.query?.(`
+      SELECT COUNT(*) as count FROM servicenow_artifacts
+      WHERE session_id = '${sessionId}'
+    `) || [];
         return result[0]?.count || 0;
     }
     groupBy(array, key) {

package/dist/queen/agent-factory.js

@@ -267,6 +267,9 @@ class AgentFactory {
             portal_page: complexity > 0.7
                 ? ['researcher', 'widget-creator', 'page-designer', 'tester']
                 : ['widget-creator', 'page-designer', 'tester'],
+            workspace: complexity > 0.7
+                ? ['researcher', 'workspace-specialist', 'ui-builder-expert', 'tester']
+                : ['workspace-specialist', 'ui-builder-expert'],
             unknown: ['researcher', 'widget-creator'] // Safe default
         };
         return sequences[taskType] || ['researcher'];
@@ -447,6 +450,27 @@ class AgentFactory {
                 'NAVIGATION INTEGRATION: Ensure clear navigation paths and consistent user experience',
                 'CROSS-BROWSER TESTING: Validate consistent experience across all browsers and device types',
                 'USABILITY VALIDATION: Test with real users to ensure the page meets their needs effectively'
+            ],
+            'workspace-specialist': (instr) => [
+                'WORKSPACE REQUIREMENTS: Analyze workspace needs and user workflows',
+                'UX FRAMEWORK DESIGN: Plan Now Experience Framework architecture',
+                'COMPONENT DESIGN: Design workspace components and data integration',
+                'IMPLEMENTATION: Create workspace using appropriate MCP tools',
+                'VALIDATION: Test workspace functionality and user experience'
+            ],
+            'ui-builder-expert': (instr) => [
+                'UI BUILDER ANALYSIS: Determine required UI Builder components',
+                'PAGE DESIGN: Design page layout and component structure',
+                'DATA INTEGRATION: Configure data brokers and connections',
+                'IMPLEMENTATION: Create UI Builder pages with proper configuration',
+                'TESTING: Validate functionality and user experience'
+            ],
+            'deployment-specialist': (instr) => [
+                'DEPLOYMENT PLANNING: Analyze artifacts and plan deployment',
+                'DEPENDENCY CHECK: Verify all prerequisites and dependencies',
+                'DEPLOYMENT EXECUTION: Execute deployment using MCP tools',
+                'VALIDATION: Test deployed artifacts thoroughly',
+                'MONITORING: Ensure deployment success and establish monitoring'
             ]
         };
         return plans[agentType]?.(instruction) || [

package/dist/queen/neural-learning.js

@@ -136,6 +136,9 @@ class NeuralLearning {
             portal_page: complexity > 0.7
                 ? ['researcher', 'widget-creator', 'page-designer', 'tester']
                 : ['widget-creator', 'page-designer', 'tester'],
+            workspace: complexity > 0.7
+                ? ['researcher', 'workspace-specialist', 'ui-builder-expert', 'tester']
+                : ['workspace-specialist', 'ui-builder-expert'],
             unknown: ['researcher', 'widget-creator'] // Default fallback
         };
         // Add catalog manager if catalog-related
@@ -200,6 +203,7 @@ class NeuralLearning {
             application: ['snow_deploy', 'snow_create_table', 'snow_create_ui_policy'],
             integration: ['snow_create_rest_message', 'snow_test_integration'],
             portal_page: ['snow_deploy', 'snow_preview_widget', 'snow_widget_test'],
+            workspace: ['snow_create_complete_workspace', 'snow_create_ux_app_route', 'snow_create_uib_page'],
             unknown: ['snow_find_artifact', 'snow_analyze_requirements']
         };
         return mcpSequences[taskType];

package/dist/queen/types.d.ts

@@ -5,7 +5,7 @@
 export interface ServiceNowTask {
     id: string;
     objective: string;
-    type: 'widget' | 'portal_page' | 'flow' | 'script' | 'application' | 'integration' | 'unknown';
+    type: 'widget' | 'portal_page' | 'flow' | 'script' | 'application' | 'integration' | 'workspace' | 'unknown';
     artifacts: string[];
     status: 'analyzing' | 'planning' | 'executing' | 'completed' | 'failed';
     result?: any;
@@ -22,7 +22,7 @@ export interface Agent {
     specialization?: string;
     startTime?: number;
 }
-export type AgentType = 'widget-creator' | 'flow-builder' | 'script-writer' | 'app-architect' | 'integration-specialist' | 'catalog-manager' | 'researcher' | 'tester' | 'ui-ux-specialist' | 'approval-specialist' | 'security-specialist' | 'css-specialist' | 'backend-specialist' | 'frontend-specialist' | 'performance-specialist' | 'page-designer';
+export type AgentType = 'widget-creator' | 'flow-builder' | 'script-writer' | 'app-architect' | 'integration-specialist' | 'catalog-manager' | 'researcher' | 'tester' | 'ui-ux-specialist' | 'approval-specialist' | 'security-specialist' | 'css-specialist' | 'backend-specialist' | 'frontend-specialist' | 'performance-specialist' | 'page-designer' | 'workspace-specialist' | 'ui-builder-expert' | 'deployment-specialist';
 export interface DeploymentPattern {
     taskType: string;
     successRate: number;

package/dist/sdk/claude-agent-sdk-integration.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Claude Agent SDK Integration Layer
+ * Bridges Snow-Flow architecture with @anthropic-ai/claude-agent-sdk@0.1.1
+ *
+ * Purpose:
+ * - Replace custom RealAgentSpawner with SDK's native agent spawning
+ * - Integrate SDK's query() with our Memory System
+ * - Provide hooks for agent coordination
+ * - Simplify agent execution while keeping our intelligence
+ */
+import { MemorySystem } from '../memory/memory-system.js';
+import { EventEmitter } from 'events';
+import type { AgentType } from '../queen/types.js';
+export interface SnowFlowAgentConfig {
+    type: AgentType;
+    objective: string;
+    context?: Record<string, any>;
+    mcpTools?: string[];
+    memory?: MemorySystem;
+    maxTurns?: number;
+    model?: 'sonnet' | 'opus' | 'haiku';
+}
+export interface AgentExecutionResult {
+    success: boolean;
+    agentId: string;
+    agentType: AgentType;
+    artifacts: string[];
+    output: string;
+    tokensUsed: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    duration: number;
+    error?: Error;
+}
+/**
+ * Snow-Flow SDK Integration
+ * Replaces 2800+ lines of custom agent code with SDK-native approach
+ */
+export declare class ClaudeAgentSDKIntegration extends EventEmitter {
+    private memory;
+    private logger;
+    private activeQueries;
+    constructor(memory: MemorySystem);
+    /**
+     * Spawn agent using Claude Agent SDK (replaces RealAgentSpawner)
+     *
+     * Before: 701 lines in RealAgentSpawner
+     * After: Single query() call with proper instructions
+     */
+    spawnAgent(config: SnowFlowAgentConfig): Promise<AgentExecutionResult>;
+    /**
+     * Spawn multiple agents in parallel
+     * Leverages our ParallelAgentEngine intelligence + SDK execution
+     */
+    spawnParallelAgents(configs: SnowFlowAgentConfig[]): Promise<AgentExecutionResult[]>;
+    /**
+     * Build agent instructions with Snow-Flow intelligence
+     * Maps agent types to clear, actionable instructions
+     */
+    private buildAgentInstructions;
+    /**
+     * Type-specific instructions for different agent types
+     */
+    private getTypeSpecificInstructions;
+    /**
+     * Build MCP server configuration for SDK
+     * Connects to our 448-tool unified server
+     */
+    private buildMCPServerConfig;
+    /**
+     * Build hooks for agent coordination
+     * Integrates with our Memory System and progress tracking
+     */
+    private buildHooks;
+    /**
+     * Process agent execution stream
+     * Extracts artifacts, tokens, and output
+     */
+    private processAgentExecution;
+    /**
+     * Control running agent (interrupt, change model, etc.)
+     */
+    controlAgent(agentId: string, action: 'interrupt' | 'pause'): Promise<void>;
+    /**
+     * Get agent status
+     */
+    getAgentStatus(agentId: string): 'active' | 'completed' | 'not-found';
+    /**
+     * Utility methods
+     */
+    private generateAgentId;
+    private mapModelName;
+    /**
+     * Cleanup
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=claude-agent-sdk-integration.d.ts.map

package/dist/sdk/claude-agent-sdk-integration.js

@@ -0,0 +1,414 @@
+"use strict";
+/**
+ * Claude Agent SDK Integration Layer
+ * Bridges Snow-Flow architecture with @anthropic-ai/claude-agent-sdk@0.1.1
+ *
+ * Purpose:
+ * - Replace custom RealAgentSpawner with SDK's native agent spawning
+ * - Integrate SDK's query() with our Memory System
+ * - Provide hooks for agent coordination
+ * - Simplify agent execution while keeping our intelligence
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAgentSDKIntegration = void 0;
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const logger_js_1 = require("../utils/logger.js");
+const events_1 = require("events");
+/**
+ * Snow-Flow SDK Integration
+ * Replaces 2800+ lines of custom agent code with SDK-native approach
+ */
+class ClaudeAgentSDKIntegration extends events_1.EventEmitter {
+    constructor(memory) {
+        super();
+        this.activeQueries = new Map();
+        this.memory = memory;
+        this.logger = new logger_js_1.Logger('ClaudeAgentSDK');
+    }
+    /**
+     * Spawn agent using Claude Agent SDK (replaces RealAgentSpawner)
+     *
+     * Before: 701 lines in RealAgentSpawner
+     * After: Single query() call with proper instructions
+     */
+    async spawnAgent(config) {
+        const agentId = this.generateAgentId(config.type);
+        const startTime = Date.now();
+        this.logger.info(`🚀 Spawning ${config.type} agent via Claude Agent SDK`);
+        this.emit('agent:spawning', { agentId, type: config.type });
+        try {
+            // Build agent instructions with Snow-Flow context
+            const instructions = this.buildAgentInstructions(config);
+            // Configure SDK options with MCP servers and hooks
+            const options = {
+                mcpServers: this.buildMCPServerConfig(),
+                hooks: this.buildHooks(agentId, config.type),
+                maxTurns: config.maxTurns || 10,
+                model: this.mapModelName(config.model),
+                permissionMode: 'bypassPermissions', // For automated agents
+                cwd: process.cwd()
+            };
+            // Execute agent via SDK query()
+            const agentQuery = (0, claude_agent_sdk_1.query)({
+                prompt: instructions,
+                options
+            });
+            // Store active query for monitoring/control
+            this.activeQueries.set(agentId, agentQuery);
+            // Process agent execution
+            const result = await this.processAgentExecution(agentId, config.type, agentQuery, startTime);
+            this.emit('agent:completed', result);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`❌ Agent ${agentId} failed:`, error);
+            this.emit('agent:failed', { agentId, type: config.type, error });
+            return {
+                success: false,
+                agentId,
+                agentType: config.type,
+                artifacts: [],
+                output: '',
+                tokensUsed: { input: 0, output: 0, total: 0 },
+                duration: Date.now() - startTime,
+                error: error
+            };
+        }
+        finally {
+            this.activeQueries.delete(agentId);
+        }
+    }
+    /**
+     * Spawn multiple agents in parallel
+     * Leverages our ParallelAgentEngine intelligence + SDK execution
+     */
+    async spawnParallelAgents(configs) {
+        this.logger.info(`🚀 Spawning ${configs.length} agents in parallel`);
+        const spawnPromises = configs.map(config => this.spawnAgent(config));
+        const results = await Promise.allSettled(spawnPromises);
+        return results.map((result, index) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
+            }
+            else {
+                const config = configs[index];
+                return {
+                    success: false,
+                    agentId: this.generateAgentId(config.type),
+                    agentType: config.type,
+                    artifacts: [],
+                    output: '',
+                    tokensUsed: { input: 0, output: 0, total: 0 },
+                    duration: 0,
+                    error: result.reason
+                };
+            }
+        });
+    }
+    /**
+     * Build agent instructions with Snow-Flow intelligence
+     * Maps agent types to clear, actionable instructions
+     */
+    buildAgentInstructions(config) {
+        const baseInstructions = `You are a ${config.type} agent in the Snow-Flow intelligent orchestration system.
+
+**Agent ID:** ${this.generateAgentId(config.type)}
+**Objective:** ${config.objective}
+**Available MCP Tools:** All 448 ServiceNow unified tools are available
+
+## 🎯 Mission
+
+${this.getTypeSpecificInstructions(config.type)}
+
+## 📋 Execution Requirements
+
+1. **Use REAL Snow-Flow MCP tools:**
+   - All tools are prefixed with 'snow_' (e.g., snow_create_workspace, snow_create_uib_page)
+   - Execute tools with proper parameters
+   - Capture sys_ids from responses
+
+2. **Store results in Memory:**
+   - Use mcp__claude-flow__memory_usage for coordination
+   - Store all created artifacts: \`memory_usage({ action: 'store', key: 'agent_work_${this.generateAgentId(config.type)}', value: JSON.stringify({ sys_ids: [...] }) })\`
+   - Share findings with other agents through Memory
+
+3. **Verify your work:**
+   - After creating artifacts, verify they exist in ServiceNow
+   - Use snow_query_table to confirm records exist
+   - Report only verified work
+
+4. **Track Update Set:**
+   - Ensure active Update Set: snow_ensure_active_update_set
+   - All changes should be tracked
+
+## ⚠️ Critical Rules
+
+- ❌ NO simulation or fake responses
+- ❌ NO placeholder sys_ids
+- ✅ ONLY report verified ServiceNow artifacts
+- ✅ USE Memory for agent coordination
+- ✅ VERIFY all work via snow_query_table
+
+## 🚀 Begin Execution
+
+${config.context ? `\n**Context:**\n${JSON.stringify(config.context, null, 2)}\n` : ''}
+
+Execute your mission now. Use TodoWrite to break down tasks if needed.`;
+        return baseInstructions;
+    }
+    /**
+     * Type-specific instructions for different agent types
+     */
+    getTypeSpecificInstructions(type) {
+        const instructions = {
+            'workspace-specialist': `Create and configure ServiceNow workspaces using:
+- snow_create_complete_workspace for full UX Framework workspaces
+- snow_create_configurable_agent_workspace for Agent Workspaces
+- snow_discover_all_workspaces to check existing workspaces
+- snow_validate_workspace_configuration to ensure proper setup`,
+            'ui-builder-expert': `Build UI Builder pages and components using:
+- snow_create_uib_page for new pages
+- snow_add_uib_page_element to add components
+- snow_create_uib_component for custom components
+- snow_create_uib_data_broker for data integration
+- Ensure proper routing and data flow`,
+            'widget-creator': `Create Service Portal widgets using:
+- snow_create_sp_widget for new widgets
+- Ensure HTML/Client/Server script coherence
+- Use snow_pull_artifact for debugging large widgets
+- Validate with snow_validate_artifact_coherence`,
+            'script-writer': `Write and deploy scripts using:
+- snow_create_script_include for reusable code
+- snow_create_business_rule for automation
+- snow_create_client_script for client-side logic
+- Ensure ES5 compatibility (NO modern JavaScript!)
+- Test with snow_execute_script_with_output`,
+            'integration-specialist': `Build integrations using:
+- snow_create_rest_message for REST APIs
+- snow_test_rest_connection for validation
+- snow_create_transform_map for data transformation
+- Handle authentication and error cases`,
+            'tester': `Test and validate implementations using:
+- snow_execute_script_with_output for functionality tests
+- snow_get_logs for error checking
+- snow_validate_artifact_coherence for widget testing
+- Create comprehensive test scenarios`,
+            'security-specialist': `Ensure security and compliance using:
+- snow_create_acl for access control
+- snow_scan_vulnerabilities for security checks
+- Review permissions and authentication
+- Validate data access patterns`,
+            'deployment-specialist': `Deploy and validate artifacts using:
+- snow_deploy for widget/artifact deployment
+- snow_ensure_active_update_set for change tracking
+- snow_validate_deployment for verification
+- Handle rollback if needed`,
+            'researcher': `Research and analyze ServiceNow environments using:
+- snow_comprehensive_search for artifact discovery
+- snow_discover_* tools for exploring configurations
+- snow_query_table for data analysis
+- Document findings in Memory`,
+            'app-architect': `Design application architecture using:
+- Analyze requirements and design data models
+- Plan UI/UX structure
+- Define integration points
+- Document architecture in Memory for other agents`,
+            'page-designer': `Design and create portal pages using:
+- snow_create_sp_page for Service Portal pages
+- Configure layout (containers, rows, columns)
+- Place widgets with proper sizing
+- Set permissions and navigation`
+        };
+        return instructions[type] || `Execute your specialized task: ${type}`;
+    }
+    /**
+     * Build MCP server configuration for SDK
+     * Connects to our 448-tool unified server
+     */
+    buildMCPServerConfig() {
+        return {
+            'servicenow-unified': {
+                type: 'stdio',
+                command: 'node',
+                args: [
+                    'dist/mcp/servicenow-mcp-unified/index.js'
+                ],
+                env: process.env
+            },
+            'claude-flow': {
+                type: 'stdio',
+                command: 'npx',
+                args: ['claude-flow@alpha', 'mcp', 'start'],
+                env: process.env
+            }
+        };
+    }
+    /**
+     * Build hooks for agent coordination
+     * Integrates with our Memory System and progress tracking
+     */
+    buildHooks(agentId, agentType) {
+        return {
+            PostToolUse: [{
+                    hooks: [async (input, toolUseId, { signal }) => {
+                            // Type guard for PostToolUseHookInput
+                            if (input.hook_event_name !== 'PostToolUse') {
+                                return { continue: true };
+                            }
+                            // Store tool execution in Memory for coordination
+                            if (input.tool_name.startsWith('snow_')) {
+                                await this.memory.store(`agent_tool_${agentId}_${toolUseId}`, {
+                                    agentId,
+                                    agentType,
+                                    toolName: input.tool_name,
+                                    toolInput: input.tool_input,
+                                    toolResponse: input.tool_response,
+                                    timestamp: new Date().toISOString()
+                                });
+                                this.emit('agent:tool-used', {
+                                    agentId,
+                                    agentType,
+                                    toolName: input.tool_name
+                                });
+                            }
+                            return { continue: true };
+                        }]
+                }],
+            SessionEnd: [{
+                    hooks: [async (input, toolUseId, { signal }) => {
+                            // Type guard for SessionEndHookInput
+                            if (input.hook_event_name !== 'SessionEnd') {
+                                return { continue: true };
+                            }
+                            // Store final session results
+                            await this.memory.store(`agent_session_${agentId}`, {
+                                agentId,
+                                agentType,
+                                reason: input.reason,
+                                timestamp: new Date().toISOString()
+                            });
+                            this.logger.info(`✅ Agent ${agentId} session ended: ${input.reason}`);
+                            return { continue: true };
+                        }]
+                }]
+        };
+    }
+    /**
+     * Process agent execution stream
+     * Extracts artifacts, tokens, and output
+     */
+    async processAgentExecution(agentId, agentType, agentQuery, startTime) {
+        const artifacts = [];
+        let output = '';
+        let tokensUsed = { input: 0, output: 0, total: 0 };
+        try {
+            // Stream agent messages
+            for await (const message of agentQuery) {
+                this.emit('agent:message', { agentId, message });
+                // Extract results from completion
+                if (message.type === 'result' && message.subtype === 'success') {
+                    output = message.result;
+                    tokensUsed = {
+                        input: message.usage.input_tokens,
+                        output: message.usage.output_tokens,
+                        total: message.usage.input_tokens + message.usage.output_tokens
+                    };
+                }
+                // Extract artifacts from tool responses
+                if (message.type === 'assistant') {
+                    const content = message.message.content;
+                    for (const block of content) {
+                        if (block.type === 'tool_use') {
+                            // Look for sys_ids in tool results
+                            const sysIdMatch = JSON.stringify(block).match(/[a-f0-9]{32}/g);
+                            if (sysIdMatch) {
+                                artifacts.push(...sysIdMatch);
+                            }
+                        }
+                    }
+                }
+            }
+            // Store final results in Memory
+            await this.memory.store(`agent_result_${agentId}`, {
+                agentId,
+                agentType,
+                success: true,
+                artifacts: [...new Set(artifacts)], // Remove duplicates
+                output,
+                tokensUsed,
+                duration: Date.now() - startTime
+            });
+            return {
+                success: true,
+                agentId,
+                agentType,
+                artifacts: [...new Set(artifacts)],
+                output,
+                tokensUsed,
+                duration: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Control running agent (interrupt, change model, etc.)
+     */
+    async controlAgent(agentId, action) {
+        const query = this.activeQueries.get(agentId);
+        if (!query) {
+            throw new Error(`Agent ${agentId} not found or already completed`);
+        }
+        if (action === 'interrupt') {
+            await query.interrupt();
+            this.logger.info(`⏸️ Agent ${agentId} interrupted`);
+        }
+    }
+    /**
+     * Get agent status
+     */
+    getAgentStatus(agentId) {
+        if (this.activeQueries.has(agentId)) {
+            return 'active';
+        }
+        // Check Memory for completed agents
+        const result = this.memory.get(`agent_result_${agentId}`);
+        return result ? 'completed' : 'not-found';
+    }
+    /**
+     * Utility methods
+     */
+    generateAgentId(type) {
+        return `sdk_${type}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    mapModelName(model) {
+        if (!model)
+            return undefined;
+        const modelMap = {
+            'sonnet': 'claude-3-5-sonnet-20241022',
+            'opus': 'claude-3-opus-20240229',
+            'haiku': 'claude-3-5-haiku-20241022'
+        };
+        return modelMap[model];
+    }
+    /**
+     * Cleanup
+     */
+    async shutdown() {
+        // Interrupt all active agents
+        for (const [agentId, query] of this.activeQueries.entries()) {
+            try {
+                await query.interrupt();
+                this.logger.info(`⏹️ Interrupted agent ${agentId}`);
+            }
+            catch (error) {
+                this.logger.error(`Failed to interrupt agent ${agentId}:`, error);
+            }
+        }
+        this.activeQueries.clear();
+        this.removeAllListeners();
+    }
+}
+exports.ClaudeAgentSDKIntegration = ClaudeAgentSDKIntegration;
+//# sourceMappingURL=claude-agent-sdk-integration.js.map