@nextsparkjs/core 0.1.0-beta.184 → 0.1.0-beta.186

package/dist/lib/mcp/errors.js

@@ -0,0 +1,66 @@
+function translateApiError(result, context) {
+  var _a;
+  const { status, body } = result;
+  const code = body.code ?? `HTTP_${status}`;
+  const detail = body.error ? ` (API: ${body.error})` : "";
+  switch (code) {
+    case "AUTHENTICATION_FAILED":
+      return "API key inv\xE1lida, expirada o revocada. Gener\xE1 una nueva en Settings \u2192 API Keys y actualiz\xE1 la configuraci\xF3n del cliente MCP.";
+    case "TEAM_CONTEXT_REQUIRED":
+      return "Falta el contexto de equipo (team). Verific\xE1 que tu API key pertenezca a un usuario con un team activo, o envi\xE1 el header x-team-id.";
+    case "TEAM_ACCESS_DENIED":
+      return "El usuario de la API key no es miembro del team indicado. Verific\xE1 el x-team-id o us\xE1 el team por defecto.";
+    case "VALIDATION_ERROR":
+      return `Datos inv\xE1lidos para ${context.slug}.${formatDetails(body.details)} Correg\xED los campos y reintent\xE1.`;
+    case "INVALID_FIELD_VALUE":
+      return `Un campo tiene un valor no permitido${detail}. Revis\xE1 los valores del schema de la tool y reintent\xE1.`;
+    case "UNIQUE_CONSTRAINT_VIOLATION":
+      return `Ya existe un registro de ${context.slug} con ese valor \xFAnico${detail}. Buscalo con la tool de list y actualizalo en vez de crearlo.`;
+    case "RATE_LIMIT_EXCEEDED":
+      return "L\xEDmite de requests alcanzado. Esper\xE1 un minuto antes de reintentar; para cargas grandes us\xE1 las tools de batch si el entity las expone.";
+    default:
+      break;
+  }
+  switch (status) {
+    case 401:
+      return "No autenticado: la API key no fue aceptada. Gener\xE1 una nueva en Settings \u2192 API Keys.";
+    case 403:
+      return `Sin permiso para ${context.operation} en ${context.slug}. Si es un problema de scope, tu API key necesita el scope ${context.slug}:${scopeFor(context.operation)}. Si es un problema de rol, tu rol en el team no permite esta acci\xF3n.`;
+    case 404:
+      return `No se encontr\xF3 el registro de ${context.slug}. El ID puede ser incorrecto o el registro fue eliminado \u2014 us\xE1 la tool de list para encontrar el ID correcto.`;
+    case 409:
+      return `No se puede completar: el registro de ${context.slug} tiene registros relacionados que dependen de \xE9l${detail}. Elimin\xE1 o reasign\xE1 los registros dependientes primero.`;
+    case 429:
+      return "L\xEDmite de requests alcanzado. Esper\xE1 un minuto antes de reintentar.";
+    case 500: {
+      const hints = ((_a = context.hints) == null ? void 0 : _a.length) ? ` Posibles causas conocidas: ${context.hints.join(" \xB7 ")}.` : "";
+      return `Error interno de la API al ejecutar ${context.operation} en ${context.slug}.${hints} Si persiste, reportalo.`;
+    }
+    default:
+      return `Error ${status} (${code}) al ejecutar ${context.operation} en ${context.slug}${detail}.`;
+  }
+}
+function scopeFor(operation) {
+  if (operation === "list" || operation === "get") return "read";
+  if (operation === "delete") return "delete";
+  return "write";
+}
+function formatDetails(details) {
+  if (!details) return "";
+  if (Array.isArray(details)) {
+    const lines = details.map((issue) => {
+      if (issue && typeof issue === "object") {
+        const record = issue;
+        const path = Array.isArray(record.path) ? record.path.join(".") : String(record.path ?? "");
+        const message = String(record.message ?? JSON.stringify(record));
+        return path ? `${path}: ${message}` : message;
+      }
+      return String(issue);
+    }).slice(0, 8);
+    return ` Problemas: ${lines.join(" \xB7 ")}.`;
+  }
+  return ` Detalle: ${JSON.stringify(details).slice(0, 300)}.`;
+}
+export {
+  translateApiError
+};

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

