@nextsparkjs/core 0.1.0-beta.183 → 0.1.0-beta.185

package/dist/lib/mcp/schema-builder.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+const SEARCHED_FIELDS = ["name", "title", "slug", "content"];
+const INPUT_EXCLUDED_TYPES = /* @__PURE__ */ new Set(["media-library", "file", "image", "video", "audio"]);
+const FILTER_EXCLUDED_TYPES = /* @__PURE__ */ new Set([
+  "datetime",
+  "json",
+  "media-library",
+  "textarea",
+  "richtext",
+  "markdown"
+]);
+function buildEntitySchemas(entityConfig, context = {}) {
+  const createShape = buildInputShape(entityConfig, "create", context);
+  const updateShape = buildInputShape(entityConfig, "update", context);
+  const listShape = buildListShape(entityConfig, context);
+  const getShape = {
+    id: z.string().min(1).describe(`ID del registro de ${entityConfig.names.singular} (uuid)`)
+  };
+  const dateFields = entityConfig.fields.filter((f) => f.type === "date").map((f) => f.name);
+  const searchField = SEARCHED_FIELDS.find((name) => entityConfig.fields.some((f) => f.name === name)) ?? null;
+  return {
+    createShape,
+    createStrict: z.object(createShape).strict(),
+    updateShape,
+    updateStrict: z.object(updateShape).strict(),
+    listShape,
+    listStrict: buildListStrict(listShape),
+    getShape,
+    getStrict: z.object(getShape).strict(),
+    dateFields,
+    searchField
+  };
+}
+function presentationType(field) {
+  switch (field.type) {
+    case "select":
+    case "radio":
+    case "buttongroup":
+    case "combobox": {
+      const values = (field.options ?? []).map((opt) => String(opt.value));
+      return values.length ? z.enum(values) : z.string();
+    }
+    case "multiselect":
+    case "tags":
+      return z.array(z.string());
+    case "doublerange":
+      return z.array(z.number()).length(2);
+    case "number":
+    case "rating":
+    case "range":
+    case "currency": {
+      let type = z.number();
+      if (field.min !== void 0) type = type.min(field.min);
+      if (field.max !== void 0) type = type.max(field.max);
+      return type;
+    }
+    case "boolean":
+      return z.boolean();
+    case "date":
+    case "datetime":
+    case "email":
+    case "url":
+    case "phone":
+    case "timezone":
+    case "country":
+      return z.string().min(1);
+    case "relation":
+    case "relation-prop":
+    case "reference":
+    case "user":
+      return z.string().min(1);
+    case "relation-multi":
+    case "relation-prop-multi":
+      return z.array(z.string());
+    case "json":
+    case "address":
+      return z.record(z.string(), z.unknown());
+    case "text":
+    case "textarea":
+    case "markdown":
+    case "richtext":
+    case "code": {
+      let type = z.string();
+      if (field.maxLength) type = type.max(field.maxLength);
+      return type;
+    }
+    default:
+      console.warn(`[mcp] unmapped field type "${field.type}" (${field.name}) \u2014 using permissive schema`);
+      return z.unknown();
+  }
+}
+function buildInputShape(entityConfig, operation, context) {
+  var _a, _b;
+  const shape = {};
+  const relax = new Set(((_a = context.override) == null ? void 0 : _a.relaxRequired) ?? []);
+  for (const field of entityConfig.fields) {
+    if (INPUT_EXCLUDED_TYPES.has(field.type)) continue;
+    if ((_b = field.api) == null ? void 0 : _b.readOnly) continue;
+    let type = presentationType(field);
+    const required = operation === "create" && field.required && !relax.has(field.name);
+    if (!required) type = type.optional();
+    shape[field.name] = type.describe(describeField(entityConfig, field, field.name, context));
+  }
+  return shape;
+}
+function buildListShape(entityConfig, context) {
+  var _a;
+  const sortable = entityConfig.fields.filter((f) => {
+    var _a2;
+    return (_a2 = f.api) == null ? void 0 : _a2.sortable;
+  }).map((f) => f.name);
+  const sortableValues = [...sortable, "createdAt", "updatedAt"];
+  const dateFieldNames = entityConfig.fields.filter((f) => f.type === "date" || f.type === "datetime").map((f) => f.name);
+  const shape = {
+    page: z.number().int().min(1).optional().describe("P\xE1gina (1)"),
+    limit: z.number().int().min(1).max(100).optional().describe("Por p\xE1gina (10, m\xE1x 100)"),
+    sortBy: z.enum(sortableValues).optional().describe("Ordenar por"),
+    sortOrder: z.enum(["ASC", "DESC"]).optional().describe("Orden (DESC)")
+  };
+  const searchField = SEARCHED_FIELDS.find(
+    (name) => entityConfig.fields.some((f) => f.name === name)
+  );
+  if (searchField) {
+    shape.search = z.string().min(1).optional().describe(`Busca SOLO en "${searchField}"`);
+  }
+  if (dateFieldNames.length) {
+    shape.dateField = z.enum(dateFieldNames).optional().describe("Campo de fecha del rango (obligatorio con from/to)");
+    shape.from = z.string().optional().describe("Desde (YYYY-MM-DD)");
+    shape.to = z.string().optional().describe("Hasta (YYYY-MM-DD)");
+  }
+  const filterShape = {};
+  for (const field of entityConfig.fields) {
+    if (FILTER_EXCLUDED_TYPES.has(field.type)) continue;
+    if (INPUT_EXCLUDED_TYPES.has(field.type)) continue;
+    if (((_a = field.api) == null ? void 0 : _a.filterable) === false) continue;
+    filterShape[field.name] = presentationType(field).optional().describe(describeField(entityConfig, field, field.name, context, true));
+  }
+  if (Object.keys(filterShape).length) {
+    shape.filters = z.object(filterShape).strict().optional().describe("Filtros exactos. Fechas NO ac\xE1: us\xE1 dateField/from/to.");
+  }
+  const projectable = entityConfig.fields.map((f) => f.name);
+  if (projectable.length) {
+    shape.fields = z.array(z.enum(projectable)).min(1).optional().describe("Devolver solo estos campos (achica la respuesta)");
+  }
+  return shape;
+}
+function buildListStrict(listShape) {
+  return z.object(listShape).strict().superRefine((value, ctx) => {
+    const v = value;
+    if ((v.from || v.to) && !v.dateField) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["dateField"],
+        message: "from/to requieren dateField \u2014 sin \xE9l la API los ignora en silencio"
+      });
+    }
+  });
+}
+function describeField(entityConfig, field, name, context, compact = false) {
+  var _a, _b, _c, _d, _e, _f;
+  const overrideDescription = (_c = (_b = (_a = context.override) == null ? void 0 : _a.describe) == null ? void 0 : _b.fields) == null ? void 0 : _c[name];
+  if (overrideDescription) return compact ? shorten(overrideDescription) : overrideDescription;
+  if (!field) return name;
+  const label = ((_d = field.display) == null ? void 0 : _d.label) || name;
+  if (compact) return label;
+  const parts = [label];
+  if (((_e = field.display) == null ? void 0 : _e.description) && field.display.description !== label) {
+    parts.push(field.display.description);
+  }
+  switch (field.type) {
+    case "select":
+    case "multiselect":
+    case "radio":
+    case "buttongroup":
+    case "combobox": {
+      const options = (field.options ?? []).map((opt) => {
+        var _a2;
+        const value = String(opt.value);
+        const translated = ((_a2 = context.translateOption) == null ? void 0 : _a2.call(context, entityConfig.slug, field.name, value)) ?? opt.label;
+        return translated && translated !== value ? `${value}=${translated}` : value;
+      }).join(", ");
+      if (options) parts.push(options);
+      break;
+    }
+    case "relation":
+      if ((_f = field.relation) == null ? void 0 : _f.entity) {
+        parts.push(`uuid de ${field.relation.entity} (us\xE1 su tool de list)`);
+      }
+      break;
+    case "user":
+      parts.push("uuid de un miembro del team");
+      break;
+    case "date":
+      parts.push("YYYY-MM-DD");
+      break;
+    case "datetime":
+      parts.push("ISO 8601 con offset, ej. 2026-08-05T10:00:00-03:00");
+      break;
+    case "boolean":
+      parts.push("true/false (booleano, no string)");
+      break;
+    default:
+      break;
+  }
+  return parts.join(". ");
+}
+function shorten(text) {
+  return text.length <= 60 ? text : `${text.slice(0, 57)}...`;
+}
+export {
+  buildEntitySchemas
+};

