mcp-use 1.9.0 → 1.9.1-canary.1

package/dist/src/server/mcp-server.d.ts

@@ -1,198 +1,60 @@
-import type { CreateMessageRequest, CreateMessageResult, ElicitResult } from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
-/**
- * Options for the sample() function in tool context.
- */
-export interface SampleOptions {
-    /**
-     * Timeout in milliseconds for the sampling request.
-     * Default: no timeout (Infinity) - waits indefinitely for the LLM response.
-     * Set this if you want to limit how long to wait for sampling.
-     */
-    timeout?: number;
+import { McpServer as OfficialMcpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CreateMessageRequest, CreateMessageResult } from "@modelcontextprotocol/sdk/types.js";
+import type { Hono as HonoType } from "hono";
+import { toolRegistration, convertZodSchemaToParams, createParamsSchema } from "./tools/index.js";
+import { registerResource, registerResourceTemplate } from "./resources/index.js";
+import { registerPrompt } from "./prompts/index.js";
+import type { ToolContext, SampleOptions, ElicitOptions, ElicitFormParams, ElicitUrlParams } from "./types/tool-context.js";
+export type { ToolContext, SampleOptions, ElicitOptions, ElicitFormParams, ElicitUrlParams, };
+import { onRootsChanged, listRoots } from "./roots/index.js";
+import type { SessionData } from "./sessions/index.js";
+import { getActiveSessions, sendNotification, sendNotificationToSession } from "./notifications/index.js";
+import type { ServerConfig } from "./types/index.js";
+import { parseTemplateUri as parseTemplateUriHelper } from "./utils/index.js";
+export declare class McpServer {
+    /**
+     * Native MCP server instance from @modelcontextprotocol/sdk
+     * Exposed publicly for advanced use cases
+     */
+    readonly nativeServer: OfficialMcpServer;
+    /** @deprecated Use nativeServer instead - kept for backward compatibility */
+    get server(): OfficialMcpServer;
+    private config;
+    app: HonoType;
+    private mcpMounted;
+    private inspectorMounted;
+    serverPort?: number;
+    serverHost: string;
+    serverBaseUrl?: string;
+    registeredTools: string[];
+    registeredPrompts: string[];
+    registeredResources: string[];
+    buildId?: string;
+    sessions: Map<string, SessionData>;
+    private idleCleanupInterval?;
+    private oauthConfig?;
+    private oauthSetupState;
+    private oauthProvider?;
+    private oauthMiddleware?;
     /**
-     * Interval in milliseconds between progress notifications.
-     * Default: 5000 (5 seconds).
-     * Progress notifications are sent to the client to prevent timeout
-     * when the client has resetTimeoutOnProgress enabled.
+     * Storage for registration "recipes" that can be replayed on new server instances
+     * Following the official SDK pattern where each session gets its own server instance
      */
-    progressIntervalMs?: number;
+    private registrationRecipes;
     /**
-     * Optional callback called each time a progress notification is sent.
-     * Useful for logging or custom progress handling.
+     * Resource subscription manager for tracking and notifying resource updates
      */
-    onProgress?: (progress: {
-        progress: number;
-        total?: number;
-        message: string;
-    }) => void;
-}
-/**
- * Options for the elicit() function in tool context.
- */
-export interface ElicitOptions {
+    private subscriptionManager;
     /**
-     * Timeout in milliseconds for the elicitation request.
-     * Default: no timeout (Infinity) - waits indefinitely for user response.
-     * Set this if you want to limit how long to wait for user input.
+     * Clean up resource subscriptions for a closed session
      *
-     * @example
-     * ```typescript
-     * // Wait indefinitely (default)
-     * await ctx.elicit(message, schema);
+     * This method is called automatically when a session is closed to remove
+     * all resource subscriptions associated with that session.
      *
-     * // With 2 minute timeout
-     * await ctx.elicit(message, schema, { timeout: 120000 });
-     * ```
+     * @param sessionId - The session ID to clean up
+     * @internal
      */
-    timeout?: number;
-}
-/**
- * Parameters for form mode elicitation.
- * Used to request structured data from users with optional JSON schema validation.
- */
-export interface ElicitFormParams {
-    /** Human-readable message explaining why the information is needed */
-    message: string;
-    /** JSON Schema defining the structure of the expected response */
-    requestedSchema: Record<string, any>;
-    /** Mode specifier (optional for backwards compatibility, defaults to "form") */
-    mode?: "form";
-}
-/**
- * Parameters for URL mode elicitation.
- * Used to direct users to external URLs for sensitive interactions.
- * MUST be used for interactions involving sensitive information like credentials.
- */
-export interface ElicitUrlParams {
-    /** Human-readable message explaining why the interaction is needed */
-    message: string;
-    /** URL for the user to navigate to */
-    url: string;
-    /** Mode specifier (required for URL mode) */
-    mode: "url";
-}
-/**
- * Context object passed to tool callbacks.
- * Provides access to sampling, elicitation, and progress reporting capabilities.
- */
-export interface ToolContext {
-    /**
-     * Request sampling from the client's LLM with automatic progress notifications.
-     *
-     * Progress notifications are sent every 5 seconds (configurable) while waiting
-     * for the sampling response. This prevents client-side timeouts when the client
-     * has `resetTimeoutOnProgress: true` enabled.
-     *
-     * By default, there is no timeout - the function waits indefinitely for the
-     * LLM response. Set `options.timeout` to limit the wait time.
-     *
-     * @param params - Sampling parameters (messages, model preferences, etc.)
-     * @param options - Optional configuration for timeout and progress
-     * @returns The sampling result from the client's LLM
-     *
-     * @example
-     * ```typescript
-     * // Basic usage - waits indefinitely with automatic progress notifications
-     * const result = await ctx.sample({
-     *   messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
-     * });
-     *
-     * // With timeout and custom progress handling
-     * const result = await ctx.sample(
-     *   { messages: [...] },
-     *   {
-     *     timeout: 120000, // 2 minute timeout
-     *     progressIntervalMs: 3000, // Report progress every 3 seconds
-     *     onProgress: ({ progress, message }) => console.log(message),
-     *   }
-     * );
-     * ```
-     */
-    sample: (params: CreateMessageRequest["params"], options?: SampleOptions) => Promise<CreateMessageResult>;
-    /**
-     * Request user input via the client through elicitation.
-     *
-     * Supports two modes with automatic mode detection:
-     * - **Form mode**: Pass a Zod schema as second parameter - collects structured data
-     * - **URL mode**: Pass a URL string as second parameter - directs to external URL
-     * - **Verbose mode**: Pass an object with explicit mode for backwards compatibility
-     *
-     * By default, there is no timeout - waits indefinitely for user response.
-     * Set `options.timeout` to limit the wait time.
-     *
-     * @example
-     * ```typescript
-     * // Form mode (simplified) - automatically inferred from Zod schema
-     * const result = await ctx.elicit(
-     *   "Please provide your information",
-     *   z.object({
-     *     name: z.string().default("Anonymous"),
-     *     age: z.number().default(0)
-     *   })
-     * );
-     * // result.data is typed as { name: string, age: number }
-     *
-     * // With timeout
-     * const result = await ctx.elicit(
-     *   "Enter info",
-     *   z.object({ name: z.string() }),
-     *   { timeout: 60000 } // 1 minute timeout
-     * );
-     *
-     * // URL mode (simplified) - automatically inferred from URL string
-     * const authResult = await ctx.elicit(
-     *   "Please authorize access",
-     *   "https://example.com/oauth/authorize"
-     * );
-     *
-     * // Verbose API (backwards compatible)
-     * const verboseResult = await ctx.elicit({
-     *   message: "Please provide your information",
-     *   requestedSchema: { type: "object", properties: {...} },
-     *   mode: "form"
-     * });
-     * ```
-     */
-    elicit: {
-        <T extends z.ZodObject<any>>(message: string, schema: T, options?: ElicitOptions): Promise<ElicitResult & {
-            data: z.infer<T>;
-        }>;
-        (message: string, url: string, options?: ElicitOptions): Promise<ElicitResult>;
-        (params: ElicitFormParams | ElicitUrlParams, options?: ElicitOptions): Promise<ElicitResult>;
-    };
-    /**
-     * Send a progress notification to the client.
-     * Only available if the client requested progress updates for this tool call.
-     *
-     * @param progress - Current progress value (should increase with each call)
-     * @param total - Total progress value if known
-     * @param message - Optional message describing current progress
-     */
-    reportProgress?: (progress: number, total?: number, message?: string) => Promise<void>;
-}
-import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import { type Hono as HonoType } from "hono";
-import type { PromptDefinition, ResourceDefinition, ResourceTemplateDefinition, ServerConfig, ToolDefinition, ToolCallback, UIResourceDefinition, InferToolInput, InferToolOutput } from "./types/index.js";
-export declare class McpServer<HasOAuth extends boolean = false> {
-    private server;
-    private config;
-    private app;
-    private mcpMounted;
-    private inspectorMounted;
-    private serverPort?;
-    private serverHost;
-    private serverBaseUrl?;
-    private registeredTools;
-    private registeredPrompts;
-    private registeredResources;
-    private buildId?;
-    private sessions;
-    private idleCleanupInterval?;
-    private oauthProvider?;
-    private oauthMiddleware?;
-    private oauthConfig?;
-    private oauthSetupComplete;
+    cleanupSessionSubscriptions(sessionId: string): void;
     /**
      * Creates a new MCP server instance with Hono integration
      *
@@ -205,407 +67,53 @@ export declare class McpServer<HasOAuth extends boolean = false> {
      */
     constructor(config: ServerConfig);
     /**
-     * Gets the server base URL with fallback to host:port if not configured
-     * @returns The complete base URL for the server
-     */
-    private getServerBaseUrl;
-    /**
-     * Gets additional CSP URLs from environment variable
-     * Supports comma-separated list or single URL
-     * @returns Array of URLs to add to CSP resource_domains
-     */
-    private getCSPUrls;
-    /**
-     * Setup OAuth authentication
-     *
-     * Initializes OAuth provider, creates bearer auth middleware,
-     * sets up OAuth routes, and applies auth to /mcp endpoints.
-     *
-     * @private
-     */
-    private setupOAuth;
-    /**
-     * Define a static resource that can be accessed by clients
-     *
-     * Registers a resource with the MCP server that clients can access via HTTP.
-     * Resources are static content like files, data, or pre-computed results that
-     * can be retrieved by clients without requiring parameters.
-     *
-     * @param resourceDefinition - Configuration object containing resource metadata and handler function
-     * @param resourceDefinition.name - Unique identifier for the resource
-     * @param resourceDefinition.uri - URI pattern for accessing the resource
-     * @param resourceDefinition.title - Optional human-readable title for the resource
-     * @param resourceDefinition.description - Optional description of the resource
-     * @param resourceDefinition.mimeType - MIME type of the resource content
-     * @param resourceDefinition.annotations - Optional annotations (audience, priority, lastModified)
-     * @param resourceDefinition.readCallback - Async callback function that returns the resource content
-     * @returns The server instance for method chaining
-     *
-     * @example
-     * ```typescript
-     * server.resource({
-     *   name: 'config',
-     *   uri: 'config://app-settings',
-     *   title: 'Application Settings',
-     *   mimeType: 'application/json',
-     *   description: 'Current application configuration',
-     *   annotations: {
-     *     audience: ['user'],
-     *     priority: 0.8
-     *   },
-     *   readCallback: async () => ({
-     *     contents: [{
-     *       uri: 'config://app-settings',
-     *       mimeType: 'application/json',
-     *       text: JSON.stringify({ theme: 'dark', language: 'en' })
-     *     }]
-     *   })
-     * })
-     * ```
+     * Wrap registration methods to capture recipes following official SDK pattern.
+     * Each session will get a fresh server instance with all registrations replayed.
      */
-    resource(resourceDefinition: ResourceDefinition): this;
+    private wrapRegistrationMethods;
     /**
-     * Define a dynamic resource template with parameters
-     *
-     * Registers a parameterized resource template with the MCP server. Templates use URI
-     * patterns with placeholders that can be filled in at request time, allowing dynamic
-     * resource generation based on parameters.
-     *
-     * @param resourceTemplateDefinition - Configuration object for the resource template
-     * @param resourceTemplateDefinition.name - Unique identifier for the template
-     * @param resourceTemplateDefinition.resourceTemplate - ResourceTemplate object with uriTemplate and metadata
-     * @param resourceTemplateDefinition.readCallback - Async callback function that generates resource content from URI and params
-     * @returns The server instance for method chaining
-     *
-     * @example
-     * ```typescript
-     * server.resourceTemplate({
-     *   name: 'user-profile',
-     *   resourceTemplate: {
-     *     uriTemplate: 'user://{userId}/profile',
-     *     name: 'User Profile',
-     *     mimeType: 'application/json'
-     *   },
-     *   readCallback: async (uri, params) => ({
-     *     contents: [{
-     *       uri: uri.toString(),
-     *       mimeType: 'application/json',
-     *       text: JSON.stringify({ userId: params.userId, name: 'John Doe' })
-     *     }]
-     *   })
-     * })
-     * ```
+     * Create a new server instance for a session following official SDK pattern.
+     * This is called for each initialize request to create an isolated server.
      */
-    resourceTemplate(resourceTemplateDefinition: ResourceTemplateDefinition): this;
+    getServerForSession(): OfficialMcpServer;
     /**
-     * Define a tool that can be called by clients
-     *
-     * Registers a tool with the MCP server that clients can invoke with parameters.
-     * Tools are functions that perform actions, computations, or operations and
-     * return results. They accept structured input parameters and return structured output.
-     *
-     * Supports Apps SDK metadata for ChatGPT integration via the _meta field.
-     *
-     * @param toolDefinition - Configuration object containing tool metadata and handler function
-     * @param toolDefinition.name - Unique identifier for the tool
-     * @param toolDefinition.description - Optional human-readable description of what the tool does
-     * @param toolDefinition.inputs - Array of input parameter definitions (legacy, use schema instead)
-     * @param toolDefinition.schema - Zod object schema for input validation (preferred)
-     * @param toolDefinition.outputSchema - Zod object schema for structured output validation
-     * @param toolDefinition.cb - Async callback function that executes the tool logic with provided parameters
-     * @param toolDefinition._meta - Optional metadata for the tool (e.g. Apps SDK metadata)
-     * @param callback - Optional separate callback function (alternative to cb property)
-     * @returns The server instance for method chaining
-     *
-     * @example
-     * ```typescript
-     * // Using Zod schema (preferred)
-     * server.tool({
-     *   name: 'calculate',
-     *   description: 'Performs mathematical calculations',
-     *   schema: z.object({
-     *     expression: z.string(),
-     *     precision: z.number().optional()
-     *   }),
-     *   cb: async ({ expression, precision = 2 }) => {
-     *     const result = eval(expression)
-     *     return text(`Result: ${result.toFixed(precision)}`)
-     *   }
-     * })
-     *
-     * // Using legacy inputs array
-     * server.tool({
-     *   name: 'greet',
-     *   inputs: [{ name: 'name', type: 'string', required: true }],
-     *   cb: async ({ name }) => text(`Hello, ${name}!`)
-     * })
-     *
-     * // With separate callback for better typing
-     * server.tool({
-     *   name: 'add',
-     *   schema: z.object({ a: z.number(), b: z.number() })
-     * }, async ({ a, b }) => text(`${a + b}`))
-     * ```
-     */
-    tool<T extends ToolDefinition<any, any, HasOAuth>>(toolDefinition: T, callback: ToolCallback<InferToolInput<T>, InferToolOutput<T>, HasOAuth>): this;
-    tool<T extends ToolDefinition<any, any, HasOAuth>>(toolDefinition: T): this;
-    /**
-     * Define a prompt template
-     *
-     * Registers a prompt template with the MCP server that clients can use to generate
-     * structured prompts for AI models. Prompt templates accept parameters and return
-     * formatted text that can be used as input to language models or other AI systems.
-     *
-     * @param promptDefinition - Configuration object containing prompt metadata and handler function
-     * @param promptDefinition.name - Unique identifier for the prompt template
-     * @param promptDefinition.description - Human-readable description of the prompt's purpose
-     * @param promptDefinition.args - Array of argument definitions with types and validation
-     * @param promptDefinition.cb - Async callback function that generates the prompt from provided arguments
-     * @returns The server instance for method chaining
-     *
-     * @example
-     * ```typescript
-     * server.prompt({
-     *   name: 'code-review',
-     *   description: 'Generates a code review prompt',
-     *   args: [
-     *     { name: 'language', type: 'string', required: true },
-     *     { name: 'focus', type: 'string', required: false }
-     *   ],
-     *   cb: async ({ language, focus = 'general' }) => {
-     *     return {
-     *       messages: [{
-     *         role: 'user',
-     *         content: `Please review this ${language} code with focus on ${focus}...`
-     *       }]
-     *     }
-     *   }
-     * })
-     * ```
-     */
-    prompt(promptDefinition: PromptDefinition): this;
-    /**
-     * Request LLM sampling from connected clients.
-     *
-     * This method allows server tools to request LLM completions from clients
-     * that support the sampling capability. The client will handle model selection,
-     * user approval (human-in-the-loop), and return the generated response.
-     *
-     * @param params - Sampling request parameters including messages, model preferences, etc.
-     * @param options - Optional request options (timeouts, cancellation, etc.)
-     * @returns Promise resolving to the generated message from the client's LLM
-     *
-     * @example
-     * ```typescript
-     * // In a tool callback
-     * server.tool({
-     *   name: 'analyze-sentiment',
-     *   description: 'Analyze sentiment using LLM',
-     *   inputs: [{ name: 'text', type: 'string', required: true }],
-     *   cb: async (params, ctx) => {
-     *     const result = await ctx.sample({
-     *       messages: [{
-     *         role: 'user',
-     *         content: { type: 'text', text: `Analyze sentiment: ${params.text}` }
-     *       }],
-     *       modelPreferences: {
-     *         intelligencePriority: 0.8,
-     *         speedPriority: 0.5
-     *       }
-     *     });
-     *     return {
-     *       content: [{ type: 'text', text: result.content.text }]
-     *     };
-     *   }
-     * })
-     * ```
+     * Gets the server base URL with fallback to host:port if not configured
+     * @returns The complete base URL for the server
      */
-    createMessage(params: CreateMessageRequest["params"], options?: RequestOptions): Promise<CreateMessageResult>;
+    private getServerBaseUrl;
+    tool: typeof toolRegistration;
+    convertZodSchemaToParams: typeof convertZodSchemaToParams;
+    createParamsSchema: typeof createParamsSchema;
+    parseTemplateUri: typeof parseTemplateUriHelper;
+    resource: typeof registerResource;
+    resourceTemplate: typeof registerResourceTemplate;
+    prompt: typeof registerPrompt;
+    getActiveSessions: typeof getActiveSessions;
+    sendNotification: typeof sendNotification;
+    sendNotificationToSession: typeof sendNotificationToSession;
     /**
-     * Register a UI widget as both a tool and a resource
-     *
-     * Creates a unified interface for MCP-UI compatible widgets that can be accessed
-     * either as tools (with parameters) or as resources (static access). The tool
-     * allows dynamic parameter passing while the resource provides discoverable access.
+     * Notify subscribed clients that a resource has been updated
      *
-     * Supports multiple UI resource types:
-     * - externalUrl: Legacy MCP-UI iframe-based widgets
-     * - rawHtml: Legacy MCP-UI raw HTML content
-     * - remoteDom: Legacy MCP-UI Remote DOM scripting
-     * - appsSdk: OpenAI Apps SDK compatible widgets (text/html+skybridge)
+     * This method sends a `notifications/resources/updated` notification to all
+     * sessions that have subscribed to the specified resource URI.
      *
-     * @param widgetNameOrDefinition - Widget name (string) for auto-loading schema, or full configuration object
-     * @param definition.name - Unique identifier for the resource
-     * @param definition.type - Type of UI resource (externalUrl, rawHtml, remoteDom, appsSdk)
-     * @param definition.title - Human-readable title for the widget
-     * @param definition.description - Description of the widget's functionality
-     * @param definition.props - Widget properties configuration with types and defaults
-     * @param definition.size - Preferred iframe size [width, height] (e.g., ['900px', '600px'])
-     * @param definition.annotations - Resource annotations for discovery
-     * @param definition.appsSdkMetadata - Apps SDK specific metadata (CSP, widget description, etc.)
-     * @returns The server instance for method chaining
+     * @param uri - The URI of the resource that changed
+     * @returns Promise that resolves when all notifications have been sent
      *
      * @example
      * ```typescript
-     * // Simple usage - auto-loads from generated schema
-     * server.uiResource('display-weather')
-     *
-     * // Legacy MCP-UI widget
-     * server.uiResource({
-     *   type: 'externalUrl',
-     *   name: 'kanban-board',
-     *   widget: 'kanban-board',
-     *   title: 'Kanban Board',
-     *   description: 'Interactive task management board',
-     *   props: {
-     *     initialTasks: {
-     *       type: 'array',
-     *       description: 'Initial tasks to display',
-     *       required: false
-     *     }
-     *   },
-     *   size: ['900px', '600px']
-     * })
-     *
-     * // Apps SDK widget
-     * server.uiResource({
-     *   type: 'appsSdk',
-     *   name: 'kanban-board',
-     *   title: 'Kanban Board',
-     *   description: 'Interactive task management board',
-     *   htmlTemplate: `
-     *     <div id="kanban-root"></div>
-     *     <style>${kanbanCSS}</style>
-     *     <script type="module">${kanbanJS}</script>
-     *   `,
-     *   appsSdkMetadata: {
-     *     'openai/widgetDescription': 'Displays an interactive kanban board',
-     *     'openai/widgetCSP': {
-     *       connect_domains: [],
-     *       resource_domains: ['https://cdn.example.com']
-     *     }
-     *   }
-     * })
+     * // After updating a resource, notify subscribers
+     * await server.notifyResourceUpdated("file:///path/to/resource.txt");
      * ```
      */
-    uiResource(definition: UIResourceDefinition): this;
-    /**
-     * Create a UIResource object for a widget with the given parameters
-     *
-     * This method is shared between tool and resource handlers to avoid duplication.
-     * It creates a consistent UIResource structure that can be rendered by MCP-UI
-     * compatible clients.
-     *
-     * @private
-     * @param definition - UIResource definition
-     * @param params - Parameters to pass to the widget via URL
-     * @returns UIResource object compatible with MCP-UI
-     */
-    private createWidgetUIResource;
-    /**
-     * Generate a widget URI with optional build ID for cache busting
-     *
-     * @private
-     * @param widgetName - Widget name/identifier
-     * @param extension - Optional file extension (e.g., '.html')
-     * @param suffix - Optional suffix (e.g., random ID for dynamic URIs)
-     * @returns Widget URI with build ID if available
-     */
-    private generateWidgetUri;
-    /**
-     * Convert widget props definition to tool input schema
-     *
-     * Transforms the widget props configuration into the format expected by
-     * the tool registration system, mapping types and handling defaults.
-     *
-     * @private
-     * @param props - Widget props configuration
-     * @returns Array of InputDefinition objects for tool registration
-     */
-    private convertPropsToInputs;
-    /**
-     * Apply default values to widget props
-     *
-     * Extracts default values from the props configuration to use when
-     * the resource is accessed without parameters.
-     *
-     * @private
-     * @param props - Widget props configuration
-     * @returns Object with default values for each prop
-     */
-    private applyDefaultProps;
-    /**
-     * Check if server is running in production mode
-     *
-     * @private
-     * @returns true if in production mode, false otherwise
-     */
-    private isProductionMode;
-    /**
-     * Read build manifest file
-     *
-     * @private
-     * @returns Build manifest or null if not found
-     */
-    private readBuildManifest;
-    /**
-     * Mount widget files - automatically chooses between dev and production mode
-     *
-     * In development mode: creates Vite dev servers with HMR support
-     * In production mode: serves pre-built static widgets
-     *
-     * @param options - Configuration options
-     * @param options.baseRoute - Base route for widgets (defaults to '/mcp-use/widgets')
-     * @param options.resourcesDir - Directory containing widget files (defaults to 'resources')
-     * @returns Promise that resolves when all widgets are mounted
-     */
-    mountWidgets(options?: {
-        baseRoute?: string;
-        resourcesDir?: string;
-    }): Promise<void>;
-    /**
-     * Mount individual widget files from resources/ directory in development mode
-     *
-     * Scans the resources/ directory for .tsx/.ts widget files and creates individual
-     * Vite dev servers for each widget with HMR support. Each widget is served at its
-     * own route: /mcp-use/widgets/{widget-name}
-     *
-     * @private
-     * @param options - Configuration options
-     * @param options.baseRoute - Base route for widgets (defaults to '/mcp-use/widgets')
-     * @param options.resourcesDir - Directory containing widget files (defaults to 'resources')
-     * @returns Promise that resolves when all widgets are mounted
-     */
-    private mountWidgetsDev;
-    /**
-     * Mount pre-built widgets from dist/resources/widgets/ directory in production mode
-     *
-     * Serves static widget bundles that were built using the build command.
-     * Sets up Express routes to serve the HTML and asset files, then registers
-     * tools and resources for each widget.
-     *
-     * @private
-     * @param options - Configuration options
-     * @param options.baseRoute - Base route for widgets (defaults to '/mcp-use/widgets')
-     * @returns Promise that resolves when all widgets are mounted
-     */
-    private mountWidgetsProduction;
-    /**
-     * Helper to wait for transport.handleRequest to complete and response to be written
-     *
-     * Wraps the transport.handleRequest call in a Promise that only resolves when
-     * expressRes.end() is called, ensuring all async operations complete before
-     * we attempt to read the response.
-     *
-     * @private
-     */
-    private waitForRequestComplete;
+    notifyResourceUpdated(uri: string): Promise<void>;
+    uiResource: any;
     /**
      * Mount MCP server endpoints at /mcp and /sse
      *
      * Sets up the HTTP transport layer for the MCP server, creating endpoints for
      * Server-Sent Events (SSE) streaming, POST message handling, and DELETE session cleanup.
-     * Transports are reused per session ID to maintain state across requests.
+     * The transport manages multiple sessions through a single server instance.
      *
      * This method is called automatically when the server starts listening and ensures
      * that MCP clients can communicate with the server over HTTP.
@@ -630,7 +138,7 @@ export declare class McpServer<HasOAuth extends boolean = false> {
      * The server will be accessible at the specified port with MCP endpoints at /mcp and /sse
      * and inspector UI at /inspector (if the inspector package is installed).
      *
-     * @param port - Port number to listen on (defaults to 3001 if not specified)
+     * @param port - Port number to listen on (defaults to 3000 if not specified)
      * @returns Promise that resolves when the server is successfully listening
      *
      * @example
@@ -645,6 +153,13 @@ export declare class McpServer<HasOAuth extends boolean = false> {
      * Log registered tools, prompts, and resources to console
      */
     private logRegisteredItems;
+    getBuildId(): string | undefined;
+    getServerPort(): number;
+    /**
+     * Create a message for sampling (calling the LLM)
+     * Delegates to the native SDK server
+     */
+    createMessage(params: CreateMessageRequest["params"], options?: any): Promise<CreateMessageResult>;
     listen(port?: number): Promise<void>;
     /**
      * Get the fetch handler for the server after mounting all endpoints
@@ -682,132 +197,8 @@ export declare class McpServer<HasOAuth extends boolean = false> {
     getHandler(options?: {
         provider?: "supabase" | "cloudflare" | "deno-deploy";
     }): Promise<(req: Request) => Promise<Response>>;
-    /**
-     * Get array of active session IDs
-     *
-     * Returns an array of all currently active session IDs. This is useful for
-     * sending targeted notifications to specific clients or iterating over
-     * connected clients.
-     *
-     * Note: This only works in stateful mode. In stateless mode (edge environments),
-     * this will return an empty array.
-     *
-     * @returns Array of active session ID strings
-     *
-     * @example
-     * ```typescript
-     * const sessions = server.getActiveSessions();
-     * console.log(`${sessions.length} clients connected`);
-     *
-     * // Send notification to first connected client
-     * if (sessions.length > 0) {
-     *   server.sendNotificationToSession(sessions[0], "custom/hello", { message: "Hi!" });
-     * }
-     * ```
-     */
-    getActiveSessions(): string[];
-    /**
-     * Send a notification to all connected clients
-     *
-     * Broadcasts a JSON-RPC notification to all active sessions. Notifications are
-     * one-way messages that do not expect a response from the client.
-     *
-     * Note: This only works in stateful mode with active sessions. If no sessions
-     * are connected, the notification is silently discarded (per MCP spec: "server MAY send").
-     *
-     * @param method - The notification method name (e.g., "custom/my-notification")
-     * @param params - Optional parameters to include in the notification
-     *
-     * @example
-     * ```typescript
-     * // Send a simple notification to all clients
-     * server.sendNotification("custom/server-status", {
-     *   status: "ready",
-     *   timestamp: new Date().toISOString()
-     * });
-     *
-     * // Notify all clients that resources have changed
-     * server.sendNotification("notifications/resources/list_changed");
-     * ```
-     */
-    sendNotification(method: string, params?: Record<string, unknown>): Promise<void>;
-    /**
-     * Send a notification to a specific client session
-     *
-     * Sends a JSON-RPC notification to a single client identified by their session ID.
-     * This allows sending customized notifications to individual clients.
-     *
-     * Note: This only works in stateful mode. If the session ID doesn't exist,
-     * the notification is silently discarded.
-     *
-     * @param sessionId - The target session ID (from getActiveSessions())
-     * @param method - The notification method name (e.g., "custom/my-notification")
-     * @param params - Optional parameters to include in the notification
-     * @returns true if the notification was sent, false if session not found
-     *
-     * @example
-     * ```typescript
-     * const sessions = server.getActiveSessions();
-     *
-     * // Send different messages to different clients
-     * sessions.forEach((sessionId, index) => {
-     *   server.sendNotificationToSession(sessionId, "custom/welcome", {
-     *     message: `Hello client #${index + 1}!`,
-     *     clientNumber: index + 1
-     *   });
-     * });
-     * ```
-     */
-    sendNotificationToSession(sessionId: string, method: string, params?: Record<string, unknown>): Promise<boolean>;
-    private onRootsChangedCallback?;
-    /**
-     * Register a callback for when a client's roots change
-     *
-     * When a client sends a `notifications/roots/list_changed` notification,
-     * the server will automatically request the updated roots list and call
-     * this callback with the new roots.
-     *
-     * @param callback - Function called with the updated roots array
-     *
-     * @example
-     * ```typescript
-     * server.onRootsChanged(async (roots) => {
-     *   console.log("Client roots updated:", roots);
-     *   roots.forEach(root => {
-     *     console.log(`  - ${root.name || "unnamed"}: ${root.uri}`);
-     *   });
-     * });
-     * ```
-     */
-    onRootsChanged(callback: (roots: Array<{
-        uri: string;
-        name?: string;
-    }>) => void | Promise<void>): this;
-    /**
-     * Request the current roots list from a specific client session
-     *
-     * This sends a `roots/list` request to the client and returns
-     * the list of roots the client has configured.
-     *
-     * @param sessionId - The session ID of the client to query
-     * @returns Array of roots, or null if the session doesn't exist or request fails
-     *
-     * @example
-     * ```typescript
-     * const sessions = server.getActiveSessions();
-     * if (sessions.length > 0) {
-     *   const roots = await server.listRoots(sessions[0]);
-     *   if (roots) {
-     *     console.log(`Client has ${roots.length} roots:`);
-     *     roots.forEach(r => console.log(`  - ${r.uri}`));
-     *   }
-     * }
-     * ```
-     */
-    listRoots(sessionId: string): Promise<Array<{
-        uri: string;
-        name?: string;
-    }> | null>;
+    onRootsChanged: typeof onRootsChanged;
+    listRoots: typeof listRoots;
     /**
      * Mount MCP Inspector UI at /inspector
      *
@@ -831,78 +222,8 @@ export declare class McpServer<HasOAuth extends boolean = false> {
      * - No inspector UI available
      */
     private mountInspector;
-    /**
-     * Setup default widget serving routes
-     *
-     * Configures Hono routes to serve MCP UI widgets and their static assets.
-     * Widgets are served from the dist/resources/widgets directory and can
-     * be accessed via HTTP endpoints for embedding in web applications.
-     *
-     * Routes created:
-     * - GET /mcp-use/widgets/:widget - Serves widget's index.html
-     * - GET /mcp-use/widgets/:widget/assets/* - Serves widget-specific assets
-     * - GET /mcp-use/widgets/assets/* - Fallback asset serving with auto-discovery
-     *
-     * @private
-     * @returns void
-     *
-     * @example
-     * Widget routes:
-     * - http://localhost:3001/mcp-use/widgets/kanban-board
-     * - http://localhost:3001/mcp-use/widgets/todo-list/assets/style.css
-     * - http://localhost:3001/mcp-use/widgets/assets/script.js (auto-discovered)
-     */
-    private setupWidgetRoutes;
-    /**
-     * Convert a Zod object schema to the internal Record<string, z.ZodSchema> format
-     *
-     * @param zodSchema - Zod object schema to convert
-     * @returns Object mapping parameter names to Zod validation schemas
-     */
-    private convertZodSchemaToParams;
-    /**
-     * Create input schema for tools
-     *
-     * Converts tool input definitions into Zod validation schemas for runtime validation.
-     * Supports common data types (string, number, boolean, object, array) and optional
-     * parameters. Used internally when registering tools with the MCP server.
-     *
-     * @param inputs - Array of input parameter definitions with name, type, and optional flag
-     * @returns Object mapping parameter names to Zod validation schemas
-     *
-     * @example
-     * ```typescript
-     * const schema = this.createParamsSchema([
-     *   { name: 'query', type: 'string', required: true, description: 'Search query' },
-     *   { name: 'limit', type: 'number', required: false }
-     * ])
-     * // Returns: { query: z.string().describe('Search query'), limit: z.number().optional() }
-     * ```
-     */
-    private createParamsSchema;
-    /**
-     * Parse parameter values from a URI based on a template
-     *
-     * Extracts parameter values from an actual URI by matching it against a URI template.
-     * The template contains placeholders like {param} which are extracted as key-value pairs.
-     *
-     * @param template - URI template with placeholders (e.g., "user://{userId}/posts/{postId}")
-     * @param uri - Actual URI to parse (e.g., "user://123/posts/456")
-     * @returns Object mapping parameter names to their values
-     *
-     * @example
-     * ```typescript
-     * const params = this.parseTemplateUri("user://{userId}/posts/{postId}", "user://123/posts/456")
-     * // Returns: { userId: "123", postId: "456" }
-     * ```
-     */
-    private parseTemplateUri;
 }
-export type McpServerInstance<HasOAuth extends boolean = false> = Omit<McpServer<HasOAuth>, keyof HonoType> & HonoType & {
-    getHandler: (options?: {
-        provider?: "supabase" | "cloudflare" | "deno-deploy";
-    }) => Promise<(req: Request) => Promise<Response>>;
-};
+export type McpServerInstance = McpServer & HonoType;
 /**
  * Create a new MCP server instance
  *
@@ -951,6 +272,6 @@ export type McpServerInstance<HasOAuth extends boolean = false> = Omit<McpServer
  */
 export declare function createMCPServer(name: string, config: Partial<ServerConfig> & {
     oauth: NonNullable<ServerConfig["oauth"]>;
-}): McpServerInstance<true>;
-export declare function createMCPServer(name: string, config?: Partial<ServerConfig>): McpServerInstance<false>;
+}): McpServerInstance;
+export declare function createMCPServer(name: string, config?: Partial<ServerConfig>): McpServerInstance;
 //# sourceMappingURL=mcp-server.d.ts.map