skybridge 0.0.0-dev.df0cfdd → 0.0.0-dev.df1e961

package/dist/server/middleware.test.js

@@ -1,9 +1,8 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
 import { describe, expect, it, vi } from "vitest";
 import { z } from "zod";
+import { Skybridge } from "./app.js";
 import { buildMiddlewareChain, getHandlerMaps, getToolError, matchesFilter, } from "./middleware.js";
-import { McpServer } from "./server.js";
 // ---------------------------------------------------------------------------
 // matchesFilter
 // ---------------------------------------------------------------------------
@@ -208,29 +207,42 @@ describe("McpServer.mcpMiddleware()", () => {
         return new Client({ name: "test-client", version: "1.0.0" });
     }
     it("returns this for chaining", () => {
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        const result = server.mcpMiddleware(async (_req, _extra, next) => next());
-        expect(result).toBe(server);
+        new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                const result = server.mcpMiddleware(async (_req, _extra, next) => next());
+                expect(result).toBe(server);
+                return server;
+            },
+        });
     });
     it("intercepts tools/call and exposes request params", async () => {
         let capturedMethod = "";
         let capturedParams = {};
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({
-            name: "greet",
-            description: "greet",
-            inputSchema: { name: z.string() },
-        }, (args) => ({
-            content: [{ type: "text", text: `hi ${args.name}` }],
-        }));
-        server.mcpMiddleware("tools/call", async (request, _extra, next) => {
-            capturedMethod = request.method;
-            capturedParams = request.params;
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({
+                    name: "greet",
+                    description: "greet",
+                    inputSchema: { name: z.string() },
+                }, (args) => ({
+                    content: [{ type: "text", text: `hi ${args.name}` }],
+                }));
+                server.mcpMiddleware("tools/call", async (request, _extra, next) => {
+                    capturedMethod = request.method;
+                    capturedParams = request.params;
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         const result = await client.callTool({
             name: "greet",
@@ -243,59 +255,70 @@ describe("McpServer.mcpMiddleware()", () => {
         });
         expect(result.content).toEqual([{ type: "text", text: "hi World" }]);
         await client.close();
-        await server.close();
+        await instance.close();
     });
     it("array filter works", async () => {
         const matchedMethods = [];
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({ name: "t1", description: "t1" }, () => ({
-            content: [{ type: "text", text: "ok" }],
-        }));
-        server.mcpMiddleware(["tools/call", "tools/list"], async (request, _extra, next) => {
-            matchedMethods.push(request.method);
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({ name: "t1", description: "t1" }, () => ({
+                    content: [{ type: "text", text: "ok" }],
+                }));
+                server.mcpMiddleware(["tools/call", "tools/list"], async (request, _extra, next) => {
+                    matchedMethods.push(request.method);
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         await client.listTools();
         await client.callTool({ name: "t1" });
         expect(matchedMethods).toEqual(["tools/list", "tools/call"]);
         await client.close();
-        await server.close();
-    });
-    it("throws if registered after connect()", async () => {
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        const [_clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
-        expect(() => server.mcpMiddleware(async (_req, _extra, next) => next())).toThrow("Cannot register MCP middleware after run() or connect()");
-        await server.close();
-    });
-    it("throws when filter provided without handler", () => {
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        expect(() => 
-        // @ts-expect-error intentionally passing filter without handler
-        server.mcpMiddleware("tools/call")).toThrow("mcpMiddleware requires a handler function");
+        await instance.close();
+    });
+    it("throws when filter provided without handler", async () => {
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => 
+            // @ts-expect-error intentionally passing filter without handler
+            server.mcpMiddleware("tools/call"),
+        });
+        await expect(app.createServerInstance()).rejects.toThrow("mcpMiddleware requires a handler function");
     });
     it("catch-all middleware + filtered middleware stack correctly", async () => {
         const calls = [];
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({ name: "t1", description: "t1" }, () => ({
-            content: [{ type: "text", text: "ok" }],
-        }));
-        server
-            .mcpMiddleware(async (request, _extra, next) => {
-            calls.push(`global:${request.method}`);
-            return next();
-        })
-            .mcpMiddleware("tools/call", async (_req, _extra, next) => {
-            calls.push("tools-only");
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({ name: "t1", description: "t1" }, () => ({
+                    content: [{ type: "text", text: "ok" }],
+                }));
+                server
+                    .mcpMiddleware(async (request, _extra, next) => {
+                    calls.push(`global:${request.method}`);
+                    return next();
+                })
+                    .mcpMiddleware("tools/call", async (_req, _extra, next) => {
+                    calls.push("tools-only");
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         await client.listTools();
         await client.callTool({ name: "t1" });
@@ -309,41 +332,55 @@ describe("McpServer.mcpMiddleware()", () => {
         const toolsCallIdx = calls.indexOf("global:tools/call");
         expect(calls[toolsCallIdx + 1]).toBe("tools-only");
         await client.close();
-        await server.close();
+        await instance.close();
     });
     it("notification middleware receives extra as undefined", async () => {
         let capturedExtra = "sentinel";
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({ name: "t1", description: "t1" }, () => ({
-            content: [{ type: "text", text: "ok" }],
-        }));
-        server.mcpMiddleware("notification", async (_request, extra, next) => {
-            capturedExtra = extra;
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({ name: "t1", description: "t1" }, () => ({
+                    content: [{ type: "text", text: "ok" }],
+                }));
+                server.mcpMiddleware("notification", async (_request, extra, next) => {
+                    capturedExtra = extra;
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         // The client sends notifications/initialized automatically on connect.
         await client.listTools();
         expect(capturedExtra).toBeUndefined();
         await client.close();
-        await server.close();
+        await instance.close();
     });
     it("wildcard filter intercepts matching methods only", async () => {
         const matchedMethods = [];
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({ name: "t1", description: "t1" }, () => ({
-            content: [{ type: "text", text: "ok" }],
-        }));
-        server.mcpMiddleware("tools/*", async (request, _extra, next) => {
-            matchedMethods.push(request.method);
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({ name: "t1", description: "t1" }, () => ({
+                    content: [{ type: "text", text: "ok" }],
+                }));
+                server.mcpMiddleware("tools/*", async (request, _extra, next) => {
+                    matchedMethods.push(request.method);
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         await client.listTools();
         await client.callTool({ name: "t1" });
@@ -353,30 +390,37 @@ describe("McpServer.mcpMiddleware()", () => {
         expect(matchedMethods).not.toContain("initialize");
         expect(matchedMethods).not.toContain("notifications/initialized");
         await client.close();
-        await server.close();
-    });
-    it("middleware can modify tool result via McpServer integration", async () => {
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({
-            name: "greet",
-            description: "greet",
-            inputSchema: { name: z.string() },
-        }, (args) => ({
-            content: [{ type: "text", text: `hi ${args.name}` }],
-        }));
-        server.mcpMiddleware("tools/call", async (_req, _extra, next) => {
-            const result = (await next());
-            return {
-                ...result,
-                content: [
-                    ...result.content,
-                    { type: "text", text: " (modified)" },
-                ],
-            };
+        await instance.close();
+    });
+    it("middleware can modify tool result via Skybridge integration", async () => {
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({
+                    name: "greet",
+                    description: "greet",
+                    inputSchema: { name: z.string() },
+                }, (args) => ({
+                    content: [{ type: "text", text: `hi ${args.name}` }],
+                }));
+                server.mcpMiddleware("tools/call", async (_req, _extra, next) => {
+                    const result = (await next());
+                    return {
+                        ...result,
+                        content: [
+                            ...result.content,
+                            { type: "text", text: " (modified)" },
+                        ],
+                    };
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         const result = await client.callTool({
             name: "greet",
@@ -387,53 +431,67 @@ describe("McpServer.mcpMiddleware()", () => {
             { type: "text", text: " (modified)" },
         ]);
         await client.close();
-        await server.close();
+        await instance.close();
     });
-    it("middleware can short-circuit via McpServer integration", async () => {
+    it("middleware can short-circuit via Skybridge integration", async () => {
         const handlerCalled = vi.fn();
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({ name: "t1", description: "t1" }, () => {
-            handlerCalled();
-            return {
-                content: [{ type: "text", text: "original" }],
-            };
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({ name: "t1", description: "t1" }, () => {
+                    handlerCalled();
+                    return {
+                        content: [{ type: "text", text: "original" }],
+                    };
+                });
+                server.mcpMiddleware("tools/call", async () => ({
+                    content: [{ type: "text", text: "short-circuited" }],
+                }));
+                return server;
+            },
         });
-        server.mcpMiddleware("tools/call", async () => ({
-            content: [{ type: "text", text: "short-circuited" }],
-        }));
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         const result = await client.callTool({ name: "t1" });
         expect(result.content).toEqual([{ type: "text", text: "short-circuited" }]);
         expect(handlerCalled).not.toHaveBeenCalled();
         await client.close();
-        await server.close();
+        await instance.close();
     });
     it("exposes a thrown tool error to middleware via getToolError", async () => {
         const schemaError = new Error("boom with schema");
         const schemalessError = new Error("boom without schema");
         let captured;
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({
-            name: "withSchema",
-            description: "withSchema",
-            inputSchema: { name: z.string() },
-        }, () => {
-            throw schemaError;
-        });
-        server.registerTool({ name: "withoutSchema", description: "withoutSchema" }, () => {
-            throw schemalessError;
-        });
-        server.mcpMiddleware("tools/call", async (_request, extra, next) => {
-            const result = await next();
-            captured = getToolError(extra);
-            return result;
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({
+                    name: "withSchema",
+                    description: "withSchema",
+                    inputSchema: { name: z.string() },
+                }, () => {
+                    throw schemaError;
+                });
+                server.registerTool({ name: "withoutSchema", description: "withoutSchema" }, () => {
+                    throw schemalessError;
+                });
+                server.mcpMiddleware("tools/call", async (_request, extra, next) => {
+                    const result = await next();
+                    captured = getToolError(extra);
+                    return result;
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         const withSchema = await client.callTool({
             name: "withSchema",
@@ -445,28 +503,35 @@ describe("McpServer.mcpMiddleware()", () => {
         expect(withoutSchema.isError).toBe(true);
         expect(captured).toBe(schemalessError);
         await client.close();
-        await server.close();
+        await instance.close();
     });
-    it("middleware can mutate tool call params via McpServer integration", async () => {
+    it("middleware can mutate tool call params via Skybridge integration", async () => {
         let receivedName = "";
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({
-            name: "greet",
-            description: "greet",
-            inputSchema: { name: z.string() },
-        }, (args) => {
-            receivedName = args.name;
-            return {
-                content: [{ type: "text", text: `hi ${args.name}` }],
-            };
-        });
-        server.mcpMiddleware("tools/call", async (request, _extra, next) => {
-            request.params.arguments = { name: "Overridden" };
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({
+                    name: "greet",
+                    description: "greet",
+                    inputSchema: { name: z.string() },
+                }, (args) => {
+                    receivedName = args.name;
+                    return {
+                        content: [{ type: "text", text: `hi ${args.name}` }],
+                    };
+                });
+                server.mcpMiddleware("tools/call", async (request, _extra, next) => {
+                    request.params.arguments = { name: "Overridden" };
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         await client.callTool({
             name: "greet",
@@ -474,21 +539,28 @@ describe("McpServer.mcpMiddleware()", () => {
         });
         expect(receivedName).toBe("Overridden");
         await client.close();
-        await server.close();
+        await instance.close();
     });
     it("category 'request' filter matches requests but not notifications", async () => {
         const matchedMethods = [];
-        const server = new McpServer({ name: "test", version: "1.0.0" });
-        server.registerTool({ name: "t1", description: "t1" }, () => ({
-            content: [{ type: "text", text: "ok" }],
-        }));
-        server.mcpMiddleware("request", async (request, _extra, next) => {
-            matchedMethods.push(request.method);
-            return next();
+        const app = new Skybridge({
+            name: "test",
+            version: "1.0.0",
+            handler: (server) => {
+                server.registerTool({ name: "t1", description: "t1" }, () => ({
+                    content: [{ type: "text", text: "ok" }],
+                }));
+                server.mcpMiddleware("request", async (request, _extra, next) => {
+                    matchedMethods.push(request.method);
+                    return next();
+                });
+                return server;
+            },
         });
         const client = createClient();
         const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-        await server.connect(serverTransport);
+        const instance = await app.createServerInstance();
+        await instance.connect(serverTransport);
         await client.connect(clientTransport);
         await client.listTools();
         await client.callTool({ name: "t1" });
@@ -496,7 +568,7 @@ describe("McpServer.mcpMiddleware()", () => {
         expect(matchedMethods).toContain("tools/call");
         expect(matchedMethods).not.toContain("notifications/initialized");
         await client.close();
-        await server.close();
+        await instance.close();
     });
 });
 // ---------------------------------------------------------------------------