bantou 0.1.0 → 0.2.0

package/.output/server/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js

@@ -0,0 +1,971 @@
+import { Server } from './index.js';
+import { normalizeObjectSchema, safeParseAsync, getObjectShape, objectFromShape, getParseErrorMessage, getSchemaDescription, isSchemaOptional, getLiteralValue } from './zod-compat.js';
+import { toJsonSchemaCompat } from './zod-json-schema-compat.js';
+import { McpError, ErrorCode, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, CompleteRequestSchema, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate } from '../types.js';
+import { isCompletable, getCompleter } from './completable.js';
+import { UriTemplate } from '../shared/uriTemplate.js';
+import { validateAndWarnToolName } from '../shared/toolNameValidation.js';
+import { ExperimentalMcpServerTasks } from '../experimental/tasks/mcp-server.js';
+import { ZodOptional } from 'zod';
+// Counts array elements and object members in `value`, stopping once the running total passes `max`.
+function toolInputElementCount(value, max) {
+    let count = 0;
+    const stack = [value];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === null || typeof node !== 'object')
+            continue;
+        if (Array.isArray(node)) {
+            for (const child of node) {
+                if (++count > max)
+                    return count;
+                if (child !== null && typeof child === 'object')
+                    stack.push(child);
+            }
+        }
+        else {
+            for (const key in node) {
+                if (!Object.prototype.hasOwnProperty.call(node, key))
+                    continue;
+                if (++count > max)
+                    return count;
+                const child = node[key];
+                if (child !== null && typeof child === 'object')
+                    stack.push(child);
+            }
+        }
+    }
+    return count;
+}
+// Resolves the configured element ceiling: no limit when unset or Infinity, else a number of at least 1.
+function resolveMaxToolInputElements(value) {
+    if (value === undefined || value === Infinity)
+        return undefined;
+    if (typeof value !== 'number' || Number.isNaN(value) || value < 1) {
+        throw new RangeError(`maxToolInputElements must be a number of at least 1, or Infinity, got ${String(value)}`);
+    }
+    return value;
+}
+/**
+ * High-level MCP server that provides a simpler API for working with resources, tools, and prompts.
+ * For advanced usage (like sending notifications or setting custom request handlers), use the underlying
+ * Server instance available via the `server` property.
+ */
+export class McpServer {
+    constructor(serverInfo, options) {
+        this._registeredResources = {};
+        this._registeredResourceTemplates = {};
+        this._registeredTools = {};
+        this._registeredPrompts = {};
+        this._toolHandlersInitialized = false;
+        this._completionHandlerInitialized = false;
+        this._resourceHandlersInitialized = false;
+        this._promptHandlersInitialized = false;
+        this.server = new Server(serverInfo, options);
+        this._maxToolInputElements = resolveMaxToolInputElements(options?.maxToolInputElements);
+        // A capability declared in the options gets its handlers now, so registering after connect() works.
+        if (options?.capabilities?.tools) {
+            this.setToolRequestHandlers();
+        }
+        if (options?.capabilities?.resources) {
+            this.setResourceRequestHandlers();
+        }
+        if (options?.capabilities?.prompts) {
+            this.setPromptRequestHandlers();
+        }
+    }
+    /**
+     * Access experimental features.
+     *
+     * WARNING: These APIs are experimental and may change without notice.
+     *
+     * @experimental
+     */
+    get experimental() {
+        if (!this._experimental) {
+            this._experimental = {
+                tasks: new ExperimentalMcpServerTasks(this)
+            };
+        }
+        return this._experimental;
+    }
+    /**
+     * Attaches to the given transport, starts it, and starts listening for messages.
+     *
+     * The `server` object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
+     */
+    async connect(transport) {
+        return await this.server.connect(transport);
+    }
+    /**
+     * Closes the connection.
+     */
+    async close() {
+        await this.server.close();
+    }
+    setToolRequestHandlers() {
+        if (this._toolHandlersInitialized) {
+            return;
+        }
+        this.server.assertCanSetRequestHandler(getMethodValue(ListToolsRequestSchema));
+        this.server.assertCanSetRequestHandler(getMethodValue(CallToolRequestSchema));
+        this.server.registerCapabilities({
+            tools: {
+                listChanged: true
+            }
+        });
+        this.server.setRequestHandler(ListToolsRequestSchema, () => ({
+            tools: Object.entries(this._registeredTools)
+                .filter(([, tool]) => tool.enabled)
+                .map(([name, tool]) => {
+                const toolDefinition = {
+                    name,
+                    title: tool.title,
+                    description: tool.description,
+                    inputSchema: (() => {
+                        const obj = normalizeObjectSchema(tool.inputSchema);
+                        return obj
+                            ? toJsonSchemaCompat(obj, {
+                                strictUnions: true,
+                                pipeStrategy: 'input'
+                            })
+                            : EMPTY_OBJECT_JSON_SCHEMA;
+                    })(),
+                    annotations: tool.annotations,
+                    execution: tool.execution,
+                    _meta: tool._meta
+                };
+                if (tool.outputSchema) {
+                    const obj = normalizeObjectSchema(tool.outputSchema);
+                    if (obj) {
+                        toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
+                            strictUnions: true,
+                            pipeStrategy: 'output'
+                        });
+                    }
+                }
+                return toolDefinition;
+            })
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+            try {
+                const tool = this._registeredTools[request.params.name];
+                if (!tool) {
+                    throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+                }
+                if (!tool.enabled) {
+                    throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
+                }
+                const isTaskRequest = !!request.params.task;
+                const taskSupport = tool.execution?.taskSupport;
+                const isTaskHandler = 'createTask' in tool.handler;
+                // Validate task hint configuration
+                if ((taskSupport === 'required' || taskSupport === 'optional') && !isTaskHandler) {
+                    throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
+                }
+                // Handle taskSupport 'required' without task augmentation
+                if (taskSupport === 'required' && !isTaskRequest) {
+                    throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
+                }
+                // Handle taskSupport 'optional' without task augmentation - automatic polling
+                if (taskSupport === 'optional' && !isTaskRequest && isTaskHandler) {
+                    return await this.handleAutomaticTaskPolling(tool, request, extra);
+                }
+                // Normal execution path
+                const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+                const result = await this.executeToolHandler(tool, args, extra);
+                // Return CreateTaskResult immediately for task requests
+                if (isTaskRequest) {
+                    return result;
+                }
+                // Validate output schema for non-task requests
+                await this.validateToolOutput(tool, result, request.params.name);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof McpError) {
+                    if (error.code === ErrorCode.UrlElicitationRequired) {
+                        throw error; // Return the error to the caller without wrapping in CallToolResult
+                    }
+                }
+                return this.createToolError(error instanceof Error ? error.message : String(error));
+            }
+        });
+        this._toolHandlersInitialized = true;
+    }
+    /**
+     * Creates a tool error result.
+     *
+     * @param errorMessage - The error message.
+     * @returns The tool error result.
+     */
+    createToolError(errorMessage) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: errorMessage
+                }
+            ],
+            isError: true
+        };
+    }
+    /**
+     * Validates tool input arguments against the tool's input schema.
+     */
+    async validateToolInput(tool, args, toolName) {
+        if (this._maxToolInputElements !== undefined &&
+            toolInputElementCount(args, this._maxToolInputElements) > this._maxToolInputElements) {
+            throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${toolName}: arguments contain more than the maximum of ${this._maxToolInputElements} elements`);
+        }
+        if (!tool.inputSchema) {
+            return undefined;
+        }
+        // Try to normalize to object schema first (for raw shapes and object schemas)
+        // If that fails, use the schema directly (for union/intersection/etc)
+        const inputObj = normalizeObjectSchema(tool.inputSchema);
+        const schemaToParse = inputObj ?? tool.inputSchema;
+        const parseResult = await safeParseAsync(schemaToParse, args ?? {});
+        if (!parseResult.success) {
+            const error = 'error' in parseResult ? parseResult.error : 'Unknown error';
+            const errorMessage = getParseErrorMessage(error);
+            throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+        }
+        return parseResult.data;
+    }
+    /**
+     * Validates tool output against the tool's output schema.
+     */
+    async validateToolOutput(tool, result, toolName) {
+        if (!tool.outputSchema) {
+            return;
+        }
+        // Only validate CallToolResult, not CreateTaskResult
+        if (!('content' in result)) {
+            return;
+        }
+        if (result.isError) {
+            return;
+        }
+        if (!result.structuredContent) {
+            throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+        }
+        // if the tool has an output schema, validate structured content
+        const outputObj = normalizeObjectSchema(tool.outputSchema);
+        const parseResult = await safeParseAsync(outputObj, result.structuredContent);
+        if (!parseResult.success) {
+            const error = 'error' in parseResult ? parseResult.error : 'Unknown error';
+            const errorMessage = getParseErrorMessage(error);
+            throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+        }
+    }
+    /**
+     * Executes a tool handler (either regular or task-based).
+     */
+    async executeToolHandler(tool, args, extra) {
+        const handler = tool.handler;
+        const isTaskHandler = 'createTask' in handler;
+        if (isTaskHandler) {
+            if (!extra.taskStore) {
+                throw new Error('No task store provided.');
+            }
+            const taskExtra = { ...extra, taskStore: extra.taskStore };
+            if (tool.inputSchema) {
+                const typedHandler = handler;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return await Promise.resolve(typedHandler.createTask(args, taskExtra));
+            }
+            else {
+                const typedHandler = handler;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return await Promise.resolve(typedHandler.createTask(taskExtra));
+            }
+        }
+        if (tool.inputSchema) {
+            const typedHandler = handler;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return await Promise.resolve(typedHandler(args, extra));
+        }
+        else {
+            const typedHandler = handler;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return await Promise.resolve(typedHandler(extra));
+        }
+    }
+    /**
+     * Handles automatic task polling for tools with taskSupport 'optional'.
+     */
+    async handleAutomaticTaskPolling(tool, request, extra) {
+        if (!extra.taskStore) {
+            throw new Error('No task store provided for task-capable tool.');
+        }
+        // Validate input and create task
+        const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+        const handler = tool.handler;
+        const taskExtra = { ...extra, taskStore: extra.taskStore };
+        const createTaskResult = args // undefined only if tool.inputSchema is undefined
+            ? await Promise.resolve(handler.createTask(args, taskExtra))
+            : // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                await Promise.resolve(handler.createTask(taskExtra));
+        // Poll until completion
+        const taskId = createTaskResult.task.taskId;
+        let task = createTaskResult.task;
+        const pollInterval = task.pollInterval ?? 5000;
+        while (task.status !== 'completed' && task.status !== 'failed' && task.status !== 'cancelled') {
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            const updatedTask = await extra.taskStore.getTask(taskId);
+            if (!updatedTask) {
+                throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
+            }
+            task = updatedTask;
+        }
+        // Return the final result
+        return (await extra.taskStore.getTaskResult(taskId));
+    }
+    setCompletionRequestHandler() {
+        if (this._completionHandlerInitialized) {
+            return;
+        }
+        this.server.assertCanSetRequestHandler(getMethodValue(CompleteRequestSchema));
+        this.server.registerCapabilities({
+            completions: {}
+        });
+        this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
+            switch (request.params.ref.type) {
+                case 'ref/prompt':
+                    assertCompleteRequestPrompt(request);
+                    return this.handlePromptCompletion(request, request.params.ref);
+                case 'ref/resource':
+                    assertCompleteRequestResourceTemplate(request);
+                    return this.handleResourceCompletion(request, request.params.ref);
+                default:
+                    throw new McpError(ErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
+            }
+        });
+        this._completionHandlerInitialized = true;
+    }
+    async handlePromptCompletion(request, ref) {
+        const prompt = this._registeredPrompts[ref.name];
+        if (!prompt) {
+            throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
+        }
+        if (!prompt.enabled) {
+            throw new McpError(ErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
+        }
+        if (!prompt.argsSchema) {
+            return EMPTY_COMPLETION_RESULT;
+        }
+        const promptShape = getObjectShape(prompt.argsSchema);
+        const field = promptShape?.[request.params.argument.name];
+        if (!isCompletable(field)) {
+            return EMPTY_COMPLETION_RESULT;
+        }
+        const completer = getCompleter(field);
+        if (!completer) {
+            return EMPTY_COMPLETION_RESULT;
+        }
+        const suggestions = await completer(request.params.argument.value, request.params.context);
+        return createCompletionResult(suggestions);
+    }
+    async handleResourceCompletion(request, ref) {
+        const template = Object.values(this._registeredResourceTemplates).find(t => t.resourceTemplate.uriTemplate.toString() === ref.uri);
+        if (!template) {
+            if (this._registeredResources[ref.uri]) {
+                // Attempting to autocomplete a fixed resource URI is not an error in the spec (but probably should be).
+                return EMPTY_COMPLETION_RESULT;
+            }
+            throw new McpError(ErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
+        }
+        const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
+        if (!completer) {
+            return EMPTY_COMPLETION_RESULT;
+        }
+        const suggestions = await completer(request.params.argument.value, request.params.context);
+        return createCompletionResult(suggestions);
+    }
+    setResourceRequestHandlers() {
+        if (this._resourceHandlersInitialized) {
+            return;
+        }
+        this.server.assertCanSetRequestHandler(getMethodValue(ListResourcesRequestSchema));
+        this.server.assertCanSetRequestHandler(getMethodValue(ListResourceTemplatesRequestSchema));
+        this.server.assertCanSetRequestHandler(getMethodValue(ReadResourceRequestSchema));
+        this.server.registerCapabilities({
+            resources: {
+                listChanged: true
+            }
+        });
+        this.server.setRequestHandler(ListResourcesRequestSchema, async (request, extra) => {
+            const resources = Object.entries(this._registeredResources)
+                .filter(([_, resource]) => resource.enabled)
+                .map(([uri, resource]) => ({
+                uri,
+                name: resource.name,
+                ...resource.metadata
+            }));
+            const templateResources = [];
+            for (const template of Object.values(this._registeredResourceTemplates)) {
+                if (!template.resourceTemplate.listCallback) {
+                    continue;
+                }
+                const result = await template.resourceTemplate.listCallback(extra);
+                for (const resource of result.resources) {
+                    templateResources.push({
+                        ...template.metadata,
+                        // the defined resource metadata should override the template metadata if present
+                        ...resource
+                    });
+                }
+            }
+            return { resources: [...resources, ...templateResources] };
+        });
+        this.server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+            const resourceTemplates = Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
+                name,
+                uriTemplate: template.resourceTemplate.uriTemplate.toString(),
+                ...template.metadata
+            }));
+            return { resourceTemplates };
+        });
+        this.server.setRequestHandler(ReadResourceRequestSchema, async (request, extra) => {
+            const uri = new URL(request.params.uri);
+            // First check for exact resource match
+            const resource = this._registeredResources[uri.toString()];
+            if (resource) {
+                if (!resource.enabled) {
+                    throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} disabled`);
+                }
+                return resource.readCallback(uri, extra);
+            }
+            // Then check templates
+            for (const template of Object.values(this._registeredResourceTemplates)) {
+                const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
+                if (variables) {
+                    return template.readCallback(uri, variables, extra);
+                }
+            }
+            throw new McpError(ErrorCode.InvalidParams, `Resource ${uri} not found`);
+        });
+        this._resourceHandlersInitialized = true;
+    }
+    setPromptRequestHandlers() {
+        if (this._promptHandlersInitialized) {
+            return;
+        }
+        this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
+        this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));
+        this.server.registerCapabilities({
+            prompts: {
+                listChanged: true
+            }
+        });
+        this.server.setRequestHandler(ListPromptsRequestSchema, () => ({
+            prompts: Object.entries(this._registeredPrompts)
+                .filter(([, prompt]) => prompt.enabled)
+                .map(([name, prompt]) => {
+                return {
+                    name,
+                    title: prompt.title,
+                    description: prompt.description,
+                    arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : undefined
+                };
+            })
+        }));
+        this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra) => {
+            const prompt = this._registeredPrompts[request.params.name];
+            if (!prompt) {
+                throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
+            }
+            if (!prompt.enabled) {
+                throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
+            }
+            if (prompt.argsSchema) {
+                const argsObj = normalizeObjectSchema(prompt.argsSchema);
+                const parseResult = await safeParseAsync(argsObj, request.params.arguments ?? {});
+                if (!parseResult.success) {
+                    const error = 'error' in parseResult ? parseResult.error : 'Unknown error';
+                    const errorMessage = getParseErrorMessage(error);
+                    throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
+                }
+                const args = parseResult.data;
+                const cb = prompt.callback;
+                return await Promise.resolve(cb(args, extra));
+            }
+            else {
+                const cb = prompt.callback;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return await Promise.resolve(cb(extra));
+            }
+        });
+        this._promptHandlersInitialized = true;
+    }
+    resource(name, uriOrTemplate, ...rest) {
+        let metadata;
+        if (typeof rest[0] === 'object') {
+            metadata = rest.shift();
+        }
+        const readCallback = rest[0];
+        if (typeof uriOrTemplate === 'string') {
+            if (this._registeredResources[uriOrTemplate]) {
+                throw new Error(`Resource ${uriOrTemplate} is already registered`);
+            }
+            const registeredResource = this._createRegisteredResource(name, undefined, uriOrTemplate, metadata, readCallback);
+            this.setResourceRequestHandlers();
+            this.sendResourceListChanged();
+            return registeredResource;
+        }
+        else {
+            if (this._registeredResourceTemplates[name]) {
+                throw new Error(`Resource template ${name} is already registered`);
+            }
+            const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, undefined, uriOrTemplate, metadata, readCallback);
+            this.setResourceRequestHandlers();
+            this.sendResourceListChanged();
+            return registeredResourceTemplate;
+        }
+    }
+    registerResource(name, uriOrTemplate, config, readCallback) {
+        if (typeof uriOrTemplate === 'string') {
+            if (this._registeredResources[uriOrTemplate]) {
+                throw new Error(`Resource ${uriOrTemplate} is already registered`);
+            }
+            const registeredResource = this._createRegisteredResource(name, config.title, uriOrTemplate, config, readCallback);
+            this.setResourceRequestHandlers();
+            this.sendResourceListChanged();
+            return registeredResource;
+        }
+        else {
+            if (this._registeredResourceTemplates[name]) {
+                throw new Error(`Resource template ${name} is already registered`);
+            }
+            const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config.title, uriOrTemplate, config, readCallback);
+            this.setResourceRequestHandlers();
+            this.sendResourceListChanged();
+            return registeredResourceTemplate;
+        }
+    }
+    _createRegisteredResource(name, title, uri, metadata, readCallback) {
+        const registeredResource = {
+            name,
+            title,
+            metadata,
+            readCallback,
+            enabled: true,
+            disable: () => registeredResource.update({ enabled: false }),
+            enable: () => registeredResource.update({ enabled: true }),
+            remove: () => registeredResource.update({ uri: null }),
+            update: updates => {
+                if (typeof updates.uri !== 'undefined' && updates.uri !== uri) {
+                    delete this._registeredResources[uri];
+                    if (updates.uri)
+                        this._registeredResources[updates.uri] = registeredResource;
+                }
+                if (typeof updates.name !== 'undefined')
+                    registeredResource.name = updates.name;
+                if (typeof updates.title !== 'undefined')
+                    registeredResource.title = updates.title;
+                if (typeof updates.metadata !== 'undefined')
+                    registeredResource.metadata = updates.metadata;
+                if (typeof updates.callback !== 'undefined')
+                    registeredResource.readCallback = updates.callback;
+                if (typeof updates.enabled !== 'undefined')
+                    registeredResource.enabled = updates.enabled;
+                this.sendResourceListChanged();
+            }
+        };
+        this._registeredResources[uri] = registeredResource;
+        return registeredResource;
+    }
+    _createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
+        const registeredResourceTemplate = {
+            resourceTemplate: template,
+            title,
+            metadata,
+            readCallback,
+            enabled: true,
+            disable: () => registeredResourceTemplate.update({ enabled: false }),
+            enable: () => registeredResourceTemplate.update({ enabled: true }),
+            remove: () => registeredResourceTemplate.update({ name: null }),
+            update: updates => {
+                if (typeof updates.name !== 'undefined' && updates.name !== name) {
+                    delete this._registeredResourceTemplates[name];
+                    if (updates.name)
+                        this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
+                }
+                if (typeof updates.title !== 'undefined')
+                    registeredResourceTemplate.title = updates.title;
+                if (typeof updates.template !== 'undefined')
+                    registeredResourceTemplate.resourceTemplate = updates.template;
+                if (typeof updates.metadata !== 'undefined')
+                    registeredResourceTemplate.metadata = updates.metadata;
+                if (typeof updates.callback !== 'undefined')
+                    registeredResourceTemplate.readCallback = updates.callback;
+                if (typeof updates.enabled !== 'undefined')
+                    registeredResourceTemplate.enabled = updates.enabled;
+                this.sendResourceListChanged();
+            }
+        };
+        this._registeredResourceTemplates[name] = registeredResourceTemplate;
+        // If the resource template has any completion callbacks, enable completions capability
+        const variableNames = template.uriTemplate.variableNames;
+        const hasCompleter = Array.isArray(variableNames) && variableNames.some(v => !!template.completeCallback(v));
+        if (hasCompleter) {
+            this.setCompletionRequestHandler();
+        }
+        return registeredResourceTemplate;
+    }
+    _createRegisteredPrompt(name, title, description, argsSchema, callback) {
+        const registeredPrompt = {
+            title,
+            description,
+            argsSchema: argsSchema === undefined ? undefined : objectFromShape(argsSchema),
+            callback,
+            enabled: true,
+            disable: () => registeredPrompt.update({ enabled: false }),
+            enable: () => registeredPrompt.update({ enabled: true }),
+            remove: () => registeredPrompt.update({ name: null }),
+            update: updates => {
+                if (typeof updates.name !== 'undefined' && updates.name !== name) {
+                    delete this._registeredPrompts[name];
+                    if (updates.name)
+                        this._registeredPrompts[updates.name] = registeredPrompt;
+                }
+                if (typeof updates.title !== 'undefined')
+                    registeredPrompt.title = updates.title;
+                if (typeof updates.description !== 'undefined')
+                    registeredPrompt.description = updates.description;
+                if (typeof updates.argsSchema !== 'undefined')
+                    registeredPrompt.argsSchema = objectFromShape(updates.argsSchema);
+                if (typeof updates.callback !== 'undefined')
+                    registeredPrompt.callback = updates.callback;
+                if (typeof updates.enabled !== 'undefined')
+                    registeredPrompt.enabled = updates.enabled;
+                this.sendPromptListChanged();
+            }
+        };
+        this._registeredPrompts[name] = registeredPrompt;
+        // If any argument uses a Completable schema, enable completions capability
+        if (argsSchema) {
+            const hasCompletable = Object.values(argsSchema).some(field => {
+                const inner = field instanceof ZodOptional ? field._def?.innerType : field;
+                return isCompletable(inner);
+            });
+            if (hasCompletable) {
+                this.setCompletionRequestHandler();
+            }
+        }
+        return registeredPrompt;
+    }
+    _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
+        // Validate tool name according to SEP specification
+        validateAndWarnToolName(name);
+        const registeredTool = {
+            title,
+            description,
+            inputSchema: getZodSchemaObject(inputSchema),
+            outputSchema: getZodSchemaObject(outputSchema),
+            annotations,
+            execution,
+            _meta,
+            handler: handler,
+            enabled: true,
+            disable: () => registeredTool.update({ enabled: false }),
+            enable: () => registeredTool.update({ enabled: true }),
+            remove: () => registeredTool.update({ name: null }),
+            update: updates => {
+                if (typeof updates.name !== 'undefined' && updates.name !== name) {
+                    if (typeof updates.name === 'string') {
+                        validateAndWarnToolName(updates.name);
+                    }
+                    delete this._registeredTools[name];
+                    if (updates.name)
+                        this._registeredTools[updates.name] = registeredTool;
+                }
+                if (typeof updates.title !== 'undefined')
+                    registeredTool.title = updates.title;
+                if (typeof updates.description !== 'undefined')
+                    registeredTool.description = updates.description;
+                if (typeof updates.paramsSchema !== 'undefined')
+                    registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
+                if (typeof updates.outputSchema !== 'undefined')
+                    registeredTool.outputSchema = objectFromShape(updates.outputSchema);
+                if (typeof updates.callback !== 'undefined')
+                    registeredTool.handler = updates.callback;
+                if (typeof updates.annotations !== 'undefined')
+                    registeredTool.annotations = updates.annotations;
+                if (typeof updates._meta !== 'undefined')
+                    registeredTool._meta = updates._meta;
+                if (typeof updates.enabled !== 'undefined')
+                    registeredTool.enabled = updates.enabled;
+                this.sendToolListChanged();
+            }
+        };
+        this._registeredTools[name] = registeredTool;
+        this.setToolRequestHandlers();
+        this.sendToolListChanged();
+        return registeredTool;
+    }
+    /**
+     * tool() implementation. Parses arguments passed to overrides defined above.
+     */
+    tool(name, ...rest) {
+        if (this._registeredTools[name]) {
+            throw new Error(`Tool ${name} is already registered`);
+        }
+        let description;
+        let inputSchema;
+        let outputSchema;
+        let annotations;
+        // Tool properties are passed as separate arguments, with omissions allowed.
+        // Support for this style is frozen as of protocol version 2025-03-26. Future additions
+        // to tool definition should *NOT* be added.
+        if (typeof rest[0] === 'string') {
+            description = rest.shift();
+        }
+        // Handle the different overload combinations
+        if (rest.length > 1) {
+            // We have at least one more arg before the callback
+            const firstArg = rest[0];
+            if (isZodRawShapeCompat(firstArg)) {
+                // We have a params schema as the first arg
+                inputSchema = rest.shift();
+                // Check if the next arg is potentially annotations
+                if (rest.length > 1 && typeof rest[0] === 'object' && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
+                    // Case: tool(name, paramsSchema, annotations, cb)
+                    // Or: tool(name, description, paramsSchema, annotations, cb)
+                    annotations = rest.shift();
+                }
+            }
+            else if (typeof firstArg === 'object' && firstArg !== null) {
+                // ToolAnnotations values are primitives. Nested objects indicate a misplaced schema
+                if (Object.values(firstArg).some(v => typeof v === 'object' && v !== null)) {
+                    throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
+                }
+                annotations = rest.shift();
+            }
+        }
+        const callback = rest[0];
+        return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, undefined, callback);
+    }
+    /**
+     * Registers a tool with a config object and callback.
+     */
+    registerTool(name, config, cb) {
+        if (this._registeredTools[name]) {
+            throw new Error(`Tool ${name} is already registered`);
+        }
+        const { title, description, inputSchema, outputSchema, annotations, _meta } = config;
+        return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: 'forbidden' }, _meta, cb);
+    }
+    prompt(name, ...rest) {
+        if (this._registeredPrompts[name]) {
+            throw new Error(`Prompt ${name} is already registered`);
+        }
+        let description;
+        if (typeof rest[0] === 'string') {
+            description = rest.shift();
+        }
+        let argsSchema;
+        if (rest.length > 1) {
+            argsSchema = rest.shift();
+        }
+        const cb = rest[0];
+        const registeredPrompt = this._createRegisteredPrompt(name, undefined, description, argsSchema, cb);
+        this.setPromptRequestHandlers();
+        this.sendPromptListChanged();
+        return registeredPrompt;
+    }
+    /**
+     * Registers a prompt with a config object and callback.
+     */
+    registerPrompt(name, config, cb) {
+        if (this._registeredPrompts[name]) {
+            throw new Error(`Prompt ${name} is already registered`);
+        }
+        const { title, description, argsSchema } = config;
+        const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb);
+        this.setPromptRequestHandlers();
+        this.sendPromptListChanged();
+        return registeredPrompt;
+    }
+    /**
+     * Checks if the server is connected to a transport.
+     * @returns True if the server is connected
+     */
+    isConnected() {
+        return this.server.transport !== undefined;
+    }
+    /**
+     * Sends a logging message to the client, if connected.
+     * Note: You only need to send the parameters object, not the entire JSON RPC message
+     * @see LoggingMessageNotification
+     * @param params
+     * @param sessionId optional for stateless and backward compatibility
+     */
+    async sendLoggingMessage(params, sessionId) {
+        return this.server.sendLoggingMessage(params, sessionId);
+    }
+    /**
+     * Sends a resource list changed event to the client, if connected.
+     */
+    sendResourceListChanged() {
+        if (this.isConnected()) {
+            this.server.sendResourceListChanged();
+        }
+    }
+    /**
+     * Sends a tool list changed event to the client, if connected.
+     */
+    sendToolListChanged() {
+        if (this.isConnected()) {
+            this.server.sendToolListChanged();
+        }
+    }
+    /**
+     * Sends a prompt list changed event to the client, if connected.
+     */
+    sendPromptListChanged() {
+        if (this.isConnected()) {
+            this.server.sendPromptListChanged();
+        }
+    }
+}
+/**
+ * A resource template combines a URI pattern with optional functionality to enumerate
+ * all resources matching that pattern.
+ */
+export class ResourceTemplate {
+    constructor(uriTemplate, _callbacks) {
+        this._callbacks = _callbacks;
+        this._uriTemplate = typeof uriTemplate === 'string' ? new UriTemplate(uriTemplate) : uriTemplate;
+    }
+    /**
+     * Gets the URI template pattern.
+     */
+    get uriTemplate() {
+        return this._uriTemplate;
+    }
+    /**
+     * Gets the list callback, if one was provided.
+     */
+    get listCallback() {
+        return this._callbacks.list;
+    }
+    /**
+     * Gets the callback for completing a specific URI template variable, if one was provided.
+     */
+    completeCallback(variable) {
+        return this._callbacks.complete?.[variable];
+    }
+}
+const EMPTY_OBJECT_JSON_SCHEMA = {
+    type: 'object',
+    properties: {}
+};
+/**
+ * Checks if a value looks like a Zod schema by checking for parse/safeParse methods.
+ */
+function isZodTypeLike(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'parse' in value &&
+        typeof value.parse === 'function' &&
+        'safeParse' in value &&
+        typeof value.safeParse === 'function');
+}
+/**
+ * Checks if an object is a Zod schema instance (v3 or v4).
+ *
+ * Zod schemas have internal markers:
+ * - v3: `_def` property
+ * - v4: `_zod` property
+ *
+ * This includes transformed schemas like z.preprocess(), z.transform(), z.pipe().
+ */
+function isZodSchemaInstance(obj) {
+    return '_def' in obj || '_zod' in obj || isZodTypeLike(obj);
+}
+/**
+ * Checks if an object is a "raw shape" - a plain object where values are Zod schemas.
+ *
+ * Raw shapes are used as shorthand: `{ name: z.string() }` instead of `z.object({ name: z.string() })`.
+ *
+ * IMPORTANT: This must NOT match actual Zod schema instances (like z.preprocess, z.pipe),
+ * which have internal properties that could be mistaken for schema values.
+ */
+function isZodRawShapeCompat(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    // If it's already a Zod schema instance, it's NOT a raw shape
+    if (isZodSchemaInstance(obj)) {
+        return false;
+    }
+    // Empty objects are valid raw shapes (tools with no parameters)
+    if (Object.keys(obj).length === 0) {
+        return true;
+    }
+    // A raw shape has at least one property that is a Zod schema
+    return Object.values(obj).some(isZodTypeLike);
+}
+/**
+ * Converts a provided Zod schema to a Zod object if it is a ZodRawShapeCompat,
+ * otherwise returns the schema as is. Throws if the value is not a valid Zod schema.
+ */
+function getZodSchemaObject(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    if (isZodRawShapeCompat(schema)) {
+        return objectFromShape(schema);
+    }
+    if (!isZodSchemaInstance(schema)) {
+        throw new Error('inputSchema must be a Zod schema or raw shape, received an unrecognized object');
+    }
+    return schema;
+}
+function promptArgumentsFromSchema(schema) {
+    const shape = getObjectShape(schema);
+    if (!shape)
+        return [];
+    return Object.entries(shape).map(([name, field]) => {
+        // Get description - works for both v3 and v4
+        const description = getSchemaDescription(field);
+        // Check if optional - works for both v3 and v4
+        const isOptional = isSchemaOptional(field);
+        return {
+            name,
+            description,
+            required: !isOptional
+        };
+    });
+}
+function getMethodValue(schema) {
+    const shape = getObjectShape(schema);
+    const methodSchema = shape?.method;
+    if (!methodSchema) {
+        throw new Error('Schema is missing a method literal');
+    }
+    // Extract literal value - works for both v3 and v4
+    const value = getLiteralValue(methodSchema);
+    if (typeof value === 'string') {
+        return value;
+    }
+    throw new Error('Schema method literal must be a string');
+}
+function createCompletionResult(suggestions) {
+    return {
+        completion: {
+            values: suggestions.slice(0, 100),
+            total: suggestions.length,
+            hasMore: suggestions.length > 100
+        }
+    };
+}
+const EMPTY_COMPLETION_RESULT = {
+    completion: {
+        values: [],
+        hasMore: false
+    }
+};
+//# sourceMappingURL=mcp.js.map