claude-flow 2.5.0-alpha.138 → 2.5.0-alpha.141

package/dist/src/sdk/claude-flow-mcp-integration.js

@@ -0,0 +1,221 @@
+import { query } from '@anthropic-ai/claude-code';
+import { RealSessionForking } from './session-forking';
+import { RealQueryController } from './query-control';
+import { RealCheckpointManager } from './checkpoint-manager';
+import { createMathMcpServer, createSessionMcpServer, createCheckpointMcpServer, createQueryControlMcpServer } from './in-process-mcp';
+export class IntegratedClaudeFlowSession {
+    forking;
+    controller;
+    checkpointManager;
+    config;
+    constructor(config = {}){
+        this.config = config;
+        if (config.enableSessionForking) {
+            this.forking = new RealSessionForking();
+        }
+        if (config.enableQueryControl) {
+            this.controller = new RealQueryController();
+        }
+        if (config.enableCheckpoints) {
+            this.checkpointManager = new RealCheckpointManager({
+                autoCheckpointInterval: config.checkpointInterval || 10
+            });
+        }
+    }
+    async createIntegratedQuery(prompt, sessionId, options = {}) {
+        const mcpServers = {};
+        if (this.config.inProcessServers?.math) {
+            mcpServers.math = createMathMcpServer();
+        }
+        if (this.config.inProcessServers?.session) {
+            mcpServers.session = createSessionMcpServer();
+        }
+        if (this.config.inProcessServers?.checkpoint) {
+            mcpServers.checkpoint = createCheckpointMcpServer();
+        }
+        if (this.config.inProcessServers?.queryControl) {
+            mcpServers.queryControl = createQueryControlMcpServer();
+        }
+        const integratedQuery = query({
+            prompt,
+            options: {
+                ...options,
+                mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined
+            }
+        });
+        if (this.forking) {
+            await this.forking.trackSession(sessionId, integratedQuery);
+        }
+        if (this.checkpointManager && this.config.enableCheckpoints) {
+            await this.checkpointManager.trackSession(sessionId, integratedQuery, true);
+        }
+        return integratedQuery;
+    }
+    async forkWithMcpCoordination(baseSessionId, forkDescription) {
+        if (!this.forking) {
+            throw new Error('Session forking not enabled');
+        }
+        const fork = await this.forking.fork(baseSessionId, {});
+        if (this.checkpointManager) {
+            await this.checkpointManager.createCheckpoint(baseSessionId, `Fork created: ${forkDescription}`);
+        }
+        return fork;
+    }
+    async pauseWithCheckpoint(activeQuery, sessionId, originalPrompt, checkpointDescription) {
+        if (!this.controller) {
+            throw new Error('Query control not enabled');
+        }
+        this.controller.requestPause(sessionId);
+        const pausePointId = await this.controller.pauseQuery(activeQuery, sessionId, originalPrompt, {});
+        if (this.checkpointManager) {
+            await this.checkpointManager.createCheckpoint(sessionId, checkpointDescription || `Paused at ${pausePointId}`);
+        }
+        return pausePointId;
+    }
+    async resumeFromCheckpoint(checkpointId, continuePrompt) {
+        if (!this.checkpointManager) {
+            throw new Error('Checkpoints not enabled');
+        }
+        return await this.checkpointManager.rollbackToCheckpoint(checkpointId, continuePrompt);
+    }
+    getMetrics() {
+        return {
+            queryControl: this.controller?.getMetrics(),
+            activeSessions: this.forking?.getActiveSessions(),
+            checkpoints: this.checkpointManager ? {
+                enabled: true
+            } : {
+                enabled: false
+            }
+        };
+    }
+}
+export async function exampleClaudeFlowMcpWithSdk() {
+    const session = new IntegratedClaudeFlowSession({
+        enableSessionForking: true,
+        enableQueryControl: true,
+        enableCheckpoints: true,
+        checkpointInterval: 10,
+        mcpToolsConfig: {
+            swarmTopology: 'mesh',
+            maxAgents: 8,
+            enableNeural: true,
+            enableMemory: true
+        },
+        inProcessServers: {
+            math: true,
+            session: true,
+            checkpoint: true,
+            queryControl: true
+        }
+    });
+    const mainQuery = await session.createIntegratedQuery(`
+    Initialize a mesh swarm with 8 agents using Claude Flow MCP tools.
+    Then use the math MCP server to calculate factorial of 10.
+    Store results in session and create a checkpoint.
+    `, 'integrated-session', {});
+    console.log('Created integrated query with:');
+    console.log('- SDK: Session forking, checkpoints, query control');
+    console.log('- In-process MCP: math, session, checkpoint, queryControl');
+    console.log('- Claude Flow MCP tools: swarm_init, agent_spawn, etc.');
+    const fork1 = await session.forkWithMcpCoordination('integrated-session', 'Try hierarchical topology');
+    console.log('Forked session:', fork1.sessionId);
+    if (session['checkpointManager']) {
+        const cp = await session['checkpointManager'].createCheckpoint('integrated-session', 'Before swarm initialization');
+        console.log('Checkpoint created:', cp);
+    }
+    const metrics = session.getMetrics();
+    console.log('Metrics:', metrics);
+}
+export function exampleNpxIntegration() {
+    console.log(`
+╔════════════════════════════════════════════════════════════╗
+║  Claude Flow NPX + SDK Integration                         ║
+╚════════════════════════════════════════════════════════════╝
+
+# Install Claude Flow MCP server
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+
+# Optional: Add ruv-swarm for enhanced coordination
+claude mcp add ruv-swarm npx ruv-swarm mcp start
+
+# Now use SDK features WITH MCP tools:
+
+## 1. Session Forking + Swarm Coordination
+import { query } from '@anthropic-ai/claude-code';
+import { RealSessionForking } from './sdk/session-forking';
+
+const forking = new RealSessionForking();
+const q = query({
+  prompt: 'Use mcp__claude-flow__swarm_init to create mesh topology',
+  options: {
+    // MCP tools are auto-available via 'claude mcp add'
+  }
+});
+
+await forking.trackSession('swarm-session', q);
+const fork = await forking.fork('swarm-session');
+
+## 2. Checkpoints + Neural Training
+import { RealCheckpointManager } from './sdk/checkpoint-manager';
+
+const manager = new RealCheckpointManager();
+const q = query({
+  prompt: 'Use mcp__claude-flow__neural_train to train patterns',
+});
+
+await manager.trackSession('neural-session', q, true);
+const cp = await manager.createCheckpoint('neural-session', 'Before training');
+
+// Train neural patterns with Claude Flow MCP
+// Then rollback if needed:
+await manager.rollbackToCheckpoint(cp);
+
+## 3. Query Control + Task Orchestration
+import { RealQueryController } from './sdk/query-control';
+
+const controller = new RealQueryController();
+const q = query({
+  prompt: \`
+    Use mcp__claude-flow__task_orchestrate to:
+    - Break down complex task
+    - Distribute to agents
+    - Monitor progress
+  \`,
+});
+
+// Pause if needed
+controller.requestPause('task-session');
+const pauseId = await controller.pauseQuery(q, 'task-session', 'Task', {});
+
+// Resume later
+const resumed = await controller.resumeQuery('task-session');
+
+## 4. In-Process MCP + Claude Flow MCP Together
+import { createMathMcpServer } from './sdk/in-process-mcp';
+
+const q = query({
+  prompt: \`
+    Use math server to calculate factorial.
+    Use mcp__claude-flow__memory_usage to store result.
+    Use mcp__claude-flow__agent_spawn to process result.
+  \`,
+  options: {
+    mcpServers: {
+      math: createMathMcpServer(), // In-process (fast!)
+      // claude-flow MCP tools auto-available
+    }
+  }
+});
+
+╔════════════════════════════════════════════════════════════╗
+║  Key Benefits:                                             ║
+║  ✅ SDK = In-process, zero overhead                       ║
+║  ✅ MCP tools = Coordination, neural, swarms              ║
+║  ✅ Together = Maximum power and flexibility              ║
+╚════════════════════════════════════════════════════════════╝
+  `);
+}
+export { IntegratedClaudeFlowSession };
+
+//# sourceMappingURL=claude-flow-mcp-integration.js.map

