@pagopa/dx-mcpserver 0.2.2 → 0.2.4

package/dist/handlers/ask.js

@@ -5,10 +5,7 @@ import { resolveToWebsiteUrl } from "../services/bedrock.js";
 import { parseJsonBody, sendErrorResponse, sendJsonResponse, } from "../utils/http.js";
 const AskBodySchema = z.object({
     query: z
-        .string({
-        invalid_type_error: "Missing required field: query",
-        required_error: "Missing required field: query",
-    })
+        .string({ error: "Missing required field: query" })
         .trim()
         .min(1, "Missing required field: query"),
 });
@@ -25,7 +22,11 @@ export async function handleAskEndpoint(req, res, config, kbRuntimeClient) {
         }
         const result = AskBodySchema.safeParse(jsonBody);
         if (!result.success) {
-            return sendErrorResponse(res, 400, result.error.errors[0].message);
+            const firstIssue = result.error.issues[0];
+            if (!firstIssue) {
+                throw new Error("Request validation failed without any issues");
+            }
+            return sendErrorResponse(res, 400, firstIssue.message);
         }
         const { query } = result.data;
         const response = await retrieveAndGenerate(config.aws.knowledgeBaseId, config.aws.modelArn, query, kbRuntimeClient);

package/dist/handlers/search.js

@@ -4,19 +4,14 @@ import { queryKnowledgeBaseStructured } from "../services/bedrock.js";
 import { parseJsonBody, sendErrorResponse, sendJsonResponse, } from "../utils/http.js";
 const SearchBodySchema = z.object({
     number_of_results: z
-        .number({
-        invalid_type_error: "number_of_results must be between 1 and 20",
-    })
+        .number({ error: "number_of_results must be between 1 and 20" })
         .int()
         .min(1, "number_of_results must be between 1 and 20")
         .max(20, "number_of_results must be between 1 and 20")
         .optional()
         .default(5),
     query: z
-        .string({
-        invalid_type_error: "Missing required field: query",
-        required_error: "Missing required field: query",
-    })
+        .string({ error: "Missing required field: query" })
         .trim()
         .min(1, "Missing required field: query"),
 });
@@ -33,7 +28,11 @@ export async function handleSearchEndpoint(req, res, config, kbRuntimeClient) {
         }
         const result = SearchBodySchema.safeParse(jsonBody);
         if (!result.success) {
-            return sendErrorResponse(res, 400, result.error.errors[0].message);
+            const firstIssue = result.error.issues[0];
+            if (!firstIssue) {
+                throw new Error("Request validation failed without any issues");
+            }
+            return sendErrorResponse(res, 400, firstIssue.message);
         }
         const { number_of_results: numberOfResults, query } = result.data;
         const results = await queryKnowledgeBaseStructured(config.aws.knowledgeBaseId, query, kbRuntimeClient, numberOfResults, config.aws.rerankingEnabled);

package/dist/mcp/server.js

@@ -64,9 +64,8 @@ export function createServer({ enabledPrompts, requestId, toolDefinitions, }) {
                 ? fieldSchema
                 : fieldSchema.optional();
         }
