@blokjs/trigger-mcp 0.6.12

package/dist/McpTrigger.d.ts

@@ -0,0 +1,114 @@
+/**
+ * McpTrigger — Model Context Protocol trigger. Exposes Blok workflows as
+ * MCP **tools** (and **resources**) to external clients (Cursor, Claude
+ * Code, …) over two transports multiplexed on the shared Hono port:
+ *
+ *   - **SSE (legacy 2024-11-05)** — `GET <path>/sse` opens the stream and
+ *     announces `POST <path>/messages?sessionId=…` for JSON-RPC. This is the
+ *     2-endpoint shape existing IDE configs expect (drop-in parity).
+ *   - **Streamable-HTTP** — a single `<path>` endpoint (the current official
+ *     remote transport), served statelessly via the SDK's web-standard
+ *     transport directly off `c.req.raw`.
+ *
+ * **Authoring surface** — a workflow opts in with `trigger.mcp`:
+ *
+ * ```ts
+ * export default workflow({
+ *   name: "search_code",
+ *   version: "1.0.0",
+ *   input: z.object({ query: z.string(), limit: z.number().optional() }),
+ *   trigger: { mcp: { path: "/mcp", serverName: "tetrix-platform",
+ *                     tool: { description: "Full-text search the indexed code" } } },
+ *   steps: [ { id: "search", use: "@tetrix/meili-search", inputs: { query: $.req.body.query } } ],
+ * });
+ * ```
+ *
+ * Every workflow sharing the same `path` + `serverName` is aggregated into one
+ * MCP server. Each tool's `inputSchema` is generated from the workflow's `input`
+ * Zod schema (via zod-to-json-schema). On `tools/call` the trigger runs the
+ * mapped workflow through the runner — so every call is a Blok Studio run with
+ * tracing / retries / idempotency for free.
+ *
+ * **Hono integration:** identical to `SSETrigger`/`WebhookTrigger` — accepts the
+ * shared `Hono` app + an optional `HttpTriggerLike` exposing `addPreCatchAllHook`
+ * so routes register AFTER the workflow registry is populated but BEFORE the
+ * legacy `/:workflow{.+}` catch-all.
+ *
+ * **Identity:** an `x-user-context` header (or `?user_context=`) carrying base64
+ * `{userId,email}` is parsed per connection and passed to the workflow ctx for
+ * credential injection. It is NOT access control — there is no scoping here
+ * (that's the app's call). Tokens are never logged (the global sanitizer middleware
+ * handles redaction).
+ */
+import { DefaultLogger, type GlobalOptions as RunnerGlobalOptions, TriggerBase } from "@blokjs/runner";
+import type { Hono } from "hono";
+/** Parsed `x-user-context` identity (credential injection only — never scoping). */
+export interface McpUserContext {
+    userId: string;
+    email: string;
+}
+type McpTransportKind = "sse" | "streamable-http";
+interface McpToolMeta {
+    name?: string;
+    description?: string;
+}
+interface McpResourceMeta {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+/** Loosely-read `trigger.mcp` config (validated at workflow load by the helper). */
+interface McpTriggerConfig {
+    path: string;
+    serverName?: string;
+    serverVersion?: string;
+    transports?: McpTransportKind[];
+    tool?: McpToolMeta;
+    resource?: McpResourceMeta;
+    middleware?: string[];
+}
+interface HttpTriggerLike {
+    addPreCatchAllHook(cb: () => void | Promise<void>): void;
+}
+/** Parse a base64-encoded `{userId,email}` identity string. Returns null on any failure. */
+export declare function parseUserContext(value: string | undefined | null): McpUserContext | null;
+export default class McpTrigger extends TriggerBase {
+    protected nodeMap: RunnerGlobalOptions;
+    protected readonly logger: DefaultLogger;
+    protected readonly tracer: import("@opentelemetry/api").Tracer;
+    private readonly meter;
+    private readonly counterToolCalls;
+    private readonly counterSessions;
+    private readonly app;
+    private readonly httpTrigger;
+    private wired;
+    /** Live SSE sessions: sessionId → { transport, server, userContext }. */
+    private sseSessions;
+    constructor(app: Hono<any, any, any>, httpTrigger?: HttpTriggerLike);
+    /** Inject the runner's GlobalOptions (nodes + workflows). Called before `listen()`. */
+    setNodeMap(nodeMap: RunnerGlobalOptions): void;
+    listen(): Promise<number>;
+    stop(): Promise<void>;
+    getStats(): {
+        sessions: number;
+    };
+    private registerRoutesFromRegistry;
+    private getServerGroups;
+    private buildServer;
+    private dispatchTool;
+    private dispatchResource;
+    /**
+     * Run a workflow through the runner and return `ctx.response.data`. Mirrors
+     * the WebhookTrigger request→response dispatch (init → context → middleware →
+     * run). MCP tool calls within a session are serial, matching the shared
+     * `this.configuration` lifecycle the other triggers use.
+     */
+    private runWorkflow;
+    private registerGroupRoutes;
+    private registerSseRoutes;
+    private registerStreamableHttpRoute;
+}
+export declare function _setActiveMcpTrigger(trigger: McpTrigger | null): void;
+export declare function _getActiveMcpTrigger(): McpTrigger | null;
+export type { McpTriggerConfig };

package/dist/McpTrigger.js

@@ -0,0 +1,423 @@
+/**
+ * McpTrigger — Model Context Protocol trigger. Exposes Blok workflows as
+ * MCP **tools** (and **resources**) to external clients (Cursor, Claude
+ * Code, …) over two transports multiplexed on the shared Hono port:
+ *
+ *   - **SSE (legacy 2024-11-05)** — `GET <path>/sse` opens the stream and
+ *     announces `POST <path>/messages?sessionId=…` for JSON-RPC. This is the
+ *     2-endpoint shape existing IDE configs expect (drop-in parity).
+ *   - **Streamable-HTTP** — a single `<path>` endpoint (the current official
+ *     remote transport), served statelessly via the SDK's web-standard
+ *     transport directly off `c.req.raw`.
+ *
+ * **Authoring surface** — a workflow opts in with `trigger.mcp`:
+ *
+ * ```ts
+ * export default workflow({
+ *   name: "search_code",
+ *   version: "1.0.0",
+ *   input: z.object({ query: z.string(), limit: z.number().optional() }),
+ *   trigger: { mcp: { path: "/mcp", serverName: "tetrix-platform",
+ *                     tool: { description: "Full-text search the indexed code" } } },
+ *   steps: [ { id: "search", use: "@tetrix/meili-search", inputs: { query: $.req.body.query } } ],
+ * });
+ * ```
+ *
+ * Every workflow sharing the same `path` + `serverName` is aggregated into one
+ * MCP server. Each tool's `inputSchema` is generated from the workflow's `input`
+ * Zod schema (via zod-to-json-schema). On `tools/call` the trigger runs the
+ * mapped workflow through the runner — so every call is a Blok Studio run with
+ * tracing / retries / idempotency for free.
+ *
+ * **Hono integration:** identical to `SSETrigger`/`WebhookTrigger` — accepts the
+ * shared `Hono` app + an optional `HttpTriggerLike` exposing `addPreCatchAllHook`
+ * so routes register AFTER the workflow registry is populated but BEFORE the
+ * legacy `/:workflow{.+}` catch-all.
+ *
+ * **Identity:** an `x-user-context` header (or `?user_context=`) carrying base64
+ * `{userId,email}` is parsed per connection and passed to the workflow ctx for
+ * credential injection. It is NOT access control — there is no scoping here
+ * (that's the app's call). Tokens are never logged (the global sanitizer middleware
+ * handles redaction).
+ */
+import { DefaultLogger, TriggerBase, WorkflowRegistry, } from "@blokjs/runner";
+import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
+import { Server as McpSdkServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { SpanStatusCode, metrics, trace } from "@opentelemetry/api";
+import { v4 as uuid } from "uuid";
+import { zodToJsonSchema } from "zod-to-json-schema";
+const DEFAULT_SERVER_NAME = "blok-mcp";
+const DEFAULT_SERVER_VERSION = "1.0.0";
+const DEFAULT_TRANSPORTS = ["sse", "streamable-http"];
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+/** Parse a base64-encoded `{userId,email}` identity string. Returns null on any failure. */
+export function parseUserContext(value) {
+    if (!value || typeof value !== "string")
+        return null;
+    try {
+        const decoded = Buffer.from(value, "base64").toString("utf-8");
+        if (!decoded || decoded.trim() === "null")
+            return null;
+        const ctx = JSON.parse(decoded);
+        if (!ctx || typeof ctx.userId !== "string")
+            return null;
+        return { userId: ctx.userId, email: typeof ctx.email === "string" ? ctx.email : "unknown" };
+    }
+    catch {
+        return null;
+    }
+}
+/** Convert a Zod schema to a JSON-Schema object suitable for an MCP tool `inputSchema`. */
+// biome-ignore lint/suspicious/noExplicitAny: zod schema is opaque here
+function toInputJsonSchema(inputZod) {
+    const empty = { type: "object", properties: {}, additionalProperties: true };
+    if (!inputZod || typeof inputZod !== "object" || typeof inputZod.safeParse !== "function") {
+        return empty;
+    }
+    try {
+        const json = zodToJsonSchema(inputZod, { target: "jsonSchema7", $refStrategy: "none" });
+        // biome-ignore lint/performance/noDelete: strip JSON-Schema meta the MCP client doesn't need
+        delete json.$schema;
+        if (json.type !== "object") {
+            return { ...empty, _wrapped: json };
+        }
+        return json;
+    }
+    catch {
+        return empty;
+    }
+}
+// -----------------------------------------------------------------------------
+// Trigger
+// -----------------------------------------------------------------------------
+export default class McpTrigger extends TriggerBase {
+    nodeMap = {};
+    logger = new DefaultLogger();
+    tracer = trace.getTracer(process.env.PROJECT_NAME || "trigger-mcp-workflow", process.env.PROJECT_VERSION || "0.0.1");
+    meter = metrics.getMeter("blok");
+    counterToolCalls = this.meter.createCounter("blok_mcp_tool_calls_total", {
+        description: "MCP tools/call dispatches.",
+        unit: "1",
+    });
+    counterSessions = this.meter.createCounter("blok_mcp_sse_sessions_total", {
+        description: "MCP SSE sessions opened.",
+        unit: "1",
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: Hono generic propagation (matches SSE/WS triggers)
+    app;
+    httpTrigger;
+    wired = false;
+    /** Live SSE sessions: sessionId → { transport, server, userContext }. */
+    sseSessions = new Map();
+    // biome-ignore lint/suspicious/noExplicitAny: matches `app` field generic
+    constructor(app, httpTrigger) {
+        super();
+        this.app = app;
+        this.httpTrigger = httpTrigger ?? null;
+        _setActiveMcpTrigger(this);
+    }
+    /** Inject the runner's GlobalOptions (nodes + workflows). Called before `listen()`. */
+    setNodeMap(nodeMap) {
+        this.nodeMap = nodeMap;
+    }
+    async listen() {
+        const startTime = this.startCounter();
+        if (this.wired) {
+            this.logger.log("[blok][mcp] listen() called twice; ignoring");
+            return this.endCounter(startTime);
+        }
+        this.wired = true;
+        if (this.httpTrigger) {
+            this.httpTrigger.addPreCatchAllHook(() => this.registerRoutesFromRegistry());
+        }
+        else {
+            this.registerRoutesFromRegistry();
+        }
+        return this.endCounter(startTime);
+    }
+    async stop() {
+        for (const { transport } of this.sseSessions.values()) {
+            try {
+                await transport.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.sseSessions.clear();
+        this.wired = false;
+        if (_getActiveMcpTrigger() === this)
+            _setActiveMcpTrigger(null);
+        this.destroyMonitoring();
+        this.logger.log("[blok][mcp] stopped");
+    }
+    getStats() {
+        return { sessions: this.sseSessions.size };
+    }
+    // ---------------------------------------------------------------------------
+    // Registry scan + grouping
+    // ---------------------------------------------------------------------------
+    registerRoutesFromRegistry() {
+        const groups = this.getServerGroups();
+        if (groups.length === 0) {
+            this.logger.log("[blok][mcp] no workflows with trigger.mcp found");
+            return;
+        }
+        for (const group of groups) {
+            this.registerGroupRoutes(group);
+        }
+    }
+    getServerGroups() {
+        const registry = WorkflowRegistry.getInstance();
+        const byPath = new Map();
+        for (const entry of registry.list()) {
+            // Workflows registered as builders expose config on `_config`; plain
+            // objects (tests / JSON) expose it at the top level.
+            const wf = entry.workflow?._config ?? entry.workflow;
+            const cfg = wf?.trigger?.mcp;
+            if (!cfg || typeof cfg.path !== "string")
+                continue;
+            const path = cfg.path;
+            let group = byPath.get(path);
+            if (!group) {
+                group = {
+                    path,
+                    serverName: cfg.serverName || DEFAULT_SERVER_NAME,
+                    serverVersion: cfg.serverVersion || DEFAULT_SERVER_VERSION,
+                    transports: Array.isArray(cfg.transports) && cfg.transports.length > 0 ? cfg.transports : DEFAULT_TRANSPORTS,
+                    tools: [],
+                    resources: [],
+                };
+                byPath.set(path, group);
+            }
+            if (cfg.resource && typeof cfg.resource.uri === "string") {
+                group.resources.push({
+                    workflowName: entry.name,
+                    uri: cfg.resource.uri,
+                    name: cfg.resource.name || entry.name,
+                    description: cfg.resource.description,
+                    mimeType: cfg.resource.mimeType || "application/json",
+                });
+            }
+            else {
+                const inputZod = wf?.input;
+                group.tools.push({
+                    workflowName: entry.name,
+                    toolName: cfg.tool?.name || entry.name,
+                    description: cfg.tool?.description || `Run the "${entry.name}" workflow.`,
+                    inputZod,
+                });
+            }
+        }
+        return [...byPath.values()];
+    }
+    // ---------------------------------------------------------------------------
+    // MCP server factory (one per request/session, bound to a user context)
+    // ---------------------------------------------------------------------------
+    buildServer(group, getUserContext) {
+        const server = new McpSdkServer({ name: group.serverName, version: group.serverVersion }, { capabilities: { tools: {}, resources: {} } });
+        server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: group.tools.map((t) => ({
+                name: t.toolName,
+                description: t.description,
+                inputSchema: toInputJsonSchema(t.inputZod),
+            })),
+        }));
+        server.setRequestHandler(CallToolRequestSchema, async (req) => {
+            const toolName = req.params.name;
+            const tool = group.tools.find((t) => t.toolName === toolName);
+            if (!tool) {
+                return { content: [{ type: "text", text: `Unknown tool: ${toolName}` }], isError: true };
+            }
+            const args = (req.params.arguments ?? {});
+            return this.dispatchTool(tool, args, getUserContext());
+        });
+        if (group.resources.length > 0) {
+            server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+                resources: group.resources.map((r) => ({
+                    uri: r.uri,
+                    name: r.name,
+                    description: r.description,
+                    mimeType: r.mimeType,
+                })),
+            }));
+            server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
+                const uri = req.params.uri;
+                const resource = group.resources.find((r) => r.uri === uri);
+                if (!resource)
+                    throw new Error(`Unknown resource: ${uri}`);
+                const result = await this.dispatchResource(resource, getUserContext());
+                const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+                return { contents: [{ uri: resource.uri, mimeType: resource.mimeType, text }] };
+            });
+        }
+        return server;
+    }
+    // ---------------------------------------------------------------------------
+    // Workflow dispatch (tools/call + resources/read run through the runner)
+    // ---------------------------------------------------------------------------
+    async dispatchTool(tool, args, userContext) {
+        this.counterToolCalls.add(1, { tool: tool.toolName });
+        try {
+            const data = await this.runWorkflow(tool.workflowName, args, userContext, `mcp.tool:${tool.toolName}`);
+            const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.logger.error(`[blok][mcp] tool "${tool.toolName}" failed: ${msg}`);
+            // Tool failure → MCP tool error result, NOT a transport crash.
+            return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+        }
+    }
+    async dispatchResource(resource, userContext) {
+        return this.runWorkflow(resource.workflowName, {}, userContext, `mcp.resource:${resource.uri}`);
+    }
+    /**
+     * Run a workflow through the runner and return `ctx.response.data`. Mirrors
+     * the WebhookTrigger request→response dispatch (init → context → middleware →
+     * run). MCP tool calls within a session are serial, matching the shared
+     * `this.configuration` lifecycle the other triggers use.
+     */
+    async runWorkflow(workflowName, args, userContext, spanLabel) {
+        const requestId = uuid();
+        return this.tracer.startActiveSpan(`mcp:${workflowName}`, async (span) => {
+            try {
+                const registry = WorkflowRegistry.getInstance();
+                const entry = registry.get(workflowName);
+                if (!entry)
+                    throw new Error(`workflow "${workflowName}" not found in registry`);
+                await this.configuration.init(workflowName, this.nodeMap, entry.workflow);
+                const headers = {};
+                if (userContext) {
+                    // Carry identity to the workflow exactly as HTTP would (base64 header).
+                    headers["x-user-context"] = Buffer.from(JSON.stringify(userContext), "utf-8").toString("base64");
+                }
+                const ctx = this.createContext(undefined, workflowName, requestId);
+                ctx.request = {
+                    body: args,
+                    headers,
+                    params: {},
+                    query: {},
+                };
+                ctx._mcp = { userContext };
+                await this.applyMiddlewareChain(ctx, this.nodeMap);
+                await this.run(ctx);
+                span.setAttribute("workflow_name", workflowName);
+                span.setAttribute("mcp_label", spanLabel);
+                span.setStatus({ code: SpanStatusCode.OK });
+                return ctx.response?.data;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                span.recordException(err);
+                span.setStatus({ code: SpanStatusCode.ERROR, message: msg });
+                throw err;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Route registration (SSE + Streamable-HTTP)
+    // ---------------------------------------------------------------------------
+    registerGroupRoutes(group) {
+        this.logger.log(`[blok][mcp] server "${group.serverName}" at ${group.path} — ${group.tools.length} tool(s), ${group.resources.length} resource(s), transports=[${group.transports.join(",")}]`);
+        if (group.transports.includes("sse")) {
+            this.registerSseRoutes(group);
+        }
+        if (group.transports.includes("streamable-http")) {
+            this.registerStreamableHttpRoute(group);
+        }
+    }
+    registerSseRoutes(group) {
+        const ssePath = `${group.path}/sse`;
+        const messagesPath = `${group.path}/messages`;
+        this.logger.log(`[blok][mcp]   GET  ${ssePath}   POST ${messagesPath}  (sse)`);
+        // GET <path>/sse — open the SSE stream; SDK announces the messages endpoint.
+        this.app.get(ssePath, async (c) => {
+            const env = c.env;
+            if (!env?.outgoing) {
+                return c.text("MCP SSE transport requires the Node server (@hono/node-server).", 500);
+            }
+            const rawUserCtx = c.req.header("x-user-context") || (new URL(c.req.url).searchParams.get("user_context") ?? undefined);
+            const userContext = parseUserContext(rawUserCtx);
+            const transport = new SSEServerTransport(messagesPath, env.outgoing);
+            const sessionId = transport.sessionId;
+            const server = this.buildServer(group, () => this.sseSessions.get(sessionId)?.userContext ?? null);
+            this.sseSessions.set(sessionId, { transport, server, userContext });
+            this.counterSessions.add(1, { server: group.serverName });
+            transport.onclose = () => {
+                this.sseSessions.delete(sessionId);
+            };
+            try {
+                await server.connect(transport);
+            }
+            catch (err) {
+                this.sseSessions.delete(sessionId);
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.error(`[blok][mcp] sse connect failed: ${msg}`);
+            }
+            return RESPONSE_ALREADY_SENT;
+        });
+        // POST <path>/messages?sessionId=… — JSON-RPC messages for an open stream.
+        this.app.post(messagesPath, async (c) => {
+            const env = c.env;
+            const sessionId = new URL(c.req.url).searchParams.get("sessionId") ?? undefined;
+            if (!sessionId)
+                return c.text("Missing sessionId query parameter", 400);
+            const session = this.sseSessions.get(sessionId);
+            if (!session)
+                return c.text("Session not found", 404);
+            const body = await c.req.json().catch(() => undefined);
+            try {
+                await session.transport.handlePostMessage(env.incoming, env.outgoing, body);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.error(`[blok][mcp] handlePostMessage failed: ${msg}`);
+                if (!env.outgoing.headersSent)
+                    return c.text("Error handling MCP message", 500);
+            }
+            return RESPONSE_ALREADY_SENT;
+        });
+    }
+    registerStreamableHttpRoute(group) {
+        this.logger.log(`[blok][mcp]   ALL  ${group.path}  (streamable-http)`);
+        // Stateless Streamable-HTTP: a fresh server + transport per request, served
+        // directly off the Fetch `Request` (works on any Hono runtime).
+        this.app.all(group.path, async (c) => {
+            const rawUserCtx = c.req.header("x-user-context") || (new URL(c.req.url).searchParams.get("user_context") ?? undefined);
+            const userContext = parseUserContext(rawUserCtx);
+            const server = this.buildServer(group, () => userContext);
+            const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            try {
+                await server.connect(transport);
+                const res = await transport.handleRequest(c.req.raw);
+                return res;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.error(`[blok][mcp] streamable-http request failed: ${msg}`);
+                return c.json({ jsonrpc: "2.0", error: { code: -32603, message: msg }, id: null }, 500);
+            }
+        });
+    }
+}
+// -----------------------------------------------------------------------------
+// Singleton accessor (parity with SSE/Webhook triggers)
+// -----------------------------------------------------------------------------
+let activeTrigger = null;
+export function _setActiveMcpTrigger(trigger) {
+    activeTrigger = trigger;
+}
+export function _getActiveMcpTrigger() {
+    return activeTrigger;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"McpTrigger.js","sourceRoot":"","sources":["../src/McpTrigger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * McpTrigger — Model Context Protocol trigger. Exposes Blok workflows as\n * MCP **tools** (and **resources**) to external clients (Cursor, Claude\n * Code, …) over two transports multiplexed on the shared Hono port:\n *\n *   - **SSE (legacy 2024-11-05)** — `GET <path>/sse` opens the stream and\n *     announces `POST <path>/messages?sessionId=…` for JSON-RPC. This is the\n *     2-endpoint shape existing IDE configs expect (drop-in parity).\n *   - **Streamable-HTTP** — a single `<path>` endpoint (the current official\n *     remote transport), served statelessly via the SDK's web-standard\n *     transport directly off `c.req.raw`.\n *\n * **Authoring surface** — a workflow opts in with `trigger.mcp`:\n *\n * ```ts\n * export default workflow({\n *   name: \"search_code\",\n *   version: \"1.0.0\",\n *   input: z.object({ query: z.string(), limit: z.number().optional() }),\n *   trigger: { mcp: { path: \"/mcp\", serverName: \"tetrix-platform\",\n *                     tool: { description: \"Full-text search the indexed code\" } } },\n *   steps: [ { id: \"search\", use: \"@tetrix/meili-search\", inputs: { query: $.req.body.query } } ],\n * });\n * ```\n *\n * Every workflow sharing the same `path` + `serverName` is aggregated into one\n * MCP server. Each tool's `inputSchema` is generated from the workflow's `input`\n * Zod schema (via zod-to-json-schema). On `tools/call` the trigger runs the\n * mapped workflow through the runner — so every call is a Blok Studio run with\n * tracing / retries / idempotency for free.\n *\n * **Hono integration:** identical to `SSETrigger`/`WebhookTrigger` — accepts the\n * shared `Hono` app + an optional `HttpTriggerLike` exposing `addPreCatchAllHook`\n * so routes register AFTER the workflow registry is populated but BEFORE the\n * legacy `/:workflow{.+}` catch-all.\n *\n * **Identity:** an `x-user-context` header (or `?user_context=`) carrying base64\n * `{userId,email}` is parsed per connection and passed to the workflow ctx for\n * credential injection. It is NOT access control — there is no scoping here\n * (that's the app's call). Tokens are never logged (the global sanitizer middleware\n * handles redaction).\n */\n\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\nimport {\n\tDefaultLogger,\n\ttype GlobalOptions as RunnerGlobalOptions,\n\tTriggerBase,\n\tWorkflowRegistry,\n} from \"@blokjs/runner\";\nimport type { Context, RequestContext } from \"@blokjs/shared\";\nimport { RESPONSE_ALREADY_SENT } from \"@hono/node-server/utils/response\";\nimport { Server as McpSdkServer } from \"@modelcontextprotocol/sdk/server/index.js\";\nimport { SSEServerTransport } from \"@modelcontextprotocol/sdk/server/sse.js\";\nimport { WebStandardStreamableHTTPServerTransport } from \"@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js\";\nimport {\n\tCallToolRequestSchema,\n\tListResourcesRequestSchema,\n\tListToolsRequestSchema,\n\tReadResourceRequestSchema,\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport { type Span, SpanStatusCode, metrics, trace } from \"@opentelemetry/api\";\nimport type { Hono, Context as HonoContext } from \"hono\";\nimport { v4 as uuid } from \"uuid\";\nimport { zodToJsonSchema } from \"zod-to-json-schema\";\n\n// -----------------------------------------------------------------------------\n// Types\n// -----------------------------------------------------------------------------\n\n/** Parsed `x-user-context` identity (credential injection only — never scoping). */\nexport interface McpUserContext {\n\tuserId: string;\n\temail: string;\n}\n\ntype McpTransportKind = \"sse\" | \"streamable-http\";\n\ninterface McpToolMeta {\n\tname?: string;\n\tdescription?: string;\n}\ninterface McpResourceMeta {\n\turi: string;\n\tname?: string;\n\tdescription?: string;\n\tmimeType?: string;\n}\n\n/** Loosely-read `trigger.mcp` config (validated at workflow load by the helper). */\ninterface McpTriggerConfig {\n\tpath: string;\n\tserverName?: string;\n\tserverVersion?: string;\n\ttransports?: McpTransportKind[];\n\ttool?: McpToolMeta;\n\tresource?: McpResourceMeta;\n\tmiddleware?: string[];\n}\n\ninterface HttpTriggerLike {\n\taddPreCatchAllHook(cb: () => void | Promise<void>): void;\n}\n\n/** A workflow exposed as an MCP tool. */\ninterface ToolEntry {\n\tworkflowName: string;\n\ttoolName: string;\n\tdescription: string;\n\t// biome-ignore lint/suspicious/noExplicitAny: workflow `input` is an opaque ZodType\n\tinputZod: any | undefined;\n}\n\n/** A workflow exposed as an MCP resource. */\ninterface ResourceEntry {\n\tworkflowName: string;\n\turi: string;\n\tname: string;\n\tdescription?: string;\n\tmimeType: string;\n}\n\n/** All workflows that share a (path, serverName) form one MCP server. */\ninterface ServerGroup {\n\tpath: string;\n\tserverName: string;\n\tserverVersion: string;\n\ttransports: McpTransportKind[];\n\ttools: ToolEntry[];\n\tresources: ResourceEntry[];\n}\n\nconst DEFAULT_SERVER_NAME = \"blok-mcp\";\nconst DEFAULT_SERVER_VERSION = \"1.0.0\";\nconst DEFAULT_TRANSPORTS: McpTransportKind[] = [\"sse\", \"streamable-http\"];\n\n// -----------------------------------------------------------------------------\n// Helpers\n// -----------------------------------------------------------------------------\n\n/** Parse a base64-encoded `{userId,email}` identity string. Returns null on any failure. */\nexport function parseUserContext(value: string | undefined | null): McpUserContext | null {\n\tif (!value || typeof value !== \"string\") return null;\n\ttry {\n\t\tconst decoded = Buffer.from(value, \"base64\").toString(\"utf-8\");\n\t\tif (!decoded || decoded.trim() === \"null\") return null;\n\t\tconst ctx = JSON.parse(decoded) as { userId?: string; email?: string };\n\t\tif (!ctx || typeof ctx.userId !== \"string\") return null;\n\t\treturn { userId: ctx.userId, email: typeof ctx.email === \"string\" ? ctx.email : \"unknown\" };\n\t} catch {\n\t\treturn null;\n\t}\n}\n\n/** Convert a Zod schema to a JSON-Schema object suitable for an MCP tool `inputSchema`. */\n// biome-ignore lint/suspicious/noExplicitAny: zod schema is opaque here\nfunction toInputJsonSchema(inputZod: any | undefined): { type: \"object\"; [k: string]: unknown } {\n\tconst empty = { type: \"object\" as const, properties: {}, additionalProperties: true };\n\tif (!inputZod || typeof inputZod !== \"object\" || typeof inputZod.safeParse !== \"function\") {\n\t\treturn empty;\n\t}\n\ttry {\n\t\tconst json = zodToJsonSchema(inputZod, { target: \"jsonSchema7\", $refStrategy: \"none\" }) as Record<string, unknown>;\n\t\t// biome-ignore lint/performance/noDelete: strip JSON-Schema meta the MCP client doesn't need\n\t\tdelete json.$schema;\n\t\tif (json.type !== \"object\") {\n\t\t\treturn { ...empty, _wrapped: json } as { type: \"object\"; [k: string]: unknown };\n\t\t}\n\t\treturn json as { type: \"object\"; [k: string]: unknown };\n\t} catch {\n\t\treturn empty;\n\t}\n}\n\n// -----------------------------------------------------------------------------\n// Trigger\n// -----------------------------------------------------------------------------\n\nexport default class McpTrigger extends TriggerBase {\n\tprotected nodeMap: RunnerGlobalOptions = {} as RunnerGlobalOptions;\n\tprotected readonly logger = new DefaultLogger();\n\tprotected readonly tracer = trace.getTracer(\n\t\tprocess.env.PROJECT_NAME || \"trigger-mcp-workflow\",\n\t\tprocess.env.PROJECT_VERSION || \"0.0.1\",\n\t);\n\tprivate readonly meter = metrics.getMeter(\"blok\");\n\tprivate readonly counterToolCalls = this.meter.createCounter(\"blok_mcp_tool_calls_total\", {\n\t\tdescription: \"MCP tools/call dispatches.\",\n\t\tunit: \"1\",\n\t});\n\tprivate readonly counterSessions = this.meter.createCounter(\"blok_mcp_sse_sessions_total\", {\n\t\tdescription: \"MCP SSE sessions opened.\",\n\t\tunit: \"1\",\n\t});\n\n\t// biome-ignore lint/suspicious/noExplicitAny: Hono generic propagation (matches SSE/WS triggers)\n\tprivate readonly app: Hono<any, any, any>;\n\tprivate readonly httpTrigger: HttpTriggerLike | null;\n\tprivate wired = false;\n\n\t/** Live SSE sessions: sessionId → { transport, server, userContext }. */\n\tprivate sseSessions = new Map<\n\t\tstring,\n\t\t{ transport: SSEServerTransport; server: McpSdkServer; userContext: McpUserContext | null }\n\t>();\n\n\t// biome-ignore lint/suspicious/noExplicitAny: matches `app` field generic\n\tconstructor(app: Hono<any, any, any>, httpTrigger?: HttpTriggerLike) {\n\t\tsuper();\n\t\tthis.app = app;\n\t\tthis.httpTrigger = httpTrigger ?? null;\n\t\t_setActiveMcpTrigger(this);\n\t}\n\n\t/** Inject the runner's GlobalOptions (nodes + workflows). Called before `listen()`. */\n\tsetNodeMap(nodeMap: RunnerGlobalOptions): void {\n\t\tthis.nodeMap = nodeMap;\n\t}\n\n\tasync listen(): Promise<number> {\n\t\tconst startTime = this.startCounter();\n\t\tif (this.wired) {\n\t\t\tthis.logger.log(\"[blok][mcp] listen() called twice; ignoring\");\n\t\t\treturn this.endCounter(startTime);\n\t\t}\n\t\tthis.wired = true;\n\n\t\tif (this.httpTrigger) {\n\t\t\tthis.httpTrigger.addPreCatchAllHook(() => this.registerRoutesFromRegistry());\n\t\t} else {\n\t\t\tthis.registerRoutesFromRegistry();\n\t\t}\n\t\treturn this.endCounter(startTime);\n\t}\n\n\tasync stop(): Promise<void> {\n\t\tfor (const { transport } of this.sseSessions.values()) {\n\t\t\ttry {\n\t\t\t\tawait transport.close();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.sseSessions.clear();\n\t\tthis.wired = false;\n\t\tif (_getActiveMcpTrigger() === this) _setActiveMcpTrigger(null);\n\t\tthis.destroyMonitoring();\n\t\tthis.logger.log(\"[blok][mcp] stopped\");\n\t}\n\n\tgetStats(): { sessions: number } {\n\t\treturn { sessions: this.sseSessions.size };\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// Registry scan + grouping\n\t// ---------------------------------------------------------------------------\n\n\tprivate registerRoutesFromRegistry(): void {\n\t\tconst groups = this.getServerGroups();\n\t\tif (groups.length === 0) {\n\t\t\tthis.logger.log(\"[blok][mcp] no workflows with trigger.mcp found\");\n\t\t\treturn;\n\t\t}\n\t\tfor (const group of groups) {\n\t\t\tthis.registerGroupRoutes(group);\n\t\t}\n\t}\n\n\tprivate getServerGroups(): ServerGroup[] {\n\t\tconst registry = WorkflowRegistry.getInstance();\n\t\tconst byPath = new Map<string, ServerGroup>();\n\n\t\tfor (const entry of registry.list()) {\n\t\t\t// Workflows registered as builders expose config on `_config`; plain\n\t\t\t// objects (tests / JSON) expose it at the top level.\n\t\t\tconst wf = (entry.workflow as { _config?: unknown })?._config ?? entry.workflow;\n\t\t\tconst cfg = (wf as { trigger?: { mcp?: McpTriggerConfig } })?.trigger?.mcp;\n\t\t\tif (!cfg || typeof cfg.path !== \"string\") continue;\n\n\t\t\tconst path = cfg.path;\n\t\t\tlet group = byPath.get(path);\n\t\t\tif (!group) {\n\t\t\t\tgroup = {\n\t\t\t\t\tpath,\n\t\t\t\t\tserverName: cfg.serverName || DEFAULT_SERVER_NAME,\n\t\t\t\t\tserverVersion: cfg.serverVersion || DEFAULT_SERVER_VERSION,\n\t\t\t\t\ttransports: Array.isArray(cfg.transports) && cfg.transports.length > 0 ? cfg.transports : DEFAULT_TRANSPORTS,\n\t\t\t\t\ttools: [],\n\t\t\t\t\tresources: [],\n\t\t\t\t};\n\t\t\t\tbyPath.set(path, group);\n\t\t\t}\n\n\t\t\tif (cfg.resource && typeof cfg.resource.uri === \"string\") {\n\t\t\t\tgroup.resources.push({\n\t\t\t\t\tworkflowName: entry.name,\n\t\t\t\t\turi: cfg.resource.uri,\n\t\t\t\t\tname: cfg.resource.name || entry.name,\n\t\t\t\t\tdescription: cfg.resource.description,\n\t\t\t\t\tmimeType: cfg.resource.mimeType || \"application/json\",\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tconst inputZod = (wf as { input?: unknown })?.input;\n\t\t\t\tgroup.tools.push({\n\t\t\t\t\tworkflowName: entry.name,\n\t\t\t\t\ttoolName: cfg.tool?.name || entry.name,\n\t\t\t\t\tdescription: cfg.tool?.description || `Run the \"${entry.name}\" workflow.`,\n\t\t\t\t\tinputZod,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn [...byPath.values()];\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// MCP server factory (one per request/session, bound to a user context)\n\t// ---------------------------------------------------------------------------\n\n\tprivate buildServer(group: ServerGroup, getUserContext: () => McpUserContext | null): McpSdkServer {\n\t\tconst server = new McpSdkServer(\n\t\t\t{ name: group.serverName, version: group.serverVersion },\n\t\t\t{ capabilities: { tools: {}, resources: {} } },\n\t\t);\n\n\t\tserver.setRequestHandler(ListToolsRequestSchema, async () => ({\n\t\t\ttools: group.tools.map((t) => ({\n\t\t\t\tname: t.toolName,\n\t\t\t\tdescription: t.description,\n\t\t\t\tinputSchema: toInputJsonSchema(t.inputZod),\n\t\t\t})),\n\t\t}));\n\n\t\tserver.setRequestHandler(CallToolRequestSchema, async (req) => {\n\t\t\tconst toolName = req.params.name;\n\t\t\tconst tool = group.tools.find((t) => t.toolName === toolName);\n\t\t\tif (!tool) {\n\t\t\t\treturn { content: [{ type: \"text\", text: `Unknown tool: ${toolName}` }], isError: true };\n\t\t\t}\n\t\t\tconst args = (req.params.arguments ?? {}) as Record<string, unknown>;\n\t\t\treturn this.dispatchTool(tool, args, getUserContext());\n\t\t});\n\n\t\tif (group.resources.length > 0) {\n\t\t\tserver.setRequestHandler(ListResourcesRequestSchema, async () => ({\n\t\t\t\tresources: group.resources.map((r) => ({\n\t\t\t\t\turi: r.uri,\n\t\t\t\t\tname: r.name,\n\t\t\t\t\tdescription: r.description,\n\t\t\t\t\tmimeType: r.mimeType,\n\t\t\t\t})),\n\t\t\t}));\n\n\t\t\tserver.setRequestHandler(ReadResourceRequestSchema, async (req) => {\n\t\t\t\tconst uri = req.params.uri;\n\t\t\t\tconst resource = group.resources.find((r) => r.uri === uri);\n\t\t\t\tif (!resource) throw new Error(`Unknown resource: ${uri}`);\n\t\t\t\tconst result = await this.dispatchResource(resource, getUserContext());\n\t\t\t\tconst text = typeof result === \"string\" ? result : JSON.stringify(result, null, 2);\n\t\t\t\treturn { contents: [{ uri: resource.uri, mimeType: resource.mimeType, text }] };\n\t\t\t});\n\t\t}\n\n\t\treturn server;\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// Workflow dispatch (tools/call + resources/read run through the runner)\n\t// ---------------------------------------------------------------------------\n\n\tprivate async dispatchTool(\n\t\ttool: ToolEntry,\n\t\targs: Record<string, unknown>,\n\t\tuserContext: McpUserContext | null,\n\t): Promise<{ content: Array<{ type: \"text\"; text: string }>; isError?: boolean }> {\n\t\tthis.counterToolCalls.add(1, { tool: tool.toolName });\n\t\ttry {\n\t\t\tconst data = await this.runWorkflow(tool.workflowName, args, userContext, `mcp.tool:${tool.toolName}`);\n\t\t\tconst text = typeof data === \"string\" ? data : JSON.stringify(data, null, 2);\n\t\t\treturn { content: [{ type: \"text\", text }] };\n\t\t} catch (err) {\n\t\t\tconst msg = err instanceof Error ? err.message : String(err);\n\t\t\tthis.logger.error(`[blok][mcp] tool \"${tool.toolName}\" failed: ${msg}`);\n\t\t\t// Tool failure → MCP tool error result, NOT a transport crash.\n\t\t\treturn { content: [{ type: \"text\", text: `Error: ${msg}` }], isError: true };\n\t\t}\n\t}\n\n\tprivate async dispatchResource(resource: ResourceEntry, userContext: McpUserContext | null): Promise<unknown> {\n\t\treturn this.runWorkflow(resource.workflowName, {}, userContext, `mcp.resource:${resource.uri}`);\n\t}\n\n\t/**\n\t * Run a workflow through the runner and return `ctx.response.data`. Mirrors\n\t * the WebhookTrigger request→response dispatch (init → context → middleware →\n\t * run). MCP tool calls within a session are serial, matching the shared\n\t * `this.configuration` lifecycle the other triggers use.\n\t */\n\tprivate async runWorkflow(\n\t\tworkflowName: string,\n\t\targs: Record<string, unknown>,\n\t\tuserContext: McpUserContext | null,\n\t\tspanLabel: string,\n\t): Promise<unknown> {\n\t\tconst requestId = uuid();\n\t\treturn this.tracer.startActiveSpan(`mcp:${workflowName}`, async (span: Span) => {\n\t\t\ttry {\n\t\t\t\tconst registry = WorkflowRegistry.getInstance();\n\t\t\t\tconst entry = registry.get(workflowName);\n\t\t\t\tif (!entry) throw new Error(`workflow \"${workflowName}\" not found in registry`);\n\t\t\t\tawait this.configuration.init(workflowName, this.nodeMap, entry.workflow);\n\n\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\tif (userContext) {\n\t\t\t\t\t// Carry identity to the workflow exactly as HTTP would (base64 header).\n\t\t\t\t\theaders[\"x-user-context\"] = Buffer.from(JSON.stringify(userContext), \"utf-8\").toString(\"base64\");\n\t\t\t\t}\n\n\t\t\t\tconst ctx: Context = this.createContext(undefined, workflowName, requestId);\n\t\t\t\tctx.request = {\n\t\t\t\t\tbody: args,\n\t\t\t\t\theaders,\n\t\t\t\t\tparams: {},\n\t\t\t\t\tquery: {},\n\t\t\t\t} as unknown as RequestContext;\n\t\t\t\t(ctx as Record<string, unknown>)._mcp = { userContext };\n\n\t\t\t\tawait this.applyMiddlewareChain(ctx, this.nodeMap);\n\t\t\t\tawait this.run(ctx);\n\n\t\t\t\tspan.setAttribute(\"workflow_name\", workflowName);\n\t\t\t\tspan.setAttribute(\"mcp_label\", spanLabel);\n\t\t\t\tspan.setStatus({ code: SpanStatusCode.OK });\n\t\t\t\treturn ctx.response?.data;\n\t\t\t} catch (err) {\n\t\t\t\tconst msg = err instanceof Error ? err.message : String(err);\n\t\t\t\tspan.recordException(err as Error);\n\t\t\t\tspan.setStatus({ code: SpanStatusCode.ERROR, message: msg });\n\t\t\t\tthrow err;\n\t\t\t} finally {\n\t\t\t\tspan.end();\n\t\t\t}\n\t\t});\n\t}\n\n\t// ---------------------------------------------------------------------------\n\t// Route registration (SSE + Streamable-HTTP)\n\t// ---------------------------------------------------------------------------\n\n\tprivate registerGroupRoutes(group: ServerGroup): void {\n\t\tthis.logger.log(\n\t\t\t`[blok][mcp] server \"${group.serverName}\" at ${group.path} — ${group.tools.length} tool(s), ${group.resources.length} resource(s), transports=[${group.transports.join(\",\")}]`,\n\t\t);\n\n\t\tif (group.transports.includes(\"sse\")) {\n\t\t\tthis.registerSseRoutes(group);\n\t\t}\n\t\tif (group.transports.includes(\"streamable-http\")) {\n\t\t\tthis.registerStreamableHttpRoute(group);\n\t\t}\n\t}\n\n\tprivate registerSseRoutes(group: ServerGroup): void {\n\t\tconst ssePath = `${group.path}/sse`;\n\t\tconst messagesPath = `${group.path}/messages`;\n\t\tthis.logger.log(`[blok][mcp]   GET  ${ssePath}   POST ${messagesPath}  (sse)`);\n\n\t\t// GET <path>/sse — open the SSE stream; SDK announces the messages endpoint.\n\t\tthis.app.get(ssePath, async (c: HonoContext) => {\n\t\t\tconst env = c.env as unknown as { incoming: IncomingMessage; outgoing: ServerResponse };\n\t\t\tif (!env?.outgoing) {\n\t\t\t\treturn c.text(\"MCP SSE transport requires the Node server (@hono/node-server).\", 500);\n\t\t\t}\n\t\t\tconst rawUserCtx =\n\t\t\t\tc.req.header(\"x-user-context\") || (new URL(c.req.url).searchParams.get(\"user_context\") ?? undefined);\n\t\t\tconst userContext = parseUserContext(rawUserCtx);\n\n\t\t\tconst transport = new SSEServerTransport(messagesPath, env.outgoing);\n\t\t\tconst sessionId = transport.sessionId;\n\t\t\tconst server = this.buildServer(group, () => this.sseSessions.get(sessionId)?.userContext ?? null);\n\t\t\tthis.sseSessions.set(sessionId, { transport, server, userContext });\n\t\t\tthis.counterSessions.add(1, { server: group.serverName });\n\n\t\t\ttransport.onclose = () => {\n\t\t\t\tthis.sseSessions.delete(sessionId);\n\t\t\t};\n\n\t\t\ttry {\n\t\t\t\tawait server.connect(transport);\n\t\t\t} catch (err) {\n\t\t\t\tthis.sseSessions.delete(sessionId);\n\t\t\t\tconst msg = err instanceof Error ? err.message : String(err);\n\t\t\t\tthis.logger.error(`[blok][mcp] sse connect failed: ${msg}`);\n\t\t\t}\n\t\t\treturn RESPONSE_ALREADY_SENT;\n\t\t});\n\n\t\t// POST <path>/messages?sessionId=… — JSON-RPC messages for an open stream.\n\t\tthis.app.post(messagesPath, async (c: HonoContext) => {\n\t\t\tconst env = c.env as unknown as { incoming: IncomingMessage; outgoing: ServerResponse };\n\t\t\tconst sessionId = new URL(c.req.url).searchParams.get(\"sessionId\") ?? undefined;\n\t\t\tif (!sessionId) return c.text(\"Missing sessionId query parameter\", 400);\n\t\t\tconst session = this.sseSessions.get(sessionId);\n\t\t\tif (!session) return c.text(\"Session not found\", 404);\n\t\t\tconst body = await c.req.json().catch(() => undefined);\n\t\t\ttry {\n\t\t\t\tawait session.transport.handlePostMessage(env.incoming, env.outgoing, body);\n\t\t\t} catch (err) {\n\t\t\t\tconst msg = err instanceof Error ? err.message : String(err);\n\t\t\t\tthis.logger.error(`[blok][mcp] handlePostMessage failed: ${msg}`);\n\t\t\t\tif (!env.outgoing.headersSent) return c.text(\"Error handling MCP message\", 500);\n\t\t\t}\n\t\t\treturn RESPONSE_ALREADY_SENT;\n\t\t});\n\t}\n\n\tprivate registerStreamableHttpRoute(group: ServerGroup): void {\n\t\tthis.logger.log(`[blok][mcp]   ALL  ${group.path}  (streamable-http)`);\n\n\t\t// Stateless Streamable-HTTP: a fresh server + transport per request, served\n\t\t// directly off the Fetch `Request` (works on any Hono runtime).\n\t\tthis.app.all(group.path, async (c: HonoContext) => {\n\t\t\tconst rawUserCtx =\n\t\t\t\tc.req.header(\"x-user-context\") || (new URL(c.req.url).searchParams.get(\"user_context\") ?? undefined);\n\t\t\tconst userContext = parseUserContext(rawUserCtx);\n\n\t\t\tconst server = this.buildServer(group, () => userContext);\n\t\t\tconst transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined });\n\t\t\ttry {\n\t\t\t\tawait server.connect(transport);\n\t\t\t\tconst res = await transport.handleRequest(c.req.raw);\n\t\t\t\treturn res;\n\t\t\t} catch (err) {\n\t\t\t\tconst msg = err instanceof Error ? err.message : String(err);\n\t\t\t\tthis.logger.error(`[blok][mcp] streamable-http request failed: ${msg}`);\n\t\t\t\treturn c.json({ jsonrpc: \"2.0\", error: { code: -32603, message: msg }, id: null }, 500);\n\t\t\t}\n\t\t});\n\t}\n}\n\n// -----------------------------------------------------------------------------\n// Singleton accessor (parity with SSE/Webhook triggers)\n// -----------------------------------------------------------------------------\n\nlet activeTrigger: McpTrigger | null = null;\nexport function _setActiveMcpTrigger(trigger: McpTrigger | null): void {\n\tactiveTrigger = trigger;\n}\nexport function _getActiveMcpTrigger(): McpTrigger | null {\n\treturn activeTrigger;\n}\n\nexport type { McpTriggerConfig };\n"]}