@ttoss/http-server-mcp 0.27.1 → 0.28.1

package/MIGRATIONS.md

@@ -1,5 +1,40 @@
 # Migrations
 
+## The `2026-07-28` revision needs `createMcpServer`
+
+That revision is served only when `createMcpRouter` is given a
+`createMcpServer` factory.
+
+```diff
++const buildServer = () => {
++  const mcpServer = new McpServer({ name: 'my-server', version: '1.0.0' });
++  registerEverything(mcpServer);
++  return mcpServer;
++};
++
+-createMcpRouter(mcpServer, {
++createMcpRouter(buildServer(), {
++  createMcpServer: buildServer,
+   auth: { ... },
+ });
+```
+
+**Why it cannot default to the server you already pass.** The negotiated
+revision is instance state: serving one `2026-07-28` request marks that
+`McpServer` modern for good, and it then validates every later message against
+that revision. One instance serving both eras is pinned by the first client to
+speak the newer one, after which every 2025-era request is answered
+`-32602 Request is missing the required _meta envelope for protocol revision
+2026-07-28` at **HTTP 200** for the life of the process — a status and body a
+client reads as "no tools" rather than as a fault. The SDK's own serving
+entries take a factory and call it once per request for this reason.
+
+**What you will observe if you miss this.** A client speaking `2026-07-28` gets
+`400` with `-32022 Unsupported protocol version` and `data.supported` listing
+the 2025-era revisions, which it can renegotiate from. Only deployments
+actually receiving that traffic are affected; every client without the
+per-request envelope is served exactly as before.
+
 ## `tools/list` is no longer public by default
 
 `auth.publicMethods` now defaults to `['initialize']` instead of

package/README.md

