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

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { connectStdio } from './packem_shared/connectStdio-mHv2dT3u.mjs';
+import { connectStdio } from './packem_shared/connectStdio-CeI3w0q7.mjs';
 
 const ENABLED_ENV_VALUES = /* @__PURE__ */ new Set(["1", "on", "true", "yes"]);
 const isEnvEnabled = (value) => value !== void 0 && ENABLED_ENV_VALUES.has(value.trim().toLowerCase());

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 { 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';
+export { createMcpFetchHandler } from './packem_shared/createMcpFetchHandler-D8HWylar.mjs';
+export { createPaidMcpServer } from './packem_shared/createPaidMcpServer-D0vrMTDp.mjs';
+export { connectStdio, createLunoraMcpServer } from './packem_shared/connectStdio-CeI3w0q7.mjs';
+export { READ_ONLY_TOOL_DEFINITIONS, WRITE_TOOL_DEFINITIONS, callTool, toolDefinitions } from './packem_shared/READ_ONLY_TOOL_DEFINITIONS-CWb_wFd5.mjs';

package/dist/packem_shared/{READ_ONLY_TOOL_DEFINITIONS-B5x61zt4.mjs → READ_ONLY_TOOL_DEFINITIONS-CWb_wFd5.mjs}

@@ -66,23 +66,82 @@ const readFunctionPath = (input) => {
   }
   return functionPath;
 };
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const describeArgs = (value) => Array.isArray(value) ? "an array" : `a ${typeof value}`;
+const readArgumentsBag = (raw) => {
+  if (raw === void 0 || raw === null) {
+    return {};
+  }
+  if (typeof raw === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new LunoraError("BAD_REQUEST", `"args" must be a JSON object; received a string that is not valid JSON`);
+    }
+    if (!isPlainObject(parsed)) {
+      throw new LunoraError("BAD_REQUEST", `"args" must be a JSON object; the provided string decoded to ${describeArgs(parsed)}`);
+    }
+    return parsed;
+  }
+  if (!isPlainObject(raw)) {
+    throw new LunoraError("BAD_REQUEST", `"args" must be a JSON object, got ${describeArgs(raw)}`);
+  }
+  return raw;
+};
 const readRunArguments = (input) => {
   const functionPath = readFunctionPath(input);
-  const rawArguments = input.args;
-  const isPlainObject = typeof rawArguments === "object" && rawArguments !== null && !Array.isArray(rawArguments);
-  const args = isPlainObject ? rawArguments : {};
+  const args = readArgumentsBag(input.args);
   const shardKey = typeof input.shardKey === "string" && input.shardKey.length > 0 ? input.shardKey : void 0;
   return { args, functionPath, shardKey };
 };
 const reference = (functionPath) => {
   return { __lunoraRef: functionPath };
 };
+const bytesToBase64 = (bytes) => {
+  let binary = "";
+  const chunk = 32768;
+  for (let index = 0; index < bytes.length; index += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
+  }
+  return btoa(binary);
+};
+const jsonResultReplacer = (_key, value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof ArrayBuffer) {
+    return bytesToBase64(new Uint8Array(value));
+  }
+  if (ArrayBuffer.isView(value)) {
+    const view = value;
+    return bytesToBase64(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+  }
+  return value;
+};
 const ok = (value) => {
-  const text = value === void 0 ? "null" : JSON.stringify(value, void 0, 2);
+  const text = value === void 0 ? "null" : JSON.stringify(value, jsonResultReplacer, 2);
   return { content: [{ text, type: "text" }] };
 };
+const FUNCTIONS_CACHE_TTL_MS = 3e4;
+const functionsCache = /* @__PURE__ */ new WeakMap();
+const listFunctionsCached = (client) => {
+  const now = Date.now();
+  const cached = functionsCache.get(client);
+  if (cached !== void 0 && cached.expiresAt > now) {
+    return cached.promise;
+  }
+  const promise = client.listFunctions().catch((error) => {
+    if (functionsCache.get(client)?.promise === promise) {
+      functionsCache.delete(client);
+    }
+    throw error;
+  });
+  functionsCache.set(client, { expiresAt: now + FUNCTIONS_CACHE_TTL_MS, promise });
+  return promise;
+};
 const assertRunnable = async (client, functionPath, expectedKind) => {
-  const functions = await client.listFunctions();
+  const functions = await listFunctionsCached(client);
   const descriptor = functions.find((function_) => function_.path === functionPath);
   if (descriptor === void 0) {
     throw new LunoraError("NOT_FOUND", `function not found or not public: ${functionPath}`);
@@ -104,7 +163,7 @@ const callTool = async (client, name, input, allowWrites = false) => {
     switch (name) {
       case "lunora_get_function_schema": {
         const functionPath = readFunctionPath(input);
-        const functions = await client.listFunctions();
+        const functions = await listFunctionsCached(client);
         const descriptor = functions.find((function_) => function_.path === functionPath);
         if (descriptor === void 0) {
           return { content: [{ text: `function not found: ${functionPath}`, type: "text" }], isError: true };
@@ -112,7 +171,7 @@ const callTool = async (client, name, input, allowWrites = false) => {
         return ok({ args: descriptor.args ?? [], kind: descriptor.kind, path: descriptor.path });
       }
       case "lunora_list_functions": {
-        return ok(await client.listFunctions());
+        return ok(await listFunctionsCached(client));
       }
       case "lunora_list_tables": {
         return ok(await client.listGlobalTables());

package/dist/packem_shared/{connectStdio-mHv2dT3u.mjs → connectStdio-CeI3w0q7.mjs}

@@ -6,7 +6,7 @@ import { LunoraError } from '@lunora/errors';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { toolDefinitions, callTool } from './READ_ONLY_TOOL_DEFINITIONS-B5x61zt4.mjs';
+import { toolDefinitions, callTool } from './READ_ONLY_TOOL_DEFINITIONS-CWb_wFd5.mjs';
 
 const resolveVersion = () => {
   try {

package/dist/packem_shared/createMcpFetchHandler-D8HWylar.mjs

@@ -0,0 +1,14 @@
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { createLunoraMcpServer } from './connectStdio-CeI3w0q7.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-D0vrMTDp.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-D8HWylar.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.22",
   "description": "Model Context Protocol server exposing a Lunora deployment to AI agents",
   "keywords": [
     "ai-agents",
@@ -49,8 +49,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.20",
-    "@lunora/errors": "1.0.0-alpha.3",
+    "@lunora/client": "1.0.0-alpha.21",
+    "@lunora/errors": "1.0.0-alpha.4",
+    "@lunora/x402": "1.0.0-alpha.2",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {