agentworkshop 0.5.1 → 0.5.2

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

@@ -0,0 +1,429 @@
+import { mergeCapabilities, Protocol } from '../shared/protocol.js';
+import { CreateMessageResultSchema, CreateMessageResultWithToolsSchema, ElicitResultSchema, EmptyResultSchema, ErrorCode, InitializedNotificationSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, ListRootsResultSchema, LoggingLevelSchema, McpError, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, CallToolRequestSchema, CallToolResultSchema, CreateTaskResultSchema } from '../types.js';
+import { AjvJsonSchemaValidator } from '../validation/ajv-provider.js';
+import { getLiteralValue, getObjectShape, safeParse } from './zod-compat.js';
+import { ExperimentalServerTasks } from '../experimental/tasks/server.js';
+import { assertToolsCallTaskCapability, assertClientRequestTaskCapability } from '../experimental/tasks/helpers.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"
+ * })
+ * ```
+ * @deprecated Use `McpServer` instead for the high-level API. Only use `Server` for advanced use cases.
+ */
+export class Server extends Protocol {
+    /**
+     * Initializes this server with the given name and version information.
+     */
+    constructor(_serverInfo, options) {
+        super(options);
+        this._serverInfo = _serverInfo;
+        // Map log levels by session id
+        this._loggingLevels = new Map();
+        // Map LogLevelSchema to severity index
+        this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
+        // Is a message with the given level ignored in the log level set for the given session id?
+        this.isMessageIgnored = (level, sessionId) => {
+            const currentLevel = this._loggingLevels.get(sessionId);
+            return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
+        };
+        this._capabilities = options?.capabilities ?? {};
+        this._instructions = options?.instructions;
+        this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+        this.setRequestHandler(InitializeRequestSchema, request => this._oninitialize(request));
+        this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
+        if (this._capabilities.logging) {
+            this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+                const transportSessionId = extra.sessionId || extra.requestInfo?.headers['mcp-session-id'] || undefined;
+                const { level } = request.params;
+                const parseResult = LoggingLevelSchema.safeParse(level);
+                if (parseResult.success) {
+                    this._loggingLevels.set(transportSessionId, parseResult.data);
+                }
+                return {};
+            });
+        }
+    }
+    /**
+     * Access experimental features.
+     *
+     * WARNING: These APIs are experimental and may change without notice.
+     *
+     * @experimental
+     */
+    get experimental() {
+        if (!this._experimental) {
+            this._experimental = {
+                tasks: new ExperimentalServerTasks(this)
+            };
+        }
+        return this._experimental;
+    }
+    /**
+     * Registers new capabilities. This can only be called before connecting to a transport.
+     *
+     * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+     */
+    registerCapabilities(capabilities) {
+        if (this.transport) {
+            throw new Error('Cannot register capabilities after connecting to transport');
+        }
+        this._capabilities = mergeCapabilities(this._capabilities, capabilities);
+    }
+    /**
+     * Override request handler registration to enforce server-side validation for tools/call.
+     */
+    setRequestHandler(requestSchema, handler) {
+        const shape = getObjectShape(requestSchema);
+        const methodSchema = shape?.method;
+        if (!methodSchema) {
+            throw new Error('Schema is missing a method literal');
+        }
+        const methodValue = getLiteralValue(methodSchema);
+        if (typeof methodValue !== 'string') {
+            throw new Error('Schema method literal must be a string');
+        }
+        const method = methodValue;
+        if (method === 'tools/call') {
+            const wrappedHandler = async (request, extra) => {
+                const validatedRequest = safeParse(CallToolRequestSchema, request);
+                if (!validatedRequest.success) {
+                    const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+                    throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+                }
+                const { params } = validatedRequest.data;
+                const result = await Promise.resolve(handler(request, extra));
+                // When task creation is requested, validate and return CreateTaskResult
+                if (params.task) {
+                    const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+                    if (!taskValidationResult.success) {
+                        const errorMessage = taskValidationResult.error instanceof Error
+                            ? taskValidationResult.error.message
+                            : String(taskValidationResult.error);
+                        throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+                    }
+                    return taskValidationResult.data;
+                }
+                // For non-task requests, validate against CallToolResultSchema
+                const validationResult = safeParse(CallToolResultSchema, result);
+                if (!validationResult.success) {
+                    const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+                    throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+                }
+                return validationResult.data;
+            };
+            // Install the wrapped handler
+            return super.setRequestHandler(requestSchema, wrappedHandler);
+        }
+        // Other handlers use default behavior
+        return super.setRequestHandler(requestSchema, handler);
+    }
+    assertCapabilityForMethod(method) {
+        switch (method) {
+            case 'sampling/createMessage':
+                if (!this._clientCapabilities?.sampling) {
+                    throw new Error(`Client does not support sampling (required for ${method})`);
+                }
+                break;
+            case 'elicitation/create':
+                if (!this._clientCapabilities?.elicitation) {
+                    throw new Error(`Client does not support elicitation (required for ${method})`);
+                }
+                break;
+            case 'roots/list':
+                if (!this._clientCapabilities?.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/elicitation/complete':
+                if (!this._clientCapabilities?.elicitation?.url) {
+                    throw new Error(`Client does not support URL elicitation (required for ${method})`);
+                }
+                break;
+            case 'notifications/cancelled':
+                // Cancellation notifications are always allowed
+                break;
+            case 'notifications/progress':
+                // Progress notifications are always allowed
+                break;
+        }
+    }
+    assertRequestHandlerCapability(method) {
+        // Task handlers are registered in Protocol constructor before _capabilities is initialized
+        // Skip capability check for task methods during initialization
+        if (!this._capabilities) {
+            return;
+        }
+        switch (method) {
+            case 'completion/complete':
+                if (!this._capabilities.completions) {
+                    throw new Error(`Server does not support completions (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 'tasks/get':
+            case 'tasks/list':
+            case 'tasks/result':
+            case 'tasks/cancel':
+                if (!this._capabilities.tasks) {
+                    throw new Error(`Server does not support tasks capability (required for ${method})`);
+                }
+                break;
+            case 'ping':
+            case 'initialize':
+                // No specific capability required for these methods
+                break;
+        }
+    }
+    assertTaskCapability(method) {
+        assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, 'Client');
+    }
+    assertTaskHandlerCapability(method) {
+        // Task handlers are registered in Protocol constructor before _capabilities is initialized
+        // Skip capability check for task methods during initialization
+        if (!this._capabilities) {
+            return;
+        }
+        assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, 'Server');
+    }
+    async _oninitialize(request) {
+        const requestedVersion = request.params.protocolVersion;
+        this._clientCapabilities = request.params.capabilities;
+        this._clientVersion = request.params.clientInfo;
+        const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
+        return {
+            protocolVersion,
+            capabilities: this.getCapabilities(),
+            serverInfo: this._serverInfo,
+            ...(this._instructions && { instructions: this._instructions })
+        };
+    }
+    /**
+     * 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);
+    }
+    // Implementation
+    async createMessage(params, options) {
+        // Capability check - only required when tools/toolChoice are provided
+        if (params.tools || params.toolChoice) {
+            if (!this._clientCapabilities?.sampling?.tools) {
+                throw new Error('Client does not support sampling tools capability.');
+            }
+        }
+        // Message structure validation - always validate tool_use/tool_result pairs.
+        // These may appear even without tools/toolChoice in the current request when
+        // a previous sampling request returned tool_use and this is a follow-up with results.
+        if (params.messages.length > 0) {
+            const lastMessage = params.messages[params.messages.length - 1];
+            const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+            const hasToolResults = lastContent.some(c => c.type === 'tool_result');
+            const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+            const previousContent = previousMessage
+                ? Array.isArray(previousMessage.content)
+                    ? previousMessage.content
+                    : [previousMessage.content]
+                : [];
+            const hasPreviousToolUse = previousContent.some(c => c.type === 'tool_use');
+            if (hasToolResults) {
+                if (lastContent.some(c => c.type !== 'tool_result')) {
+                    throw new Error('The last message must contain only tool_result content if any is present');
+                }
+                if (!hasPreviousToolUse) {
+                    throw new Error('tool_result blocks are not matching any tool_use from the previous message');
+                }
+            }
+            if (hasPreviousToolUse) {
+                const toolUseIds = new Set(previousContent.filter(c => c.type === 'tool_use').map(c => c.id));
+                const toolResultIds = new Set(lastContent.filter(c => c.type === 'tool_result').map(c => c.toolUseId));
+                if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every(id => toolResultIds.has(id))) {
+                    throw new Error('ids of tool_result blocks and tool_use blocks from previous message do not match');
+                }
+            }
+        }
+        // Use different schemas based on whether tools are provided
+        if (params.tools) {
+            return this.request({ method: 'sampling/createMessage', params }, CreateMessageResultWithToolsSchema, options);
+        }
+        return this.request({ method: 'sampling/createMessage', params }, CreateMessageResultSchema, options);
+    }
+    /**
+     * Creates an elicitation request for the given parameters.
+     * For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
+     * @param params The parameters for the elicitation request.
+     * @param options Optional request options.
+     * @returns The result of the elicitation request.
+     */
+    async elicitInput(params, options) {
+        const mode = (params.mode ?? 'form');
+        switch (mode) {
+            case 'url': {
+                if (!this._clientCapabilities?.elicitation?.url) {
+                    throw new Error('Client does not support url elicitation.');
+                }
+                const urlParams = params;
+                return this.request({ method: 'elicitation/create', params: urlParams }, ElicitResultSchema, options);
+            }
+            case 'form': {
+                if (!this._clientCapabilities?.elicitation?.form) {
+                    throw new Error('Client does not support form elicitation.');
+                }
+                const formParams = params.mode === 'form' ? params : { ...params, mode: 'form' };
+                const result = await this.request({ method: 'elicitation/create', params: formParams }, ElicitResultSchema, options);
+                if (result.action === 'accept' && result.content && formParams.requestedSchema) {
+                    try {
+                        const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
+                        const validationResult = validator(result.content);
+                        if (!validationResult.valid) {
+                            throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
+                        }
+                    }
+                    catch (error) {
+                        if (error instanceof McpError) {
+                            throw error;
+                        }
+                        throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                return result;
+            }
+        }
+    }
+    /**
+     * Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
+     * notification for the specified elicitation ID.
+     *
+     * @param elicitationId The ID of the elicitation to mark as complete.
+     * @param options Optional notification options. Useful when the completion notification should be related to a prior request.
+     * @returns A function that emits the completion notification when awaited.
+     */
+    createElicitationCompletionNotifier(elicitationId, options) {
+        if (!this._clientCapabilities?.elicitation?.url) {
+            throw new Error('Client does not support URL elicitation (required for notifications/elicitation/complete)');
+        }
+        return () => this.notification({
+            method: 'notifications/elicitation/complete',
+            params: {
+                elicitationId
+            }
+        }, options);
+    }
+    async listRoots(params, options) {
+        return this.request({ method: 'roots/list', params }, ListRootsResultSchema, options);
+    }
+    /**
+     * 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) {
+        if (this._capabilities.logging) {
+            if (!this.isMessageIgnored(params.level, sessionId)) {
+                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