conductor-node-mcp 12.8.1

package/server.mjs

@@ -0,0 +1,92 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { endpoints, query } from "./tools.mjs";
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import Conductor from 'conductor-node';
+import { applyCompatibilityTransformations, defaultClientCapabilities, parseEmbeddedJSON, } from "./compat.mjs";
+import { dynamicTools } from "./dynamic-tools.mjs";
+export { endpoints } from "./tools.mjs";
+// Create server instance
+export const server = new McpServer({
+    name: 'conductor_node_api',
+    version: '12.8.1',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+/**
+ * Initializes the provided MCP Server with the given tools and handlers.
+ * If not provided, the default client, tools and handlers will be used.
+ */
+export function init(params) {
+    const server = params.server instanceof McpServer ? params.server.server : params.server;
+    const providedEndpoints = params.endpoints || endpoints;
+    const endpointMap = Object.fromEntries(providedEndpoints.map((endpoint) => [endpoint.tool.name, endpoint]));
+    const client = params.client || new Conductor({});
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: providedEndpoints.map((endpoint) => endpoint.tool),
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const endpoint = endpointMap[name];
+        if (!endpoint) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+        return executeHandler(endpoint.tool, endpoint.handler, client, args, params.capabilities);
+    });
+}
+/**
+ * Selects the tools to include in the MCP Server based on the provided options.
+ */
+export function selectTools(endpoints, options) {
+    const filteredEndpoints = query(options.filters, endpoints);
+    const includedTools = filteredEndpoints;
+    if (options.includeAllTools && includedTools.length === 0) {
+        includedTools.push(...endpoints);
+    }
+    if (options.includeDynamicTools) {
+        includedTools.push(...dynamicTools(endpoints));
+    }
+    if (includedTools.length === 0) {
+        includedTools.push(...endpoints);
+    }
+    return applyCompatibilityTransformations(includedTools, options.capabilities);
+}
+/**
+ * Runs the provided handler with the given client and arguments.
+ */
+export async function executeHandler(tool, handler, client, args, compatibilityOptions) {
+    const options = { ...defaultClientCapabilities, ...compatibilityOptions };
+    if (options.validJson && args) {
+        args = parseEmbeddedJSON(args, tool.inputSchema);
+    }
+    const result = await handler(client, args || {});
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+}
+export const readEnv = (env) => {
+    if (typeof globalThis.process !== 'undefined') {
+        return globalThis.process.env?.[env]?.trim();
+    }
+    else if (typeof globalThis.Deno !== 'undefined') {
+        return globalThis.Deno.env?.get?.(env)?.trim();
+    }
+    return;
+};
+export const readEnvOrError = (env) => {
+    let envValue = readEnv(env);
+    if (envValue === undefined) {
+        throw new Error(`Environment variable ${env} is not set`);
+    }
+    return envValue;
+};
+//# sourceMappingURL=server.mjs.map

package/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.mjs","sourceRoot":"","sources":["src/server.ts"],"names":[],"mappings":"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"}

package/src/compat.ts

