claude-flow/src/sdk/in-process-mcp.ts

Enterprise-grade AI agent orchestration with WASM-powered ReasoningBank memory and AgentDB vector database (always uses latest agentic-flow)

/**
 * Real In-Process MCP - 100% SDK-Powered
 * Claude-Flow v2.5-alpha.130+
 *
 * Uses ONLY Claude Code SDK primitives - TRUE in-process MCP:
 * - createSdkMcpServer() (SDK creates in-process server)
 * - tool() (SDK defines tools with Zod schemas)
 * - No subprocess, stdio, or HTTP transport overhead
 *
 * VERIFIED: Real in-process MCP servers using actual SDK capabilities
 */

import {
  createSdkMcpServer,
  tool,
  type McpSdkServerConfigWithInstance,
} from '@anthropic-ai/claude-code';
import { z } from 'zod';

/**
 * Example 1: Math Operations MCP Server
 *
 * Simple in-process server with basic math operations
 */
export function createMathMcpServer(): McpSdkServerConfigWithInstance {
  return createSdkMcpServer({
    name: 'math-operations',
    version: '1.0.0',
    tools: [
      // Add two numbers
      tool({
        name: 'add',
        description: 'Add two numbers together',
        parameters: z.object({
          a: z.number().describe('First number'),
          b: z.number().describe('Second number'),
        }),
        execute: async ({ a, b }) => {
          return { result: a + b };
        },
      }),

      // Multiply two numbers
      tool({
        name: 'multiply',
        description: 'Multiply two numbers',
        parameters: z.object({
          a: z.number().describe('First number'),
          b: z.number().describe('Second number'),
        }),
        execute: async ({ a, b }) => {
          return { result: a * b };
        },
      }),

      // Calculate factorial
      tool({
        name: 'factorial',
        description: 'Calculate factorial of a number',
        parameters: z.object({
          n: z.number().int().min(0).describe('Number to calculate factorial of'),
        }),
        execute: async ({ n }) => {
          let result = 1;
          for (let i = 2; i <= n; i++) {
            result *= i;
          }
          return { result };
        },
      }),
    ],
  });
}

/**
 * Example 2: Session Management MCP Server
 *
 * In-process server for managing session state
 */
export function createSessionMcpServer(): McpSdkServerConfigWithInstance {
  // In-process state (no IPC overhead!)
  const sessions = new Map<string, { data: Record<string, any>; created: number }>();

  return createSdkMcpServer({
    name: 'session-manager',
    version: '1.0.0',
    tools: [
      // Create session
      tool({
        name: 'session_create',
        description: 'Create a new session with initial data',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
          data: z.record(z.any()).optional().describe('Initial session data'),
        }),
        execute: async ({ sessionId, data = {} }) => {
          if (sessions.has(sessionId)) {
            return { error: 'Session already exists' };
          }

          sessions.set(sessionId, {
            data,
            created: Date.now(),
          });

          return {
            success: true,
            sessionId,
            created: sessions.get(sessionId)!.created,
          };
        },
      }),

      // Get session data
      tool({
        name: 'session_get',
        description: 'Get session data by ID',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
        }),
        execute: async ({ sessionId }) => {
          const session = sessions.get(sessionId);

          if (!session) {
            return { error: 'Session not found' };
          }

          return {
            sessionId,
            data: session.data,
            created: session.created,
          };
        },
      }),

      // Update session data
      tool({
        name: 'session_update',
        description: 'Update session data (merges with existing)',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
          data: z.record(z.any()).describe('Data to merge'),
        }),
        execute: async ({ sessionId, data }) => {
          const session = sessions.get(sessionId);

          if (!session) {
            return { error: 'Session not found' };
          }

          // Merge data
          session.data = { ...session.data, ...data };

          return {
            success: true,
            sessionId,
            data: session.data,
          };
        },
      }),

      // Delete session
      tool({
        name: 'session_delete',
        description: 'Delete a session',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
        }),
        execute: async ({ sessionId }) => {
          const existed = sessions.delete(sessionId);

          return {
            success: existed,
            sessionId,
          };
        },
      }),

      // List all sessions
      tool({
        name: 'session_list',
        description: 'List all active sessions',
        parameters: z.object({}),
        execute: async () => {
          const sessionList = Array.from(sessions.entries()).map(([id, session]) => ({
            sessionId: id,
            created: session.created,
            dataKeys: Object.keys(session.data),
          }));

          return {
            sessions: sessionList,
            count: sessionList.length,
          };
        },
      }),
    ],
  });
}

/**
 * Example 3: Checkpoint Management MCP Server
 *
 * In-process server integrated with checkpoint manager
 */
export function createCheckpointMcpServer(): McpSdkServerConfigWithInstance {
  // Import checkpoint manager
  const { checkpointManager } = require('./checkpoint-manager');

  return createSdkMcpServer({
    name: 'checkpoint-manager',
    version: '1.0.0',
    tools: [
      // Create checkpoint
      tool({
        name: 'checkpoint_create',
        description: 'Create a checkpoint for a session',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
          description: z.string().describe('Checkpoint description'),
        }),
        execute: async ({ sessionId, description }) => {
          try {
            const checkpointId = await checkpointManager.createCheckpoint(
              sessionId,
              description
            );

            return {
              success: true,
              checkpointId,
              description,
            };
          } catch (error) {
            return {
              success: false,
              error: error instanceof Error ? error.message : String(error),
            };
          }
        },
      }),

      // List checkpoints
      tool({
        name: 'checkpoint_list',
        description: 'List all checkpoints for a session',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
        }),
        execute: async ({ sessionId }) => {
          const checkpoints = checkpointManager.listCheckpoints(sessionId);

          return {
            sessionId,
            checkpoints: checkpoints.map(c => ({
              id: c.id,
              description: c.description,
              timestamp: c.timestamp,
              messageCount: c.messageCount,
              totalTokens: c.totalTokens,
              filesModified: c.filesModified,
            })),
            count: checkpoints.length,
          };
        },
      }),

      // Get checkpoint info
      tool({
        name: 'checkpoint_get',
        description: 'Get checkpoint details',
        parameters: z.object({
          checkpointId: z.string().describe('Checkpoint identifier'),
        }),
        execute: async ({ checkpointId }) => {
          const checkpoint = checkpointManager.getCheckpoint(checkpointId);

          if (!checkpoint) {
            return { error: 'Checkpoint not found' };
          }

          return {
            checkpoint: {
              id: checkpoint.id,
              sessionId: checkpoint.sessionId,
              description: checkpoint.description,
              timestamp: checkpoint.timestamp,
              messageCount: checkpoint.messageCount,
              totalTokens: checkpoint.totalTokens,
              filesModified: checkpoint.filesModified,
            },
          };
        },
      }),

      // Delete checkpoint
      tool({
        name: 'checkpoint_delete',
        description: 'Delete a checkpoint',
        parameters: z.object({
          checkpointId: z.string().describe('Checkpoint identifier'),
        }),
        execute: async ({ checkpointId }) => {
          try {
            await checkpointManager.deleteCheckpoint(checkpointId);

            return {
              success: true,
              checkpointId,
            };
          } catch (error) {
            return {
              success: false,
              error: error instanceof Error ? error.message : String(error),
            };
          }
        },
      }),

      // Compare checkpoints
      tool({
        name: 'checkpoint_diff',
        description: 'Compare two checkpoints',
        parameters: z.object({
          fromId: z.string().describe('From checkpoint ID'),
          toId: z.string().describe('To checkpoint ID'),
        }),
        execute: async ({ fromId, toId }) => {
          try {
            const diff = checkpointManager.getCheckpointDiff(fromId, toId);

            return {
              success: true,
              diff,
            };
          } catch (error) {
            return {
              success: false,
              error: error instanceof Error ? error.message : String(error),
            };
          }
        },
      }),
    ],
  });
}

/**
 * Example 4: Query Control MCP Server
 *
 * In-process server for pause/resume operations
 */
export function createQueryControlMcpServer(): McpSdkServerConfigWithInstance {
  const { queryController } = require('./query-control');

  return createSdkMcpServer({
    name: 'query-control',
    version: '1.0.0',
    tools: [
      // Request pause
      tool({
        name: 'query_pause_request',
        description: 'Request a query to pause at next safe point',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
        }),
        execute: async ({ sessionId }) => {
          queryController.requestPause(sessionId);

          return {
            success: true,
            sessionId,
            status: 'pause_requested',
          };
        },
      }),

      // Cancel pause request
      tool({
        name: 'query_pause_cancel',
        description: 'Cancel a pause request',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
        }),
        execute: async ({ sessionId }) => {
          queryController.cancelPauseRequest(sessionId);

          return {
            success: true,
            sessionId,
            status: 'pause_cancelled',
          };
        },
      }),

      // List paused queries
      tool({
        name: 'query_paused_list',
        description: 'List all paused queries',
        parameters: z.object({}),
        execute: async () => {
          const paused = queryController.listPausedQueries();

          return {
            paused,
            count: paused.length,
          };
        },
      }),

      // Get paused query state
      tool({
        name: 'query_paused_get',
        description: 'Get paused query state',
        parameters: z.object({
          sessionId: z.string().describe('Session identifier'),
        }),
        execute: async ({ sessionId }) => {
          const state = queryController.getPausedState(sessionId);

          if (!state) {
            return { error: 'Paused query not found' };
          }

          return {
            sessionId,
            pausePointMessageId: state.pausePointMessageId,
            pausedAt: state.pausedAt,
            messageCount: state.messages.length,
          };
        },
      }),

      // Get metrics
      tool({
        name: 'query_metrics',
        description: 'Get query control metrics',
        parameters: z.object({}),
        execute: async () => {
          const metrics = queryController.getMetrics();

          return {
            metrics: {
              totalPauses: metrics.totalPauses,
              totalResumes: metrics.totalResumes,
              averagePauseDuration: metrics.averagePauseDuration,
              longestPause: metrics.longestPause,
            },
          };
        },
      }),
    ],
  });
}

/**
 * Example Usage:
 *
 * ```typescript
 * import { query } from '@anthropic-ai/claude-code';
 * import {
 *   createMathMcpServer,
 *   createSessionMcpServer,
 *   createCheckpointMcpServer,
 *   createQueryControlMcpServer,
 * } from './in-process-mcp';
 *
 * // Use in-process MCP servers (no IPC overhead!)
 * const result = await query({
 *   prompt: 'Calculate 5! and store result in session',
 *   options: {
 *     mcpServers: {
 *       math: createMathMcpServer(),
 *       session: createSessionMcpServer(),
 *       checkpoint: createCheckpointMcpServer(),
 *       queryControl: createQueryControlMcpServer(),
 *     },
 *   },
 * });
 * ```
 */

// Export all server factories
export {
  createMathMcpServer,
  createSessionMcpServer,
  createCheckpointMcpServer,
  createQueryControlMcpServer,
};