@geminilight/mindos 0.6.27 → 0.6.29

package/app/components/ui/Toaster.tsx

@@ -0,0 +1,39 @@
+'use client';
+
+import { useSyncExternalStore } from 'react';
+import { Check, AlertCircle, Info, X } from 'lucide-react';
+import { subscribe, getSnapshot, dismiss, type Toast } from '@/lib/toast';
+
+const icons: Record<Toast['type'], React.ReactNode> = {
+  success: <Check size={15} className="text-success shrink-0" />,
+  error: <AlertCircle size={15} className="text-error shrink-0" />,
+  info: <Info size={15} className="text-muted-foreground shrink-0" />,
+};
+
+export default function Toaster() {
+  const toasts = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+
+  if (toasts.length === 0) return null;
+
+  return (
+    <div className="fixed bottom-4 right-4 z-50 flex flex-col-reverse gap-2 pointer-events-none" aria-live="polite">
+      {toasts.map((t) => (
+        <div
+          key={t.id}
+          className="pointer-events-auto flex items-center gap-2.5 bg-card border border-border rounded-lg shadow-lg px-4 py-2.5 min-w-[180px] max-w-[320px] animate-in slide-in-from-right-4 fade-in duration-200"
+        >
+          {icons[t.type]}
+          <span className="text-sm text-foreground flex-1 truncate">{t.message}</span>
+          <button
+            type="button"
+            onClick={() => dismiss(t.id)}
+            className="shrink-0 p-0.5 rounded text-muted-foreground hover:text-foreground transition-colors"
+            aria-label="Dismiss"
+          >
+            <X size={13} />
+          </button>
+        </div>
+      ))}
+    </div>
+  );
+}

package/app/hooks/useA2aRegistry.ts

@@ -8,6 +8,7 @@ interface A2aRegistry {
   discovering: boolean;
   error: string | null;
   discover: (url: string) => Promise<RemoteAgent | null>;
+  remove: (id: string) => void;
   refresh: () => void;
 }
 
@@ -44,10 +45,14 @@ export function useA2aRegistry(): A2aRegistry {
     }
   }, []);
 
+  const remove = useCallback((id: string) => {
+    setAgents(prev => prev.filter(a => a.id !== id));
+  }, []);
+
   const refresh = useCallback(() => {
     setAgents([]);
     setError(null);
   }, []);
 
-  return { agents, discovering, error, discover, refresh };
+  return { agents, discovering, error, discover, remove, refresh };
 }

package/app/hooks/useAcpDetection.ts

