@vendure/mcp-plugin 3.8.0-minor-bootstrap.0

package/lib/tools/built-in/shop/update-cart-line.tool.js

@@ -0,0 +1,60 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCartLineTool = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const mcp_sdk_1 = require("@vendure/mcp-sdk");
+const zod_1 = require("zod");
+const active_order_service_1 = require("../active-order.service");
+const id_schema_1 = require("../id-schema");
+const int32_schema_1 = require("../int32-schema");
+const serializer_service_1 = require("../serializer.service");
+const updateCartLineInput = zod_1.z.strictObject({
+    orderLineId: id_schema_1.idSchema.describe('Order line ID.'),
+    quantity: int32_schema_1.int32Schema.min(0).describe('New quantity for the line, a whole number. 0 removes the line.'),
+});
+let UpdateCartLineTool = class UpdateCartLineTool {
+    constructor(activeOrder, orderService, serializer) {
+        this.activeOrder = activeOrder;
+        this.orderService = orderService;
+        this.serializer = serializer;
+    }
+    async execute(ctx, input) {
+        const order = await this.activeOrder.findOrThrow(ctx);
+        return this.serializer.orderOrError(await this.orderService.adjustOrderLine(order.ctx, order.id, input.orderLineId, input.quantity));
+    }
+};
+exports.UpdateCartLineTool = UpdateCartLineTool;
+exports.UpdateCartLineTool = UpdateCartLineTool = __decorate([
+    (0, mcp_sdk_1.McpTool)({
+        name: 'update_cart_line',
+        toolset: 'shop',
+        description: 'Update the quantity of a cart line.',
+        keywords: [
+            'change the quantity',
+            'buy more of this one',
+            'increase how many I want',
+            'reduce the amount in my basket',
+            'adjust item count',
+            'update the number of this item',
+        ],
+        permissions: [core_1.Permission.Public],
+        behavior: 'mutating',
+        usesActiveOrder: true,
+        inputSchema: updateCartLineInput,
+    }),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [active_order_service_1.McpActiveOrderService,
+        core_1.OrderService,
+        serializer_service_1.McpToolSerializerService])
+], UpdateCartLineTool);
+//# sourceMappingURL=update-cart-line.tool.js.map

package/lib/tools/built-in/shop/update-cart-line.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-cart-line.tool.js","sourceRoot":"","sources":["../../../../src/tools/built-in/shop/update-cart-line.tool.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAC5C,wCAAyE;AACzE,8CAA2D;AAC3D,6BAAwB;AAExB,kEAAgE;AAChE,4CAAwC;AACxC,kDAA8C;AAC9C,8DAAiE;AAEjE,MAAM,mBAAmB,GAAG,OAAC,CAAC,YAAY,CAAC;IACvC,WAAW,EAAE,oBAAQ,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IAChD,QAAQ,EAAE,0BAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,gEAAgE,CAAC;CAC1G,CAAC,CAAC;AAsBI,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAC3B,YACqB,WAAkC,EAClC,YAA0B,EAC1B,UAAoC;QAFpC,gBAAW,GAAX,WAAW,CAAuB;QAClC,iBAAY,GAAZ,YAAY,CAAc;QAC1B,eAAU,GAAV,UAAU,CAA0B;IACtD,CAAC;IAEJ,KAAK,CAAC,OAAO,CAAC,GAAmB,EAAE,KAA0B;QACzD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACtD,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,CAC/B,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,CAClG,CAAC;IACN,CAAC;CACJ,CAAA;AAbY,gDAAkB;6BAAlB,kBAAkB;IAlB9B,IAAA,iBAAO,EAAC;QACL,IAAI,EAAE,kBAAkB;QACxB,OAAO,EAAE,MAAM;QACf,WAAW,EAAE,qCAAqC;QAClD,QAAQ,EAAE;YACN,qBAAqB;YACrB,sBAAsB;YACtB,0BAA0B;YAC1B,gCAAgC;YAChC,mBAAmB;YACnB,gCAAgC;SACnC;QACD,WAAW,EAAE,CAAC,iBAAU,CAAC,MAAM,CAAC;QAChC,QAAQ,EAAE,UAAU;QACpB,eAAe,EAAE,IAAI;QACrB,WAAW,EAAE,mBAAmB;KACnC,CAAC;IACD,IAAA,mBAAU,GAAE;qCAGyB,4CAAqB;QACpB,mBAAY;QACd,6CAAwB;GAJhD,kBAAkB,CAa9B"}

