@lunora/mcp 1.0.0-alpha.13 → 1.0.0-alpha.131

package/dist/packem_shared/createMcpFetchHandler-DSK2X9Hd.mjs

@@ -0,0 +1 @@
+import{serveStateless as c}from"./DEFAULT_MAX_REQUEST_BYTES-CbbpkHRK.mjs";import{DEFAULT_MAX_REQUEST_BYTES as u}from"./DEFAULT_MAX_REQUEST_BYTES-CbbpkHRK.mjs";import{resolveClient as s,createLunoraMcpServer as a}from"./connectStdio-BBtfW4UB.mjs";const l=e=>{const r=s(e);return t=>c(a({...e,client:r}),t,{maxRequestBytes:e.maxRequestBytes})};export{u as DEFAULT_MAX_REQUEST_BYTES,l as createMcpFetchHandler,c as serveStateless};

package/dist/packem_shared/createPaidMcpServer-BIBKMtxs.mjs

@@ -0,0 +1 @@
+import{LunoraError as y}from"@lunora/errors";import{Server as g}from"@modelcontextprotocol/sdk/server/index.js";import{ListToolsRequestSchema as E,CallToolRequestSchema as x}from"@modelcontextprotocol/sdk/types.js";import{readScreenedBody as T,serveStateless as B}from"./DEFAULT_MAX_REQUEST_BYTES-CbbpkHRK.mjs";const M=(t,o,a,c)=>{const l=t.get(o);if(l!==void 0)return l;const i=a().catch(u=>{throw t.get(o)===i&&t.delete(o),u});return t.set(o,i),i},C=async()=>{try{return(await import("@lunora/x402/charge")).createChargeMiddleware}catch(t){throw new y("INTERNAL",`paid MCP tools need the optional peer "@lunora/x402" — install it alongside @lunora/mcp to charge for tools (${t instanceof Error?t.message:String(t)})`)}},A={name:"lunora-paid-mcp",version:"0.0.0"},L="tools/call",v=t=>{if(typeof t!="object"||t===null)return;const{method:o,params:a}=t;if(o!==L||typeof a!="object"||a===null)return;const{name:c}=a;return typeof c=="string"?c:void 0},q=()=>Response.json({error:"A JSON-RPC batch may not reference a paid MCP tool; send paid tools/call requests individually."},{status:400}),I=t=>{const o=new Map,a=new Map,c=new Map,l=t.serverInfo??A,i=(e,r,s)=>{if(o.has(e.name))throw new y("BAD_REQUEST",`MCP tool "${e.name}" is already registered.`);const n={description:e.description,inputSchema:e.inputSchema,name:e.name};e.annotations!==void 0&&(n.annotations=e.annotations),o.set(e.name,{definition:n,handler:r}),s!==void 0&&a.set(e.name,s)},u=()=>{const e=new g(l,{capabilities:{tools:{}}});return e.setRequestHandler(E,()=>({tools:[...o.values()].map(r=>r.definition)})),e.setRequestHandler(x,async r=>{const s=o.get(r.params.name);if(s===void 0)return{content:[{text:`unknown tool: ${r.params.name}`,type:"text"}],isError:!0};try{return await s.handler(r.params.arguments??{})}catch(n){return{content:[{text:n instanceof Error?n.message:String(n),type:"text"}],isError:!0}}}),e},w=(e,r)=>M(c,e,async()=>(await C())({...t.charge,price:r},{resource:e}));return{fetchHandler:async(e,r,s)=>{const n=await T(e.clone(),t.maxRequestBytes);if("response"in n)return n.response;const{parsedBody:d}=n,p=()=>B(u(),e,d===void 0?{maxRequestBytes:t.maxRequestBytes}:{maxRequestBytes:t.maxRequestBytes,parsedBody:d});if(Array.isArray(d))return d.some(f=>a.has(v(f)??""))?q():p();const m=v(d),h=m===void 0?void 0:a.get(m);if(m===void 0||h===void 0)return p();const R=await w(m,h),S=typeof s?.waitUntil=="function"?{waitUntil:f=>{s.waitUntil?.(f)}}:void 0;return R.handle(e,p,S)},paidTool:(e,r)=>{i(e,r,e.price)},tool:(e,r)=>{i(e,r)}}};export{I as createPaidMcpServer};

package/dist/packem_shared/createToolServer-BtGuPyMU.mjs

