@perplexity-ai/mcp-server 0.2.3 → 0.3.1

package/dist/index.js

@@ -155,9 +155,31 @@ if (!PERPLEXITY_API_KEY) {
     console.error("Error: PERPLEXITY_API_KEY environment variable is required");
     process.exit(1);
 }
-// Configure timeout for API requests (default: 5 minutes)
-// Can be overridden via PERPLEXITY_TIMEOUT_MS environment variable
-const TIMEOUT_MS = parseInt(process.env.PERPLEXITY_TIMEOUT_MS || "300000", 10);
+/**
+ * Validates an array of message objects for chat completion tools.
+ * Ensures each message has a valid role and content field.
+ *
+ * @param {any} messages - The messages to validate
+ * @param {string} toolName - The name of the tool calling this validation (for error messages)
+ * @throws {Error} If messages is not an array or if any message is invalid
+ */
+function validateMessages(messages, toolName) {
+    if (!Array.isArray(messages)) {
+        throw new Error(`Invalid arguments for ${toolName}: 'messages' must be an array`);
+    }
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            throw new Error(`Invalid message at index ${i}: must be an object`);
+        }
+        if (!msg.role || typeof msg.role !== 'string') {
+            throw new Error(`Invalid message at index ${i}: 'role' must be a string`);
+        }
+        if (msg.content === undefined || msg.content === null || typeof msg.content !== 'string') {
+            throw new Error(`Invalid message at index ${i}: 'content' must be a string`);
+        }
+    }
+}
 /**
  * Performs a chat completion by sending a request to the Perplexity API.
  * Appends citations to the returned message content if they exist.
@@ -167,15 +189,17 @@ const TIMEOUT_MS = parseInt(process.env.PERPLEXITY_TIMEOUT_MS || "300000", 10);
  * @returns {Promise<string>} The chat completion result with appended citations.
  * @throws Will throw an error if the API request fails.
  */
