@geminilight/mindos 0.6.25 → 0.6.27

package/app/hooks/useAskSession.ts

@@ -78,13 +78,19 @@ export function useAskSession(currentFile?: string) {
   const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
   const persistTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  /** Load sessions from server, pick the matching one or create fresh. */
+  /** Load sessions from server, pick the matching one or create fresh. Prunes stale empty sessions. */
   const initSessions = useCallback(async () => {
-    const sorted = (await fetchSessions())
+    const all = (await fetchSessions())
       .sort((a, b) => b.updatedAt - a.updatedAt)
       .slice(0, MAX_SESSIONS);
-    setSessions(sorted);
 
+    // Prune any empty sessions that leaked to server (from older versions)
+    const emptyIds = all.filter((s) => s.messages.length === 0).map((s) => s.id);
+    const sorted = emptyIds.length > 0 ? all.filter((s) => !emptyIds.includes(s.id)) : all;
+    if (emptyIds.length > 0) void removeSessions(emptyIds);
+
+    // Always prepend a fresh empty session in memory (never persisted until first message)
+    const fresh = createSession(currentFile);
     const matched = currentFile
       ? sorted.find((sess) => sess.currentFile === currentFile)
       : sorted[0];
@@ -92,20 +98,19 @@ export function useAskSession(currentFile?: string) {
     if (matched) {
       setActiveSessionId(matched.id);
       setMessages(matched.messages);
+      setSessions([...sorted]);
     } else {
-      const fresh = createSession(currentFile);
       setActiveSessionId(fresh.id);
       setMessages([]);
-      const next = [fresh, ...sorted].slice(0, MAX_SESSIONS);
-      setSessions(next);
-      await upsertSession(fresh);
+      // Empty session lives only in memory — no upsertSession call
+      setSessions([fresh, ...sorted].slice(0, MAX_SESSIONS));
     }
   }, [currentFile]);
 
-  /** Persist current session (debounced). */
+  /** Persist current session (debounced). Only persists if session has messages. */
   const persistSession = useCallback(
     (msgs: Message[], sessionId: string | null) => {
-      if (!sessionId) return;
+      if (!sessionId || msgs.length === 0) return;
       let sessionToPersist: ChatSession | null = null;
       setSessions((prev) => {
         const now = Date.now();
@@ -135,35 +140,48 @@ export function useAskSession(currentFile?: string) {
     }
   }, []);
 
-  /** Create a brand-new session. */
+  /** Create a brand-new session (memory only). If current session is already empty, reuse it. */
   const resetSession = useCallback(() => {
-    const fresh = createSession(currentFile);
-    setActiveSessionId(fresh.id);
-    setMessages([]);
     setSessions((prev) => {
-      const next = [fresh, ...prev]
+      const active = prev.find((s) => s.id === activeSessionId);
+      // Already on an empty session — just clear input, don't create another
+      if (active && active.messages.length === 0) return prev;
+
+      const fresh = createSession(currentFile);
+      setActiveSessionId(fresh.id);
+      setMessages([]);
+      // Memory only — no upsertSession call. Will be persisted on first message.
+      return [fresh, ...prev]
         .sort((a, b) => b.updatedAt - a.updatedAt)
         .slice(0, MAX_SESSIONS);
-      void upsertSession(fresh);
-      return next;
     });
-  }, [currentFile]);
+  }, [currentFile, activeSessionId]);
 
-  /** Switch to an existing session. */
+  /** Switch to an existing session. Auto-drops abandoned empty sessions from memory. */
   const loadSession = useCallback(
     (id: string) => {
       const target = sessions.find((s) => s.id === id);
       if (!target) return;
+
+      // Drop the session we're leaving if it's empty (it was never persisted, just remove from memory)
+      const leaving = activeSessionId ? sessions.find((s) => s.id === activeSessionId) : null;
+      if (leaving && leaving.messages.length === 0 && leaving.id !== id) {
+        setSessions((prev) => prev.filter((s) => s.id !== leaving.id));
+      }
+
       setActiveSessionId(target.id);
       setMessages(target.messages);
     },
-    [sessions],
+    [sessions, activeSessionId],
   );
 
-  /** Delete a session. If it's the active one, create fresh. */
+  /** Delete a session. If it's the active one, create fresh (memory only). */
   const deleteSession = useCallback(
     (id: string) => {
-      void removeSession(id);
+      const target = sessions.find((s) => s.id === id);
+      // Only call removeSession if the session has messages (i.e. was persisted)
+      if (target && target.messages.length > 0) void removeSession(id);
+
       const remaining = sessions.filter((s) => s.id !== id);
       setSessions(remaining);
 
@@ -172,21 +190,22 @@ export function useAskSession(currentFile?: string) {
         setActiveSessionId(fresh.id);
         setMessages([]);
         setSessions([fresh, ...remaining].slice(0, MAX_SESSIONS));
-        void upsertSession(fresh);
+        // No upsertSession — memory only
       }
     },
     [activeSessionId, currentFile, sessions],
   );
 
   const clearAllSessions = useCallback(() => {
-    const allIds = sessions.map(s => s.id);
-    void removeSessions(allIds);
+    // Only delete sessions that have messages (were persisted)
+    const persistedIds = sessions.filter(s => s.messages.length > 0).map(s => s.id);
+    if (persistedIds.length > 0) void removeSessions(persistedIds);
 
     const fresh = createSession(currentFile);
     setActiveSessionId(fresh.id);
     setMessages([]);
     setSessions([fresh]);
-    void upsertSession(fresh);
+    // No upsertSession — memory only
   }, [currentFile, sessions]);
 
   return {

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

@@ -0,0 +1,212 @@
+/**
+ * A2A Agent Tools — Expose A2A client capabilities as tools
+ * for the MindOS built-in agent to discover and delegate to external agents.
+ */
+
+import { Type, type Static } from '@sinclair/typebox';
+import type { AgentTool } from '@mariozechner/pi-agent-core';
+import {
+  discoverAgent,
+  discoverAgents,
+  delegateTask,
+  checkRemoteTaskStatus,
+  getDiscoveredAgents,
+} from './client';
+import { createPlan, executePlan } from './orchestrator';
+
+function textResult(text: string) {
+  return { content: [{ type: 'text' as const, text }], details: {} };
+}
+
+/* ── Parameter Schemas ─────────────────────────────────────────────────── */
+
+const DiscoverAgentParams = Type.Object({
+  url: Type.String({ description: 'Base URL of the agent to discover (e.g. http://localhost:3456)' }),
+});
+
+const DiscoverMultipleParams = Type.Object({
+  urls: Type.Array(Type.String(), { description: 'List of base URLs to discover agents from' }),
+});
+
+const DelegateParams = Type.Object({
+  agent_id: Type.String({ description: 'ID of the target agent (from list_remote_agents)' }),
+  message: Type.String({ description: 'Natural language message to send to the agent' }),
+});
+
+const CheckStatusParams = Type.Object({
+  agent_id: Type.String({ description: 'ID of the agent that owns the task' }),
+  task_id: Type.String({ description: 'Task ID returned by delegate_to_agent' }),
+});
+
+const OrchestrateParams = Type.Object({
+  request: Type.String({ description: 'The complex request to decompose and execute across multiple agents' }),
+  subtasks: Type.Optional(Type.Array(Type.String(), { description: 'Pre-decomposed subtask descriptions. If omitted, auto-decomposition is used.' })),
+  strategy: Type.Optional(Type.Union([
+    Type.Literal('parallel'),
+    Type.Literal('sequential'),
+  ], { description: 'Execution strategy: parallel (default) or sequential', default: 'parallel' })),
+});
+
+/* ── Tool Implementations ──────────────────────────────────────────────── */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const a2aTools: AgentTool<any>[] = [
+  {
+    name: 'list_remote_agents',
+    label: 'List Remote Agents',
+    description: 'List all discovered remote A2A agents and their capabilities. Shows agent ID, name, skills, and reachability status. Call discover_agent first to add agents.',
+    parameters: Type.Object({}),
+    execute: async (_id: string) => {
+      const agents = getDiscoveredAgents();
+      if (agents.length === 0) {
+        return textResult('No remote agents discovered yet. Use discover_agent with a URL to find agents.');
+      }
+      const lines = agents.map(a => {
+        const skills = a.card.skills.map(s => s.name).join(', ');
+        const status = a.reachable ? 'reachable' : 'unreachable';
+        return `- **${a.card.name}** (id: ${a.id}, ${status})\n  Skills: ${skills || 'none declared'}`;
+      });
+      return textResult(`Discovered agents:\n\n${lines.join('\n\n')}`);
+    },
+  },
+
+  {
+    name: 'discover_agent',
+    label: 'Discover Remote Agent',
+    description: 'Discover a remote A2A agent by fetching its agent card from the given URL. The agent card describes the agent\'s capabilities and skills.',
+    parameters: DiscoverAgentParams,
+    execute: async (_id: string, params: Static<typeof DiscoverAgentParams>) => {
+      try {
+        const agent = await discoverAgent(params.url);
+        if (!agent) {
+          return textResult(`No A2A agent found at ${params.url}. The server may not support the A2A protocol.`);
+        }
+        const skills = agent.card.skills.map(s => `  - ${s.name}: ${s.description}`).join('\n');
+        return textResult(
+          `Discovered agent: **${agent.card.name}** (v${agent.card.version})\n` +
+          `ID: ${agent.id}\n` +
+          `Description: ${agent.card.description}\n` +
+          `Endpoint: ${agent.endpoint}\n` +
+          `Skills:\n${skills || '  (none declared)'}`
+        );
+      } catch (err) {
+        return textResult(`Failed to discover agent at ${params.url}: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'discover_agents',
+    label: 'Discover Multiple Agents',
+    description: 'Discover multiple remote A2A agents by fetching their agent cards concurrently. Returns all successfully discovered agents.',
+    parameters: DiscoverMultipleParams,
+    execute: async (_id: string, params: Static<typeof DiscoverMultipleParams>) => {
+      try {
+        const agents = await discoverAgents(params.urls);
+        if (agents.length === 0) {
+          return textResult(`No A2A agents found at any of the ${params.urls.length} URLs.`);
+        }
+        const lines = agents.map(a =>
+          `- **${a.card.name}** (id: ${a.id}) — ${a.card.skills.length} skills`
+        );
+        return textResult(`Discovered ${agents.length}/${params.urls.length} agents:\n\n${lines.join('\n')}`);
+      } catch (err) {
+        return textResult(`Discovery failed: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'delegate_to_agent',
+    label: 'Delegate Task to Agent',
+    description: 'Send a task to a remote A2A agent. The agent will process the message and return a result. Use list_remote_agents to see available agents and their skills first.',
+    parameters: DelegateParams,
+    execute: async (_id: string, params: Static<typeof DelegateParams>) => {
+      try {
+        const task = await delegateTask(params.agent_id, params.message);
+
+        if (task.status.state === 'TASK_STATE_COMPLETED') {
+          const result = task.artifacts?.[0]?.parts?.[0]?.text
+            ?? task.history?.find(m => m.role === 'ROLE_AGENT')?.parts?.[0]?.text
+            ?? 'Task completed (no text result)';
+          return textResult(`Agent completed task (id: ${task.id}):\n\n${result}`);
+        }
+
+        if (task.status.state === 'TASK_STATE_FAILED') {
+          const errMsg = task.status.message?.parts?.[0]?.text ?? 'Unknown error';
+          return textResult(`Agent failed task (id: ${task.id}): ${errMsg}`);
+        }
+
+        // Task is still in progress (non-blocking)
+        return textResult(
+          `Task submitted (id: ${task.id}, state: ${task.status.state}).\n` +
+          `Use check_task_status to poll for completion.`
+        );
+      } catch (err) {
+        return textResult(`Delegation failed: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'check_task_status',
+    label: 'Check Remote Task Status',
+    description: 'Check the status of a task previously delegated to a remote agent. Returns the current state, any results, or error information.',
+    parameters: CheckStatusParams,
+    execute: async (_id: string, params: Static<typeof CheckStatusParams>) => {
+      try {
+        const task = await checkRemoteTaskStatus(params.agent_id, params.task_id);
+
+        const state = task.status.state;
+        if (state === 'TASK_STATE_COMPLETED') {
+          const result = task.artifacts?.[0]?.parts?.[0]?.text ?? 'Completed (no text)';
+          return textResult(`Task ${params.task_id} completed:\n\n${result}`);
+        }
+        if (state === 'TASK_STATE_FAILED') {
+          const errMsg = task.status.message?.parts?.[0]?.text ?? 'Unknown error';
+          return textResult(`Task ${params.task_id} failed: ${errMsg}`);
+        }
+
+        return textResult(`Task ${params.task_id} state: ${state}`);
+      } catch (err) {
+        return textResult(`Status check failed: ${(err as Error).message}`);
+      }
+    },
+  },
+
+  {
+    name: 'orchestrate',
+    label: 'Orchestrate Multi-Agent Task',
+    description: 'Decompose a complex request into subtasks and execute them across multiple remote agents. Auto-matches subtasks to the best available agent based on skills. Use discover_agent first to register agents.',
+    parameters: OrchestrateParams,
+    execute: async (_id: string, params: Static<typeof OrchestrateParams>) => {
+      try {
+        const strategy = params.strategy ?? 'parallel';
+        const plan = createPlan(params.request, strategy, params.subtasks);
+
+        const assigned = plan.subtasks.filter(st => st.assignedAgentId);
+        if (assigned.length === 0) {
+          return textResult(
+            `Created plan with ${plan.subtasks.length} subtasks but no agents matched any skill.\n` +
+            `Subtasks: ${plan.subtasks.map(st => st.description).join(', ')}\n\n` +
+            'Discover agents first using discover_agent, then retry.'
+          );
+        }
+
+        const result = await executePlan(plan);
+
+        const summary = plan.subtasks.map(st => {
+          const icon = st.status === 'completed' ? '[OK]' : st.status === 'failed' ? '[FAIL]' : '[?]';
+          return `${icon} ${st.description}`;
+        }).join('\n');
+
+        return textResult(
+          `Orchestration ${result.status} (${strategy}, ${plan.subtasks.length} subtasks):\n\n` +
+          `${summary}\n\n---\n\n${result.aggregatedResult ?? '(no result)'}`
+        );
+      } catch (err) {
+        return textResult(`Orchestration failed: ${(err as Error).message}`);
+      }
+    },
+  },
+];

package/app/lib/a2a/client.ts

@@ -0,0 +1,207 @@
+/**
+ * A2A Client — Discover external agents and delegate tasks via A2A protocol.
+ * Phase 2: MindOS as an A2A Client (orchestrator).
+ */
+
+import type {
+  AgentCard,
+  RemoteAgent,
+  A2ATask,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  SendMessageParams,
+} from './types';
+
+/* ── Constants ─────────────────────────────────────────────────────────── */
+
+const DISCOVERY_TIMEOUT_MS = 5_000;
+const RPC_TIMEOUT_MS = 30_000;
+const CARD_CACHE_TTL_MS = 5 * 60 * 1000; // 5 min
+
+/* ── Agent Registry (in-memory cache) ──────────────────────────────────── */
+
+const registry = new Map<string, RemoteAgent>();
+
+/** Derive a stable ID from a URL (includes protocol to avoid collisions) */
+function urlToId(url: string): string {
+  try {
+    const u = new URL(url);
+    const proto = u.protocol.replace(':', '');
+    const port = u.port || (u.protocol === 'https:' ? '443' : '80');
+    return `${proto}-${u.hostname}-${port}`;
+  } catch {
+    return url.replace(/[^a-zA-Z0-9]/g, '-');
+  }
+}
+
+/* ── HTTP helpers ──────────────────────────────────────────────────────── */
+
+async function fetchWithTimeout(url: string, opts: RequestInit & { timeoutMs?: number } = {}): Promise<Response> {
+  const { timeoutMs = DISCOVERY_TIMEOUT_MS, ...fetchOpts } = opts;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...fetchOpts, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function jsonRpcCall(endpoint: string, method: string, params: unknown, token?: string): Promise<JsonRpcResponse> {
+  const body: JsonRpcRequest = {
+    jsonrpc: '2.0',
+    id: `mindos-${Date.now()}`,
+    method,
+    params: params as Record<string, unknown>,
+  };
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'A2A-Version': '1.0',
+  };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  const res = await fetchWithTimeout(endpoint, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+    timeoutMs: RPC_TIMEOUT_MS,
+  });
+
+  if (!res.ok) {
+    throw new Error(`A2A RPC failed: ${res.status} ${res.statusText}`);
+  }
+
+  return res.json();
+}
+
+/* ── Discovery ─────────────────────────────────────────────────────────── */
+
+/**
+ * Discover an A2A agent at the given base URL.
+ * Fetches /.well-known/agent-card.json and caches the result.
+ */
+export async function discoverAgent(baseUrl: string): Promise<RemoteAgent | null> {
+  const cleanUrl = baseUrl.replace(/\/+$/, '');
+  const cardUrl = `${cleanUrl}/.well-known/agent-card.json`;
+  const id = urlToId(cleanUrl);
+
+  // Check cache
+  const cached = registry.get(id);
+  if (cached && Date.now() - new Date(cached.discoveredAt).getTime() < CARD_CACHE_TTL_MS) {
+    return cached;
+  }
+
+  try {
+    const res = await fetchWithTimeout(cardUrl);
+    if (!res.ok) return null;
+
+    const card: AgentCard = await res.json();
+    // Validate minimum required fields
+    if (!card || typeof card.name !== 'string' || !card.name ||
+        !Array.isArray(card.supportedInterfaces) || card.supportedInterfaces.length === 0) {
+      return null;
+    }
+
+    // Find JSON-RPC endpoint
+    const jsonRpcInterface = card.supportedInterfaces.find(i => i.protocolBinding === 'JSONRPC');
+    if (!jsonRpcInterface) return null;
+
+    const agent: RemoteAgent = {
+      id,
+      card,
+      endpoint: jsonRpcInterface.url,
+      discoveredAt: new Date().toISOString(),
+      reachable: true,
+    };
+
+    registry.set(id, agent);
+    return agent;
+  } catch {
+    // Mark as unreachable if previously cached
+    if (cached) {
+      cached.reachable = false;
+      return cached;
+    }
+    return null;
+  }
+}
+
+/**
+ * Discover agents from a list of URLs (concurrent, best-effort).
+ */
+export async function discoverAgents(urls: string[]): Promise<RemoteAgent[]> {
+  const results = await Promise.allSettled(urls.map(discoverAgent));
+  return results
+    .filter((r): r is PromiseFulfilledResult<RemoteAgent | null> => r.status === 'fulfilled')
+    .map(r => r.value)
+    .filter((a): a is RemoteAgent => a !== null);
+}
+
+/* ── Task Delegation ───────────────────────────────────────────────────── */
+
+/**
+ * Send a message to a remote agent via A2A JSON-RPC.
+ * Returns the resulting task.
+ */
+export async function delegateTask(
+  agentId: string,
+  message: string,
+  token?: string,
+): Promise<A2ATask> {
+  const agent = registry.get(agentId);
+  if (!agent) throw new Error(`Agent not found: ${agentId}`);
+  if (!agent.reachable) throw new Error(`Agent not reachable: ${agent.card.name}`);
+
+  const params: SendMessageParams = {
+    message: {
+      role: 'ROLE_USER',
+      parts: [{ text: message }],
+    },
+    configuration: { blocking: true },
+  };
+
+  const response = await jsonRpcCall(agent.endpoint, 'SendMessage', params, token);
+
+  if (response.error) {
+    throw new Error(`A2A error [${response.error.code}]: ${response.error.message}`);
+  }
+
+  return response.result as A2ATask;
+}
+
+/**
+ * Check the status of a task on a remote agent.
+ */
+export async function checkRemoteTaskStatus(
+  agentId: string,
+  taskId: string,
+  token?: string,
+): Promise<A2ATask> {
+  const agent = registry.get(agentId);
+  if (!agent) throw new Error(`Agent not found: ${agentId}`);
+
+  const response = await jsonRpcCall(agent.endpoint, 'GetTask', { id: taskId }, token);
+
+  if (response.error) {
+    throw new Error(`A2A error [${response.error.code}]: ${response.error.message}`);
+  }
+
+  return response.result as A2ATask;
+}
+
+/* ── Registry Access ───────────────────────────────────────────────────── */
+
+/** Get all discovered agents */
+export function getDiscoveredAgents(): RemoteAgent[] {
+  return [...registry.values()];
+}
+
+/** Get a specific agent by ID */
+export function getAgent(id: string): RemoteAgent | undefined {
+  return registry.get(id);
+}
+
+/** Clear the agent registry cache */
+export function clearRegistry(): void {
+  registry.clear();
+}

package/app/lib/a2a/index.ts

@@ -1,5 +1,8 @@
 export { buildAgentCard } from './agent-card';
 export { handleSendMessage, handleGetTask, handleCancelTask } from './task-handler';
+export { discoverAgent, discoverAgents, delegateTask, checkRemoteTaskStatus, getDiscoveredAgents, getAgent, clearRegistry } from './client';
+export { matchSkill, decompose, createPlan, executePlan } from './orchestrator';
+export { a2aTools } from './a2a-tools';
 export { A2A_ERRORS } from './types';
 export type {
   AgentCard,
@@ -20,4 +23,9 @@ export type {
   SendMessageParams,
   GetTaskParams,
   CancelTaskParams,
+  RemoteAgent,
+  SubTask,
+  ExecutionStrategy,
+  OrchestrationPlan,
+  SkillMatch,
 } from './types';