@@ -0,0 +1,15 @@
+/**
+ * In-process entity executor.
+ *
+ * Invokes the core generic handlers directly (exactly like
+ * app/api/v1/[entity]/route.ts does) with a synthesized NextRequest carrying
+ * the caller's Authorization and the resolved x-team-id. NO fetch fallback:
+ * if the in-process path fails it fails loudly; we never degrade to HTTP,
+ * which would send the credential to an env-derived URL.
+ *
+ * Team context is injected in ALL FIVE operations — the handler only reads
+ * the x-team-id header, and validates it on every operation.
+ */
+import type { EntityExecutor } from './types';
+export declare const executeEntityOperation: EntityExecutor;
+//# sourceMappingURL=executor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAUH,OAAO,KAAK,EAAmB,cAAc,EAA2C,MAAM,SAAS,CAAA;AAKvG,eAAO,MAAM,sBAAsB,EAAE,cA8BpC,CAAA"}

package/dist/lib/mcp/executor.js

@@ -0,0 +1,63 @@
+import { NextRequest } from "next/server";
+import {
+  handleGenericList,
+  handleGenericCreate,
+  handleGenericRead,
+  handleGenericUpdate,
+  handleGenericDelete
+} from "../api/entity/generic-handler.js";
+const INTERNAL_ORIGIN = "http://mcp.internal";
+const executeEntityOperation = async (args, ctx) => {
+  const request = buildRequest(args, ctx);
+  const params = Promise.resolve({ entity: args.slug, id: args.id ?? "" });
+  let response;
+  switch (args.operation) {
+    case "list":
+      response = await handleGenericList(request);
+      break;
+    case "create":
+      response = await handleGenericCreate(request);
+      break;
+    case "get":
+      response = await handleGenericRead(request, { params });
+      break;
+    case "update":
+      response = await handleGenericUpdate(request, { params });
+      break;
+    case "delete":
+      response = await handleGenericDelete(request, { params });
+      break;
+    default:
+      throw new Error(`Unsupported entity operation: ${String(args.operation)}`);
+  }
+  const body = await response.json();
+  return { status: response.status, body };
+};
+function buildRequest(args, ctx) {
+  const path = args.id ? `/api/v1/${args.slug}/${args.id}` : `/api/v1/${args.slug}`;
+  const url = new URL(path, INTERNAL_ORIGIN);
+  for (const [key, value] of Object.entries(args.query ?? {})) {
+    if (value !== void 0 && value !== "") url.searchParams.set(key, value);
+  }
+  const method = METHODS[args.operation];
+  const headers = {
+    authorization: ctx.authHeader,
+    "x-team-id": ctx.teamId
+  };
+  let body;
+  if (args.body !== void 0) {
+    body = JSON.stringify(args.body);
+    headers["content-type"] = "application/json";
+  }
+  return new NextRequest(url, { method, headers, body });
+}
+const METHODS = {
+  list: "GET",
+  get: "GET",
+  create: "POST",
+  update: "PATCH",
+  delete: "DELETE"
+};
+export {
+  executeEntityOperation
+};

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

