@zereight/mcp-gitlab 2.1.61 → 2.1.63

package/build/utils/schema.js

@@ -1,30 +1,50 @@
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 /**
  * Convert a Zod schema to JSON Schema, fixing nullable/optional fields
  * so they are not marked as required, and extracting required fields from the Zod schema.
  */
 export const toJSONSchema = (schema) => {
-    const jsonSchema = zodToJsonSchema(schema, { $refStrategy: "none" });
+    // Zod 4 native conversion. (zod-to-json-schema only understands Zod 3
+    // internals and silently emits an empty schema for Zod 4 schemas.)
+    // draft-7 keeps output closest to the previous converter; io:"input"
+    // describes tool arguments (preprocess/coerce evaluated input-side).
+    const jsonSchema = z.toJSONSchema(schema, { target: "draft-7", io: "input" });
+    // Public classes only (no _def access): works on both Zod 3 and Zod 4,
+    // whose internals differ (_def.typeName vs _zod.def.type).
     const isOptionalLikeField = (zodType) => {
-        const def = zodType._def;
-        const typeName = def?.typeName;
-        if (["ZodOptional", "ZodNullable", "ZodDefault", "ZodCatch"].includes(typeName)) {
+        if (zodType instanceof z.ZodOptional ||
+            zodType instanceof z.ZodNullable ||
+            zodType instanceof z.ZodDefault ||
+            zodType instanceof z.ZodCatch) {
             return true;
         }
-        if (typeName === "ZodEffects") {
-            return isOptionalLikeField(def.schema);
+        // ZodEffects (v3 preprocess/refine/transform): unwrap the inner schema.
+        const ZodEffects = z.ZodEffects;
+        if (ZodEffects &&
+            zodType instanceof ZodEffects &&
+            typeof zodType.innerType === "function") {
+            return isOptionalLikeField(zodType.innerType());
         }
-        if (typeName === "ZodBranded") {
-            return isOptionalLikeField(def.type);
+        // ZodBranded: unwrap to the branded schema.
+        const ZodBranded = z.ZodBranded;
+        if (ZodBranded &&
+            zodType instanceof ZodBranded &&
+            typeof zodType.unwrap === "function") {
+            return isOptionalLikeField(zodType.unwrap());
         }
-        if (typeName === "ZodPipeline") {
-            return isOptionalLikeField(def.in);
+        // Pipes (v3 ZodPipeline / v4 ZodPipe/ZodPreprocess from preprocess/transform):
+        // optional-like when either side is optional-like.
+        const maybeIn = zodType.in;
+        const maybeOut = zodType.out;
+        if (maybeIn instanceof z.ZodType && maybeOut instanceof z.ZodType) {
+            return isOptionalLikeField(maybeIn) || isOptionalLikeField(maybeOut);
         }
         return false;
     };
-    // Extract required fields from Zod schema
-    const zodRequiredFields = (() => {
+    // Extract required fields from Zod schema (authoritative for the root object:
+    // the native converter marks defaulted fields as required, we keep the
+    // previous convention that defaulted/optional-like fields are not required).
+    const { zodRequiredFields, hasAuthoritativeRequired } = (() => {
         if (schema instanceof z.ZodObject) {
             const shape = schema.shape;
             const requiredFields = [];
@@ -34,9 +54,9 @@ export const toJSONSchema = (schema) => {
                     requiredFields.push(key);
                 }
             });
-            return requiredFields;
+            return { zodRequiredFields: requiredFields, hasAuthoritativeRequired: true };
         }
-        return [];
+        return { zodRequiredFields: [], hasAuthoritativeRequired: false };
     })();
     // Post-process to fix nullable/optional fields and strip verbose keys
     function fixNullableOptional(obj, isRoot = false) {
@@ -47,14 +67,13 @@ export const toJSONSchema = (schema) => {
             delete obj.additionalProperties;
             // If this object has properties, process them
             if (obj.properties) {
-                const requiredSet = new Set(obj.required || []);
-                // Add required fields extracted from Zod schema (only for root object)
-                if (isRoot) {
-                    zodRequiredFields.forEach(field => {
-                        if (obj.properties[field]) {
-                            requiredSet.add(field);
-                        }
-                    });
+                let requiredSet;
+                if (isRoot && hasAuthoritativeRequired) {
+                    // Zod shape is the source of truth at root level.
+                    requiredSet = new Set(zodRequiredFields.filter(field => obj.properties[field]));
+                }
+                else {
+                    requiredSet = new Set(obj.required || []);
                 }
                 Object.keys(obj.properties).forEach(key => {
                     const prop = obj.properties[key];
@@ -66,6 +85,10 @@ export const toJSONSchema = (schema) => {
                     else if (Array.isArray(prop.type) && prop.type.includes("null")) {
                         requiredSet.delete(key);
                     }
+                    // Fields with defaults are not required (previous converter semantics).
+                    if (prop && typeof prop === "object" && "default" in prop) {
+                        requiredSet.delete(key);
+                    }
                     // Recursively process nested objects (not root)
                     obj.properties[key] = fixNullableOptional(prop, false);
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zereight/mcp-gitlab",
-  "version": "2.1.61",
+  "version": "2.1.63",
   "mcpName": "io.github.zereight/gitlab-mcp",
   "description": "GitLab MCP server for projects, merge requests, issues, pipelines, wiki, releases, and more",
   "keywords": [
@@ -85,8 +85,7 @@
     "tldts": "^6.1.86",
     "tough-cookie": "^5.1.2",
     "undici": "^6.28.0",
-    "zod": "^3.24.2",
-    "zod-to-json-schema": "3.24.5"
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@types/express": "^5.0.2",