mcp-use 1.0.6 → 1.1.0

package/dist/src/server/index.js

@@ -57,44 +57,91 @@ function buildWidgetUrl(widget, props, config) {
   return url.toString();
 }
 __name(buildWidgetUrl, "buildWidgetUrl");
-function createExternalUrlResource(uri, iframeUrl, encoding = "text") {
+function createExternalUrlResource(uri, iframeUrl, encoding = "text", adapters, metadata) {
   return createUIResource({
     uri,
     content: { type: "externalUrl", iframeUrl },
-    encoding
+    encoding,
+    adapters,
+    metadata
   });
 }
 __name(createExternalUrlResource, "createExternalUrlResource");
-function createRawHtmlResource(uri, htmlString, encoding = "text") {
+function createRawHtmlResource(uri, htmlString, encoding = "text", adapters, metadata) {
   return createUIResource({
     uri,
     content: { type: "rawHtml", htmlString },
-    encoding
+    encoding,
+    adapters,
+    metadata
   });
 }
 __name(createRawHtmlResource, "createRawHtmlResource");
-function createRemoteDomResource(uri, script, framework = "react", encoding = "text") {
+function createRemoteDomResource(uri, script, framework = "react", encoding = "text", adapters, metadata) {
   return createUIResource({
     uri,
     content: { type: "remoteDom", script, framework },
-    encoding
+    encoding,
+    adapters,
+    metadata
   });
 }
 __name(createRemoteDomResource, "createRemoteDomResource");
+function createAppsSdkResource(uri, htmlTemplate, metadata) {
+  const resource = {
+    uri,
+    mimeType: "text/html+skybridge",
+    text: htmlTemplate
+  };
+  if (metadata && Object.keys(metadata).length > 0) {
+    resource._meta = metadata;
+  }
+  return {
+    type: "resource",
+    resource
+  };
+}
+__name(createAppsSdkResource, "createAppsSdkResource");
 function createUIResourceFromDefinition(definition, params, config) {
-  const uri = `ui://widget/${definition.name}`;
+  const uri = definition.type === "appsSdk" ? `ui://widget/${definition.name}.html` : `ui://widget/${definition.name}`;
   const encoding = definition.encoding || "text";
   switch (definition.type) {
     case "externalUrl": {
       const widgetUrl = buildWidgetUrl(definition.widget, params, config);
-      return createExternalUrlResource(uri, widgetUrl, encoding);
+      return createExternalUrlResource(
+        uri,
+        widgetUrl,
+        encoding,
+        definition.adapters,
+        definition.appsSdkMetadata
+      );
     }
     case "rawHtml": {
-      return createRawHtmlResource(uri, definition.htmlContent, encoding);
+      return createRawHtmlResource(
+        uri,
+        definition.htmlContent,
+        encoding,
+        definition.adapters,
+        definition.appsSdkMetadata
+      );
     }
     case "remoteDom": {
       const framework = definition.framework || "react";
-      return createRemoteDomResource(uri, definition.script, framework, encoding);
+      return createRemoteDomResource(
+        uri,
+        definition.script,
+        framework,
+        encoding,
+        definition.adapters,
+        definition.appsSdkMetadata
+      );
+    }
+    case "appsSdk": {
+      return createAppsSdkResource(
+        uri,
+        definition.htmlTemplate,
+        definition.appsSdkMetadata
+      );
     }
     default: {
       const _exhaustive = definition;
@@ -165,7 +212,7 @@ var McpServer = class {
    * @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.fn - Async function that returns the resource content
+   * @param resourceDefinition.readCallback - Async callback function that returns the resource content
    * @returns The server instance for method chaining
    * 
    * @example
@@ -180,7 +227,7 @@ var McpServer = class {
    *     audience: ['user'],
    *     priority: 0.8
    *   },
-   *   fn: async () => ({
+   *   readCallback: async () => ({
    *     contents: [{
    *       uri: 'config://app-settings',
    *       mimeType: 'application/json',
@@ -191,7 +238,7 @@ var McpServer = class {
    * ```
    */
   resource(resourceDefinition) {
-    this.server.resource(
+    this.server.registerResource(
       resourceDefinition.name,
       resourceDefinition.uri,
       {
@@ -202,7 +249,7 @@ var McpServer = class {
         annotations: resourceDefinition.annotations
       },
       async () => {
-        return await resourceDefinition.fn();
+        return await resourceDefinition.readCallback();
       }
     );
     return this;
@@ -217,7 +264,7 @@ var McpServer = class {
    * @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.fn - Async function that generates resource content from URI and params
+   * @param resourceTemplateDefinition.readCallback - Async callback function that generates resource content from URI and params
    * @returns The server instance for method chaining
    * 
    * @example
@@ -229,7 +276,7 @@ var McpServer = class {
    *     name: 'User Profile',
    *     mimeType: 'application/json'
    *   },
-   *   fn: async (uri, params) => ({
+   *   readCallback: async (uri, params) => ({
    *     contents: [{
    *       uri: uri.toString(),
    *       mimeType: 'application/json',
@@ -265,7 +312,7 @@ var McpServer = class {
     if (resourceTemplateDefinition.annotations) {
       metadata.annotations = resourceTemplateDefinition.annotations;
     }
-    this.server.resource(
+    this.server.registerResource(
       resourceTemplateDefinition.name,
       template,
       metadata,
@@ -274,7 +321,7 @@ var McpServer = class {
           resourceTemplateDefinition.resourceTemplate.uriTemplate,
           uri.toString()
         );
-        return await resourceTemplateDefinition.fn(uri, params);
+        return await resourceTemplateDefinition.readCallback(uri, params);
       }
     );
     return this;
@@ -286,11 +333,14 @@ var McpServer = class {
    * 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 - Human-readable description of what the tool does
    * @param toolDefinition.inputs - Array of input parameter definitions with types and validation
-   * @param toolDefinition.fn - Async function that executes the tool logic with provided parameters
+   * @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)
    * @returns The server instance for method chaining
    * 
    * @example
@@ -302,21 +352,31 @@ var McpServer = class {
    *     { name: 'expression', type: 'string', required: true },
    *     { name: 'precision', type: 'number', required: false }
    *   ],
-   *   fn: async ({ expression, precision = 2 }) => {
+   *   cb: async ({ expression, precision = 2 }) => {
    *     const result = eval(expression)
    *     return { result: Number(result.toFixed(precision)) }
+   *   },
+   *   _meta: {
+   *     'openai/outputTemplate': 'ui://widgets/calculator',
+   *     'openai/toolInvocation/invoking': 'Calculating...',
+   *     'openai/toolInvocation/invoked': 'Calculation complete'
    *   }
    * })
    * ```
    */
   tool(toolDefinition) {
     const inputSchema = this.createToolInputSchema(toolDefinition.inputs || []);
-    this.server.tool(
+    this.server.registerTool(
       toolDefinition.name,
-      toolDefinition.description ?? "",
-      inputSchema,
+      {
+        title: toolDefinition.title,
+        description: toolDefinition.description ?? "",
+        inputSchema,
+        annotations: toolDefinition.annotations,
+        _meta: toolDefinition._meta
+      },
       async (params) => {
-        return await toolDefinition.fn(params);
+        return await toolDefinition.cb(params);
       }
     );
     return this;
@@ -332,7 +392,7 @@ var McpServer = class {
    * @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.fn - Async function that generates the prompt from provided arguments
+   * @param promptDefinition.cb - Async callback function that generates the prompt from provided arguments
    * @returns The server instance for method chaining
    * 
    * @example
@@ -344,7 +404,7 @@ var McpServer = class {
    *     { name: 'language', type: 'string', required: true },
    *     { name: 'focus', type: 'string', required: false }
    *   ],
-   *   fn: async ({ language, focus = 'general' }) => {
+   *   cb: async ({ language, focus = 'general' }) => {
    *     return {
    *       messages: [{
    *         role: 'user',
@@ -357,12 +417,15 @@ var McpServer = class {
    */
   prompt(promptDefinition) {
     const argsSchema = this.createPromptArgsSchema(promptDefinition.args || []);
-    this.server.prompt(
+    this.server.registerPrompt(
       promptDefinition.name,
-      promptDefinition.description ?? "",
-      argsSchema,
+      {
+        title: promptDefinition.title,
+        description: promptDefinition.description ?? "",
+        argsSchema
+      },
       async (params) => {
-        return await promptDefinition.fn(params);
+        return await promptDefinition.cb(params);
       }
     );
     return this;
@@ -374,19 +437,28 @@ var McpServer = class {
    * either as tools (with parameters) or as resources (static access). The tool
    * allows dynamic parameter passing while the resource provides discoverable access.
    *
+   * 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)
+   *
    * @param definition - Configuration for the UI widget
    * @param definition.name - Unique identifier for the resource
-   * @param definition.widget - Widget name (matches directory in dist/resources/mcp-use/widgets)
+   * @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., ['800px', '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
    *
    * @example
    * ```typescript
+   * // Legacy MCP-UI widget
    * server.uiResource({
+   *   type: 'externalUrl',
    *   name: 'kanban-board',
    *   widget: 'kanban-board',
    *   title: 'Kanban Board',
@@ -396,18 +468,41 @@ var McpServer = class {
    *       type: 'array',
    *       description: 'Initial tasks to display',
    *       required: false
-   *     },
-   *     theme: {
-   *       type: 'string',
-   *       default: 'light'
    *     }
    *   },
    *   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']
+   *     }
+   *   }
+   * })
    * ```
    */
   uiResource(definition) {
-    const toolName = definition.type === "externalUrl" ? `ui_${definition.widget}` : `ui_${definition.name}`;
+    let toolName;
+    if (definition.type === "appsSdk") {
+      toolName = definition.name;
+    } else if (definition.type === "externalUrl") {
+      toolName = `ui_${definition.widget}`;
+    } else {
+      toolName = `ui_${definition.name}`;
+    }
     const displayName = definition.title || definition.name;
     let resourceUri;
     let mimeType;
@@ -424,8 +519,12 @@ var McpServer = class {
         resourceUri = `ui://widget/${definition.name}`;
         mimeType = "application/vnd.mcp-ui.remote-dom+javascript";
         break;
+      case "appsSdk":
+        resourceUri = `ui://widget/${definition.name}.html`;
+        mimeType = "text/html+skybridge";
+        break;
       default:
-        throw new Error(`Unsupported UI resource type. Must be one of: externalUrl, rawHtml, remoteDom`);
+        throw new Error(`Unsupported UI resource type. Must be one of: externalUrl, rawHtml, remoteDom, appsSdk`);
     }
     this.resource({
       name: definition.name,
@@ -434,20 +533,51 @@ var McpServer = class {
       description: definition.description,
       mimeType,
       annotations: definition.annotations,
-      fn: /* @__PURE__ */ __name(async () => {
+      readCallback: /* @__PURE__ */ __name(async () => {
         const params = definition.type === "externalUrl" ? this.applyDefaultProps(definition.props) : {};
         const uiResource = this.createWidgetUIResource(definition, params);
         return {
           contents: [uiResource.resource]
         };
-      }, "fn")
+      }, "readCallback")
     });
+    const toolMetadata = {};
+    if (definition.type === "appsSdk" && definition.appsSdkMetadata) {
+      toolMetadata["openai/outputTemplate"] = resourceUri;
+      const toolMetadataFields = [
+        "openai/toolInvocation/invoking",
+        "openai/toolInvocation/invoked",
+        "openai/widgetAccessible",
+        "openai/resultCanProduceWidget"
+      ];
+      for (const field of toolMetadataFields) {
+        if (definition.appsSdkMetadata[field] !== void 0) {
+          toolMetadata[field] = definition.appsSdkMetadata[field];
+        }
+      }
+    }
     this.tool({
       name: toolName,
-      description: definition.description || `Display ${displayName}`,
+      title: definition.title,
+      // For Apps SDK, use title as description to match OpenAI's pizzaz reference implementation
+      description: definition.type === "appsSdk" && definition.title ? definition.title : definition.description || `Display ${displayName}`,
       inputs: this.convertPropsToInputs(definition.props),
-      fn: /* @__PURE__ */ __name(async (params) => {
+      _meta: Object.keys(toolMetadata).length > 0 ? toolMetadata : void 0,
+      cb: /* @__PURE__ */ __name(async (params) => {
         const uiResource = this.createWidgetUIResource(definition, params);
+        if (definition.type === "appsSdk") {
+          return {
+            _meta: toolMetadata,
+            content: [
+              {
+                type: "text",
+                text: `Displaying ${displayName}`
+              }
+            ],
+            // structuredContent will be injected as window.openai.toolOutput by Apps SDK
+            structuredContent: params
+          };
+        }
         return {
           content: [
             {
@@ -458,7 +588,7 @@ var McpServer = class {
             uiResource
           ]
         };
-      }, "fn")
+      }, "cb")
     });
     return this;
   }
@@ -787,6 +917,9 @@ var McpServer = class {
         default:
           zodType = z.any();
       }
+      if (input.description) {
+        zodType = zodType.describe(input.description);
+      }
       if (!input.required) {
         zodType = zodType.optional();
       }

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

@@ -32,7 +32,7 @@ export declare class McpServer {
      * @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.fn - Async function that returns the resource content
+     * @param resourceDefinition.readCallback - Async callback function that returns the resource content
      * @returns The server instance for method chaining
      *
      * @example
@@ -47,7 +47,7 @@ export declare class McpServer {
      *     audience: ['user'],
      *     priority: 0.8
      *   },
-     *   fn: async () => ({
+     *   readCallback: async () => ({
      *     contents: [{
      *       uri: 'config://app-settings',
      *       mimeType: 'application/json',
@@ -68,7 +68,7 @@ export declare class McpServer {
      * @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.fn - Async function that generates resource content from URI and params
+     * @param resourceTemplateDefinition.readCallback - Async callback function that generates resource content from URI and params
      * @returns The server instance for method chaining
      *
      * @example
@@ -80,7 +80,7 @@ export declare class McpServer {
      *     name: 'User Profile',
      *     mimeType: 'application/json'
      *   },
-     *   fn: async (uri, params) => ({
+     *   readCallback: async (uri, params) => ({
      *     contents: [{
      *       uri: uri.toString(),
      *       mimeType: 'application/json',
@@ -98,11 +98,14 @@ export declare class McpServer {
      * 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 - Human-readable description of what the tool does
      * @param toolDefinition.inputs - Array of input parameter definitions with types and validation
-     * @param toolDefinition.fn - Async function that executes the tool logic with provided parameters
+     * @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)
      * @returns The server instance for method chaining
      *
      * @example
@@ -114,9 +117,14 @@ export declare class McpServer {
      *     { name: 'expression', type: 'string', required: true },
      *     { name: 'precision', type: 'number', required: false }
      *   ],
-     *   fn: async ({ expression, precision = 2 }) => {
+     *   cb: async ({ expression, precision = 2 }) => {
      *     const result = eval(expression)
      *     return { result: Number(result.toFixed(precision)) }
+     *   },
+     *   _meta: {
+     *     'openai/outputTemplate': 'ui://widgets/calculator',
+     *     'openai/toolInvocation/invoking': 'Calculating...',
+     *     'openai/toolInvocation/invoked': 'Calculation complete'
      *   }
      * })
      * ```
@@ -133,7 +141,7 @@ export declare class McpServer {
      * @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.fn - Async function that generates the prompt from provided arguments
+     * @param promptDefinition.cb - Async callback function that generates the prompt from provided arguments
      * @returns The server instance for method chaining
      *
      * @example
@@ -145,7 +153,7 @@ export declare class McpServer {
      *     { name: 'language', type: 'string', required: true },
      *     { name: 'focus', type: 'string', required: false }
      *   ],
-     *   fn: async ({ language, focus = 'general' }) => {
+     *   cb: async ({ language, focus = 'general' }) => {
      *     return {
      *       messages: [{
      *         role: 'user',
@@ -164,19 +172,28 @@ export declare class McpServer {
      * either as tools (with parameters) or as resources (static access). The tool
      * allows dynamic parameter passing while the resource provides discoverable access.
      *
+     * 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)
+     *
      * @param definition - Configuration for the UI widget
      * @param definition.name - Unique identifier for the resource
-     * @param definition.widget - Widget name (matches directory in dist/resources/mcp-use/widgets)
+     * @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., ['800px', '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
      *
      * @example
      * ```typescript
+     * // Legacy MCP-UI widget
      * server.uiResource({
+     *   type: 'externalUrl',
      *   name: 'kanban-board',
      *   widget: 'kanban-board',
      *   title: 'Kanban Board',
@@ -186,14 +203,30 @@ export declare class McpServer {
      *       type: 'array',
      *       description: 'Initial tasks to display',
      *       required: false
-     *     },
-     *     theme: {
-     *       type: 'string',
-     *       default: 'light'
      *     }
      *   },
      *   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']
+     *     }
+     *   }
+     * })
      * ```
      */
     uiResource(definition: UIResourceDefinition): this;

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

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/server/mcp-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,oBAAoB,EAIrB,MAAM,kBAAkB,CAAA;AAGzB,OAAgB,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAM/C,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B;;;;;;;;;OASG;gBACS,MAAM,EAAE,YAAY;IAsChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,IAAI;IAkBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gBAAgB,CAAC,0BAA0B,EAAE,0BAA0B,GAAG,IAAI;IA4C9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,IAAI,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAa1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IAahD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,UAAU,CAAC,UAAU,EAAE,oBAAoB,GAAG,IAAI;IAyElD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IAsBtB;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;;;;;;;;;;;;;;;OAmBG;YACW,QAAQ;IAyDtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,qBAAqB;IAmC7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,sBAAsB;IAmC9B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,gBAAgB;CAyBzB;AAED,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,OAAO,CAAA;AAExE;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,iBAAiB,CAOnG"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/server/mcp-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,YAAY,EACZ,cAAc,EACd,oBAAoB,EAIrB,MAAM,kBAAkB,CAAA;AAGzB,OAAgB,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAA;AAM/C,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B;;;;;;;;;OASG;gBACS,MAAM,EAAE,YAAY;IAsChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,IAAI;IAkBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,gBAAgB,CAAC,0BAA0B,EAAE,0BAA0B,GAAG,IAAI;IA4C9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,IAAI,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAmB1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,MAAM,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,IAAI;IAgBhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;IACH,UAAU,CAAC,UAAU,EAAE,oBAAoB,GAAG,IAAI;IAgIlD;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,cAAc;IAsBtB;;;;;;;;;OASG;IACH,OAAO,CAAC,oBAAoB;IAY5B;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAYzB;;;;;;;;;;;;;;;;;;;OAmBG;YACW,QAAQ;IAyDtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa1C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,cAAc;IAqBtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IAsCzB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,qBAAqB;IAwC7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CAAC,sBAAsB;IAmC9B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,gBAAgB;CAyBzB;AAED,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,GAAG,OAAO,CAAA;AAExE;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,OAAO,CAAC,YAAY,CAAM,GAAG,iBAAiB,CAOnG"}

package/dist/src/server/types/index.d.ts

@@ -2,7 +2,7 @@
  * Centralized type exports for MCP server
  */
 export { ServerConfig, InputDefinition, ResourceAnnotations } from './common.js';
-export { ResourceHandler, ResourceTemplateHandler, ResourceTemplateConfig, ResourceTemplateDefinition, ResourceDefinition, UIResourceContent, WidgetProps, UIEncoding, RemoteDomFramework, UIResourceDefinition, ExternalUrlUIResource, RawHtmlUIResource, RemoteDomUIResource, WidgetConfig, WidgetManifest, DiscoverWidgetsOptions } from './resource.js';
-export { ToolHandler, ToolDefinition } from './tool.js';
-export { PromptHandler, PromptDefinition } from './prompt.js';
+export { ReadResourceCallback, ReadResourceTemplateCallback, ResourceTemplateConfig, ResourceTemplateDefinition, ResourceDefinition, UIResourceContent, WidgetProps, UIEncoding, RemoteDomFramework, UIResourceDefinition, ExternalUrlUIResource, RawHtmlUIResource, RemoteDomUIResource, AppsSdkUIResource, WidgetConfig, WidgetManifest, DiscoverWidgetsOptions, AppsSdkMetadata, AppsSdkToolMetadata } from './resource.js';
+export { ToolCallback, ToolDefinition } from './tool.js';
+export { PromptCallback, PromptDefinition } from './prompt.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/server/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,YAAY,EACZ,eAAe,EACf,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAElB,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,sBAAsB,EACvB,MAAM,eAAe,CAAA;AAGtB,OAAO,EACL,WAAW,EACX,cAAc,EACf,MAAM,WAAW,CAAA;AAGlB,OAAO,EACL,aAAa,EACb,gBAAgB,EACjB,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,YAAY,EACZ,eAAe,EACf,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,oBAAoB,EACpB,4BAA4B,EAC5B,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAElB,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,sBAAsB,EAEtB,eAAe,EACf,mBAAmB,EACpB,MAAM,eAAe,CAAA;AAGtB,OAAO,EACL,YAAY,EACZ,cAAc,EACf,MAAM,WAAW,CAAA;AAGlB,OAAO,EACL,cAAc,EACd,gBAAgB,EACjB,MAAM,aAAa,CAAA"}

package/dist/src/server/types/prompt.d.ts

@@ -1,14 +1,16 @@
 import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
 import type { InputDefinition } from './common.js';
-export type PromptHandler = (params: Record<string, any>) => Promise<GetPromptResult>;
+export type PromptCallback = (params: Record<string, any>) => Promise<GetPromptResult>;
 export interface PromptDefinition {
     /** Unique identifier for the prompt */
     name: string;
+    /** Human-readable title for the prompt */
+    title?: string;
     /** Description of what the prompt does */
     description?: string;
     /** Argument definitions */
     args?: InputDefinition[];
-    /** Async function that generates the prompt */
-    fn: PromptHandler;
+    /** Async callback function that generates the prompt */
+    cb: PromptCallback;
 }
 //# sourceMappingURL=prompt.d.ts.map

package/dist/src/server/types/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../src/server/types/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;AAErF,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,2BAA2B;IAC3B,IAAI,CAAC,EAAE,eAAe,EAAE,CAAA;IACxB,+CAA+C;IAC/C,EAAE,EAAE,aAAa,CAAA;CAClB"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../../src/server/types/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;AAEtF,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,0CAA0C;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,2BAA2B;IAC3B,IAAI,CAAC,EAAE,eAAe,EAAE,CAAA;IACxB,wDAAwD;IACxD,EAAE,EAAE,cAAc,CAAA;CACnB"}