Model Context Protocol (MCP)

export function createRoutaMcpServer(
  workspaceIdOrOptions: string | CreateMcpServerOptions,
  system?: RoutaSystem
): RoutaMcpServerResult {
  const server = new McpServer({
    name: "routa-mcp",
    version: "0.1.0",
  });

  const toolManager = new RoutaMcpToolManager(routaSystem.tools, opts.workspaceId);
  toolManager.setToolMode(toolMode); // "essential" or "full"
  toolManager.registerTools(server);

  return { server, system: routaSystem, toolManager };
}

// Coordinator agent using MCP tools

// 1. Create a task
const taskResult = await mcp.call_tool("create_task", {
  title: "Implement user authentication",
  objective: "Add JWT-based authentication to API",
  workspaceId: "workspace-123",
  scope: "src/auth/",
  acceptanceCriteria: [
    "Login endpoint returns valid JWT",
    "Protected routes verify token",
    "Tests pass"
  ]
});

const taskId = taskResult.data.taskId;

// 2. Delegate to a CRAFTER agent
await mcp.call_tool("delegate_task_to_agent", {
  taskId,
  callerAgentId: "coordinator-agent-id",
  specialist: "CRAFTER",
  provider: "opencode",
  cwd: "/workspace/project",
  waitMode: "immediate"
});

// 3. Read agent conversation later
const conversation = await mcp.call_tool("read_agent_conversation", {
  agentId: "crafter-agent-id",
  lastN: 10
});

// 1. Create spec note
await mcp.call_tool("set_note_content", {
  noteId: "spec",
  content: `
# Project Spec

@@@task[auth]
Objective: Implement authentication
Scope: src/auth/
Acceptance:
- JWT login works
- Tests pass
@@@

@@@task[api]
Objective: Add REST endpoints
Scope: src/api/
Acceptance:
- CRUD operations work
- OpenAPI spec generated
@@@
  `,
  workspaceId: "workspace-123"
});

// 2. Convert @@@task blocks to structured tasks
const result = await mcp.call_tool("convert_task_blocks", {
  noteId: "spec",
  workspaceId: "workspace-123"
});

// Returns: { taskIds: ["uuid-1", "uuid-2"], noteIds: ["task-auth", "task-api"] }

// 3. Delegate each task
for (const taskId of result.data.taskIds) {
  await mcp.call_tool("delegate_task_to_agent", {
    taskId,
    callerAgentId: "coordinator-id",
    specialist: "CRAFTER"
  });
}

// src/core/mcp/routa-mcp-http-server.ts
const httpServer = new RoutaMcpHttpServer({
  workspaceId: "workspace-123",
  toolMode: "essential"
});

await httpServer.start(8080);
// Agent connects to: http://localhost:8080/api/mcp

// src/core/mcp/ws-server-transport.ts
const transport = new WebSocketServerTransport(ws);
const { server } = createRoutaMcpServer({
  workspaceId: "workspace-123",
  toolMode: "essential"
});

await server.connect(transport);

const { server } = createRoutaMcpServer({
  workspaceId: "workspace-123",
  toolMode: "essential"
});

const transport = new StdioServerTransport();
await server.connect(transport);

export async function executeMcpTool(
  tools: AgentTools,
  name: string,
  args: Record<string, unknown>,
  noteTools?: NoteTools,
  workspaceTools?: WorkspaceTools
) {
  // Validate workspaceId
  const workspace = args.workspaceId as string;
  if (!workspace) {
    return { content: [{ type: "text", text: JSON.stringify({ error: "workspaceId is required" }) }], isError: true };
  }

  // Dispatch to appropriate tool
  switch (name) {
    case "list_agents":
      return formatResult(await tools.listAgents(workspace));
    case "delegate_task_to_agent":
      const orchestrator = getRoutaOrchestrator();
      return formatResult(
        await orchestrator.delegateTaskWithSpawn({ /* ... */ })
      );
    // ...
  }
}