@spotlightjs/spotlight 4.7.1 → 4.8.0

package/dist/node_modules/.pnpm/{@modelcontextprotocol_sdk@1.16.0 → @modelcontextprotocol_sdk@1.24.3_zod@4.1.13}/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js

@@ -2,16 +2,17 @@
 !function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "78651c0e-b1a8-4ad1-ad92-04e10f714528", e._sentryDebugIdIdentifier = "sentry-dbid-78651c0e-b1a8-4ad1-ad92-04e10f714528");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0427edf9-ba7c-42a4-9e21-a26575708b86", e._sentryDebugIdIdentifier = "sentry-dbid-0427edf9-ba7c-42a4-9e21-a26575708b86");
   } catch (e2) {
   }
 }();
 import { Server } from "./index.js";
-import { z } from "zod";
-import "../../../../../../../zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js";
-import { zodToJsonSchema } from "../../../../../../../zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js";
-import { ListToolsRequestSchema, CallToolRequestSchema, McpError, ErrorCode, CompleteRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from "../types.js";
-import { Completable } from "./completable.js";
+import { normalizeObjectSchema, safeParseAsync, getParseErrorMessage, getObjectShape, objectFromShape, getLiteralValue, getSchemaDescription, isSchemaOptional } from "./zod-compat.js";
+import { toJsonSchemaCompat } from "./zod-json-schema-compat.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, McpError, ErrorCode, CompleteRequestSchema, assertCompleteRequestResourceTemplate, assertCompleteRequestPrompt, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from "../types.js";
+import { isCompletable, getCompleter } from "./completable.js";
+import { validateAndWarnToolName } from "../shared/toolNameValidation.js";
+import { ExperimentalMcpServerTasks } from "../experimental/tasks/mcp-server.js";
 class McpServer {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -24,6 +25,21 @@ class McpServer {
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
   }
+  /**
+   * 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.
    *
@@ -42,8 +58,8 @@ class McpServer {
     if (this._toolHandlersInitialized) {
       return;
     }
-    this.server.assertCanSetRequestHandler(ListToolsRequestSchema.shape.method.value);
-    this.server.assertCanSetRequestHandler(CallToolRequestSchema.shape.method.value);
+    this.server.assertCanSetRequestHandler(getMethodValue(ListToolsRequestSchema));
+    this.server.assertCanSetRequestHandler(getMethodValue(CallToolRequestSchema));
     this.server.registerCapabilities({
       tools: {
         listChanged: true
@@ -55,88 +71,197 @@ class McpServer {
           name,
           title: tool.title,
           description: tool.description,
-          inputSchema: tool.inputSchema ? zodToJsonSchema(tool.inputSchema, {
-            strictUnions: true
-          }) : EMPTY_OBJECT_JSON_SCHEMA,
-          annotations: tool.annotations
+          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) {
-          toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, { strictUnions: true });
+          const obj = normalizeObjectSchema(tool.outputSchema);
+          if (obj) {
+            toolDefinition.outputSchema = toJsonSchemaCompat(obj, {
+              strictUnions: true,
+              pipeStrategy: "output"
+            });
+          }
         }
         return toolDefinition;
       })
     }));
     this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-      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`);
-      }
-      let result;
-      if (tool.inputSchema) {
-        const parseResult = await tool.inputSchema.safeParseAsync(request.params.arguments);
-        if (!parseResult.success) {
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${request.params.name}: ${parseResult.error.message}`);
+      var _a;
+      try {
+        const tool = this._registeredTools[request.params.name];
+        if (!tool) {
+          throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
         }
-        const args = parseResult.data;
-        const cb = tool.callback;
-        try {
-          result = await Promise.resolve(cb(args, extra));
-        } catch (error) {
-          result = {
-            content: [
-              {
-                type: "text",
-                text: error instanceof Error ? error.message : String(error)
-              }
-            ],
-            isError: true
-          };
+        if (!tool.enabled) {
+          throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
         }
-      } else {
-        const cb = tool.callback;
-        try {
-          result = await Promise.resolve(cb(extra));
-        } catch (error) {
-          result = {
-            content: [
-              {
-                type: "text",
-                text: error instanceof Error ? error.message : String(error)
-              }
-            ],
-            isError: true
-          };
+        const isTaskRequest = !!request.params.task;
+        const taskSupport = (_a = tool.execution) === null || _a === void 0 ? void 0 : _a.taskSupport;
+        const isTaskHandler = "createTask" in tool.handler;
+        if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
+          throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
         }
-      }
-      if (tool.outputSchema && !result.isError) {
-        if (!result.structuredContent) {
-          throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} has an output schema but no structured content was provided`);
+        if (taskSupport === "required" && !isTaskRequest) {
+          throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
         }
-        const parseResult = await tool.outputSchema.safeParseAsync(result.structuredContent);
-        if (!parseResult.success) {
-          throw new McpError(ErrorCode.InvalidParams, `Invalid structured content for tool ${request.params.name}: ${parseResult.error.message}`);
+        if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
+          return await this.handleAutomaticTaskPolling(tool, request, extra);
+        }
+        const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+        const result = await this.executeToolHandler(tool, args, extra);
+        if (isTaskRequest) {
+          return result;
         }
+        await this.validateToolOutput(tool, result, request.params.name);
+        return result;
+      } catch (error) {
+        if (error instanceof McpError) {
+          if (error.code === ErrorCode.UrlElicitationRequired) {
+            throw error;
+          }
+        }
+        return this.createToolError(error instanceof Error ? error.message : String(error));
       }
-      return result;
     });
     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 (!tool.inputSchema) {
+      return void 0;
+    }
+    const inputObj = normalizeObjectSchema(tool.inputSchema);
+    const schemaToParse = inputObj !== null && inputObj !== void 0 ? 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;
+    }
+    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`);
+    }
+    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;
+        return await Promise.resolve(typedHandler.createTask(args, taskExtra));
+      } else {
+        const typedHandler = handler;
+        return await Promise.resolve(typedHandler.createTask(taskExtra));
+      }
+    }
+    if (tool.inputSchema) {
+      const typedHandler = handler;
+      return await Promise.resolve(typedHandler(args, extra));
+    } else {
+      const typedHandler = handler;
+      return await Promise.resolve(typedHandler(extra));
+    }
+  }
+  /**
+   * Handles automatic task polling for tools with taskSupport 'optional'.
+   */
+  async handleAutomaticTaskPolling(tool, request, extra) {
+    var _a;
+    if (!extra.taskStore) {
+      throw new Error("No task store provided for task-capable tool.");
+    }
+    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 ? await Promise.resolve(handler.createTask(args, taskExtra)) : (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await Promise.resolve(handler.createTask(taskExtra))
+    );
+    const taskId = createTaskResult.task.taskId;
+    let task = createTaskResult.task;
+    const pollInterval = (_a = task.pollInterval) !== null && _a !== void 0 ? _a : 5e3;
+    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 await extra.taskStore.getTaskResult(taskId);
+  }
   setCompletionRequestHandler() {
     if (this._completionHandlerInitialized) {
       return;
     }
-    this.server.assertCanSetRequestHandler(CompleteRequestSchema.shape.method.value);
+    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}`);
@@ -155,12 +280,16 @@ class McpServer {
     if (!prompt.argsSchema) {
       return EMPTY_COMPLETION_RESULT;
     }
-    const field = prompt.argsSchema.shape[request.params.argument.name];
-    if (!(field instanceof Completable)) {
+    const promptShape = getObjectShape(prompt.argsSchema);
+    const field = promptShape === null || promptShape === void 0 ? void 0 : promptShape[request.params.argument.name];
+    if (!isCompletable(field)) {
+      return EMPTY_COMPLETION_RESULT;
+    }
+    const completer = getCompleter(field);
+    if (!completer) {
       return EMPTY_COMPLETION_RESULT;
     }
-    const def = field._def;
-    const suggestions = await def.complete(request.params.argument.value, request.params.context);
+    const suggestions = await completer(request.params.argument.value, request.params.context);
     return createCompletionResult(suggestions);
   }
   async handleResourceCompletion(request, ref) {
@@ -182,9 +311,9 @@ class McpServer {
     if (this._resourceHandlersInitialized) {
       return;
     }
-    this.server.assertCanSetRequestHandler(ListResourcesRequestSchema.shape.method.value);
-    this.server.assertCanSetRequestHandler(ListResourceTemplatesRequestSchema.shape.method.value);
-    this.server.assertCanSetRequestHandler(ReadResourceRequestSchema.shape.method.value);
+    this.server.assertCanSetRequestHandler(getMethodValue(ListResourcesRequestSchema));
+    this.server.assertCanSetRequestHandler(getMethodValue(ListResourceTemplatesRequestSchema));
+    this.server.assertCanSetRequestHandler(getMethodValue(ReadResourceRequestSchema));
     this.server.registerCapabilities({
       resources: {
         listChanged: true
@@ -244,8 +373,8 @@ class McpServer {
     if (this._promptHandlersInitialized) {
       return;
     }
-    this.server.assertCanSetRequestHandler(ListPromptsRequestSchema.shape.method.value);
-    this.server.assertCanSetRequestHandler(GetPromptRequestSchema.shape.method.value);
+    this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
+    this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));
     this.server.registerCapabilities({
       prompts: {
         listChanged: true
@@ -270,9 +399,12 @@ class McpServer {
         throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
       }
       if (prompt.argsSchema) {
-        const parseResult = await prompt.argsSchema.safeParseAsync(request.params.arguments);
+        const argsObj = normalizeObjectSchema(prompt.argsSchema);
+        const parseResult = await safeParseAsync(argsObj, request.params.arguments);
         if (!parseResult.success) {
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${parseResult.error.message}`);
+          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;
@@ -396,7 +528,7 @@ class McpServer {
     const registeredPrompt = {
       title,
       description,
-      argsSchema: argsSchema === void 0 ? void 0 : z.object(argsSchema),
+      argsSchema: argsSchema === void 0 ? void 0 : objectFromShape(argsSchema),
       callback,
       enabled: true,
       disable: () => registeredPrompt.update({ enabled: false }),
@@ -413,7 +545,7 @@ class McpServer {
         if (typeof updates.description !== "undefined")
           registeredPrompt.description = updates.description;
         if (typeof updates.argsSchema !== "undefined")
-          registeredPrompt.argsSchema = z.object(updates.argsSchema);
+          registeredPrompt.argsSchema = objectFromShape(updates.argsSchema);
         if (typeof updates.callback !== "undefined")
           registeredPrompt.callback = updates.callback;
         if (typeof updates.enabled !== "undefined")
@@ -424,20 +556,26 @@ class McpServer {
     this._registeredPrompts[name] = registeredPrompt;
     return registeredPrompt;
   }
-  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, callback) {
+  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
+    validateAndWarnToolName(name);
     const registeredTool = {
       title,
       description,
-      inputSchema: inputSchema === void 0 ? void 0 : z.object(inputSchema),
-      outputSchema: outputSchema === void 0 ? void 0 : z.object(outputSchema),
+      inputSchema: getZodSchemaObject(inputSchema),
+      outputSchema: getZodSchemaObject(outputSchema),
       annotations,
-      callback,
+      execution,
+      _meta,
+      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;
@@ -447,11 +585,13 @@ class McpServer {
         if (typeof updates.description !== "undefined")
           registeredTool.description = updates.description;
         if (typeof updates.paramsSchema !== "undefined")
-          registeredTool.inputSchema = z.object(updates.paramsSchema);
+          registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
         if (typeof updates.callback !== "undefined")
-          registeredTool.callback = updates.callback;
+          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();
@@ -478,9 +618,9 @@ class McpServer {
     }
     if (rest.length > 1) {
       const firstArg = rest[0];
-      if (isZodRawShape(firstArg)) {
+      if (isZodRawShapeCompat(firstArg)) {
         inputSchema = rest.shift();
-        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
+        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
@@ -488,7 +628,7 @@ class McpServer {
       }
     }
     const callback = rest[0];
-    return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, callback);
+    return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
   }
   /**
    * Registers a tool with a config object and callback.
@@ -497,8 +637,8 @@ class McpServer {
     if (this._registeredTools[name]) {
       throw new Error(`Tool ${name} is already registered`);
     }
-    const { title, description, inputSchema, outputSchema, annotations } = config;
-    return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, cb);
+    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]) {
@@ -538,6 +678,16 @@ class McpServer {
   isConnected() {
     return this.server.transport !== void 0;
   }
+  /**
+   * 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.
    */
@@ -567,21 +717,58 @@ const EMPTY_OBJECT_JSON_SCHEMA = {
   type: "object",
   properties: {}
 };
-function isZodRawShape(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  const isEmptyObject = Object.keys(obj).length === 0;
-  return isEmptyObject || Object.values(obj).some(isZodTypeLike);
-}
 function isZodTypeLike(value) {
   return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
 }
+function isZodSchemaInstance(obj) {
+  return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
+}
+function isZodRawShapeCompat(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  if (isZodSchemaInstance(obj)) {
+    return false;
+  }
+  if (Object.keys(obj).length === 0) {
+    return true;
+  }
+  return Object.values(obj).some(isZodTypeLike);
+}
+function getZodSchemaObject(schema) {
+  if (!schema) {
+    return void 0;
+  }
+  if (isZodRawShapeCompat(schema)) {
+    return objectFromShape(schema);
+  }
+  return schema;
+}
 function promptArgumentsFromSchema(schema) {
-  return Object.entries(schema.shape).map(([name, field]) => ({
-    name,
-    description: field.description,
-    required: !field.isOptional()
-  }));
+  const shape = getObjectShape(schema);
+  if (!shape)
+    return [];
+  return Object.entries(shape).map(([name, field]) => {
+    const description = getSchemaDescription(field);
+    const isOptional = isSchemaOptional(field);
+    return {
+      name,
+      description,
+      required: !isOptional
+    };
+  });
+}
+function getMethodValue(schema) {
+  const shape = getObjectShape(schema);
+  const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+  if (!methodSchema) {
+    throw new Error("Schema is missing a method literal");
+  }
+  const value = getLiteralValue(methodSchema);
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new Error("Schema method literal must be a string");
 }
 function createCompletionResult(suggestions) {
   return {