@tsed/cli-mcp 7.0.0-beta.3

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,69 @@
+import { injectable } from "@tsed/cli-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(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);
+                });
+            }
+            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/CLIMCPServer.js";

package/lib/esm/interfaces/interfaces.js

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

package/lib/esm/services/CLIMCPServer.js

@@ -0,0 +1,36 @@
+import "./McpServerFactory.js";
+import { createInjector, loadPlugins } from "@tsed/cli-core";
+import { constant, inject, injector } from "@tsed/di";
+import { $asyncEmit } from "@tsed/hooks";
+import { MCP_SERVER } from "./McpServerFactory.js";
+export class CLIMCPServer {
+    constructor(settings) {
+        createInjector({
+            ...settings,
+            logger: {
+                level: "info"
+            }
+        });
+    }
+    static async bootstrap(settings) {
+        const server = new CLIMCPServer({
+            ...settings,
+            name: settings.name || "tsed",
+            project: {
+                srcDir: "src",
+                scriptsDir: "scripts",
+                ...(settings.project || {})
+            }
+        });
+        return server.bootstrap();
+    }
+    async bootstrap() {
+        constant("plugins") && (await loadPlugins());
+        await $asyncEmit("$beforeInit");
+        await injector().load();
+        await $asyncEmit("$afterInit");
+        injector().settings.set("loaded", true);
+        await $asyncEmit("$onReady");
+        await inject(MCP_SERVER).connect();
+    }
+}

package/lib/esm/services/McpServerFactory.js

@@ -0,0 +1,42 @@
+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 mode = 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, uri, template, handler, ...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() {
+            logger().info({ event: "MCP_SERVER_CONNECT" });
+            if (mode === "streamable-http") {
+                await mcpStreamableServer(server);
+            }
+            else {
+                await mcpStdioServer(server);
+            }
+            logger().info({ event: "MCP_SERVER_CONNECTED" });
+        }
+    };
+})
+    .token();

package/lib/esm/services/McpStdioServer.js

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

package/lib/esm/services/McpStreamableServer.js

@@ -0,0 +1,28 @@
+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");
+    app
+        .listen(port, () => {
+        console.log(`Demo MCP Server running on http://localhost:${port}/mcp`);
+    })
+        .on("error", (error) => {
+        console.error("Server error:", error);
+        process.exit(1);
+    });
+}

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;
+}