skybridge 0.0.0-dev.8eed82d → 0.0.0-dev.8f4a954

package/dist/server/server.d.ts

@@ -1,30 +1,35 @@
-import type { McpUiToolMeta } from "@modelcontextprotocol/ext-apps";
+import { type ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
 import { McpServer as McpServerBase } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { AnySchema, SchemaOutput, ZodRawShapeCompat } from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
-import type { ContentBlock, ServerNotification, ServerRequest, ServerResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
-import type { ErrorRequestHandler, RequestHandler } from "express";
+import type { ContentBlock, Implementation, ServerNotification, ServerRequest, ServerResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
+import { type ErrorRequestHandler, type Express, type RequestHandler } from "express";
 import type { McpExtra, McpExtraFor, McpMethodString, McpMiddlewareFilter, McpMiddlewareFn, McpResultFor, McpTypedMiddlewareFn, McpWildcard } from "./middleware.js";
 export type ToolDef<TInput = unknown, TOutput = unknown, TResponseMetadata = unknown> = {
     input: TInput;
     output: TOutput;
     responseMetadata: TResponseMetadata;
 };
-export type WidgetHostType = "apps-sdk" | "mcp-app";
+export type ViewHostType = "apps-sdk" | "mcp-app";
 export interface ViewCsp {
+    /** Origins for static assets (images, fonts, scripts, styles). */
     resourceDomains?: string[];
+    /** Origins the view may contact via fetch/XHR. */
     connectDomains?: string[];
+    /** Origins allowed for iframe embeds (opts into stricter app review). */
     frameDomains?: string[];
+    /** Origins that can receive openExternal redirects without the safe-link modal. */
     redirectDomains?: string[];
+    /** Origins allowed in `<base href>` tags (mcp-apps only). */
     baseUriDomains?: string[];
 }
-export interface WidgetNameRegistry {
+export interface ViewNameRegistry {
 }
-export type WidgetName = keyof WidgetNameRegistry extends never ? string : keyof WidgetNameRegistry & string;
+export type ViewName = keyof ViewNameRegistry & string;
 export interface ViewConfig {
-    component: WidgetName;
+    component: ViewName;
     description?: string;
-    hosts?: WidgetHostType[];
+    hosts?: ViewHostType[];
     prefersBorder?: boolean;
     domain?: string;
     csp?: ViewCsp;
@@ -37,19 +42,15 @@ export interface KnownToolMeta {
 }
 export type ToolMeta = KnownToolMeta & Record<string, unknown>;
 export type HandlerContent = string | ContentBlock | ContentBlock[];
-type OpenaiToolMeta = {
-    "openai/outputTemplate": string;
-    "openai/widgetAccessible"?: boolean;
-    "openai/toolInvocation/invoking"?: string;
-    "openai/toolInvocation/invoked"?: string;
-};
-/** @see https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/draft/apps.mdx#resource-discovery */
-type McpAppsToolMeta = {
-    ui: McpUiToolMeta;
-};
-type InternalToolMeta = Partial<OpenaiToolMeta & McpAppsToolMeta>;
 /**
  * Type-level marker interface for cross-package type inference.
+ *
+ * Consumers infer tool types via the structural `$types` property rather than
+ * the `McpServer` class generic, because class-generic inference breaks when
+ * `McpServer` comes from different package installations (e.g. a consumer
+ * with its own `skybridge` dep vs. the in-tree workspace version).
+ *
+ * Inspired by tRPC's `_def` pattern and Hono's type markers.
  */
 export interface McpServerTypes<TTools extends Record<string, ToolDef>> {
     readonly tools: TTools;
@@ -75,7 +76,7 @@ type ExtractMeta<T> = [Extract<T, {
 type AddTool<TTools, TName extends string, TInput extends ZodRawShapeCompat, TOutput, TResponseMetadata = unknown> = McpServer<TTools & {
     [K in TName]: ToolDef<ShapeOutput<TInput>, TOutput, TResponseMetadata>;
 }>;
-interface UnifiedToolConfig<TInput extends ZodRawShapeCompat | AnySchema> {
+interface ToolConfig<TInput extends ZodRawShapeCompat | AnySchema> {
     name: string;
     title?: string;
     description?: string;
@@ -86,61 +87,110 @@ interface UnifiedToolConfig<TInput extends ZodRawShapeCompat | AnySchema> {
     _meta?: ToolMeta;
 }
 type ToolHandler<TInput extends ZodRawShapeCompat, TReturn extends {
-    content: HandlerContent;
+    content?: HandlerContent;
 } = {
-    content: HandlerContent;
+    content?: HandlerContent;
 }> = (args: ShapeOutput<TInput>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => TReturn | Promise<TReturn>;
-export declare function normalizeContent(content: HandlerContent): ContentBlock[];
+export declare function normalizeContent(content: HandlerContent | undefined): ContentBlock[];
 interface McpServerBaseOmitted extends Omit<McpServerBase, "registerTool" | "connect"> {
 }
 declare const McpServerBaseOmitted: new (...args: ConstructorParameters<typeof McpServerBase>) => McpServerBaseOmitted;
 export declare class McpServer<TTools extends Record<string, ToolDef> = Record<never, ToolDef>> extends McpServerBaseOmitted {
     readonly $types: McpServerTypes<TTools>;
-    private express?;
-    private customMiddleware;
+    /**
+     * The underlying Express app. Use this to extend the HTTP server with
+     * custom routes, middleware, or settings — e.g.
+     * `server.express.get("/health", ...)`.
+     *
+     * `express.json()` is pre-applied. Register your handlers before `run()`;
+     * after `run()`, dev-mode middleware, the `/mcp` route, and the default
+     * error handler are appended in that order.
+     *
+     * Note: Alpic Cloud only routes traffic to `/mcp` — custom routes work
+     * locally and on self-hosted deployments.
+     */
+    readonly express: Express;
     private customErrorMiddleware;
     private mcpMiddlewareEntries;
     private mcpMiddlewareApplied;
-    private claimedWidgets;
+    private claimedViews;
+    private viteManifest;
+    private readonly serverInfo;
+    private readonly serverOptions?;
+    constructor(serverInfo: Implementation, options?: ServerOptions);
     use(...handlers: RequestHandler[]): this;
     use(path: string, ...handlers: RequestHandler[]): this;
     useOnError(...handlers: ErrorRequestHandler[]): this;
     useOnError(path: string, ...handlers: ErrorRequestHandler[]): this;
+    /** Register MCP protocol-level middleware (catch-all). */
     mcpMiddleware(handler: McpMiddlewareFn): this;
+    /** Register MCP protocol-level middleware for all requests (`extra` is `McpExtra`). */
     mcpMiddleware(filter: "request", handler: (request: {
         method: string;
         params: Record<string, unknown>;
     }, extra: McpExtra, next: () => Promise<ServerResult>) => Promise<unknown> | unknown): this;
+    /** Register MCP protocol-level middleware for all notifications (`extra` is `undefined`). */
     mcpMiddleware(filter: "notification", handler: (request: {
         method: string;
         params: Record<string, unknown>;
     }, extra: undefined, next: () => Promise<undefined>) => Promise<unknown> | unknown): this;
+    /**
+     * Register MCP protocol-level middleware for an exact method.
+     * Narrows `params`, `extra`, and `next()` result based on the method string.
+     */
     mcpMiddleware<M extends McpMethodString>(filter: M, handler: McpTypedMiddlewareFn<M>): this;
+    /**
+     * Register MCP protocol-level middleware for a wildcard pattern (e.g. `"tools/*"`).
+     * `next()` returns the union of result types for matching methods.
+     */
     mcpMiddleware<W extends McpWildcard>(filter: W, handler: (request: {
         method: string;
         params: Record<string, unknown>;
     }, extra: McpExtraFor<W>, next: () => Promise<McpResultFor<W>>) => Promise<unknown> | unknown): this;
+    /**
+     * Register MCP protocol-level middleware with a method filter.
+     * Filter can be an exact method (`"tools/call"`), wildcard (`"tools/*"`),
+     * category (`"request"` | `"notification"`), or an array of those.
+     */
     mcpMiddleware(filter: McpMiddlewareFilter, handler: McpMiddlewareFn): this;
     private applyMcpMiddleware;
     connect(transport: Parameters<typeof McpServerBase.prototype.connect>[0]): Promise<void>;
-    run(): Promise<void>;
-    /** @internal */
-    enforceOneToolPerWidget(component: string, toolName: string): void;
-    /** @internal */
-    registerViewResources(toolName: string, view: ViewConfig, toolMeta: InternalToolMeta): void;
-    private registerWidgetResource;
-    /** @internal */
-    wrapHandlerWithViewUUID<InputArgs extends ZodRawShapeCompat>(cb: ToolHandler<InputArgs>): ToolHandler<InputArgs>;
-    /** @internal */
-    wrapHandlerWithContentNormalization<InputArgs extends ZodRawShapeCompat>(cb: ToolHandler<InputArgs>): ToolHandler<InputArgs>;
-    private lookupWidgetFile;
+    /**
+     * Per-request stateless connect. The SDK's `Protocol` only allows one
+     * transport per instance, so we can't reuse this `McpServer` across
+     * concurrent requests. The SDK's idiomatic fix is a `() => McpServer`
+     * factory, but that would break Skybridge's singleton API — so instead
+     * we build a fresh underlying `Server` per request and share the main
+     * server's handler maps by reference. The cast is unavoidable: there's
+     * no public API to inject handler maps. `getHandlerMaps` validates the
+     * read side and fails fast on SDK field renames.
+     */
+    connectStatelessTransport(transport: Parameters<typeof McpServerBase.prototype.connect>[0]): Promise<void>;
+    run(): Promise<{
+        fetch: (...args: unknown[]) => unknown;
+    } | undefined>;
+    private enforceOneToolPerView;
+    private registerViewResources;
+    private registerViewResource;
+    private wrapHandler;
+    private computeViewVersionParam;
+    private lookupViewFile;
     private lookupDistFile;
+    /**
+     * Inject the Vite manifest as a value rather than letting `readManifest()`
+     * load it from disk. Required for runtimes without a usable filesystem
+     * (Cloudflare Workers, etc.) — the user's `skybridge build` emits the
+     * manifest as a JS module which the entry imports and passes here.
+     */
+    setViteManifest(manifest: Record<string, {
+        file: string;
+    }>): this;
     private readManifest;
     registerTool<TName extends string, InputArgs extends ZodRawShapeCompat, TReturn extends {
-        content: HandlerContent;
-    }>(config: UnifiedToolConfig<InputArgs> & {
+        content?: HandlerContent;
+    }>(config: ToolConfig<InputArgs> & {
         name: TName;
     }, cb: ToolHandler<InputArgs, TReturn>): AddTool<TTools, TName, InputArgs, ExtractStructuredContent<TReturn>, ExtractMeta<TReturn>>;
-    registerTool<InputArgs extends ZodRawShapeCompat>(config: UnifiedToolConfig<InputArgs>, cb: ToolHandler<InputArgs>): this;
+    registerTool<InputArgs extends ZodRawShapeCompat>(config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs>): this;
 }
 export {};

package/dist/server/server.js

@@ -2,8 +2,10 @@ import crypto from "node:crypto";
 import { readFileSync } from "node:fs";
 import http from "node:http";
 import path from "node:path";
+import { Server as SdkServer, } from "@modelcontextprotocol/sdk/server/index.js";
 import { McpServer as McpServerBase } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { mergeWith, union } from "es-toolkit";
+import express, {} from "express";
 import { createApp } from "./express.js";
 import { createMiddlewareEntry } from "./metric.js";
 import { buildMiddlewareChain, getHandlerMaps } from "./middleware.js";
@@ -15,10 +17,10 @@ const mergeWithUnion = (target, source) => {
         }
     });
 };
-// ---------------------------------------------------------------------------
-// Content normalization
-// ---------------------------------------------------------------------------
 export function normalizeContent(content) {
+    if (content === undefined) {
+        return [];
+    }
     if (typeof content === "string") {
         return [{ type: "text", text: content }];
     }
@@ -29,23 +31,41 @@ export function normalizeContent(content) {
 }
 const McpServerBaseOmitted = McpServerBase;
 export class McpServer extends McpServerBaseOmitted {
+    /**
+     * The underlying Express app. Use this to extend the HTTP server with
+     * custom routes, middleware, or settings — e.g.
+     * `server.express.get("/health", ...)`.
+     *
+     * `express.json()` is pre-applied. Register your handlers before `run()`;
+     * after `run()`, dev-mode middleware, the `/mcp` route, and the default
+     * error handler are appended in that order.
+     *
+     * Note: Alpic Cloud only routes traffic to `/mcp` — custom routes work
+     * locally and on self-hosted deployments.
+     */
     express;
-    customMiddleware = [];
     customErrorMiddleware = [];
     mcpMiddlewareEntries = [];
     mcpMiddlewareApplied = false;
-    claimedWidgets = new Map();
+    claimedViews = new Map();
+    viteManifest = null;
+    serverInfo;
+    serverOptions;
+    constructor(serverInfo, options) {
+        super(serverInfo, options);
+        this.serverInfo = serverInfo;
+        this.serverOptions = options;
+        this.express = express();
+        this.express.use(express.json());
+    }
     use(pathOrHandler, ...handlers) {
+        // Branching is load-bearing: Express's `app.use` overloads can't be
+        // resolved against a `string | RequestHandler` union, so we narrow.
         if (typeof pathOrHandler === "string") {
-            this.customMiddleware.push({
-                path: pathOrHandler,
-                handlers,
-            });
+            this.express.use(pathOrHandler, ...handlers);
         }
         else {
-            this.customMiddleware.push({
-                handlers: [pathOrHandler, ...handlers],
-            });
+            this.express.use(pathOrHandler, ...handlers);
         }
         return this;
     }
@@ -111,49 +131,84 @@ export class McpServer extends McpServerBaseOmitted {
         this.applyMcpMiddleware();
         return McpServerBase.prototype.connect.call(this, transport);
     }
+    /**
+     * Per-request stateless connect. The SDK's `Protocol` only allows one
+     * transport per instance, so we can't reuse this `McpServer` across
+     * concurrent requests. The SDK's idiomatic fix is a `() => McpServer`
+     * factory, but that would break Skybridge's singleton API — so instead
+     * we build a fresh underlying `Server` per request and share the main
+     * server's handler maps by reference. The cast is unavoidable: there's
+     * no public API to inject handler maps. `getHandlerMaps` validates the
+     * read side and fails fast on SDK field renames.
+     */
+    async connectStatelessTransport(transport) {
+        this.applyMcpMiddleware();
+        const { requestHandlers, notificationHandlers } = getHandlerMaps(this.server);
+        const fresh = new SdkServer(this.serverInfo, this.serverOptions);
+        const target = fresh;
+        target._requestHandlers = requestHandlers;
+        target._notificationHandlers = notificationHandlers;
+        await fresh.connect(transport);
+    }
     async run() {
         this.applyMcpMiddleware();
         const httpServer = http.createServer();
-        if (!this.express) {
-            this.express = await createApp({
-                mcpServer: this,
-                httpServer,
-                customMiddleware: this.customMiddleware,
-                errorMiddleware: this.customErrorMiddleware,
-            });
-        }
+        await createApp({
+            mcpServer: this,
+            httpServer,
+            errorMiddleware: this.customErrorMiddleware,
+        });
         httpServer.on("request", this.express);
-        return new Promise((resolve, reject) => {
+        const port = parseInt(process.env.__PORT ?? "3000", 10);
+        await new Promise((resolve, reject) => {
             httpServer.on("error", (error) => {
                 console.error("Failed to start server:", error);
                 reject(error);
             });
-            const port = parseInt(process.env.__PORT ?? "3000", 10);
             httpServer.listen(port, () => {
                 resolve();
             });
         });
+        // On workerd, bridge the Node http server to a Workers fetch handler.
+        // The specifier is held in a variable to sidestep tsc's module resolution
+        // (`cloudflare:node` only exists under wrangler/workerd).
+        if (typeof navigator !== "undefined" &&
+            navigator.userAgent === "Cloudflare-Workers") {
+            const cloudflareNode = "cloudflare:node";
+            const { httpServerHandler } = await import(cloudflareNode);
+            return httpServerHandler({ port });
+        }
+        const shutdown = () => {
+            // Drop both handlers so a second signal falls through to Node's default
+            // (force-quit on a second Ctrl+C while drain is hanging).
+            process.off("SIGTERM", shutdown);
+            process.off("SIGINT", shutdown);
+            httpServer.close(() => process.exit(0));
+            // Force exit if connections don't drain in time so the port is still
+            // released promptly (e.g. for nodemon restarts).
+            setTimeout(() => process.exit(0), 3000).unref();
+        };
+        process.on("SIGTERM", shutdown);
+        process.on("SIGINT", shutdown);
+        return undefined;
     }
-    // registerTool is defined via interface merging + prototype assignment below
-    // to avoid TypeScript override signature incompatibility with the base class.
-    // -------------------------------------------------------------------------
-    // View (widget) resource registration
-    // -------------------------------------------------------------------------
-    /** @internal */
-    enforceOneToolPerWidget(component, toolName) {
-        const existingTool = this.claimedWidgets.get(component);
+    enforceOneToolPerView(component, toolName) {
+        const existingTool = this.claimedViews.get(component);
         if (existingTool) {
-            throw new Error(`skybridge: widget "${component}" is already used by tool "${existingTool}". Tool "${toolName}" cannot also reference it — each widget backs exactly one tool.`);
+            throw new Error(`skybridge: view "${component}" is already used by tool "${existingTool}". Tool "${toolName}" cannot also reference it — each view backs exactly one tool.`);
         }
-        this.claimedWidgets.set(component, toolName);
+        this.claimedViews.set(component, toolName);
     }
-    /** @internal */
     registerViewResources(toolName, view, toolMeta) {
         const hosts = view.hosts ?? ["apps-sdk", "mcp-app"];
+        // Append a content-derived version param so hosts (e.g. ChatGPT) bust
+        // their cache when the bundle changes, but keep the URI stable across
+        // `tools/list` calls when the bundle hasn't changed.
+        const versionParam = this.computeViewVersionParam(view.component);
         if (hosts.includes("apps-sdk")) {
-            const widgetConfig = {
+            const viewResource = {
                 hostType: "apps-sdk",
-                uri: `ui://widgets/apps-sdk/${view.component}.html`,
+                uri: `ui://views/apps-sdk/${view.component}.html${versionParam}`,
                 mimeType: "text/html+skybridge",
                 buildContentMeta: ({ resourceDomains, connectDomains, domain }, overrides) => {
                     const defaults = {
@@ -183,17 +238,17 @@ export class McpServer extends McpServerBaseOmitted {
                     return base;
                 },
             };
-            this.registerWidgetResource({
+            this.registerViewResource({
                 name: toolName,
-                widgetConfig,
+                viewResource,
                 view,
             });
-            toolMeta["openai/outputTemplate"] = widgetConfig.uri;
+            toolMeta["openai/outputTemplate"] = viewResource.uri;
         }
         if (hosts.includes("mcp-app")) {
-            const widgetConfig = {
+            const viewResource = {
                 hostType: "mcp-app",
-                uri: `ui://widgets/ext-apps/${view.component}.html`,
+                uri: `ui://views/ext-apps/${view.component}.html${versionParam}`,
                 mimeType: "text/html;profile=mcp-app",
                 buildContentMeta: ({ resourceDomains, connectDomains, domain, baseUriDomains }, overrides) => {
                     const defaults = {
@@ -241,19 +296,19 @@ export class McpServer extends McpServerBaseOmitted {
                     return base;
                 },
             };
-            this.registerWidgetResource({
+            this.registerViewResource({
                 name: toolName,
-                widgetConfig,
+                viewResource,
                 view,
             });
             // @ts-expect-error - For backwards compatibility with Claude current implementation of the specs
-            toolMeta["ui/resourceUri"] = widgetConfig.uri;
-            toolMeta.ui = { resourceUri: widgetConfig.uri };
+            toolMeta["ui/resourceUri"] = viewResource.uri;
+            toolMeta.ui = { resourceUri: viewResource.uri };
         }
     }
-    registerWidgetResource({ name, widgetConfig, view, }) {
-        const { hostType, uri: widgetUri, mimeType, buildContentMeta, } = widgetConfig;
-        this.registerResource(name, widgetUri, { description: view.description }, async (uri, extra) => {
+    registerViewResource({ name, viewResource, view, }) {
+        const { hostType, uri: viewUri, mimeType, buildContentMeta } = viewResource;
+        this.registerResource(name, viewUri, { description: view.description }, async (uri, extra) => {
             const isProduction = process.env.NODE_ENV === "production";
             const isClaude = extra?.requestInfo?.headers?.["user-agent"] === "Claude-User";
             const headers = extra?.requestInfo?.headers || {};
@@ -286,13 +341,13 @@ export class McpServer extends McpServerBaseOmitted {
                 ? templateHelper.renderProduction({
                     hostType,
                     serverUrl,
-                    widgetFile: this.lookupWidgetFile(view.component),
+                    viewFile: this.lookupViewFile(view.component),
                     styleFile: this.lookupDistFile("style.css") ?? "",
                 })
                 : templateHelper.renderDevelopment({
                     hostType,
                     serverUrl,
-                    widgetName: view.component,
+                    viewName: view.component,
                 });
             const connectDomains = [serverUrl];
             if (!isProduction) {
@@ -304,6 +359,8 @@ export class McpServer extends McpServerBaseOmitted {
             if (isClaude) {
                 const pathname = extra?.requestInfo?.url?.pathname ?? "";
                 const rawUrl = header("x-alpic-forwarded-url") ?? `${serverUrl}${pathname}`;
+                // Strip a lone trailing slash so the hash matches the connector URL
+                // as registered with Claude (which has no trailing slash on bare origins).
                 const url = rawUrl.endsWith("/") ? rawUrl.slice(0, -1) : rawUrl;
                 const hash = crypto
                     .createHash("sha256")
@@ -325,50 +382,68 @@ export class McpServer extends McpServerBaseOmitted {
             };
         });
     }
-    // -------------------------------------------------------------------------
-    // Handler wrapping
-    // -------------------------------------------------------------------------
-    /** @internal */
-    wrapHandlerWithViewUUID(cb) {
+    wrapHandler(cb, { attachViewUUID }) {
         return async (args, extra) => {
             const result = await cb(args, extra);
             return {
                 ...result,
                 content: normalizeContent(result.content),
-                _meta: {
-                    ...result._meta,
-                    viewUUID: crypto.randomUUID(),
-                },
+                ...(attachViewUUID && {
+                    _meta: {
+                        ...result._meta,
+                        viewUUID: crypto.randomUUID(),
+                    },
+                }),
             };
         };
     }
-    /** @internal */
-    wrapHandlerWithContentNormalization(cb) {
-        return async (args, extra) => {
-            const result = await cb(args, extra);
-            return {
-                ...result,
-                content: normalizeContent(result.content),
-            };
-        };
+    computeViewVersionParam(viewName) {
+        if (process.env.NODE_ENV !== "production") {
+            return "";
+        }
+        try {
+            const viewFile = this.lookupViewFile(viewName);
+            const styleFile = this.lookupDistFile("style.css") ?? "";
+            const hash = crypto
+                .createHash("sha256")
+                .update(viewFile)
+                .update("\0")
+                .update(styleFile)
+                .digest("hex")
+                .slice(0, 8);
+            return `?v=${hash}`;
+        }
+        catch {
+            return "";
+        }
     }
-    // -------------------------------------------------------------------------
-    // Manifest helpers
-    // -------------------------------------------------------------------------
-    lookupWidgetFile(widgetName) {
+    lookupViewFile(viewName) {
         const manifest = this.readManifest();
         for (const entry of Object.values(manifest)) {
-            if (entry?.isEntry && entry.name === widgetName && entry.file) {
+            if (entry?.isEntry && entry.name === viewName && entry.file) {
                 return entry.file;
             }
         }
-        throw new Error(`Widget "${widgetName}" not found in Vite manifest. Did the build complete successfully? Look for an entry with name "${widgetName}" in dist/assets/.vite/manifest.json.`);
+        throw new Error(`View "${viewName}" not found in Vite manifest. Did the build complete successfully? Look for an entry with name "${viewName}" in dist/assets/.vite/manifest.json.`);
     }
     lookupDistFile(key) {
         const manifest = this.readManifest();
         return manifest[key]?.file;
     }
+    /**
+     * Inject the Vite manifest as a value rather than letting `readManifest()`
+     * load it from disk. Required for runtimes without a usable filesystem
+     * (Cloudflare Workers, etc.) — the user's `skybridge build` emits the
+     * manifest as a JS module which the entry imports and passes here.
+     */
+    setViteManifest(manifest) {
+        this.viteManifest = manifest;
+        return this;
+    }
     readManifest() {
+        if (this.viteManifest) {
+            return this.viteManifest;
+        }
         return JSON.parse(readFileSync(path.join(process.cwd(), "dist", "assets", ".vite", "manifest.json"), "utf-8"));
     }
     registerTool(...args) {
@@ -382,12 +457,10 @@ export class McpServer extends McpServerBaseOmitted {
         const { name, view, _meta: userToolMeta, ...toolFields } = config;
         const toolMeta = { ...userToolMeta };
         if (view) {
-            this.enforceOneToolPerWidget(view.component, name);
+            this.enforceOneToolPerView(view.component, name);
             this.registerViewResources(name, view, toolMeta);
         }
-        const wrappedCb = view
-            ? this.wrapHandlerWithViewUUID(cb)
-            : this.wrapHandlerWithContentNormalization(cb);
+        const wrappedCb = this.wrapHandler(cb, { attachViewUUID: Boolean(view) });
         baseFn.call(this, name, { ...toolFields, _meta: toolMeta }, wrappedCb);
         return this;
     }