@guru-ai-product/ai-product-kit 0.2.251112183752 → 0.2.251113155253

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.d.ts

@@ -0,0 +1,112 @@
+import { Protocol, ProtocolOptions, RequestOptions } from "../shared/protocol.js";
+import { ClientCapabilities, CreateMessageRequest, Implementation, ListRootsRequest, LoggingMessageNotification, Notification, Request, ResourceUpdatedNotification, Result, ServerCapabilities, ServerNotification, ServerRequest, ServerResult } from "../types.js";
+export type ServerOptions = ProtocolOptions & {
+    /**
+     * Capabilities to advertise as being supported by this server.
+     */
+    capabilities: ServerCapabilities;
+};
+/**
+ * An MCP server on top of a pluggable transport.
+ *
+ * This server will automatically respond to the initialization flow as initiated from the client.
+ *
+ * To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+ *
+ * ```typescript
+ * // Custom schemas
+ * const CustomRequestSchema = RequestSchema.extend({...})
+ * const CustomNotificationSchema = NotificationSchema.extend({...})
+ * const CustomResultSchema = ResultSchema.extend({...})
+ *
+ * // Type aliases
+ * type CustomRequest = z.infer<typeof CustomRequestSchema>
+ * type CustomNotification = z.infer<typeof CustomNotificationSchema>
+ * type CustomResult = z.infer<typeof CustomResultSchema>
+ *
+ * // Create typed server
+ * const server = new Server<CustomRequest, CustomNotification, CustomResult>({
+ *   name: "CustomServer",
+ *   version: "1.0.0"
+ * })
+ * ```
+ */
+export declare class Server<RequestT extends Request = Request, NotificationT extends Notification = Notification, ResultT extends Result = Result> extends Protocol<ServerRequest | RequestT, ServerNotification | NotificationT, ServerResult | ResultT> {
+    private _serverInfo;
+    private _clientCapabilities?;
+    private _clientVersion?;
+    private _capabilities;
+    /**
+     * Callback for when initialization has fully completed (i.e., the client has sent an `initialized` notification).
+     */
+    oninitialized?: () => void;
+    /**
+     * Initializes this server with the given name and version information.
+     */
+    constructor(_serverInfo: Implementation, options: ServerOptions);
+    protected assertCapabilityForMethod(method: RequestT["method"]): void;
+    protected assertNotificationCapability(method: (ServerNotification | NotificationT)["method"]): void;
+    protected assertRequestHandlerCapability(method: string): void;
+    private _oninitialize;
+    /**
+     * After initialization has completed, this will be populated with the client's reported capabilities.
+     */
+    getClientCapabilities(): ClientCapabilities | undefined;
+    /**
+     * After initialization has completed, this will be populated with information about the client's name and version.
+     */
+    getClientVersion(): Implementation | undefined;
+    private getCapabilities;
+    ping(): Promise<{
+        _meta?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    createMessage(params: CreateMessageRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        model: import("zod").ZodString;
+        stopReason: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodEnum<["endTurn", "stopSequence", "maxTokens"]>, import("zod").ZodString]>>;
+        role: import("zod").ZodEnum<["user", "assistant"]>;
+        content: import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"image">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            type: import("zod").ZodLiteral<"image">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            type: import("zod").ZodLiteral<"image">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>]>;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    listRoots(params?: ListRootsRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        roots: import("zod").ZodArray<import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            uri: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            uri: import("zod").ZodString;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    sendLoggingMessage(params: LoggingMessageNotification["params"]): Promise<void>;
+    sendResourceUpdated(params: ResourceUpdatedNotification["params"]): Promise<void>;
+    sendResourceListChanged(): Promise<void>;
+    sendToolListChanged(): Promise<void>;
+    sendPromptListChanged(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,eAAe,EACf,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EAGpB,cAAc,EAMd,gBAAgB,EAEhB,0BAA0B,EAC1B,YAAY,EACZ,OAAO,EACP,2BAA2B,EAC3B,MAAM,EACN,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,YAAY,EAEb,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG;IAC5C;;OAEG;IACH,YAAY,EAAE,kBAAkB,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,MAAM,CACjB,QAAQ,SAAS,OAAO,GAAG,OAAO,EAClC,aAAa,SAAS,YAAY,GAAG,YAAY,EACjD,OAAO,SAAS,MAAM,GAAG,MAAM,CAC/B,SAAQ,QAAQ,CAChB,aAAa,GAAG,QAAQ,EACxB,kBAAkB,GAAG,aAAa,EAClC,YAAY,GAAG,OAAO,CACvB;IAcG,OAAO,CAAC,WAAW;IAbrB,OAAO,CAAC,mBAAmB,CAAC,CAAqB;IACjD,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,aAAa,CAAqB;IAE1C;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAE3B;;OAEG;gBAEO,WAAW,EAAE,cAAc,EACnC,OAAO,EAAE,aAAa;IAaxB,SAAS,CAAC,yBAAyB,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI;IAwBrE,SAAS,CAAC,4BAA4B,CACpC,MAAM,EAAE,CAAC,kBAAkB,GAAG,aAAa,CAAC,CAAC,QAAQ,CAAC,GACrD,IAAI;IA6CP,SAAS,CAAC,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;YAqDhD,aAAa;IAiB3B;;OAEG;IACH,qBAAqB,IAAI,kBAAkB,GAAG,SAAS;IAIvD;;OAEG;IACH,gBAAgB,IAAI,cAAc,GAAG,SAAS;IAI9C,OAAO,CAAC,eAAe;IAIjB,IAAI;;;IAIJ,aAAa,CACjB,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,EACtC,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASpB,SAAS,CACb,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EACnC,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;IASpB,kBAAkB,CAAC,MAAM,EAAE,0BAA0B,CAAC,QAAQ,CAAC;IAI/D,mBAAmB,CAAC,MAAM,EAAE,2BAA2B,CAAC,QAAQ,CAAC;IAOjE,uBAAuB;IAMvB,mBAAmB;IAInB,qBAAqB;CAG5B"}

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.js

@@ -0,0 +1,182 @@
+import { Protocol, } from "../shared/protocol.js";
+import { CreateMessageResultSchema, EmptyResultSchema, InitializedNotificationSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, ListRootsResultSchema, SUPPORTED_PROTOCOL_VERSIONS, } from "../types.js";
+/**
+ * An MCP server on top of a pluggable transport.
+ *
+ * This server will automatically respond to the initialization flow as initiated from the client.
+ *
+ * To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+ *
+ * ```typescript
+ * // Custom schemas
+ * const CustomRequestSchema = RequestSchema.extend({...})
+ * const CustomNotificationSchema = NotificationSchema.extend({...})
+ * const CustomResultSchema = ResultSchema.extend({...})
+ *
+ * // Type aliases
+ * type CustomRequest = z.infer<typeof CustomRequestSchema>
+ * type CustomNotification = z.infer<typeof CustomNotificationSchema>
+ * type CustomResult = z.infer<typeof CustomResultSchema>
+ *
+ * // Create typed server
+ * const server = new Server<CustomRequest, CustomNotification, CustomResult>({
+ *   name: "CustomServer",
+ *   version: "1.0.0"
+ * })
+ * ```
+ */
+export class Server extends Protocol {
+    /**
+     * Initializes this server with the given name and version information.
+     */
+    constructor(_serverInfo, options) {
+        super(options);
+        this._serverInfo = _serverInfo;
+        this._capabilities = options.capabilities;
+        this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
+        this.setNotificationHandler(InitializedNotificationSchema, () => { var _a; return (_a = this.oninitialized) === null || _a === void 0 ? void 0 : _a.call(this); });
+    }
+    assertCapabilityForMethod(method) {
+        var _a, _b;
+        switch (method) {
+            case "sampling/createMessage":
+                if (!((_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling)) {
+                    throw new Error(`Client does not support sampling (required for ${method})`);
+                }
+                break;
+            case "roots/list":
+                if (!((_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.roots)) {
+                    throw new Error(`Client does not support listing roots (required for ${method})`);
+                }
+                break;
+            case "ping":
+                // No specific capability required for ping
+                break;
+        }
+    }
+    assertNotificationCapability(method) {
+        switch (method) {
+            case "notifications/message":
+                if (!this._capabilities.logging) {
+                    throw new Error(`Server does not support logging (required for ${method})`);
+                }
+                break;
+            case "notifications/resources/updated":
+            case "notifications/resources/list_changed":
+                if (!this._capabilities.resources) {
+                    throw new Error(`Server does not support notifying about resources (required for ${method})`);
+                }
+                break;
+            case "notifications/tools/list_changed":
+                if (!this._capabilities.tools) {
+                    throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
+                }
+                break;
+            case "notifications/prompts/list_changed":
+                if (!this._capabilities.prompts) {
+                    throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
+                }
+                break;
+            case "notifications/cancelled":
+                // Cancellation notifications are always allowed
+                break;
+            case "notifications/progress":
+                // Progress notifications are always allowed
+                break;
+        }
+    }
+    assertRequestHandlerCapability(method) {
+        switch (method) {
+            case "sampling/createMessage":
+                if (!this._capabilities.sampling) {
+                    throw new Error(`Server does not support sampling (required for ${method})`);
+                }
+                break;
+            case "logging/setLevel":
+                if (!this._capabilities.logging) {
+                    throw new Error(`Server does not support logging (required for ${method})`);
+                }
+                break;
+            case "prompts/get":
+            case "prompts/list":
+                if (!this._capabilities.prompts) {
+                    throw new Error(`Server does not support prompts (required for ${method})`);
+                }
+                break;
+            case "resources/list":
+            case "resources/templates/list":
+            case "resources/read":
+                if (!this._capabilities.resources) {
+                    throw new Error(`Server does not support resources (required for ${method})`);
+                }
+                break;
+            case "tools/call":
+            case "tools/list":
+                if (!this._capabilities.tools) {
+                    throw new Error(`Server does not support tools (required for ${method})`);
+                }
+                break;
+            case "ping":
+            case "initialize":
+                // No specific capability required for these methods
+                break;
+        }
+    }
+    async _oninitialize(request) {
+        const requestedVersion = request.params.protocolVersion;
+        this._clientCapabilities = request.params.capabilities;
+        this._clientVersion = request.params.clientInfo;
+        return {
+            protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
+                ? requestedVersion
+                : LATEST_PROTOCOL_VERSION,
+            capabilities: this.getCapabilities(),
+            serverInfo: this._serverInfo,
+        };
+    }
+    /**
+     * After initialization has completed, this will be populated with the client's reported capabilities.
+     */
+    getClientCapabilities() {
+        return this._clientCapabilities;
+    }
+    /**
+     * After initialization has completed, this will be populated with information about the client's name and version.
+     */
+    getClientVersion() {
+        return this._clientVersion;
+    }
+    getCapabilities() {
+        return this._capabilities;
+    }
+    async ping() {
+        return this.request({ method: "ping" }, EmptyResultSchema);
+    }
+    async createMessage(params, options) {
+        return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
+    }
+    async listRoots(params, options) {
+        return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
+    }
+    async sendLoggingMessage(params) {
+        return this.notification({ method: "notifications/message", params });
+    }
+    async sendResourceUpdated(params) {
+        return this.notification({
+            method: "notifications/resources/updated",
+            params,
+        });
+    }
+    async sendResourceListChanged() {
+        return this.notification({
+            method: "notifications/resources/list_changed",
+        });
+    }
+    async sendToolListChanged() {
+        return this.notification({ method: "notifications/tools/list_changed" });
+    }
+    async sendPromptListChanged() {
+        return this.notification({ method: "notifications/prompts/list_changed" });
+    }
+}
+//# sourceMappingURL=index.js.map

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"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"}

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/server/index.test.ts"],"names":[],"mappings":""}

package/mcp/node_modules/@modelcontextprotocol/sdk/dist/server/index.test.js

@@ -0,0 +1,360 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-constant-binary-expression */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+import { Server } from "./index.js";
+import { z } from "zod";
+import { RequestSchema, NotificationSchema, ResultSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, CreateMessageRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, SetLevelRequestSchema, } from "../types.js";
+import { InMemoryTransport } from "../inMemory.js";
+import { Client } from "../client/index.js";
+test("should accept latest protocol version", async () => {
+    var _a;
+    let sendPromiseResolve;
+    const sendPromise = new Promise((resolve) => {
+        sendPromiseResolve = resolve;
+    });
+    const serverTransport = {
+        start: jest.fn().mockResolvedValue(undefined),
+        close: jest.fn().mockResolvedValue(undefined),
+        send: jest.fn().mockImplementation((message) => {
+            if (message.id === 1 && message.result) {
+                expect(message.result).toEqual({
+                    protocolVersion: LATEST_PROTOCOL_VERSION,
+                    capabilities: expect.any(Object),
+                    serverInfo: {
+                        name: "test server",
+                        version: "1.0",
+                    },
+                });
+                sendPromiseResolve(undefined);
+            }
+            return Promise.resolve();
+        }),
+    };
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {},
+            logging: {},
+        },
+    });
+    await server.connect(serverTransport);
+    // Simulate initialize request with latest version
+    (_a = serverTransport.onmessage) === null || _a === void 0 ? void 0 : _a.call(serverTransport, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: LATEST_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: {
+                name: "test client",
+                version: "1.0",
+            },
+        },
+    });
+    await expect(sendPromise).resolves.toBeUndefined();
+});
+test("should accept supported older protocol version", async () => {
+    var _a;
+    const OLD_VERSION = SUPPORTED_PROTOCOL_VERSIONS[1];
+    let sendPromiseResolve;
+    const sendPromise = new Promise((resolve) => {
+        sendPromiseResolve = resolve;
+    });
+    const serverTransport = {
+        start: jest.fn().mockResolvedValue(undefined),
+        close: jest.fn().mockResolvedValue(undefined),
+        send: jest.fn().mockImplementation((message) => {
+            if (message.id === 1 && message.result) {
+                expect(message.result).toEqual({
+                    protocolVersion: OLD_VERSION,
+                    capabilities: expect.any(Object),
+                    serverInfo: {
+                        name: "test server",
+                        version: "1.0",
+                    },
+                });
+                sendPromiseResolve(undefined);
+            }
+            return Promise.resolve();
+        }),
+    };
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {},
+            logging: {},
+        },
+    });
+    await server.connect(serverTransport);
+    // Simulate initialize request with older version
+    (_a = serverTransport.onmessage) === null || _a === void 0 ? void 0 : _a.call(serverTransport, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: OLD_VERSION,
+            capabilities: {},
+            clientInfo: {
+                name: "test client",
+                version: "1.0",
+            },
+        },
+    });
+    await expect(sendPromise).resolves.toBeUndefined();
+});
+test("should handle unsupported protocol version", async () => {
+    var _a;
+    let sendPromiseResolve;
+    const sendPromise = new Promise((resolve) => {
+        sendPromiseResolve = resolve;
+    });
+    const serverTransport = {
+        start: jest.fn().mockResolvedValue(undefined),
+        close: jest.fn().mockResolvedValue(undefined),
+        send: jest.fn().mockImplementation((message) => {
+            if (message.id === 1 && message.result) {
+                expect(message.result).toEqual({
+                    protocolVersion: LATEST_PROTOCOL_VERSION,
+                    capabilities: expect.any(Object),
+                    serverInfo: {
+                        name: "test server",
+                        version: "1.0",
+                    },
+                });
+                sendPromiseResolve(undefined);
+            }
+            return Promise.resolve();
+        }),
+    };
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {},
+            logging: {},
+        },
+    });
+    await server.connect(serverTransport);
+    // Simulate initialize request with unsupported version
+    (_a = serverTransport.onmessage) === null || _a === void 0 ? void 0 : _a.call(serverTransport, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "invalid-version",
+            capabilities: {},
+            clientInfo: {
+                name: "test client",
+                version: "1.0",
+            },
+        },
+    });
+    await expect(sendPromise).resolves.toBeUndefined();
+});
+test("should respect client capabilities", async () => {
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {},
+            logging: {},
+        },
+        enforceStrictCapabilities: true,
+    });
+    const client = new Client({
+        name: "test client",
+        version: "1.0",
+    }, {
+        capabilities: {
+            sampling: {},
+        },
+    });
+    // Implement request handler for sampling/createMessage
+    client.setRequestHandler(CreateMessageRequestSchema, async (request) => {
+        // Mock implementation of createMessage
+        return {
+            model: "test-model",
+            role: "assistant",
+            content: {
+                type: "text",
+                text: "This is a test response",
+            },
+        };
+    });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await Promise.all([
+        client.connect(clientTransport),
+        server.connect(serverTransport),
+    ]);
+    expect(server.getClientCapabilities()).toEqual({ sampling: {} });
+    // This should work because sampling is supported by the client
+    await expect(server.createMessage({
+        messages: [],
+        maxTokens: 10,
+    })).resolves.not.toThrow();
+    // This should still throw because roots are not supported by the client
+    await expect(server.listRoots()).rejects.toThrow(/^Client does not support/);
+});
+test("should respect server notification capabilities", async () => {
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            logging: {},
+        },
+        enforceStrictCapabilities: true,
+    });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await server.connect(serverTransport);
+    // This should work because logging is supported by the server
+    await expect(server.sendLoggingMessage({
+        level: "info",
+        data: "Test log message",
+    })).resolves.not.toThrow();
+    // This should throw because resource notificaitons are not supported by the server
+    await expect(server.sendResourceUpdated({ uri: "test://resource" })).rejects.toThrow(/^Server does not support/);
+});
+test("should only allow setRequestHandler for declared capabilities", () => {
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            prompts: {},
+            resources: {},
+        },
+    });
+    // These should work because the capabilities are declared
+    expect(() => {
+        server.setRequestHandler(ListPromptsRequestSchema, () => ({ prompts: [] }));
+    }).not.toThrow();
+    expect(() => {
+        server.setRequestHandler(ListResourcesRequestSchema, () => ({
+            resources: [],
+        }));
+    }).not.toThrow();
+    // These should throw because the capabilities are not declared
+    expect(() => {
+        server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: [] }));
+    }).toThrow(/^Server does not support tools/);
+    expect(() => {
+        server.setRequestHandler(SetLevelRequestSchema, () => ({}));
+    }).toThrow(/^Server does not support logging/);
+});
+/*
+  Test that custom request/notification/result schemas can be used with the Server class.
+  */
+test("should typecheck", () => {
+    const GetWeatherRequestSchema = RequestSchema.extend({
+        method: z.literal("weather/get"),
+        params: z.object({
+            city: z.string(),
+        }),
+    });
+    const GetForecastRequestSchema = RequestSchema.extend({
+        method: z.literal("weather/forecast"),
+        params: z.object({
+            city: z.string(),
+            days: z.number(),
+        }),
+    });
+    const WeatherForecastNotificationSchema = NotificationSchema.extend({
+        method: z.literal("weather/alert"),
+        params: z.object({
+            severity: z.enum(["warning", "watch"]),
+            message: z.string(),
+        }),
+    });
+    const WeatherRequestSchema = GetWeatherRequestSchema.or(GetForecastRequestSchema);
+    const WeatherNotificationSchema = WeatherForecastNotificationSchema;
+    const WeatherResultSchema = ResultSchema.extend({
+        temperature: z.number(),
+        conditions: z.string(),
+    });
+    // Create a typed Server for weather data
+    const weatherServer = new Server({
+        name: "WeatherServer",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: {},
+            logging: {},
+        },
+    });
+    // Typecheck that only valid weather requests/notifications/results are allowed
+    weatherServer.setRequestHandler(GetWeatherRequestSchema, (request) => {
+        return {
+            temperature: 72,
+            conditions: "sunny",
+        };
+    });
+    weatherServer.setNotificationHandler(WeatherForecastNotificationSchema, (notification) => {
+        console.log(`Weather alert: ${notification.params.message}`);
+    });
+});
+test("should handle server cancelling a request", async () => {
+    const server = new Server({
+        name: "test server",
+        version: "1.0",
+    }, {
+        capabilities: {
+            sampling: {},
+        },
+    });
+    const client = new Client({
+        name: "test client",
+        version: "1.0",
+    }, {
+        capabilities: {
+            sampling: {},
+        },
+    });
+    // Set up client to delay responding to createMessage
+    client.setRequestHandler(CreateMessageRequestSchema, async (_request, extra) => {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        return {
+            model: "test",
+            role: "assistant",
+            content: {
+                type: "text",
+                text: "Test response",
+            },
+        };
+    });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await Promise.all([
+        client.connect(clientTransport),
+        server.connect(serverTransport),
+    ]);
+    // Set up abort controller
+    const controller = new AbortController();
+    // Issue request but cancel it immediately
+    const createMessagePromise = server.createMessage({
+        messages: [],
+        maxTokens: 10,
+    }, {
+        signal: controller.signal,
+    });
+    controller.abort("Cancelled by test");
+    // Request should be rejected
+    await expect(createMessagePromise).rejects.toBe("Cancelled by test");
+});
+//# sourceMappingURL=index.test.js.map