@lunora/mcp 1.0.0-alpha.20 → 1.0.0-alpha.21

package/dist/index.d.mts

@@ -1,5 +1,8 @@
-import { LunoraClient } from '@lunora/client';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { LunoraClient } from '@lunora/client';
+import { X402ChargeConfig, X402Price } from '@lunora/x402/charge';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
 interface LunoraMcpServerOptions {
   allowWrites?: boolean;
   client?: LunoraClient;
@@ -9,6 +12,8 @@ interface LunoraMcpServerOptions {
 }
 declare const createLunoraMcpServer: (options: LunoraMcpServerOptions) => Server;
 declare const connectStdio: (options: LunoraMcpServerOptions) => Promise<Server>;
+type McpFetchHandler = (request: Request) => Promise<Response>;
+declare const createMcpFetchHandler: (options: LunoraMcpServerOptions) => McpFetchHandler;
 interface ToolInputSchema {
   properties: Record<string, unknown>;
   required?: ReadonlyArray<string>;
@@ -30,4 +35,28 @@ declare const READ_ONLY_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
 declare const WRITE_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
 declare const toolDefinitions: (allowWrites: boolean) => ReadonlyArray<ToolDefinition>;
 declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>, allowWrites?: boolean) => Promise<ToolResult>;
-export { type LunoraMcpServerOptions, READ_ONLY_TOOL_DEFINITIONS, type ToolDefinition, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, connectStdio, createLunoraMcpServer, toolDefinitions };
+type ToolHandler = (arguments_: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+interface RegisterToolOptions {
+  annotations?: Tool["annotations"];
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+}
+interface RegisterPaidToolOptions extends RegisterToolOptions {
+  price: X402Price;
+}
+type PaidMcpChargeConfig = Omit<X402ChargeConfig, "price">;
+interface PaidMcpServerConfig {
+  charge: PaidMcpChargeConfig;
+  serverInfo?: {
+    name: string;
+    version: string;
+  };
+}
+interface PaidMcpServer {
+  readonly fetchHandler: McpFetchHandler;
+  paidTool: (options: RegisterPaidToolOptions, handler: ToolHandler) => void;
+  tool: (options: RegisterToolOptions, handler: ToolHandler) => void;
+}
+declare const createPaidMcpServer: (config: PaidMcpServerConfig) => PaidMcpServer;
+export { type LunoraMcpServerOptions, type McpFetchHandler, type PaidMcpChargeConfig, type PaidMcpServer, type PaidMcpServerConfig, READ_ONLY_TOOL_DEFINITIONS, type RegisterPaidToolOptions, type RegisterToolOptions, type ToolDefinition, type ToolHandler, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, connectStdio, createLunoraMcpServer, createMcpFetchHandler, createPaidMcpServer, toolDefinitions };

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-import { LunoraClient } from '@lunora/client';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { LunoraClient } from '@lunora/client';
+import { X402ChargeConfig, X402Price } from '@lunora/x402/charge';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
 interface LunoraMcpServerOptions {
   allowWrites?: boolean;
   client?: LunoraClient;
@@ -9,6 +12,8 @@ interface LunoraMcpServerOptions {
 }
 declare const createLunoraMcpServer: (options: LunoraMcpServerOptions) => Server;
 declare const connectStdio: (options: LunoraMcpServerOptions) => Promise<Server>;
+type McpFetchHandler = (request: Request) => Promise<Response>;
+declare const createMcpFetchHandler: (options: LunoraMcpServerOptions) => McpFetchHandler;
 interface ToolInputSchema {
   properties: Record<string, unknown>;
   required?: ReadonlyArray<string>;
@@ -30,4 +35,28 @@ declare const READ_ONLY_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
 declare const WRITE_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
 declare const toolDefinitions: (allowWrites: boolean) => ReadonlyArray<ToolDefinition>;
 declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>, allowWrites?: boolean) => Promise<ToolResult>;
-export { type LunoraMcpServerOptions, READ_ONLY_TOOL_DEFINITIONS, type ToolDefinition, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, connectStdio, createLunoraMcpServer, toolDefinitions };
+type ToolHandler = (arguments_: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+interface RegisterToolOptions {
+  annotations?: Tool["annotations"];
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+}
+interface RegisterPaidToolOptions extends RegisterToolOptions {
+  price: X402Price;
+}
+type PaidMcpChargeConfig = Omit<X402ChargeConfig, "price">;
+interface PaidMcpServerConfig {
+  charge: PaidMcpChargeConfig;
+  serverInfo?: {
+    name: string;
+    version: string;
+  };
+}
+interface PaidMcpServer {
+  readonly fetchHandler: McpFetchHandler;
+  paidTool: (options: RegisterPaidToolOptions, handler: ToolHandler) => void;
+  tool: (options: RegisterToolOptions, handler: ToolHandler) => void;
+}
+declare const createPaidMcpServer: (config: PaidMcpServerConfig) => PaidMcpServer;
+export { type LunoraMcpServerOptions, type McpFetchHandler, type PaidMcpChargeConfig, type PaidMcpServer, type PaidMcpServerConfig, READ_ONLY_TOOL_DEFINITIONS, type RegisterPaidToolOptions, type RegisterToolOptions, type ToolDefinition, type ToolHandler, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, connectStdio, createLunoraMcpServer, createMcpFetchHandler, createPaidMcpServer, toolDefinitions };

package/dist/index.mjs

@@ -1,2 +1,4 @@
+export { createMcpFetchHandler } from './packem_shared/createMcpFetchHandler-CGqlLHxj.mjs';
+export { createPaidMcpServer } from './packem_shared/createPaidMcpServer-S7RdldZo.mjs';
 export { connectStdio, createLunoraMcpServer } from './packem_shared/connectStdio-mHv2dT3u.mjs';
 export { READ_ONLY_TOOL_DEFINITIONS, WRITE_TOOL_DEFINITIONS, callTool, toolDefinitions } from './packem_shared/READ_ONLY_TOOL_DEFINITIONS-B5x61zt4.mjs';

package/dist/packem_shared/createMcpFetchHandler-CGqlLHxj.mjs

@@ -0,0 +1,14 @@
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { createLunoraMcpServer } from './connectStdio-mHv2dT3u.mjs';
+
+const serveStateless = async (server, request, options) => {
+  const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true, sessionIdGenerator: void 0 });
+  await server.connect(transport);
+  const response = await transport.handleRequest(request, options);
+  transport.close().catch(() => void 0);
+  server.close().catch(() => void 0);
+  return response;
+};
+const createMcpFetchHandler = (options) => (request) => serveStateless(createLunoraMcpServer(options), request);
+
+export { createMcpFetchHandler, serveStateless };

package/dist/packem_shared/createPaidMcpServer-S7RdldZo.mjs

@@ -0,0 +1,93 @@
+import { LunoraError } from '@lunora/errors';
+import { createChargeMiddleware } from '@lunora/x402/charge';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { serveStateless } from './createMcpFetchHandler-CGqlLHxj.mjs';
+
+const DEFAULT_SERVER_INFO = { name: "lunora-paid-mcp", version: "0.0.0" };
+const CALL_TOOL_METHOD = "tools/call";
+const callToolName = (message) => {
+  if (typeof message !== "object" || message === null) {
+    return void 0;
+  }
+  const { method, params } = message;
+  if (method !== CALL_TOOL_METHOD || typeof params !== "object" || params === null) {
+    return void 0;
+  }
+  const { name } = params;
+  return typeof name === "string" ? name : void 0;
+};
+const refuseBatch = () => Response.json({ error: "A JSON-RPC batch may not reference a paid MCP tool; send paid tools/call requests individually." }, { status: 400 });
+const createPaidMcpServer = (config) => {
+  const tools = /* @__PURE__ */ new Map();
+  const prices = /* @__PURE__ */ new Map();
+  const middlewareByTool = /* @__PURE__ */ new Map();
+  const serverInfo = config.serverInfo ?? DEFAULT_SERVER_INFO;
+  const register = (options, handler, price) => {
+    if (tools.has(options.name)) {
+      throw new LunoraError("BAD_REQUEST", `MCP tool "${options.name}" is already registered.`);
+    }
+    const definition = { description: options.description, inputSchema: options.inputSchema, name: options.name };
+    if (options.annotations !== void 0) {
+      definition.annotations = options.annotations;
+    }
+    tools.set(options.name, { definition, handler });
+    if (price !== void 0) {
+      prices.set(options.name, price);
+    }
+  };
+  const buildServer = () => {
+    const server = new Server(serverInfo, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, () => {
+      return { tools: [...tools.values()].map((entry) => entry.definition) };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const entry = tools.get(request.params.name);
+      if (entry === void 0) {
+        return { content: [{ text: `unknown tool: ${request.params.name}`, type: "text" }], isError: true };
+      }
+      const result = await entry.handler(request.params.arguments ?? {});
+      return result;
+    });
+    return server;
+  };
+  const gateFor = (name, price) => {
+    let pending = middlewareByTool.get(name);
+    if (pending === void 0) {
+      pending = createChargeMiddleware({ ...config.charge, price }, { resource: name }).catch((error) => {
+        middlewareByTool.delete(name);
+        throw error;
+      });
+      middlewareByTool.set(name, pending);
+    }
+    return pending;
+  };
+  const fetchHandler = async (request) => {
+    let parsedBody;
+    try {
+      parsedBody = await request.clone().json();
+    } catch {
+      parsedBody = void 0;
+    }
+    const dispatch = () => serveStateless(buildServer(), request, parsedBody === void 0 ? void 0 : { parsedBody });
+    if (Array.isArray(parsedBody)) {
+      return parsedBody.some((message) => prices.has(callToolName(message) ?? "")) ? refuseBatch() : dispatch();
+    }
+    const name = callToolName(parsedBody);
+    const price = name === void 0 ? void 0 : prices.get(name);
+    if (name === void 0 || price === void 0) {
+      return dispatch();
+    }
+    const middleware = await gateFor(name, price);
+    return middleware.handle(request, dispatch);
+  };
+  const paidTool = (options, handler) => {
+    register(options, handler, options.price);
+  };
+  const tool = (options, handler) => {
+    register(options, handler);
+  };
+  return { fetchHandler, paidTool, tool };
+};
+
+export { createPaidMcpServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/mcp",
-  "version": "1.0.0-alpha.20",
+  "version": "1.0.0-alpha.21",
   "description": "Model Context Protocol server exposing a Lunora deployment to AI agents",
   "keywords": [
     "ai-agents",
@@ -51,6 +51,7 @@
   "dependencies": {
     "@lunora/client": "1.0.0-alpha.20",
     "@lunora/errors": "1.0.0-alpha.3",
+    "@lunora/x402": "1.0.0-alpha.1",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {