@geminilight/mindos 0.6.23 → 0.6.27

package/app/lib/a2a/index.ts

@@ -0,0 +1,31 @@
+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,
+  AgentInterface,
+  AgentCapabilities,
+  AgentSkill,
+  SecurityScheme,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcError,
+  TaskState,
+  MessageRole,
+  MessagePart,
+  A2AMessage,
+  TaskStatus,
+  TaskArtifact,
+  A2ATask,
+  SendMessageParams,
+  GetTaskParams,
+  CancelTaskParams,
+  RemoteAgent,
+  SubTask,
+  ExecutionStrategy,
+  OrchestrationPlan,
+  SkillMatch,
+} from './types';

package/app/lib/a2a/orchestrator.ts

@@ -0,0 +1,255 @@
+/**
+ * A2A Orchestrator — Multi-agent task decomposition and execution.
+ * Phase 3: Breaks complex requests into sub-tasks, matches to agents, executes, aggregates.
+ */
+
+import { randomUUID } from 'crypto';
+import type {
+  RemoteAgent,
+  SubTask,
+  OrchestrationPlan,
+  ExecutionStrategy,
+  SkillMatch,
+  AgentSkill,
+} from './types';
+import { getDiscoveredAgents, delegateTask } from './client';
+
+/* ── Constants ─────────────────────────────────────────────────────────── */
+
+const MAX_SUBTASKS = 10;
+
+/* ── Skill Matcher ─────────────────────────────────────────────────────── */
+
+/** Score how well a skill matches a task description (keyword overlap, deduplicated) */
+function scoreSkillMatch(taskDesc: string, skill: AgentSkill): number {
+  const taskWords = new Set(taskDesc.toLowerCase().split(/\s+/));
+  // Deduplicate skill words to avoid double-counting from name + description overlap
+  const skillWords = new Set([
+    ...skill.name.toLowerCase().split(/\s+/),
+    ...skill.description.toLowerCase().split(/\s+/),
+    ...(skill.tags ?? []).map(t => t.toLowerCase()),
+  ]);
+  let matches = 0;
+  for (const w of skillWords) {
+    if (w.length > 2 && taskWords.has(w)) matches++;
+  }
+  return matches;
+}
+
+/**
+ * Find the best agent+skill match for a sub-task description.
+ * Returns null if no agent has a relevant skill.
+ */
+export function matchSkill(taskDescription: string): SkillMatch | null {
+  const agents = getDiscoveredAgents().filter(a => a.reachable);
+  if (agents.length === 0) return null;
+
+  let best: SkillMatch | null = null;
+  let bestScore = 0;
+
+  for (const agent of agents) {
+    for (const skill of agent.card.skills) {
+      const score = scoreSkillMatch(taskDescription, skill);
+      if (score > bestScore) {
+        bestScore = score;
+        best = {
+          agentId: agent.id,
+          agentName: agent.card.name,
+          skillId: skill.id,
+          skillName: skill.name,
+          confidence: Math.min(score / 3, 1),
+        };
+      }
+    }
+  }
+
+  return best;
+}
+
+/* ── Task Decomposer ───────────────────────────────────────────────────── */
+
+/**
+ * Decompose a complex request into sub-tasks.
+ * Uses simple heuristics: split on sentence boundaries and conjunctions.
+ * For LLM-based decomposition, the agent tool can call this with pre-decomposed parts.
+ */
+export function decompose(request: string, subtaskDescriptions?: string[]): SubTask[] {
+  let descriptions: string[];
+
+  if (subtaskDescriptions && subtaskDescriptions.length > 0) {
+    descriptions = subtaskDescriptions;
+  } else {
+    descriptions = splitIntoSubtasks(request);
+  }
+
+  return descriptions.slice(0, MAX_SUBTASKS).map((desc, i) => ({
+    id: `st-${randomUUID().slice(0, 8)}`,
+    description: desc.trim(),
+    assignedAgentId: null,
+    matchedSkillId: null,
+    status: 'pending' as const,
+    result: null,
+    error: null,
+    dependsOn: [],
+  }));
+}
+
+/** Simple heuristic: split on "and then", "then", "also", numbered lists, semicolons */
+function splitIntoSubtasks(text: string): string[] {
+  // Try numbered list first: split on "N. " pattern at boundaries
+  const numbered = text.split(/(?:^|\s)(?=\d+\.\s)/m).map(s => s.replace(/^\d+\.\s*/, '').trim()).filter(Boolean);
+  if (numbered.length >= 2) return numbered;
+
+  // Try splitting on conjunctions/semicolons
+  const parts = text.split(/;\s*|\.\s+(?:then|and then|also|next|finally)\s+/i).filter(Boolean);
+  if (parts.length >= 2) return parts;
+
+  // Fallback: treat as single task
+  return [text];
+}
+
+/* ── Execution Engine ──────────────────────────────────────────────────── */
+
+/**
+ * Create an orchestration plan from a request.
+ */
+export function createPlan(
+  request: string,
+  strategy: ExecutionStrategy = 'parallel',
+  subtaskDescriptions?: string[],
+): OrchestrationPlan {
+  const subtasks = decompose(request, subtaskDescriptions);
+
+  // Auto-match skills to agents
+  for (const st of subtasks) {
+    const match = matchSkill(st.description);
+    if (match) {
+      st.assignedAgentId = match.agentId;
+      st.matchedSkillId = match.skillId;
+    }
+  }
+
+  return {
+    id: `plan-${randomUUID().slice(0, 8)}`,
+    originalRequest: request,
+    strategy,
+    subtasks,
+    createdAt: new Date().toISOString(),
+    completedAt: null,
+    status: 'planning',
+    aggregatedResult: null,
+  };
+}
+
+/**
+ * Execute a single sub-task by delegating to its assigned agent.
+ */
+async function executeSubtask(subtask: SubTask, token?: string): Promise<void> {
+  if (!subtask.assignedAgentId) {
+    subtask.status = 'failed';
+    subtask.error = 'No agent assigned to this subtask';
+    return;
+  }
+
+  subtask.status = 'running';
+
+  try {
+    // delegateTask has its own 30s RPC timeout via fetchWithTimeout in client.ts
+    const task = await delegateTask(subtask.assignedAgentId, subtask.description, token);
+
+    if (task.status.state === 'TASK_STATE_COMPLETED') {
+      subtask.status = 'completed';
+      subtask.result = task.artifacts?.[0]?.parts?.[0]?.text
+        ?? task.history?.find(m => m.role === 'ROLE_AGENT')?.parts?.[0]?.text
+        ?? 'Completed (no text result)';
+    } else if (task.status.state === 'TASK_STATE_FAILED') {
+      subtask.status = 'failed';
+      subtask.error = task.status.message?.parts?.[0]?.text ?? 'Agent reported failure';
+    } else {
+      subtask.status = 'completed';
+      subtask.result = `Task in progress (state: ${task.status.state})`;
+    }
+  } catch (err) {
+    subtask.status = 'failed';
+    subtask.error = (err as Error).message;
+  }
+}
+
+/**
+ * Execute all sub-tasks in an orchestration plan.
+ */
+export async function executePlan(plan: OrchestrationPlan, token?: string): Promise<OrchestrationPlan> {
+  plan.status = 'executing';
+
+  const unassigned = plan.subtasks.filter(st => !st.assignedAgentId);
+  if (unassigned.length === plan.subtasks.length) {
+    plan.status = 'failed';
+    plan.aggregatedResult = 'No agents available for any subtask. Discover agents first using discover_agent.';
+    return plan;
+  }
+
+  // Mark unassigned subtasks as failed before execution
+  for (const st of plan.subtasks) {
+    if (!st.assignedAgentId) {
+      st.status = 'failed';
+      st.error = 'No matching agent found for this subtask';
+    }
+  }
+
+  const assignedTasks = plan.subtasks.filter(st => st.assignedAgentId);
+
+  if (plan.strategy === 'parallel') {
+    await Promise.allSettled(
+      assignedTasks.map(st => executeSubtask(st, token))
+    );
+  } else {
+    // Sequential or dependency-based
+    for (const st of plan.subtasks) {
+      if (!st.assignedAgentId) {
+        st.status = 'failed';
+        st.error = 'No agent assigned';
+        continue;
+      }
+
+      // Check dependencies
+      if (st.dependsOn.length > 0) {
+        const deps = st.dependsOn.map(id => plan.subtasks.find(s => s.id === id));
+        const allDone = deps.every(d => d?.status === 'completed');
+        if (!allDone) {
+          st.status = 'failed';
+          st.error = 'Dependencies not met';
+          continue;
+        }
+      }
+
+      await executeSubtask(st, token);
+
+      // Stop on failure in sequential mode
+      if (plan.strategy === 'sequential' && st.status === 'failed') break;
+    }
+  }
+
+  // Aggregate results
+  const completed = plan.subtasks.filter(st => st.status === 'completed');
+  const failed = plan.subtasks.filter(st => st.status === 'failed');
+
+  if (failed.length === plan.subtasks.length) {
+    plan.status = 'failed';
+    plan.aggregatedResult = `All ${failed.length} subtasks failed:\n` +
+      failed.map(st => `- ${st.description}: ${st.error}`).join('\n');
+  } else {
+    plan.status = 'completed';
+    const parts: string[] = [];
+    for (const st of plan.subtasks) {
+      if (st.status === 'completed' && st.result) {
+        parts.push(`## ${st.description}\n\n${st.result}`);
+      } else if (st.status === 'failed') {
+        parts.push(`## ${st.description}\n\n[Failed: ${st.error}]`);
+      }
+    }
+    plan.aggregatedResult = parts.join('\n\n---\n\n');
+  }
+
+  plan.completedAt = new Date().toISOString();
+  return plan;
+}

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