@@ -0,0 +1,438 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { Endpoint } from './tools';
+
+export interface ClientCapabilities {
+  topLevelUnions: boolean;
+  validJson: boolean;
+  refs: boolean;
+  unions: boolean;
+  formats: boolean;
+  toolNameLength: number | undefined;
+}
+
+export const defaultClientCapabilities: ClientCapabilities = {
+  topLevelUnions: true,
+  validJson: true,
+  refs: true,
+  unions: true,
+  formats: true,
+  toolNameLength: undefined,
+};
+
+/**
+ * Attempts to parse strings into JSON objects
+ */
+export function parseEmbeddedJSON(args: Record<string, unknown>, schema: Record<string, unknown>) {
+  let updated = false;
+  const newArgs: Record<string, unknown> = Object.assign({}, args);
+
+  for (const [key, value] of Object.entries(newArgs)) {
+    if (typeof value === 'string') {
+      try {
+        const parsed = JSON.parse(value);
+        newArgs[key] = parsed;
+        updated = true;
+      } catch (e) {
+        // Not valid JSON, leave as is
+      }
+    }
+  }
+
+  if (updated) {
+    return newArgs;
+  }
+
+  return args;
+}
+
+export type JSONSchema = {
+  type?: string;
+  properties?: Record<string, JSONSchema>;
+  required?: string[];
+  anyOf?: JSONSchema[];
+  $ref?: string;
+  $defs?: Record<string, JSONSchema>;
+  [key: string]: any;
+};
+
+/**
+ * Truncates tool names to the specified length while ensuring uniqueness.
+ * If truncation would cause duplicate names, appends a number to make them unique.
+ */
+export function truncateToolNames(names: string[], maxLength: number): Map<string, string> {
+  if (maxLength <= 0) {
+    return new Map();
+  }
+
+  const renameMap = new Map<string, string>();
+  const usedNames = new Set<string>();
+
+  const toTruncate = names.filter((name) => name.length > maxLength);
+
+  if (toTruncate.length === 0) {
+    return renameMap;
+  }
+
+  const willCollide =
+    new Set(toTruncate.map((name) => name.slice(0, maxLength - 1))).size < toTruncate.length;
+
+  if (!willCollide) {
+    for (const name of toTruncate) {
+      const truncatedName = name.slice(0, maxLength);
+      renameMap.set(name, truncatedName);
+    }
+  } else {
+    const baseLength = maxLength - 1;
+
+    for (const name of toTruncate) {
+      const baseName = name.slice(0, baseLength);
+      let counter = 1;
+
+      while (usedNames.has(baseName + counter)) {
+        counter++;
+      }
+
+      const finalName = baseName + counter;
+      renameMap.set(name, finalName);
+      usedNames.add(finalName);
+    }
+  }
+
+  return renameMap;
+}
+
+/**
+ * Removes top-level unions from a tool by splitting it into multiple tools,
+ * one for each variant in the union.
+ */
+export function removeTopLevelUnions(tool: Tool): Tool[] {
+  const inputSchema = tool.inputSchema as JSONSchema;
+  const variants = inputSchema.anyOf;
+
+  if (!variants || !Array.isArray(variants) || variants.length === 0) {
+    return [tool];
+  }
+
+  const defs = inputSchema.$defs || {};
+
+  return variants.map((variant, index) => {
+    const variantSchema: JSONSchema = {
+      ...inputSchema,
+      ...variant,
+      type: 'object',
+      properties: {
+        ...(inputSchema.properties || {}),
+        ...(variant.properties || {}),
+      },
+    };
+
+    delete variantSchema.anyOf;
+
+    if (!variantSchema['description']) {
+      variantSchema['description'] = tool.description;
+    }
+
+    const usedDefs = findUsedDefs(variant, defs);
+    if (Object.keys(usedDefs).length > 0) {
+      variantSchema.$defs = usedDefs;
+    } else {
+      delete variantSchema.$defs;
+    }
+
+    return {
+      ...tool,
+      name: `${tool.name}_${toSnakeCase(variant['title'] || `variant${index + 1}`)}`,
+      description: variant['description'] || tool.description,
+      inputSchema: variantSchema,
+    } as Tool;
+  });
+}
+
+function findUsedDefs(
+  schema: JSONSchema,
+  defs: Record<string, JSONSchema>,
+  visited: Set<string> = new Set(),
+): Record<string, JSONSchema> {
+  const usedDefs: Record<string, JSONSchema> = {};
+
+  if (typeof schema !== 'object' || schema === null) {
+    return usedDefs;
+  }
+
+  if (schema.$ref) {
+    const refParts = schema.$ref.split('/');
+    if (refParts[0] === '#' && refParts[1] === '$defs' && refParts[2]) {
+      const defName = refParts[2];
+      const def = defs[defName];
+      if (def && !visited.has(schema.$ref)) {
+        usedDefs[defName] = def;
+        visited.add(schema.$ref);
+        Object.assign(usedDefs, findUsedDefs(def, defs, visited));
+        visited.delete(schema.$ref);
+      }
+    }
+    return usedDefs;
+  }
+
+  for (const key in schema) {
+    if (key !== '$defs' && typeof schema[key] === 'object' && schema[key] !== null) {
+      Object.assign(usedDefs, findUsedDefs(schema[key] as JSONSchema, defs, visited));
+    }
+  }
+
+  return usedDefs;
+}
+
+// Export for testing
+export { findUsedDefs };
+
+/**
+ * Inlines all $refs in a schema, eliminating $defs.
+ * If a circular reference is detected, the circular property is removed.
+ */
+export function inlineRefs(schema: JSONSchema): JSONSchema {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  const clonedSchema = { ...schema };
+  const defs: Record<string, JSONSchema> = schema.$defs || {};
+
+  delete clonedSchema.$defs;
+
+  const result = inlineRefsRecursive(clonedSchema, defs, new Set<string>());
+  // The top level can never be null
+  return result === null ? {} : result;
+}
+
+function inlineRefsRecursive(
+  schema: JSONSchema,
+  defs: Record<string, JSONSchema>,
+  refPath: Set<string>,
+): JSONSchema | null {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (Array.isArray(schema)) {
+    return schema.map((item) => {
+      const processed = inlineRefsRecursive(item, defs, refPath);
+      return processed === null ? {} : processed;
+    }) as JSONSchema;
+  }
+
+  const result = { ...schema };
+
+  if ('$ref' in result && typeof result.$ref === 'string') {
+    if (result.$ref.startsWith('#/$defs/')) {
+      const refName = result.$ref.split('/').pop() as string;
+      const def = defs[refName];
+
+      // If we've already seen this ref in our path, we have a circular reference
+      if (refPath.has(result.$ref)) {
+        // For circular references, we completely remove the property
+        // by returning null. The parent will remove it.
+        return null;
+      }
+
+      if (def) {
+        const newRefPath = new Set(refPath);
+        newRefPath.add(result.$ref);
+
+        const inlinedDef = inlineRefsRecursive({ ...def }, defs, newRefPath);
+
+        if (inlinedDef === null) {
+          return { ...result };
+        }
+
+        // Merge the inlined definition with the original schema's properties
+        // but preserve things like description, etc.
+        const { $ref, ...rest } = result;
+        return { ...inlinedDef, ...rest };
+      }
+    }
+
+    // Keep external refs as-is
+    return result;
+  }
+
+  for (const key in result) {
+    if (result[key] && typeof result[key] === 'object') {
+      const processed = inlineRefsRecursive(result[key] as JSONSchema, defs, refPath);
+      if (processed === null) {
+        // Remove properties that would cause circular references
+        delete result[key];
+      } else {
+        result[key] = processed;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Removes anyOf fields from a schema, using only the first variant.
+ */
+export function removeAnyOf(schema: JSONSchema): JSONSchema {
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (Array.isArray(schema)) {
+    return schema.map((item) => removeAnyOf(item)) as JSONSchema;
+  }
+
+  const result = { ...schema };
+
+  if ('anyOf' in result && Array.isArray(result.anyOf) && result.anyOf.length > 0) {
+    const firstVariant = result.anyOf[0];
+
+    if (firstVariant && typeof firstVariant === 'object') {
+      // Special handling for properties to ensure deep merge
+      if (firstVariant.properties && result.properties) {
+        result.properties = {
+          ...result.properties,
+          ...(firstVariant.properties as Record<string, JSONSchema>),
+        };
+      } else if (firstVariant.properties) {
+        result.properties = { ...firstVariant.properties };
+      }
+
+      for (const key in firstVariant) {
+        if (key !== 'properties') {
+          result[key] = firstVariant[key];
+        }
+      }
+    }
+
+    delete result.anyOf;
+  }
+
+  for (const key in result) {
+    if (result[key] && typeof result[key] === 'object') {
+      result[key] = removeAnyOf(result[key] as JSONSchema);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Removes format fields from a schema and appends them to the description.
+ */
+export function removeFormats(schema: JSONSchema, formatsCapability: boolean): JSONSchema {
+  if (formatsCapability) {
+    return schema;
+  }
+
+  if (!schema || typeof schema !== 'object') {
+    return schema;
+  }
+
+  if (Array.isArray(schema)) {
+    return schema.map((item) => removeFormats(item, formatsCapability)) as JSONSchema;
+  }
+
+  const result = { ...schema };
+
+  if ('format' in result && typeof result['format'] === 'string') {
+    const formatStr = `(format: "${result['format']}")`;
+
+    if ('description' in result && typeof result['description'] === 'string') {
+      result['description'] = `${result['description']} ${formatStr}`;
+    } else {
+      result['description'] = formatStr;
+    }
+
+    delete result['format'];
+  }
+
+  for (const key in result) {
+    if (result[key] && typeof result[key] === 'object') {
+      result[key] = removeFormats(result[key] as JSONSchema, formatsCapability);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Applies all compatibility transformations to the endpoints based on the provided capabilities.
+ */
+export function applyCompatibilityTransformations(
+  endpoints: Endpoint[],
+  capabilities: ClientCapabilities,
+): Endpoint[] {
+  let transformedEndpoints = [...endpoints];
+
+  // Handle top-level unions first as this changes tool names
+  if (!capabilities.topLevelUnions) {
+    const newEndpoints: Endpoint[] = [];
+
+    for (const endpoint of transformedEndpoints) {
+      const variantTools = removeTopLevelUnions(endpoint.tool);
+
+      if (variantTools.length === 1) {
+        newEndpoints.push(endpoint);
+      } else {
+        for (const variantTool of variantTools) {
+          newEndpoints.push({
+            ...endpoint,
+            tool: variantTool,
+          });
+        }
+      }
+    }
+
+    transformedEndpoints = newEndpoints;
+  }
+
+  if (capabilities.toolNameLength) {
+    const toolNames = transformedEndpoints.map((endpoint) => endpoint.tool.name);
+    const renameMap = truncateToolNames(toolNames, capabilities.toolNameLength);
+
+    transformedEndpoints = transformedEndpoints.map((endpoint) => ({
+      ...endpoint,
+      tool: {
+        ...endpoint.tool,
+        name: renameMap.get(endpoint.tool.name) ?? endpoint.tool.name,
+      },
+    }));
+  }
+
+  if (!capabilities.refs || !capabilities.unions || !capabilities.formats) {
+    transformedEndpoints = transformedEndpoints.map((endpoint) => {
+      let schema = endpoint.tool.inputSchema as JSONSchema;
+
+      if (!capabilities.refs) {
+        schema = inlineRefs(schema);
+      }
+
+      if (!capabilities.unions) {
+        schema = removeAnyOf(schema);
+      }
+
+      if (!capabilities.formats) {
+        schema = removeFormats(schema, capabilities.formats);
+      }
+
+      return {
+        ...endpoint,
+        tool: {
+          ...endpoint.tool,
+          inputSchema: schema as typeof endpoint.tool.inputSchema,
+        },
+      };
+    });
+  }
+
+  return transformedEndpoints;
+}
+
+function toSnakeCase(str: string): string {
+  return str
+    .replace(/\s+/g, '_')
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .toLowerCase();
+}

package/src/dynamic-tools.ts

@@ -0,0 +1,153 @@
+import Conductor from 'conductor-node';
+import { Endpoint } from './tools';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { z } from 'zod';
+import { Cabidela } from '@cloudflare/cabidela';
+
+function zodToInputSchema(schema: z.ZodSchema) {
+  return {
+    type: 'object' as const,
+    ...(zodToJsonSchema(schema) as any),
+  };
+}
+
+/**
+ * A list of tools that expose all the endpoints in the API dynamically.
+ *
+ * Instead of exposing every endpoint as it's own tool, which uses up too many tokens for LLMs to use at once,
+ * we expose a single tool that can be used to search for endpoints by name, resource, operation, or tag, and then
+ * a generic endpoint that can be used to invoke any endpoint with the provided arguments.
+ *
+ * @param endpoints - The endpoints to include in the list.
+ */
+export function dynamicTools(endpoints: Endpoint[]): Endpoint[] {
+  const listEndpointsSchema = z.object({
+    search_query: z
+      .string()
+      .optional()
+      .describe(
+        'An optional search query to filter the endpoints by. Provide a partial name, resource, operation, or tag to filter the endpoints returned.',
+      ),
+  });
+
+  const listEndpointsTool = {
+    metadata: {
+      resource: 'dynamic_tools',
+      operation: 'read' as const,
+      tags: [],
+    },
+    tool: {
+      name: 'list_api_endpoints',
+      description: 'List or search for all endpoints in the QuickBooks Desktop Node.js API',
+      inputSchema: zodToInputSchema(listEndpointsSchema),
+    },
+    handler: async (client: Conductor, args: Record<string, unknown> | undefined) => {
+      const query = args && listEndpointsSchema.parse(args).search_query?.trim();
+
+      const filteredEndpoints =
+        query && query.length > 0 ?
+          endpoints.filter((endpoint) => {
+            const fieldsToMatch = [
+              endpoint.tool.name,
+              endpoint.tool.description,
+              endpoint.metadata.resource,
+              endpoint.metadata.operation,
+              ...endpoint.metadata.tags,
+            ];
+            return fieldsToMatch.some((field) => field && field.toLowerCase().includes(query.toLowerCase()));
+          })
+        : endpoints;
+
+      return {
+        tools: filteredEndpoints.map(({ tool, metadata }) => ({
+          name: tool.name,
+          description: tool.description,
+          resource: metadata.resource,
+          operation: metadata.operation,
+          tags: metadata.tags,
+        })),
+      };
+    },
+  };
+
+  const getEndpointSchema = z.object({
+    endpoint: z.string().describe('The name of the endpoint to get the schema for.'),
+  });
+  const getEndpointTool = {
+    metadata: {
+      resource: 'dynamic_tools',
+      operation: 'read' as const,
+      tags: [],
+    },
+    tool: {
+      name: 'get_api_endpoint_schema',
+      description:
+        'Get the schema for an endpoint in the QuickBooks Desktop Node.js 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: Conductor, args: Record<string, unknown> | undefined) => {
+      if (!args) {
+        throw new Error('No endpoint provided');
+      }
+      const endpointName = getEndpointSchema.parse(args).endpoint;
+
+      const endpoint = endpoints.find((e) => e.tool.name === endpointName);
+      if (!endpoint) {
+        throw new Error(`Endpoint ${endpointName} not found`);
+      }
+      return endpoint.tool;
+    },
+  };
+
+  const invokeEndpointSchema = z.object({
+    endpoint_name: z.string().describe('The name of the endpoint to invoke.'),
+    args: z
+      .record(z.string(), z.any())
+      .describe(
+        'The arguments to pass to the endpoint. This must match the schema returned by the `get_api_endpoint_schema` tool.',
+      ),
+  });
+
+  const invokeEndpointTool = {
+    metadata: {
+      resource: 'dynamic_tools',
+      operation: 'write' as const,
+      tags: [],
+    },
+    tool: {
+      name: 'invoke_api_endpoint',
+      description:
+        'Invoke an endpoint in the QuickBooks Desktop Node.js 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 (client: Conductor, args: Record<string, unknown> | undefined) => {
+      if (!args) {
+        throw new Error('No endpoint provided');
+      }
+      const { success, data, error } = invokeEndpointSchema.safeParse(args);
+      if (!success) {
+        throw new Error(`Invalid arguments for endpoint. ${error?.format()}`);
+      }
+      const { endpoint_name, args: endpointArgs } = data;
+
+      const endpoint = endpoints.find((e) => e.tool.name === endpoint_name);
+      if (!endpoint) {
+        throw new Error(
+          `Endpoint ${endpoint_name} not found. Use the \`list_api_endpoints\` tool to get the list of available endpoints.`,
+        );
+      }
+
+      try {
+        // Try to validate the arguments for a better error message
+        const cabidela = new Cabidela(endpoint.tool.inputSchema, { fullErrors: true });
+        cabidela.validate(endpointArgs);
+      } catch (error) {
+        throw new Error(`Invalid arguments for endpoint ${endpoint_name}:\n${error}`);
+      }
+
+      return endpoint.handler(client, endpointArgs);
+    },
+  };
+
+  return [getEndpointTool, listEndpointsTool, invokeEndpointTool];
+}