-function performChatCompletion(messages_1) {
+export function performChatCompletion(messages_1) {
     return __awaiter(this, arguments, void 0, function* (messages, model = "sonar-pro") {
+        // Read timeout fresh each time to respect env var changes
+        const TIMEOUT_MS = parseInt(process.env.PERPLEXITY_TIMEOUT_MS || "300000", 10);
         // Construct the API endpoint URL and request body
         const url = new URL("https://api.perplexity.ai/chat/completions");
         const body = {
             model: model, // Model identifier passed as parameter
             messages: messages,
             // Additional parameters can be added here if required (e.g., max_tokens, temperature, etc.)
-            // See the Sonar API documentation for more details: 
+            // See the Sonar API documentation for more details:
             // https://docs.perplexity.ai/api-reference/chat-completions
         };
         const controller = new AbortController();
@@ -219,8 +243,16 @@ function performChatCompletion(messages_1) {
         catch (jsonError) {
             throw new Error(`Failed to parse JSON response from Perplexity API: ${jsonError}`);
         }
-        // Directly retrieve the main message content from the response 
-        let messageContent = data.choices[0].message.content;
+        // Validate response structure
+        if (!data.choices || !Array.isArray(data.choices) || data.choices.length === 0) {
+            throw new Error("Invalid API response: missing or empty choices array");
+        }
+        const firstChoice = data.choices[0];
+        if (!firstChoice.message || typeof firstChoice.message.content !== 'string') {
+            throw new Error("Invalid API response: missing message content");
+        }
+        // Directly retrieve the main message content from the response
+        let messageContent = firstChoice.message.content;
         // If citations are provided, append them to the message content
         if (data.citations && Array.isArray(data.citations) && data.citations.length > 0) {
             messageContent += "\n\nCitations:\n";
@@ -237,7 +269,7 @@ function performChatCompletion(messages_1) {
  * @param {any} data - The search response data from the API.
  * @returns {string} Formatted search results.
  */
-function formatSearchResults(data) {
+export function formatSearchResults(data) {
     if (!data.results || !Array.isArray(data.results)) {
         return "No search results found.";
     }
@@ -265,8 +297,10 @@ function formatSearchResults(data) {
  * @returns {Promise<string>} The formatted search results.
  * @throws Will throw an error if the API request fails.
  */
-function performSearch(query_1) {
+export function performSearch(query_1) {
     return __awaiter(this, arguments, void 0, function* (query, maxResults = 10, maxTokensPerPage = 1024, country) {
+        // Read timeout fresh each time to respect env var changes
+        const TIMEOUT_MS = parseInt(process.env.PERPLEXITY_TIMEOUT_MS || "300000", 10);
         const url = new URL("https://api.perplexity.ai/search");
         const body = {
             query: query,
@@ -352,10 +386,7 @@ server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(void 0, v
         }
         switch (name) {
             case "perplexity_ask": {
-                if (!Array.isArray(args.messages)) {
-                    throw new Error("Invalid arguments for perplexity_ask: 'messages' must be an array");
-                }
-                // Invoke the chat completion function with the provided messages
+                validateMessages(args.messages, "perplexity_ask");
                 const messages = args.messages;
                 const result = yield performChatCompletion(messages, "sonar-pro");
                 return {
@@ -364,10 +395,7 @@ server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(void 0, v
                 };
             }
             case "perplexity_research": {
-                if (!Array.isArray(args.messages)) {
-                    throw new Error("Invalid arguments for perplexity_research: 'messages' must be an array");
-                }
-                // Invoke the chat completion function with the provided messages using the deep research model
+                validateMessages(args.messages, "perplexity_research");
                 const messages = args.messages;
                 const result = yield performChatCompletion(messages, "sonar-deep-research");
                 return {
@@ -376,10 +404,7 @@ server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(void 0, v
                 };
             }
             case "perplexity_reason": {
-                if (!Array.isArray(args.messages)) {
-                    throw new Error("Invalid arguments for perplexity_reason: 'messages' must be an array");
-                }
-                // Invoke the chat completion function with the provided messages using the reasoning model
+                validateMessages(args.messages, "perplexity_reason");
                 const messages = args.messages;
                 const result = yield performChatCompletion(messages, "sonar-reasoning-pro");
                 return {

package/dist/index.test.js

@@ -0,0 +1,487 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { formatSearchResults, performChatCompletion, performSearch } from "./index.js";
+describe("Perplexity MCP Server", () => {
+    let originalFetch;
+    beforeEach(() => {
+        originalFetch = global.fetch;
+    });
+    afterEach(() => {
+        global.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    describe("formatSearchResults", () => {
+        it("should format search results correctly", () => {
+            const mockData = {
+                results: [
+                    {
+                        title: "Test Result 1",
+                        url: "https://example.com/1",
+                        snippet: "This is a test snippet",
+                        date: "2025-01-01",
+                    },
+                    {
+                        title: "Test Result 2",
+                        url: "https://example.com/2",
+                        snippet: "Another snippet",
+                    },
+                ],
+            };
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toContain("Found 2 search results");
+            expect(formatted).toContain("Test Result 1");
+            expect(formatted).toContain("https://example.com/1");
+            expect(formatted).toContain("This is a test snippet");
+            expect(formatted).toContain("Date: 2025-01-01");
+            expect(formatted).toContain("Test Result 2");
+        });
+        it("should handle empty results", () => {
+            const mockData = { results: [] };
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toContain("Found 0 search results");
+        });
+        it("should handle missing results array", () => {
+            const mockData = {};
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toBe("No search results found.");
+        });
+    });
+    describe("performChatCompletion", () => {
+        it("should successfully complete chat request", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                choices: [
+                    {
+                        message: {
+                            content: "This is a test response",
+                        },
+                    },
+                ],
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const messages = [{ role: "user", content: "test question" }];
+            const result = yield performChatCompletion(messages, "sonar-pro");
+            expect(result).toBe("This is a test response");
+            expect(global.fetch).toHaveBeenCalledWith("https://api.perplexity.ai/chat/completions", expect.objectContaining({
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Bearer test-api-key",
+                },
+                body: JSON.stringify({
+                    model: "sonar-pro",
+                    messages,
+                }),
+            }));
+        }));
+        it("should append citations when present", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                choices: [
+                    {
+                        message: {
+                            content: "Response with citations",
+                        },
+                    },
+                ],
+                citations: [
+                    "https://example.com/source1",
+                    "https://example.com/source2",
+                ],
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            const result = yield performChatCompletion(messages);
+            expect(result).toContain("Response with citations");
+            expect(result).toContain("\n\nCitations:\n");
+            expect(result).toContain("[1] https://example.com/source1");
+            expect(result).toContain("[2] https://example.com/source2");
+        }));
+        it("should handle API errors", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 401,
+                statusText: "Unauthorized",
+                text: () => __awaiter(void 0, void 0, void 0, function* () { return "Invalid API key"; }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("Perplexity API error: 401 Unauthorized");
+        }));
+        it("should handle timeout errors", () => __awaiter(void 0, void 0, void 0, function* () {
+            process.env.PERPLEXITY_TIMEOUT_MS = "100";
+            global.fetch = vi.fn().mockImplementation((_url, options) => {
+                return new Promise((resolve, reject) => {
+                    const signal = options === null || options === void 0 ? void 0 : options.signal;
+                    if (signal) {
+                        signal.addEventListener("abort", () => {
+                            reject(new DOMException("The operation was aborted.", "AbortError"));
+                        });
+                    }
+                    setTimeout(() => {
+                        resolve({
+                            ok: true,
+                            json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [{ message: { content: "late" } }] }); }),
+                        });
+                    }, 200);
+                });
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("Request timeout");
+        }));
+        it("should handle network errors", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockRejectedValue(new Error("Network failure"));
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("Network error while calling Perplexity API");
+        }));
+    });
+    describe("performSearch", () => {
+        it("should successfully perform search", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                results: [
+                    {
+                        title: "Search Result",
+                        url: "https://example.com",
+                        snippet: "Test snippet",
+                    },
+                ],
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const result = yield performSearch("test query", 10, 1024);
+            expect(result).toContain("Found 1 search results");
+            expect(result).toContain("Search Result");
+            expect(global.fetch).toHaveBeenCalledWith("https://api.perplexity.ai/search", expect.objectContaining({
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Bearer test-api-key",
+                },
+                body: JSON.stringify({
+                    query: "test query",
+                    max_results: 10,
+                    max_tokens_per_page: 1024,
+                }),
+            }));
+        }));
+        it("should include country parameter when provided", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = { results: [] };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            yield performSearch("test", 10, 1024, "US");
+            expect(global.fetch).toHaveBeenCalledWith("https://api.perplexity.ai/search", expect.objectContaining({
+                body: JSON.stringify({
+                    query: "test",
+                    max_results: 10,
+                    max_tokens_per_page: 1024,
+                    country: "US",
+                }),
+            }));
+        }));
+        it("should handle search API errors", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500,
+                statusText: "Internal Server Error",
+                text: () => __awaiter(void 0, void 0, void 0, function* () { return "Server error"; }),
+            });
+            yield expect(performSearch("test")).rejects.toThrow("Perplexity Search API error: 500 Internal Server Error");
+        }));
+    });
+    describe("API Response Validation", () => {
+        it("should handle empty choices array", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [] }); }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("missing or empty choices array");
+        }));
+        it("should handle missing message content", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [{ message: null }] }); }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("missing message content");
+        }));
+        it("should handle missing choices property", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("missing or empty choices array");
+        }));
+        it("should handle malformed message object", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [{ message: { content: 123 } }] }); }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("missing message content");
+        }));
+        it("should handle null choices", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: null }); }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("missing or empty choices array");
+        }));
+        it("should handle undefined message in choice", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [{}] }); }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("missing message content");
+        }));
+        it("should handle empty citations array gracefully", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                choices: [{ message: { content: "Response" } }],
+                citations: [],
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            const result = yield performChatCompletion(messages);
+            expect(result).toBe("Response");
+            expect(result).not.toContain("Citations:");
+        }));
+        it("should handle non-array citations", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                choices: [{ message: { content: "Response" } }],
+                citations: "not-an-array",
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            const result = yield performChatCompletion(messages);
+            expect(result).toBe("Response");
+            expect(result).not.toContain("Citations:");
+        }));
+    });
+    describe("Edge Cases", () => {
+        it("should handle JSON parse errors gracefully", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error("Invalid JSON");
+                }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("Failed to parse JSON response");
+        }));
+        it("should handle error text parse failures", () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500,
+                statusText: "Internal Server Error",
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error("Cannot read error");
+                }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            yield expect(performChatCompletion(messages)).rejects.toThrow("Unable to parse error response");
+        }));
+        it("should handle special characters in messages", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                choices: [{ message: { content: "Response with émojis 🎉 and unicode ñ" } }],
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const messages = [{ role: "user", content: "test with émojis 🎉" }];
+            const result = yield performChatCompletion(messages);
+            expect(result).toContain("émojis 🎉");
+            expect(result).toContain("unicode ñ");
+        }));
+        it("should handle very long content strings", () => __awaiter(void 0, void 0, void 0, function* () {
+            const longContent = "x".repeat(100000);
+            const mockResponse = {
+                choices: [{ message: { content: longContent } }],
+            };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            const messages = [{ role: "user", content: "test" }];
+            const result = yield performChatCompletion(messages);
+            expect(result).toBe(longContent);
+            expect(result.length).toBe(100000);
+        }));
+        it("should handle multiple models correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const models = ["sonar-pro", "sonar-deep-research", "sonar-reasoning-pro"];
+            for (const model of models) {
+                const mockResponse = {
+                    choices: [{ message: { content: `Response from ${model}` } }],
+                };
+                global.fetch = vi.fn().mockResolvedValue({
+                    ok: true,
+                    json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+                });
+                const messages = [{ role: "user", content: "test" }];
+                const result = yield performChatCompletion(messages, model);
+                expect(result).toContain(model);
+                expect(global.fetch).toHaveBeenCalledWith("https://api.perplexity.ai/chat/completions", expect.objectContaining({
+                    body: expect.stringContaining(`"model":"${model}"`),
+                }));
+            }
+        }));
+        it("should handle search with boundary values", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = { results: [] };
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return mockResponse; }),
+            });
+            // Test max values
+            yield performSearch("test", 20, 2048);
+            expect(global.fetch).toHaveBeenCalledWith("https://api.perplexity.ai/search", expect.objectContaining({
+                body: expect.stringContaining('"max_results":20'),
+            }));
+            // Test min values
+            yield performSearch("test", 1, 256);
+            expect(global.fetch).toHaveBeenCalledWith("https://api.perplexity.ai/search", expect.objectContaining({
+                body: expect.stringContaining('"max_results":1'),
+            }));
+        }));
+        it("should handle formatSearchResults with missing optional fields", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockData = {
+                results: [
+                    { title: "Test", url: "https://example.com" },
+                    { title: "Test 2", url: "https://example.com/2", snippet: "snippet only" },
+                    { title: "Test 3", url: "https://example.com/3", date: "2025-01-01" },
+                ],
+            };
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toContain("Test");
+            expect(formatted).toContain("Test 2");
+            expect(formatted).toContain("snippet only");
+            expect(formatted).toContain("Date: 2025-01-01");
+            expect(formatted).not.toContain("undefined");
+        }));
+        it("should handle concurrent requests correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            let callCount = 0;
+            global.fetch = vi.fn().mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+                const currentCall = ++callCount;
+                yield new Promise((resolve) => setTimeout(resolve, 10));
+                return {
+                    ok: true,
+                    json: () => __awaiter(void 0, void 0, void 0, function* () {
+                        return ({
+                            choices: [{ message: { content: `Response ${currentCall}` } }]
+                        });
+                    }),
+                };
+            }));
+            const messages = [{ role: "user", content: "test" }];
+            const promises = [
+                performChatCompletion(messages),
+                performChatCompletion(messages),
+                performChatCompletion(messages),
+            ];
+            const results = yield Promise.all(promises);
+            expect(results).toHaveLength(3);
+            expect(global.fetch).toHaveBeenCalledTimes(3);
+            // Results should all be present (may not be unique due to timing)
+            expect(results.every(r => r.startsWith("Response"))).toBe(true);
+        }));
+        it("should respect timeout on each call independently", () => __awaiter(void 0, void 0, void 0, function* () {
+            // First call with long timeout
+            process.env.PERPLEXITY_TIMEOUT_MS = "1000";
+            global.fetch = vi.fn().mockImplementation((_url, options) => {
+                return new Promise((resolve) => {
+                    const signal = options === null || options === void 0 ? void 0 : options.signal;
+                    setTimeout(() => {
+                        if (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+                            resolve({
+                                ok: true,
+                                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [{ message: { content: "fast" } }] }); }),
+                            });
+                        }
+                    }, 50);
+                });
+            });
+            const messages = [{ role: "user", content: "test" }];
+            const result1 = yield performChatCompletion(messages);
+            expect(result1).toBe("fast");
+            // Second call with short timeout
+            process.env.PERPLEXITY_TIMEOUT_MS = "10";
+            global.fetch = vi.fn().mockImplementation((_url, options) => {
+                return new Promise((resolve, reject) => {
+                    const signal = options === null || options === void 0 ? void 0 : options.signal;
+                    if (signal) {
+                        signal.addEventListener("abort", () => {
+                            reject(new DOMException("The operation was aborted.", "AbortError"));
+                        });
+                    }
+                    setTimeout(() => {
+                        resolve({
+                            ok: true,
+                            json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ choices: [{ message: { content: "slow" } }] }); }),
+                        });
+                    }, 100);
+                });
+            });
+            yield expect(performChatCompletion(messages)).rejects.toThrow("timeout");
+        }));
+    });
+    describe("formatSearchResults Edge Cases", () => {
+        it("should handle results with null/undefined values", () => {
+            const mockData = {
+                results: [
+                    { title: null, url: "https://example.com", snippet: undefined },
+                    { title: "Valid", url: null, snippet: "snippet", date: undefined },
+                ],
+            };
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toContain("null");
+            expect(formatted).toContain("Valid");
+            expect(formatted).not.toContain("undefined");
+        });
+        it("should handle empty strings in result fields", () => {
+            const mockData = {
+                results: [{ title: "", url: "", snippet: "", date: "" }],
+            };
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toContain("Found 1 search results");
+        });
+        it("should handle results with extra unexpected fields", () => {
+            const mockData = {
+                results: [
+                    {
+                        title: "Test",
+                        url: "https://example.com",
+                        unexpectedField: "should be ignored",
+                        anotherField: 12345,
+                    },
+                ],
+            };
+            const formatted = formatSearchResults(mockData);
+            expect(formatted).toContain("Test");
+            expect(formatted).not.toContain("unexpectedField");
+            expect(formatted).not.toContain("12345");
+        });
+    });
+});

