@tsed/cli-mcp 7.0.0-rc.1 → 7.0.0-rc.3

package/lib/esm/constants/constants.js

@@ -0,0 +1,5 @@
+export const MCP_PROVIDER_TYPES = {
+    TOOL: "mcp:tool",
+    RESOURCE: "mcp:resource",
+    PROMPT: "mcp:prompt"
+};

package/lib/esm/decorators/prompt.js

@@ -0,0 +1,12 @@
+import { classOf } from "@tsed/core";
+import { definePrompt } from "../fn/definePrompt.js";
+export function Prompt(options) {
+    return (target, propertyKey, _) => {
+        definePrompt({
+            ...options,
+            name: options?.name || String(propertyKey),
+            token: classOf(target),
+            propertyKey: propertyKey
+        });
+    };
+}

package/lib/esm/decorators/resource.js

@@ -0,0 +1,15 @@
+import { classOf } from "@tsed/core";
+import { isString } from "@tsed/core/utils/isString.js";
+import { defineResource } from "../fn/defineResource.js";
+export function Resource(uriOrTemplate, options) {
+    return (target, propertyKey, _) => {
+        defineResource({
+            ...options,
+            name: options?.name || String(propertyKey),
+            token: classOf(target),
+            propertyKey,
+            uri: isString(uriOrTemplate) ? uriOrTemplate : undefined,
+            template: !isString(uriOrTemplate) ? uriOrTemplate : undefined
+        });
+    };
+}

package/lib/esm/decorators/tool.js

@@ -0,0 +1,12 @@
+import { classOf } from "@tsed/core";
+import { defineTool } from "../fn/defineTool.js";
+export function Tool(name, options = {}) {
+    return (target, propertyKey, _) => {
+        defineTool({
+            ...options,
+            name: name || String(propertyKey),
+            token: classOf(target),
+            propertyKey
+        });
+    };
+}

package/lib/esm/fn/definePrompt.js