@@ -0,0 +1 @@
+import{Server as l}from"@modelcontextprotocol/sdk/server/index.js";import{ListToolsRequestSchema as d,CallToolRequestSchema as f,ListResourcesRequestSchema as p,ReadResourceRequestSchema as R}from"@modelcontextprotocol/sdk/types.js";const v=(c,u,o)=>{const s=new Map;for(const e of u)s.has(e.definition.name)||s.set(e.definition.name,e);const m=[...s.values()].map(e=>e.definition),r=new l(c,{capabilities:o===void 0?{tools:{}}:{resources:{},tools:{}}});return r.setRequestHandler(d,()=>({tools:m})),r.setRequestHandler(f,async e=>{const{arguments:n,name:t}=e.params,i=s.get(t);if(i===void 0)return{content:[{text:`unknown tool: ${t}`,type:"text"}],isError:!0};try{return await i.handle(n??{})}catch(a){return{content:[{text:a instanceof Error?a.message:String(a),type:"text"}],isError:!0}}}),o!==void 0&&(r.setRequestHandler(p,async()=>({resources:[...await o.list()]})),r.setRequestHandler(R,async e=>{const{uri:n}=e.params,t=await o.read(n);if(t===void 0)throw new Error(`unknown resource: ${n}`);return{contents:[{mimeType:t.mimeType??"text/plain",text:t.text,uri:n}]}})),r};export{v as createToolServer};

package/dist/packem_shared/observability-tools-B-g9Y9IT.mjs

