agent-orchestrator-mcp-server 0.1.0

package/shared/tools/search-sessions.d.ts

@@ -0,0 +1,92 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { IAgentOrchestratorClient } from '../orchestrator-client/orchestrator-client.js';
+export declare const SearchSessionsSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    query: z.ZodOptional<z.ZodString>;
+    search_contents: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodOptional<z.ZodEnum<["waiting", "running", "needs_input", "failed", "archived"]>>;
+    agent_type: z.ZodOptional<z.ZodString>;
+    show_archived: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status?: "waiting" | "running" | "needs_input" | "failed" | "archived" | undefined;
+    agent_type?: string | undefined;
+    show_archived?: boolean | undefined;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search_contents?: boolean | undefined;
+    id?: number | undefined;
+    query?: string | undefined;
+}, {
+    status?: "waiting" | "running" | "needs_input" | "failed" | "archived" | undefined;
+    agent_type?: string | undefined;
+    show_archived?: boolean | undefined;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search_contents?: boolean | undefined;
+    id?: number | undefined;
+    query?: string | undefined;
+}>;
+export declare function searchSessionsTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            id: {
+                type: string;
+                description: "Get a specific session by ID. When provided, other filters are ignored.";
+            };
+            query: {
+                type: string;
+                maxLength: number;
+                description: "Search query to find sessions. Searches across title, metadata, and custom_metadata. Leave empty to list all sessions.";
+            };
+            search_contents: {
+                type: string;
+                description: "Also search within transcript contents. May be slow for sessions with large transcripts. Default: false";
+            };
+            status: {
+                type: string;
+                enum: string[];
+                description: "Filter results by status. Options: \"waiting\", \"running\", \"needs_input\", \"failed\", \"archived\"";
+            };
+            agent_type: {
+                type: string;
+                description: "Filter results by agent type.";
+            };
+            show_archived: {
+                type: string;
+                description: "Include archived sessions in results. Default: false";
+            };
+            page: {
+                type: string;
+                minimum: number;
+                description: "Page number for pagination. Default: 1";
+            };
+            per_page: {
+                type: string;
+                minimum: number;
+                maximum: number;
+                description: "Number of results per page (1-100). Default: 25";
+            };
+        };
+        required: never[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+//# sourceMappingURL=search-sessions.d.ts.map

package/shared/tools/search-sessions.js

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    id: 'Get a specific session by ID. When provided, other filters are ignored.',
+    query: 'Search query to find sessions. Searches across title, metadata, and custom_metadata. Leave empty to list all sessions.',
+    search_contents: 'Also search within transcript contents. May be slow for sessions with large transcripts. Default: false',
+    status: 'Filter results by status. Options: "waiting", "running", "needs_input", "failed", "archived"',
+    agent_type: 'Filter results by agent type.',
+    show_archived: 'Include archived sessions in results. Default: false',
+    page: 'Page number for pagination. Default: 1',
+    per_page: 'Number of results per page (1-100). Default: 25',
+};
+export const SearchSessionsSchema = z.object({
+    id: z.number().optional().describe(PARAM_DESCRIPTIONS.id),
+    query: z.string().max(1000).optional().describe(PARAM_DESCRIPTIONS.query),
+    search_contents: z.boolean().optional().describe(PARAM_DESCRIPTIONS.search_contents),
+    status: z
+        .enum(['waiting', 'running', 'needs_input', 'failed', 'archived'])
+        .optional()
+        .describe(PARAM_DESCRIPTIONS.status),
+    agent_type: z.string().optional().describe(PARAM_DESCRIPTIONS.agent_type),
+    show_archived: z.boolean().optional().describe(PARAM_DESCRIPTIONS.show_archived),
+    page: z.number().min(1).optional().describe(PARAM_DESCRIPTIONS.page),
+    per_page: z.number().min(1).max(100).optional().describe(PARAM_DESCRIPTIONS.per_page),
+});
+const TOOL_DESCRIPTION = `Search for agent sessions in the Agent Orchestrator.
+
+**Use cases:**
+- Find a specific session by ID (set id parameter)
+- Search sessions by keyword in title/prompt (set query parameter)
+- List all sessions with optional status filter
+- Monitor sessions requiring attention (status: "needs_input")
+
+**Returns:** A list of matching sessions with their status, configuration, and metadata.
+
+**Session statuses:**
+- waiting: Session created, waiting to start
+- running: Agent is actively executing
+- needs_input: Agent paused, waiting for user input
+- failed: Session encountered an error
+- archived: Session completed and archived`;
+/** Maximum characters to display for prompt preview */
+const MAX_PROMPT_DISPLAY_LENGTH = 100;
+function formatSession(session) {
+    const lines = [
+        `### ${session.title} (ID: ${session.id})`,
+        '',
+        `- **Status:** ${session.status}`,
+        `- **Agent Type:** ${session.agent_type}`,
+    ];
+    if (session.slug)
+        lines.push(`- **Slug:** ${session.slug}`);
+    if (session.git_root)
+        lines.push(`- **Repository:** ${session.git_root}`);
+    if (session.branch)
+        lines.push(`- **Branch:** ${session.branch}`);
+    if (session.prompt) {
+        const truncatedPrompt = session.prompt.length > MAX_PROMPT_DISPLAY_LENGTH
+            ? session.prompt.slice(0, MAX_PROMPT_DISPLAY_LENGTH) + '...'
+            : session.prompt;
+        lines.push(`- **Prompt:** ${truncatedPrompt}`);
+    }
+    if (session.mcp_servers && session.mcp_servers.length > 0) {
+        lines.push(`- **MCP Servers:** ${session.mcp_servers.join(', ')}`);
+    }
+    lines.push(`- **Created:** ${session.created_at}`);
+    lines.push(`- **Updated:** ${session.updated_at}`);
+    return lines.join('\n');
+}
+export function searchSessionsTool(_server, clientFactory) {
+    return {
+        name: 'search_sessions',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: {
+                    type: 'number',
+                    description: PARAM_DESCRIPTIONS.id,
+                },
+                query: {
+                    type: 'string',
+                    maxLength: 1000,
+                    description: PARAM_DESCRIPTIONS.query,
+                },
+                search_contents: {
+                    type: 'boolean',
+                    description: PARAM_DESCRIPTIONS.search_contents,
+                },
+                status: {
+                    type: 'string',
+                    enum: ['waiting', 'running', 'needs_input', 'failed', 'archived'],
+                    description: PARAM_DESCRIPTIONS.status,
+                },
+                agent_type: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.agent_type,
+                },
+                show_archived: {
+                    type: 'boolean',
+                    description: PARAM_DESCRIPTIONS.show_archived,
+                },
+                page: {
+                    type: 'number',
+                    minimum: 1,
+                    description: PARAM_DESCRIPTIONS.page,
+                },
+                per_page: {
+                    type: 'number',
+                    minimum: 1,
+                    maximum: 100,
+                    description: PARAM_DESCRIPTIONS.per_page,
+                },
+            },
+            required: [],
+        },
+        handler: async (args) => {
+            try {
+                const validatedArgs = SearchSessionsSchema.parse(args);
+                const client = clientFactory();
+                // If ID is provided, get that specific session
+                if (validatedArgs.id !== undefined) {
+                    const session = await client.getSession(validatedArgs.id);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `## Session Found\n\n${formatSession(session)}`,
+                            },
+                        ],
+                    };
+                }
+                // Otherwise, search or list sessions
+                let sessions;
+                let pagination;
+                if (validatedArgs.query) {
+                    // Use search endpoint
+                    const response = await client.searchSessions(validatedArgs.query, {
+                        search_contents: validatedArgs.search_contents,
+                        status: validatedArgs.status,
+                        agent_type: validatedArgs.agent_type,
+                        show_archived: validatedArgs.show_archived,
+                        page: validatedArgs.page,
+                        per_page: validatedArgs.per_page,
+                    });
+                    sessions = response.sessions;
+                    pagination = response.pagination;
+                }
+                else {
+                    // Use list endpoint
+                    const response = await client.listSessions({
+                        status: validatedArgs.status,
+                        agent_type: validatedArgs.agent_type,
+                        show_archived: validatedArgs.show_archived,
+                        page: validatedArgs.page,
+                        per_page: validatedArgs.per_page,
+                    });
+                    sessions = response.sessions;
+                    pagination = response.pagination;
+                }
+                if (sessions.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'No sessions found matching the specified criteria.',
+                            },
+                        ],
+                    };
+                }
+                const lines = [
+                    `## Agent Sessions`,
+                    '',
+                    `Found ${pagination.total_count} session(s) (page ${pagination.page} of ${pagination.total_pages}):`,
+                    '',
+                ];
+                sessions.forEach((session) => {
+                    lines.push(formatSession(session));
+                    lines.push('');
+                });
+                if (pagination.page < pagination.total_pages) {
+                    lines.push('---');
+                    lines.push(`*More sessions available. Use page=${pagination.page + 1} to see the next page.*`);
+                }
+                return {
+                    content: [{ type: 'text', text: lines.join('\n') }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error searching sessions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools/start-session.d.ts

@@ -0,0 +1,119 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { z } from 'zod';
+import type { IAgentOrchestratorClient } from '../orchestrator-client/orchestrator-client.js';
+export declare const StartSessionSchema: z.ZodObject<{
+    agent_type: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    git_root: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    subdirectory: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    stop_condition: z.ZodOptional<z.ZodString>;
+    execution_provider: z.ZodOptional<z.ZodEnum<["local_filesystem", "remote_sandbox"]>>;
+    mcp_servers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    custom_metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    agent_type?: string | undefined;
+    prompt?: string | undefined;
+    git_root?: string | undefined;
+    branch?: string | undefined;
+    subdirectory?: string | undefined;
+    slug?: string | undefined;
+    stop_condition?: string | undefined;
+    execution_provider?: "local_filesystem" | "remote_sandbox" | undefined;
+    mcp_servers?: string[] | undefined;
+    config?: Record<string, unknown> | undefined;
+    custom_metadata?: Record<string, unknown> | undefined;
+}, {
+    title?: string | undefined;
+    agent_type?: string | undefined;
+    prompt?: string | undefined;
+    git_root?: string | undefined;
+    branch?: string | undefined;
+    subdirectory?: string | undefined;
+    slug?: string | undefined;
+    stop_condition?: string | undefined;
+    execution_provider?: "local_filesystem" | "remote_sandbox" | undefined;
+    mcp_servers?: string[] | undefined;
+    config?: Record<string, unknown> | undefined;
+    custom_metadata?: Record<string, unknown> | undefined;
+}>;
+export declare function startSessionTool(_server: Server, clientFactory: () => IAgentOrchestratorClient): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            agent_type: {
+                type: string;
+                description: "Agent type for the session. Currently only \"claude_code\" is supported. Default: \"claude_code\"";
+            };
+            prompt: {
+                type: string;
+                description: "Initial prompt for the agent. If provided, the agent job is automatically queued. Omit for a clone-only session.";
+            };
+            git_root: {
+                type: string;
+                description: "Repository URL or local path. Examples: \"https://github.com/example/repo.git\", \"/path/to/repo\"";
+            };
+            branch: {
+                type: string;
+                description: "Git branch to work on. Default: \"main\"";
+            };
+            subdirectory: {
+                type: string;
+                description: "Subdirectory within the repository to focus on.";
+            };
+            title: {
+                type: string;
+                description: "Display title for the session. Used for identification in the UI.";
+            };
+            slug: {
+                type: string;
+                description: "URL-friendly identifier for the session. Must be unique.";
+            };
+            stop_condition: {
+                type: string;
+                description: "Condition that determines when the agent should stop. Passed to the agent as context.";
+            };
+            execution_provider: {
+                type: string;
+                enum: string[];
+                description: "Execution environment. Options: \"local_filesystem\" (runs locally), \"remote_sandbox\" (runs in isolated sandbox). Default: \"local_filesystem\"";
+            };
+            mcp_servers: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: "List of MCP server names to enable for this session. Example: [\"github-development\", \"slack\"]";
+            };
+            config: {
+                type: string;
+                description: "Additional configuration as a JSON object.";
+            };
+            custom_metadata: {
+                type: string;
+                description: "User-defined metadata as a JSON object. Useful for tracking tickets, projects, etc.";
+            };
+        };
+        required: never[];
+    };
+    handler: (args: unknown) => Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError?: undefined;
+    } | {
+        content: {
+            type: string;
+            text: string;
+        }[];
+        isError: boolean;
+    }>;
+};
+//# sourceMappingURL=start-session.d.ts.map

