loopback4-mcp 0.0.1

package/src/types.ts

@@ -0,0 +1,59 @@
+import {BindingKey, Context} from '@loopback/core';
+import {RequestHandlerExtra} from '@modelcontextprotocol/sdk/shared/protocol';
+import {
+  CallToolResult,
+  ServerNotification,
+  ServerRequest,
+} from '@modelcontextprotocol/sdk/types';
+import * as z from 'zod';
+import {McpHookFunction} from './interfaces';
+const objectSchema = z.object({
+  content: z.array(
+    z.object({
+      type: z.literal('text'),
+      text: z.string(),
+    }),
+  ),
+  isError: z.boolean().optional(),
+});
+export type McpToolHandler = (
+  ctx: Context,
+  args: {[key: string]: unknown},
+  extras: RequestHandlerExtra<ServerRequest, ServerNotification>,
+) => CallToolResult | Promise<CallToolResult>;
+
+export interface McpTool {
+  name: string;
+  description: string;
+  schema: z.ZodRawShape;
+  handler: McpToolHandler;
+}
+
+export interface McpHookConfig {
+  binding: BindingKey<McpHookFunction> | string;
+  config?: {[key: string]: unknown};
+}
+
+export interface McpToolMetadata {
+  name: string;
+  description: string;
+  schema: z.ZodRawShape;
+  controllerFunction: Function;
+  preHook?: McpHookConfig;
+  postHook?: McpHookConfig;
+  parameterNames?: string[]; // Populated from LoopBack metadata
+  controllerBinding?: BindingKey<object>;
+}
+
+export interface McpToolDecoratorOptions {
+  name: string;
+  description: string;
+  schema?: z.ZodRawShape;
+  preHook?: McpHookConfig;
+  postHook?: McpHookConfig;
+}
+export function isTextMessage(
+  message: unknown,
+): message is z.infer<typeof objectSchema> {
+  return objectSchema.safeParse(message).success;
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './mcp-parameter-extractor';

package/src/utils/mcp-parameter-extractor.ts

@@ -0,0 +1,67 @@
+import {MetadataInspector} from '@loopback/core';
+import {SchemaObject} from '@loopback/openapi-v3';
+import {OAI3Keys} from '@loopback/openapi-v3/dist/keys';
+import {ParameterObject} from '@loopback/rest';
+
+/**
+ * Extract parameter information using LoopBack's parameter metadata system
+ * Developers creating MCP tools must use @param decorators
+ */
+export function extractParameterInfo(target: Object, propertyKey: string) {
+  const paramMetadata = MetadataInspector.getMethodMetadata(
+    OAI3Keys.PARAMETERS_KEY, // LoopBack parameter metadata key
+    target,
+    propertyKey,
+  );
+
+  if (
+    !paramMetadata ||
+    !Array.isArray(paramMetadata) ||
+    paramMetadata.length === 0
+  ) {
+    throw new Error(
+      `No LoopBack parameter metadata found for ${propertyKey}. ` +
+        `MCP tools must use @param decorators (e.g., @param.query.string('paramName'))`,
+    );
+  }
+
+  const parameterNames = paramMetadata.map(
+    (param: ParameterObject, index: number) => {
+      if (!param.name) {
+        throw new Error(
+          `Parameter ${index} in ${propertyKey} is missing name. Use @param.query.string('name')`,
+        );
+      }
+      return param.name;
+    },
+  );
+
+  const parameterOptional = paramMetadata.map(
+    (param: ParameterObject) => param.required === false,
+  );
+
+  const parameterTypes = paramMetadata.map((param: ParameterObject) => {
+    // Extract type information from LoopBack parameter schema
+    const schema = param.schema as SchemaObject;
+    if (schema?.type) {
+      switch (schema.type) {
+        case 'string':
+          return 'string';
+        case 'number':
+        case 'integer':
+          return 'number';
+        case 'boolean':
+          return 'boolean';
+        case 'object':
+          return 'object';
+        case 'array':
+          return 'array';
+        default:
+          return 'any';
+      }
+    }
+    return 'any';
+  });
+
+  return {parameterNames, parameterOptional, parameterTypes};
+}