neuro-vault-mcp 3.3.0 → 3.4.0

package/dist/cli.js

@@ -14263,6 +14263,16 @@ function date4(params) {
 config(en_default());
 
 // src/lib/input-coercion.ts
+var CoerceError = class extends Error {
+  fieldName;
+  bareMessage;
+  constructor(fieldName, bareMessage) {
+    super(`${fieldName}: ${bareMessage}`);
+    this.name = "CoerceError";
+    this.fieldName = fieldName;
+    this.bareMessage = bareMessage;
+  }
+};
 function unwrap(schema) {
   let current = schema;
   while (current instanceof external_exports.ZodOptional || current instanceof external_exports.ZodNullable || current instanceof external_exports.ZodDefault) {
@@ -14275,46 +14285,91 @@ function unwrap(schema) {
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function coerceField(schema, value) {
+function describeJsonShape(parsed) {
+  if (parsed === null) return "null";
+  if (Array.isArray(parsed)) return "array";
+  return typeof parsed;
+}
+function coerceFieldValue(schema, value, fieldName = "value") {
   if (value === null || value === void 0) return value;
   const inner = unwrap(schema);
   if (inner instanceof external_exports.ZodNumber) {
-    if (typeof value === "string" && value.trim() !== "") {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      if (value.trim() === "") return value;
       const n = Number(value);
       if (Number.isFinite(n)) return n;
+      throw new CoerceError(
+        fieldName,
+        `expected number or numeric string, got ${JSON.stringify(value)}`
+      );
     }
     return value;
   }
   if (inner instanceof external_exports.ZodBoolean) {
+    if (typeof value === "boolean") return value;
     if (value === "true") return true;
     if (value === "false") return false;
+    if (typeof value === "string") {
+      throw new CoerceError(
+        fieldName,
+        `expected boolean or "true"/"false", got ${JSON.stringify(value)}`
+      );
+    }
     return value;
   }
   if (inner instanceof external_exports.ZodObject || inner instanceof external_exports.ZodRecord) {
+    if (isPlainObject2(value)) return value;
     if (typeof value === "string") {
+      let parsed;
       try {
-        const parsed = JSON.parse(value);
-        if (isPlainObject2(parsed)) return parsed;
+        parsed = JSON.parse(value);
       } catch {
+        throw new CoerceError(
+          fieldName,
+          `expected object or JSON-string of one, failed to parse: ${JSON.stringify(value)}`
+        );
       }
-      return value;
+      if (isPlainObject2(parsed)) return parsed;
+      throw new CoerceError(
+        fieldName,
+        `expected object, parsed JSON resolved to ${describeJsonShape(parsed)}`
+      );
     }
     return value;
   }
   return value;
 }
-function coerceInput(schema, value) {
-  const inner = unwrap(schema);
-  if (!(inner instanceof external_exports.ZodObject)) return value;
-  if (!isPlainObject2(value)) return value;
-  const shape = inner.shape;
-  const out = { ...value };
-  for (const key of Object.keys(shape)) {
-    if (key in out) {
-      out[key] = coerceField(shape[key], out[key]);
+function wrapField(field, fieldName) {
+  let inner = field;
+  let isOptional = false;
+  while (inner instanceof external_exports.ZodOptional || inner instanceof external_exports.ZodNullable || inner instanceof external_exports.ZodDefault) {
+    if (inner instanceof external_exports.ZodOptional) isOptional = true;
+    const next = inner.unwrap();
+    if (!next) break;
+    inner = next;
+  }
+  const wrapped = external_exports.preprocess((v, ctx) => {
+    try {
+      return coerceFieldValue(inner, v, fieldName);
+    } catch (err) {
+      if (err instanceof CoerceError) {
+        ctx.addIssue({ code: "custom", message: err.bareMessage });
+        return external_exports.NEVER;
+      }
+      throw err;
     }
+  }, inner);
+  return isOptional ? wrapped.optional() : wrapped;
+}
+function wrapSchemaWithCoercion(schema) {
+  if (!(schema instanceof external_exports.ZodObject)) return schema;
+  const shape = schema.shape;
+  const newShape = {};
+  for (const [key, field] of Object.entries(shape)) {
+    newShape[key] = wrapField(field, key);
   }
-  return out;
+  return external_exports.object(newShape);
 }
 
 // src/lib/tool-response.ts
@@ -14385,18 +14440,18 @@ function formatZodError(error48) {
   return { message, issues };
 }
 function registerTool(tool) {
+  const coercingSchema = wrapSchemaWithCoercion(tool.inputSchema);
   return {
     name: tool.name,
     spec: {
       ...tool.title !== void 0 ? { title: tool.title } : {},
       description: tool.description,
-      inputSchema: tool.inputSchema,
+      inputSchema: coercingSchema,
       ...tool.outputSchema !== void 0 ? { outputSchema: tool.outputSchema } : {},
       ...tool.annotations !== void 0 ? { annotations: tool.annotations } : {}
     },
     handler: async (args) => invokeTool(async () => {
-      const coerced = coerceInput(tool.inputSchema, args);
-      const result = tool.inputSchema.safeParse(coerced);
+      const result = coercingSchema.safeParse(args);
       if (!result.success) {
         const { message, issues } = formatZodError(result.error);
         throw new ToolHandlerError("INVALID_PARAMS", message, { details: { issues } });