-        const zodObject = z.object(argsSchemaShape);
         mcpServer.registerPrompt(catalogEntry.prompt.name, {
-            argsSchema: zodObject.shape,
+            argsSchema: argsSchemaShape,
             description: catalogEntry.prompt.description,
         }, async (args) => {
             const content = await decoratedPrompt.load(args || {});

package/dist/tools/__tests__/QueryValidation.test.js

@@ -22,14 +22,14 @@ describe("Query Validation", () => {
             shortQueries.forEach((input) => {
                 const result = queryDocSchema.safeParse(input);
                 expect(result.success).toBe(false);
-                expect(result.error?.errors[0].message).toBe("Query must be at least 3 characters");
+                expect(result.error?.issues[0]?.message).toBe("Query must be at least 3 characters");
             });
         });
         it("should reject queries exceeding 500 characters", () => {
             const longQuery = { query: "a".repeat(501) };
             const result = queryDocSchema.safeParse(longQuery);
             expect(result.success).toBe(false);
-            expect(result.error?.errors[0].message).toBe("Query must not exceed 500 characters");
+            expect(result.error?.issues[0]?.message).toBe("Query must not exceed 500 characters");
         });
         it("should reject missing query field", () => {
             const missingQuery = {};

package/dist/utils/__tests__/error-handling.test.js

@@ -1,6 +1,6 @@
 import { AxiosError, AxiosHeaders } from "axios";
 import { describe, expect, it } from "vitest";
-import { ZodError } from "zod";
+import { z, ZodError } from "zod";
 import { handleApiError, isAxiosError, isZodError } from "../error-handling.js";
 /**
  * Helper to create an AxiosError with a response
@@ -73,49 +73,48 @@ describe("handleApiError - Axios network errors", () => {
 });
 describe("handleApiError - Zod validation errors", () => {
     it("should format single validation error", () => {
-        const error = new ZodError([
-            {
-                code: "too_small",
-                inclusive: true,
-                message: "String must contain at least 3 character(s)",
-                minimum: 3,
-                path: ["query"],
-                type: "string",
-            },
-        ]);
-        expect(handleApiError(error)).toBe("Error: Invalid input - query: String must contain at least 3 character(s)");
+        const result = z
+            .object({
+            query: z.string().min(3, "String must contain at least 3 character(s)"),
+        })
+            .safeParse({ query: "" });
+        expect(result.success).toBe(false);
+        if (result.success) {
+            throw new Error("Expected validation to fail");
+        }
+        expect(handleApiError(result.error)).toBe("Error: Invalid input - query: String must contain at least 3 character(s)");
     });
     it("should format multiple validation errors", () => {
-        const error = new ZodError([
-            {
-                code: "too_small",
-                inclusive: true,
-                message: "String must contain at least 3 character(s)",
-                minimum: 3,
-                path: ["query"],
-                type: "string",
-            },
-            {
-                code: "invalid_type",
-                expected: "number",
-                message: "Expected number, received string",
-                path: ["page"],
-                received: "string",
-            },
-        ]);
-        expect(handleApiError(error)).toBe("Error: Invalid input - query: String must contain at least 3 character(s); page: Expected number, received string");
+        const result = z
+            .intersection(z.object({
+            query: z
+                .string()
+                .min(3, "String must contain at least 3 character(s)"),
+        }), z.object({
+            page: z.number({ error: "Expected number, received string" }),
+        }))
+            .safeParse({ page: "one", query: "" });
+        expect(result.success).toBe(false);
+        if (result.success) {
+            throw new Error("Expected validation to fail");
+        }
+        expect(handleApiError(result.error)).toBe("Error: Invalid input - query: String must contain at least 3 character(s); page: Expected number, received string");
     });
     it("should handle nested path errors", () => {
-        const error = new ZodError([
-            {
-                code: "invalid_type",
-                expected: "string",
-                message: "Required",
-                path: ["data", "nested", "field"],
-                received: "undefined",
-            },
-        ]);
-        expect(handleApiError(error)).toBe("Error: Invalid input - data.nested.field: Required");
+        const result = z
+            .object({
+            data: z.object({
+                nested: z.object({
+                    field: z.string({ error: "Required" }),
+                }),
+            }),
+        })
+            .safeParse({ data: { nested: {} } });
+        expect(result.success).toBe(false);
+        if (result.success) {
+            throw new Error("Expected validation to fail");
+        }
+        expect(handleApiError(result.error)).toBe("Error: Invalid input - data.nested.field: Required");
     });
 });
 describe("handleApiError - generic errors", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-mcpserver",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "description": "An MCP server that supports developers using DX tools.",
   "repository": {
@@ -19,26 +19,26 @@
     "dx": "./dist/cli.js"
   },
   "dependencies": {
-    "@aws-sdk/client-bedrock-agent-runtime": "^3.1030.0",
-    "@aws-sdk/client-s3": "^3.1030.0",
-    "@aws-sdk/s3-request-presigner": "^3.1030.0",
-    "@logtape/logtape": "^1.3.7",
+    "@aws-sdk/client-bedrock-agent-runtime": "^3.1041.0",
+    "@aws-sdk/client-s3": "^3.1041.0",
+    "@aws-sdk/s3-request-presigner": "^3.1041.0",
+    "@logtape/logtape": "^1.3.8",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@octokit/rest": "^22.0.1",
-    "axios": "^1.15.0",
-    "zod": "^3.25.76",
-    "@pagopa/azure-tracing": "^0.5.0",
-    "@pagopa/dx-mcpprompts": "^0.2.7"
+    "axios": "^1.16.0",
+    "zod": "^4.4.2",
+    "@pagopa/azure-tracing": "^0.5.1",
+    "@pagopa/dx-mcpprompts": "^0.2.8"
   },
   "devDependencies": {
     "@types/node": "^22.19.17",
     "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^10.2.0",
+    "eslint": "^10.3.0",
     "prettier": "3.8.3",
     "tsx": "^4.21.0",
     "typescript": "~5.9.3",
     "vitest": "^3.2.4",
-    "@pagopa/eslint-config": "^6.0.3"
+    "@pagopa/eslint-config": "^6.0.4"
   },
   "scripts": {
     "start": "tsx src/cli.ts",