@tsed/cli-mcp 7.0.0-beta.10

package/lib/esm/fn/definePrompt.js

@@ -0,0 +1,52 @@
+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(() => ({
+        ...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);
+            });
+        }
+    }));
+    return provider.token();
+}

package/lib/esm/fn/defineResource.js

@@ -0,0 +1,34 @@
+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(() => ({
+        ...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
+                }
+            }
+        }
+    }));
+    return provider.token();
+}

package/lib/esm/fn/defineTool.js

@@ -0,0 +1,85 @@
+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 { 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(() => ({
+        ...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
+                try {
+                    await $ctx.destroy();
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }));
+    return provider.token();
+}

package/lib/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./fn/definePrompt.js";
+export * from "./fn/defineResource.js";
+export * from "./fn/defineTool.js";
+export * from "./services/McpServerFactory.js";

package/lib/esm/interfaces/interfaces.js

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

package/lib/esm/services/McpServerFactory.js

@@ -0,0 +1,41 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { constant, inject, injectable, logger } from "@tsed/di";
+import { mcpStdioServer } from "./McpStdioServer.js";
+import { mcpStreamableServer } from "./McpStreamableServer.js";
+export const MCP_SERVER = injectable(McpServer)
+    .factory(() => {
+    const defaultMode = constant("mcp.mode");
+    const name = constant("name");
+    const server = new McpServer({
+        name,
+        version: constant("pkg.version")
+    });
+    const tools = constant("tools", []);
+    tools.map((token) => {
+        const { name, handler, ...opts } = inject(token);
+        server.registerTool(name, opts, handler);
+    });
+    const resources = constant("resources", []);
+    resources.map((token) => {
+        const { name, handler, uri, template, ...opts } = inject(token);
+        server.registerResource(name, (uri || template), opts, handler);
+    });
+    const prompts = constant("prompts", []);
+    prompts.map((token) => {
+        const { name, handler, ...opts } = inject(token);
+        server.registerPrompt(name, opts, handler);
+    });
+    return {
+        server,
+        async connect(mode = defaultMode) {
+            if (mode === "streamable-http") {
+                logger().info({ event: "MCP_SERVER_CONNECT", mode });
+                await mcpStreamableServer(server);
+            }
+            else {
+                await mcpStdioServer(server);
+            }
+        }
+    };
+})
+    .token();

package/lib/esm/services/McpStdioServer.js

@@ -0,0 +1,7 @@
+import { logger } from "@tsed/di";
+export async function mcpStdioServer(server) {
+    const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+    const transport = new StdioServerTransport();
+    logger().stop();
+    return server.connect(transport);
+}

package/lib/esm/services/McpStreamableServer.js

@@ -0,0 +1,40 @@
+import { logger } from "@tsed/di";
+export async function mcpStreamableServer(server) {
+    const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+    // @ts-ignore
+    const { default: express } = await import("express");
+    const app = express();
+    app.use(express.json());
+    app.post("/mcp", async (req, res) => {
+        // Create a new transport for each request to prevent request ID collisions
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+            enableJsonResponse: true
+        });
+        res.on("close", () => {
+            transport.close();
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    });
+    const port = parseInt(process.env.PORT || "3000");
+    return new Promise((resolve, reject) => {
+        app
+            .listen(port, () => {
+            logger().info({
+                event: "MCP_STREAMABLE_SERVER",
+                state: "OK",
+                message: `Running http://localhost:${port}/mcp`
+            });
+        })
+            .on("close", () => resolve(true))
+            .on("error", (error) => {
+            logger().error({
+                event: "MCP_STREAMABLE_SERVER",
+                state: "KO",
+                message: error.message
+            });
+            reject(error);
+        });
+    });
+}

package/lib/esm/utils/toZod.js

@@ -0,0 +1,9 @@
+import { JsonSchema } from "@tsed/schema";
+import { jsonSchemaToZod } from "json-schema-to-zod";
+import { z } from "zod";
+function transform(schema) {
+    return eval(`(z) => ${jsonSchemaToZod(schema.toJSON()).replace("z.object", "")}`)(z);
+}
+export function toZod(schema) {
+    return schema && schema instanceof JsonSchema ? transform(schema) : schema;
+}