package/lib/tools/built-in/string-schemas.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const shortText: z.ZodString;
+export declare const longText: z.ZodString;
+export declare function enumString<T extends string>(schema: z.ZodString): z.ZodType<T>;

package/lib/tools/built-in/string-schemas.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longText = exports.shortText = void 0;
+exports.enumString = enumString;
+const zod_1 = require("zod");
+// Caps free-text inputs so an oversized value is refused before it reaches the database.
+// shortText matches Vendure's usual varchar(255) columns; longText is for text columns.
+exports.shortText = zod_1.z.string().max(255);
+exports.longText = zod_1.z.string().max(10000);
+function enumString(schema) {
+    return schema;
+}
+//# sourceMappingURL=string-schemas.js.map

package/lib/tools/built-in/string-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-schemas.js","sourceRoot":"","sources":["../../../src/tools/built-in/string-schemas.ts"],"names":[],"mappings":";;;AAQA,gCAEC;AAVD,6BAAwB;AAExB,yFAAyF;AACzF,wFAAwF;AAC3E,QAAA,SAAS,GAAG,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEhC,QAAA,QAAQ,GAAG,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAE9C,SAAgB,UAAU,CAAmB,MAAmB;IAC5D,OAAO,MAAiC,CAAC;AAC7C,CAAC"}

package/lib/transport/mcp-server.factory.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/server';
+import { McpToolset } from '@vendure/mcp-sdk';
+import { McpExecutionContext } from '../internal-types';
+import { McpToolRegistryService } from '../registry/mcp-tool-registry.service';
+/**
+ * @description
+ * Builds a fresh v2 `McpServer` for a single request, registering only the tools the caller is
+ * permitted to see. Each tool is registered with its schema, compiled once at bootstrap, and a
+ * callback that delegates to the registry's execution entry point.
+ *
+ * @since 3.8.0
+ */
+export declare function createMcpServerForRequest(executionContext: McpExecutionContext, toolset: McpToolset, registry: McpToolRegistryService): Promise<McpServer>;

package/lib/transport/mcp-server.factory.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServerForRequest = createMcpServerForRequest;
+const server_1 = require("@modelcontextprotocol/server");
+/** Version advertised in the MCP server's `serverInfo`. Cosmetic — the MCP server implementation version. */
+const MCP_SERVER_VERSION = '1.0.0';
+/**
+ * @description
+ * Builds a fresh v2 `McpServer` for a single request, registering only the tools the caller is
+ * permitted to see. Each tool is registered with its schema, compiled once at bootstrap, and a
+ * callback that delegates to the registry's execution entry point.
+ *
+ * @since 3.8.0
+ */
+async function createMcpServerForRequest(executionContext, toolset, registry) {
+    const server = new server_1.McpServer({ name: `vendure-mcp-${toolset}`, version: MCP_SERVER_VERSION }, 
+    // Overrides the SDK default of true: every request gets a throwaway server with no open connection to notify clients on.
+    { capabilities: { tools: { listChanged: false } } });
+    const tools = await registry.getExposedTools(executionContext, toolset);
+    for (const tool of tools) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.compiledInputSchema,
+            annotations: tool.annotations,
+        }, 
+        // The SDK validates `args` against the registered (wire) schema before this runs.
+        async (args) => registry.callTool(executionContext, toolset, tool.name, args));
+    }
+    return server;
+}
+//# sourceMappingURL=mcp-server.factory.js.map

