mcp-use 1.0.7 → 1.1.0

package/dist/src/server/index.cjs

@@ -95,44 +95,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 (0, import_server.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 (0, import_server.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 (0, import_server.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;
@@ -203,7 +250,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
@@ -218,7 +265,7 @@ var McpServer = class {
    *     audience: ['user'],
    *     priority: 0.8
    *   },
-   *   fn: async () => ({
+   *   readCallback: async () => ({
    *     contents: [{
    *       uri: 'config://app-settings',
    *       mimeType: 'application/json',
@@ -229,7 +276,7 @@ var McpServer = class {
    * ```
    */
   resource(resourceDefinition) {
-    this.server.resource(
+    this.server.registerResource(
       resourceDefinition.name,
       resourceDefinition.uri,
       {
@@ -240,7 +287,7 @@ var McpServer = class {
         annotations: resourceDefinition.annotations
       },
       async () => {
-        return await resourceDefinition.fn();
+        return await resourceDefinition.readCallback();
       }
     );
     return this;
@@ -255,7 +302,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
@@ -267,7 +314,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',
@@ -303,7 +350,7 @@ var McpServer = class {
     if (resourceTemplateDefinition.annotations) {
       metadata.annotations = resourceTemplateDefinition.annotations;
     }
-    this.server.resource(
+    this.server.registerResource(
       resourceTemplateDefinition.name,
       template,
       metadata,
@@ -312,7 +359,7 @@ var McpServer = class {
           resourceTemplateDefinition.resourceTemplate.uriTemplate,
           uri.toString()
         );
-        return await resourceTemplateDefinition.fn(uri, params);
+        return await resourceTemplateDefinition.readCallback(uri, params);
       }
     );
     return this;
@@ -324,11 +371,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
@@ -340,21 +390,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;
@@ -370,7 +430,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
@@ -382,7 +442,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',
@@ -395,12 +455,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;
@@ -412,19 +475,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',
@@ -434,18 +506,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;
@@ -462,8 +557,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,
@@ -472,20 +571,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: [
             {
@@ -496,7 +626,7 @@ var McpServer = class {
             uiResource
           ]
         };
-      }, "fn")
+      }, "cb")
     });
     return this;
   }
@@ -825,6 +955,9 @@ var McpServer = class {
         default:
           zodType = import_zod.z.any();
       }
+      if (input.description) {
+        zodType = zodType.describe(input.description);
+      }
       if (!input.required) {
         zodType = zodType.optional();
       }

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

@@ -1,5 +1,5 @@
 export { createMCPServer, type McpServerInstance } from './mcp-server.js';
 export * from './types/index.js';
 export { buildWidgetUrl, createExternalUrlResource, createRawHtmlResource, createRemoteDomResource, createUIResourceFromDefinition, type UrlConfig } from './adapters/mcp-ui-adapter.js';
-export type { InputDefinition, PromptDefinition, PromptHandler, ResourceDefinition, ResourceHandler, ServerConfig, ToolDefinition, ToolHandler, UIResourceDefinition, ExternalUrlUIResource, RawHtmlUIResource, RemoteDomUIResource, WidgetProps, WidgetConfig, WidgetManifest, DiscoverWidgetsOptions, } from './types/index.js';
+export type { InputDefinition, PromptDefinition, PromptCallback, ResourceDefinition, ReadResourceCallback, ReadResourceTemplateCallback, ServerConfig, ToolDefinition, ToolCallback, UIResourceDefinition, ExternalUrlUIResource, RawHtmlUIResource, RemoteDomUIResource, WidgetProps, WidgetConfig, WidgetManifest, DiscoverWidgetsOptions, } from './types/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAA;AAExB,cAAc,kBAAkB,CAAA;AAGhC,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EACvB,8BAA8B,EAC9B,KAAK,SAAS,EACf,MAAM,8BAA8B,CAAA;AAErC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,cAAc,EACd,WAAW,EAEX,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,sBAAsB,GACvB,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAA;AAExB,cAAc,kBAAkB,CAAA;AAGhC,OAAO,EACL,cAAc,EACd,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EACvB,8BAA8B,EAC9B,KAAK,SAAS,EACf,MAAM,8BAA8B,CAAA;AAErC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,4BAA4B,EAC5B,YAAY,EACZ,cAAc,EACd,YAAY,EAEZ,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,sBAAsB,GACvB,MAAM,kBAAkB,CAAA"}