@bluehive/sdk-mcp 0.1.0-alpha.2

package/src/compat.ts

@@ -0,0 +1,478 @@
+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,
+};
+
+export type ClientType = 'openai-agents' | 'claude' | 'claude-code' | 'cursor';
+
+// Client presets for compatibility
+// Note that these could change over time as models get better, so this is
+// a best effort.
+export const knownClients: Record<ClientType, ClientCapabilities> = {
+  'openai-agents': {
+    topLevelUnions: false,
+    validJson: true,
+    refs: true,
+    unions: true,
+    formats: true,
+    toolNameLength: undefined,
+  },
+  claude: {
+    topLevelUnions: true,
+    validJson: false,
+    refs: true,
+    unions: true,
+    formats: true,
+    toolNameLength: undefined,
+  },
+  'claude-code': {
+    topLevelUnions: false,
+    validJson: true,
+    refs: true,
+    unions: true,
+    formats: true,
+    toolNameLength: undefined,
+  },
+  cursor: {
+    topLevelUnions: false,
+    validJson: true,
+    refs: false,
+    unions: false,
+    formats: false,
+    toolNameLength: 50,
+  },
+};
+
+/**
+ * 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 BlueHive from '@bluehive/sdk';
+import { Endpoint, asTextContentResult, ToolCallResult } from './tools/types';
+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 BlueHive TypeScript API',
+      inputSchema: zodToInputSchema(listEndpointsSchema),
+    },
+    handler: async (client: BlueHive, args: Record<string, unknown> | undefined): Promise<ToolCallResult> => {
+      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 asTextContentResult({
+        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 BlueHive 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: BlueHive, 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 asTextContentResult(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 BlueHive 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 (client: BlueHive, args: Record<string, unknown> | undefined): Promise<ToolCallResult> => {
+      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 await endpoint.handler(client, endpointArgs);
+    },
+  };
+
+  return [getEndpointTool, listEndpointsTool, invokeEndpointTool];
+}