@@ -0,0 +1 @@
+import{LunoraError as v}from"@lunora/errors";import{ADMIN_FUNCTIONS as d}from"@lunora/shard-engine";const _=e=>{let t="";for(let s=0;s<e.length;s+=32768)t+=String.fromCharCode(...e.subarray(s,s+32768));return btoa(t)},T=(e,t)=>{if(typeof t=="bigint")return t.toString();if(t instanceof ArrayBuffer)return _(new Uint8Array(t));if(ArrayBuffer.isView(t)){const r=t;return _(new Uint8Array(r.buffer,r.byteOffset,r.byteLength))}return t},N=e=>JSON.parse(JSON.stringify(e,T)),R=e=>({content:[{text:e===void 0?"null":JSON.stringify(e,T,2),type:"text"}]}),u=e=>({...R(e),structuredContent:N(e)}),V=e=>({content:[{text:e,type:"text"}],isError:!0}),p={destructiveHint:!1,idempotentHint:!0,openWorldHint:!0,readOnlyHint:!0},I=50,w=500,A=["1m","5m","15m","1h"],E=["open","resolved","ignored"],O=["trace","debug","log","info","warn","error","fatal"],m={description:"Shard to read from on a .shardBy()-partitioned deployment. Omit for the default (unsharded) shard — these reads are PER-SHARD, not deployment-wide.",type:"string"},y={description:`Maximum rows to return (default ${I.toString()}, clamped to ${w.toString()}).`,type:"number"},U=e=>{const t=typeof e=="number"?e:Number.NaN;return Number.isFinite(t)?Math.max(1,Math.min(Math.floor(t),w)):I},S=(e,t)=>t.includes(e)?e:void 0,b=e=>typeof e=="string"&&e.length>0?e:void 0,P={properties:{level:{description:`Keep only entries at this severity. One of: ${O.join(", ")}.`,type:"string"},limit:y,shardKey:m},type:"object"},L={properties:{functionPathPrefix:{description:'Keep only Issues whose function path starts with this, e.g. "messages:".',type:"string"},limit:y,shardKey:m,status:{description:`Triage status to keep. One of: ${E.join(", ")}. Default: all.`,type:"string"}},type:"object"},M={properties:{limit:y,shardKey:m},type:"object"},k={properties:{limit:y,range:{description:`Time window to report over. One of: ${A.join(", ")}. Default: 15m.`,type:"string"},shardKey:m},type:"object"},H={properties:{shardKey:m},type:"object"},C={properties:{dropped:{description:"Entries the shard's in-memory ring EVICTED before this read — they are gone and cannot be fetched. Non-zero means `entries` + `total` describe only the newest slice of what the deployment logged.",type:"number"},entries:{description:"Recent log entries, NEWEST FIRST: { level, message, timestamp, functionPath?, fields? }.",type:"array"},total:{description:"Entries still in the ring matching `level`, before `limit` narrowed them. NOT the number of lines logged — see `dropped`.",type:"number"}},required:["dropped","entries","total"],type:"object"},x={properties:{issues:{description:"Grouped error Issues, newest first: { hash, title, count, status, functionPath, lastSeen, … }.",type:"array"}},required:["issues"],type:"object"},j={properties:{advisories:{description:"Schema/query advisories: { id, level, title, detail, … }.",type:"array"},total:{description:"Advisories available before `limit` narrowed them.",type:"number"}},required:["advisories","total"],type:"object"},q={properties:{buckets:{description:"Combined throughput/latency series across the range.",type:"array"},capped:{description:"True when the deployment's tracked-statement cap was reached, so coverage is partial.",type:"boolean"},entries:{description:"Per-statement activity in the range, hottest first.",type:"array"},total:{description:"Statements available before `limit` narrowed them.",type:"number"},trackedStatements:{description:"Distinct statements the deployment is tracking.",type:"number"}},required:["entries","buckets"],type:"object"},D={properties:{migrations:{description:"Every declared migration with its applied/pending state.",type:"array"}},required:["migrations"],type:"object"},G=[{annotations:{...p,title:"Read recent logs"},description:"Read the deployment's recent log entries (newest first) after running a function, to see what it printed and where it failed. In-memory and per-shard: resets when the shard hibernates.",inputSchema:P,name:"lunora_get_logs",outputSchema:C},{annotations:{...p,title:"List grouped error Issues"},description:"List errors grouped into Issues by fingerprint, with occurrence counts and triage status — the first call when asking what is currently broken, rather than reading raw logs.",inputSchema:L,name:"lunora_get_issues",outputSchema:x},{annotations:{...p,title:"List schema and query advisories"},description:"List the deployment's schema/query advisories (missing indexes, unsafe policies, and similar lints) before or after changing the schema.",inputSchema:M,name:"lunora_get_advisories",outputSchema:j},{annotations:{...p,title:"Read query insights"},description:"Read per-statement execution counts and latency over a recent time window, to find which query is slow or hot before optimizing one.",inputSchema:k,name:"lunora_get_query_insights",outputSchema:q},{annotations:{...p,title:"Read migration status"},description:"Read which migrations have been applied and which are pending, to check whether a schema change has actually landed on the deployment.",inputSchema:H,name:"lunora_get_migration_status",outputSchema:D}],Y=new Set(G.map(e=>e.name)),l=async(e,t,r,s)=>{const a={__lunoraRef:t};return e.query(a,r,{...s===void 0?{}:{shardKey:s}})},h=(e,t)=>{const r=e?.[t];return Array.isArray(r)?r:[]},$=async(e,t,r)=>{const s=b(r.shardKey),a=U(r.limit);switch(t){case"lunora_get_advisories":{const n=await l(e,d.getAdvisories,{},s),i=h(n,"advisories");return u({advisories:i.slice(0,a),total:i.length})}case"lunora_get_issues":{const n=S(r.status,E),i=b(r.functionPathPrefix),o=await l(e,d.getIssues,{limit:a,...n===void 0?{}:{status:n},...i===void 0?{}:{functionPathPrefix:i}},s);return u({issues:h(o,"issues")})}case"lunora_get_logs":{const n=S(r.level,O),i=await l(e,d.getLogs,{},s),o=h(i,"entries").filter(g=>n===void 0||g.level===n),{dropped:c}=i??{};return u({dropped:typeof c=="number"?c:0,entries:o.slice(0,a),total:o.length})}case"lunora_get_migration_status":{const n=await l(e,d.migrationStatus,{},s);return u({migrations:h(n,"migrations")})}case"lunora_get_query_insights":{const n=S(r.range,A),i=await l(e,d.getQueryInsights,{...n===void 0?{}:{range:n}},s),o=h(i,"entries"),{buckets:c,capped:g,trackedStatements:f}=i??{};return u({buckets:Array.isArray(c)?c:[],capped:g===!0,entries:o.slice(0,a),total:o.length,trackedStatements:typeof f=="number"?f:o.length})}default:throw new v("INTERNAL",`unknown observability tool: ${t}`)}};export{I as D,w as M,G as O,Y as a,$ as c,V as e,R as o};

package/dist/packem_shared/serve-stateless.d-CKsbI0fP.d.mts