@@ -0,0 +1,228 @@
+/**
+ * A2A Task handler for MindOS.
+ * Routes A2A SendMessage requests to internal MCP tools.
+ */
+
+import { randomUUID } from 'crypto';
+import type {
+  A2ATask,
+  A2AMessage,
+  SendMessageParams,
+  GetTaskParams,
+  CancelTaskParams,
+  TaskState,
+} from './types';
+
+/* ── In-memory Task Store (Phase 1) ───────────────────────────────────── */
+// NOTE: In-memory Map is lost on serverless cold starts / process restarts.
+// Acceptable for Phase 1. Phase 2 should use persistent storage if needed.
+
+const tasks = new Map<string, A2ATask>();
+const MAX_TASKS = 1000;
+
+function pruneOldTasks() {
+  if (tasks.size <= MAX_TASKS) return;
+  // Remove oldest completed tasks first
+  const entries = [...tasks.entries()].sort((a, b) =>
+    new Date(a[1].status.timestamp).getTime() - new Date(b[1].status.timestamp).getTime()
+  );
+  const toRemove = entries.slice(0, tasks.size - MAX_TASKS);
+  for (const [id] of toRemove) tasks.delete(id);
+}
+
+/* ── Skill Router ─────────────────────────────────────────────────────── */
+
+interface SkillRoute {
+  pattern: RegExp;
+  tool: string;
+  extractParams: (text: string) => Record<string, string>;
+}
+
+const SKILL_ROUTES: SkillRoute[] = [
+  {
+    pattern: /^(?:search|find|look\s*up|query)\b/i,
+    tool: 'search_notes',
+    extractParams: (text) => ({ q: text.replace(/^(?:search|find|look\s*up|query)\s+(?:for\s+)?/i, '').trim() }),
+  },
+  {
+    pattern: /^(?:read|get|show|open|view)\s+(?:the\s+)?(?:file\s+)?(?:at\s+)?(.+\.(?:md|csv))/i,
+    tool: 'read_file',
+    extractParams: (text) => {
+      const match = text.match(/(?:at\s+)?([^\s]+\.(?:md|csv))/i);
+      return { path: match?.[1] ?? '' };
+    },
+  },
+  {
+    pattern: /^(?:list|show|tree)\s+(?:files|spaces|structure)/i,
+    tool: 'list_files',
+    extractParams: () => ({}),
+  },
+  {
+    pattern: /^(?:list|show)\s+spaces/i,
+    tool: 'list_spaces',
+    extractParams: () => ({}),
+  },
+];
+
+function routeToTool(text: string): { tool: string; params: Record<string, string> } | null {
+  for (const route of SKILL_ROUTES) {
+    if (route.pattern.test(text)) {
+      return { tool: route.tool, params: route.extractParams(text) };
+    }
+  }
+  return null;
+}
+
+/* ── Execute via internal API ─────────────────────────────────────────── */
+
+const TOOL_TIMEOUT_MS = 10_000;
+
+async function fetchWithTimeout(url: string): Promise<Response> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TOOL_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    return res;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/** Sanitize file path: reject traversal attempts */
+function sanitizePath(p: string): string {
+  if (!p || p.includes('..') || p.includes('\0')) throw new Error('Invalid path');
+  // Normalize double slashes and strip leading slashes
+  return p.replace(/\/\//g, '/').replace(/^\/+/, '');
+}
+
+async function executeTool(tool: string, params: Record<string, string>): Promise<string> {
+  const baseUrl = `http://localhost:${process.env.PORT || 3456}`;
+
+  switch (tool) {
+    case 'search_notes': {
+      const q = (params.q || '').slice(0, 500); // limit query length
+      const res = await fetchWithTimeout(`${baseUrl}/api/search?q=${encodeURIComponent(q)}`);
+      if (!res.ok) throw new Error(`Search failed: ${res.status}`);
+      const data = await res.json();
+      return JSON.stringify(data, null, 2);
+    }
+    case 'read_file': {
+      const safePath = sanitizePath(params.path || '');
+      const res = await fetchWithTimeout(`${baseUrl}/api/file?path=${encodeURIComponent(safePath)}`);
+      if (!res.ok) throw new Error(`Read failed: ${res.status}`);
+      const data = await res.json();
+      return typeof data.content === 'string' ? data.content : JSON.stringify(data);
+    }
+    case 'list_files': {
+      const res = await fetchWithTimeout(`${baseUrl}/api/files`);
+      if (!res.ok) throw new Error(`List failed: ${res.status}`);
+      const data = await res.json();
+      return JSON.stringify(data, null, 2);
+    }
+    case 'list_spaces': {
+      const res = await fetchWithTimeout(`${baseUrl}/api/files`);
+      if (!res.ok) throw new Error(`List failed: ${res.status}`);
+      const data = await res.json();
+      const spaces = (data.tree ?? data.files ?? []).filter((n: { isSpace?: boolean }) => n.isSpace);
+      return JSON.stringify(spaces, null, 2);
+    }
+    default:
+      throw new Error(`Unknown tool: ${tool}`);
+  }
+}
+
+/* ── Public API ────────────────────────────────────────────────────────── */
+
+export async function handleSendMessage(params: SendMessageParams): Promise<A2ATask> {
+  const taskId = randomUUID();
+  const now = new Date().toISOString();
+
+  // Extract text from message parts
+  const text = params.message.parts
+    .map(p => p.text ?? (p.data ? JSON.stringify(p.data) : ''))
+    .join(' ')
+    .trim();
+
+  if (!text) {
+    const failedTask = createTask(taskId, 'TASK_STATE_FAILED', 'Empty message — no text content found.', now);
+    tasks.set(taskId, failedTask);
+    return failedTask;
+  }
+
+  // Create task in WORKING state
+  const task = createTask(taskId, 'TASK_STATE_WORKING', undefined, now);
+  task.history = [params.message];
+  tasks.set(taskId, task);
+  pruneOldTasks();
+
+  // Route to tool
+  const route = routeToTool(text);
+
+  try {
+    let result: string;
+    if (route) {
+      result = await executeTool(route.tool, route.params);
+    } else {
+      // Fallback: treat as search query
+      result = await executeTool('search_notes', { q: text });
+    }
+
+    // Update task to completed
+    task.status = {
+      state: 'TASK_STATE_COMPLETED',
+      timestamp: new Date().toISOString(),
+    };
+    task.artifacts = [{
+      artifactId: randomUUID(),
+      name: 'result',
+      parts: [{ text: result, mediaType: 'text/plain' }],
+    }];
+    task.history.push({
+      role: 'ROLE_AGENT',
+      parts: [{ text: result }],
+    });
+
+    return task;
+  } catch (err) {
+    task.status = {
+      state: 'TASK_STATE_FAILED',
+      message: {
+        role: 'ROLE_AGENT',
+        parts: [{ text: `Error: ${(err as Error).message}` }],
+      },
+      timestamp: new Date().toISOString(),
+    };
+    return task;
+  }
+}
+
+export function handleGetTask(params: GetTaskParams): A2ATask | null {
+  return tasks.get(params.id) ?? null;
+}
+
+export function handleCancelTask(params: CancelTaskParams): A2ATask | null {
+  const task = tasks.get(params.id);
+  if (!task) return null;
+
+  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
+
+  task.status = {
+    state: 'TASK_STATE_CANCELED',
+    timestamp: new Date().toISOString(),
+  };
+  return task;
+}
+
+/* ── Helpers ───────────────────────────────────────────────────────────── */
+
+function createTask(id: string, state: TaskState, errorMessage: string | undefined, timestamp: string): A2ATask {
+  return {
+    id,
+    status: {
+      state,
+      timestamp,
+      ...(errorMessage ? { message: { role: 'ROLE_AGENT', parts: [{ text: errorMessage }] } } : {}),
+    },
+  };
+}