Session Management

interface A2aSessionInfo {
  id: string;                // Session identifier
  agentName: string;         // Display name (e.g., "routa-opencode-abc123")
  provider: string;          // Provider ID (opencode, claude, etc.)
  status: string;            // Connection status
  capabilities: string[];    // Available JSON-RPC methods
  rpcUrl: string;            // JSON-RPC endpoint URL
  eventStreamUrl: string;    // SSE stream URL
  createdAt: string;         // ISO 8601 timestamp
}

GET /api/a2a/sessions

[
  {
    "id": "session-abc123",
    "agentName": "routa-opencode-abc123",
    "provider": "opencode",
    "status": "connected",
    "capabilities": [
      "initialize",
      "method_list",
      "session/new",
      "session/prompt",
      "session/cancel",
      "session/load",
      "list_agents",
      "create_agent",
      "delegate_task",
      "message_agent"
    ],
    "rpcUrl": "http://localhost:3000/api/a2a/rpc?sessionId=session-abc123",
    "eventStreamUrl": "http://localhost:3000/api/a2a/rpc?sessionId=session-abc123",
    "createdAt": "2026-03-03T12:00:00Z"
  }
]

import { getA2aSessionRegistry } from "@/core/a2a";

const registry = getA2aSessionRegistry();
const sessions = registry.listSessions("http://localhost:3000");

for (const session of sessions) {
  console.log(`Session ${session.id}:`);
  console.log(`  Agent: ${session.agentName}`);
  console.log(`  Provider: ${session.provider}`);
  console.log(`  Status: ${session.status}`);
  console.log(`  RPC URL: ${session.rpcUrl}`);
}

GET /api/a2a/sessions?id=session-abc123

const session = registry.getSession(
  "session-abc123",
  "http://localhost:3000"
);

if (session) {
  console.log("Found session:", session.agentName);
  console.log("Capabilities:", session.capabilities);
} else {
  console.log("Session not found");
}

const baseCapabilities = [
  "initialize",      // Initialize the A2A connection
  "method_list",     // List available JSON-RPC methods
];

const acpCapabilities = [
  "session/new",     // Create new ACP session
  "session/prompt",  // Send message to session
  "session/cancel",  // Cancel running session
  "session/load",    // Load persisted session
];

const routaCapabilities = [
  "list_agents",     // List agents in workspace
  "create_agent",    // Create new agent
  "delegate_task",   // Delegate task to agent
  "message_agent",   // Send message to agent
];

routa-{provider}-{sessionId}

import { getHttpSessionStore } from "@/core/acp/http-session-store";

const sessionStore = getHttpSessionStore();
const routaSessions = sessionStore.listSessions();

console.log("Active Routa sessions:", routaSessions.length);

private toA2aSessionInfo(
  session: RoutaSessionRecord,
  baseUrl: string
): A2aSessionInfo {
  return {
    id: session.sessionId,
    agentName: `routa-${session.provider}-${session.sessionId.slice(0, 8)}`,
    provider: session.provider || "unknown",
    status: "connected",
    capabilities: this.getSessionCapabilities(session),
    rpcUrl: `${baseUrl}/api/a2a/rpc?sessionId=${session.sessionId}`,
    eventStreamUrl: `${baseUrl}/api/a2a/rpc?sessionId=${session.sessionId}`,
    createdAt: session.createdAt,
  };
}

import { AcpSessionManager } from "@/core/acp";

const manager = new AcpSessionManager();
const sessionId = await manager.createSession({
  provider: "opencode",
  workspaceId: "workspace-123",
  workspacePath: "/path/to/project",
});

console.log("Created session:", sessionId);

curl -X POST http://localhost:3000/api/a2a/rpc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "session/prompt",
    "params": {
      "sessionId": "session-abc123",
      "message": "Implement user login"
    },
    "id": 1
  }'

// Save session state
await manager.persistSession(sessionId);

// Load session later
const restored = await manager.loadSession(sessionId);

import { AcpSessionManager } from "@/core/acp";
import { getA2aSessionRegistry } from "@/core/a2a";

async function createAndExposeSession() {
  // 1. Create ACP session
  const manager = new AcpSessionManager();
  const sessionId = await manager.createSession({
    provider: "opencode",
    workspaceId: "my-workspace",
    workspacePath: "/home/user/project",
    sessionMode: "orchestrator",
  });
  
  console.log("Created session:", sessionId);
  
  // 2. Verify it's exposed via A2A
  const registry = getA2aSessionRegistry();
  const session = registry.getSession(
    sessionId,
    "http://localhost:3000"
  );
  
  if (session) {
    console.log("Session is exposed via A2A:");
    console.log("  RPC URL:", session.rpcUrl);
    console.log("  Capabilities:", session.capabilities);
  }
  
  // 3. Send a message
  const response = await manager.sendMessage(sessionId, {
    role: "user",
    content: "List all TypeScript files in the project",
  });
  
  console.log("Response:", response);
}

createAndExposeSession();

// Future enhancement
interface SessionFilter {
  provider?: string;        // Filter by provider
  workspaceId?: string;     // Filter by workspace
  status?: string;          // Filter by status
  createdAfter?: Date;      // Filter by creation time
}

const sessions = registry.listSessions(
  "http://localhost:3000",
  { provider: "opencode", status: "connected" }
);

// Good: Store session ID securely
process.env.ROUTA_SESSION_ID = sessionId;

// Bad: Log session IDs
console.log("Session:", sessionId); // Avoid this