@metronome/mcp 0.3.0 → 2.0.0

package/src/docs-search-tool.ts

@@ -0,0 +1,48 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { Metadata, asTextContentResult } from './tools/types';
+
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+
+export const metadata: Metadata = {
+  resource: 'all',
+  operation: 'read',
+  tags: [],
+  httpMethod: 'get',
+};
+
+export const tool: Tool = {
+  name: 'search_docs',
+  description:
+    'Search for documentation for how to use the client to interact with the API.\nThe tool will return an array of Markdown-formatted documentation pages.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'The query to search for.',
+      },
+      language: {
+        type: 'string',
+        description: 'The language for the SDK to search for.',
+        enum: ['http', 'python', 'go', 'typescript', 'terraform', 'ruby', 'java', 'kotlin'],
+      },
+    },
+    required: ['query', 'language'],
+  },
+  annotations: {
+    readOnlyHint: true,
+  },
+};
+
+const docsSearchURL =
+  process.env['DOCS_SEARCH_URL'] || 'https://api.stainless.com/api/projects/metronome/docs/search';
+
+export const handler = async (_: unknown, args: Record<string, unknown> | undefined) => {
+  const body = args as any;
+  const query = new URLSearchParams(body).toString();
+  const result = await fetch(`${docsSearchURL}?${query}`);
+  return asTextContentResult(await result.json());
+};
+
+export default { metadata, tool, handler };

package/src/dynamic-tools.ts