@@ -0,0 +1,65 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+
+export interface DetectedAgent {
+  id: string;
+  name: string;
+  binaryPath: string;
+}
+
+export interface NotInstalledAgent {
+  id: string;
+  name: string;
+  installCmd: string;
+}
+
+interface AcpDetectionState {
+  installedAgents: DetectedAgent[];
+  notInstalledAgents: NotInstalledAgent[];
+  loading: boolean;
+  error: string | null;
+  refresh: () => void;
+}
+
+export function useAcpDetection(): AcpDetectionState {
+  const [installedAgents, setInstalledAgents] = useState<DetectedAgent[]>([]);
+  const [notInstalledAgents, setNotInstalledAgents] = useState<NotInstalledAgent[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [trigger, setTrigger] = useState(0);
+
+  const refresh = useCallback(() => {
+    setTrigger((n) => n + 1);
+  }, []);
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+
+    fetch('/api/acp/detect')
+      .then((res) => {
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return res.json();
+      })
+      .then((data) => {
+        if (cancelled) return;
+        setInstalledAgents(data.installed ?? []);
+        setNotInstalledAgents(data.notInstalled ?? []);
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        setError((err as Error).message);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [trigger]);
+
+  return { installedAgents, notInstalledAgents, loading, error, refresh };
+}

package/app/hooks/useAcpRegistry.ts

@@ -0,0 +1,51 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import type { AcpRegistryEntry } from '@/lib/acp/types';
+
+interface AcpRegistryState {
+  agents: AcpRegistryEntry[];
+  loading: boolean;
+  error: string | null;
+  retry: () => void;
+}
+
+export function useAcpRegistry(): AcpRegistryState {
+  const [agents, setAgents] = useState<AcpRegistryEntry[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [trigger, setTrigger] = useState(0);
+
+  const retry = useCallback(() => {
+    setTrigger((n) => n + 1);
+  }, []);
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setError(null);
+
+    fetch('/api/acp/registry')
+      .then((res) => {
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return res.json();
+      })
+      .then((data) => {
+        if (cancelled) return;
+        setAgents(data.registry?.agents ?? []);
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        setError((err as Error).message);
+      })
+      .finally(() => {
+        if (!cancelled) setLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [trigger]);
+
+  return { agents, loading, error, retry };
+}

package/app/hooks/useDelegationHistory.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { useState, useEffect, useCallback, useRef } from 'react';
+import type { DelegationRecord } from '@/lib/a2a/types';
+
+interface DelegationHistory {
+  delegations: DelegationRecord[];
+  loading: boolean;
+  refresh: () => void;
+}
+
+const POLL_INTERVAL_MS = 5_000;
+
+export function useDelegationHistory(active: boolean): DelegationHistory {
+  const [delegations, setDelegations] = useState<DelegationRecord[]>([]);
+  const [loading, setLoading] = useState(false);
+  const mountedRef = useRef(true);
+
+  const fetchHistory = useCallback(async () => {
+    setLoading(true);
+    try {
+      const res = await fetch('/api/a2a/delegations');
+      if (!res.ok) return;
+      const data = await res.json();
+      if (mountedRef.current) {
+        setDelegations(data.delegations ?? []);
+      }
+    } catch {
+      // silently ignore fetch errors
+    } finally {
+      if (mountedRef.current) setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => { mountedRef.current = false; };
+  }, []);
+
+  // Fetch on mount and poll while active
+  useEffect(() => {
+    if (!active) return;
+    fetchHistory();
+    const id = setInterval(fetchHistory, POLL_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, [active, fetchHistory]);
+
+  return { delegations, loading, refresh: fetchHistory };
+}

package/app/lib/a2a/client.ts

@@ -10,6 +10,7 @@ import type {
   JsonRpcRequest,
   JsonRpcResponse,
   SendMessageParams,
+  DelegationRecord,
 } from './types';
 
 /* ── Constants ─────────────────────────────────────────────────────────── */
@@ -22,6 +23,20 @@ const CARD_CACHE_TTL_MS = 5 * 60 * 1000; // 5 min
 
 const registry = new Map<string, RemoteAgent>();
 
+/* ── Delegation History ────────────────────────────────────────────────── */
+
+const delegationHistory: DelegationRecord[] = [];
+
+/** Get all delegation history records */
+export function getDelegationHistory(): DelegationRecord[] {
+  return [...delegationHistory];
+}
+
+/** Clear all delegation history records */
+export function clearDelegationHistory(): void {
+  delegationHistory.length = 0;
+}
+
 /** Derive a stable ID from a URL (includes protocol to avoid collisions) */
 function urlToId(url: string): string {
   try {
@@ -152,6 +167,19 @@ export async function delegateTask(
   if (!agent) throw new Error(`Agent not found: ${agentId}`);
   if (!agent.reachable) throw new Error(`Agent not reachable: ${agent.card.name}`);
 
+  const record: DelegationRecord = {
+    id: `del-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    agentId,
+    agentName: agent.card.name,
+    message,
+    status: 'pending',
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    result: null,
+    error: null,
+  };
+  delegationHistory.push(record);
+
   const params: SendMessageParams = {
     message: {
       role: 'ROLE_USER',
@@ -160,13 +188,29 @@ export async function delegateTask(
     configuration: { blocking: true },
   };
 
-  const response = await jsonRpcCall(agent.endpoint, 'SendMessage', params, token);
+  try {
+    const response = await jsonRpcCall(agent.endpoint, 'SendMessage', params, token);
 
-  if (response.error) {
-    throw new Error(`A2A error [${response.error.code}]: ${response.error.message}`);
-  }
+    if (response.error) {
+      record.status = 'failed';
+      record.completedAt = new Date().toISOString();
+      record.error = `A2A error [${response.error.code}]: ${response.error.message}`;
+      throw new Error(record.error);
+    }
 
-  return response.result as A2ATask;
+    const task = response.result as A2ATask;
+    record.status = 'completed';
+    record.completedAt = new Date().toISOString();
+    record.result = task.artifacts?.[0]?.parts?.[0]?.text ?? null;
+    return task;
+  } catch (err) {
+    if (record.status === 'pending') {
+      record.status = 'failed';
+      record.completedAt = new Date().toISOString();
+      record.error = (err as Error).message;
+    }
+    throw err;
+  }
 }
 
 /**

package/app/lib/a2a/orchestrator.ts

@@ -5,7 +5,6 @@
 
 import { randomUUID } from 'crypto';
 import type {
-  RemoteAgent,
   SubTask,
   OrchestrationPlan,
   ExecutionStrategy,

package/app/lib/a2a/task-handler.ts

@@ -200,18 +200,18 @@ export function handleGetTask(params: GetTaskParams): A2ATask | null {
   return tasks.get(params.id) ?? null;
 }
 
-export function handleCancelTask(params: CancelTaskParams): A2ATask | null {
+export function handleCancelTask(params: CancelTaskParams): { task: A2ATask | null; reason: 'not_found' | 'not_cancelable' | 'ok' } {
   const task = tasks.get(params.id);
-  if (!task) return null;
+  if (!task) return { task: null, reason: 'not_found' };
 
   const terminalStates: TaskState[] = ['TASK_STATE_COMPLETED', 'TASK_STATE_FAILED', 'TASK_STATE_CANCELED', 'TASK_STATE_REJECTED'];
-  if (terminalStates.includes(task.status.state)) return null; // not cancelable
+  if (terminalStates.includes(task.status.state)) return { task: null, reason: 'not_cancelable' };
 
   task.status = {
     state: 'TASK_STATE_CANCELED',
     timestamp: new Date().toISOString(),
   };
-  return task;
+  return { task, reason: 'ok' };
 }
 
 /* ── Helpers ───────────────────────────────────────────────────────────── */

package/app/lib/a2a/types.ts

@@ -210,3 +210,18 @@ export interface SkillMatch {
   skillName: string;
   confidence: number;
 }
+
+/* ── Delegation History (Phase 3 UI) ─────────────────────────────────── */
+
+/** A recorded delegation attempt for the history log */
+export interface DelegationRecord {
+  id: string;
+  agentId: string;
+  agentName: string;
+  message: string;
+  status: 'pending' | 'completed' | 'failed';
+  startedAt: string;
+  completedAt: string | null;
+  result: string | null;
+  error: string | null;
+}

package/app/lib/acp/acp-tools.ts

@@ -0,0 +1,93 @@
+/**
+ * ACP Agent Tools — Expose ACP capabilities as tools
+ * for the MindOS built-in agent to discover and invoke ACP agents.
+ */
+
+import { Type, type Static } from '@sinclair/typebox';
+import type { AgentTool } from '@mariozechner/pi-agent-core';
+import { getAcpAgents, findAcpAgent } from './registry';
+import { createSessionFromEntry, prompt, closeSession } from './session';
+
+function textResult(text: string) {
+  return { content: [{ type: 'text' as const, text }], details: {} };
+}
+
+/* ── Parameter Schemas ─────────────────────────────────────────────────── */
+
+const ListAcpAgentsParams = Type.Object({
+  tag: Type.Optional(Type.String({ description: 'Optional tag to filter agents by (e.g. "coding", "search")' })),
+});
+
+const CallAcpAgentParams = Type.Object({
+  agent_id: Type.String({ description: 'ID of the ACP agent from the registry (from list_acp_agents)' }),
+  message: Type.String({ description: 'Natural language message to send to the ACP agent' }),
+});
+
+/* ── Tool Implementations ──────────────────────────────────────────────── */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const acpTools: AgentTool<any>[] = [
+  {
+    name: 'list_acp_agents',
+    label: 'List ACP Agents',
+    description: 'List available ACP (Agent Client Protocol) agents from the public registry. These are local subprocess-based agents like Gemini CLI, Claude, Copilot, etc. Optionally filter by tag.',
+    parameters: ListAcpAgentsParams,
+    execute: async (_id: string, params: Static<typeof ListAcpAgentsParams>) => {
+      try {
+        let agents = await getAcpAgents();
+
+        if (params.tag) {
+          const tag = params.tag.toLowerCase();
+          agents = agents.filter(a =>
+            a.tags?.some(t => t.toLowerCase().includes(tag))
+          );
+        }
+
+        if (agents.length === 0) {
+          return textResult(
+            params.tag
+              ? `No ACP agents found with tag "${params.tag}". Try list_acp_agents without a tag filter.`
+              : 'No ACP agents found in the registry. The registry may be unavailable.'
+          );
+        }
+
+        const lines = agents.map(a => {
+          const tags = a.tags?.join(', ') || 'none';
+          return `- **${a.name}** (id: \`${a.id}\`, transport: ${a.transport})\n  ${a.description}\n  Tags: ${tags}`;
+        });
+
+        return textResult(`Available ACP agents (${agents.length}):\n\n${lines.join('\n\n')}`);
+      } catch (err) {
+        return textResult(`Failed to list ACP agents: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'call_acp_agent',
+    label: 'Call ACP Agent',
+    description: 'Spawn an ACP agent, send it a message, and return the result. The agent runs as a local subprocess. Use list_acp_agents first to see available agents.',
+    parameters: CallAcpAgentParams,
+    execute: async (_id: string, params: Static<typeof CallAcpAgentParams>) => {
+      try {
+        const entry = await findAcpAgent(params.agent_id);
+        if (!entry) {
+          return textResult(`ACP agent not found: ${params.agent_id}. Use list_acp_agents to see available agents.`);
+        }
+
+        const session = await createSessionFromEntry(entry);
+
+        try {
+          const response = await prompt(session.id, params.message);
+          return textResult(
+            `**${entry.name}** responded:\n\n${response.text || '(empty response)'}`
+          );
+        } finally {
+          await closeSession(session.id).catch(() => {});
+        }
+      } catch (err) {
+        return textResult(`ACP call failed: ${(err as Error).message}`);
+      }
+    },
+  },
+];

package/app/lib/acp/bridge.ts

@@ -0,0 +1,138 @@
+/**
+ * A2A-ACP Bridge — Translate between A2A protocol and ACP protocol.
+ * Allows A2A agents to delegate to ACP agents transparently,
+ * and ACP session results to be returned as A2A tasks.
+ */
+
+import type { A2AMessage, A2ATask, TaskState } from '@/lib/a2a/types';
+import type { AcpPromptResponse, AcpSessionUpdate } from './types';
+import { createSession, prompt, closeSession } from './session';
+
+/* ── A2A → ACP ─────────────────────────────────────────────────────────── */
+
+/**
+ * Bridge an A2A SendMessage request to an ACP session/prompt.
+ * Creates a session, sends the message, returns the result, then closes.
+ */
+export async function bridgeA2aToAcp(
+  a2aMessage: A2AMessage,
+  acpAgentId: string,
+): Promise<A2ATask> {
+  const taskId = `acp-bridge-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  // Extract text from A2A message parts
+  const text = a2aMessage.parts
+    .map(p => p.text ?? '')
+    .filter(Boolean)
+    .join('\n');
+
+  if (!text) {
+    return makeFailedTask(taskId, 'No text content in A2A message');
+  }
+
+  let session;
+  try {
+    session = await createSession(acpAgentId);
+  } catch (err) {
+    return makeFailedTask(taskId, `Failed to create ACP session: ${(err as Error).message}`);
+  }
+
+  try {
+    const response = await prompt(session.id, text);
+    return bridgeAcpResponseToA2a(taskId, response);
+  } catch (err) {
+    return makeFailedTask(taskId, `ACP prompt failed: ${(err as Error).message}`);
+  } finally {
+    await closeSession(session.id).catch(() => {});
+  }
+}
+
+/* ── ACP → A2A ─────────────────────────────────────────────────────────── */
+
+/**
+ * Convert a completed ACP prompt response to an A2A task result.
+ */
+export function bridgeAcpResponseToA2a(
+  taskId: string,
+  response: AcpPromptResponse,
+): A2ATask {
+  return {
+    id: taskId,
+    status: {
+      state: 'TASK_STATE_COMPLETED',
+      message: {
+        role: 'ROLE_AGENT',
+        parts: [{ text: response.text }],
+      },
+      timestamp: new Date().toISOString(),
+    },
+    artifacts: response.text ? [{
+      artifactId: `${taskId}-artifact`,
+      parts: [{ text: response.text }],
+    }] : undefined,
+  };
+}
+
+/**
+ * Convert a stream of ACP session updates to A2A task updates.
+ * Aggregates text updates and maps final state.
+ */
+export function bridgeAcpUpdatesToA2a(
+  taskId: string,
+  updates: AcpSessionUpdate[],
+): A2ATask {
+  let aggregatedText = '';
+  let finalState: TaskState = 'TASK_STATE_WORKING';
+  let errorMessage = '';
+
+  for (const update of updates) {
+    switch (update.type) {
+      case 'text':
+        aggregatedText += update.text ?? '';
+        break;
+      case 'done':
+        finalState = 'TASK_STATE_COMPLETED';
+        break;
+      case 'error':
+        finalState = 'TASK_STATE_FAILED';
+        errorMessage = update.error ?? 'Unknown error';
+        break;
+    }
+  }
+
+  if (finalState === 'TASK_STATE_FAILED') {
+    return makeFailedTask(taskId, errorMessage);
+  }
+
+  return {
+    id: taskId,
+    status: {
+      state: finalState,
+      message: aggregatedText ? {
+        role: 'ROLE_AGENT',
+        parts: [{ text: aggregatedText }],
+      } : undefined,
+      timestamp: new Date().toISOString(),
+    },
+    artifacts: aggregatedText ? [{
+      artifactId: `${taskId}-artifact`,
+      parts: [{ text: aggregatedText }],
+    }] : undefined,
+  };
+}
+
+/* ── Internal ──────────────────────────────────────────────────────────── */
+
+function makeFailedTask(taskId: string, error: string): A2ATask {
+  return {
+    id: taskId,
+    status: {
+      state: 'TASK_STATE_FAILED',
+      message: {
+        role: 'ROLE_AGENT',
+        parts: [{ text: error }],
+      },
+      timestamp: new Date().toISOString(),
+    },
+  };
+}

package/app/lib/acp/index.ts

@@ -0,0 +1,24 @@
+export { fetchAcpRegistry, getAcpAgents, findAcpAgent, clearRegistryCache } from './registry';
+export { spawnAcpAgent, sendMessage, sendAndWait, onMessage, killAgent, killAllAgents, getProcess, getActiveProcesses } from './subprocess';
+export { createSession, createSessionFromEntry, prompt, promptStream, cancelPrompt, closeSession, getSession, getActiveSessions, closeAllSessions } from './session';
+export { bridgeA2aToAcp, bridgeAcpResponseToA2a, bridgeAcpUpdatesToA2a } from './bridge';
+export { acpTools } from './acp-tools';
+export { ACP_ERRORS } from './types';
+export type {
+  AcpCapabilities,
+  AcpSessionState,
+  AcpSession,
+  AcpJsonRpcRequest,
+  AcpJsonRpcResponse,
+  AcpJsonRpcError,
+  AcpPromptRequest,
+  AcpPromptResponse,
+  AcpUpdateType,
+  AcpSessionUpdate,
+  AcpToolCall,
+  AcpToolResult,
+  AcpRegistryEntry,
+  AcpRegistry,
+  AcpTransportType,
+} from './types';
+export type { AcpProcess } from './subprocess';