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" }],
  },
};