snow-flow 2.0.2 → 2.0.3

package/src/mcp/shared/agent-context-provider.ts

@@ -1,365 +0,0 @@
-/**
- * Agent Context Provider for MCP Operations
- * Provides agent context awareness and tracking for all MCP tools
- */
-
-import { MCPMemoryManager, AgentContext } from './mcp-memory-manager.js';
-import { Logger } from '../../utils/logger.js';
-
-export interface MCPOperationContext {
-  session_id: string;
-  agent_id: string;
-  agent_type: string;
-  operation_name: string;
-  mcp_server: string;
-}
-
-export interface OperationResult<T = any> {
-  success: boolean;
-  data?: T;
-  error?: string;
-  duration_ms: number;
-  memory_updates?: Record<string, any>;
-}
-
-export class AgentContextProvider {
-  private memory: MCPMemoryManager;
-  private logger: Logger;
-
-  constructor() {
-    this.memory = MCPMemoryManager.getInstance();
-    this.logger = new Logger('AgentContextProvider');
-  }
-
-  /**
-   * Extract agent context from tool arguments or environment
-   */
-  extractAgentContext(args: any): AgentContext {
-    // Check if agent context is provided in args
-    if (args.agent_context) {
-      return args.agent_context;
-    }
-
-    // Check for session_id and agent_id in args
-    if (args.session_id && args.agent_id) {
-      return {
-        session_id: args.session_id,
-        agent_id: args.agent_id,
-        agent_type: args.agent_type || 'unknown'
-      };
-    }
-
-    // Check environment variables (for backward compatibility)
-    const session_id = process.env.SNOW_FLOW_SESSION_ID || `session_${Date.now()}`;
-    const agent_id = process.env.SNOW_FLOW_AGENT_ID || `agent_${Date.now()}`;
-    const agent_type = process.env.SNOW_FLOW_AGENT_TYPE || 'mcp_direct';
-
-    return {
-      session_id,
-      agent_id,
-      agent_type
-    };
-  }
-
-  /**
-   * Execute an MCP operation with full agent context tracking
-   */
-  async executeWithContext<T>(
-    context: MCPOperationContext,
-    operation: () => Promise<T>
-  ): Promise<OperationResult<T>> {
-    const startTime = Date.now();
-    const { session_id, agent_id, operation_name } = context;
-
-    try {
-      // Update agent coordination - mark as active
-      await this.memory.updateAgentCoordination({
-        session_id,
-        agent_id,
-        agent_type: context.agent_type,
-        status: 'active',
-        current_tool: operation_name,
-        progress_percentage: 0
-      });
-
-      // Execute the operation
-      const result = await operation();
-      const duration = Date.now() - startTime;
-
-      // Track performance
-      await this.memory.trackPerformance({
-        session_id,
-        agent_id,
-        operation_name,
-        duration_ms: duration,
-        success: true
-      });
-
-      // Update progress
-      await this.memory.updateAgentCoordination({
-        session_id,
-        agent_id,
-        progress_percentage: 100,
-        current_tool: null
-      });
-
-      return {
-        success: true,
-        data: result,
-        duration_ms: duration
-      };
-
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-
-      // Track failed operation
-      await this.memory.trackPerformance({
-        session_id,
-        agent_id,
-        operation_name,
-        duration_ms: duration,
-        success: false,
-        error_message: errorMessage
-      });
-
-      // Update agent status with error
-      await this.memory.updateAgentCoordination({
-        session_id,
-        agent_id,
-        status: 'blocked',
-        error_state: errorMessage,
-        current_tool: null
-      });
-
-      return {
-        success: false,
-        error: errorMessage,
-        duration_ms: duration
-      };
-    }
-  }
-
-  /**
-   * Report progress during long-running operations
-   */
-  async reportProgress(
-    context: AgentContext,
-    progress: number,
-    phase?: string
-  ): Promise<void> {
-    try {
-      await this.memory.updateAgentCoordination({
-        session_id: context.session_id,
-        agent_id: context.agent_id,
-        agent_type: context.agent_type,
-        progress_percentage: Math.min(100, Math.max(0, progress)),
-        current_tool: phase
-      });
-
-      // Optionally update shared context with detailed progress
-      if (phase) {
-        await this.memory.updateSharedContext({
-          session_id: context.session_id,
-          context_key: `${context.agent_id}_progress`,
-          context_value: JSON.stringify({
-            progress,
-            phase,
-            timestamp: new Date().toISOString()
-          }),
-          created_by_agent: context.agent_id
-        });
-      }
-    } catch (error) {
-      this.logger.error('Failed to report progress', error);
-    }
-  }
-
-  /**
-   * Notify other agents of handoff or completion
-   */
-  async notifyHandoff(
-    from_context: AgentContext,
-    to_agent: string,
-    artifact_info: {
-      type: string;
-      sys_id: string;
-      next_steps: string[];
-    }
-  ): Promise<void> {
-    try {
-      await this.memory.sendAgentMessage({
-        session_id: from_context.session_id,
-        from_agent: from_context.agent_id,
-        to_agent,
-        message_type: 'handoff',
-        content: JSON.stringify({
-          artifact_type: artifact_info.type,
-          artifact_sys_id: artifact_info.sys_id,
-          next_steps: artifact_info.next_steps,
-          handoff_time: new Date().toISOString()
-        }),
-        artifact_reference: artifact_info.sys_id
-      });
-
-      // Update shared context for the handoff
-      await this.memory.updateSharedContext({
-        session_id: from_context.session_id,
-        context_key: `${artifact_info.type}_ready_for_${to_agent}`,
-        context_value: JSON.stringify({
-          sys_id: artifact_info.sys_id,
-          ready: true,
-          from_agent: from_context.agent_id,
-          next_steps: artifact_info.next_steps
-        }),
-        created_by_agent: from_context.agent_id
-      });
-
-      this.logger.info(`Notified handoff from ${from_context.agent_id} to ${to_agent}`);
-    } catch (error) {
-      this.logger.error('Failed to notify handoff', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Check for pending work from other agents
-   */
-  async checkForHandoffs(context: AgentContext): Promise<any[]> {
-    try {
-      const messages = await this.memory.checkForMessages(
-        context.agent_id,
-        context.session_id
-      );
-
-      const handoffs = messages
-        .filter(m => m.message_type === 'handoff')
-        .map(m => {
-          try {
-            return JSON.parse(m.content);
-          } catch {
-            return m.content;
-          }
-        });
-
-      return handoffs;
-    } catch (error) {
-      this.logger.error('Failed to check for handoffs', error);
-      return [];
-    }
-  }
-
-  /**
-   * Store artifact information with agent tracking
-   */
-  async storeArtifact(
-    context: AgentContext,
-    artifact: {
-      sys_id: string;
-      type: string;
-      name: string;
-      description?: string;
-      config?: any;
-      update_set_id?: string;
-    }
-  ): Promise<void> {
-    try {
-      await this.memory.storeArtifact({
-        sys_id: artifact.sys_id,
-        artifact_type: artifact.type,
-        name: artifact.name,
-        description: artifact.description,
-        created_by_agent: context.agent_id,
-        session_id: context.session_id,
-        deployment_status: 'created',
-        update_set_id: artifact.update_set_id,
-        metadata: artifact.config ? JSON.stringify(artifact.config) : undefined
-      });
-
-      // Update shared context
-      await this.memory.updateSharedContext({
-        session_id: context.session_id,
-        context_key: `${artifact.type}_${artifact.name}_created`,
-        context_value: JSON.stringify({
-          sys_id: artifact.sys_id,
-          created_by: context.agent_id,
-          timestamp: new Date().toISOString()
-        }),
-        created_by_agent: context.agent_id
-      });
-
-      this.logger.info(`Stored artifact ${artifact.name} (${artifact.sys_id})`);
-    } catch (error) {
-      this.logger.error('Failed to store artifact', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Request Queen intervention for critical issues
-   */
-  async requestQueenIntervention(
-    context: AgentContext,
-    issue: {
-      type: string;
-      priority: 'low' | 'medium' | 'high' | 'critical';
-      description: string;
-      attempted_solutions?: string[];
-    }
-  ): Promise<void> {
-    try {
-      await this.memory.sendAgentMessage({
-        session_id: context.session_id,
-        from_agent: context.agent_id,
-        to_agent: 'queen_agent',
-        message_type: 'error',
-        content: JSON.stringify({
-          issue_type: issue.type,
-          priority: issue.priority,
-          description: issue.description,
-          attempted_solutions: issue.attempted_solutions || [],
-          requesting_agent: context.agent_id,
-          timestamp: new Date().toISOString()
-        })
-      });
-
-      // Update agent status to blocked
-      await this.memory.updateAgentCoordination({
-        session_id: context.session_id,
-        agent_id: context.agent_id,
-        agent_type: context.agent_type,
-        status: 'blocked',
-        error_state: issue.description
-      });
-
-      this.logger.warn(`Requested Queen intervention for ${issue.type}`);
-    } catch (error) {
-      this.logger.error('Failed to request Queen intervention', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Get session artifacts created by all agents
-   */
-  async getSessionArtifacts(session_id: string): Promise<any[]> {
-    try {
-      return await this.memory.getSessionArtifacts(session_id);
-    } catch (error) {
-      this.logger.error('Failed to get session artifacts', error);
-      return [];
-    }
-  }
-
-  /**
-   * Get current session context
-   */
-  async getSessionContext(session_id: string): Promise<any> {
-    try {
-      return await this.memory.getSessionContext(session_id);
-    } catch (error) {
-      this.logger.error('Failed to get session context', error);
-      return {};
-    }
-  }
-}