@@ -0,0 +1,154 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { HandleRequestOptions } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+/**
+ * The MCP wire shapes every tool surface in this package speaks — the
+ * deployment tools (`./tools`), the agent tools (`./agent-tools`), and the
+ * documentation tools (`./docs`).
+ *
+ * They live in their own module (rather than in `./tools`) so a consumer that
+ * only wants the docs surface can import the types without dragging
+ * `@lunora/client` into its bundle. `./tools` re-exports them, so the package's
+ * public API is unchanged.
+ */
+/** A JSON-Schema object describing a tool's arguments, per the MCP spec. */
+interface ToolInputSchema {
+  properties: Record<string, unknown>;
+  required?: ReadonlyArray<string>;
+  type: "object";
+}
+/**
+ * MCP tool annotations — hints a client may use to decide how to present a tool
+ * (badge it read-only, confirm before a destructive call).
+ *
+ * They are hints, not enforcement: this package's actual guarantees are made at
+ * dispatch, where a write tool is refused unless `allowWrites` is set. These
+ * exist so a client can *show* the user what the server already enforces,
+ * instead of every tool looking equally dangerous.
+ */
+interface ToolAnnotations {
+  /** The tool may perform irreversible changes. Only meaningful when `readOnlyHint` is false. */
+  destructiveHint?: boolean;
+  /** Repeating the call with the same arguments has no additional effect. */
+  idempotentHint?: boolean;
+  /** The tool reaches systems beyond this server (the network, external services). */
+  openWorldHint?: boolean;
+  /** The tool does not modify anything. */
+  readOnlyHint?: boolean;
+  /** Human-facing title, shown instead of the raw tool name. */
+  title?: string;
+}
+interface ToolDefinition {
+  annotations?: ToolAnnotations;
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+  /**
+   * JSON Schema for the tool's `structuredContent`. Optional: a tool that
+   * emits only a text block declares none, and a client that negotiated an
+   * MCP revision older than `2025-06-18` ignores it either way.
+   */
+  outputSchema?: ToolInputSchema;
+}
+/** The MCP `CallToolResult` shape this package's tools return. */
+interface ToolResult {
+  content: {
+    text: string;
+    type: "text";
+  }[];
+  isError?: boolean;
+  /**
+   * The machine-readable result, mirroring the text block. Present only for
+   * tools that declare an `outputSchema`; per the MCP spec it must be a JSON
+   * OBJECT (never a bare array) and must survive `JSON.stringify` — the
+   * transport serializes it, so an un-mapped `bigint` here fails the whole
+   * response rather than one field.
+   */
+  structuredContent?: Record<string, unknown>;
+}
+/** A tool: what to advertise in `ListTools`, and what to run on `CallTool`. */
+interface McpTool {
+  definition: ToolDefinition;
+  handle: (input: Record<string, unknown>) => Promise<ToolResult>;
+}
+/** Name/version pair reported in the MCP `initialize` handshake. */
+interface McpServerInfo {
+  name: string;
+  version: string;
+}
+/** One addressable document a client can list and read directly. */
+interface McpResourceSummary {
+  description?: string;
+  mimeType?: string;
+  name: string;
+  uri: string;
+}
+/**
+ * A set of resources the server exposes alongside its tools.
+ *
+ * Tools are calls a model chooses to make; resources are documents a *client*
+ * can enumerate and attach on its own — the user picking a page to put in
+ * context, without the model having to guess a search query first. The same
+ * corpus is worth offering both ways.
+ */
+interface McpResourceProvider {
+  /** Every resource, for `resources/list`. */
+  list: () => Promise<ReadonlyArray<McpResourceSummary>>;
+  /** One resource's body, or `undefined` when the uri is unknown. */
+  read: (uri: string) => Promise<{
+    mimeType?: string;
+    text: string;
+  } | undefined>;
+}
+/**
+ * Build an MCP `Server` that advertises and dispatches `tools`.
+ *
+ * On duplicate names the FIRST wins, so a caller can layer surfaces in
+ * precedence order without the later list silently shadowing the earlier one.
+ * Thrown errors become `isError` results rather than rejections, per the MCP
+ * convention that a tool failure is output the model can read and react to,
+ * not a protocol-level fault.
+ */
+declare const createToolServer: (info: McpServerInfo, tools: ReadonlyArray<McpTool>, resources?: McpResourceProvider) => Server;
+/** A Web-Standard fetch handler: takes a `Request`, returns the MCP `Response`. */
+type McpFetchHandler = (request: Request) => Promise<Response>;
+/**
+ * Largest request body served. Every MCP call is a short JSON-RPC message — a
+ * few hundred bytes — so this is orders of magnitude of headroom while still
+ * bounding what a caller can push through the parser.
+ */
+declare const DEFAULT_MAX_REQUEST_BYTES: number;
+/** What {@link serveStateless} accepts on top of the transport's own options. */
+interface ServeStatelessOptions extends HandleRequestOptions {
+  /**
+   * Largest accepted request body, in bytes — enforced while the body streams
+   * in, not after it is buffered. Defaults to
+   * {@link DEFAULT_MAX_REQUEST_BYTES}, which a value that is not a
+   * non-negative safe integer also falls back to (see `resolveLimit`).
+   */
+  maxRequestBytes?: number;
+}
+/**
+ * Drive one request through a fresh **stateless** Streamable-HTTP transport bound
+ * to `server`, then tear both down.
+ *
+ * `sessionIdGenerator: undefined` → stateless (no cross-request session store);
+ * `enableJsonResponse: true` → the whole JSON-RPC response is buffered into the
+ * returned `Response`, so closing the transport/server afterwards can't truncate
+ * an in-flight body. Cleanup is fire-and-forget with swallowed rejections (a
+ * `.catch()`-terminated chain) so it never delays or masks the resolved response.
+ *
+ * The request is screened first ({@link screenRequest}); an oversized body or a
+ * JSON-RPC batch is refused here and no server is ever constructed for it.
+ *
+ * `options.parsedBody` lets a caller hand over a body it already read (e.g. the
+ * paid-tool gate, which peeks the JSON-RPC message to price the call) so the
+ * transport doesn't re-read a consumed stream. It is trusted as already
+ * screened, so read it with {@link readScreenedBody} — anything else hands this
+ * surface an unbounded body.
+ *
+ * Teardown runs in a `finally`: a rejection from `connect` or `handleRequest`
+ * would otherwise skip it and leak a server + transport per failed request,
+ * which on a public endpoint is exactly the request an attacker can repeat.
+ */
+declare const serveStateless: (server: Server, request: Request, options?: ServeStatelessOptions) => Promise<Response>;
+export { DEFAULT_MAX_REQUEST_BYTES as D, McpResourceProvider as M, ServeStatelessOptions as S, ToolDefinition as T, McpFetchHandler as a, McpTool as b, McpResourceSummary as c, McpServerInfo as d, ToolInputSchema as e, ToolResult as f, createToolServer as g, serveStateless as s };

