skybridge 0.0.0-dev.bfa3fec → 0.0.0-dev.bfb8742

package/dist/server/server.d.ts

@@ -6,7 +6,9 @@ import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/proto
 import type { ContentBlock, Implementation, RequestMeta, ServerNotification, ServerRequest, ServerResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import express, { type ErrorRequestHandler, type Express, type RequestHandler } from "express";
 import type { OAuthConfig } from "./auth/index.js";
+import type { AuthInfo, ExtraClaims } from "./auth.js";
 import type { McpExtra, McpExtraFor, McpMethodString, McpMiddlewareFilter, McpMiddlewareFn, McpResultFor, McpTypedMiddlewareFn, McpWildcard } from "./middleware.js";
+import { type SkillsManifest } from "./skills.js";
 /**
  * Type marker for a registered tool — carries its input, output, and response
  * metadata shapes so views can infer types from `typeof server`.
@@ -88,17 +90,42 @@ export type SecurityScheme = {
     type: "oauth2";
     scopes?: string[];
 };
+/**
+ * Declarative per-tool auth. Enforced when the server has an `oauth` provider:
+ * anonymous or under-scoped calls are rejected before the handler runs. Omit
+ * `auth` entirely for the secure default (sign-in required, no specific scope).
+ */
+export type ToolAuth = {
+    /**
+     * When `true`, the tool is callable signed out; the token is still used when
+     * one is present. Omit (or `false`) to require sign-in.
+     */
+    allowsAnonymous?: boolean;
+    /** OAuth scopes the caller's token must carry to invoke the tool. */
+    scopes?: string[];
+};
 /**
  * Options forwarded to the built-in `express.json()` body parser. Derived
  * from Express's own types so the public API doesn't depend on `body-parser`.
  */
 export type JsonOptions = NonNullable<Parameters<typeof express.json>[0]>;
-/** Skybridge-specific server options, passed as the third `McpServer` constructor argument. */
-export interface SkybridgeServerOptions {
+/**
+ * Skybridge-specific server options, passed as the third `McpServer` constructor
+ * argument.
+ *
+ * @typeParam TAuthExtra - Claims the `oauth` verifier populates. Inferred from
+ * the config a provider returns, and carried on to tool handlers.
+ */
+export interface SkybridgeServerOptions<TAuthExtra extends ExtraClaims = ExtraClaims> {
     /** Options for the built-in `express.json()` middleware, e.g. `{ limit: "10mb" }`. */
     json?: JsonOptions;
     /** Resource-server OAuth config. When set, mounts well-known metadata and bearer auth on `/mcp`. */
-    oauth?: OAuthConfig;
+    oauth?: OAuthConfig<TAuthExtra>;
+    /**
+     * @experimental Serve Agent Skills from `src/skills` over MCP (SEP-2640).
+     * API may change.
+     */
+    skills?: boolean;
 }
 /**
  * Well-known keys recognized by host runtimes when set on a tool's `_meta`.
@@ -158,10 +185,10 @@ type ExtractMeta<T> = [Extract<T, {
 }> extends {
     _meta: infer M;
 } ? Simplify<M> : unknown;
-type AddTool<TTools, TName extends string, TInput extends ZodRawShapeCompat, TOutput, TResponseMetadata = unknown> = McpServer<TTools & {
+type AddTool<TTools, TName extends string, TInput extends ZodRawShapeCompat, TOutput, TResponseMetadata = unknown, TAuthExtra extends ExtraClaims = ExtraClaims> = McpServer<TTools & {
     [K in TName]: ToolDef<ShapeOutput<TInput>, TOutput, TResponseMetadata>;
-}>;
-interface ToolConfig<TInput extends ZodRawShapeCompat | AnySchema> {
+}, TAuthExtra>;
+interface ToolConfigBase<TInput extends ZodRawShapeCompat | AnySchema> {
     name: string;
     title?: string;
     description?: string;
@@ -169,6 +196,17 @@ interface ToolConfig<TInput extends ZodRawShapeCompat | AnySchema> {
     outputSchema?: ZodRawShapeCompat | AnySchema;
     annotations?: ToolAnnotations;
     view?: ViewConfig;
+    _meta?: ToolMeta;
+}
+/**
+ * The auth face of a tool config: either the high-level `auth` shorthand or the
+ * low-level `securitySchemes` escape hatch, never both.
+ */
+type ToolAuthConfig = {
+    auth?: ToolAuth;
+    securitySchemes?: never;
+} | {
+    auth?: never;
     /**
      * Declares which auth schemes this tool supports (e.g. `noauth`, `oauth2`).
      * Lets clients label tools that require sign-in before calling, and pass
@@ -177,8 +215,8 @@ interface ToolConfig<TInput extends ZodRawShapeCompat | AnySchema> {
      * enhanced behavior to authenticated ones.
      */
     securitySchemes?: SecurityScheme[];
-    _meta?: ToolMeta;
-}
+};
+type ToolConfig<TInput extends ZodRawShapeCompat | AnySchema> = ToolConfigBase<TInput> & ToolAuthConfig;
 /**
  * Optional client-supplied hints attached to `params._meta` on every tool call
  * by the Apps SDK host. Hints only: never use for authorization, and tolerate
@@ -208,14 +246,15 @@ export interface ClientHintsMeta {
     /** Stable id for the currently mounted widget instance. */
     "openai/widgetSessionId"?: string;
 }
