conductor-node-mcp 12.25.0 → 12.27.0

package/src/http.ts

@@ -4,13 +4,33 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 
 import express from 'express';
-import { McpOptions } from './options';
+import { fromError } from 'zod-validation-error/v3';
+import { McpOptions, parseQueryOptions } from './options';
 import { 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 = (
+  defaultMcpOptions: 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({
@@ -71,6 +91,7 @@ const del = async (req: express.Request, res: express.Response) => {
 
 export const streamableHTTPApp = (options: McpOptions): express.Express => {
   const app = express();
+  app.set('query parser', 'extended');
   app.use(express.json());
 
   app.get('/', get);

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';
 
@@ -40,7 +40,7 @@ if (require.main === module) {
 
 function parseOptionsOrError() {
   try {
-    return parseOptions();
+    return parseCLIOptions();
   } catch (error) {
     console.error('Error parsing options:', error);
     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';
 
@@ -14,6 +16,7 @@ export type McpOptions = {
   client: ClientType | undefined;
   includeDynamicTools: boolean | undefined;
   includeAllTools: boolean | undefined;
+  includeCodeTools: boolean | undefined;
   filters: Filter[];
   capabilities?: Partial<ClientCapabilities>;
 };
@@ -47,18 +50,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'],
       description: 'Use dynamic tools or all tools',
     })
     .option('no-tools', {
       type: 'string',
       array: true,
-      choices: ['dynamic', 'all'],
+      choices: ['dynamic', 'all', 'code'],
       description: 'Do not use any dynamic or all tools',
     })
     .option('tool', {
@@ -249,11 +252,13 @@ export function parseOptions(): CLIOptions {
     }
   }
 
+  const shouldIncludeToolType = (toolType: 'dynamic' | 'all' | 'code') =>
+    explicitTools ? argv.tools?.includes(toolType) && !argv.noTools?.includes(toolType) : undefined;
+
   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 includeDynamicTools = shouldIncludeToolType('dynamic');
+  const includeAllTools = shouldIncludeToolType('all');
+  const includeCodeTools = shouldIncludeToolType('code');
 
   const transport = argv.transport as 'stdio' | 'http';
 
@@ -262,6 +267,7 @@ export function parseOptions(): CLIOptions {
     client: client && knownClients[client] ? client : undefined,
     includeDynamicTools,
     includeAllTools,
+    includeCodeTools,
     filters,
     capabilities: clientCapabilities,
     list: argv.list || false,
@@ -271,6 +277,125 @@ 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'])).describe('Use dynamic tools or all tools'),
+  no_tools: coerceArray(z.enum(['dynamic', 'all'])).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: ClientCapabilities = {
+    topLevelUnions: true,
+    validJson: true,
+    refs: true,
+    unions: true,
+    formats: true,
+    toolNameLength: undefined,
+    ...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;
+    }
+  }
+
+  return {
+    client: queryOptions.client ?? defaultOptions.client,
+    includeDynamicTools:
+      defaultOptions.includeDynamicTools ??
+      (queryOptions.tools?.includes('dynamic') && !queryOptions.no_tools?.includes('dynamic')),
+    includeAllTools:
+      defaultOptions.includeAllTools ??
+      (queryOptions.tools?.includes('all') && !queryOptions.no_tools?.includes('all')),
+    // Never include code tools on remote server.
+    includeCodeTools: undefined,
+    filters,
+    capabilities: clientCapabilities,
+  };
+}
+
 function getCapabilitiesExplanation(): string {
   return `
 Client Capabilities Explanation:

package/src/server.ts

@@ -14,6 +14,7 @@ import {
   parseEmbeddedJSON,
 } from './compat';
 import { dynamicTools } from './dynamic-tools';
+import { codeTool } from './code-tool';
 import { McpOptions } from './options';
 
 export { McpOptions } from './options';
@@ -26,7 +27,7 @@ export const newMcpServer = () =>
   new McpServer(
     {
       name: 'conductor_node_api',
-      version: '12.25.0',
+      version: '12.27.0',
     },
     { capabilities: { tools: {}, logging: {} } },
   );
@@ -100,6 +101,8 @@ export function selectTools(endpoints: Endpoint[], options: McpOptions): Endpoin
       includedTools = endpoints;
     } else if (options.includeDynamicTools) {
       includedTools = dynamicTools(endpoints);
+    } else if (options.includeCodeTools) {
+      includedTools = [codeTool()];
     } else {
       includedTools = endpoints;
     }