@@ -478,6 +478,78 @@ register({
 
 **`buildContext`** injects request-scoped values (DB clients, tenant IDs) into every handler call without threading them through each individual tool. It receives the full `ToolCallContext` so context can vary by identity or by call args.
 
+## MCP Apps (interactive UIs)
+
+The [`io.modelcontextprotocol/ui`](https://github.com/modelcontextprotocol/ext-apps) extension lets a tool result render as an interactive view instead of text. The view is a `ui://` resource holding an HTML document, which the host loads into a sandboxed iframe and talks to over `postMessage`; the tool points at it through its `_meta`.
+
+The extension asks nothing of the transport, so `createMcpRouter` serves it as-is on both protocol revisions. `registerAppResource` owns the parts that are easy to get wrong — the `ui://` scheme, the exact MIME type, `_meta.ui` on both the declaration and the read result, and the deprecated flat linkage key that is still legal until the extension reaches GA.
+
+```typescript
+import {
+  McpServer,
+  registerAppResource,
+  UI_EXTENSION_ID,
+  UI_RESOURCE_MIME_TYPE,
+  z,
+} from '@ttoss/http-server-mcp';
+
+const server = new McpServer(
+  { name: 'weather', version: '1.0.0' },
+  {
+    capabilities: {
+      extensions: { [UI_EXTENSION_ID]: { mimeTypes: [UI_RESOURCE_MIME_TYPE] } },
+    },
+  }
+);
+
+const dashboard = registerAppResource({
+  server,
+  name: 'weather_dashboard',
+  uri: 'ui://weather/dashboard',
+  description: 'Interactive weather dashboard',
+  html: dashboardHtml, // a string, or ({ uri }) => string built per read
+  ui: {
+    csp: { connectDomains: ['https://api.openweathermap.org'] },
+    prefersBorder: true,
+  },
+});
+
+server.registerTool(
+  'get-weather',
+  {
+    description: 'Get the weather for a location',
+    inputSchema: { location: z.string() },
+    _meta: dashboard.toolMeta(),
+  },
+  async ({ location }) => {
+    const forecast = await fetchForecast(location);
+    return {
+      // Text stays meaningful: it is what a host without Apps renders.
+      content: [{ type: 'text', text: summarise(forecast) }],
+      structuredContent: forecast,
+    };
+  }
+);
+```
+
+`toolMeta()` is the linkage for **every** registration path — `registerTool`, [`registerToolFromSchema`](#registertoolfromschemaserver-params), and a [`GatedToolDef`](#creategatedtoolregistraroptions) all take `_meta`:
+
+```typescript
+registerToolFromSchema(server, {
+  name: 'refresh-dashboard',
+  description: 'Refresh dashboard data',
+  // Callable by the view, hidden from the model.
+  _meta: dashboard.toolMeta({ visibility: ['app'] }),
+  handler: async () => ({ content: [{ type: 'text', text: 'refreshed' }] }),
+});
+```
+
+### Register the linkage unconditionally
+
+The spec suggests checking the client's declared capability before registering UI-enabled tools. Do not: that read is only reliable on the `2026-07-28` revision, where the capability arrives in each request's envelope. In this package's default [stateless mode](#stateless-vs-stateful-mode) there is no remembered `initialize` for a 2025-era client, so a capability-gated registration silently drops the view for every one of them.
+
+Declaring it always is also strictly more compatible — a host without Apps support ignores `_meta` and renders the tool's `content`, which is the extension's own graceful-degradation contract. Keep every tool's text result meaningful on its own and the fallback takes care of itself.
+
 ## Issuing tokens for MCP clients
 
 The `auth` option above covers the **resource-server** half of MCP authorization — it verifies tokens issued by an external authorization server (Cognito, Auth0, …). To make your own first-party server _issue_ the tokens an MCP client runs the full OAuth flow against, add the [`@ttoss/http-server-auth`](https://ttoss.dev/docs/modules/packages/http-server-auth) plugin's `oauthServer()` and pair it with `createMcpRouter({ auth: { verifyToken } })` so one deployment both issues and verifies tokens. See the [OAuth Authorization Server](https://ttoss.dev/docs/engineering/guidelines/oauth-authorization-server) guideline.
@@ -582,6 +654,7 @@ The `GatedToolDef` passed to `register` has:
 - `requiredScope` — Single scope that must appear in `identity.scopes`.
 - `inputSchema` — Zod field map or `ZodObject`, forwarded to `server.registerTool`.
 - `gates` (`Array<(ctx: ToolCallContext) => void | Promise<void>>`, optional) — Per-tool guards appended after the global `gates`. Receive the full `ToolCallContext` enabling arg-conditional authorization.
+- `_meta` (`Record<string, unknown>`, optional) — Tool metadata forwarded verbatim on `tools/list`; how a gated tool links to an [MCP Apps](#mcp-apps-interactive-uis) view.
 - `method` — Async handler. Receives merged call args + `buildContext` output.
 
 **`ToolCallContext`** is the object passed to gates, `buildContext`, and `onError`:
@@ -590,6 +663,33 @@ The `GatedToolDef` passed to `register` has:
 - `args` (`Record<string, unknown>`) — The validated tool input (post SDK parse).
 - `handler` (`string`) — The tool name, for error attribution.
 
+### `registerAppResource(params)`
+
+Registers an [MCP Apps](#mcp-apps-interactive-uis) view: a `ui://` resource whose HTML a host renders for a linked tool's result.
+
+**Parameters (`params`):**
+
+- `server` (`McpServer`) — The MCP server to register the resource on.
+- `name` (`string`) — Resource name, as listed by `resources/list`.
+- `uri` (`string`) — Resource URI. Must use the `ui://` scheme, or the call throws.
+- `description` (`string`, optional) — What the view does and when a host should render it.
+- `html` (`string | ({ uri: URL }) => string | Promise<string>`) — The view's HTML5 document, or a builder invoked per `resources/read`.
+- `ui` (`UiResourceMeta`, optional) — Rendering and security configuration relayed to the host as `_meta.ui`:
+  - `csp` (`UiResourceCsp`) — Origins the view may reach, mapped onto the iframe's Content Security Policy: `connectDomains` (`connect-src`), `resourceDomains` (scripts/styles/images/fonts/media), `frameDomains` (`frame-src`), `baseUriDomains` (`base-uri`). An omitted list is the restrictive default, not "no restriction".
+  - `permissions` (`UiResourcePermissions`) — Browser capabilities requested for the view (`camera`, `microphone`, `geolocation`, `clipboardWrite`), each as `{}`. A host _may_ grant them, so feature-detect in the view rather than assuming.
+  - `domain` (`string`) — Dedicated sandbox origin, for views needing a stable one (OAuth callbacks, CORS, API key allowlists). The format is host-specific.
+  - `prefersBorder` (`boolean`) — Whether the host should draw a border and background around the view.
+
+**Returns:** `RegisteredAppResource`
+
+- `uri` (`string`) — The URI tools link to.
+- `resource` (`RegisteredResource`) — The SDK's registration handle, for `update`/`disable`/`remove`.
+- `toolMeta(params?)` — Builds the `_meta` bag linking a tool to this view, writing both `_meta.ui.resourceUri` and the deprecated flat `_meta['ui/resourceUri']`. Takes `visibility` (`Array<'model' | 'app'>`, optional — the spec's default is both) and `_meta` (`Record<string, unknown>`, optional) to merge further entries in.
+
+### `UI_EXTENSION_ID` / `UI_RESOURCE_MIME_TYPE`
+
+`'io.modelcontextprotocol/ui'` and `'text/html;profile=mcp-app'`. Use the first as the `capabilities.extensions` key when advertising Apps support on the `McpServer`, and the second as the MIME type a host negotiates.
+
 ### `registerToolFromSchema(server, params)`
 
 Registers a tool using a **plain JSON Schema** object for `inputSchema` instead of a Zod shape.
@@ -603,6 +703,7 @@ Use this when tool definitions are shared between the MCP server and an AI SDK a
 - `params.description` (`string`, optional) — Human-readable description
 - `params.inputSchema` (`JsonObjectSchema`, optional) — Plain JSON Schema object (defaults to `{ type: 'object', properties: {} }`)
 - `params.validateArguments` (`boolean`, optional) — Enforce `inputSchema` on `tools/call` (default: `false`); see [Argument validation](#argument-validation)
+- `params._meta` (`Record<string, unknown>`, optional) — Tool metadata forwarded verbatim on `tools/list`; how a tool links to an [MCP Apps](#mcp-apps-interactive-uis) view
 - `params.handler` (`(args: Record<string, unknown>) => CallToolResult | Promise<CallToolResult>`) — Tool handler receiving the raw request arguments
 
 **Returns:** `void`
@@ -805,7 +906,27 @@ app.listen(3000);
 
 This package implements the [Model Context Protocol](https://spec.modelcontextprotocol.io/) over HTTP using JSON responses (no SSE streaming), and serves each request over the protocol revision it actually speaks.
 
-Requests are classified once at the boundary. Traffic from today's MCP clients is served over `NodeStreamableHTTPServerTransport` with `enableJsonResponse: true`, adapting Koa's context-based middleware to the SDK's Node.js request/response expectations. Requests carrying the `2026-07-28` revision's per-request envelope are served by that revision's stateless core (`createMcpHandler`) instead. Both paths are served from the same `McpServer` instance and the same registered tools, so supporting the newer revision requires no configuration.
+Requests are classified once at the boundary, and the classifier's answer is three-way. Traffic from today's MCP clients is served over `NodeStreamableHTTPServerTransport` with `enableJsonResponse: true`, adapting Koa's context-based middleware to the SDK's Node.js request/response expectations. Requests carrying the `2026-07-28` revision's per-request envelope are served by that revision's stateless core (`createMcpHandler`). Requests the classifier refuses outright are answered with its own rejection — the status, code, message and data it chose — rather than passed to either era's handler.
+
+### Serving the `2026-07-28` revision
+
+Set `createMcpServer` to a factory returning an `McpServer` with the same tools registered:
+
+```typescript
+const buildServer = () => {
+  const mcpServer = new McpServer({ name: 'my-server', version: '1.0.0' });
+  registerEverything(mcpServer);
+  return mcpServer;
+};
+
+const mcpRouter = createMcpRouter(buildServer(), {
+  createMcpServer: buildServer,
+});
+```
+
+It has to be a factory, and cannot default to the server the router was given, because the negotiated revision is instance state: serving one `2026-07-28` request marks that `McpServer` modern for good, and it then validates every later message against that revision. One instance serving both eras is pinned by the first client to speak the newer one, after which every 2025-era request is answered `-32602 Request is missing the required _meta envelope…` at HTTP 200 for the life of the process. The SDK's own serving entries take a factory and call it once per request for the same reason.
+
+Without `createMcpServer`, `2026-07-28` requests get the unsupported-protocol-version error listing the revisions this endpoint does serve, so that client renegotiates and no other client is affected.
 
 **Supported HTTP methods:**
 
@@ -954,3 +1075,4 @@ newest first.
 - [MCP Documentation](https://modelcontextprotocol.io)
 - [MCP Specification](https://spec.modelcontextprotocol.io/)
 - [MCP SDK TypeScript](https://github.com/modelcontextprotocol/typescript-sdk)
+- [MCP Apps extension (`io.modelcontextprotocol/ui`)](https://github.com/modelcontextprotocol/ext-apps)

package/dist/index.cjs

@@ -36,41 +36,88 @@ var header = (ctx, name) => {
   const value = ctx.get(name);
   return value === "" ? void 0 : value;
 };
+/** The id to echo in an error answer, by the SDK's own rule. */
+var echoableRequestId = body => {
+  if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+  const {
+    id,
+    method
+  } = body;
+  if (typeof method !== "string") return null;
+  return typeof id === "string" || typeof id === "number" ? id : null;
+};
+/**
+* Writes a JSON-RPC error straight to the Node response: `createMcpRouter` sets
+* `ctx.respond = false` after serving, so Koa never writes `ctx.body`.
+*/
+var emitJsonRpcError = (ctx, answer, body) => {
+  ctx.res.writeHead(answer.httpStatus, {
+    "content-type": "application/json"
+  });
+  ctx.res.end(JSON.stringify({
+    jsonrpc: "2.0",
+    error: {
+      code: answer.code,
+      message: answer.message,
+      ...(answer.data !== void 0 && {
+        data: answer.data
+      })
+    },
+    id: echoableRequestId(body)
+  }));
+};
+/** The SDK's own ladder rejection, emitted with the status the SDK chose. */
+var rejectionAnswer = rejection => {
+  return {
+    httpStatus: rejection.httpStatus,
+    code: rejection.code,
+    message: rejection.message,
+    ...(rejection.data !== void 0 && {
+      data: rejection.data
+    })
+  };
+};
+/**
+* The answer to `2026-07-28` traffic without `createMcpServer`. `data.supported`
+* is what lets the client renegotiate onto a revision this endpoint serves.
+*/
+var REVISION_NOT_SERVED_ANSWER = {
+  httpStatus: 400,
+  code: _modelcontextprotocol_server.ProtocolErrorCode.UnsupportedProtocolVersion,
+  message: "Unsupported protocol version: this endpoint serves the 2025-era MCP revisions only. Pass createMcpServer to createMcpRouter to serve protocol revision 2026-07-28.",
+  data: {
+    supported: [..._modelcontextprotocol_server.SUPPORTED_PROTOCOL_VERSIONS]
+  }
+};
 /**
 * Builds the per-request serving function used by `createMcpRouter`, routing
-* each request to the protocol revision it actually speaks.
-*
-* Requests are classified once at the boundary with the SDK's own
-* `classifyInboundRequest`:
-*
-* - **2025-era traffic** (everything without a `2026-07-28` per-request
-*   envelope — which is all traffic from today's MCP clients) is served over
-*   `NodeStreamableHTTPServerTransport` with `enableJsonResponse: true`, the
-*   same wiring and the same plain-JSON responses this package has always
-*   produced.
-* - **`2026-07-28` traffic** is served by `createMcpHandler` with
-*   `legacy: 'reject'`, so the modern revision is handled by the SDK's
-*   stateless core rather than the transport above. Malformed requests are
-*   routed here too, so the SDK emits its own spec-defined rejection instead of
-*   this package inventing one.
-*
-* Splitting on the classifier — instead of letting `createMcpHandler` serve
-* both eras through its built-in legacy fallback — is what keeps 2025-era
-* responses byte-compatible. That fallback constructs its transport with only
-* `sessionIdGenerator: undefined` and no way to pass `enableJsonResponse`, so
-* every response it produces is SSE-framed (`text/event-stream`) regardless of
-* the handler's `responseMode`. Owning the legacy branch keeps `application/json`.
+* each request by the SDK's three-way `classifyInboundRequest` outcome.
+*
+* **Why the modern era needs `createMcpServer` rather than the `server` above.**
+* The negotiated revision is *instance* state: the SDK marks an instance modern
+* when it serves one modern request, and it then validates every later message
+* against `2026-07-28` — there is no per-request era consult. One instance
+* serving both eras is therefore pinned by the first client to speak the newer
+* revision, after which every 2025-era request is answered `-32602 Request is
+* missing the required _meta envelope…` at HTTP 200 for the life of the
+* process. The SDK's own entries take a factory and call it per request for
+* this reason (they also `close()` the instance, which a shared one cannot
+* survive). Without the factory, `2026-07-28` traffic gets
+* {@link REVISION_NOT_SERVED_ANSWER} and no other client is affected.
+*
+* **Why not `createMcpHandler`'s built-in legacy fallback.** It constructs its
+* transport with no way to pass `enableJsonResponse`, so every response it
+* produces is SSE-framed. Owning the legacy branch keeps `application/json`.
 */
 var createMcpRequestServer = ({
+  createMcpServer,
   server,
   sessionIdGenerator
 }) => {
   const isStateful = sessionIdGenerator !== void 0;
-  const modernHandler = (0, _modelcontextprotocol_node.toNodeHandler)((0, _modelcontextprotocol_server.createMcpHandler)(() => {
-    return server;
-  }, {
+  const modernHandler = createMcpServer ? (0, _modelcontextprotocol_node.toNodeHandler)((0, _modelcontextprotocol_server.createMcpHandler)(createMcpServer, {
     legacy: "reject"
-  }));
+  })) : void 0;
   let sharedTransport;
   if (isStateful) {
     sharedTransport = new _modelcontextprotocol_node.NodeStreamableHTTPServerTransport({
@@ -87,17 +134,23 @@ var createMcpRequestServer = ({
     statelessQueue = result.catch(() => {});
     return result;
   };
-  const isLegacy = (ctx, body) => {
-    return (0, _modelcontextprotocol_server.classifyInboundRequest)({
+  return async (ctx, body) => {
+    const outcome = (0, _modelcontextprotocol_server.classifyInboundRequest)({
       httpMethod: ctx.method,
       protocolVersionHeader: header(ctx, "mcp-protocol-version"),
       mcpMethodHeader: header(ctx, "mcp-method"),
       mcpNameHeader: header(ctx, "mcp-name"),
       body
-    }).kind === "legacy";
-  };
-  return async (ctx, body) => {
-    if (!isLegacy(ctx, body)) {
+    });
+    if (outcome.kind === "reject") {
+      emitJsonRpcError(ctx, rejectionAnswer(outcome), body);
+      return;
+    }
+    if (outcome.kind === "modern") {
+      if (modernHandler === void 0) {
+        emitJsonRpcError(ctx, REVISION_NOT_SERVED_ANSWER, body);
+        return;
+      }
       await modernHandler(ctx.req, ctx.res, body);
       return;
     }
@@ -120,6 +173,160 @@ var createMcpRequestServer = ({
   };
 };
 
+//#endregion
+//#region src/registerAppResource.ts
+/**
+* Identifier of the MCP Apps extension (`io.modelcontextprotocol/ui`), used as
+* the key under `capabilities.extensions` on both sides of the handshake.
+*
+* A client declares Apps support with it; a server may advertise the same key
+* so a host can discover the support without inspecting tool metadata:
+*
+* ```typescript
+* new McpServer(
+*   { name: 'weather', version: '1.0.0' },
+*   {
+*     capabilities: {
+*       extensions: {
+*         [UI_EXTENSION_ID]: { mimeTypes: [UI_RESOURCE_MIME_TYPE] },
+*       },
+*     },
+*   }
+* );
+* ```
+*/
+var UI_EXTENSION_ID = "io.modelcontextprotocol/ui";
+/** MIME type every MCP Apps HTML resource is served as. */
+var UI_RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+/**
+* Deprecated flat tool metadata key for the linked resource URI. Written
+* alongside `_meta.ui.resourceUri` because both forms are legal until the
+* extension reaches GA, at which point this key is removed from the spec.
+*/
+var LEGACY_RESOURCE_URI_KEY = "ui/resourceUri";
+/**
+* Registers an MCP Apps view: a `ui://` resource a tool result is rendered
+* with, per the `io.modelcontextprotocol/ui` extension.
+*
+* The extension asks nothing of the transport — a view is an ordinary MCP
+* resource, and the tool linkage is ordinary tool `_meta` — so this is
+* registration sugar over `registerResource`, not new protocol surface. What
+* it owns is the part that is easy to get wrong: the `ui://` scheme, the exact
+* MIME type, `_meta.ui` on both the declaration and the read result, and
+* writing the deprecated flat linkage key alongside the current one.
+*
+* **Register the linkage unconditionally.** The extension's negotiation is
+* per-request and only reliably readable on the `2026-07-28` revision; in this
+* package's default stateless 2025-era mode there is no remembered
+* `initialize` to read a client capability from. Gating registration on that
+* capability would therefore silently drop the view for every 2025-era client.
+* A host without Apps support simply ignores `_meta`, so keep each tool's
+* `content` meaningful on its own and let the text result be the fallback.
+*
+* @example
+* ```typescript
+* import {
+*   McpServer,
+*   registerAppResource,
+*   UI_EXTENSION_ID,
+*   UI_RESOURCE_MIME_TYPE,
+*   z,
+* } from '@ttoss/http-server-mcp';
+*
+* const server = new McpServer(
+*   { name: 'weather', version: '1.0.0' },
+*   {
+*     capabilities: {
+*       extensions: { [UI_EXTENSION_ID]: { mimeTypes: [UI_RESOURCE_MIME_TYPE] } },
+*     },
+*   }
+* );
+*
+* const dashboard = registerAppResource({
+*   server,
+*   name: 'weather_dashboard',
+*   uri: 'ui://weather/dashboard',
+*   description: 'Interactive weather dashboard',
+*   html: dashboardHtml,
+*   ui: {
+*     csp: { connectDomains: ['https://api.openweathermap.org'] },
+*     prefersBorder: true,
+*   },
+* });
+*
+* server.registerTool(
+*   'get-weather',
+*   {
+*     description: 'Get the weather for a location',
+*     inputSchema: { location: z.string() },
+*     _meta: dashboard.toolMeta(),
+*   },
+*   async ({ location }) => {
+*     const forecast = await fetchForecast(location);
+*     return {
+*       // Text stays meaningful: it is what a host without Apps renders.
+*       content: [{ type: 'text', text: summarise(forecast) }],
+*       structuredContent: forecast,
+*     };
+*   }
+* );
+* ```
+*/
+var registerAppResource = ({
+  server,
+  name,
+  uri,
+  description,
+  html,
+  ui
+}) => {
+  if (!uri.startsWith("ui://")) throw new Error(`An MCP Apps resource URI must use the ui:// scheme (received "${uri}").`);
+  const meta = ui === void 0 ? void 0 : {
+    ui
+  };
+  const resource = server.registerResource(name, uri, {
+    description,
+    mimeType: UI_RESOURCE_MIME_TYPE,
+    ...(meta === void 0 ? {} : {
+      _meta: meta
+    })
+  }, async requestedUri => {
+    const text = typeof html === "string" ? html : await html({
+      uri: requestedUri
+    });
+    return {
+      contents: [{
+        uri: requestedUri.href,
+        mimeType: UI_RESOURCE_MIME_TYPE,
+        text,
+        ...(meta === void 0 ? {} : {
+          _meta: meta
+        })
+      }]
+    };
+  });
+  const toolMeta = ({
+    visibility,
+    _meta
+  } = {}) => {
+    return {
+      ..._meta,
+      ui: {
+        resourceUri: uri,
+        ...(visibility === void 0 ? {} : {
+          visibility
+        })
+      },
+      [LEGACY_RESOURCE_URI_KEY]: uri
+    };
+  };
+  return {
+    uri,
+    resource,
+    toolMeta
+  };
+};
+
 //#endregion
 //#region src/registerToolFromSchema.ts
 /**
@@ -163,7 +370,7 @@ var toStandardSchema = ({
 *
 * @param server - The `McpServer` instance to register the tool on.
 * @param params - Tool configuration including name, description, inputSchema,
-*   validateArguments, and handler.
+*   validateArguments, `_meta`, and handler.
 *
 * @example
 * ```typescript
@@ -194,14 +401,16 @@ var registerToolFromSchema = (server, params) => {
       properties: {}
     },
     validateArguments = false,
-    handler
+    handler,
+    _meta
   } = params;
   server.registerTool(name, {
     description,
     inputSchema: toStandardSchema({
       inputSchema,
       validateArguments
-    })
+    }),
+    _meta
   }, async args => {
     return handler(args);
   });
@@ -316,7 +525,8 @@ var createGatedToolRegistrar = ({
     };
     server.registerTool(def.name, {
       description: def.description,
-      inputSchema: def.inputSchema
+      inputSchema: def.inputSchema,
+      _meta: def._meta
     }, handler);
   };
   return {
@@ -535,6 +745,7 @@ var createMcpRouter = (server, options = {}) => {
     path = "/mcp",
     aliases = [],
     sessionIdGenerator,
+    createMcpServer,
     apiBaseUrl,
     getApiHeaders,
     auth
@@ -542,7 +753,8 @@ var createMcpRouter = (server, options = {}) => {
   const needsContext = apiBaseUrl !== void 0 || getApiHeaders !== void 0 || auth !== void 0;
   const serveRequest = createMcpRequestServer({
     server,
-    sessionIdGenerator
+    sessionIdGenerator,
+    createMcpServer
   });
   const router = new _ttoss_http_server.Router();
   let authCheck;
@@ -642,11 +854,14 @@ Object.defineProperty(exports, 'McpServer', {
     return _modelcontextprotocol_server.McpServer;
   }
 });
+exports.UI_EXTENSION_ID = UI_EXTENSION_ID;
+exports.UI_RESOURCE_MIME_TYPE = UI_RESOURCE_MIME_TYPE;
 exports.apiCall = apiCall;
 exports.checkScopes = checkScopes;
 exports.createGatedToolRegistrar = createGatedToolRegistrar;
 exports.createMcpRouter = createMcpRouter;
 exports.getIdentity = getIdentity;
+exports.registerAppResource = registerAppResource;
 exports.registerToolFromSchema = registerToolFromSchema;
 Object.defineProperty(exports, 'z', {
   enumerable: true,