-type ToolHandlerExtra = Omit<RequestHandlerExtra<ServerRequest, ServerNotification>, "_meta"> & {
+type ToolHandlerExtra<TAuthExtra extends ExtraClaims = ExtraClaims> = Omit<RequestHandlerExtra<ServerRequest, ServerNotification>, "_meta" | "authInfo"> & {
     _meta?: RequestMeta & ClientHintsMeta;
+    authInfo?: AuthInfo<TAuthExtra>;
 };
 type ToolHandler<TInput extends ZodRawShapeCompat, TReturn extends {
     content?: HandlerContent;
 } = {
     content?: HandlerContent;
-}> = (args: ShapeOutput<TInput>, extra: ToolHandlerExtra) => TReturn | Promise<TReturn>;
+}, TAuthExtra extends ExtraClaims = ExtraClaims> = (args: ShapeOutput<TInput>, extra: ToolHandlerExtra<TAuthExtra>) => TReturn | Promise<TReturn>;
 /**
  * Coerce a tool handler's return value into an MCP `content` array. Strings
  * become a single `TextContent`; a single block is wrapped in an array;
@@ -236,7 +275,8 @@ declare const McpServerBaseOmitted: new (...args: ConstructorParameters<typeof M
 export declare function __setBuildManifest(manifest: Record<string, {
     file: string;
 }>): void;
-export declare class McpServer<TTools extends Record<string, ToolDef> = Record<never, ToolDef>> extends McpServerBaseOmitted {
+export declare function __setSkillsManifest(manifest: SkillsManifest): void;
+export declare class McpServer<TTools extends Record<string, ToolDef> = Record<never, ToolDef>, TAuthExtra extends ExtraClaims = ExtraClaims> extends McpServerBaseOmitted {
     readonly $types: McpServerTypes<TTools>;
     /**
      * The underlying Express app. Use this to extend the HTTP server with
@@ -268,7 +308,11 @@ export declare class McpServer<TTools extends Record<string, ToolDef> = Record<n
     private viteManifest;
     private readonly serverInfo;
     private readonly serverOptions?;
-    constructor(serverInfo: Implementation, options?: ServerOptions, skybridgeOptions?: SkybridgeServerOptions);
+    private oauthEnabled;
+    private resolveResourceMetadataUrl?;
+    private securitySchemesByTool;
+    constructor(serverInfo: Implementation, options?: ServerOptions, skybridgeOptions?: SkybridgeServerOptions<TAuthExtra>);
+    private setupSkills;
     /**
      * Register Express middleware on the underlying app. Mirrors `app.use` —
      * pass handlers directly or a path-prefixed handler list. Register before
@@ -295,12 +339,12 @@ export declare class McpServer<TTools extends Record<string, ToolDef> = Record<n
     useOnError(...handlers: ErrorRequestHandler[]): this;
     useOnError(path: string, ...handlers: ErrorRequestHandler[]): this;
     /** Register MCP protocol-level middleware (catch-all). */
