@eaperezc/mcpgen 0.1.0

package/dist/testing/index.js

@@ -0,0 +1,1049 @@
+import { z } from 'zod';
+import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
+import pino from 'pino';
+
+// src/testing/TestClient.ts
+
+// src/errors/McpError.ts
+var McpError = class _McpError extends Error {
+  code;
+  details;
+  timestamp;
+  constructor(options) {
+    super(options.message);
+    this.name = "McpError";
+    this.code = options.code;
+    this.details = options.details;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (options.cause) {
+      this.cause = options.cause;
+    }
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Convert error to a JSON-serializable object
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack
+    };
+  }
+  /**
+   * Create an error for tool not found
+   */
+  static toolNotFound(toolName) {
+    return new _McpError({
+      code: "TOOL_NOT_FOUND" /* TOOL_NOT_FOUND */,
+      message: `Tool '${toolName}' not found`,
+      details: { toolName }
+    });
+  }
+  /**
+   * Create an error for resource not found
+   */
+  static resourceNotFound(uri) {
+    return new _McpError({
+      code: "RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */,
+      message: `Resource '${uri}' not found`,
+      details: { uri }
+    });
+  }
+  /**
+   * Create an error for prompt not found
+   */
+  static promptNotFound(promptName) {
+    return new _McpError({
+      code: "PROMPT_NOT_FOUND" /* PROMPT_NOT_FOUND */,
+      message: `Prompt '${promptName}' not found`,
+      details: { promptName }
+    });
+  }
+  /**
+   * Create a validation error
+   */
+  static validationError(message, details) {
+    return new _McpError({
+      code: "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+      message,
+      details
+    });
+  }
+  /**
+   * Create an authentication error
+   */
+  static authError(code, message) {
+    return new _McpError({
+      code,
+      message
+    });
+  }
+  /**
+   * Create an internal error
+   */
+  static internal(message, cause) {
+    return new _McpError({
+      code: "INTERNAL_ERROR" /* INTERNAL_ERROR */,
+      message,
+      cause
+    });
+  }
+};
+
+// src/logging/types.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+// src/logging/Logger.ts
+var Logger = class _Logger {
+  pino;
+  config;
+  defaultContext;
+  constructor(config = {}) {
+    this.config = {
+      level: config.level ?? "info",
+      json: config.json ?? process.env["NODE_ENV"] === "production",
+      timestamps: config.timestamps ?? true,
+      pretty: config.pretty ?? process.env["NODE_ENV"] !== "production",
+      defaultContext: config.defaultContext ?? {}
+    };
+    this.defaultContext = this.config.defaultContext ?? {};
+    this.pino = pino({
+      level: this.config.level,
+      transport: this.config.pretty ? {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "SYS:standard",
+          ignore: "pid,hostname"
+        }
+      } : void 0,
+      formatters: {
+        level: (label) => ({ level: label })
+      },
+      timestamp: this.config.timestamps ? pino.stdTimeFunctions.isoTime : false
+    });
+  }
+  /**
+   * Check if a log level should be output
+   */
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.config.level];
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(context) {
+    const child = new _Logger(this.config);
+    child.defaultContext = { ...this.defaultContext, ...context };
+    child.pino = this.pino.child(context);
+    return child;
+  }
+  /**
+   * Log a debug message
+   */
+  debug(message, context) {
+    if (this.shouldLog("debug")) {
+      this.pino.debug({ ...this.defaultContext, ...context }, message);
+    }
+  }
+  /**
+   * Log an info message
+   */
+  info(message, context) {
+    if (this.shouldLog("info")) {
+      this.pino.info({ ...this.defaultContext, ...context }, message);
+    }
+  }
+  /**
+   * Log a warning message
+   */
+  warn(message, context) {
+    if (this.shouldLog("warn")) {
+      this.pino.warn({ ...this.defaultContext, ...context }, message);
+    }
+  }
+  /**
+   * Log an error message
+   */
+  error(message, error) {
+    if (this.shouldLog("error")) {
+      if (error instanceof Error) {
+        this.pino.error(
+          {
+            ...this.defaultContext,
+            err: {
+              message: error.message,
+              name: error.name,
+              stack: error.stack
+            }
+          },
+          message
+        );
+      } else {
+        this.pino.error({ ...this.defaultContext, ...error }, message);
+      }
+    }
+  }
+  /**
+   * Log with correlation ID for request tracing
+   */
+  withCorrelationId(correlationId) {
+    return this.child({ correlationId });
+  }
+  /**
+   * Set the log level
+   */
+  setLevel(level) {
+    this.config.level = level;
+    this.pino.level = level;
+  }
+  /**
+   * Get the current log level
+   */
+  getLevel() {
+    return this.config.level;
+  }
+};
+var logger = new Logger();
+
+// src/context/RequestContext.ts
+var asyncLocalStorage = new AsyncLocalStorage();
+function createRequestContext(correlationId, logger2) {
+  const id = randomUUID();
+  const contextLogger = (logger2 ?? logger).withCorrelationId(id);
+  return {
+    correlationId: id,
+    startTime: /* @__PURE__ */ new Date(),
+    logger: contextLogger,
+    custom: /* @__PURE__ */ new Map()
+  };
+}
+async function runInRequestContextAsync(fn, context) {
+  const ctx = context ?? createRequestContext();
+  return asyncLocalStorage.run(ctx, fn);
+}
+function getRequestContext() {
+  return asyncLocalStorage.getStore();
+}
+function requireRequestContext() {
+  const context = getRequestContext();
+  if (!context) {
+    throw new Error("No request context available. Ensure code is running within runInRequestContext.");
+  }
+  return context;
+}
+function getContextLogger() {
+  return getRequestContext()?.logger ?? logger;
+}
+function setAuthContext(auth) {
+  const context = requireRequestContext();
+  context.auth = auth;
+}
+
+// src/tools/BaseTool.ts
+var BaseTool = class {
+  /** Required scopes for this tool (optional) */
+  scopes = [];
+  /**
+   * Validate and execute the tool
+   */
+  async run(input) {
+    const logger2 = getContextLogger();
+    const parseResult = this.schema.safeParse(input);
+    if (!parseResult.success) {
+      const errors = parseResult.error.errors.map((e) => ({
+        path: e.path.join("."),
+        message: e.message
+      }));
+      logger2.warn("Tool input validation failed", {
+        tool: this.name,
+        errors
+      });
+      throw new McpError({
+        code: "TOOL_VALIDATION_ERROR" /* TOOL_VALIDATION_ERROR */,
+        message: `Invalid input for tool '${this.name}'`,
+        details: { errors }
+      });
+    }
+    try {
+      logger2.debug("Executing tool", { tool: this.name });
+      const result = await this.execute(parseResult.data);
+      logger2.debug("Tool executed successfully", { tool: this.name });
+      return result;
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger2.error("Tool execution failed", error instanceof Error ? error : void 0);
+      throw new McpError({
+        code: "TOOL_EXECUTION_ERROR" /* TOOL_EXECUTION_ERROR */,
+        message: `Tool '${this.name}' execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        cause: error instanceof Error ? error : void 0
+      });
+    }
+  }
+  /**
+   * Get tool metadata for registration
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.schema,
+      scopes: this.scopes
+    };
+  }
+  /**
+   * Convert schema to JSON Schema format for MCP protocol
+   */
+  getJsonSchema() {
+    return zodToJsonSchema(this.schema);
+  }
+};
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  if (typeName === "ZodObject") {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const zodValue = value;
+      properties[key] = zodToJsonSchema(zodValue);
+      if (!zodValue.isOptional()) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    };
+  }
+  if (typeName === "ZodString") {
+    const result = { type: "string" };
+    if (def.description) result["description"] = def.description;
+    return result;
+  }
+  if (typeName === "ZodNumber") {
+    const result = { type: "number" };
+    if (def.description) result["description"] = def.description;
+    return result;
+  }
+  if (typeName === "ZodBoolean") {
+    const result = { type: "boolean" };
+    if (def.description) result["description"] = def.description;
+    return result;
+  }
+  if (typeName === "ZodArray") {
+    return {
+      type: "array",
+      items: zodToJsonSchema(def.type)
+    };
+  }
+  if (typeName === "ZodOptional") {
+    return zodToJsonSchema(def.innerType);
+  }
+  if (typeName === "ZodDefault") {
+    const inner = zodToJsonSchema(def.innerType);
+    return { ...inner, default: def.defaultValue() };
+  }
+  return {};
+}
+
+// src/tools/registry.ts
+var InlineTool = class extends BaseTool {
+  name;
+  description;
+  schema;
+  scopes;
+  handler;
+  constructor(name, definition) {
+    super();
+    this.name = name;
+    this.description = definition.description;
+    this.schema = definition.schema;
+    this.scopes = definition.scopes ?? [];
+    this.handler = definition.handler;
+  }
+  async execute(input) {
+    return this.handler(input);
+  }
+};
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool instance
+   */
+  register(tool) {
+    if (this.tools.has(tool.name)) {
+      throw new McpError({
+        code: "TOOL_ALREADY_REGISTERED" /* TOOL_ALREADY_REGISTERED */,
+        message: `Tool '${tool.name}' is already registered`,
+        details: { toolName: tool.name }
+      });
+    }
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Register an inline tool definition
+   */
+  registerInline(name, definition) {
+    const tool = new InlineTool(name, definition);
+    this.register(tool);
+  }
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get a tool by name or throw if not found
+   */
+  getOrThrow(name) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw McpError.toolNotFound(name);
+    }
+    return tool;
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Remove a tool
+   */
+  remove(name) {
+    return this.tools.delete(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get all tool names
+   */
+  getNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * Get the number of registered tools
+   */
+  get size() {
+    return this.tools.size;
+  }
+  /**
+   * Clear all tools
+   */
+  clear() {
+    this.tools.clear();
+  }
+};
+
+// src/resources/BaseResource.ts
+var BaseResource = class {
+  /** Description of the resource */
+  description;
+  /** MIME type of the resource content */
+  mimeType = "text/plain";
+  /** Required scopes for this resource (optional) */
+  scopes = [];
+  /**
+   * Safely read the resource with error handling
+   */
+  async safeRead() {
+    const logger2 = getContextLogger();
+    try {
+      logger2.debug("Reading resource", { uri: this.uri });
+      const result = await this.read();
+      logger2.debug("Resource read successfully", { uri: this.uri });
+      return result;
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger2.error("Resource read failed", error instanceof Error ? error : void 0);
+      throw new McpError({
+        code: "RESOURCE_READ_ERROR" /* RESOURCE_READ_ERROR */,
+        message: `Failed to read resource '${this.uri}': ${error instanceof Error ? error.message : "Unknown error"}`,
+        cause: error instanceof Error ? error : void 0,
+        details: { uri: this.uri }
+      });
+    }
+  }
+  /**
+   * Get resource metadata for registration
+   */
+  getMetadata() {
+    return {
+      uri: this.uri,
+      name: this.name,
+      description: this.description,
+      mimeType: this.mimeType,
+      scopes: this.scopes
+    };
+  }
+  /**
+   * Helper to create text content
+   */
+  text(content) {
+    return { type: "text", text: content };
+  }
+  /**
+   * Helper to create JSON content
+   */
+  json(data) {
+    return { type: "text", text: JSON.stringify(data, null, 2) };
+  }
+  /**
+   * Helper to create blob content
+   */
+  blob(data, mimeType) {
+    return { type: "blob", data, mimeType };
+  }
+};
+
+// src/resources/registry.ts
+var InlineResource = class extends BaseResource {
+  uri;
+  name;
+  description;
+  mimeType;
+  scopes;
+  handler;
+  constructor(uri, definition) {
+    super();
+    this.uri = uri;
+    this.name = definition.name;
+    this.description = definition.description;
+    this.mimeType = definition.mimeType;
+    this.scopes = definition.scopes ?? [];
+    this.handler = definition.read;
+  }
+  async read() {
+    return this.handler();
+  }
+};
+var ResourceRegistry = class {
+  resources = /* @__PURE__ */ new Map();
+  /**
+   * Register a resource instance
+   */
+  register(resource) {
+    if (this.resources.has(resource.uri)) {
+      throw new McpError({
+        code: "RESOURCE_ALREADY_REGISTERED" /* RESOURCE_ALREADY_REGISTERED */,
+        message: `Resource '${resource.uri}' is already registered`,
+        details: { uri: resource.uri }
+      });
+    }
+    this.resources.set(resource.uri, resource);
+  }
+  /**
+   * Register an inline resource definition
+   */
+  registerInline(uri, definition) {
+    const resource = new InlineResource(uri, definition);
+    this.register(resource);
+  }
+  /**
+   * Get a resource by URI
+   */
+  get(uri) {
+    return this.resources.get(uri);
+  }
+  /**
+   * Get a resource by URI or throw if not found
+   */
+  getOrThrow(uri) {
+    const resource = this.resources.get(uri);
+    if (!resource) {
+      throw McpError.resourceNotFound(uri);
+    }
+    return resource;
+  }
+  /**
+   * Check if a resource exists
+   */
+  has(uri) {
+    return this.resources.has(uri);
+  }
+  /**
+   * Remove a resource
+   */
+  remove(uri) {
+    return this.resources.delete(uri);
+  }
+  /**
+   * Get all registered resources
+   */
+  getAll() {
+    return Array.from(this.resources.values());
+  }
+  /**
+   * Get all resource URIs
+   */
+  getUris() {
+    return Array.from(this.resources.keys());
+  }
+  /**
+   * Get the number of registered resources
+   */
+  get size() {
+    return this.resources.size;
+  }
+  /**
+   * Clear all resources
+   */
+  clear() {
+    this.resources.clear();
+  }
+};
+
+// src/prompts/BasePrompt.ts
+var BasePrompt = class {
+  /** Human-readable description */
+  description;
+  /** Zod schema for arguments validation */
+  arguments;
+  /** Required scopes for this prompt (optional) */
+  scopes = [];
+  /**
+   * Validate arguments and render the prompt
+   */
+  async safeRender(args) {
+    const logger2 = getContextLogger();
+    if (this.arguments) {
+      const parseResult = this.arguments.safeParse(args);
+      if (!parseResult.success) {
+        const errors = parseResult.error.errors.map((e) => ({
+          path: e.path.join("."),
+          message: e.message
+        }));
+        logger2.warn("Prompt argument validation failed", {
+          prompt: this.name,
+          errors
+        });
+        throw new McpError({
+          code: "VALIDATION_ERROR" /* VALIDATION_ERROR */,
+          message: `Invalid arguments for prompt '${this.name}'`,
+          details: { errors }
+        });
+      }
+      args = parseResult.data;
+    }
+    try {
+      logger2.debug("Rendering prompt", { prompt: this.name });
+      const result = await this.render(args);
+      logger2.debug("Prompt rendered successfully", { prompt: this.name });
+      return result;
+    } catch (error) {
+      if (error instanceof McpError) {
+        throw error;
+      }
+      logger2.error("Prompt render failed", error instanceof Error ? error : void 0);
+      throw new McpError({
+        code: "PROMPT_RENDER_ERROR" /* PROMPT_RENDER_ERROR */,
+        message: `Failed to render prompt '${this.name}': ${error instanceof Error ? error.message : "Unknown error"}`,
+        cause: error instanceof Error ? error : void 0,
+        details: { promptName: this.name }
+      });
+    }
+  }
+  /**
+   * Get prompt metadata for registration
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      description: this.description,
+      arguments: this.getArgumentsMetadata(),
+      scopes: this.scopes
+    };
+  }
+  /**
+   * Get arguments metadata from schema
+   */
+  getArgumentsMetadata() {
+    if (!this.arguments) return [];
+    const def = this.arguments._def;
+    if (def.typeName !== "ZodObject") return [];
+    const shape = this.arguments.shape;
+    const result = [];
+    for (const [name, value] of Object.entries(shape)) {
+      const zodValue = value;
+      const zodDef = zodValue._def;
+      result.push({
+        name,
+        description: zodDef.description,
+        required: !zodValue.isOptional()
+      });
+    }
+    return result;
+  }
+  /**
+   * Helper to create a user message
+   */
+  user(content) {
+    return { role: "user", content };
+  }
+  /**
+   * Helper to create an assistant message
+   */
+  assistant(content) {
+    return { role: "assistant", content };
+  }
+};
+
+// src/prompts/registry.ts
+var InlinePrompt = class extends BasePrompt {
+  name;
+  description;
+  arguments;
+  scopes;
+  handler;
+  constructor(name, definition) {
+    super();
+    this.name = name;
+    this.description = definition.description;
+    this.arguments = definition.arguments;
+    this.scopes = definition.scopes ?? [];
+    this.handler = definition.render;
+  }
+  async render(args) {
+    return this.handler(args);
+  }
+};
+var PromptRegistry = class {
+  prompts = /* @__PURE__ */ new Map();
+  /**
+   * Register a prompt instance
+   */
+  register(prompt) {
+    if (this.prompts.has(prompt.name)) {
+      throw new McpError({
+        code: "PROMPT_ALREADY_REGISTERED" /* PROMPT_ALREADY_REGISTERED */,
+        message: `Prompt '${prompt.name}' is already registered`,
+        details: { promptName: prompt.name }
+      });
+    }
+    this.prompts.set(prompt.name, prompt);
+  }
+  /**
+   * Register an inline prompt definition
+   */
+  registerInline(name, definition) {
+    const prompt = new InlinePrompt(name, definition);
+    this.register(prompt);
+  }
+  /**
+   * Get a prompt by name
+   */
+  get(name) {
+    return this.prompts.get(name);
+  }
+  /**
+   * Get a prompt by name or throw if not found
+   */
+  getOrThrow(name) {
+    const prompt = this.prompts.get(name);
+    if (!prompt) {
+      throw McpError.promptNotFound(name);
+    }
+    return prompt;
+  }
+  /**
+   * Check if a prompt exists
+   */
+  has(name) {
+    return this.prompts.has(name);
+  }
+  /**
+   * Remove a prompt
+   */
+  remove(name) {
+    return this.prompts.delete(name);
+  }
+  /**
+   * Get all registered prompts
+   */
+  getAll() {
+    return Array.from(this.prompts.values());
+  }
+  /**
+   * Get all prompt names
+   */
+  getNames() {
+    return Array.from(this.prompts.keys());
+  }
+  /**
+   * Get the number of registered prompts
+   */
+  get size() {
+    return this.prompts.size;
+  }
+  /**
+   * Clear all prompts
+   */
+  clear() {
+    this.prompts.clear();
+  }
+};
+
+// src/testing/TestClient.ts
+var MockTool = class extends BaseTool {
+  name;
+  description;
+  schema = z.object({}).passthrough();
+  response;
+  error;
+  customHandler;
+  constructor(config) {
+    super();
+    this.name = config.name;
+    this.description = config.description ?? `Mock tool: ${config.name}`;
+    this.response = config.response;
+    this.error = config.error;
+    this.customHandler = config.handler;
+  }
+  async execute(input) {
+    if (this.error) {
+      throw this.error;
+    }
+    if (this.customHandler) {
+      const result = await this.customHandler(input);
+      return { content: result };
+    }
+    return { content: this.response ?? { success: true } };
+  }
+};
+var MockResource = class extends BaseResource {
+  uri;
+  name;
+  content;
+  error;
+  customHandler;
+  constructor(config) {
+    super();
+    this.uri = config.uri;
+    this.name = config.name ?? `Mock resource: ${config.uri}`;
+    this.content = config.content;
+    this.error = config.error;
+    this.customHandler = config.handler;
+  }
+  async read() {
+    if (this.error) {
+      throw this.error;
+    }
+    if (this.customHandler) {
+      const result = await this.customHandler();
+      const text2 = typeof result === "string" ? result : JSON.stringify(result);
+      return { contents: [{ type: "text", text: text2 }] };
+    }
+    const text = typeof this.content === "string" ? this.content : JSON.stringify(this.content ?? {});
+    return { contents: [{ type: "text", text }] };
+  }
+};
+var MockPrompt = class extends BasePrompt {
+  name;
+  description;
+  arguments = z.object({}).passthrough();
+  messages;
+  error;
+  customHandler;
+  constructor(config) {
+    super();
+    this.name = config.name;
+    this.description = config.description;
+    this.messages = config.messages;
+    this.error = config.error;
+    this.customHandler = config.handler;
+  }
+  async render(args) {
+    if (this.error) {
+      throw this.error;
+    }
+    if (this.customHandler) {
+      return this.customHandler(args);
+    }
+    return {
+      messages: this.messages ?? [{ role: "user", content: "Mock prompt" }]
+    };
+  }
+};
+var TestClient = class _TestClient {
+  toolRegistry = new ToolRegistry();
+  resourceRegistry = new ResourceRegistry();
+  promptRegistry = new PromptRegistry();
+  config;
+  logger;
+  constructor(config = {}) {
+    this.config = config;
+    this.logger = new Logger({
+      level: config.debug ? "debug" : "error",
+      pretty: true
+    });
+  }
+  /**
+   * Create a test client from an existing McpServer
+   */
+  static fromServer(server, config) {
+    const client = new _TestClient(config);
+    for (const tool of server.getToolRegistry().getAll()) {
+      client.toolRegistry.register(tool);
+    }
+    for (const resource of server.getResourceRegistry().getAll()) {
+      client.resourceRegistry.register(resource);
+    }
+    for (const prompt of server.getPromptRegistry().getAll()) {
+      client.promptRegistry.register(prompt);
+    }
+    return client;
+  }
+  /**
+   * Register a tool for testing
+   */
+  registerTool(tool) {
+    this.toolRegistry.register(tool);
+    return this;
+  }
+  /**
+   * Register a resource for testing
+   */
+  registerResource(resource) {
+    this.resourceRegistry.register(resource);
+    return this;
+  }
+  /**
+   * Register a prompt for testing
+   */
+  registerPrompt(prompt) {
+    this.promptRegistry.register(prompt);
+    return this;
+  }
+  /**
+   * Register a mock tool
+   */
+  mockTool(config) {
+    this.toolRegistry.register(new MockTool(config));
+    return this;
+  }
+  /**
+   * Register a mock resource
+   */
+  mockResource(config) {
+    this.resourceRegistry.register(new MockResource(config));
+    return this;
+  }
+  /**
+   * Register a mock prompt
+   */
+  mockPrompt(config) {
+    this.promptRegistry.register(new MockPrompt(config));
+    return this;
+  }
+  /**
+   * Call a tool
+   */
+  async callTool(name, input) {
+    return runInRequestContextAsync(async () => {
+      if (this.config.auth) {
+        setAuthContext(this.config.auth);
+      }
+      const tool = this.toolRegistry.getOrThrow(name);
+      return tool.run(input ?? {});
+    }, createRequestContext(void 0, this.logger));
+  }
+  /**
+   * Read a resource
+   */
+  async readResource(uri) {
+    return runInRequestContextAsync(async () => {
+      if (this.config.auth) {
+        setAuthContext(this.config.auth);
+      }
+      const resource = this.resourceRegistry.getOrThrow(uri);
+      return resource.safeRead();
+    }, createRequestContext(void 0, this.logger));
+  }
+  /**
+   * Render a prompt
+   */
+  async renderPrompt(name, args) {
+    return runInRequestContextAsync(async () => {
+      if (this.config.auth) {
+        setAuthContext(this.config.auth);
+      }
+      const prompt = this.promptRegistry.getOrThrow(name);
+      return prompt.safeRender(args ?? {});
+    }, createRequestContext(void 0, this.logger));
+  }
+  /**
+   * List all registered tools
+   */
+  listTools() {
+    return this.toolRegistry.getNames();
+  }
+  /**
+   * List all registered resources
+   */
+  listResources() {
+    return this.resourceRegistry.getUris();
+  }
+  /**
+   * List all registered prompts
+   */
+  listPrompts() {
+    return this.promptRegistry.getNames();
+  }
+  /**
+   * Check if a tool exists
+   */
+  hasTool(name) {
+    return this.toolRegistry.has(name);
+  }
+  /**
+   * Check if a resource exists
+   */
+  hasResource(uri) {
+    return this.resourceRegistry.has(uri);
+  }
+  /**
+   * Check if a prompt exists
+   */
+  hasPrompt(name) {
+    return this.promptRegistry.has(name);
+  }
+  /**
+   * Clear all registered items
+   */
+  clear() {
+    this.toolRegistry.clear();
+    this.resourceRegistry.clear();
+    this.promptRegistry.clear();
+    return this;
+  }
+};
+function createTestClient(config) {
+  return new TestClient(config);
+}
+
+export { TestClient, createTestClient };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map