1  import { useState, useEffect, useCallback } from 'react';
  2  import { AgentService } from '../services/agents';
  3  import type { AgentInfo, SpecializedAgent, AgentStatus } from '../types/agents';
  4  
  5  /**
  6   * Hook for managing agent list
  7   */
  8  export function useAgents() {
  9    const [agents, setAgents] = useState<AgentInfo[]>([]);
 10    const [loading, setLoading] = useState(true);
 11    const [error, setError] = useState<string | null>(null);
 12  
 13    const loadAgents = useCallback(async () => {
 14      try {
 15        setLoading(true);
 16        setError(null);
 17        const agentList = await AgentService.listAgents();
 18        setAgents(agentList);
 19      } catch (err) {
 20        setError(err instanceof Error ? err.message : 'Failed to load agents');
 21      } finally {
 22        setLoading(false);
 23      }
 24    }, []);
 25  
 26    useEffect(() => {
 27      loadAgents();
 28    }, [loadAgents]);
 29  
 30    return { agents, loading, error, reload: loadAgents };
 31  }
 32  
 33  /**
 34   * Hook for managing a specific agent
 35   */
 36  export function useAgent(agentName: string | null) {
 37    const [agent, setAgent] = useState<SpecializedAgent | null>(null);
 38    const [loading, setLoading] = useState(false);
 39    const [error, setError] = useState<string | null>(null);
 40  
 41    const loadAgent = useCallback(async () => {
 42      if (!agentName) {
 43        setAgent(null);
 44        return;
 45      }
 46  
 47      try {
 48        setLoading(true);
 49        setError(null);
 50        const agentDetails = await AgentService.getAgentDetails(agentName);
 51        setAgent(agentDetails);
 52      } catch (err) {
 53        setError(err instanceof Error ? err.message : 'Failed to load agent');
 54      } finally {
 55        setLoading(false);
 56      }
 57    }, [agentName]);
 58  
 59    useEffect(() => {
 60      loadAgent();
 61    }, [loadAgent]);
 62  
 63    return { agent, loading, error, reload: loadAgent };
 64  }
 65  
 66  /**
 67   * Hook for invoking agents
 68   */
 69  export function useAgentInvocation() {
 70    const [loading, setLoading] = useState(false);
 71    const [error, setError] = useState<string | null>(null);
 72    const [result, setResult] = useState<string | null>(null);
 73  
 74    const invoke = useCallback(async (agentName: string, task: string) => {
 75      try {
 76        setLoading(true);
 77        setError(null);
 78        const response = await AgentService.invokeAgent(agentName, task);
 79        setResult(response);
 80        return response;
 81      } catch (err) {
 82        const errorMsg = err instanceof Error ? err.message : 'Failed to invoke agent';
 83        setError(errorMsg);
 84        throw err;
 85      } finally {
 86        setLoading(false);
 87      }
 88    }, []);
 89  
 90    return { invoke, loading, error, result };
 91  }
 92  
 93  /**
 94   * Hook for agent status
 95   */
 96  export function useAgentStatus(agentName: string | null) {
 97    const [status, setStatus] = useState<AgentStatus | null>(null);
 98    const [loading, setLoading] = useState(false);
 99    const [error, setError] = useState<string | null>(null);
100  
101    const loadStatus = useCallback(async () => {
102      if (!agentName) {
103        setStatus(null);
104        return;
105      }
106  
107      try {
108        setLoading(true);
109        setError(null);
110        const agentStatus = await AgentService.getAgentStatus(agentName);
111        setStatus(agentStatus);
112      } catch (err) {
113        setError(err instanceof Error ? err.message : 'Failed to load agent status');
114      } finally {
115        setLoading(false);
116      }
117    }, [agentName]);
118  
119    useEffect(() => {
120      loadStatus();
121    }, [loadStatus]);
122  
123    return { status, loading, error, reload: loadStatus };
124  }
125  
126  /**
127   * Hook for orchestrating tasks across multiple agents
128   */
129  export function useOrchestration() {
130    const [loading, setLoading] = useState(false);
131    const [error, setError] = useState<string | null>(null);
132    const [result, setResult] = useState<string | null>(null);
133  
134    const orchestrate = useCallback(async (task: string, agents: string[]) => {
135      try {
136        setLoading(true);
137        setError(null);
138        const response = await AgentService.orchestrateTask(task, agents);
139        setResult(response);
140        return response;
141      } catch (err) {
142        const errorMsg = err instanceof Error ? err.message : 'Failed to orchestrate task';
143        setError(errorMsg);
144        throw err;
145      } finally {
146        setLoading(false);
147      }
148    }, []);
149  
150    return { orchestrate, loading, error, result };
151  }