package/shared/tools/start-session.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+const PARAM_DESCRIPTIONS = {
+    agent_type: 'Agent type for the session. Currently only "claude_code" is supported. Default: "claude_code"',
+    prompt: 'Initial prompt for the agent. If provided, the agent job is automatically queued. Omit for a clone-only session.',
+    git_root: 'Repository URL or local path. Examples: "https://github.com/example/repo.git", "/path/to/repo"',
+    branch: 'Git branch to work on. Default: "main"',
+    subdirectory: 'Subdirectory within the repository to focus on.',
+    title: 'Display title for the session. Used for identification in the UI.',
+    slug: 'URL-friendly identifier for the session. Must be unique.',
+    stop_condition: 'Condition that determines when the agent should stop. Passed to the agent as context.',
+    execution_provider: 'Execution environment. Options: "local_filesystem" (runs locally), "remote_sandbox" (runs in isolated sandbox). Default: "local_filesystem"',
+    mcp_servers: 'List of MCP server names to enable for this session. Example: ["github-development", "slack"]',
+    config: 'Additional configuration as a JSON object.',
+    custom_metadata: 'User-defined metadata as a JSON object. Useful for tracking tickets, projects, etc.',
+};
+export const StartSessionSchema = z.object({
+    agent_type: z.string().optional().describe(PARAM_DESCRIPTIONS.agent_type),
+    prompt: z.string().optional().describe(PARAM_DESCRIPTIONS.prompt),
+    git_root: z.string().optional().describe(PARAM_DESCRIPTIONS.git_root),
+    branch: z.string().optional().describe(PARAM_DESCRIPTIONS.branch),
+    subdirectory: z.string().optional().describe(PARAM_DESCRIPTIONS.subdirectory),
+    title: z.string().optional().describe(PARAM_DESCRIPTIONS.title),
+    slug: z.string().optional().describe(PARAM_DESCRIPTIONS.slug),
+    stop_condition: z.string().optional().describe(PARAM_DESCRIPTIONS.stop_condition),
+    execution_provider: z
+        .enum(['local_filesystem', 'remote_sandbox'])
+        .optional()
+        .describe(PARAM_DESCRIPTIONS.execution_provider),
+    mcp_servers: z.array(z.string()).optional().describe(PARAM_DESCRIPTIONS.mcp_servers),
+    config: z.record(z.unknown()).optional().describe(PARAM_DESCRIPTIONS.config),
+    custom_metadata: z.record(z.unknown()).optional().describe(PARAM_DESCRIPTIONS.custom_metadata),
+});
+const TOOL_DESCRIPTION = `Start a new agent session in the Agent Orchestrator.
+
+**Returns:** The created session with its ID, status, and configuration.
+
+**Behavior:**
+- If a prompt is provided, the agent job is automatically queued to start
+- If no prompt is provided, creates a clone-only session that can be started later with action_session
+
+**Use cases:**
+- Start a new agent task on a repository
+- Create a session to work on a specific branch
+- Set up an agent with specific MCP servers enabled
+- Create a session with custom metadata for tracking`;
+export function startSessionTool(_server, clientFactory) {
+    return {
+        name: 'start_session',
+        description: TOOL_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agent_type: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.agent_type,
+                },
+                prompt: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.prompt,
+                },
+                git_root: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.git_root,
+                },
+                branch: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.branch,
+                },
+                subdirectory: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.subdirectory,
+                },
+                title: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.title,
+                },
+                slug: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.slug,
+                },
+                stop_condition: {
+                    type: 'string',
+                    description: PARAM_DESCRIPTIONS.stop_condition,
+                },
+                execution_provider: {
+                    type: 'string',
+                    enum: ['local_filesystem', 'remote_sandbox'],
+                    description: PARAM_DESCRIPTIONS.execution_provider,
+                },
+                mcp_servers: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: PARAM_DESCRIPTIONS.mcp_servers,
+                },
+                config: {
+                    type: 'object',
+                    description: PARAM_DESCRIPTIONS.config,
+                },
+                custom_metadata: {
+                    type: 'object',
+                    description: PARAM_DESCRIPTIONS.custom_metadata,
+                },
+            },
+            required: [],
+        },
+        handler: async (args) => {
+            try {
+                const validatedArgs = StartSessionSchema.parse(args);
+                const client = clientFactory();
+                const session = await client.createSession(validatedArgs);
+                const lines = [
+                    `## Session Started Successfully`,
+                    '',
+                    `- **ID:** ${session.id}`,
+                    `- **Title:** ${session.title}`,
+                    `- **Status:** ${session.status}`,
+                ];
+                if (session.slug)
+                    lines.push(`- **Slug:** ${session.slug}`);
+                if (session.job_id) {
+                    lines.push(`- **Job ID:** ${session.job_id}`);
+                    lines.push('');
+                    lines.push('*The agent job has been queued and will start shortly.*');
+                }
+                else {
+                    lines.push('');
+                    lines.push('*No prompt was provided. Use action_session with "follow_up" or "restart" action to start the agent.*');
+                }
+                return {
+                    content: [{ type: 'text', text: lines.join('\n') }],
+                };
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error starting session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/shared/tools.d.ts

@@ -0,0 +1,29 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ClientFactory } from './server.js';
+/**
+ * Available tool groups for agent-orchestrator:
+ * - 'readonly': Read-only operations (search_sessions, get_session)
+ * - 'write': Write operations (start_session, action_session)
+ * - 'admin': Administrative operations (reserved for future use)
+ */
+export type ToolGroup = 'readonly' | 'write' | 'admin';
+/**
+ * Parse enabled tool groups from environment variable.
+ * @param enabledGroupsParam - Comma-separated list of groups (e.g., "readonly,write")
+ * @returns Array of enabled tool groups
+ */
+export declare function parseEnabledToolGroups(enabledGroupsParam?: string): ToolGroup[];
+/**
+ * Creates a function to register all tools with the server.
+ * This pattern uses individual tool files for better modularity and testability.
+ *
+ * Each tool is defined in its own file under the `tools/` directory and follows
+ * a factory pattern that accepts the server and clientFactory as parameters.
+ *
+ * @param clientFactory - Factory function that creates client instances
+ * @param enabledGroups - Optional array of enabled tool groups (defaults to all)
+ * @returns Function that registers all tools with a server
+ */
+export declare function createRegisterTools(clientFactory: ClientFactory, enabledGroups?: ToolGroup[]): (server: Server) => void;
+export declare function registerTools(server: Server): void;
+//# sourceMappingURL=tools.d.ts.map

package/shared/tools.js

@@ -0,0 +1,88 @@
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+// Simplified tool surface - 4 tools
+import { searchSessionsTool } from './tools/search-sessions.js';
+import { startSessionTool } from './tools/start-session.js';
+import { getSessionTool } from './tools/get-session.js';
+import { actionSessionTool } from './tools/action-session.js';
+const ALL_TOOL_GROUPS = ['readonly', 'write', 'admin'];
+/**
+ * Parse enabled tool groups from environment variable.
+ * @param enabledGroupsParam - Comma-separated list of groups (e.g., "readonly,write")
+ * @returns Array of enabled tool groups
+ */
+export function parseEnabledToolGroups(enabledGroupsParam) {
+    if (!enabledGroupsParam) {
+        return ALL_TOOL_GROUPS; // All groups enabled by default
+    }
+    const requestedGroups = enabledGroupsParam.split(',').map((g) => g.trim().toLowerCase());
+    const validGroups = requestedGroups.filter((g) => ALL_TOOL_GROUPS.includes(g));
+    if (validGroups.length === 0) {
+        console.error(`Warning: No valid tool groups found in "${enabledGroupsParam}". Valid groups: ${ALL_TOOL_GROUPS.join(', ')}`);
+        return ALL_TOOL_GROUPS;
+    }
+    return validGroups;
+}
+/**
+ * All available tools with their group assignments.
+ * Tools can belong to multiple groups.
+ *
+ * Simplified tool surface:
+ * - search_sessions: Search/list/get sessions by ID
+ * - start_session: Create a new session
+ * - get_session: Get detailed session info with optional logs/transcripts
+ * - action_session: Perform actions (follow_up, pause, restart, archive, unarchive)
+ */
+const ALL_TOOLS = [
+    // Read operations
+    { factory: searchSessionsTool, groups: ['readonly', 'write', 'admin'] },
+    { factory: getSessionTool, groups: ['readonly', 'write', 'admin'] },
+    // Write operations
+    { factory: startSessionTool, groups: ['write', 'admin'] },
+    { factory: actionSessionTool, groups: ['write', 'admin'] },
+];
+/**
+ * Creates a function to register all tools with the server.
+ * This pattern uses individual tool files for better modularity and testability.
+ *
+ * Each tool is defined in its own file under the `tools/` directory and follows
+ * a factory pattern that accepts the server and clientFactory as parameters.
+ *
+ * @param clientFactory - Factory function that creates client instances
+ * @param enabledGroups - Optional array of enabled tool groups (defaults to all)
+ * @returns Function that registers all tools with a server
+ */
+export function createRegisterTools(clientFactory, enabledGroups) {
+    const groups = enabledGroups || parseEnabledToolGroups(process.env.ENABLED_TOOLGROUPS);
+    return (server) => {
+        // Filter tools by enabled groups and create instances
+        const tools = ALL_TOOLS.filter((def) => def.groups.some((g) => groups.includes(g))).map((def) => def.factory(server, clientFactory));
+        // List available tools
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                })),
+            };
+        });
+        // Handle tool calls
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            const tool = tools.find((t) => t.name === name);
+            if (!tool) {
+                throw new Error(`Unknown tool: ${name}`);
+            }
+            return await tool.handler(args);
+        });
+    };
+}
+// Keep the original registerTools for backward compatibility
+export function registerTools(server) {
+    // This maintains compatibility but doesn't use dependency injection
+    const factory = () => {
+        throw new Error('No client factory provided - use createRegisterTools for dependency injection');
+    };
+    const register = createRegisterTools(factory);
+    register(server);
+}