-    mcpMiddleware(handler: McpMiddlewareFn): this;
+    mcpMiddleware(handler: McpMiddlewareFn<TAuthExtra>): 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;
+    }, extra: McpExtra<TAuthExtra>, 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;
@@ -310,7 +354,7 @@ export declare class McpServer<TTools extends Record<string, ToolDef> = Record<n
      * 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;
+    mcpMiddleware<M extends McpMethodString>(filter: M, handler: McpTypedMiddlewareFn<M, TAuthExtra>): this;
     /**
      * Register MCP protocol-level middleware for a wildcard pattern (e.g. `"tools/*"`).
      * `next()` returns the union of result types for matching methods.
@@ -318,13 +362,13 @@ export declare class McpServer<TTools extends Record<string, ToolDef> = Record<n
     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;
+    }, extra: McpExtraFor<W, TAuthExtra>, 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;
+    mcpMiddleware(filter: McpMiddlewareFilter, handler: McpMiddlewareFn<TAuthExtra>): this;
     private applyMcpMiddleware;
     /**
      * Connect to an MCP transport (override of the SDK's `connect`). Use this
@@ -366,7 +410,7 @@ export declare class McpServer<TTools extends Record<string, ToolDef> = Record<n
     private registerViewResources;
     private registerViewResource;
     private serveLegacyAppsSdkUrl;
-    private wrapHandler;
+    private decorateToolHandler;
     private computeViewVersionParam;
     private lookupViewFile;
     private lookupDistFile;
@@ -413,7 +457,9 @@ export declare class McpServer<TTools extends Record<string, ToolDef> = Record<n
         content?: HandlerContent;
     }>(config: ToolConfig<InputArgs> & {
         name: TName;
-    }, cb: ToolHandler<InputArgs, TReturn>): AddTool<TTools, TName, InputArgs, ExtractStructuredContent<TReturn>, ExtractMeta<TReturn>>;
-    registerTool<InputArgs extends ZodRawShapeCompat>(config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs>): this;
+    }, cb: ToolHandler<InputArgs, TReturn, TAuthExtra>): AddTool<TTools, TName, InputArgs, ExtractStructuredContent<TReturn>, ExtractMeta<TReturn>, TAuthExtra>;
+    registerTool<InputArgs extends ZodRawShapeCompat>(config: ToolConfig<InputArgs>, cb: ToolHandler<InputArgs, {
+        content?: HandlerContent;
+    }, TAuthExtra>): this;
 }
 export {};

package/dist/server/server.js

@@ -6,11 +6,15 @@ 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 { warnOnLargeToolOutput } from "../context-warnings.js";
+import { authToSecuritySchemes, evaluateSecuritySchemes, inBandChallengeResult, } from "./auth/security-schemes.js";
 import { setupOAuth } from "./auth/setup.js";
 import { createApp } from "./express.js";
+import { hostFromUserAgent } from "./host.js";
 import { createMiddlewareEntry } from "./metric.js";
-import { buildMiddlewareChain, getHandlerMaps } from "./middleware.js";
+import { buildMiddlewareChain, captureToolError, getHandlerMaps, } from "./middleware.js";
 import { resolveServerOrigin } from "./requestOrigin.js";
+import { discoverSkills, registerSkills, SKILLS_EXTENSION_KEY, } from "./skills.js";
 import { templateHelper } from "./templateHelper.js";
 const mergeWithUnion = (target, source) => {
     return mergeWith(target, source, (targetVal, sourceVal) => {
@@ -19,6 +23,20 @@ const mergeWithUnion = (target, source) => {
         }
     });
 };
+const SKILLS_DIR = "src/skills";
+/**
+ * Normalize an `x-forwarded-prefix` value into a leading-slash, no-trailing-slash
+ * path. Takes the first hop of a comma-separated proxy chain.
+ * "/v1/", "v1", "/v1, /internal" → "/v1"; "", "/", undefined → "".
+ */
+function normalizeForwardedPrefix(raw) {
+    const firstHop = raw?.split(",")[0]?.trim() ?? "";
+    const trimmed = firstHop.replace(/\/+$/, "");
+    if (trimmed === "") {
+        return "";
+    }
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
 /**
  * Drop the query string from a `ui://` view URI, leaving the bare path. The
  * `?v=` cache key is the only query we append, so a plain split is enough and
@@ -92,6 +110,47 @@ let pendingBuildManifest = null;
 export function __setBuildManifest(manifest) {
     pendingBuildManifest = manifest;
 }
+let pendingSkillsManifest = null;
+export function __setSkillsManifest(manifest) {
+    pendingSkillsManifest = manifest;
+}
+// Pure and `this`-free so it can run inside the `super(...)` call, before `this`
+// exists — the capability must be present for the `initialize` response.
+function withSkillsCapability(options, skybridgeOptions) {
+    if (!skybridgeOptions?.skills) {
+        return options;
+    }
+    return {
+        ...options,
+        capabilities: {
+            ...options?.capabilities,
+            extensions: {
+                ...options?.capabilities?.extensions,
+                [SKILLS_EXTENSION_KEY]: { directoryRead: true },
+            },
+        },
+    };
+}
+// Collapses registerTool's two overloads into a single { config, cb } shape.
+//   registerTool("greet", { description }, handler)
+//     -> { config: { name: "greet", description }, cb: handler }
+//   registerTool({ name: "greet", description }, handler)
+//     -> { config: { name: "greet", description }, cb: handler }
+function normalizeRegisterToolArgs(args) {
+    if (typeof args[0] === "string") {
+        return {
+            config: {
+                name: args[0],
+                ...args[1],
+            },
+            cb: args[2],
+        };
+    }
+    return {
+        config: args[0],
+        cb: args[1],
+    };
+}
 export class McpServer extends McpServerBaseOmitted {
     /**
      * The underlying Express app. Use this to extend the HTTP server with
@@ -123,14 +182,19 @@ export class McpServer extends McpServerBaseOmitted {
     viteManifest = null;
     serverInfo;
     serverOptions;
+    oauthEnabled = false;
+    resolveResourceMetadataUrl;
+    securitySchemesByTool = new Map();
     constructor(serverInfo, options, skybridgeOptions) {
-        super(serverInfo, options);
+        const mergedOptions = withSkillsCapability(options, skybridgeOptions);
+        super(serverInfo, mergedOptions);
         this.serverInfo = serverInfo;
-        this.serverOptions = options;
+        this.serverOptions = mergedOptions;
         this.express = express();
         this.express.use(express.json(skybridgeOptions?.json));
         if (skybridgeOptions?.oauth) {
-            setupOAuth(this.express, skybridgeOptions.oauth);
+            this.oauthEnabled = true;
+            this.resolveResourceMetadataUrl = setupOAuth(this.express, skybridgeOptions.oauth, this.securitySchemesByTool);
         }
         // Pick up the manifest if `dist/__entry.js` primed it before importing
         // user code. Consume-once: clear after the first construction so a
@@ -141,6 +205,19 @@ export class McpServer extends McpServerBaseOmitted {
             this.setViteManifest(pendingBuildManifest);
             pendingBuildManifest = null;
         }
+        this.setupSkills(Boolean(skybridgeOptions?.skills));
+    }
+    setupSkills(enabled) {
+        const manifest = pendingSkillsManifest;
+        pendingSkillsManifest = null;
+        if (!enabled) {
+            return;
+        }
+        const skills = manifest ?? discoverSkills(SKILLS_DIR);
+        if (skills.length === 0) {
+            console.warn(`skybridge: the "skills" option is enabled but no skills were found in "${SKILLS_DIR}". Add a <name>/SKILL.md there, or remove the option.`);
+        }
+        registerSkills(this, skills);
     }
     use(pathOrHandler, ...handlers) {
         // Branching is load-bearing: Express's `app.use` overloads can't be
@@ -249,16 +326,33 @@ export class McpServer extends McpServerBaseOmitted {
                 }
             },
         };
+        // ChatGPT reads `securitySchemes` at the tool descriptor top level (SEP-1488,
+        // still Draft), but the SDK's registerTool strips unknown top-level fields, so
+        // it's stashed in `_meta` at registration. This restores it to the top level
+        // on tools/list output. Remove once SEP-1488 lands and the SDK preserves it.
+        //   { name: "checkout", _meta: { securitySchemes: [{ type: "oauth2" }] } }
+        //     -> { name: "checkout", _meta: {…}, securitySchemes: [{ type: "oauth2" }] }
+        const toolsListSecuritySchemesEntry = {
+            filter: "tools/list",
+            handler: async (_req, _extra, next) => {
+                const result = (await next());
+                for (const tool of result.tools) {
+                    const schemes = tool._meta?.securitySchemes;
+                    if (schemes && !("securitySchemes" in tool)) {
+                        tool.securitySchemes = schemes;
+                    }
+                }
+                return result;
+            },
+        };
         const monitoringEntry = createMiddlewareEntry();
         const entries = [
             ...(monitoringEntry ? [monitoringEntry] : []),
             viewListMetaEntry,
             viewReadResolveEntry,
+            toolsListSecuritySchemesEntry,
             ...this.mcpMiddlewareEntries,
         ];
-        if (entries.length === 0) {
-            return;
-        }
         const { requestHandlers, notificationHandlers } = getHandlerMaps(this.server);
         const instrumentMap = (map, isNotification) => {
             for (const [method, handler] of map) {
@@ -381,8 +475,13 @@ export class McpServer extends McpServerBaseOmitted {
             const val = headers[key];
             return Array.isArray(val) ? val[0] : val;
         };
-        const isClaude = header("user-agent") === "Claude-User";
+        const isClaude = hostFromUserAgent(header("user-agent")) === "claude";
         const serverUrl = resolveServerOrigin(header);
+        // Path prefix the proxy routed this request under (e.g. `foo.com/v1`). Read
+        // per-request so one process can serve many hosts/prefixes at once: the
+        // origin is recovered from x-forwarded-host, the prefix from
+        // x-forwarded-prefix. Empty when served at the origin root.
+        const assetsBasePath = normalizeForwardedPrefix(header("x-forwarded-prefix"));
         const connectDomains = [serverUrl];
         if (!isProduction) {
             const wsUrl = new URL(serverUrl);
@@ -403,7 +502,7 @@ export class McpServer extends McpServerBaseOmitted {
                 .slice(0, 32);
             contentMetaOverrides = { domain: `${hash}.claudemcpcontent.com` };
         }
-        return { serverUrl, connectDomains, contentMetaOverrides };
+        return { serverUrl, assetsBasePath, connectDomains, contentMetaOverrides };
     }
     registerViewResources(toolName, view, toolMeta) {
         // Append a content-derived version param so hosts (e.g. ChatGPT) bust
@@ -491,17 +590,21 @@ export class McpServer extends McpServerBaseOmitted {
         this.serveLegacyAppsSdkUrl(view.component, viewUri);
         this.registerResource(name, viewUri, { description: view.description }, async (uri, extra) => {
             const isProduction = process.env.NODE_ENV === "production";
-            const { serverUrl } = this.resolveViewRequestContext(extra);
+            const { serverUrl, assetsBasePath } = this.resolveViewRequestContext(extra);
+            // The view resolves all assets (template imports + runtime lazy chunks
+            // via `window.skybridge.serverUrl`) against this base, so it carries the
+            // proxy path prefix. CSP domains in `buildMeta` stay the bare origin.
+            const viewBase = `${serverUrl}${assetsBasePath}`;
             const html = isProduction
                 ? templateHelper.renderProduction({
                     hostType,
-                    serverUrl,
+                    serverUrl: viewBase,
                     viewFile: this.lookupViewFile(view.component),
                     styleFile: this.lookupDistFile("style.css") ?? "",
                 })
                 : templateHelper.renderDevelopment({
                     hostType,
-                    serverUrl,
+                    serverUrl: viewBase,
                     viewName: view.component,
                 });
             return {
@@ -516,9 +619,29 @@ export class McpServer extends McpServerBaseOmitted {
         this.viewUriByPath.set(`ui://widgets/apps-sdk/${component}.html`, canonicalUri);
         this.viewUriByPath.set(`ui://widgets/ext-apps/${component}.html`, canonicalUri);
     }
-    wrapHandler(cb, { attachViewUUID }) {
+    decorateToolHandler(cb, { attachViewUUID, securitySchemes, toolName, }) {
         return async (args, extra) => {
-            const result = await cb(args, extra);
+            const toolExtra = extra ?? args;
+            if (this.oauthEnabled) {
+                const failure = evaluateSecuritySchemes(securitySchemes, toolExtra?.authInfo);
+                if (failure) {
+                    const headers = toolExtra?.requestInfo?.headers ?? {};
+                    const header = (key) => {
+                        const value = headers[key];
+                        return Array.isArray(value) ? value[0] : value;
+                    };
+                    return inBandChallengeResult(failure, this.resolveResourceMetadataUrl?.(header));
+                }
+            }
+            let result;
+            try {
+                result = await cb(args, extra);
+            }
+            catch (error) {
+                captureToolError(toolExtra, error);
+                throw error;
+            }
+            warnOnLargeToolOutput(result, toolName);
             return {
                 ...result,
                 content: normalizeContent(result.content),
@@ -582,14 +705,19 @@ export class McpServer extends McpServerBaseOmitted {
     }
     registerTool(...args) {
         const baseFn = McpServerBase.prototype.registerTool;
-        if (typeof args[0] === "string") {
-            baseFn.call(this, args[0], args[1], args[2]);
-            return this;
+        const { config, cb } = normalizeRegisterToolArgs(args);
+        const { name, view, auth, securitySchemes: rawSecuritySchemes, _meta: userToolMeta, ...toolFields } = config;
+        const authNeedsProvider = auth !== undefined &&
+            (!auth.allowsAnonymous || Boolean(auth.scopes?.length));
+        if (rawSecuritySchemes === undefined &&
+            authNeedsProvider &&
+            !this.oauthEnabled) {
+            throw new Error(`Tool "${name}" sets \`auth: ${JSON.stringify(auth)}\` but the server has no \`oauth\` provider configured.`);
         }
-        const config = args[0];
-        const cb = args[1];
-        const { name, view, securitySchemes, _meta: userToolMeta, ...toolFields } = config;
+        const securitySchemes = rawSecuritySchemes ??
+            (auth && this.oauthEnabled ? authToSecuritySchemes(auth) : undefined);
         const toolMeta = { ...userToolMeta };
+        this.securitySchemesByTool.set(name, securitySchemes);
         if (securitySchemes) {
             // SEP-1488 puts `securitySchemes` at the top level of the tool
             // descriptor, but the SDK's `registerTool` drops unknown top-level
@@ -602,7 +730,11 @@ export class McpServer extends McpServerBaseOmitted {
             this.enforceOneToolPerView(view.component, name);
             this.registerViewResources(name, view, toolMeta);
         }
-        const wrappedCb = this.wrapHandler(cb, { attachViewUUID: Boolean(view) });
+        const wrappedCb = this.decorateToolHandler(cb, {
+            attachViewUUID: Boolean(view),
+            securitySchemes,
+            toolName: name,
+        });
         baseFn.call(this, name, { ...toolFields, _meta: toolMeta }, wrappedCb);
         return this;
     }