mcp-agent-broker 1.0.0

package/src/infrastructure/db/migrations/meta/_journal.json

@@ -0,0 +1,20 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1784615292798,
+      "tag": "0000_flawless_vanisher",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "7",
+      "when": 1784617991306,
+      "tag": "0001_fearless_sersi",
+      "breakpoints": true
+    }
+  ]
+}

package/src/infrastructure/db/schema.ts

@@ -0,0 +1,148 @@
+import { 
+  pgTable, uuid, text, jsonb, smallint, bigint, timestamp, integer, pgEnum, 
+  unique, bigserial, primaryKey, index
+} from "drizzle-orm/pg-core";
+
+export const taskStateEnum = pgEnum('task_state', [
+  'draft', 'ready', 'leased', 'running', 'blocked',
+  'awaiting_review', 'changes_requested', 'completed',
+  'failed', 'canceled', 'superseded'
+]);
+
+export const workspaceStatusEnum = pgEnum('workspace_status', ['active', 'archived']);
+export const agentStatusEnum = pgEnum('agent_status', ['connected', 'degraded', 'disconnected', 'revoked']);
+
+export const leaseStatusEnum = pgEnum('lease_status', ['active', 'released', 'expired', 'revoked']);
+export const leaseTypeEnum = pgEnum('lease_type', ['execution', 'review']);
+
+export const workspaces = pgTable('workspaces', {
+  id: uuid('id').primaryKey(),
+  organizationId: uuid('organization_id'),
+  name: text('name').notNull(),
+  status: workspaceStatusEnum('status').notNull().default('active'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const agentDefinitions = pgTable('agent_definitions', {
+  id: uuid('id').primaryKey(),
+  name: text('name').notNull(),
+  vendor: text('vendor'),
+  version: text('version').notNull(),
+  integrationType: text('integration_type'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const agentInstances = pgTable('agent_instances', {
+  id: uuid('id').primaryKey(),
+  agentDefinitionId: uuid('agent_definition_id').notNull().references(() => agentDefinitions.id),
+  workspaceId: uuid('workspace_id').notNull().references(() => workspaces.id),
+  principalId: uuid('principal_id').notNull(),
+  status: agentStatusEnum('status').notNull().default('connected'),
+  capabilitiesJson: jsonb('capabilities_json').notNull().default('[]'),
+  lastHeartbeatAt: timestamp('last_heartbeat_at', { withTimezone: true }),
+  revokedAt: timestamp('revoked_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const tasks = pgTable('tasks', {
+  id: uuid('id').primaryKey(),
+  workspaceId: uuid('workspace_id').notNull(),
+  repositoryId: uuid('repository_id').notNull(),
+  sessionId: uuid('session_id'),
+  objective: text('objective').notNull(),
+  description: text('description').notNull().default(''),
+  acceptanceCriteria: jsonb('acceptance_criteria').notNull().default('[]'),
+  constraints: jsonb('constraints').notNull().default('[]'),
+  priority: smallint('priority').notNull().default(3),
+  state: taskStateEnum('state').notNull().default('draft'),
+  baseCommitSha: text('base_commit_sha'),
+  activeExecutionLeaseId: uuid('active_execution_lease_id'),
+  activeReviewLeaseId: uuid('active_review_lease_id'),
+  nextFencingToken: bigint('next_fencing_token', { mode: 'number' }).notNull().default(0),
+  version: bigint('version', { mode: 'number' }).notNull().default(1),
+  createdBy: uuid('created_by').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
+  completedAt: timestamp('completed_at', { withTimezone: true }),
+});
+
+export const taskAttempts = pgTable('task_attempts', {
+  id: uuid('id').primaryKey(),
+  workspaceId: uuid('workspace_id').notNull(),
+  taskId: uuid('task_id').notNull().references(() => tasks.id),
+  attemptNumber: integer('attempt_number').notNull(),
+  agentInstanceId: uuid('agent_instance_id').notNull(),
+  status: text('status').notNull(),
+  startedAt: timestamp('started_at', { withTimezone: true }),
+  endedAt: timestamp('ended_at', { withTimezone: true }),
+  outcome: text('outcome'),
+}, (table) => ({
+  unq: unique().on(table.taskId, table.attemptNumber)
+}));
+
+export const leases = pgTable('leases', {
+  id: uuid('id').primaryKey(),
+  workspaceId: uuid('workspace_id').notNull(),
+  taskId: uuid('task_id').notNull().references(() => tasks.id),
+  taskAttemptId: uuid('task_attempt_id').references(() => taskAttempts.id),
+  agentInstanceId: uuid('agent_instance_id').notNull(),
+  leaseType: leaseTypeEnum('lease_type').notNull(),
+  status: leaseStatusEnum('status').notNull(),
+  fencingToken: bigint('fencing_token', { mode: 'number' }).notNull(),
+  acquiredAt: timestamp('acquired_at', { withTimezone: true }).notNull(),
+  renewedAt: timestamp('renewed_at', { withTimezone: true }).notNull(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+  releasedAt: timestamp('released_at', { withTimezone: true }),
+}, (table) => ({
+  unq: unique().on(table.taskId, table.leaseType, table.fencingToken),
+  // Note: Drizzle partial unique index would be handled in migrations or sql
+}));
+
+export const events = pgTable('events', {
+  eventSeq: bigserial('event_seq', { mode: 'number' }).primaryKey(),
+  eventId: uuid('event_id').notNull().unique(),
+  eventType: text('event_type').notNull(),
+  eventVersion: integer('event_version').notNull(),
+  workspaceId: uuid('workspace_id').notNull(),
+  aggregateType: text('aggregate_type').notNull(),
+  aggregateId: uuid('aggregate_id').notNull(),
+  aggregateVersion: bigint('aggregate_version', { mode: 'number' }).notNull(),
+  actorType: text('actor_type').notNull(),
+  actorId: uuid('actor_id'),
+  correlationId: uuid('correlation_id').notNull(),
+  causationId: uuid('causation_id'),
+  payload: jsonb('payload').notNull(),
+  occurredAt: timestamp('occurred_at', { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+  unq: unique().on(table.aggregateType, table.aggregateId, table.aggregateVersion),
+  idx: index('events_workspace_cursor').on(table.workspaceId, table.eventSeq)
+}));
+
+export const outbox = pgTable('outbox', {
+  eventId: uuid('event_id').primaryKey().references(() => events.eventId, { onDelete: 'cascade' }),
+  availableAt: timestamp('available_at', { withTimezone: true }).notNull().defaultNow(),
+  attempts: integer('attempts').notNull().default(0),
+  lockedBy: text('locked_by'),
+  lockedUntil: timestamp('locked_until', { withTimezone: true }),
+  publishedAt: timestamp('published_at', { withTimezone: true }),
+  lastError: text('last_error'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const idempotencyRecords = pgTable('idempotency_records', {
+  principalId: uuid('principal_id').notNull(),
+  operation: text('operation').notNull(),
+  idempotencyKey: text('idempotency_key').notNull(),
+  requestHash: text('request_hash').notNull(),
+  responseJson: jsonb('response_json'),
+  responseStatus: text('response_status').notNull(),
+  resourceId: uuid('resource_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
+  expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+}, (table) => ({
+  pk: primaryKey({ columns: [table.principalId, table.operation, table.idempotencyKey] }),
+  idx: index('idempotency_expiry').on(table.expiresAt)
+}));

package/src/infrastructure/redis/index.ts

@@ -0,0 +1,7 @@
+import Redis from 'ioredis';
+
+const redisUrl = process.env.REDIS_URL || 'redis://127.0.0.1:6379';
+
+export const redis = new Redis(redisUrl, {
+  maxRetriesPerRequest: null
+});

package/src/modules/event/event.service.ts

@@ -0,0 +1,50 @@
+import { db } from '../../infrastructure/db/index.js';
+import { events, outbox } from '../../infrastructure/db/schema.js';
+import { randomUUID } from 'crypto';
+
+export class EventService {
+  /**
+   * Appends an event to the events table and inserts a corresponding outbox record
+   * as part of a transaction.
+   */
+  async appendEvent(
+    tx: any,
+    params: {
+      workspaceId: string;
+      eventType: string;
+      aggregateType: string;
+      aggregateId: string;
+      aggregateVersion: number;
+      actorType: string;
+      actorId?: string;
+      payload: any;
+    }
+  ) {
+    const eventId = randomUUID();
+    
+    // Insert into Event Store
+    await tx.insert(events).values({
+      eventId,
+      eventType: params.eventType,
+      eventVersion: 1,
+      workspaceId: params.workspaceId,
+      aggregateType: params.aggregateType,
+      aggregateId: params.aggregateId,
+      aggregateVersion: params.aggregateVersion,
+      actorType: params.actorType,
+      actorId: params.actorId || null,
+      correlationId: eventId, // Base correlation id
+      payload: params.payload,
+    });
+
+    // Insert into Outbox
+    await tx.insert(outbox).values({
+      eventId,
+      attempts: 0
+    });
+    
+    return eventId;
+  }
+}
+
+export const eventService = new EventService();

package/src/modules/identity/agent.service.ts

@@ -0,0 +1,58 @@
+import { db } from '../../infrastructure/db/index.js';
+import { agentDefinitions, agentInstances, workspaces } from '../../infrastructure/db/schema.js';
+import { randomUUID } from 'crypto';
+import { eq } from 'drizzle-orm';
+
+export class AgentService {
+  async ensureDefaultWorkspace() {
+    let [workspace] = await db.select().from(workspaces).limit(1);
+    if (!workspace) {
+      [workspace] = await db.insert(workspaces).values({
+        id: randomUUID(),
+        name: "Default Workspace",
+      }).returning();
+    }
+    return workspace;
+  }
+
+  async registerAgent(params: { name: string; vendor?: string; version: string; capabilities: string[] }) {
+    const workspace = await this.ensureDefaultWorkspace();
+    
+    // 1. Create or find agent definition
+    let [definition] = await db.select().from(agentDefinitions)
+      .where(eq(agentDefinitions.name, params.name))
+      .limit(1);
+
+    if (!definition) {
+      [definition] = await db.insert(agentDefinitions).values({
+        id: randomUUID(),
+        name: params.name,
+        vendor: params.vendor || "unknown",
+        version: params.version,
+        integrationType: "mcp-client"
+      }).returning();
+    } else {
+      // Update version if changed
+      if (definition.version !== params.version) {
+        [definition] = await db.update(agentDefinitions)
+          .set({ version: params.version, updatedAt: new Date() })
+          .where(eq(agentDefinitions.id, definition.id))
+          .returning();
+      }
+    }
+
+    // 2. Create agent instance
+    const [instance] = await db.insert(agentInstances).values({
+      id: randomUUID(),
+      agentDefinitionId: definition.id,
+      workspaceId: workspace.id,
+      principalId: randomUUID(), // Mocking principal ID for Phase 0
+      capabilitiesJson: params.capabilities,
+      status: "connected",
+    }).returning();
+
+    return instance;
+  }
+}
+
+export const agentService = new AgentService();

package/src/modules/lease/lease.service.ts

@@ -0,0 +1,89 @@
+import { db } from '../../infrastructure/db/index.js';
+import { tasks, leases } from '../../infrastructure/db/schema.js';
+import { randomUUID } from 'crypto';
+import { eq } from 'drizzle-orm';
+import { eventService } from '../event/event.service.js';
+
+export class LeaseService {
+  async acquireLease(params: {
+    taskId: string;
+    workspaceId: string;
+    agentInstanceId: string;
+    leaseType: 'execution' | 'review';
+    ttlMs?: number;
+  }) {
+    const ttlMs = params.ttlMs || 30 * 60 * 1000; // default 30 mins
+    
+    // We use a transaction to guarantee atomic lease acquisition (fencing token increment)
+    return await db.transaction(async (tx) => {
+      // 1. Lock the task row for update
+      const [task] = await tx.select().from(tasks).where(eq(tasks.id, params.taskId)).for('update');
+      
+      if (!task) throw new Error("Task not found");
+      
+      // Check if lease is already active
+      const activeLeaseId = params.leaseType === 'execution' ? task.activeExecutionLeaseId : task.activeReviewLeaseId;
+      if (activeLeaseId) {
+        const [activeLease] = await tx.select().from(leases).where(eq(leases.id, activeLeaseId));
+        if (activeLease && activeLease.status === 'active' && new Date() < activeLease.expiresAt) {
+          throw new Error("Task is already actively leased");
+        }
+      }
+
+      // 2. Increment fencing token
+      const nextFencingToken = task.nextFencingToken + 1;
+      
+      // 3. Create the lease
+      const now = new Date();
+      const expiresAt = new Date(now.getTime() + ttlMs);
+      
+      const [lease] = await tx.insert(leases).values({
+        id: randomUUID(),
+        workspaceId: params.workspaceId,
+        taskId: params.taskId,
+        agentInstanceId: params.agentInstanceId,
+        leaseType: params.leaseType,
+        status: 'active',
+        fencingToken: nextFencingToken,
+        acquiredAt: now,
+        renewedAt: now,
+        expiresAt: expiresAt,
+      }).returning();
+      
+      // 4. Update task with active lease ID and incremented token, and set state to 'leased'
+      const updateData: any = {
+        nextFencingToken: nextFencingToken,
+        version: task.version + 1,
+        state: 'leased'
+      };
+      
+      if (params.leaseType === 'execution') {
+        updateData.activeExecutionLeaseId = lease.id;
+      } else {
+        updateData.activeReviewLeaseId = lease.id;
+      }
+      
+      await tx.update(tasks).set(updateData).where(eq(tasks.id, params.taskId));
+      
+      await eventService.appendEvent(tx, {
+        workspaceId: params.workspaceId,
+        eventType: 'LeaseAcquired',
+        aggregateType: 'Task',
+        aggregateId: task.id,
+        aggregateVersion: updateData.version,
+        actorType: 'AgentInstance',
+        actorId: params.agentInstanceId,
+        payload: {
+          leaseId: lease.id,
+          leaseType: params.leaseType,
+          fencingToken: nextFencingToken,
+          expiresAt: expiresAt.toISOString()
+        }
+      });
+
+      return lease;
+    });
+  }
+}
+
+export const leaseService = new LeaseService();

package/src/modules/task/task.service.ts

@@ -0,0 +1,46 @@
+import { db } from '../../infrastructure/db/index.js';
+import { tasks } from '../../infrastructure/db/schema.js';
+import { randomUUID } from 'crypto';
+import { eventService } from '../event/event.service.js';
+
+export class TaskService {
+  async createTask(params: {
+    workspaceId: string;
+    repositoryId: string;
+    objective: string;
+    description?: string;
+    createdBy: string;
+  }) {
+    return await db.transaction(async (tx) => {
+      const taskId = randomUUID();
+      const [task] = await tx.insert(tasks).values({
+        id: taskId,
+        workspaceId: params.workspaceId,
+        repositoryId: params.repositoryId,
+        objective: params.objective,
+        description: params.description || '',
+        createdBy: params.createdBy,
+        state: 'ready',
+      }).returning();
+
+      await eventService.appendEvent(tx, {
+        workspaceId: params.workspaceId,
+        eventType: 'TaskCreated',
+        aggregateType: 'Task',
+        aggregateId: task.id,
+        aggregateVersion: task.version,
+        actorType: 'User',
+        actorId: params.createdBy,
+        payload: {
+          objective: task.objective,
+          repositoryId: task.repositoryId,
+          state: task.state
+        }
+      });
+
+      return task;
+    });
+  }
+}
+
+export const taskService = new TaskService();

package/src/transport/mcp/index.ts

@@ -0,0 +1,167 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { FastifyInstance } from "fastify";
+import { agentService } from "../../modules/identity/agent.service.js";
+import { taskService } from "../../modules/task/task.service.js";
+import { leaseService } from "../../modules/lease/lease.service.js";
+
+export async function setupMcpTransport(fastify: FastifyInstance) {
+  // Store transports for the POST /mcp/message route
+  const transports = new Map<string, SSEServerTransport>();
+
+  fastify.get("/mcp/sse", async (request, reply) => {
+    // Hijack the Fastify response so we can stream SSE headers manually
+    reply.hijack();
+    
+    const transport = new SSEServerTransport("/mcp/message", reply.raw);
+    const sessionId = transport.sessionId;
+    console.log(`New SSE connection: ${sessionId}`);
+    transports.set(sessionId, transport);
+    
+    // Create a new MCP Server instance per connection
+    const mcpServer = new Server(
+      { name: "mcp-agent-broker", version: "1.0.0" },
+      { capabilities: { tools: {} } }
+    );
+
+    // Setup tools
+    mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "register_agent",
+            description: "Register a new coding agent instance",
+            inputSchema: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                version: { type: "string" },
+                capabilities: {
+                  type: "array",
+                  items: { type: "string" }
+                }
+              },
+              required: ["name", "version", "capabilities"]
+            }
+          },
+          {
+            name: "create_task",
+            description: "Create a new coding task",
+            inputSchema: {
+              type: "object",
+              properties: {
+                workspaceId: { type: "string" },
+                repositoryId: { type: "string" },
+                objective: { type: "string" },
+                description: { type: "string" },
+                createdBy: { type: "string" }
+              },
+              required: ["workspaceId", "repositoryId", "objective", "createdBy"]
+            }
+          },
+          {
+            name: "acquire_task_lease",
+            description: "Acquire an atomic lease for a task (execution or review)",
+            inputSchema: {
+              type: "object",
+              properties: {
+                taskId: { type: "string" },
+                workspaceId: { type: "string" },
+                agentInstanceId: { type: "string" },
+                leaseType: { type: "string", enum: ["execution", "review"] }
+              },
+              required: ["taskId", "workspaceId", "agentInstanceId", "leaseType"]
+            }
+          }
+        ]
+      };
+    });
+
+    mcpServer.setRequestHandler(CallToolRequestSchema, async (req) => {
+      if (req.params.name === "register_agent") {
+        try {
+          const args = req.params.arguments as any;
+          const instance = await agentService.registerAgent({
+            name: args.name,
+            version: args.version,
+            capabilities: args.capabilities,
+          });
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Agent registered successfully! Instance ID: ${instance.id}`
+              }
+            ]
+          };
+        } catch (e: any) {
+          console.error("Error in register_agent:", e);
+          throw e;
+        }
+      } else if (req.params.name === "create_task") {
+        try {
+          const args = req.params.arguments as any;
+          const task = await taskService.createTask({
+            workspaceId: args.workspaceId,
+            repositoryId: args.repositoryId,
+            objective: args.objective,
+            description: args.description,
+            createdBy: args.createdBy
+          });
+
+          return {
+            content: [
+              { type: "text", text: `Task created successfully! Task ID: ${task.id}` }
+            ]
+          };
+        } catch (e: any) {
+          console.error("Error in create_task:", e);
+          throw e;
+        }
+      } else if (req.params.name === "acquire_task_lease") {
+        try {
+          const args = req.params.arguments as any;
+          const lease = await leaseService.acquireLease({
+            taskId: args.taskId,
+            workspaceId: args.workspaceId,
+            agentInstanceId: args.agentInstanceId,
+            leaseType: args.leaseType as "execution" | "review"
+          });
+
+          return {
+            content: [
+              { type: "text", text: `Lease acquired! Lease ID: ${lease.id}, Fencing Token: ${lease.fencingToken}` }
+            ]
+          };
+        } catch (e: any) {
+          console.error("Error in acquire_task_lease:", e);
+          throw e;
+        }
+      }
+      throw new Error(`Tool not found: ${req.params.name}`);
+    });
+
+    await mcpServer.connect(transport);
+
+    request.raw.on("close", () => {
+      console.log(`SSE connection closed: ${sessionId}`);
+      transports.delete(sessionId);
+    });
+  });
+
+  fastify.post<{ Querystring: { sessionId: string } }>("/mcp/message", async (request, reply) => {
+    const sessionId = request.query.sessionId;
+    const transport = transports.get(sessionId);
+
+    if (!transport) {
+      reply.code(404).send({ error: "Session not found" });
+      return;
+    }
+
+    // Fastify parses the body automatically
+    await transport.handleMessage(request.body as any);
+    reply.code(202).send("Accepted");
+  });
+}

package/src/workers/outbox-relay.ts

@@ -0,0 +1,61 @@
+import { db } from '../infrastructure/db/index.js';
+import { events, outbox } from '../infrastructure/db/schema.js';
+import { redis } from '../infrastructure/redis/index.js';
+import { inArray, asc } from 'drizzle-orm';
+
+export class OutboxRelayWorker {
+  private timer: NodeJS.Timeout | null = null;
+  private isRunning = false;
+
+  start() {
+    console.log("Starting Outbox Relay Worker...");
+    this.timer = setInterval(() => this.processOutbox(), 2000);
+  }
+
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+  }
+
+  async processOutbox() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+
+    try {
+      // 1. Fetch pending outbox events
+      const pendingRecords = await db.select()
+        .from(outbox)
+        .orderBy(asc(outbox.createdAt))
+        .limit(50);
+
+      if (pendingRecords.length === 0) {
+        this.isRunning = false;
+        return;
+      }
+
+      const eventIds = pendingRecords.map(r => r.eventId);
+
+      // 2. Fetch the actual event data
+      const eventData = await db.select().from(events).where(inArray(events.eventId, eventIds));
+
+      // 3. Publish to Redis Pub/Sub
+      for (const record of pendingRecords) {
+        const evt = eventData.find(e => e.eventId === record.eventId);
+        if (evt) {
+          const channel = `workspace:${evt.workspaceId}:events`;
+          await redis.publish(channel, JSON.stringify(evt));
+          console.log(`[Event Relay] Published ${evt.eventType} to ${channel}`);
+        }
+      }
+
+      // 4. Delete processed outbox records
+      await db.delete(outbox).where(inArray(outbox.eventId, eventIds));
+
+    } catch (e) {
+      console.error("Outbox Relay Error:", e);
+    } finally {
+      this.isRunning = false;
+    }
+  }
+}
+
+export const outboxRelay = new OutboxRelayWorker();

package/test_client.ts

@@ -0,0 +1,34 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+async function run() {
+  const transport = new SSEClientTransport(new URL("http://127.0.0.1:3000/mcp/sse"));
+  const client = new Client(
+    { name: "test-client", version: "1.0.0" },
+    { capabilities: {} }
+  );
+
+  await client.connect(transport);
+  console.log("Connected to MCP Server");
+
+  const result = await client.request(
+    {
+      method: "tools/call",
+      params: {
+        name: "register_agent",
+        arguments: {
+          name: "Claude Code",
+          version: "0.2.0",
+          capabilities: ["read", "write", "execute"]
+        }
+      }
+    },
+    CallToolResultSchema
+  );
+
+  console.log("Result:", JSON.stringify(result, null, 2));
+  process.exit(0);
+}
+
+run().catch(console.error);