AI Agents

interface AIAgentConfig {
  agent: {
    name: string;              // Custom agent name
    systemPrompt: string;      // Agent personality and capabilities
    userPrompt: string;        // Specific task description
    thinkingMode: "fast" | "deliberate" | "collaborative";
    maxSteps: number;          // 1-50 reasoning steps
  };
  
  provider: {
    type: "openrouter" | "openai" | "anthropic" | "ollama";
    model: string;             // Specific model name
    temperature: number;       // 0-2 creativity level
    maxTokens: number;         // Response length limit
  };
  
  execution: {
    mode: "autonomous" | "interactive";  // Approval required?
    timeout: number;                     // Execution timeout (ms)
    saveThinking: boolean;               // Save reasoning steps
    requireApproval: boolean;            // Human approval required
  };
  
  selectedTools: ToolConfig[];           // Available MCP tools
}

// Real-time execution monitoring
interface ExecutionUpdate {
  nodeId: string;
  status: "running" | "completed" | "failed";
  progress: number;              // 0-100
  thinkingSteps: ThinkingStep[];
  toolCalls: ToolCall[];
  error?: string;
  startTime: Date;
  endTime?: Date;
  duration?: number;
}

// WebSocket connection for live updates
const { isConnected } = useExecutionWebSocket({
  executionId: data.executionId,
  onNodeUpdate: (update: NodeExecutionUpdate) => {
    // Update UI with real-time progress
    updateAgentStatus(update);
  },
  onExecutionLog: (log: ExecutionLog) => {
    // Display execution logs
    addLogEntry(log);
  },
});

// AI Agent as workflow block
interface AIAgentBlock extends WorkflowBlock {
  type: "AI_AGENT";
  config: AIAgentConfig;
  
  // Input from previous blocks
  inputs: {
    context?: Record<string, any>;
    prompt?: string;
    variables?: Record<string, any>;
  };
  
  // Output for subsequent blocks
  outputs: {
    result: string;           // Main agent response
    reasoning: ThinkingStep[]; // Reasoning process
    toolCalls: ToolCall[];    // Tool interactions
    metadata: ExecutionMetadata;
  };
}

// Template access to previous block outputs
const agentPrompt = `
  Analyze the data from the previous HTTP request: {{httpRequest.data}}
  Consider the current price: {{priceMonitor.currentPrice}}
  Execute appropriate blockchain operations based on the analysis.
`;

// Custom MCP server definition
interface CustomMCPServer {
  id: string;
  name: string;
  displayName: string;
  description: string;
  category: string;
  
  connection: {
    type: "stdio" | "http" | "websocket";
    command?: string;
    args?: string[];
    url?: string;
    env?: Record<string, string>;
  };
  
  configSchema: {
    type: "object";
    properties: Record<string, any>;
    required: string[];
  };
  
  tools: MCPTool[];
}

// Register custom server
const customServer: CustomMCPServer = {
  id: "custom-analytics",
  name: "custom-analytics",
  displayName: "Custom Analytics Engine",
  description: "Custom analytics and reporting tools",
  category: "analytics",
  
  connection: {
    type: "stdio",
    command: "python",
    args: ["./custom-analytics-server.py"],
    env: {
      "API_KEY": "{{secrets.analytics_api_key}}"
    }
  },
  
  configSchema: {
    type: "object",
    properties: {
      "API_KEY": {
        type: "string",
        description: "Analytics API key",
        required: true,
        sensitive: true
      }
    },
    required: ["API_KEY"]
  },
  
  tools: [
    {
      name: "analyze_portfolio",
      description: "Analyze portfolio performance and risks",
      parameters: {
        type: "object",
        properties: {
          portfolioData: { type: "object" },
          timeframe: { type: "string" }
        }
      }
    }
  ]
};

// Multi-agent workflow pattern
interface MultiAgentWorkflow {
  agents: {
    researcher: AIAgentConfig;     // Market research and analysis
    strategist: AIAgentConfig;     // Strategy development
    executor: AIAgentConfig;       // Transaction execution
    monitor: AIAgentConfig;        // Performance monitoring
  };
  
  coordination: {
    dataFlow: AgentDataFlow[];     // How agents share data
    dependencies: AgentDependency[]; // Execution order
    conflictResolution: ConflictResolutionStrategy;
  };
}

// Example coordination pattern
const defiWorkflow: MultiAgentWorkflow = {
  agents: {
    researcher: {
      agent: {
        name: "Market Researcher",
        systemPrompt: "Analyze market conditions and identify opportunities",
        tools: ["brave-search", "fetch", "sequential-thinking"]
      }
    },
    executor: {
      agent: {
        name: "Transaction Executor", 
        systemPrompt: "Execute transactions based on research findings",
        tools: ["goat", "sei"]
      }
    }
  },
  
  coordination: {
    dataFlow: [
      { from: "researcher", to: "executor", data: "marketAnalysis" }
    ]
  }
};