package/dist/packem_shared/serve-stateless.d-CKsbI0fP.d.ts

@@ -0,0 +1,154 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { HandleRequestOptions } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+/**
+ * The MCP wire shapes every tool surface in this package speaks — the
+ * deployment tools (`./tools`), the agent tools (`./agent-tools`), and the
+ * documentation tools (`./docs`).
+ *
+ * They live in their own module (rather than in `./tools`) so a consumer that
+ * only wants the docs surface can import the types without dragging
+ * `@lunora/client` into its bundle. `./tools` re-exports them, so the package's
+ * public API is unchanged.
+ */
+/** A JSON-Schema object describing a tool's arguments, per the MCP spec. */
+interface ToolInputSchema {
+  properties: Record<string, unknown>;
+  required?: ReadonlyArray<string>;
+  type: "object";
+}
+/**
+ * MCP tool annotations — hints a client may use to decide how to present a tool
+ * (badge it read-only, confirm before a destructive call).
+ *
+ * They are hints, not enforcement: this package's actual guarantees are made at
+ * dispatch, where a write tool is refused unless `allowWrites` is set. These
+ * exist so a client can *show* the user what the server already enforces,
+ * instead of every tool looking equally dangerous.
+ */
+interface ToolAnnotations {
+  /** The tool may perform irreversible changes. Only meaningful when `readOnlyHint` is false. */
+  destructiveHint?: boolean;
+  /** Repeating the call with the same arguments has no additional effect. */
+  idempotentHint?: boolean;
+  /** The tool reaches systems beyond this server (the network, external services). */
+  openWorldHint?: boolean;
+  /** The tool does not modify anything. */
+  readOnlyHint?: boolean;
+  /** Human-facing title, shown instead of the raw tool name. */
+  title?: string;
+}
+interface ToolDefinition {
+  annotations?: ToolAnnotations;
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+  /**
+   * JSON Schema for the tool's `structuredContent`. Optional: a tool that
+   * emits only a text block declares none, and a client that negotiated an
+   * MCP revision older than `2025-06-18` ignores it either way.
+   */
+  outputSchema?: ToolInputSchema;
+}
+/** The MCP `CallToolResult` shape this package's tools return. */
+interface ToolResult {
+  content: {
+    text: string;
+    type: "text";
+  }[];
+  isError?: boolean;
+  /**
+   * The machine-readable result, mirroring the text block. Present only for
+   * tools that declare an `outputSchema`; per the MCP spec it must be a JSON
+   * OBJECT (never a bare array) and must survive `JSON.stringify` — the
+   * transport serializes it, so an un-mapped `bigint` here fails the whole
+   * response rather than one field.
+   */
+  structuredContent?: Record<string, unknown>;
+}
+/** A tool: what to advertise in `ListTools`, and what to run on `CallTool`. */
+interface McpTool {
+  definition: ToolDefinition;
+  handle: (input: Record<string, unknown>) => Promise<ToolResult>;
+}
+/** Name/version pair reported in the MCP `initialize` handshake. */
+interface McpServerInfo {
+  name: string;
+  version: string;
+}
+/** One addressable document a client can list and read directly. */
+interface McpResourceSummary {
+  description?: string;
+  mimeType?: string;
+  name: string;
+  uri: string;
+}
+/**
+ * A set of resources the server exposes alongside its tools.
+ *
+ * Tools are calls a model chooses to make; resources are documents a *client*
+ * can enumerate and attach on its own — the user picking a page to put in
+ * context, without the model having to guess a search query first. The same
+ * corpus is worth offering both ways.
+ */
+interface McpResourceProvider {
+  /** Every resource, for `resources/list`. */
+  list: () => Promise<ReadonlyArray<McpResourceSummary>>;
+  /** One resource's body, or `undefined` when the uri is unknown. */
+  read: (uri: string) => Promise<{
+    mimeType?: string;
+    text: string;
+  } | undefined>;
+}
+/**
+ * Build an MCP `Server` that advertises and dispatches `tools`.
+ *
+ * On duplicate names the FIRST wins, so a caller can layer surfaces in
+ * precedence order without the later list silently shadowing the earlier one.
+ * Thrown errors become `isError` results rather than rejections, per the MCP
+ * convention that a tool failure is output the model can read and react to,
+ * not a protocol-level fault.
+ */
+declare const createToolServer: (info: McpServerInfo, tools: ReadonlyArray<McpTool>, resources?: McpResourceProvider) => Server;
+/** A Web-Standard fetch handler: takes a `Request`, returns the MCP `Response`. */
+type McpFetchHandler = (request: Request) => Promise<Response>;
+/**
+ * Largest request body served. Every MCP call is a short JSON-RPC message — a
+ * few hundred bytes — so this is orders of magnitude of headroom while still
+ * bounding what a caller can push through the parser.
+ */
+declare const DEFAULT_MAX_REQUEST_BYTES: number;
+/** What {@link serveStateless} accepts on top of the transport's own options. */
+interface ServeStatelessOptions extends HandleRequestOptions {
+  /**
+   * Largest accepted request body, in bytes — enforced while the body streams
+   * in, not after it is buffered. Defaults to
+   * {@link DEFAULT_MAX_REQUEST_BYTES}, which a value that is not a
+   * non-negative safe integer also falls back to (see `resolveLimit`).
+   */
+  maxRequestBytes?: number;
+}
+/**
+ * Drive one request through a fresh **stateless** Streamable-HTTP transport bound
+ * to `server`, then tear both down.
+ *
+ * `sessionIdGenerator: undefined` → stateless (no cross-request session store);
+ * `enableJsonResponse: true` → the whole JSON-RPC response is buffered into the
+ * returned `Response`, so closing the transport/server afterwards can't truncate
+ * an in-flight body. Cleanup is fire-and-forget with swallowed rejections (a
+ * `.catch()`-terminated chain) so it never delays or masks the resolved response.
+ *
+ * The request is screened first ({@link screenRequest}); an oversized body or a
+ * JSON-RPC batch is refused here and no server is ever constructed for it.
+ *
+ * `options.parsedBody` lets a caller hand over a body it already read (e.g. the
+ * paid-tool gate, which peeks the JSON-RPC message to price the call) so the
+ * transport doesn't re-read a consumed stream. It is trusted as already
+ * screened, so read it with {@link readScreenedBody} — anything else hands this
+ * surface an unbounded body.
+ *
+ * Teardown runs in a `finally`: a rejection from `connect` or `handleRequest`
+ * would otherwise skip it and leak a server + transport per failed request,
+ * which on a public endpoint is exactly the request an attacker can repeat.
+ */
+declare const serveStateless: (server: Server, request: Request, options?: ServeStatelessOptions) => Promise<Response>;
+export { DEFAULT_MAX_REQUEST_BYTES as D, McpResourceProvider as M, ServeStatelessOptions as S, ToolDefinition as T, McpFetchHandler as a, McpTool as b, McpResourceSummary as c, McpServerInfo as d, ToolInputSchema as e, ToolResult as f, createToolServer as g, serveStateless as s };