package/dist/src/sdk/claude-flow-mcp-integration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/sdk/claude-flow-mcp-integration.ts"],"sourcesContent":["/**\n * Claude Flow MCP Integration - SDK + Existing MCP Tools\n * Claude-Flow v2.5-alpha.130+\n *\n * Integrates SDK-powered features WITH existing Claude Flow MCP tools:\n * - Uses SDK for session management, forking, checkpoints\n * - Uses Claude Flow MCP tools for swarm coordination, neural features\n * - Combines both for maximum power\n *\n * VERIFIED: Real integration of SDK + MCP tools\n */\n\nimport { query, type Query, type Options } from '@anthropic-ai/claude-code';\nimport { RealSessionForking } from './session-forking';\nimport { RealQueryController } from './query-control';\nimport { RealCheckpointManager } from './checkpoint-manager';\nimport {\n  createMathMcpServer,\n  createSessionMcpServer,\n  createCheckpointMcpServer,\n  createQueryControlMcpServer,\n} from './in-process-mcp';\n\n/**\n * Integration Configuration\n */\nexport interface ClaudeFlowIntegrationConfig {\n  // SDK features\n  enableSessionForking?: boolean;\n  enableQueryControl?: boolean;\n  enableCheckpoints?: boolean;\n  checkpointInterval?: number;\n\n  // MCP tool configuration\n  mcpToolsConfig?: {\n    swarmTopology?: 'hierarchical' | 'mesh' | 'ring' | 'star';\n    maxAgents?: number;\n    enableNeural?: boolean;\n    enableMemory?: boolean;\n  };\n\n  // In-process MCP servers\n  inProcessServers?: {\n    math?: boolean;\n    session?: boolean;\n    checkpoint?: boolean;\n    queryControl?: boolean;\n  };\n}\n\n/**\n * Integrated Claude Flow Session\n *\n * Combines SDK features with Claude Flow MCP tools\n */\nexport class IntegratedClaudeFlowSession {\n  private forking?: RealSessionForking;\n  private controller?: RealQueryController;\n  private checkpointManager?: RealCheckpointManager;\n  private config: ClaudeFlowIntegrationConfig;\n\n  constructor(config: ClaudeFlowIntegrationConfig = {}) {\n    this.config = config;\n\n    // Initialize SDK features based on config\n    if (config.enableSessionForking) {\n      this.forking = new RealSessionForking();\n    }\n\n    if (config.enableQueryControl) {\n      this.controller = new RealQueryController();\n    }\n\n    if (config.enableCheckpoints) {\n      this.checkpointManager = new RealCheckpointManager({\n        autoCheckpointInterval: config.checkpointInterval || 10,\n      });\n    }\n  }\n\n  /**\n   * Create a query that uses BOTH SDK features AND Claude Flow MCP tools\n   */\n  async createIntegratedQuery(\n    prompt: string,\n    sessionId: string,\n    options: Partial<Options> = {}\n  ): Promise<Query> {\n    // Build MCP servers configuration\n    const mcpServers: Record<string, any> = {};\n\n    // Add in-process servers if enabled\n    if (this.config.inProcessServers?.math) {\n      mcpServers.math = createMathMcpServer();\n    }\n    if (this.config.inProcessServers?.session) {\n      mcpServers.session = createSessionMcpServer();\n    }\n    if (this.config.inProcessServers?.checkpoint) {\n      mcpServers.checkpoint = createCheckpointMcpServer();\n    }\n    if (this.config.inProcessServers?.queryControl) {\n      mcpServers.queryControl = createQueryControlMcpServer();\n    }\n\n    // Add Claude Flow MCP tools (these use stdio/subprocess)\n    // The MCP server is already configured globally via `claude mcp add claude-flow`\n    // So we don't need to add it here - it's automatically available\n\n    // Create the query\n    const integratedQuery = query({\n      prompt,\n      options: {\n        ...options,\n        mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined,\n      },\n    });\n\n    // Track with SDK features\n    if (this.forking) {\n      await this.forking.trackSession(sessionId, integratedQuery);\n    }\n\n    if (this.checkpointManager && this.config.enableCheckpoints) {\n      await this.checkpointManager.trackSession(\n        sessionId,\n        integratedQuery,\n        true // Auto-checkpoint\n      );\n    }\n\n    return integratedQuery;\n  }\n\n  /**\n   * Fork a session (SDK) while using Claude Flow MCP tools for coordination\n   */\n  async forkWithMcpCoordination(\n    baseSessionId: string,\n    forkDescription: string\n  ) {\n    if (!this.forking) {\n      throw new Error('Session forking not enabled');\n    }\n\n    // Fork using SDK\n    const fork = await this.forking.fork(baseSessionId, {\n      // In-process servers are inherited\n    });\n\n    // Create checkpoint for fork point\n    if (this.checkpointManager) {\n      await this.checkpointManager.createCheckpoint(\n        baseSessionId,\n        `Fork created: ${forkDescription}`\n      );\n    }\n\n    return fork;\n  }\n\n  /**\n   * Pause a query (SDK) and create checkpoint\n   */\n  async pauseWithCheckpoint(\n    activeQuery: Query,\n    sessionId: string,\n    originalPrompt: string,\n    checkpointDescription: string\n  ) {\n    if (!this.controller) {\n      throw new Error('Query control not enabled');\n    }\n\n    // Request pause\n    this.controller.requestPause(sessionId);\n\n    // Pause query\n    const pausePointId = await this.controller.pauseQuery(\n      activeQuery,\n      sessionId,\n      originalPrompt,\n      {}\n    );\n\n    // Create checkpoint at pause point\n    if (this.checkpointManager) {\n      await this.checkpointManager.createCheckpoint(\n        sessionId,\n        checkpointDescription || `Paused at ${pausePointId}`\n      );\n    }\n\n    return pausePointId;\n  }\n\n  /**\n   * Resume from checkpoint\n   */\n  async resumeFromCheckpoint(checkpointId: string, continuePrompt?: string) {\n    if (!this.checkpointManager) {\n      throw new Error('Checkpoints not enabled');\n    }\n\n    // Rollback to checkpoint using SDK\n    return await this.checkpointManager.rollbackToCheckpoint(\n      checkpointId,\n      continuePrompt\n    );\n  }\n\n  /**\n   * Get comprehensive metrics\n   */\n  getMetrics() {\n    return {\n      queryControl: this.controller?.getMetrics(),\n      activeSessions: this.forking?.getActiveSessions(),\n      checkpoints: this.checkpointManager\n        ? {\n            // Would need to track total checkpoints across sessions\n            enabled: true,\n          }\n        : { enabled: false },\n    };\n  }\n}\n\n/**\n * Example: Use Claude Flow MCP tools WITH SDK features\n */\nexport async function exampleClaudeFlowMcpWithSdk() {\n  const session = new IntegratedClaudeFlowSession({\n    enableSessionForking: true,\n    enableQueryControl: true,\n    enableCheckpoints: true,\n    checkpointInterval: 10,\n    mcpToolsConfig: {\n      swarmTopology: 'mesh',\n      maxAgents: 8,\n      enableNeural: true,\n      enableMemory: true,\n    },\n    inProcessServers: {\n      math: true,\n      session: true,\n      checkpoint: true,\n      queryControl: true,\n    },\n  });\n\n  // Create query that uses BOTH:\n  // - In-process MCP servers (SDK)\n  // - Claude Flow MCP tools (stdio)\n  const mainQuery = await session.createIntegratedQuery(\n    `\n    Initialize a mesh swarm with 8 agents using Claude Flow MCP tools.\n    Then use the math MCP server to calculate factorial of 10.\n    Store results in session and create a checkpoint.\n    `,\n    'integrated-session',\n    {}\n  );\n\n  console.log('Created integrated query with:');\n  console.log('- SDK: Session forking, checkpoints, query control');\n  console.log('- In-process MCP: math, session, checkpoint, queryControl');\n  console.log('- Claude Flow MCP tools: swarm_init, agent_spawn, etc.');\n\n  // Fork the session to try different approaches\n  const fork1 = await session.forkWithMcpCoordination(\n    'integrated-session',\n    'Try hierarchical topology'\n  );\n\n  console.log('Forked session:', fork1.sessionId);\n\n  // Create checkpoint before major changes\n  if (session['checkpointManager']) {\n    const cp = await session['checkpointManager'].createCheckpoint(\n      'integrated-session',\n      'Before swarm initialization'\n    );\n    console.log('Checkpoint created:', cp);\n  }\n\n  // Get metrics\n  const metrics = session.getMetrics();\n  console.log('Metrics:', metrics);\n}\n\n/**\n * NPX Command Integration\n *\n * Show how to use Claude Flow NPX commands with SDK features\n */\nexport function exampleNpxIntegration() {\n  console.log(`\n╔════════════════════════════════════════════════════════════╗\n║  Claude Flow NPX + SDK Integration                         ║\n╚════════════════════════════════════════════════════════════╝\n\n# Install Claude Flow MCP server\nclaude mcp add claude-flow npx claude-flow@alpha mcp start\n\n# Optional: Add ruv-swarm for enhanced coordination\nclaude mcp add ruv-swarm npx ruv-swarm mcp start\n\n# Now use SDK features WITH MCP tools:\n\n## 1. Session Forking + Swarm Coordination\nimport { query } from '@anthropic-ai/claude-code';\nimport { RealSessionForking } from './sdk/session-forking';\n\nconst forking = new RealSessionForking();\nconst q = query({\n  prompt: 'Use mcp__claude-flow__swarm_init to create mesh topology',\n  options: {\n    // MCP tools are auto-available via 'claude mcp add'\n  }\n});\n\nawait forking.trackSession('swarm-session', q);\nconst fork = await forking.fork('swarm-session');\n\n## 2. Checkpoints + Neural Training\nimport { RealCheckpointManager } from './sdk/checkpoint-manager';\n\nconst manager = new RealCheckpointManager();\nconst q = query({\n  prompt: 'Use mcp__claude-flow__neural_train to train patterns',\n});\n\nawait manager.trackSession('neural-session', q, true);\nconst cp = await manager.createCheckpoint('neural-session', 'Before training');\n\n// Train neural patterns with Claude Flow MCP\n// Then rollback if needed:\nawait manager.rollbackToCheckpoint(cp);\n\n## 3. Query Control + Task Orchestration\nimport { RealQueryController } from './sdk/query-control';\n\nconst controller = new RealQueryController();\nconst q = query({\n  prompt: \\`\n    Use mcp__claude-flow__task_orchestrate to:\n    - Break down complex task\n    - Distribute to agents\n    - Monitor progress\n  \\`,\n});\n\n// Pause if needed\ncontroller.requestPause('task-session');\nconst pauseId = await controller.pauseQuery(q, 'task-session', 'Task', {});\n\n// Resume later\nconst resumed = await controller.resumeQuery('task-session');\n\n## 4. In-Process MCP + Claude Flow MCP Together\nimport { createMathMcpServer } from './sdk/in-process-mcp';\n\nconst q = query({\n  prompt: \\`\n    Use math server to calculate factorial.\n    Use mcp__claude-flow__memory_usage to store result.\n    Use mcp__claude-flow__agent_spawn to process result.\n  \\`,\n  options: {\n    mcpServers: {\n      math: createMathMcpServer(), // In-process (fast!)\n      // claude-flow MCP tools auto-available\n    }\n  }\n});\n\n╔════════════════════════════════════════════════════════════╗\n║  Key Benefits:                                             ║\n║  ✅ SDK = In-process, zero overhead                       ║\n║  ✅ MCP tools = Coordination, neural, swarms              ║\n║  ✅ Together = Maximum power and flexibility              ║\n╚════════════════════════════════════════════════════════════╝\n  `);\n}\n\nexport { IntegratedClaudeFlowSession };\n"],"names":["query","RealSessionForking","RealQueryController","RealCheckpointManager","createMathMcpServer","createSessionMcpServer","createCheckpointMcpServer","createQueryControlMcpServer","IntegratedClaudeFlowSession","forking","controller","checkpointManager","config","enableSessionForking","enableQueryControl","enableCheckpoints","autoCheckpointInterval","checkpointInterval","createIntegratedQuery","prompt","sessionId","options","mcpServers","inProcessServers","math","session","checkpoint","queryControl","integratedQuery","Object","keys","length","undefined","trackSession","forkWithMcpCoordination","baseSessionId","forkDescription","Error","fork","createCheckpoint","pauseWithCheckpoint","activeQuery","originalPrompt","checkpointDescription","requestPause","pausePointId","pauseQuery","resumeFromCheckpoint","checkpointId","continuePrompt","rollbackToCheckpoint","getMetrics","activeSessions","getActiveSessions","checkpoints","enabled","exampleClaudeFlowMcpWithSdk","mcpToolsConfig","swarmTopology","maxAgents","enableNeural","enableMemory","mainQuery","console","log","fork1","cp","metrics","exampleNpxIntegration"],"mappings":"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"}

package/dist/src/sdk/in-process-mcp.js

@@ -0,0 +1,374 @@
+import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
+import { z } from 'zod';
+export function createMathMcpServer() {
+    return createSdkMcpServer({
+        name: 'math-operations',
+        version: '1.0.0',
+        tools: [
+            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
+                    };
+                }
+            }),
+            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
+                    };
+                }
+            }),
+            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
+                    };
+                }
+            })
+        ]
+    });
+}
+export function createSessionMcpServer() {
+    const sessions = new Map();
+    return createSdkMcpServer({
+        name: 'session-manager',
+        version: '1.0.0',
+        tools: [
+            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
+                    };
+                }
+            }),
+            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
+                    };
+                }
+            }),
+            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'
+                        };
+                    }
+                    session.data = {
+                        ...session.data,
+                        ...data
+                    };
+                    return {
+                        success: true,
+                        sessionId,
+                        data: session.data
+                    };
+                }
+            }),
+            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
+                    };
+                }
+            }),
+            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
+                    };
+                }
+            })
+        ]
+    });
+}
+export function createCheckpointMcpServer() {
+    const { checkpointManager } = require('./checkpoint-manager');
+    return createSdkMcpServer({
+        name: 'checkpoint-manager',
+        version: '1.0.0',
+        tools: [
+            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)
+                        };
+                    }
+                }
+            }),
+            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
+                    };
+                }
+            }),
+            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
+                        }
+                    };
+                }
+            }),
+            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)
+                        };
+                    }
+                }
+            }),
+            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)
+                        };
+                    }
+                }
+            })
+        ]
+    });
+}
+export function createQueryControlMcpServer() {
+    const { queryController } = require('./query-control');
+    return createSdkMcpServer({
+        name: 'query-control',
+        version: '1.0.0',
+        tools: [
+            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'
+                    };
+                }
+            }),
+            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'
+                    };
+                }
+            }),
+            tool({
+                name: 'query_paused_list',
+                description: 'List all paused queries',
+                parameters: z.object({}),
+                execute: async ()=>{
+                    const paused = queryController.listPausedQueries();
+                    return {
+                        paused,
+                        count: paused.length
+                    };
+                }
+            }),
+            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
+                    };
+                }
+            }),
+            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
+                        }
+                    };
+                }
+            })
+        ]
+    });
+}
+export { createMathMcpServer, createSessionMcpServer, createCheckpointMcpServer, createQueryControlMcpServer };
+
+//# sourceMappingURL=in-process-mcp.js.map