@pagopa/dx-mcpserver 0.2.5 → 0.2.6

package/dist/config.js

@@ -14,7 +14,7 @@ export const envSchema = z.object({
     BEDROCK_MODEL_ARN: z.string().optional(),
     GITHUB_SEARCH_ORG: z.string().optional(),
     LOG_LEVEL: logLevelSchema,
-    PORT: z.coerce.number().int().positive().optional(),
+    PORT: z.coerce.number().int().min(0).optional(),
     REQUIRED_ORGANIZATIONS: z.string().optional(),
 });
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-mcpserver",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "type": "module",
   "description": "An MCP server that supports developers using DX tools.",
   "repository": {
@@ -19,25 +19,25 @@
     "dx": "./dist/cli.js"
   },
   "dependencies": {
-    "@aws-sdk/client-bedrock-agent-runtime": "^3.1041.0",
-    "@aws-sdk/client-s3": "^3.1041.0",
-    "@aws-sdk/s3-request-presigner": "^3.1041.0",
+    "@aws-sdk/client-bedrock-agent-runtime": "^3.1057.0",
+    "@aws-sdk/client-s3": "^3.1057.0",
+    "@aws-sdk/s3-request-presigner": "^3.1057.0",
     "@logtape/logtape": "^1.3.8",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@octokit/rest": "^22.0.1",
     "axios": "^1.16.0",
     "zod": "^4.4.2",
-    "@pagopa/dx-mcpprompts": "^0.2.8",
-    "@pagopa/azure-tracing": "^0.5.2"
+    "@pagopa/azure-tracing": "^0.5.3",
+    "@pagopa/dx-mcpprompts": "^0.2.9"
   },
   "devDependencies": {
     "@types/node": "^22.19.17",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.1.8",
     "eslint": "^10.3.0",
     "prettier": "3.8.3",
     "tsx": "^4.21.0",
     "typescript": "~5.9.3",
-    "vitest": "^3.2.4",
+    "vitest": "^4.1.8",
     "@pagopa/eslint-config": "^6.0.4"
   },
   "scripts": {

package/dist/__tests__/http-endpoints.test.js

@@ -1,240 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import { loadConfig } from "../config.js";
-// Mock the prompts package to avoid Vite resolution issues in CI
-vi.mock("@pagopa/dx-mcpprompts", () => ({
-    getEnabledPrompts: vi.fn().mockResolvedValue([]),
-}));
-// Helper to create mock Bedrock responses
-function createMockBedrockResponse(command) {
-    if (command.constructor.name === "RetrieveAndGenerateCommand") {
-        return Promise.resolve({
-            citations: [
-                {
-                    retrievedReferences: [
-                        {
-                            content: { text: "Reference content", type: "TEXT" },
-                            location: {
-                                s3Location: {
-                                    uri: "s3://bucket/docs/terraform/setup.md",
-                                },
-                                type: "S3",
-                            },
-                        },
-                    ],
-                },
-            ],
-            output: { text: "This is how you setup Terraform." },
-            sessionId: "test-session",
-        });
-    }
-    else if (command.constructor.name === "RetrieveCommand") {
-        return Promise.resolve({
-            retrievalResults: [
-                {
-                    content: { text: "Azure naming conventions guide", type: "TEXT" },
-                    location: {
-                        s3Location: { uri: "s3://bucket/docs/azure/naming.md" },
-                        type: "S3",
-                    },
-                    score: 0.95,
-                },
-            ],
-        });
-    }
-    return Promise.resolve({});
-}
-// Mock AWS SDK to avoid external dependencies
-vi.mock("@aws-sdk/client-bedrock-agent-runtime", () => ({
-    BedrockAgentRuntimeClient: vi.fn().mockImplementation(() => ({
-        config: {
-            apiVersion: "2023-11-20",
-            region: async () => "eu-central-1",
-            requestHandler: { handle: vi.fn() },
-        },
-        destroy: vi.fn(),
-        middlewareStack: {},
-        send: vi.fn(),
-    })),
-    RetrieveAndGenerateCommand: vi.fn(),
-    RetrieveCommand: vi.fn(),
-}));
-vi.mock("../config/aws.js", () => ({
-    createBedrockRuntimeClient: vi.fn(() => ({
-        config: {
-            apiVersion: "2023-11-20",
-            region: async () => "eu-central-1",
-            requestHandler: { handle: vi.fn() },
-        },
-        destroy: vi.fn(),
-        middlewareStack: {},
-        send: vi.fn().mockImplementation(createMockBedrockResponse),
-    })),
-    rerankingSupportedRegions: ["us-east-1", "eu-central-1"],
-}));
-// Shared server instance
-let server;
-let baseUrl;
-async function closeTestServer() {
-    return new Promise((resolve) => {
-        server.close(() => resolve());
-    });
-}
-async function setupTestServer() {
-    const testEnv = {
-        AWS_BEDROCK_KNOWLEDGE_BASE_ID: "test-kb-id",
-        AWS_BEDROCK_MODEL_ARN: "arn:aws:bedrock:test",
-        AWS_REGION: "eu-central-1",
-        LOG_LEVEL: "error",
-        NODE_ENV: "test",
-    };
-    const config = loadConfig(testEnv);
-    const { startHttpServer } = await import("../index.js");
-    // Use empty prompts array since we mocked the module
-    server = await startHttpServer(config, []);
-    const address = server.address();
-    const port = typeof address === "object" ? address?.port : 8080;
-    baseUrl = `http://localhost:${port}`;
-}
-describe("HTTP Endpoints Integration Tests", () => {
-    beforeAll(setupTestServer);
-    afterAll(closeTestServer);
-    describe("POST /ask", () => {
-        it("should return 200 with answer and sources for valid request", async () => {
-            const response = await fetch(`${baseUrl}/ask`, {
-                body: JSON.stringify({ query: "How do I setup Terraform?" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toContain("application/json");
-            const data = (await response.json());
-            expect(data).toHaveProperty("answer");
-            expect(data).toHaveProperty("sources");
-            expect(typeof data.answer).toBe("string");
-            expect(Array.isArray(data.sources)).toBe(true);
-        });
-        it("should return 400 for missing query field", async () => {
-            const response = await fetch(`${baseUrl}/ask`, {
-                body: JSON.stringify({}),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Missing required field: query");
-        });
-        it("should return 400 for empty query string", async () => {
-            const response = await fetch(`${baseUrl}/ask`, {
-                body: JSON.stringify({ query: "   " }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Missing required field: query");
-        });
-        it("should return 400 for invalid JSON", async () => {
-            const response = await fetch(`${baseUrl}/ask`, {
-                body: "not valid json{",
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Invalid JSON in request body");
-        });
-        it("should return 400 for non-string query", async () => {
-            const response = await fetch(`${baseUrl}/ask`, {
-                body: JSON.stringify({ query: 123 }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Missing required field: query");
-        });
-    });
-    describe("POST /search", () => {
-        it("should return 200 with results for valid request", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({ query: "Azure naming conventions" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(200);
-            expect(response.headers.get("content-type")).toContain("application/json");
-            const data = (await response.json());
-            expect(data).toHaveProperty("query");
-            expect(data).toHaveProperty("results");
-            expect(Array.isArray(data.results)).toBe(true);
-        });
-        it("should use default number_of_results when not provided", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({ query: "test query" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(200);
-            const data = (await response.json());
-            expect(data).toHaveProperty("results");
-        });
-        it("should accept custom number_of_results", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({ number_of_results: 10, query: "test query" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(200);
-        });
-        it("should return 400 for missing query field", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({}),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Missing required field: query");
-        });
-        it("should return 400 for empty query string", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({ query: "" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Missing required field: query");
-        });
-        it("should return 400 for invalid JSON", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: "{invalid json",
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("Invalid JSON in request body");
-        });
-        it("should return 400 for number_of_results out of range (too low)", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({ number_of_results: 0, query: "test" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("number_of_results must be between 1 and 20");
-        });
-        it("should return 400 for number_of_results out of range (too high)", async () => {
-            const response = await fetch(`${baseUrl}/search`, {
-                body: JSON.stringify({ number_of_results: 21, query: "test" }),
-                headers: { "Content-Type": "application/json" },
-                method: "POST",
-            });
-            expect(response.status).toBe(400);
-            const data = (await response.json());
-            expect(data.error).toBe("number_of_results must be between 1 and 20");
-        });
-    });
-});

package/dist/__tests__/index.test.js

@@ -1,169 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-export const mockTool = {
-    annotations: {
-        destructiveHint: false,
-        idempotentHint: true,
-        openWorldHint: true,
-        readOnlyHint: true,
-        title: "Test Tool",
-    },
-    description: "A test tool",
-    execute: vi.fn(async (args) => {
-        const parsedResult = z.object({ input: z.string() }).safeParse(args);
-        if (!parsedResult.success) {
-            return "Error: Invalid input";
-        }
-        return `Tool executed with: ${parsedResult.data.input}`;
-    }),
-    name: "TestTool",
-    parameters: z.object({
-        input: z.string().min(1, "Input cannot be empty"),
-    }),
-};
-export const mockCatalogEntry = {
-    category: "test",
-    enabled: true,
-    id: "test-prompt",
-    metadata: {
-        description: "A test prompt for unit testing",
-        title: "Test Prompt",
-    },
-    prompt: {
-        arguments: [
-            { description: "First argument", name: "arg1", required: true },
-            { description: "Second argument", name: "arg2", required: false },
-        ],
-        description: "A test prompt",
-        load: async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`,
-        name: "TestPrompt",
-    },
-    tags: ["test"],
-};
-export const mockPromptEntry = {
-    catalogEntry: mockCatalogEntry,
-    prompt: {
-        load: vi.fn(async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`),
-    },
-};
-describe("MCP Server Handlers", () => {
-    describe("Tool Handler Validation", () => {
-        it("should validate tool arguments against the Zod schema", async () => {
-            // Valid arguments should pass
-            const validArgs = { input: "test-value" };
-            const validationResult = mockTool.parameters.safeParse(validArgs);
-            expect(validationResult.success).toBe(true);
-            // Invalid arguments should fail
-            const invalidArgs = { input: "" };
-            const invalidationResult = mockTool.parameters.safeParse(invalidArgs);
-            expect(invalidationResult.success).toBe(false);
-            expect(invalidationResult.error?.issues[0].message).toContain("cannot be empty");
-        });
-        it("should handle tool execution errors gracefully", async () => {
-            const errorTool = {
-                ...mockTool,
-                execute: vi.fn(async () => {
-                    throw new Error("Tool execution failed");
-                }),
-            };
-            await expect(errorTool.execute({ input: "test" }, undefined)).rejects.toThrow("Tool execution failed");
-        });
-        it("should pass context with session data to tool execute", async () => {
-            const context = { session: { id: "session-123" } };
-            await mockTool.execute({ input: "test" }, context);
-            expect(mockTool.execute).toHaveBeenCalledWith({ input: "test" }, context);
-        });
-    });
-    describe("Prompt Handler Validation", () => {
-        it("should validate required prompt arguments", () => {
-            const missingRequiredArg = { arg2: "value2" };
-            const hasAllRequired = mockCatalogEntry.prompt.arguments
-                .filter((arg) => arg.required)
-                .every((arg) => arg.name in missingRequiredArg);
-            expect(hasAllRequired).toBe(false);
-            const withAllRequired = { arg1: "value1", arg2: "value2" };
-            const hasAllRequired2 = mockCatalogEntry.prompt.arguments
-                .filter((arg) => arg.required)
-                .every((arg) => arg.name in withAllRequired);
-            expect(hasAllRequired2).toBe(true);
-        });
-        it("should handle missing required prompt arguments", () => {
-            const requiredArgs = mockCatalogEntry.prompt.arguments
-                .filter((arg) => arg.required)
-                .map((arg) => arg.name);
-            const providedArgs = { arg2: "value" };
-            const missingArgs = requiredArgs.filter((arg) => !(arg in providedArgs));
-            expect(missingArgs).toEqual(["arg1"]);
-        });
-        it("should handle optional prompt arguments", async () => {
-            const argsWithoutOptional = { arg1: "required-value" };
-            await mockPromptEntry.prompt.load(argsWithoutOptional);
-            expect(mockPromptEntry.prompt.load).toHaveBeenCalledWith(argsWithoutOptional);
-            const argsWithOptional = { arg1: "required-value", arg2: "optional" };
-            await mockPromptEntry.prompt.load(argsWithOptional);
-            expect(mockPromptEntry.prompt.load).toHaveBeenCalledWith(argsWithOptional);
-        });
-        it("should handle prompt loading errors gracefully", async () => {
-            const errorPrompt = {
-                ...mockPromptEntry,
-                prompt: {
-                    load: vi.fn(async () => {
-                        throw new Error("Prompt loading failed");
-                    }),
-                },
-            };
-            await expect(errorPrompt.prompt.load({ arg1: "test" })).rejects.toThrow("Prompt loading failed");
-        });
-    });
-    describe("Request Handler Integration", () => {
-        it("should handle valid tool requests", async () => {
-            const args = { input: "test-input" };
-            const result = await mockTool.execute(args, undefined);
-            expect(result).toContain("Tool executed with: test-input");
-            expect(mockTool.execute).toHaveBeenCalledWith(args, undefined);
-        });
-        it("should reject requests with invalid tool names", () => {
-            const toolRegistry = new Map();
-            toolRegistry.set("TestTool", mockTool);
-            const toolExists = toolRegistry.has("NonExistentTool");
-            expect(toolExists).toBe(false);
-        });
-        it("should handle tool execution with proper error context", async () => {
-            const toolWithErrorContext = {
-                ...mockTool,
-                execute: vi.fn(async (args, context) => {
-                    if (!context?.session) {
-                        throw new Error("Session context required");
-                    }
-                    return "Success with context";
-                }),
-            };
-            // Should fail without context
-            await expect(toolWithErrorContext.execute({ input: "test" }, undefined)).rejects.toThrow("Session context required");
-            // Should succeed with context
-            const result = await toolWithErrorContext.execute({ input: "test" }, { session: { id: "session-1" } });
-            expect(result).toBe("Success with context");
-        });
-        it("should handle batch tool and prompt registration", () => {
-            const toolRegistry = new Map();
-            const promptRegistry = new Map();
-            // Register multiple tools
-            toolRegistry.set(mockTool.name, mockTool);
-            toolRegistry.set("AnotherTool", { ...mockTool, name: "AnotherTool" });
-            // Register multiple prompts
-            promptRegistry.set(mockPromptEntry.catalogEntry.prompt.name, mockPromptEntry);
-            promptRegistry.set("AnotherPrompt", {
-                ...mockPromptEntry,
-                catalogEntry: {
-                    ...mockPromptEntry.catalogEntry,
-                    prompt: {
-                        ...mockPromptEntry.catalogEntry.prompt,
-                        name: "AnotherPrompt",
-                    },
-                },
-            });
-            expect(toolRegistry.size).toBe(2);
-            expect(promptRegistry.size).toBe(2);
-        });
-    });
-});

package/dist/__tests__/session.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { sessionStorage } from "../session.js";
-describe("Session Management", () => {
-    it("should maintain session isolation between concurrent contexts", async () => {
-        const session1 = { id: "session-1" };
-        const session2 = { id: "session-2" };
-        const results = [];
-        // Run two sessions concurrently
-        await Promise.all([
-            sessionStorage.run(session1, async () => {
-                // Wait a bit to ensure overlap
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                const stored = sessionStorage.getStore();
-                if (stored) {
-                    results.push(stored);
-                }
-            }),
-            sessionStorage.run(session2, async () => {
-                const stored = sessionStorage.getStore();
-                if (stored) {
-                    results.push(stored);
-                }
-            }),
-        ]);
-        // Both sessions should have completed and stored their data
-        expect(results).toHaveLength(2);
-        // Each session should have its own data
-        const ids = results.map((r) => r.id).sort();
-        expect(ids).toEqual(["session-1", "session-2"]);
-    });
-    it("should return undefined when accessed outside of run context", async () => {
-        const store = sessionStorage.getStore();
-        expect(store).toBeUndefined();
-    });
-    it("should provide correct session data within run context", async () => {
-        const session = {
-            id: "test-session-123",
-        };
-        await sessionStorage.run(session, async () => {
-            const stored = sessionStorage.getStore();
-            expect(stored).toBeDefined();
-            expect(stored?.id).toBe("test-session-123");
-        });
-    });
-    it("should properly clean up session data after run context completes", async () => {
-        const session = { id: "cleanup-456" };
-        await sessionStorage.run(session, async () => {
-            expect(sessionStorage.getStore()).toBeDefined();
-        });
-        // After the run completes, store should be undefined
-        expect(sessionStorage.getStore()).toBeUndefined();
-    });
-    it("should handle nested session contexts correctly", async () => {
-        const session1 = { id: "outer-1" };
-        const session2 = { id: "inner-2" };
-        await sessionStorage.run(session1, async () => {
-            expect(sessionStorage.getStore()?.id).toBe("outer-1");
-            await sessionStorage.run(session2, async () => {
-                // Inner context should override outer
-                expect(sessionStorage.getStore()?.id).toBe("inner-2");
-            });
-            // After inner context exits, outer context should be restored
-            expect(sessionStorage.getStore()?.id).toBe("outer-1");
-        });
-    });
-});

package/dist/config/__tests__/aws-config.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createBedrockRuntimeClient, rerankingSupportedRegions, } from "../aws.js";
-describe("aws config", () => {
-    it("should export rerankingSupportedRegions as array", () => {
-        expect(Array.isArray(rerankingSupportedRegions)).toBe(true);
-        expect(rerankingSupportedRegions.length).toBeGreaterThan(0);
-    });
-    it("should create a Bedrock runtime client", () => {
-        const logger = {
-            error: vi.fn(),
-        };
-        const client = createBedrockRuntimeClient("eu-central-1", logger);
-        expect(client).toHaveProperty("send");
-    });
-});

package/dist/config/__tests__/constants.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { API_TIMEOUT, DEFAULT_PAGE_SIZE, MAX_RESULTS } from "../constants.js";
-describe("Server Constants", () => {
-    describe("API_TIMEOUT", () => {
-        it("should be a positive number", () => {
-            expect(API_TIMEOUT).toBeGreaterThan(0);
-        });
-        it("should be 30 seconds (30000ms)", () => {
-            expect(API_TIMEOUT).toBe(30000);
-        });
-    });
-    describe("MAX_RESULTS", () => {
-        it("should be a positive number", () => {
-            expect(MAX_RESULTS).toBeGreaterThan(0);
-        });
-        it("should be 100", () => {
-            expect(MAX_RESULTS).toBe(100);
-        });
-    });
-    describe("DEFAULT_PAGE_SIZE", () => {
-        it("should be a positive number", () => {
-            expect(DEFAULT_PAGE_SIZE).toBeGreaterThan(0);
-        });
-        it("should be 20", () => {
-            expect(DEFAULT_PAGE_SIZE).toBe(20);
-        });
-        it("should be less than MAX_RESULTS", () => {
-            expect(DEFAULT_PAGE_SIZE).toBeLessThan(MAX_RESULTS);
-        });
-    });
-});

package/dist/services/__tests__/bedrock-retrieve-and-generate.test.js

@@ -1,116 +0,0 @@
-import { getLogger } from "@logtape/logtape";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { retrieveAndGenerate } from "../bedrock-retrieve-and-generate.js";
-// Helper to create mock Bedrock client
-function createMockBedrockClient(sendMock) {
-    return {
-        config: {
-            apiVersion: "2023-11-20",
-            region: async () => "eu-central-1",
-            requestHandler: { handle: vi.fn() },
-        },
-        destroy: vi.fn(),
-        middlewareStack: {},
-        send: sendMock,
-    };
-}
-describe("retrieveAndGenerate", () => {
-    let loggerSpy;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        const logger = getLogger(["mcpserver", "bedrock", "retrieve-and-generate"]);
-        loggerSpy = {
-            debug: vi.spyOn(logger, "debug"),
-            error: vi.spyOn(logger, "error"),
-            info: vi.spyOn(logger, "info"),
-        };
-    });
-    it("should successfully retrieve and generate with valid parameters", async () => {
-        const mockResponse = {
-            citations: [
-                {
-                    retrievedReferences: [
-                        {
-                            content: { text: "Reference content" },
-                            location: {
-                                s3Location: { uri: "s3://bucket/doc.md" },
-                                type: "S3",
-                            },
-                        },
-                    ],
-                },
-            ],
-            output: {
-                text: "This is the AI-generated answer based on the knowledge base.",
-            },
-            sessionId: "test-session-123",
-        };
-        const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue(mockResponse));
-        const result = await retrieveAndGenerate("kb-test-id", "arn:aws:bedrock:eu-central-1::foundation-model/amazon.nova-2-lite-v1:0", "How do I setup Terraform?", mockClient, 5);
-        expect(result).toEqual(mockResponse);
-        expect(result.output?.text).toBe("This is the AI-generated answer based on the knowledge base.");
-        expect(result.sessionId).toBe("test-session-123");
-        expect(loggerSpy.debug).toHaveBeenCalledWith("Calling RetrieveAndGenerate", {
-            knowledgeBaseId: "kb-test-id",
-            modelArn: "arn:aws:bedrock:eu-central-1::foundation-model/amazon.nova-2-lite-v1:0",
-            numberOfResults: 5,
-            query: "How do I setup Terraform?",
-        });
-        expect(loggerSpy.info).toHaveBeenCalledWith("RetrieveAndGenerate successful", {
-            sessionId: "test-session-123",
-        });
-    });
-    it("should use default numberOfResults when not provided", async () => {
-        const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue({
-            output: { text: "Answer" },
-            sessionId: "session-456",
-        }));
-        await retrieveAndGenerate("kb-id", "model-arn", "test query", mockClient);
-        expect(loggerSpy.debug).toHaveBeenCalledWith("Calling RetrieveAndGenerate", expect.objectContaining({
-            numberOfResults: 5,
-        }));
-    });
-    it("should log error details and rethrow on failure", async () => {
-        const mockError = {
-            $metadata: {
-                httpStatusCode: 403,
-            },
-            __type: "AccessDeniedException",
-            message: "User is not authorized to perform: bedrock:RetrieveAndGenerate",
-            name: "AccessDeniedException",
-        };
-        const mockClient = createMockBedrockClient(vi.fn().mockRejectedValue(mockError));
-        await expect(retrieveAndGenerate("kb-id", "model-arn", "test query", mockClient)).rejects.toThrow();
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("RetrieveAndGenerate failed"));
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("AccessDeniedException"));
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("kb-id"));
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("model-arn"));
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("403"));
-    });
-    it("should handle errors without $metadata or __type", async () => {
-        const mockError = new Error("Network timeout");
-        const mockClient = createMockBedrockClient(vi.fn().mockRejectedValue(mockError));
-        await expect(retrieveAndGenerate("kb-id", "model-arn", "test query", mockClient)).rejects.toThrow("Network timeout");
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("RetrieveAndGenerate failed"));
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("Error"));
-        expect(loggerSpy.error).toHaveBeenCalledWith(expect.stringContaining("Network timeout"));
-    });
-    it("should send correct RetrieveAndGenerateCommand configuration", async () => {
-        const sendSpy = vi.fn().mockResolvedValue({
-            output: { text: "Test answer" },
-            sessionId: "test-session",
-        });
-        const mockClient = createMockBedrockClient(sendSpy);
-        await retrieveAndGenerate("kb-test-id", "arn:aws:bedrock:eu-central-1::foundation-model/test-model", "What is the capital of France?", mockClient, 10);
-        const commandArg = sendSpy.mock.calls[0][0];
-        expect(commandArg.input.input.text).toBe("What is the capital of France?");
-        expect(commandArg.input.retrieveAndGenerateConfiguration.type).toBe("KNOWLEDGE_BASE");
-        expect(commandArg.input.retrieveAndGenerateConfiguration
-            .knowledgeBaseConfiguration.knowledgeBaseId).toBe("kb-test-id");
-        expect(commandArg.input.retrieveAndGenerateConfiguration
-            .knowledgeBaseConfiguration.modelArn).toBe("arn:aws:bedrock:eu-central-1::foundation-model/test-model");
-        expect(commandArg.input.retrieveAndGenerateConfiguration
-            .knowledgeBaseConfiguration.retrievalConfiguration
-            .vectorSearchConfiguration.numberOfResults).toBe(10);
-    });
-});

package/dist/services/__tests__/bedrock.test.js

@@ -1,205 +0,0 @@
-import { getLogger } from "@logtape/logtape";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { queryKnowledgeBase, queryKnowledgeBaseStructured, } from "../bedrock.js";
-// Helper to create mock Bedrock client
-function createMockBedrockClient(sendMock) {
-    return {
-        config: {
-            apiVersion: "2023-11-20",
-            region: async () => "eu-central-1",
-            requestHandler: { handle: vi.fn() },
-        },
-        destroy: vi.fn(),
-        middlewareStack: {},
-        send: sendMock,
-    };
-}
-describe("queryKnowledgeBase", () => {
-    let loggerSpy;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Get logger and spy on its methods - no need for special configuration
-        const logger = getLogger(["mcpserver", "bedrock"]);
-        loggerSpy = {
-            warn: vi.spyOn(logger, "warn"),
-        };
-    });
-    it("should skip images in results", async () => {
-        const mockClient = {
-            config: {
-                apiVersion: "2023-11-20",
-                region: async () => "eu-central-1",
-                requestHandler: { handle: vi.fn() },
-            },
-            destroy: vi.fn(),
-            middlewareStack: {},
-            send: vi.fn().mockResolvedValue({
-                retrievalResults: [
-                    { content: { text: "doc1", type: "TEXT" } },
-                    { content: { type: "IMAGE" } },
-                ],
-            }),
-        };
-        const result = await queryKnowledgeBase("kbId", "query", mockClient, 2, false);
-        expect(result).toContain("doc1");
-        expect(loggerSpy.warn).toHaveBeenCalledWith("Images are not supported at this time. Skipping...");
-    });
-    it("should warn if reranking is not supported in region", async () => {
-        const mockClient = {
-            config: {
-                apiVersion: "2023-11-20",
-                region: async () => "unsupported-region",
-                requestHandler: { handle: vi.fn() },
-            },
-            destroy: vi.fn(),
-            middlewareStack: {},
-            send: vi.fn().mockResolvedValue({ retrievalResults: [] }),
-        };
-        const result = await queryKnowledgeBase("kbId", "query", mockClient, 2, true);
-        expect(typeof result).toBe("string");
-        expect(loggerSpy.warn).toHaveBeenCalledWith("Reranking is not supported in region unsupported-region");
-    });
-});
-describe("queryKnowledgeBaseStructured - Basic Functionality", () => {
-    let loggerSpy;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        const logger = getLogger(["mcpserver", "bedrock"]);
-        loggerSpy = {
-            warn: vi.spyOn(logger, "warn"),
-        };
-    });
-    it("should return structured QueryKnowledgeBasesOutput[] instead of a string", async () => {
-        const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue({
-            retrievalResults: [
-                {
-                    content: { text: "Documentation content", type: "TEXT" },
-                    location: {
-                        s3Location: { uri: "s3://bucket/docs/guide.md" },
-                        type: "S3",
-                    },
-                    score: 0.95,
-                },
-            ],
-        }));
-        const result = await queryKnowledgeBaseStructured("kbId", "query", mockClient, 5, false);
-        expect(Array.isArray(result)).toBe(true);
-        expect(result.length).toBe(1);
-        expect(typeof result[0]).toBe("object");
-    });
-    it("should return result objects with content, location, and score properties", async () => {
-        const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue({
-            retrievalResults: [
-                {
-                    content: { text: "Test content", type: "TEXT" },
-                    location: {
-                        s3Location: { uri: "s3://bucket/path/file.md" },
-                        type: "S3",
-                    },
-                    score: 0.87,
-                },
-            ],
-        }));
-        const result = await queryKnowledgeBaseStructured("kbId", "test query", mockClient);
-        expect(result[0]).toHaveProperty("content");
-        expect(result[0]).toHaveProperty("location");
-        expect(result[0]).toHaveProperty("score");
-        expect(result[0].content).toBe("Test content");
-        expect(result[0].score).toBe(0.87);
-    });
-    it("should resolve S3 locations to website URLs via resolveToWebsiteUrl", async () => {
-        const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue({
-            retrievalResults: [
-                {
-                    content: { text: "Content", type: "TEXT" },
-                    location: {
-                        s3Location: {
-                            uri: "s3://pagopa-dx-documentation/docs/azure/index.md",
-                        },
-                        type: "S3",
-                    },
-                    score: 0.9,
-                },
-            ],
-        }));
-        const result = await queryKnowledgeBaseStructured("kbId", "query", mockClient);
-        // resolveToWebsiteUrl should transform S3 URI to website URL
-        expect(result[0].location).toBeDefined();
-        expect(result[0].location?.webLocation?.url).toContain("https://");
-        expect(result[0].location?.webLocation?.url).not.toContain("/index");
-    });
-    it("should skip image content with warning logs", async () => {
-        const mockClient = createMockBedrockClient(vi.fn().mockResolvedValue({
-            retrievalResults: [
-                {
-                    content: { text: "Valid text content", type: "TEXT" },
-                    location: {
-                        s3Location: { uri: "s3://bucket/file.md" },
-                        type: "S3",
-                    },
-                    score: 0.9,
-                },
-                {
-                    content: { type: "IMAGE" },
-                    location: {
-                        s3Location: { uri: "s3://bucket/image.png" },
-                        type: "S3",
-                    },
-                    score: 0.85,
-                },
-            ],
-        }));
-        const result = await queryKnowledgeBaseStructured("kbId", "query", mockClient);
-        expect(result.length).toBe(1);
-        expect(result[0].content).toBe("Valid text content");
-        expect(loggerSpy.warn).toHaveBeenCalledWith("Images are not supported at this time. Skipping...");
-    });
-});
-describe("queryKnowledgeBaseStructured - Reranking", () => {
-    let loggerSpy;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        const logger = getLogger(["mcpserver", "bedrock"]);
-        loggerSpy = {
-            warn: vi.spyOn(logger, "warn"),
-        };
-    });
-    it("should apply reranking configuration when enabled in supported region", async () => {
-        const sendSpy = vi.fn().mockResolvedValue({
-            retrievalResults: [
-                {
-                    content: { text: "Reranked content", type: "TEXT" },
-                    location: { s3Location: { uri: "s3://bucket/doc.md" }, type: "S3" },
-                    score: 0.98,
-                },
-            ],
-        });
-        const mockClient = createMockBedrockClient(sendSpy);
-        // Override region for this test
-        mockClient.config.region = async () => "us-east-1"; // Supported region
-        await queryKnowledgeBaseStructured("kbId", "query", mockClient, 5, true, // Enable reranking
-        "AMAZON");
-        // Verify that send was called with reranking configuration
-        const commandArg = sendSpy.mock.calls[0][0];
-        expect(commandArg.input.retrievalConfiguration).toBeDefined();
-        expect(commandArg.input.retrievalConfiguration.vectorSearchConfiguration
-            .rerankingConfiguration).toBeDefined();
-        expect(commandArg.input.retrievalConfiguration.vectorSearchConfiguration
-            .rerankingConfiguration.bedrockRerankingConfiguration.modelConfiguration
-            .modelArn).toContain("amazon.rerank-v1:0");
-    });
-    it("should disable reranking in unsupported region with warning", async () => {
-        const sendSpy = vi.fn().mockResolvedValue({
-            retrievalResults: [],
-        });
-        const mockClient = createMockBedrockClient(sendSpy);
-        // Override region for this test
-        mockClient.config.region = async () => "ap-southeast-1"; // Unsupported region
-        await queryKnowledgeBaseStructured("kbId", "query", mockClient, 5, true);
-        expect(loggerSpy.warn).toHaveBeenCalledWith("Reranking is not supported in region ap-southeast-1");
-        // Verify that send was called WITHOUT reranking configuration
-        const commandArg = sendSpy.mock.calls[0][0];
-        expect(commandArg.input.retrievalConfiguration.vectorSearchConfiguration
-            .rerankingConfiguration).toBeUndefined();
-    });
-});