@@ -38,7 +38,7 @@ export function dynamicTools(endpoints: Endpoint[]): Endpoint[] {
     },
     tool: {
       name: 'list_api_endpoints',
-      description: 'List or search for all endpoints in the Metronome Node API',
+      description: 'List or search for all endpoints in the Metronome TypeScript API',
       inputSchema: zodToInputSchema(listEndpointsSchema),
     },
     handler: async (
@@ -85,7 +85,7 @@ export function dynamicTools(endpoints: Endpoint[]): Endpoint[] {
     tool: {
       name: 'get_api_endpoint_schema',
       description:
-        'Get the schema for an endpoint in the Metronome Node API. You can use the schema returned by this tool to invoke an endpoint with the `invoke_api_endpoint` tool.',
+        'Get the schema for an endpoint in the Metronome TypeScript API. You can use the schema returned by this tool to invoke an endpoint with the `invoke_api_endpoint` tool.',
       inputSchema: zodToInputSchema(getEndpointSchema),
     },
     handler: async (client: Metronome, args: Record<string, unknown> | undefined) => {
@@ -120,7 +120,7 @@ export function dynamicTools(endpoints: Endpoint[]): Endpoint[] {
     tool: {
       name: 'invoke_api_endpoint',
       description:
-        'Invoke an endpoint in the Metronome Node API. Note: use the `list_api_endpoints` tool to get the list of endpoints and `get_api_endpoint_schema` tool to get the schema for an endpoint.',
+        'Invoke an endpoint in the Metronome TypeScript API. Note: use the `list_api_endpoints` tool to get the list of endpoints and `get_api_endpoint_schema` tool to get the schema for an endpoint.',
       inputSchema: zodToInputSchema(invokeEndpointSchema),
     },
     handler: async (

package/src/headers.ts

@@ -1,8 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { type ClientOptions } from '@metronome/sdk/index';
-
 import { IncomingMessage } from 'node:http';
+import { ClientOptions } from '@metronome/sdk';
 
 export const parseAuthHeaders = (req: IncomingMessage): Partial<ClientOptions> => {
   if (req.headers.authorization) {
@@ -17,7 +16,7 @@ export const parseAuthHeaders = (req: IncomingMessage): Partial<ClientOptions> =
   }
 
   const bearerToken =
-    req.headers['x-metronome-bearer-token'] instanceof Array ?
+    Array.isArray(req.headers['x-metronome-bearer-token']) ?
       req.headers['x-metronome-bearer-token'][0]
     : req.headers['x-metronome-bearer-token'];
   return { bearerToken };

package/src/http.ts

@@ -4,22 +4,45 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 
 import express from 'express';
-import { McpOptions } from './options';
-import { initMcpServer, newMcpServer } from './server';
+import { fromError } from 'zod-validation-error/v3';
+import { McpOptions, parseQueryOptions } from './options';
+import { ClientOptions, initMcpServer, newMcpServer } from './server';
 import { parseAuthHeaders } from './headers';
-import { Endpoint } from './tools';
 
-const newServer = (mcpOptions: McpOptions, req: express.Request, res: express.Response): McpServer | null => {
+const newServer = ({
+  clientOptions,
+  mcpOptions: defaultMcpOptions,
+  req,
+  res,
+}: {
+  clientOptions: ClientOptions;
+  mcpOptions: McpOptions;
+  req: express.Request;
+  res: express.Response;
+}): McpServer | null => {
   const server = newMcpServer();
+
+  let mcpOptions: McpOptions;
+  try {
+    mcpOptions = parseQueryOptions(defaultMcpOptions, req.query);
+  } catch (error) {
+    res.status(400).json({
+      jsonrpc: '2.0',
+      error: {
+        code: -32000,
+        message: `Invalid request: ${fromError(error)}`,
+      },
+    });
+    return null;
+  }
+
   try {
     const authOptions = parseAuthHeaders(req);
     initMcpServer({
       server: server,
       clientOptions: {
+        ...clientOptions,
         ...authOptions,
-        defaultHeaders: {
-          'X-Stainless-MCP': 'true',
-        },
       },
       mcpOptions,
     });
@@ -37,17 +60,19 @@ const newServer = (mcpOptions: McpOptions, req: express.Request, res: express.Re
   return server;
 };
 
-const post = (defaultOptions: McpOptions) => async (req: express.Request, res: express.Response) => {
-  const server = newServer(defaultOptions, req, res);
-  // If we return null, we already set the authorization error.
-  if (server === null) return;
-  const transport = new StreamableHTTPServerTransport({
-    // Stateless server
-    sessionIdGenerator: undefined,
-  });
-  await server.connect(transport);
-  await transport.handleRequest(req, res, req.body);
-};
+const post =
+  (options: { clientOptions: ClientOptions; mcpOptions: McpOptions }) =>
+  async (req: express.Request, res: express.Response) => {
+    const server = newServer({ ...options, req, res });
+    // If we return null, we already set the authorization error.
+    if (server === null) return;
+    const transport = new StreamableHTTPServerTransport({
+      // Stateless server
+      sessionIdGenerator: undefined,
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  };
 
 const get = async (req: express.Request, res: express.Response) => {
   res.status(405).json({
@@ -69,23 +94,26 @@ const del = async (req: express.Request, res: express.Response) => {
   });
 };
 
-export const streamableHTTPApp = (options: McpOptions): express.Express => {
+export const streamableHTTPApp = ({
+  clientOptions = {},
+  mcpOptions = {},
+}: {
+  clientOptions?: ClientOptions;
+  mcpOptions?: McpOptions;
+}): express.Express => {
   const app = express();
+  app.set('query parser', 'extended');
   app.use(express.json());
 
   app.get('/', get);
-  app.post('/', post(options));
+  app.post('/', post({ clientOptions, mcpOptions }));
   app.delete('/', del);
 
   return app;
 };
 
-export const launchStreamableHTTPServer = async (
-  options: McpOptions,
-  endpoints: Endpoint[],
-  port: number | string | undefined,
-) => {
-  const app = streamableHTTPApp(options);
+export const launchStreamableHTTPServer = async (options: McpOptions, port: number | string | undefined) => {
+  const app = streamableHTTPApp({ mcpOptions: options });
   const server = app.listen(port);
   const address = server.address();
 

package/src/index.ts

@@ -2,7 +2,7 @@
 
 import { selectTools } from './server';
 import { Endpoint, endpoints } from './tools';
-import { McpOptions, parseOptions } from './options';
+import { McpOptions, parseCLIOptions } from './options';
 import { launchStdioServer } from './stdio';
 import { launchStreamableHTTPServer } from './http';
 
@@ -14,7 +14,7 @@ async function main() {
     return;
   }
 
-  const selectedTools = selectToolsOrError(endpoints, options);
+  const selectedTools = await selectToolsOrError(endpoints, options);
 
   console.error(
     `MCP Server starting with ${selectedTools.length} tools:`,
@@ -23,10 +23,10 @@ async function main() {
 
   switch (options.transport) {
     case 'stdio':
-      await launchStdioServer(options, selectedTools);
+      await launchStdioServer(options);
       break;
     case 'http':
-      await launchStreamableHTTPServer(options, selectedTools, options.port ?? options.socket);
+      await launchStreamableHTTPServer(options, options.port ?? options.socket);
       break;
   }
 }
@@ -40,16 +40,16 @@ if (require.main === module) {
 
 function parseOptionsOrError() {
   try {
-    return parseOptions();
+    return parseCLIOptions();
   } catch (error) {
     console.error('Error parsing options:', error);
     process.exit(1);
   }
 }
 
-function selectToolsOrError(endpoints: Endpoint[], options: McpOptions): Endpoint[] {
+async function selectToolsOrError(endpoints: Endpoint[], options: McpOptions): Promise<Endpoint[]> {
   try {
-    const includedTools = selectTools(endpoints, options);
+    const includedTools = await selectTools(endpoints, options);
     if (includedTools.length === 0) {
       console.error('No tools match the provided filters.');
       process.exit(1);

package/src/options.ts

@@ -1,5 +1,7 @@
+import qs from 'qs';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import z from 'zod';
 import { endpoints, Filter } from './tools';
 import { ClientCapabilities, knownClients, ClientType } from './compat';
 
@@ -11,11 +13,13 @@ export type CLIOptions = McpOptions & {
 };
 
 export type McpOptions = {
-  client: ClientType | undefined;
-  includeDynamicTools: boolean | undefined;
-  includeAllTools: boolean | undefined;
-  filters: Filter[];
-  capabilities?: Partial<ClientCapabilities>;
+  client?: ClientType | undefined;
+  includeDynamicTools?: boolean | undefined;
+  includeAllTools?: boolean | undefined;
+  includeCodeTools?: boolean | undefined;
+  includeDocsTools?: boolean | undefined;
+  filters?: Filter[] | undefined;
+  capabilities?: Partial<ClientCapabilities> | undefined;
 };
 
 const CAPABILITY_CHOICES = [
@@ -47,18 +51,18 @@ function parseCapabilityValue(cap: string): { name: Capability; value?: number }
   return { name: cap as Capability };
 }
 
-export function parseOptions(): CLIOptions {
+export function parseCLIOptions(): CLIOptions {
   const opts = yargs(hideBin(process.argv))
     .option('tools', {
       type: 'string',
       array: true,
-      choices: ['dynamic', 'all'],
+      choices: ['dynamic', 'all', 'code', 'docs'],
       description: 'Use dynamic tools or all tools',
     })
     .option('no-tools', {
       type: 'string',
       array: true,
-      choices: ['dynamic', 'all'],
+      choices: ['dynamic', 'all', 'code', 'docs'],
       description: 'Do not use any dynamic or all tools',
     })
     .option('tool', {
@@ -201,14 +205,7 @@ export function parseOptions(): CLIOptions {
   }
 
   // Parse client capabilities
-  const clientCapabilities: ClientCapabilities = {
-    topLevelUnions: true,
-    validJson: true,
-    refs: true,
-    unions: true,
-    formats: true,
-    toolNameLength: undefined,
-  };
+  const clientCapabilities: Partial<ClientCapabilities> = {};
 
   // Apply individual capability overrides
   if (Array.isArray(argv.capability)) {
@@ -249,19 +246,25 @@ export function parseOptions(): CLIOptions {
     }
   }
 
-  const explicitTools = Boolean(argv.tools || argv.noTools);
-  const includeDynamicTools =
-    explicitTools ? argv.tools?.includes('dynamic') && !argv.noTools?.includes('dynamic') : undefined;
-  const includeAllTools =
-    explicitTools ? argv.tools?.includes('all') && !argv.noTools?.includes('all') : undefined;
+  const shouldIncludeToolType = (toolType: 'dynamic' | 'all' | 'code' | 'docs') =>
+    argv.noTools?.includes(toolType) ? false
+    : argv.tools?.includes(toolType) ? true
+    : undefined;
+
+  const includeDynamicTools = shouldIncludeToolType('dynamic');
+  const includeAllTools = shouldIncludeToolType('all');
+  const includeCodeTools = shouldIncludeToolType('code');
+  const includeDocsTools = shouldIncludeToolType('docs');
 
   const transport = argv.transport as 'stdio' | 'http';
 
   const client = argv.client as ClientType;
   return {
-    client: client && knownClients[client] ? client : undefined,
+    client: client && client !== 'infer' && knownClients[client] ? client : undefined,
     includeDynamicTools,
     includeAllTools,
+    includeCodeTools,
+    includeDocsTools,
     filters,
     capabilities: clientCapabilities,
     list: argv.list || false,
@@ -271,6 +274,128 @@ export function parseOptions(): CLIOptions {
   };
 }
 
+const coerceArray = <T extends z.ZodTypeAny>(zodType: T) =>
+  z.preprocess(
+    (val) =>
+      Array.isArray(val) ? val
+      : val ? [val]
+      : val,
+    z.array(zodType).optional(),
+  );
+
+const QueryOptions = z.object({
+  tools: coerceArray(z.enum(['dynamic', 'all', 'docs'])).describe('Use dynamic tools or all tools'),
+  no_tools: coerceArray(z.enum(['dynamic', 'all', 'docs'])).describe('Do not use dynamic tools or all tools'),
+  tool: coerceArray(z.string()).describe('Include tools matching the specified names'),
+  resource: coerceArray(z.string()).describe('Include tools matching the specified resources'),
+  operation: coerceArray(z.enum(['read', 'write'])).describe(
+    'Include tools matching the specified operations',
+  ),
+  tag: coerceArray(z.string()).describe('Include tools with the specified tags'),
+  no_tool: coerceArray(z.string()).describe('Exclude tools matching the specified names'),
+  no_resource: coerceArray(z.string()).describe('Exclude tools matching the specified resources'),
+  no_operation: coerceArray(z.enum(['read', 'write'])).describe(
+    'Exclude tools matching the specified operations',
+  ),
+  no_tag: coerceArray(z.string()).describe('Exclude tools with the specified tags'),
+  client: ClientType.optional().describe('Specify the MCP client being used'),
+  capability: coerceArray(z.string()).describe('Specify client capabilities'),
+  no_capability: coerceArray(z.enum(CAPABILITY_CHOICES)).describe('Unset client capabilities'),
+});
+
+export function parseQueryOptions(defaultOptions: McpOptions, query: unknown): McpOptions {
+  const queryObject = typeof query === 'string' ? qs.parse(query) : query;
+  const queryOptions = QueryOptions.parse(queryObject);
+
+  const filters: Filter[] = [...(defaultOptions.filters ?? [])];
+
+  for (const resource of queryOptions.resource || []) {
+    filters.push({ type: 'resource', op: 'include', value: resource });
+  }
+  for (const operation of queryOptions.operation || []) {
+    filters.push({ type: 'operation', op: 'include', value: operation });
+  }
+  for (const tag of queryOptions.tag || []) {
+    filters.push({ type: 'tag', op: 'include', value: tag });
+  }
+  for (const tool of queryOptions.tool || []) {
+    filters.push({ type: 'tool', op: 'include', value: tool });
+  }
+  for (const resource of queryOptions.no_resource || []) {
+    filters.push({ type: 'resource', op: 'exclude', value: resource });
+  }
+  for (const operation of queryOptions.no_operation || []) {
+    filters.push({ type: 'operation', op: 'exclude', value: operation });
+  }
+  for (const tag of queryOptions.no_tag || []) {
+    filters.push({ type: 'tag', op: 'exclude', value: tag });
+  }
+  for (const tool of queryOptions.no_tool || []) {
+    filters.push({ type: 'tool', op: 'exclude', value: tool });
+  }
+
+  // Parse client capabilities
+  const clientCapabilities: Partial<ClientCapabilities> = { ...defaultOptions.capabilities };
+
+  for (const cap of queryOptions.capability || []) {
+    const parsed = parseCapabilityValue(cap);
+    if (parsed.name === 'top-level-unions') {
+      clientCapabilities.topLevelUnions = true;
+    } else if (parsed.name === 'valid-json') {
+      clientCapabilities.validJson = true;
+    } else if (parsed.name === 'refs') {
+      clientCapabilities.refs = true;
+    } else if (parsed.name === 'unions') {
+      clientCapabilities.unions = true;
+    } else if (parsed.name === 'formats') {
+      clientCapabilities.formats = true;
+    } else if (parsed.name === 'tool-name-length') {
+      clientCapabilities.toolNameLength = parsed.value;
+    }
+  }
+
+  for (const cap of queryOptions.no_capability || []) {
+    if (cap === 'top-level-unions') {
+      clientCapabilities.topLevelUnions = false;
+    } else if (cap === 'valid-json') {
+      clientCapabilities.validJson = false;
+    } else if (cap === 'refs') {
+      clientCapabilities.refs = false;
+    } else if (cap === 'unions') {
+      clientCapabilities.unions = false;
+    } else if (cap === 'formats') {
+      clientCapabilities.formats = false;
+    } else if (cap === 'tool-name-length') {
+      clientCapabilities.toolNameLength = undefined;
+    }
+  }
+
+  let dynamicTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('dynamic') ? false
+    : queryOptions.tools?.includes('dynamic') ? true
+    : defaultOptions.includeDynamicTools;
+
+  let allTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('all') ? false
+    : queryOptions.tools?.includes('all') ? true
+    : defaultOptions.includeAllTools;
+
+  let docsTools: boolean | undefined =
+    queryOptions.no_tools && queryOptions.no_tools?.includes('docs') ? false
+    : queryOptions.tools?.includes('docs') ? true
+    : defaultOptions.includeDocsTools;
+
+  return {
+    client: queryOptions.client ?? defaultOptions.client,
+    includeDynamicTools: dynamicTools,
+    includeAllTools: allTools,
+    includeCodeTools: undefined,
+    includeDocsTools: docsTools,
+    filters,
+    capabilities: clientCapabilities,
+  };
+}
+
 function getCapabilitiesExplanation(): string {
   return `
 Client Capabilities Explanation:

package/src/server.ts

@@ -3,7 +3,13 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Endpoint, endpoints, HandlerFunction, query } from './tools';
-import { CallToolRequestSchema, ListToolsRequestSchema, Tool } from '@modelcontextprotocol/sdk/types.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  SetLevelRequestSchema,
+  Implementation,
+  Tool,
+} from '@modelcontextprotocol/sdk/types.js';
 import { ClientOptions } from '@metronome/sdk';
 import Metronome from '@metronome/sdk';
 import {
@@ -14,6 +20,8 @@ import {
   parseEmbeddedJSON,
 } from './compat';
 import { dynamicTools } from './dynamic-tools';
+import { codeTool } from './code-tool';
+import docsSearchTool from './docs-search-tool';
 import { McpOptions } from './options';
 
 export { McpOptions } from './options';
@@ -26,7 +34,7 @@ export const newMcpServer = () =>
   new McpServer(
     {
       name: 'metronome_sdk_api',
-      version: '0.3.0',
+      version: '2.0.0',
     },
     { capabilities: { tools: {}, logging: {} } },
   );
@@ -40,72 +48,127 @@ export const server = newMcpServer();
  */
 export function initMcpServer(params: {
   server: Server | McpServer;
-  clientOptions: ClientOptions;
-  mcpOptions: McpOptions;
-  endpoints?: { tool: Tool; handler: HandlerFunction }[];
-}) {
-  const transformedEndpoints = selectTools(endpoints, params.mcpOptions);
-  const client = new Metronome(params.clientOptions);
-  const capabilities = {
-    ...defaultClientCapabilities,
-    ...(params.mcpOptions.client ? knownClients[params.mcpOptions.client] : params.mcpOptions.capabilities),
-  };
-  init({ server: params.server, client, endpoints: transformedEndpoints, capabilities });
-}
-
-export function init(params: {
-  server: Server | McpServer;
-  client?: Metronome;
-  endpoints?: { tool: Tool; handler: HandlerFunction }[];
-  capabilities?: Partial<ClientCapabilities>;
+  clientOptions?: ClientOptions;
+  mcpOptions?: McpOptions;
 }) {
   const server = params.server instanceof McpServer ? params.server.server : params.server;
-  const providedEndpoints = params.endpoints || endpoints;
+  const mcpOptions = params.mcpOptions ?? {};
+
+  let providedEndpoints: Endpoint[] | null = null;
+  let endpointMap: Record<string, Endpoint> | null = null;
+
+  const initTools = async (implementation?: Implementation) => {
+    if (implementation && (!mcpOptions.client || mcpOptions.client === 'infer')) {
+      mcpOptions.client =
+        implementation.name.toLowerCase().includes('claude') ? 'claude'
+        : implementation.name.toLowerCase().includes('cursor') ? 'cursor'
+        : undefined;
+      mcpOptions.capabilities = {
+        ...(mcpOptions.client && knownClients[mcpOptions.client]),
+        ...mcpOptions.capabilities,
+      };
+    }
+    providedEndpoints ??= await selectTools(endpoints, mcpOptions);
+    endpointMap ??= Object.fromEntries(providedEndpoints.map((endpoint) => [endpoint.tool.name, endpoint]));
+  };
 
-  const endpointMap = Object.fromEntries(providedEndpoints.map((endpoint) => [endpoint.tool.name, endpoint]));
+  const logAtLevel =
+    (level: 'debug' | 'info' | 'warning' | 'error') =>
+    (message: string, ...rest: unknown[]) => {
+      void server.sendLoggingMessage({
+        level,
+        data: { message, rest },
+      });
+    };
+  const logger = {
+    debug: logAtLevel('debug'),
+    info: logAtLevel('info'),
+    warn: logAtLevel('warning'),
+    error: logAtLevel('error'),
+  };
 
-  const client = params.client || new Metronome({ defaultHeaders: { 'X-Stainless-MCP': 'true' } });
+  let client = new Metronome({
+    logger,
+    ...params.clientOptions,
+    defaultHeaders: {
+      ...params.clientOptions?.defaultHeaders,
+      'X-Stainless-MCP': 'true',
+    },
+  });
 
   server.setRequestHandler(ListToolsRequestSchema, async () => {
+    if (providedEndpoints === null) {
+      await initTools(server.getClientVersion());
+    }
     return {
-      tools: providedEndpoints.map((endpoint) => endpoint.tool),
+      tools: providedEndpoints!.map((endpoint) => endpoint.tool),
     };
   });
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (endpointMap === null) {
+      await initTools(server.getClientVersion());
+    }
     const { name, arguments: args } = request.params;
-    const endpoint = endpointMap[name];
+    const endpoint = endpointMap![name];
     if (!endpoint) {
       throw new Error(`Unknown tool: ${name}`);
     }
 
-    return executeHandler(endpoint.tool, endpoint.handler, client, args, params.capabilities);
+    return executeHandler(endpoint.tool, endpoint.handler, client, args, mcpOptions.capabilities);
+  });
+
+  server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    const { level } = request.params;
+    switch (level) {
+      case 'debug':
+        client = client.withOptions({ logLevel: 'debug' });
+        break;
+      case 'info':
+        client = client.withOptions({ logLevel: 'info' });
+        break;
+      case 'notice':
+      case 'warning':
+        client = client.withOptions({ logLevel: 'warn' });
+        break;
+      case 'error':
+        client = client.withOptions({ logLevel: 'error' });
+        break;
+      default:
+        client = client.withOptions({ logLevel: 'off' });
+        break;
+    }
+    return {};
   });
 }
 
 /**
  * Selects the tools to include in the MCP Server based on the provided options.
  */
-export function selectTools(endpoints: Endpoint[], options: McpOptions): Endpoint[] {
-  const filteredEndpoints = query(options.filters, endpoints);
+export async function selectTools(endpoints: Endpoint[], options?: McpOptions): Promise<Endpoint[]> {
+  const filteredEndpoints = query(options?.filters ?? [], endpoints);
 
-  let includedTools = filteredEndpoints;
+  let includedTools = filteredEndpoints.slice();
 
   if (includedTools.length > 0) {
-    if (options.includeDynamicTools) {
+    if (options?.includeDynamicTools) {
       includedTools = dynamicTools(includedTools);
     }
   } else {
-    if (options.includeAllTools) {
-      includedTools = endpoints;
-    } else if (options.includeDynamicTools) {
+    if (options?.includeAllTools) {
+      includedTools = endpoints.slice();
+    } else if (options?.includeDynamicTools) {
       includedTools = dynamicTools(endpoints);
+    } else if (options?.includeCodeTools) {
+      includedTools = [await codeTool()];
     } else {
-      includedTools = endpoints;
+      includedTools = endpoints.slice();
     }
   }
-
-  const capabilities = { ...defaultClientCapabilities, ...options.capabilities };
+  if (options?.includeDocsTools ?? true) {
+    includedTools.push(docsSearchTool);
+  }
+  const capabilities = { ...defaultClientCapabilities, ...options?.capabilities };
   return applyCompatibilityTransformations(includedTools, capabilities);
 }