package/dist/vitest.config.js

@@ -0,0 +1,19 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        exclude: ['**/node_modules/**', '**/dist/**'],
+        env: {
+            PERPLEXITY_API_KEY: 'test-api-key',
+        },
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'html', 'lcov'],
+            exclude: [
+                '**/node_modules/**',
+                '**/dist/**',
+                '**/*.test.ts',
+                '**/*.config.ts',
+            ],
+        },
+    },
+});

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@perplexity-ai/mcp-server",
-  "version": "0.2.3",
-  "description": "Official MCP server for Perplexity API Platform",
+  "version": "0.3.1",
+  "mcpName": "io.github.perplexityai/mcp-server",
+  "description": "Real-time web search, reasoning, and research through Perplexity's API",
   "keywords": [
     "ai",
     "perplexity",
@@ -33,17 +34,21 @@
   "scripts": {
     "build": "tsc && shx chmod +x dist/*.js",
     "prepare": "npm run build",
-    "watch": "tsc --watch"
+    "watch": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.1",
-    "axios": "^1.6.2",
-    "dotenv": "^16.3.1"
+    "@modelcontextprotocol/sdk": "^1.21.1",
+    "dotenv": "^16.6.1"
   },
   "devDependencies": {
     "@types/node": "^20",
-    "shx": "^0.3.4",
-    "typescript": "^5.6.2"
+    "@vitest/coverage-v8": "^4.0.5",
+    "shx": "^0.4.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.5"
   },
   "engines": {
     "node": ">=18"