package/dist/services/__tests__/resolve-to-website-url.test.js

@@ -1,67 +0,0 @@
-it("returns dx.pagopa.it/llms-full.txt for llms-full.txt", () => {
-    const location = {
-        s3Location: {
-            uri: "s3://bucket/llms-full.txt",
-        },
-        type: "S3",
-    };
-    const result = resolveToWebsiteUrl(location);
-    expect(result?.webLocation?.url).toBe("https://dx.pagopa.it/llms-full.txt");
-});
-it("returns dx.pagopa.it/llms.txt for llms.txt", () => {
-    const location = {
-        s3Location: {
-            uri: "s3://bucket/llms.txt",
-        },
-        type: "S3",
-    };
-    const result = resolveToWebsiteUrl(location);
-    expect(result?.webLocation?.url).toBe("https://dx.pagopa.it/llms.txt");
-});
-it("returns dx.pagopa.it/blog/ for keys starting with /blog/", () => {
-    const location = {
-        s3Location: {
-            uri: "s3://bucket/blog/some-post.md",
-        },
-        type: "S3",
-    };
-    const result = resolveToWebsiteUrl(location);
-    expect(result?.webLocation?.url).toBe("https://dx.pagopa.it/blog/");
-});
-import { describe, expect, it } from "vitest";
-import { resolveToWebsiteUrl } from "../bedrock.js";
-describe("resolveToWebsiteUrl", () => {
-    it("converte una chiave S3 .md in url dx.pagopa.it/docs", () => {
-        const location = {
-            s3Location: {
-                uri: "s3://bucket/azure/iam.md",
-            },
-            type: "S3",
-        };
-        const result = resolveToWebsiteUrl(location);
-        expect(result?.webLocation?.url).toBe("https://dx.pagopa.it/docs/azure/iam");
-    });
-    it("converte una chiave S3 index.md in url dx.pagopa.it/docs con slash finale", () => {
-        const location = {
-            s3Location: {
-                uri: "s3://bucket/pipelines/index.md",
-            },
-            type: "S3",
-        };
-        const result = resolveToWebsiteUrl(location);
-        expect(result?.webLocation?.url).toBe("https://dx.pagopa.it/docs/pipelines/");
-    });
-    it("ignora location non S3", () => {
-        const location = {
-            type: "WEB",
-            webLocation: {
-                url: "https://example.com",
-            },
-        };
-        const result = resolveToWebsiteUrl(location);
-        expect(result?.webLocation?.url).toBe("https://example.com");
-    });
-    it("restituisce undefined se location è undefined", () => {
-        expect(resolveToWebsiteUrl(undefined)).toBeUndefined();
-    });
-});

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

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { QueryPagoPADXDocumentationInputSchema } from "../query-pagopa-dx-documentation.js";
-// Test the Zod schema validation used in the tools
-describe("Query Validation", () => {
-    // Use the actual schema from QueryPagoPADXDocumentationTool
-    const queryDocSchema = QueryPagoPADXDocumentationInputSchema;
-    describe("QueryPagoPADXDocumentationTool validation", () => {
-        it("should accept valid queries", () => {
-            const validQueries = [
-                { query: "How do I set up the project?" },
-                { query: "abc" }, // minimum 3 characters
-                { query: "What is the DX CLI?" },
-                { query: "Terraform Azure provider setup" },
-            ];
-            validQueries.forEach((input) => {
-                const result = queryDocSchema.safeParse(input);
-                expect(result.success).toBe(true);
-            });
-        });
-        it("should reject queries shorter than 3 characters", () => {
-            const shortQueries = [{ query: "" }, { query: "a" }, { query: "ab" }];
-            shortQueries.forEach((input) => {
-                const result = queryDocSchema.safeParse(input);
-                expect(result.success).toBe(false);
-                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?.issues[0]?.message).toBe("Query must not exceed 500 characters");
-        });
-        it("should reject missing query field", () => {
-            const missingQuery = {};
-            const result = queryDocSchema.safeParse(missingQuery);
-            expect(result.success).toBe(false);
-        });
-        it("should reject non-string query values", () => {
-            const invalidTypes = [
-                { query: 123 },
-                { query: null },
-                { query: undefined },
-                { query: [] },
-                { query: {} },
-            ];
-            invalidTypes.forEach((input) => {
-                const result = queryDocSchema.safeParse(input);
-                expect(result.success).toBe(false);
-            });
-        });
-    });
-    describe("Edge cases", () => {
-        it("should handle queries with special characters", () => {
-            const specialCharQueries = [
-                { query: "api/management@v1" },
-                { query: "terraform-module (azure-app-service)" },
-                { query: "query with 'quotes' and \"double quotes\"" },
-            ];
-            specialCharQueries.forEach((input) => {
-                const result = queryDocSchema.safeParse(input);
-                expect(result.success).toBe(true);
-            });
-        });
-        it("should handle very long query strings within limit", () => {
-            const longQuery = { query: "a".repeat(500) }; // exactly at limit
-            const result = queryDocSchema.safeParse(longQuery);
-            expect(result.success).toBe(true);
-        });
-        it("should accept whitespace-only strings if they meet min length", () => {
-            // Note: The Zod schema doesn't call .trim(), so whitespace-only strings will be accepted
-            // if they meet the minimum length requirement (3 characters for queryDoc)
-            const whitespaceOnly = { query: "   " }; // 3 spaces = 3 characters
-            const result = queryDocSchema.safeParse(whitespaceOnly);
-            // Whitespace-only string has length >= 3, so it passes
-            expect(result.success).toBe(true);
-        });
-    });
-});

package/dist/tools/__tests__/query-pago-pa-dx-documentation.test.js

@@ -1,47 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-vi.mock("../../services/bedrock", () => ({
-    queryKnowledgeBase: vi.fn().mockResolvedValue("mocked result"),
-}));
-import { BedrockAgentRuntimeClient } from "@aws-sdk/client-bedrock-agent-runtime";
-import { createQueryPagoPADXDocumentationTool } from "../query-pagopa-dx-documentation.js";
-const QueryPagoPADXDocumentationTool = createQueryPagoPADXDocumentationTool({
-    kbRuntimeClient: new BedrockAgentRuntimeClient({ region: "eu-central-1" }),
-    knowledgeBaseId: "mockKbId",
-    rerankingEnabled: false,
-});
-describe("QueryPagoPADXDocumentationTool", () => {
-    it("should return results from the knowledge base", async () => {
-        const args = { format: "markdown", query: "test query" };
-        const result = await QueryPagoPADXDocumentationTool.execute(args);
-        expect(result).toBe("mocked result");
-    });
-    it("should use default format if not provided", async () => {
-        const args = { query: "test query" };
-        const result = await QueryPagoPADXDocumentationTool.execute(args);
-        expect(result).toBe("mocked result");
-    });
-    it("should reject unknown parameters due to strict schema", async () => {
-        const args = { query: "test query", unknownParam: "value" };
-        const result = await QueryPagoPADXDocumentationTool.execute(args);
-        expect(result).toContain("Error: Invalid input");
-        expect(result).toContain("Unrecognized key");
-    });
-    it("should reject queries shorter than 3 characters", async () => {
-        const args = { query: "ab" };
-        const result = await QueryPagoPADXDocumentationTool.execute(args);
-        expect(result).toContain("Error: Invalid input");
-        expect(result).toContain("Query must be at least 3 characters");
-    });
-    it("should reject empty queries", async () => {
-        const args = { query: "" };
-        const result = await QueryPagoPADXDocumentationTool.execute(args);
-        expect(result).toContain("Error: Invalid input");
-        expect(result).toContain("Query must be at least 3 characters");
-    });
-    it("should reject queries exceeding 500 characters", async () => {
-        const args = { query: "a".repeat(501) };
-        const result = await QueryPagoPADXDocumentationTool.execute(args);
-        expect(result).toContain("Error: Invalid input");
-        expect(result).toContain("Query must not exceed 500 characters");
-    });
-});

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

@@ -1,64 +0,0 @@
-import { BedrockAgentRuntimeClient } from "@aws-sdk/client-bedrock-agent-runtime";
-import { describe, expect, it } from "vitest";
-import { createToolDefinitions } from "../registry.js";
-const toolDefinitions = createToolDefinitions({
-    aws: {
-        knowledgeBaseId: "kb-id",
-        modelArn: "arn:aws:bedrock:eu-central-1:123456789012:model/model-id",
-        region: "eu-central-1",
-        rerankingEnabled: false,
-    },
-    githubSearchOrg: "pagopa",
-    kbRuntimeClient: new BedrockAgentRuntimeClient({ region: "eu-central-1" }),
-});
-describe("Tool Registry", () => {
-    describe("registry structure", () => {
-        it("should contain expected tools", () => {
-            expect(toolDefinitions).toHaveLength(1);
-            const toolIds = toolDefinitions.map((entry) => entry.id);
-            expect(toolIds).toContain("pagopa_query_documentation");
-        });
-        it("should have unique tool IDs", () => {
-            const toolIds = toolDefinitions.map((entry) => entry.id);
-            const uniqueIds = new Set(toolIds);
-            expect(uniqueIds.size).toBe(toolIds.length);
-        });
-        it("should follow snake_case naming convention with pagopa prefix", () => {
-            for (const entry of toolDefinitions) {
-                expect(entry.id).toMatch(/^pagopa_[a-z_]+$/);
-            }
-        });
-    });
-    describe("tool entries", () => {
-        it("should have valid tool definitions", () => {
-            for (const entry of toolDefinitions) {
-                expect(entry.tool).toBeDefined();
-                expect(entry.tool.name).toBeTruthy();
-                expect(entry.tool.description).toBeTruthy();
-                expect(entry.tool.execute).toBeTypeOf("function");
-                expect(entry.tool.parameters).toBeDefined();
-            }
-        });
-        it("should have proper annotations", () => {
-            for (const entry of toolDefinitions) {
-                expect(entry.tool.annotations).toBeDefined();
-                expect(entry.tool.annotations.title).toBeTruthy();
-            }
-        });
-    });
-    describe("session requirements", () => {
-        it("should mark documentation tool as not requiring session", () => {
-            const docTool = toolDefinitions.find((entry) => entry.id === "pagopa_query_documentation");
-            expect(docTool?.requiresSession).toBe(false);
-        });
-    });
-    describe("pagopa_query_documentation", () => {
-        const docTool = toolDefinitions.find((entry) => entry.id === "pagopa_query_documentation");
-        it("should have correct metadata", () => {
-            expect(docTool?.tool.name).toBe("pagopa_query_documentation");
-            expect(docTool?.tool.annotations.readOnlyHint).toBe(true);
-            expect(docTool?.tool.annotations.destructiveHint).toBe(false);
-            expect(docTool?.tool.annotations.idempotentHint).toBe(true);
-        });
-    });
-});

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

@@ -1,167 +0,0 @@
-import { AxiosError, AxiosHeaders } from "axios";
-import { describe, expect, it } from "vitest";
-import { z, ZodError } from "zod";
-import { handleApiError, isAxiosError, isZodError } from "../error-handling.js";
-/**
- * Helper to create an AxiosError with a response
- */
-const createAxiosResponseError = (status, statusText) => {
-    const config = { headers: new AxiosHeaders() };
-    return new AxiosError(statusText, "ERR_BAD_REQUEST", config, undefined, {
-        config,
-        data: {},
-        headers: {},
-        status,
-        statusText,
-    });
-};
-describe("handleApiError - Axios HTTP status codes", () => {
-    it("should handle 400 Bad Request", () => {
-        const error = createAxiosResponseError(400, "Bad Request");
-        expect(handleApiError(error)).toBe("Error: Bad request. Please check your input parameters.");
-    });
-    it("should handle 401 Unauthorized", () => {
-        const error = createAxiosResponseError(401, "Unauthorized");
-        expect(handleApiError(error)).toBe("Error: Authentication failed. Please check your credentials.");
-    });
-    it("should handle 403 Forbidden", () => {
-        const error = createAxiosResponseError(403, "Forbidden");
-        expect(handleApiError(error)).toBe("Error: Permission denied. You don't have access to this resource.");
-    });
-    it("should handle 404 Not Found", () => {
-        const error = createAxiosResponseError(404, "Not Found");
-        expect(handleApiError(error)).toBe("Error: Resource not found. Please check the ID is correct.");
-    });
-    it("should handle 429 Rate Limit", () => {
-        const error = createAxiosResponseError(429, "Too Many Requests");
-        expect(handleApiError(error)).toBe("Error: Rate limit exceeded. Please wait before making more requests.");
-    });
-    it("should handle 500 Internal Server Error", () => {
-        const error = createAxiosResponseError(500, "Internal Server Error");
-        expect(handleApiError(error)).toBe("Error: Server error. The service is temporarily unavailable.");
-    });
-    it("should handle 502 Bad Gateway", () => {
-        const error = createAxiosResponseError(502, "Bad Gateway");
-        expect(handleApiError(error)).toBe("Error: Bad gateway. The service is temporarily unavailable.");
-    });
-    it("should handle 503 Service Unavailable", () => {
-        const error = createAxiosResponseError(503, "Service Unavailable");
-        expect(handleApiError(error)).toBe("Error: Service unavailable. Please try again later.");
-    });
-    it("should handle unknown status codes", () => {
-        const error = createAxiosResponseError(418, "I'm a teapot");
-        expect(handleApiError(error)).toBe("Error: API request failed with status 418");
-    });
-});
-describe("handleApiError - Axios network errors", () => {
-    it("should handle ECONNABORTED timeout errors", () => {
-        const error = new AxiosError("Timeout", "ECONNABORTED");
-        expect(handleApiError(error)).toBe("Error: Request timed out. Please try again.");
-    });
-    it("should handle ENOTFOUND errors", () => {
-        const error = new AxiosError("Not Found", "ENOTFOUND");
-        expect(handleApiError(error)).toBe("Error: Could not connect to the server. Please check your network.");
-    });
-    it("should handle ECONNREFUSED errors", () => {
-        const error = new AxiosError("Connection Refused", "ECONNREFUSED");
-        expect(handleApiError(error)).toBe("Error: Connection refused. The server may be down.");
-    });
-    it("should handle other network errors", () => {
-        const error = new AxiosError("Unknown network error");
-        expect(handleApiError(error)).toBe("Error: Network error occurred: Unknown network error");
-    });
-});
-describe("handleApiError - Zod validation errors", () => {
-    it("should format single validation error", () => {
-        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 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 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", () => {
-    it("should handle Error instances", () => {
-        const error = new Error("Something went wrong");
-        expect(handleApiError(error)).toBe("Error: Something went wrong");
-    });
-    it("should handle string errors", () => {
-        expect(handleApiError("Raw string error")).toBe("Error: Unexpected error occurred: Raw string error");
-    });
-    it("should handle null", () => {
-        expect(handleApiError(null)).toBe("Error: Unexpected error occurred: null");
-    });
-    it("should handle undefined", () => {
-        expect(handleApiError(undefined)).toBe("Error: Unexpected error occurred: undefined");
-    });
-    it("should handle objects", () => {
-        expect(handleApiError({ custom: "error" })).toBe("Error: Unexpected error occurred: [object Object]");
-    });
-});
-describe("isAxiosError", () => {
-    it("should return true for AxiosError instances", () => {
-        const error = new AxiosError("Test error");
-        expect(isAxiosError(error)).toBe(true);
-    });
-    it("should return false for regular Error instances", () => {
-        const error = new Error("Test error");
-        expect(isAxiosError(error)).toBe(false);
-    });
-    it("should return false for non-errors", () => {
-        expect(isAxiosError("string")).toBe(false);
-        expect(isAxiosError(null)).toBe(false);
-        expect(isAxiosError(undefined)).toBe(false);
-    });
-});
-describe("isZodError", () => {
-    it("should return true for ZodError instances", () => {
-        const error = new ZodError([]);
-        expect(isZodError(error)).toBe(true);
-    });
-    it("should return false for regular Error instances", () => {
-        const error = new Error("Test error");
-        expect(isZodError(error)).toBe(false);
-    });
-    it("should return false for non-errors", () => {
-        expect(isZodError("string")).toBe(false);
-        expect(isZodError(null)).toBe(false);
-        expect(isZodError(undefined)).toBe(false);
-    });
-});