package/lib/transport/mcp-server.factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.factory.js","sourceRoot":"","sources":["../../src/transport/mcp-server.factory.ts"],"names":[],"mappings":";;AAiBA,8DAyBC;AA1CD,yDAAyD;AAMzD,6GAA6G;AAC7G,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAEnC;;;;;;;GAOG;AACI,KAAK,UAAU,yBAAyB,CAC3C,gBAAqC,EACrC,OAAmB,EACnB,QAAgC;IAEhC,MAAM,MAAM,GAAG,IAAI,kBAAS,CACxB,EAAE,IAAI,EAAE,eAAe,OAAO,EAAE,EAAE,OAAO,EAAE,kBAAkB,EAAE;IAC/D,yHAAyH;IACzH,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,EAAE,CACtD,CAAC;IACF,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,eAAe,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IACxE,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACvB,MAAM,CAAC,YAAY,CACf,IAAI,CAAC,IAAI,EACT;YACI,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,WAAW,EAAE,IAAI,CAAC,mBAAmB;YACrC,WAAW,EAAE,IAAI,CAAC,WAAW;SAChC;QACD,kFAAkF;QAClF,KAAK,EAAE,IAAa,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CACzF,CAAC;IACN,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC"}

package/lib/transport/mcp-transport.controller.d.ts

@@ -0,0 +1,77 @@
+import { ArgumentsHost } from '@nestjs/common';
+import { ChannelNotFoundError, ChannelService, ConfigService, ExceptionLoggerFilter, I18nRequest } from '@vendure/core';
+import type { Response } from 'express';
+import { ResolvedMcpPluginOptions } from '../internal-types';
+import { McpOauthMetadataService } from '../oauth/oauth-metadata.service';
+import { McpOauthService } from '../oauth/oauth.service';
+import { McpRateLimiterService } from '../rate-limit/mcp-rate-limiter.service';
+import { McpToolRegistryService } from '../registry/mcp-tool-registry.service';
+import { McpShopSessionService } from '../shop-session/mcp-shop-session.service';
+export declare class McpChannelTokenExceptionFilter extends ExceptionLoggerFilter {
+    private readonly channelTokenHeader;
+    constructor(configService: ConfigService);
+    catch(exception: ChannelNotFoundError, host: ArgumentsHost): import("@vendure/core").I18nError | undefined;
+}
+/**
+ * @description
+ * HTTP transport for the MCP server. Owns authentication, anonymous shop context, the DNS-rebinding
+ * front guard, and the anonymous-IP and handshake rate-limit checks (kept here, rather than in the
+ * SDK handler, so the `-31029` `error.data` survives). It then delegates JSON-RPC handling to the
+ * v2 SDK handler via `toNodeHandler`, passing the resolved Vendure context through the SDK's
+ * pass-through `authInfo`.
+ */
+export declare class McpTransportController {
+    private readonly oauthService;
+    private readonly registry;
+    private readonly rateLimiter;
+    private readonly configService;
+    private readonly options;
+    private readonly shopSession;
+    private readonly channelService;
+    private readonly oauthMetadata;
+    private readonly nodeHandler;
+    private readonly hostGuard?;
+    private readonly originGuard?;
+    constructor(oauthService: McpOauthService, registry: McpToolRegistryService, rateLimiter: McpRateLimiterService, configService: ConfigService, options: ResolvedMcpPluginOptions, shopSession: McpShopSessionService, channelService: ChannelService, oauthMetadata: McpOauthMetadataService);
+    /** The shop endpoint answers 404 on every verb while shop access is switched off. */
+    private assertShopEnabled;
+    postShop(req: I18nRequest, res: Response, body: unknown): Promise<void>;
+    postAdmin(req: I18nRequest, res: Response, body: unknown): Promise<void>;
+    getShop(res: Response): void;
+    getAdmin(res: Response): void;
+    private handlePost;
+    /** Each guard writes its own 403 response and returns false when it rejects. */
+    private blockedByDnsRebindingGuard;
+    /** The refusals that come after the caller is known. Returns true once one has written the response. */
+    private refusedBeforeDispatch;
+    /** Returns undefined when it has already written the refusal response, rather than a caller. */
+    private resolveCaller;
+    private refusedByPreAuthRateLimits;
+    private anonymousShopExecutionContext;
+    /** True when any message in the body asks to open a subscription stream. */
+    private callsSubscriptionsListen;
+    private sendSubscriptionsUnsupported;
+    private preCheckHandshakeRateLimit;
+    /** A call missing `params` or a tool name never reaches the registry, so it must be charged here instead. */
+    private isRegistryChargedToolCall;
+    private sendRateLimitError;
+    /** Answers a request the SDK never sees: a JSON-RPC error per addressable message, with the given HTTP status. */
+    private sendRefusal;
+    /** One error per message when the body is a batch, so the client can match each refusal to its request. */
+    private refusalPayload;
+    private requestId;
+    /** Narrows an unparsed body entry to an object whose fields can be read; a primitive is not a message. */
+    private isMessage;
+    private usableId;
+    private buildAuthInfo;
+    private authenticateBearerToken;
+    private setAuthChallenge;
+    private methodNotAllowed;
+    private getBearerToken;
+    private createAnonymousShopContext;
+    private getVendureSessionToken;
+    private setVendureSessionToken;
+    /** Same precedence as core's RequestContextService: the query parameter wins over the header. */
+    private getChannelToken;
+    private getHeader;
+}