package/dist/packem_shared/toDocsSearchHits-CBLmtWXt.mjs

@@ -0,0 +1 @@
+const e=t=>typeof t=="object"&&t!==null,i=t=>t.split("<mark>").join("").split("</mark>").join(""),l=t=>Array.isArray(t)?t.filter(o=>typeof o=="string"):[],p=t=>{if(!e(t)||typeof t.url!="string"||t.url.length===0)return;const o=t,r=typeof o.content=="string"?i(o.content):"",s=l(o.breadcrumbs),n=o.type==="page",c=n?r:s.at(-1)??r;return{...n||r.length===0?{}:{excerpt:r},...s.length>0?{section:s.join(" › ")}:{},title:c.length>0?c:t.url,url:t.url}},u=t=>{const o=[];for(const r of t){const s=p(r);s!==void 0&&o.push(s)}return o};export{u as toDocsSearchHits};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/mcp",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.131",
   "description": "Model Context Protocol server exposing a Lunora deployment to AI agents",
   "keywords": [
     "ai-agents",
@@ -43,14 +43,28 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
+    "./docs": {
+      "types": "./dist/docs/index.d.ts",
+      "import": "./dist/docs/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.13",
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@lunora/client": "1.0.0-alpha.96",
+    "@lunora/errors": "1.0.0-alpha.35",
+    "@lunora/shard-engine": "1.0.0-alpha.62",
+    "@modelcontextprotocol/sdk": "^1.30.0"
+  },
+  "peerDependencies": {
+    "@lunora/x402": ">=1.0.0-alpha.21 <2.0.0-0"
+  },
+  "peerDependenciesMeta": {
+    "@lunora/x402": {
+      "optional": true
+    }
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"

package/dist/packem_shared/TOOL_DEFINITIONS-Dpiu38ji.mjs

@@ -1,112 +0,0 @@
-const RUN_INPUT_SCHEMA = {
-  properties: {
-    args: { description: "Arguments object passed to the function", type: "object" },
-    functionPath: { description: 'Function reference, e.g. "messages:send"', type: "string" },
-    shardKey: { description: "Optional shard key when the function is .shardBy()-partitioned", type: "string" }
-  },
-  required: ["functionPath"],
-  type: "object"
-};
-const NO_INPUT_SCHEMA = { properties: {}, type: "object" };
-const FUNCTION_PATH_INPUT_SCHEMA = {
-  properties: {
-    functionPath: { description: 'Function reference, e.g. "messages:send"', type: "string" }
-  },
-  required: ["functionPath"],
-  type: "object"
-};
-const TOOL_DEFINITIONS = [
-  {
-    description: "List the deployment's public functions (queries, mutations, actions) with their kinds.",
-    inputSchema: NO_INPUT_SCHEMA,
-    name: "lunora_list_functions"
-  },
-  {
-    description: "List the deployment's .global() tables and their column shapes.",
-    inputSchema: NO_INPUT_SCHEMA,
-    name: "lunora_list_tables"
-  },
-  {
-    description: "Return a function's argument JSON Schema and kind, so a caller can construct a valid arguments object. Call lunora_list_functions first to discover available function paths.",
-    inputSchema: FUNCTION_PATH_INPUT_SCHEMA,
-    name: "lunora_get_function_schema"
-  },
-  {
-    description: "Run a query and return its result. Read-only.",
-    inputSchema: RUN_INPUT_SCHEMA,
-    name: "lunora_run_query"
-  },
-  {
-    description: "Run a mutation and return its result. Writes data — use with care.",
-    inputSchema: RUN_INPUT_SCHEMA,
-    name: "lunora_run_mutation"
-  },
-  {
-    description: "Run an action and return its result. May call external services.",
-    inputSchema: RUN_INPUT_SCHEMA,
-    name: "lunora_run_action"
-  }
-];
-const readFunctionPath = (input) => {
-  const { functionPath } = input;
-  if (typeof functionPath !== "string" || functionPath.length === 0) {
-    throw new Error('"functionPath" is required and must be a non-empty string');
-  }
-  return functionPath;
-};
-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 shardKey = typeof input.shardKey === "string" && input.shardKey.length > 0 ? input.shardKey : void 0;
-  return { args, functionPath, shardKey };
-};
-const reference = (functionPath) => {
-  return { __lunoraRef: functionPath };
-};
-const ok = (value) => {
-  const text = value === void 0 ? "null" : JSON.stringify(value, void 0, 2);
-  return { content: [{ text, type: "text" }] };
-};
-const callTool = async (client, name, input) => {
-  try {
-    switch (name) {
-      case "lunora_get_function_schema": {
-        const functionPath = readFunctionPath(input);
-        const functions = await client.listFunctions();
-        const descriptor = functions.find((function_) => function_.path === functionPath);
-        if (descriptor === void 0) {
-          return { content: [{ text: `function not found: ${functionPath}`, type: "text" }], isError: true };
-        }
-        return ok({ args: descriptor.args ?? [], kind: descriptor.kind, path: descriptor.path });
-      }
-      case "lunora_list_functions": {
-        return ok(await client.listFunctions());
-      }
-      case "lunora_list_tables": {
-        return ok(await client.listGlobalTables());
-      }
-      case "lunora_run_action": {
-        const { args, functionPath, shardKey } = readRunArguments(input);
-        return ok(await client.action(reference(functionPath), args, { shardKey }));
-      }
-      case "lunora_run_mutation": {
-        const { args, functionPath, shardKey } = readRunArguments(input);
-        return ok(await client.mutation(reference(functionPath), args, { shardKey }));
-      }
-      case "lunora_run_query": {
-        const { args, functionPath, shardKey } = readRunArguments(input);
-        return ok(await client.query(reference(functionPath), args, { shardKey }));
-      }
-      default: {
-        return { content: [{ text: `unknown tool: ${name}`, type: "text" }], isError: true };
-      }
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { content: [{ text: message, type: "text" }], isError: true };
-  }
-};
-
-export { TOOL_DEFINITIONS, callTool };

package/dist/packem_shared/connectStdio-C_mvQBs2.mjs

@@ -1,64 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { LunoraClient } from '@lunora/client';
-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 { TOOL_DEFINITIONS, callTool } from './TOOL_DEFINITIONS-Dpiu38ji.mjs';
-
-const resolveVersion = () => {
-  try {
-    let directory = dirname(fileURLToPath(import.meta.url));
-    for (let depth = 0; depth < 8; depth += 1) {
-      try {
-        const raw = readFileSync(join(directory, "package.json"), "utf8");
-        const pkg = JSON.parse(raw);
-        if (pkg.name === "@lunora/mcp" && typeof pkg.version === "string" && pkg.version.length > 0) {
-          return pkg.version;
-        }
-      } catch {
-      }
-      const parent = dirname(directory);
-      if (parent === directory) {
-        break;
-      }
-      directory = parent;
-    }
-  } catch {
-  }
-  return "0.0.0";
-};
-const SERVER_INFO = { name: "lunora", version: resolveVersion() };
-const resolveClient = (options) => {
-  if (options.client !== void 0) {
-    return options.client;
-  }
-  if (options.url === void 0) {
-    throw new Error("createLunoraMcpServer requires either a `client` or a `url`");
-  }
-  const client = new LunoraClient({ fetch: options.fetch, url: options.url });
-  if (options.token !== void 0) {
-    client.setAuthToken(options.token);
-  }
-  return client;
-};
-const createLunoraMcpServer = (options) => {
-  const client = resolveClient(options);
-  const server = new Server(SERVER_INFO, { capabilities: { tools: {} } });
-  server.setRequestHandler(ListToolsRequestSchema, () => {
-    return { tools: [...TOOL_DEFINITIONS] };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const result = await callTool(client, request.params.name, request.params.arguments ?? {});
-    return result;
-  });
-  return server;
-};
-const connectStdio = async (options) => {
-  const server = createLunoraMcpServer(options);
-  await server.connect(new StdioServerTransport());
-  return server;
-};
-
-export { connectStdio, createLunoraMcpServer };