@@ -0,0 +1,9 @@
+export { createMcpEngine, type McpEngine } from './engine';
+export { executeEntityOperation } from './executor';
+export { auditToolCall } from './audit';
+export { translateApiError } from './errors';
+export { buildEntitySchemas, type EntitySchemaBundle, type SchemaBuilderContext } from './schema-builder';
+export { StatelessJsonRpcTransport } from './transport';
+export { generateEntityTools, toolToken, listArgsToQuery, normalizeDateFields, errorResult, } from './tool-generator';
+export { McpToolError, MUTATION_OPERATIONS, type AuditEntry, type EngineApi, type EntityApiResult, type EntityExecutor, type EntityPresetInfo, type ExecuteEntityArgs, type McpEngineOptions, type McpEntityOverride, type McpOperation, type McpShape, type McpToolAnnotations, type McpToolDefinition, type McpToolResult, type McpToolResultContent, type ToolExecutionContext, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAA;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AACzG,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,eAAe,EACf,mBAAmB,EACnB,WAAW,GACZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,SAAS,CAAA"}

package/dist/lib/mcp/index.js

@@ -0,0 +1,32 @@
+import { createMcpEngine } from "./engine.js";
+import { executeEntityOperation } from "./executor.js";
+import { auditToolCall } from "./audit.js";
+import { translateApiError } from "./errors.js";
+import { buildEntitySchemas } from "./schema-builder.js";
+import { StatelessJsonRpcTransport } from "./transport.js";
+import {
+  generateEntityTools,
+  toolToken,
+  listArgsToQuery,
+  normalizeDateFields,
+  errorResult
+} from "./tool-generator.js";
+import {
+  McpToolError,
+  MUTATION_OPERATIONS
+} from "./types.js";
+export {
+  MUTATION_OPERATIONS,
+  McpToolError,
+  StatelessJsonRpcTransport,
+  auditToolCall,
+  buildEntitySchemas,
+  createMcpEngine,
+  errorResult,
+  executeEntityOperation,
+  generateEntityTools,
+  listArgsToQuery,
+  normalizeDateFields,
+  toolToken,
+  translateApiError
+};

package/dist/lib/mcp/schema-builder.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Schema builder — derives MCP tool input schemas from entity configs.
+ *
+ * DESIGN NOTE: the core's generateEntitySchemas output cannot back tools/list
+ * — its fields are built as z.union([..., z.undefined()]).transform(...),
+ * which zod 4 cannot convert to JSON Schema ("Undefined cannot be
+ * represented"). So this builder emits PRESENTATION schemas (JSON-Schema-
+ * friendly, LLM-documented) derived from the same field definitions. The core
+ * still validates: every call runs in-process through the generic handler,
+ * which validates with the real core schemas. The MCP layer enforces
+ * shape/enums/strictness; the core enforces semantics. This presentation
+ * layer must never be stricter than what the real API accepts.
+ *
+ * MCP-side hardening against the API's silent failures:
+ * - strict objects: unknown keys are rejected, not stripped
+ * - sortBy: enum of the entity's actually-sortable fields
+ * - filters: only real filterable fields; date/datetime EXCLUDED (the core
+ *   applies `=` equality which never matches a timestamptz → silent [])
+ * - dateField/from/to validated as a trio (a lone `from` is silently ignored)
+ * - search only exposed when the entity has one of name|title|slug|content
+ * - `distinct` NEVER exposed (identifier interpolation risk in the core)
+ */
+import { z } from 'zod';
+import type { EntityConfig } from '../entities/types';
+import type { McpEntityOverride, McpShape } from './types';
+export interface EntitySchemaBundle {
+    createShape: McpShape;
+    createStrict: z.ZodTypeAny;
+    updateShape: McpShape;
+    updateStrict: z.ZodTypeAny;
+    listShape: McpShape;
+    listStrict: z.ZodTypeAny;
+    getShape: McpShape;
+    getStrict: z.ZodTypeAny;
+    /** Field names of type date (DATE column) — outputs get normalized to YYYY-MM-DD. */
+    dateFields: string[];
+    /** Which field the core search param actually scans for this entity (or null). */
+    searchField: string | null;
+}
+export interface SchemaBuilderContext {
+    translateOption?: (slug: string, fieldName: string, value: string) => string | undefined;
+    override?: McpEntityOverride;
+}
+export declare function buildEntitySchemas(entityConfig: EntityConfig, context?: SchemaBuilderContext): EntitySchemaBundle;
+//# sourceMappingURL=schema-builder.d.ts.map

package/dist/lib/mcp/schema-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-builder.d.ts","sourceRoot":"","sources":["../../../src/lib/mcp/schema-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,mBAAmB,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAwB1D,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,QAAQ,CAAA;IACrB,YAAY,EAAE,CAAC,CAAC,UAAU,CAAA;IAC1B,WAAW,EAAE,QAAQ,CAAA;IACrB,YAAY,EAAE,CAAC,CAAC,UAAU,CAAA;IAC1B,SAAS,EAAE,QAAQ,CAAA;IACnB,UAAU,EAAE,CAAC,CAAC,UAAU,CAAA;IACxB,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,CAAC,CAAC,UAAU,CAAA;IACvB,qFAAqF;IACrF,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,kFAAkF;IAClF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;IACxF,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC7B;AAED,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,YAAY,EAC1B,OAAO,GAAE,oBAAyB,GACjC,kBAAkB,CAwBpB"}

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"}