package/lib/transport/mcp-transport.controller.js

@@ -0,0 +1,442 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpTransportController = exports.McpChannelTokenExceptionFilter = void 0;
+const node_1 = require("@modelcontextprotocol/node");
+const server_1 = require("@modelcontextprotocol/server");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const constants_1 = require("../constants");
+const get_client_ip_1 = require("../get-client-ip");
+const get_language_code_1 = require("../get-language-code");
+const oauth_error_1 = require("../oauth/oauth-error");
+const oauth_metadata_service_1 = require("../oauth/oauth-metadata.service");
+const oauth_service_1 = require("../oauth/oauth.service");
+const mcp_rate_limiter_service_1 = require("../rate-limit/mcp-rate-limiter.service");
+const mcp_tool_registry_service_1 = require("../registry/mcp-tool-registry.service");
+const mcp_shop_session_service_1 = require("../shop-session/mcp-shop-session.service");
+const mcp_server_factory_1 = require("./mcp-server.factory");
+// Deliberately not a valid tool or method name, so it never collides with a real one.
+const MALFORMED_SUBJECT = 'malformed';
+// Converts an invalid channel token to a 400 instead of a 500, keeping Vendure's default response format and logging.
+let McpChannelTokenExceptionFilter = class McpChannelTokenExceptionFilter extends core_1.ExceptionLoggerFilter {
+    constructor(configService) {
+        super(configService);
+        this.channelTokenHeader = configService.apiOptions.channelTokenKey;
+    }
+    catch(exception, host) {
+        return super.catch(new common_1.BadRequestException(`The ${this.channelTokenHeader} query parameter or header does not name a sales channel of this server.`), host);
+    }
+};
+exports.McpChannelTokenExceptionFilter = McpChannelTokenExceptionFilter;
+exports.McpChannelTokenExceptionFilter = McpChannelTokenExceptionFilter = __decorate([
+    (0, common_1.Catch)(core_1.ChannelNotFoundError),
+    __metadata("design:paramtypes", [core_1.ConfigService])
+], McpChannelTokenExceptionFilter);
+/**
+ * @description
+ * HTTP transport for the MCP server. Owns authentication, anonymous shop context, the DNS-rebinding
+ * front guard, and the anonymous-IP and handshake rate-limit checks (kept here, rather than in the
+ * SDK handler, so the `-31029` `error.data` survives). It then delegates JSON-RPC handling to the
+ * v2 SDK handler via `toNodeHandler`, passing the resolved Vendure context through the SDK's
+ * pass-through `authInfo`.
+ */
+let McpTransportController = class McpTransportController {
+    constructor(oauthService, registry, rateLimiter, configService, options, shopSession, channelService, oauthMetadata) {
+        var _a, _b;
+        this.oauthService = oauthService;
+        this.registry = registry;
+        this.rateLimiter = rateLimiter;
+        this.configService = configService;
+        this.options = options;
+        this.shopSession = shopSession;
+        this.channelService = channelService;
+        this.oauthMetadata = oauthMetadata;
+        const handler = (0, server_1.createMcpHandler)(async (mcpCtx) => {
+            var _a;
+            const extra = (_a = mcpCtx.authInfo) === null || _a === void 0 ? void 0 : _a.extra;
+            if (!(extra === null || extra === void 0 ? void 0 : extra.executionContext) || !extra.toolset) {
+                throw new Error('MCP request is missing its resolved execution context');
+            }
+            return (0, mcp_server_factory_1.createMcpServerForRequest)(extra.executionContext, extra.toolset, this.registry);
+        }, {
+            onerror: error => {
+                // JSON.stringify escapes caller text to prevent log forgery
+                core_1.Logger.error(`MCP request handling failed: ${JSON.stringify(error.message)}`, constants_1.loggerCtx);
+            },
+        });
+        this.nodeHandler = (0, node_1.toNodeHandler)(handler, {
+            onerror: error => {
+                core_1.Logger.error(`MCP transport adapter error: ${JSON.stringify(error.message)}`, constants_1.loggerCtx);
+            },
+        });
+        const dns = this.options.dnsRebinding;
+        this.hostGuard = ((_a = dns === null || dns === void 0 ? void 0 : dns.allowedHosts) === null || _a === void 0 ? void 0 : _a.length) ? (0, node_1.hostHeaderValidation)(dns.allowedHosts) : undefined;
+        this.originGuard = ((_b = dns === null || dns === void 0 ? void 0 : dns.allowedOrigins) === null || _b === void 0 ? void 0 : _b.length) ? (0, node_1.originValidation)(dns.allowedOrigins) : undefined;
+    }
+    /** The shop endpoint answers 404 on every verb while shop access is switched off. */
+    assertShopEnabled() {
+        if (this.options.shopAccess === 'disabled') {
+            throw new common_1.NotFoundException();
+        }
+    }
+    async postShop(req, res, body) {
+        this.assertShopEnabled();
+        return this.handlePost('shop', req, res, body);
+    }
+    async postAdmin(req, res, body) {
+        return this.handlePost('admin', req, res, body);
+    }
+    getShop(res) {
+        this.assertShopEnabled();
+        this.methodNotAllowed(res);
+    }
+    getAdmin(res) {
+        this.methodNotAllowed(res);
+    }
+    async handlePost(toolset, req, res, body) {
+        var _a;
+        if (this.blockedByDnsRebindingGuard(req, res)) {
+            return;
+        }
+        const token = this.getBearerToken(this.getHeader(req.headers, 'authorization'));
+        const clientIp = (0, get_client_ip_1.getClientIp)(req);
+        const executionContext = await this.resolveCaller(toolset, req, res, body, token, clientIp);
+        if (!executionContext) {
+            return;
+        }
+        const isJson = (0, server_1.isJsonContentType)((_a = this.getHeader(req.headers, 'content-type')) !== null && _a !== void 0 ? _a : '');
+        if (await this.refusedBeforeDispatch(toolset, res, body, isJson, executionContext)) {
+            return;
+        }
+        req.auth = this.buildAuthInfo(executionContext, toolset, token);
+        await this.nodeHandler(req, res, isJson ? body : undefined);
+    }
+    /** Each guard writes its own 403 response and returns false when it rejects. */
+    blockedByDnsRebindingGuard(req, res) {
+        if (this.hostGuard && !this.hostGuard(req, res)) {
+            return true;
+        }
+        if (this.originGuard && !this.originGuard(req, res)) {
+            return true;
+        }
+        return false;
+    }
+    /** The refusals that come after the caller is known. Returns true once one has written the response. */
+    async refusedBeforeDispatch(toolset, res, body, isJson, executionContext) {
+        // Charged even for a body the SDK will refuse, since resolving the caller already cost a database round trip.
+        const preCheckExceeded = await this.preCheckHandshakeRateLimit(body, toolset, executionContext);
+        if (preCheckExceeded) {
+            this.sendRateLimitError(res, body, preCheckExceeded);
+            return true;
+        }
+        if (isJson && this.callsSubscriptionsListen(body)) {
+            this.sendSubscriptionsUnsupported(res, body);
+            return true;
+        }
+        return false;
+    }
+    /** Returns undefined when it has already written the refusal response, rather than a caller. */
+    async resolveCaller(toolset, req, res, body, token, clientIp) {
+        if (toolset === 'shop' && this.options.shopAccess === 'authenticated' && !token) {
+            this.setAuthChallenge(res, 'shop');
+            throw new common_1.UnauthorizedException('Shop MCP endpoint requires a Bearer token');
+        }
+        if (await this.refusedByPreAuthRateLimits(toolset, res, body, token, clientIp)) {
+            return undefined;
+        }
+        if (toolset === 'admin' && !token) {
+            this.setAuthChallenge(res, 'admin');
+            throw new common_1.UnauthorizedException('Admin MCP endpoint requires a Bearer token');
+        }
+        if (token) {
+            const authContext = await this.authenticateBearerToken(token, toolset, req, res, clientIp);
+            return Object.assign(Object.assign({}, authContext), { clientIp });
+        }
+        return this.anonymousShopExecutionContext(req, res, clientIp);
+    }
+    async refusedByPreAuthRateLimits(toolset, res, body, token, clientIp) {
+        // Rate-limit anonymous shop requests by IP before accessing the database.
+        if (toolset === 'shop' && !token) {
+            const exceeded = await this.rateLimiter.checkAnonymousIpRateLimit(toolset, clientIp);
+            if (exceeded) {
+                this.sendRateLimitError(res, body, exceeded);
+                return true;
+            }
+        }
+        // Checked before the token is looked up, so a flood of made-up tokens does not cost a database query each.
+        if (token) {
+            const exceeded = await this.rateLimiter.checkBearerAuthFailureRateLimit(clientIp);
+            if (exceeded) {
+                this.sendRateLimitError(res, body, exceeded);
+                return true;
+            }
+        }
+        return false;
+    }
+    // Most MCP clients cannot persist headers, so the session token usually arrives as a tool argument.
+    async anonymousShopExecutionContext(req, res, clientIp) {
+        var _a;
+        try {
+            const ctx = await this.createAnonymousShopContext(req, this.getVendureSessionToken(req.headers), this.getChannelToken(req));
+            // Preserve the session token from the header in the response so the client can reuse it.
+            this.setVendureSessionToken(res, (_a = ctx.session) === null || _a === void 0 ? void 0 : _a.token);
+            return { ctx, clientIp };
+        }
+        catch (e) {
+            if (e instanceof common_1.UnauthorizedException) {
+                this.setAuthChallenge(res, 'shop');
+            }
+            throw e;
+        }
+    }
+    /** True when any message in the body asks to open a subscription stream. */
+    callsSubscriptionsListen(body) {
+        const messages = Array.isArray(body) ? body : [body];
+        return messages.some(message => this.isMessage(message) && message.method === 'subscriptions/listen');
+    }
+    // Refused because this plugin never publishes a notification, so such a stream could only ever deliver keep-alive pings.
+    sendSubscriptionsUnsupported(res, body) {
+        // -32601 with HTTP 404 is exactly how the SDK answers a method it does not implement.
+        this.sendRefusal(res, 404, { code: -32601, message: 'Method not found: subscriptions/listen' }, body);
+    }
+    // Notifications are charged too, since they still reach the transport even though they get no reply.
+    async preCheckHandshakeRateLimit(body, toolset, executionContext) {
+        const messages = Array.isArray(body) ? body : [body];
+        for (const message of messages) {
+            if (this.isRegistryChargedToolCall(message)) {
+                continue;
+            }
+            const method = this.isMessage(message) ? message.method : undefined;
+            const exceeded = await this.rateLimiter.checkRateLimit({
+                executionContext,
+                endpoint: toolset,
+                subject: typeof method === 'string' ? method : MALFORMED_SUBJECT,
+            });
+            if (exceeded) {
+                return exceeded;
+            }
+        }
+        return undefined;
+    }
+    /** A call missing `params` or a tool name never reaches the registry, so it must be charged here instead. */
+    isRegistryChargedToolCall(message) {
+        var _a;
+        return (this.isMessage(message) &&
+            message.method === 'tools/call' &&
+            typeof ((_a = message.params) === null || _a === void 0 ? void 0 : _a.name) === 'string');
+    }
+    // HTTP 429 lets proxies and monitoring treat this as a proper refusal; the JSON-RPC body adds retry details for MCP-aware clients.
+    sendRateLimitError(res, body, exceeded) {
+        res.setHeader('Retry-After', String(exceeded.retryAfterSeconds));
+        this.sendRefusal(res, 429, {
+            code: constants_1.RATE_LIMIT_ERROR_CODE,
+            message: exceeded.message,
+            data: {
+                retryAfterSeconds: exceeded.retryAfterSeconds,
+                scope: exceeded.scope,
+            },
+        }, body);
+    }
+    /** Answers a request the SDK never sees: a JSON-RPC error per addressable message, with the given HTTP status. */
+    sendRefusal(res, status, error, body) {
+        res.status(status);
+        res.setHeader('Content-Type', 'application/json');
+        res.send(JSON.stringify(this.refusalPayload(body, error)));
+    }
+    /** One error per message when the body is a batch, so the client can match each refusal to its request. */
+    refusalPayload(body, error) {
+        if (Array.isArray(body)) {
+            const errors = body
+                // Only messages with an id JSON-RPC allows can be addressed by a reply.
+                .filter(message => this.usableId(message) !== undefined)
+                .map(message => ({
+                jsonrpc: '2.0',
+                id: this.requestId(message),
+                error,
+            }));
+            if (errors.length > 0) {
+                return errors;
+            }
+        }
+        return { jsonrpc: '2.0', id: this.requestId(body), error };
+    }
+    requestId(message) {
+        var _a;
+        return (_a = this.usableId(message)) !== null && _a !== void 0 ? _a : null;
+    }
+    /** Narrows an unparsed body entry to an object whose fields can be read; a primitive is not a message. */
+    isMessage(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    usableId(message) {
+        if (!this.isMessage(message)) {
+            return undefined;
+        }
+        const { id } = message;
+        return typeof id === 'string' || typeof id === 'number' || id === null ? id : undefined;
+    }
+    buildAuthInfo(executionContext, toolset, token) {
+        const grant = executionContext.grant;
+        return {
+            // Pass-through only; the SDK does not verify this token.
+            token: token !== null && token !== void 0 ? token : 'anonymous',
+            clientId: (grant === null || grant === void 0 ? void 0 : grant.oauthClientId) != null ? String(grant.oauthClientId) : 'anonymous',
+            scopes: [],
+            expiresAt: (grant === null || grant === void 0 ? void 0 : grant.accessTokenExpiresAt)
+                ? Math.floor(new Date(grant.accessTokenExpiresAt).getTime() / 1000)
+                : undefined,
+            extra: { executionContext, toolset },
+        };
+    }
+    async authenticateBearerToken(token, toolset, req, res, clientIp) {
+        try {
+            return await this.oauthService.authenticateBearerToken(token, toolset, req);
+        }
+        catch (e) {
+            if (e instanceof common_1.UnauthorizedException) {
+                // An access token that reached the end of its lifetime is answered by refreshing,
+                // so it is not a failed authentication attempt and must not spend the budget that
+                // is there to stop token guessing.
+                if (!(e instanceof oauth_error_1.McpAccessTokenExpiredError)) {
+                    await this.rateLimiter.recordBearerAuthFailure(clientIp);
+                }
+                this.setAuthChallenge(res, toolset, { invalidToken: true, description: e.message });
+            }
+            throw e;
+        }
+    }
+    // Per RFC 6750 §3.1: a bare challenge means no credentials were sent, while `error="invalid_token"` means one was sent and rejected.
+    setAuthChallenge(res, toolset, options) {
+        const params = [`resource_metadata="${this.oauthMetadata.protectedResourceMetadataUrl(toolset)}"`];
+        if (options === null || options === void 0 ? void 0 : options.invalidToken) {
+            params.push('error="invalid_token"');
+            if (options.description) {
+                // A header parameter is a quoted string, so only printable ASCII without a quote or backslash can go inside it.
+                const description = options.description.replace(/[^\x20-\x7e]|["\\]/g, '');
+                params.push(`error_description="${description}"`);
+            }
+        }
+        res.setHeader('WWW-Authenticate', `Bearer ${params.join(', ')}`);
+    }
+    methodNotAllowed(res) {
+        res.setHeader('Allow', 'POST');
+        res.status(405).send('Method Not Allowed');
+    }
+    getBearerToken(header) {
+        if (header === undefined) {
+            return undefined;
+        }
+        if (header.slice(0, 6).toLowerCase() !== 'bearer') {
+            return undefined;
+        }
+        const afterScheme = header.slice(6);
+        // "Bearerabc" is not a bearer header: the scheme has to be separated from the token.
+        if (!/^\s/.test(afterScheme)) {
+            return undefined;
+        }
+        const tokenStart = afterScheme.search(/\S/);
+        if (tokenStart === -1) {
+            return undefined;
+        }
+        return afterScheme.slice(tokenStart);
+    }
+    async createAnonymousShopContext(req, sessionToken, channelToken) {
+        const resolution = await this.shopSession.resolveHeaderToken(sessionToken);
+        if (resolution.kind === 'refused') {
+            throw new common_1.UnauthorizedException(resolution.message);
+        }
+        const channel = await this.channelService.getChannelFromToken(channelToken !== null && channelToken !== void 0 ? channelToken : '');
+        return new core_1.RequestContext({
+            apiType: 'shop',
+            channel,
+            languageCode: (0, get_language_code_1.getLanguageCodeFromQuery)(req),
+            session: resolution.session,
+            isAuthorized: false,
+            authorizedAsOwnerOnly: true,
+            req,
+            translationFn: req.t,
+        });
+    }
+    getVendureSessionToken(headers) {
+        const key = this.configService.authOptions.authTokenHeaderKey;
+        const value = this.getHeader(headers, key);
+        return value || undefined;
+    }
+    setVendureSessionToken(res, token) {
+        if (token) {
+            res.setHeader(this.configService.authOptions.authTokenHeaderKey, token);
+        }
+    }
+    /** Same precedence as core's RequestContextService: the query parameter wins over the header. */
+    getChannelToken(req) {
+        var _a;
+        const key = this.configService.apiOptions.channelTokenKey;
+        const fromQuery = (_a = req.query) === null || _a === void 0 ? void 0 : _a[key];
+        if (typeof fromQuery === 'string' && fromQuery) {
+            return fromQuery;
+        }
+        const value = this.getHeader(req.headers, key);
+        return value || undefined;
+    }
+    getHeader(headers, name) {
+        const value = headers[name.toLowerCase()];
+        return Array.isArray(value) ? value[0] : value;
+    }
+};
+exports.McpTransportController = McpTransportController;
+__decorate([
+    (0, common_1.Post)('shop'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], McpTransportController.prototype, "postShop", null);
+__decorate([
+    (0, common_1.Post)('admin'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], McpTransportController.prototype, "postAdmin", null);
+__decorate([
+    (0, common_1.Get)('shop'),
+    __param(0, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], McpTransportController.prototype, "getShop", null);
+__decorate([
+    (0, common_1.Get)('admin'),
+    __param(0, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], McpTransportController.prototype, "getAdmin", null);
+exports.McpTransportController = McpTransportController = __decorate([
+    (0, common_1.UseFilters)(McpChannelTokenExceptionFilter),
+    (0, common_1.Controller)('mcp'),
+    __param(4, (0, common_1.Inject)(constants_1.MCP_PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [oauth_service_1.McpOauthService,
+        mcp_tool_registry_service_1.McpToolRegistryService,
+        mcp_rate_limiter_service_1.McpRateLimiterService,
+        core_1.ConfigService, Object, mcp_shop_session_service_1.McpShopSessionService,
+        core_1.ChannelService,
+        oauth_metadata_service_1.McpOauthMetadataService])
+], McpTransportController);
+//# sourceMappingURL=mcp-transport.controller.js.map