package/dist/lib/mcp/tool-generator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tool generator — one entity config → its CRUD tool definitions.
+ *
+ * Names come from the entity config (names.singular/plural), never from naive
+ * singularization. Descriptions are fed primarily from the entity's API
+ * presets (summary → entity description, preset descriptions/payloads →
+ * few-shot examples). Delete tools require confirm:true and carry destructive
+ * warnings.
+ *
+ * No separate authorization gate is re-implemented here: every tool call
+ * round-trips in-process through the real generic entity handler (see
+ * executor.ts), which already runs `checkAuthPermission` + `hasRequiredScope`
+ * + ownership/field guards for API-key auth (fixed for #94/#95). A denied
+ * call surfaces as a normal API error, translated via errors.ts.
+ */
+import type { EntityConfig } from '../entities/types';
+import { type EntityExecutor, type EntityPresetInfo, type McpEngineOptions, type McpEntityOverride, type McpOperation, type McpToolDefinition, type McpToolResult } from './types';
+interface GeneratorDeps {
+    executor: EntityExecutor;
+    toolPrefix: string;
+    translateOption?: McpEngineOptions['translateOption'];
+    presets?: EntityPresetInfo;
+}
+export declare function generateEntityTools(entityConfig: EntityConfig, operations: McpOperation[], override: McpEntityOverride | undefined, deps: GeneratorDeps): McpToolDefinition[];
+export declare function toolToken(name: string): string;
+export declare function listArgsToQuery(args: Record<string, unknown>): Record<string, string>;
+/** DATE columns come back serialized as timestamptz — normalize to YYYY-MM-DD. */
+export declare function normalizeDateFields(row: unknown, dateFields: string[]): unknown;
+export declare function errorResult(message: string): McpToolResult;
+export {};
+//# sourceMappingURL=tool-generator.d.ts.map

package/dist/lib/mcp/tool-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-generator.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/tool-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGrD,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAEjB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAEnB,MAAM,SAAS,CAAA;AAEhB,UAAU,aAAa;IACrB,QAAQ,EAAE,cAAc,CAAA;IACxB,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;IACrD,OAAO,CAAC,EAAE,gBAAgB,CAAA;CAC3B;AAED,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,YAAY,EAAE,EAC1B,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,IAAI,EAAE,aAAa,GAClB,iBAAiB,EAAE,CA6NrB;AAID,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO9C;AA0BD,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBrF;AAED,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAU/E;AAkBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAE1D"}

package/dist/lib/mcp/tool-generator.js

@@ -0,0 +1,271 @@
+import { z } from "zod";
+import { buildEntitySchemas } from "./schema-builder.js";
+import { translateApiError } from "./errors.js";
+import {
+  McpToolError
+} from "./types.js";
+function generateEntityTools(entityConfig, operations, override, deps) {
+  const schemas = buildEntitySchemas(entityConfig, {
+    translateOption: deps.translateOption,
+    override
+  });
+  const slug = entityConfig.slug;
+  const singular = toolToken(entityConfig.names.singular);
+  const plural = toolToken(slug);
+  const entityDescription = buildEntityDescription(entityConfig, override, deps.presets);
+  const tools = [];
+  const make = (operation, name, title, description, inputSchema, strictSchema, annotations, run) => {
+    var _a, _b;
+    return {
+      name,
+      title,
+      description: ((_b = (_a = override == null ? void 0 : override.describe) == null ? void 0 : _a.tools) == null ? void 0 : _b[operation]) ?? description,
+      inputSchema,
+      strictSchema,
+      annotations,
+      meta: { entitySlug: slug, operation },
+      handler: async (rawArgs, ctx) => {
+        const parsed = strictSchema.safeParse(rawArgs ?? {});
+        if (!parsed.success) {
+          return errorResult(
+            `Argumentos inv\xE1lidos para ${name}: ${formatZodIssues(parsed.error)}. Revis\xE1 el schema de la tool.`
+          );
+        }
+        try {
+          return await run(parsed.data, ctx);
+        } catch (error) {
+          if (error instanceof McpToolError) return errorResult(error.message);
+          console.error(`[mcp] unexpected error in ${name}:`, error);
+          return errorResult(
+            `Error inesperado ejecutando ${name}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    };
+  };
+  const apiError = (result, operation) => errorResult(
+    translateApiError(result, { slug, operation, hints: override == null ? void 0 : override.errorHints })
+  );
+  if (operations.includes("list")) {
+    tools.push(
+      make(
+        "list",
+        `${deps.toolPrefix}_list_${plural}`,
+        `List ${entityConfig.names.plural}`,
+        `Lista ${entityConfig.names.plural} con paginaci\xF3n, orden y filtros. ${entityDescription}${presetExamples(deps.presets, "GET")}`,
+        schemas.listShape,
+        schemas.listStrict,
+        { readOnlyHint: true },
+        async (args, ctx) => {
+          const query = listArgsToQuery(args);
+          const result = await deps.executor({ slug, operation: "list", query }, ctx);
+          if (!result.body.success) return apiError(result, "list");
+          const data = normalizeOutput(result.body.data);
+          const info = result.body.info ?? {};
+          const total = info.total ?? (Array.isArray(data) ? data.length : "?");
+          const page = info.page ?? 1;
+          const totalPages = info.totalPages ?? 1;
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${String(total)} ${entityConfig.names.plural} (p\xE1gina ${String(page)}/${String(totalPages)})`
+              }
+            ],
+            structuredContent: { data, info }
+          };
+        }
+      )
+    );
+  }
+  if (operations.includes("get")) {
+    tools.push(
+      make(
+        "get",
+        `${deps.toolPrefix}_get_${singular}`,
+        `Get ${entityConfig.names.singular}`,
+        `Obtiene un registro de ${entityConfig.names.singular} por ID. ${entityDescription}`,
+        schemas.getShape,
+        schemas.getStrict,
+        { readOnlyHint: true },
+        async (args, ctx) => {
+          const result = await deps.executor(
+            { slug, operation: "get", id: String(args.id) },
+            ctx
+          );
+          if (!result.body.success) return apiError(result, "get");
+          const data = normalizeOutput(result.body.data);
+          return {
+            content: [{ type: "text", text: `${entityConfig.names.singular} encontrado.` }],
+            structuredContent: { data }
+          };
+        }
+      )
+    );
+  }
+  if (operations.includes("create")) {
+    tools.push(
+      make(
+        "create",
+        `${deps.toolPrefix}_create_${singular}`,
+        `Create ${entityConfig.names.singular}`,
+        `Crea un registro de ${entityConfig.names.singular}. ${entityDescription}${presetExamples(deps.presets, "POST")}`,
+        schemas.createShape,
+        schemas.createStrict,
+        {},
+        async (args, ctx) => {
+          const input = (override == null ? void 0 : override.transformInput) ? await override.transformInput("create", args, ctx) : args;
+          const result = await deps.executor({ slug, operation: "create", body: input }, ctx);
+          if (!result.body.success) return apiError(result, "create");
+          const data = normalizeOutput(result.body.data);
+          const id = extractId(data);
+          return {
+            content: [
+              { type: "text", text: `${entityConfig.names.singular} creado${id ? ` (id: ${id})` : ""}.` }
+            ],
+            structuredContent: { data }
+          };
+        }
+      )
+    );
+  }
+  if (operations.includes("update")) {
+    const updateShape = {
+      id: z.string().min(1).describe(`ID del registro de ${entityConfig.names.singular} a modificar (uuid)`),
+      ...schemas.updateShape
+    };
+    tools.push(
+      make(
+        "update",
+        `${deps.toolPrefix}_update_${singular}`,
+        `Update ${entityConfig.names.singular}`,
+        `Modifica campos de un registro de ${entityConfig.names.singular} (PATCH parcial: solo envi\xE1 los campos a cambiar). ${entityDescription}`,
+        updateShape,
+        z.object(updateShape).strict(),
+        { idempotentHint: true },
+        async (args, ctx) => {
+          const { id, ...fields } = args;
+          if (!Object.keys(fields).length) {
+            return errorResult("No enviaste ning\xFAn campo a modificar.");
+          }
+          const input = (override == null ? void 0 : override.transformInput) ? await override.transformInput("update", fields, ctx) : fields;
+          const result = await deps.executor(
+            { slug, operation: "update", id, body: input },
+            ctx
+          );
+          if (!result.body.success) return apiError(result, "update");
+          const data = normalizeOutput(result.body.data);
+          return {
+            content: [{ type: "text", text: `${entityConfig.names.singular} actualizado.` }],
+            structuredContent: { data }
+          };
+        }
+      )
+    );
+  }
+  if (operations.includes("delete")) {
+    const deleteShape = {
+      id: z.string().min(1).describe(`ID del registro de ${entityConfig.names.singular} a eliminar (uuid)`),
+      confirm: z.boolean().describe("true SOLO tras confirmaci\xF3n expl\xEDcita del usuario")
+    };
+    tools.push(
+      make(
+        "delete",
+        `${deps.toolPrefix}_delete_${singular}`,
+        `Delete ${entityConfig.names.singular}`,
+        `Elimina un ${entityConfig.names.singular}. DESTRUCTIVO: mostrale al usuario qu\xE9 vas a borrar y pedile confirmaci\xF3n antes.${deleteWarning(override)}`,
+        deleteShape,
+        z.object(deleteShape).strict(),
+        { destructiveHint: true },
+        async (args, ctx) => {
+          if (args.confirm !== true) {
+            return errorResult(
+              "Eliminaci\xF3n no confirmada: pedile al usuario confirmaci\xF3n expl\xEDcita y reintent\xE1 con confirm: true."
+            );
+          }
+          const result = await deps.executor(
+            { slug, operation: "delete", id: String(args.id) },
+            ctx
+          );
+          if (!result.body.success) return apiError(result, "delete");
+          return {
+            content: [{ type: "text", text: `${entityConfig.names.singular} eliminado (id: ${String(args.id)}).` }]
+          };
+        }
+      )
+    );
+  }
+  return tools;
+}
+function toolToken(name) {
+  return name.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function buildEntityDescription(entityConfig, override, presets) {
+  var _a;
+  if ((_a = override == null ? void 0 : override.describe) == null ? void 0 : _a.entity) return override.describe.entity;
+  return (presets == null ? void 0 : presets.summary) ? `${presets.summary}.` : "";
+}
+function presetExamples(presets, method) {
+  if (!presets) return "";
+  const relevant = presets.presets.filter((p) => (p.method ?? "GET") === method);
+  const example = relevant.find((p) => method === "POST" ? p.payload : p.params);
+  if (!example) return "";
+  const body = method === "POST" ? example.payload : example.params;
+  const label = example.description || example.title || example.id;
+  return ` Ejemplo (${label}): ${JSON.stringify(body)}`;
+}
+function deleteWarning(override) {
+  var _a, _b;
+  const hint = (_b = (_a = override == null ? void 0 : override.describe) == null ? void 0 : _a.tools) == null ? void 0 : _b.delete;
+  return hint ? ` ${hint}` : "";
+}
+function listArgsToQuery(args) {
+  const query = {};
+  const { filters, fields, ...rest } = args;
+  for (const [key, value] of Object.entries(rest)) {
+    if (value === void 0 || value === null || value === "") continue;
+    query[key] = String(value);
+  }
+  for (const [key, value] of Object.entries(filters ?? {})) {
+    if (value === void 0 || value === null || value === "") continue;
+    query[key] = String(value);
+  }
+  if (fields == null ? void 0 : fields.length) query.fields = fields.join(",");
+  return query;
+}
+function normalizeDateFields(row, dateFields) {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return row;
+  const record = { ...row };
+  for (const field of dateFields) {
+    const value = record[field];
+    if (typeof value === "string" && value.length >= 10) {
+      record[field] = value.slice(0, 10);
+    }
+  }
+  return record;
+}
+function normalizeOutput(data) {
+  return data;
+}
+function extractId(data) {
+  if (data && typeof data === "object" && "id" in data) {
+    return String(data.id);
+  }
+  return null;
+}
+function errorResult(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function formatZodIssues(error) {
+  return error.issues.slice(0, 6).map((issue) => {
+    const path = issue.path.join(".");
+    return path ? `${path}: ${issue.message}` : issue.message;
+  }).join(" \xB7 ");
+}
+export {
+  errorResult,
+  generateEntityTools,
+  listArgsToQuery,
+  normalizeDateFields,
+  toolToken
+};

package/dist/lib/mcp/transport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Stateless in-memory Transport for MCP over HTTP (App Router friendly).
+ *
+ * The official StreamableHTTPServerTransport requires Node's
+ * IncomingMessage/ServerResponse, which Next.js App Router does not expose.
+ * This transport bypasses HTTP entirely: the route handler parses the
+ * JSON-RPC body, feeds each message to an ephemeral McpServer through this
+ * transport, and returns the collected responses as plain JSON.
+ *
+ * Stateless by design: one server + one transport per request, no sessions,
+ * no SSE/server-push. Server-originated notifications are dropped.
+ */
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export declare class StatelessJsonRpcTransport implements Transport {
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    private pending;
+    private closed;
+    start(): Promise<void>;
+    /** Called by the McpServer with responses (and notifications, which we drop). */
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Feed one client message to the server. Resolves with the server's
+     * response for requests, or null for notifications (no response expected).
+     */
+    handleMessage(message: JSONRPCMessage): Promise<JSONRPCMessage | null>;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/lib/mcp/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAA;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAA;AAMxE,qBAAa,yBAA0B,YAAW,SAAS;IACzD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;IACpB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAChC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAA;IAE7C,OAAO,CAAC,OAAO,CAA8C;IAC7D,OAAO,CAAC,MAAM,CAAQ;IAEhB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,iFAAiF;IAC3E,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAe5C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;;OAGG;IACG,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;CAsB7E"}

package/dist/lib/mcp/transport.js

@@ -0,0 +1,58 @@
+const RESPONSE_TIMEOUT_MS = 3e4;
+class StatelessJsonRpcTransport {
+  onclose;
+  onerror;
+  onmessage;
+  pending = /* @__PURE__ */ new Map();
+  closed = false;
+  async start() {
+  }
+  /** Called by the McpServer with responses (and notifications, which we drop). */
+  async send(message) {
+    if (this.closed) return;
+    const id = message.id;
+    if (id !== void 0 && id !== null && !("method" in message)) {
+      const resolve = this.pending.get(id);
+      if (resolve) {
+        this.pending.delete(id);
+        resolve(message);
+        return;
+      }
+    }
+  }
+  async close() {
+    var _a;
+    this.closed = true;
+    this.pending.clear();
+    (_a = this.onclose) == null ? void 0 : _a.call(this);
+  }
+  /**
+   * Feed one client message to the server. Resolves with the server's
+   * response for requests, or null for notifications (no response expected).
+   */
+  async handleMessage(message) {
+    if (!this.onmessage) {
+      throw new Error("Transport not connected to a server");
+    }
+    const isRequest = "method" in message && "id" in message && message.id !== null;
+    if (!isRequest) {
+      this.onmessage(message);
+      return null;
+    }
+    const request = message;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(request.id);
+        reject(new Error(`MCP request ${String(request.id)} timed out`));
+      }, RESPONSE_TIMEOUT_MS);
+      this.pending.set(request.id, (response) => {
+        clearTimeout(timer);
+        resolve(response);
+      });
+      this.onmessage(message);
+    });
+  }
+}
+export {
+  StatelessJsonRpcTransport
+};