@@ -1,52 +1,34 @@
-import { injectable } from "@tsed/cli-core";
-import { DIContext, injector, logger, runInContext } from "@tsed/di";
-import { v4 } from "uuid";
-/**
- * Prompts are reusable templates that help humans prompt models to interact with your server.
- * They're designed to be user-driven, and might appear as slash commands in a chat interface.
- *
- * ```ts
- * import {definePrompt} from "@tsed/cli-mcp";
- *
- * export default definePrompt({
- *   name: "review-code",
- *   title: 'Code review',
- *   description: 'Review code for best practices and potential issues',
- *   argsSchema: { code: z.string() }
- *   handler: ({ code }) => ({
- *     messages: [
- *       {
- *         role: 'user',
- *         content: {
- *           type: 'text',
- *           text: `Please review this code:\n\n${code}`
- *         }
- *       }
- *     ]
- *   })
- * });
- * ```
- *
- * @param options {PromptProps}
- */
-export function definePrompt(options) {
-    const provider = injectable(options.token || Symbol.for(`MCP:RESOURCE:${options.name}`))
-        .type("CLI_MCP_RESOURCES")
-        .factory(() => ({
+import { isArrowFn } from "@tsed/core";
+import { inject, injectable } from "@tsed/di";
+import { JsonEntityStore, JsonSchema } from "@tsed/schema";
+import { MCP_PROVIDER_TYPES } from "../constants/constants.js";
+import { toZod } from "../utils/toZod.js";
+function mapOptions(options) {
+    let handler = undefined;
+    if ("handler" in options) {
+        handler = options.handler;
+    }
+    if ("propertyKey" in options && options.propertyKey) {
+        const { token, propertyKey } = options;
+        handler = ((...args) => {
+            const instance = inject(options.token);
+            return instance[propertyKey](...args);
+        });
+        const methodStore = JsonEntityStore.fromMethod(token, propertyKey);
+        options.description = options.description || methodStore.operation.get("description");
+        options.title = options.title || methodStore.schema.get("title");
+    }
+    return {
         ...options,
-        async handler(...args) {
-            const $ctx = new DIContext({
-                id: v4(),
-                injector: injector(),
-                logger: logger(),
-                level: logger().level,
-                maxStackSize: 0,
-                platform: "MCP"
-            });
-            return runInContext($ctx, () => {
-                return options.handler(...args);
-            });
-        }
-    }));
+        argsSchema: toZod(isArrowFn(options.argsSchema) ? options.argsSchema() : options.argsSchema),
+        handler: handler
+    };
+}
+export function definePrompt(options) {
+    const provider = injectable(Symbol.for(`MCP:PROMPT:${options.name}`))
+        .type(MCP_PROVIDER_TYPES.PROMPT)
+        .factory(() => {
+        return mapOptions(options);
+    });
     return provider.token();
 }

package/lib/esm/fn/defineResource.js

@@ -1,34 +1,31 @@
-import { injectable } from "@tsed/cli-core";
-import { DIContext, injector, logger, runInContext } from "@tsed/di";
-import { v4 } from "uuid";
-export function defineResource(options) {
-    const provider = injectable(options.token || Symbol.for(`MCP:RESOURCE:${options.name}`))
-        .type("CLI_MCP_RESOURCES")
-        .factory(() => ({
+import { inject, injectable } from "@tsed/di";
+import { JsonEntityStore } from "@tsed/schema";
+import { MCP_PROVIDER_TYPES } from "../constants/constants.js";
+function mapOptions(options) {
+    let handler;
+    if ("propertyKey" in options && options.propertyKey) {
+        const { token, propertyKey } = options;
+        handler = (...args) => {
+            const instance = inject(options.token);
+            return instance[propertyKey](...args);
+        };
+        const methodStore = JsonEntityStore.fromMethod(token, propertyKey);
+        options.description = options.description || methodStore.operation.get("description");
+        options.title = options.title || methodStore.schema.get("title");
+    }
+    else {
+        handler = options.handler;
+    }
+    return {
         ...options,
-        async handler(...args) {
-            const $ctx = new DIContext({
-                id: v4(),
-                injector: injector(),
-                logger: logger(),
-                level: logger().level,
-                maxStackSize: 0,
-                platform: "MCP"
-            });
-            try {
-                return await runInContext($ctx, () => {
-                    return options.handler(...args);
-                });
-            }
-            finally {
-                try {
-                    await $ctx.destroy();
-                }
-                catch {
-                    // ignore
-                }
-            }
-        }
-    }));
+        handler
+    };
+}
+export function defineResource(options) {
+    const provider = injectable(Symbol.for(`MCP:RESOURCE:${options.name}`))
+        .type(MCP_PROVIDER_TYPES.RESOURCE)
+        .factory(() => {
+        return mapOptions(options);
+    });
     return provider.token();
 }

package/lib/esm/fn/defineTool.js

@@ -1,85 +1,67 @@
-import { injectable } from "@tsed/cli-core";
 import { isArrowFn } from "@tsed/core";
-import { DIContext, injector, logger, runInContext } from "@tsed/di";
-import { JsonSchema } from "@tsed/schema";
-import { v4 } from "uuid";
+import { inject, injectable, logger } from "@tsed/di";
+import { JsonEntityStore, JsonMethodStore, JsonSchema } from "@tsed/schema";
+import { MCP_PROVIDER_TYPES } from "../constants/constants.js";
 import { toZod } from "../utils/toZod.js";
-/**
- * Tools let LLMs take actions through your server. Tools can perform computation, fetch data and have side effects.
- * Tools should be designed to be model-controlled - i.e. AI models will decide which tools to call, and the arguments.
- *
- * ```typescript
- * import {defineTool} from "@tsed/cli-mcp";
- * import {s} from "@tsed/schema";
- *
- * export default defineTool({
- *  name: "my-tool",
- *  title: "My Tool",
- *  description: "My tool description",
- *  inputSchema: s.object({
- *    param1: s.string().required() // also support Zod
- *  }),
- *  outputSchema: s.object({
- *     result: s.string().required() // also support Zod
- *  }),
- *  handler(args) {
- *    return {
- *      content: [],
- *      structuredContent: {
- *        result: "Hello World!"
- *      }
- *    }
- * });
- * ```
- *
- * @param options
- */
-export function defineTool(options) {
-    const provider = injectable(options.token || Symbol.for(`MCP:TOOL:${options.name}`))
-        .type("CLI_MCP_TOOLS")
-        .factory(() => ({
+function getOutputSchema(methodStore) {
+    const schema = methodStore.operation.getResponseOf(200)?.getMedia("application/json")?.get("schema");
+    return schema?.itemSchema();
+}
+function getInputSchema(token, propertyKey) {
+    return JsonEntityStore.from(token, propertyKey, 0).schema?.itemSchema();
+}
+function mapOptions(options) {
+    let handler;
+    if ("propertyKey" in options) {
+        const { token, propertyKey } = options;
+        handler = (args, extra) => {
+            const instance = inject(options.token);
+            return instance[options.propertyKey](args, extra);
+        };
+        const methodStore = JsonEntityStore.fromMethod(token, propertyKey);
+        options.description = options.description || methodStore.operation.get("description");
+        options.inputSchema = options.inputSchema || getInputSchema(token, propertyKey);
+        options.outputSchema = options.outputSchema || getOutputSchema(methodStore);
+    }
+    else {
+        handler = options.handler;
+    }
+    return {
         ...options,
-        inputSchema: toZod(isArrowFn(options.inputSchema) ? options.inputSchema() : options.inputSchema),
-        outputSchema: toZod(options.outputSchema),
-        async handler(args, extra) {
-            const $ctx = new DIContext({
-                id: v4(),
-                injector: injector(),
-                logger: logger(),
-                level: logger().level,
-                maxStackSize: 0,
-                platform: "MCP"
-            });
-            try {
-                return await runInContext($ctx, () => {
-                    return options.handler(args, extra);
-                });
-            }
-            catch (er) {
-                $ctx.logger.error({
-                    event: "MCP_TOOL_ERROR",
-                    tool: options.name,
-                    error_message: er.message,
-                    stack: er.stack
-                });
-                return {
-                    content: [],
-                    structuredContent: {
-                        code: "E_MCP_TOOL_ERROR",
-                        message: er.message
-                    }
-                };
-            }
-            finally {
-                // Ensure per-invocation context is destroyed to avoid leaks
+        handler
+    };
+}
+export function defineTool(options) {
+    const provider = injectable(Symbol.for(`MCP:TOOL:${options.name}`))
+        .type(MCP_PROVIDER_TYPES.TOOL)
+        .factory(() => {
+        let { handler, ...opts } = mapOptions(options);
+        return {
+            ...opts,
+            name: opts.name,
+            inputSchema: toZod(isArrowFn(opts.inputSchema) ? opts.inputSchema() : opts.inputSchema),
+            outputSchema: toZod(opts.outputSchema),
+            async handler(args, extra) {
                 try {
-                    await $ctx.destroy();
+                    return await handler(args, extra);
                 }
-                catch {
-                    // ignore
+                catch (er) {
+                    logger().error({
+                        event: "MCP_TOOL_ERROR",
+                        tool: opts.name,
+                        error_message: er?.message,
+                        stack: er?.stack
+                    });
+                    return {
+                        content: [],
+                        structuredContent: {
+                            code: "E_MCP_TOOL_ERROR",
+                            message: er?.message
+                        }
+                    };
                 }
             }
-        }
-    }));
+        };
+    });
     return provider.token();
 }

package/lib/esm/services/McpServerFactory.js

@@ -1,28 +1,40 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { constant, inject, injectable, logger } from "@tsed/di";
+import { constant, inject, injectable, injector, logger } from "@tsed/di";
+import { MCP_PROVIDER_TYPES } from "../constants/constants.js";
 import { mcpStdioServer } from "./McpStdioServer.js";
 import { mcpStreamableServer } from "./McpStreamableServer.js";
+function collectTokens(type, configured = []) {
+    const tokens = new Set(configured);
+    injector()
+        .getProviders(type)
+        .forEach((provider) => tokens.add(provider.token));
+    return [...tokens];
+}
 export const MCP_SERVER = injectable(McpServer)
     .factory(() => {
     const defaultMode = constant("mcp.mode");
-    const name = constant("name");
+    const name = constant("name", "tsed-mcp");
+    const version = constant("version", "0.0.0");
     const server = new McpServer({
         name,
-        version: constant("pkg.version")
+        version
     });
-    const tools = constant("tools", []);
-    tools.map((token) => {
-        const { name, handler, ...opts } = inject(token);
+    const toolTokens = collectTokens(MCP_PROVIDER_TYPES.TOOL, constant("tools", []));
+    toolTokens.forEach((token) => {
+        const definition = inject(token);
+        const { name, handler, ...opts } = definition;
         server.registerTool(name, opts, handler);
     });
-    const resources = constant("resources", []);
-    resources.map((token) => {
-        const { name, handler, uri, template, ...opts } = inject(token);
+    const resourceTokens = collectTokens(MCP_PROVIDER_TYPES.RESOURCE, constant("resources", []));
+    resourceTokens.forEach((token) => {
+        const definition = inject(token);
+        const { name, handler, uri, template, ...opts } = definition;
         server.registerResource(name, (uri || template), opts, handler);
     });
-    const prompts = constant("prompts", []);
-    prompts.map((token) => {
-        const { name, handler, ...opts } = inject(token);
+    const promptTokens = collectTokens(MCP_PROVIDER_TYPES.PROMPT, constant("prompts", []));
+    promptTokens.forEach((token) => {
+        const definition = inject(token);
+        const { name, handler, ...opts } = definition;
         server.registerPrompt(name, opts, handler);
     });
     return {

package/lib/esm/utils/json-schema-to-zod/Types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/utils/json-schema-to-zod/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
+import { parseArgs, parseOrReadJSON, readPipe } from "./utils/cliTools.js";
+const params = {
+    input: {
+        shorthand: "i",
+        value: "string",
+        required: process.stdin.isTTY && "input is required when no JSON or file path is piped",
+        description: "JSON or a source file path. Required if no data is piped."
+    },
+    output: {
+        shorthand: "o",
+        value: "string",
+        description: "A file path to write to. If not supplied stdout will be used."
+    },
+    name: {
+        shorthand: "n",
+        value: "string",
+        description: "The name of the schema in the output."
+    },
+    depth: {
+        shorthand: "d",
+        value: "number",
+        description: "Maximum depth of recursion before falling back to z.any(). Defaults to 0."
+    },
+    module: {
+        shorthand: "m",
+        value: ["esm", "cjs", "none"],
+        description: "Module syntax; 'esm', 'cjs' or 'none'. Defaults to 'esm'."
+    },
+    type: {
+        shorthand: "t",
+        value: "string",
+        description: "The name of the (optional) inferred type export."
+    },
+    noImport: {
+        shorthand: "ni",
+        description: "Removes the `import { z } from 'zod';` or equivalent from the output."
+    },
+    withJsdocs: {
+        shorthand: "wj",
+        description: "Generate jsdocs off of the description property."
+    },
+    zodVersion: {
+        shorthand: "zv",
+        value: "number",
+        description: "Target Zod version: 3 or 4. Defaults to 4."
+    }
+};
+async function main() {
+    const args = parseArgs(params, process.argv, true);
+    const input = args.input || (await readPipe());
+    const jsonSchema = parseOrReadJSON(input);
+    const zodVersion = (args.zodVersion === 3 ? 3 : 4);
+    const zodSchema = jsonSchemaToZod(jsonSchema, {
+        name: args.name,
+        depth: args.depth,
+        module: args.module || "esm",
+        noImport: args.noImport,
+        type: args.type,
+        withJsdocs: args.withJsdocs,
+        zodVersion
+    });
+    if (args.output) {
+        mkdirSync(dirname(args.output), { recursive: true });
+        writeFileSync(args.output, zodSchema);
+    }
+    else {
+        console.log(zodSchema);
+    }
+}
+void main();

package/lib/esm/utils/json-schema-to-zod/index.js

@@ -0,0 +1,25 @@
+export * from "./jsonSchemaToZod.js";
+export * from "./parsers/parseAllOf.js";
+export * from "./parsers/parseAnyOf.js";
+export * from "./parsers/parseArray.js";
+export * from "./parsers/parseBoolean.js";
+export * from "./parsers/parseConst.js";
+export * from "./parsers/parseDefault.js";
+export * from "./parsers/parseEnum.js";
+export * from "./parsers/parseIfThenElse.js";
+export * from "./parsers/parseMultipleType.js";
+export * from "./parsers/parseNot.js";
+export * from "./parsers/parseNull.js";
+export * from "./parsers/parseNullable.js";
+export * from "./parsers/parseNumber.js";
+export * from "./parsers/parseObject.js";
+export * from "./parsers/parseOneOf.js";
+export * from "./parsers/parseSchema.js";
+export * from "./parsers/parseString.js";
+export * from "./Types.js";
+export * from "./utils/half.js";
+export * from "./utils/jsdocs.js";
+export * from "./utils/omit.js";
+export * from "./utils/withMessage.js";
+import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
+export default jsonSchemaToZod;

package/lib/esm/utils/json-schema-to-zod/jsonSchemaToZod.js

@@ -0,0 +1,43 @@
+import { parseSchema } from "./parsers/parseSchema.js";
+import { expandJsdocs } from "./utils/jsdocs.js";
+export const jsonSchemaToZod = (schema, { module, name, type, noImport, zodVersion = 4, ...rest } = {}) => {
+    if (type && (!name || module !== "esm")) {
+        throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
+    }
+    let result = parseSchema(schema, {
+        module,
+        name,
+        path: [],
+        seen: new Map(),
+        zodVersion,
+        ...rest
+    });
+    const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description ? expandJsdocs(schema.description) : "";
+    if (module === "cjs") {
+        result = `${jsdocs}module.exports = ${name ? `{ ${JSON.stringify(name)}: ${result} }` : result}
+`;
+        if (!noImport) {
+            result = `${jsdocs}const { z } = require("zod")
+
+${result}`;
+        }
+    }
+    else if (module === "esm") {
+        result = `${jsdocs}export ${name ? `const ${name} =` : `default`} ${result}
+`;
+        if (!noImport) {
+            result = `import { z } from "zod"
+
+${result}`;
+        }
+    }
+    else if (name) {
+        result = `${jsdocs}const ${name} = ${result}`;
+    }
+    if (type && name) {
+        let typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
+        result += `export type ${typeName} = z.infer<typeof ${name}>
+`;
+    }
+    return result;
+};

package/lib/esm/utils/json-schema-to-zod/parsers/parseAllOf.js

@@ -0,0 +1,37 @@
+import { half } from "../utils/half.js";
+import { parseSchema } from "./parseSchema.js";
+const originalIndex = Symbol("Original index");
+const ensureOriginalIndex = (arr) => {
+    let newArr = [];
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        if (typeof item === "boolean") {
+            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+        }
+        else if (originalIndex in item) {
+            return arr;
+        }
+        else {
+            newArr.push({ ...item, [originalIndex]: i });
+        }
+    }
+    return newArr;
+};
+export function parseAllOf(schema, refs) {
+    if (schema.allOf.length === 0) {
+        return "z.never()";
+    }
+    else if (schema.allOf.length === 1) {
+        const item = schema.allOf[0];
+        return parseSchema(item, {
+            ...refs,
+            path: [...refs.path, "allOf", item[originalIndex]]
+        });
+    }
+    else {
+        const [left, right] = half(ensureOriginalIndex(schema.allOf));
+        return `z.intersection(${parseAllOf({ allOf: left }, refs)}, ${parseAllOf({
+            allOf: right
+        }, refs)})`;
+    }
+}

package/lib/esm/utils/json-schema-to-zod/parsers/parseAnyOf.js

@@ -0,0 +1,11 @@
+import { parseSchema } from "./parseSchema.js";
+export const parseAnyOf = (schema, refs) => {
+    return schema.anyOf.length
+        ? schema.anyOf.length === 1
+            ? parseSchema(schema.anyOf[0], {
+                ...refs,
+                path: [...refs.path, "anyOf", 0]
+            })
+            : `z.union([${schema.anyOf.map((schema, i) => parseSchema(schema, { ...refs, path: [...refs.path, "anyOf", i] })).join(", ")}])`
+        : `z.any()`;
+};

package/lib/esm/utils/json-schema-to-zod/parsers/parseArray.js

@@ -0,0 +1,16 @@
+import { withMessage } from "../utils/withMessage.js";
+import { parseSchema } from "./parseSchema.js";
+export const parseArray = (schema, refs) => {
+    if (Array.isArray(schema.items)) {
+        return `z.tuple([${schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }))}])`;
+    }
+    let r = !schema.items
+        ? "z.array(z.any())"
+        : `z.array(${parseSchema(schema.items, {
+            ...refs,
+            path: [...refs.path, "items"]
+        })})`;
+    r += withMessage(schema, "minItems", ({ json }) => [`.min(${json}`, ", ", ")"]);
+    r += withMessage(schema, "maxItems", ({ json }) => [`.max(${json}`, ", ", ")"]);
+    return r;
+};

package/lib/esm/utils/json-schema-to-zod/parsers/parseBoolean.js

@@ -0,0 +1,3 @@
+export const parseBoolean = (_schema) => {
+    return "z.boolean()";
+};

package/lib/esm/utils/json-schema-to-zod/parsers/parseConst.js

@@ -0,0 +1,3 @@
+export const parseConst = (schema) => {
+    return `z.literal(${JSON.stringify(schema.const)})`;
+};

package/lib/esm/utils/json-schema-to-zod/parsers/parseDefault.js

@@ -0,0 +1,3 @@
+export const parseDefault = (_schema) => {
+    return "z.any()";
+};

package/lib/esm/utils/json-schema-to-zod/parsers/parseEnum.js

@@ -0,0 +1,15 @@
+export const parseEnum = (schema) => {
+    if (schema.enum.length === 0) {
+        return "z.never()";
+    }
+    else if (schema.enum.length === 1) {
+        // union does not work when there is only one element
+        return `z.literal(${JSON.stringify(schema.enum[0])})`;
+    }
+    else if (schema.enum.every((x) => typeof x === "string")) {
+        return `z.enum([${schema.enum.map((x) => JSON.stringify(x))}])`;
+    }
+    else {
+        return `z.union([${schema.enum.map((x) => `z.literal(${JSON.stringify(x)})`).join(", ")}])`;
+    }
+};