add middleware

perplexity-ask/dist/index.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+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 { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { createSSEServer } from "./sse-server.js";
+/**
+ * Definition of the Perplexity Ask Tool.
+ * This tool accepts an array of messages and returns a chat completion response
+ * from the Perplexity API, with citations appended to the message if provided.
+ */
+const PERPLEXITY_ASK_TOOL = {
+    name: "perplexity_ask",
+    description: "Engages in a conversation using the Sonar API. " +
+        "Accepts an array of messages (each with a role and content) " +
+        "and returns a ask completion response from the Perplexity model.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messages: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        role: {
+                            type: "string",
+                            description: "Role of the message (e.g., system, user, assistant)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The content of the message",
+                        },
+                    },
+                    required: ["role", "content"],
+                },
+                description: "Array of conversation messages",
+            },
+        },
+        required: ["messages"],
+    },
+};
+/**
+ * Definition of the Perplexity Research Tool.
+ * This tool performs deep research queries using the Perplexity API.
+ */
+const PERPLEXITY_RESEARCH_TOOL = {
+    name: "perplexity_research",
+    description: "Performs deep research using the Perplexity API. " +
+        "Accepts an array of messages (each with a role and content) " +
+        "and returns a comprehensive research response with citations.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messages: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        role: {
+                            type: "string",
+                            description: "Role of the message (e.g., system, user, assistant)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The content of the message",
+                        },
+                    },
+                    required: ["role", "content"],
+                },
+                description: "Array of conversation messages",
+            },
+        },
+        required: ["messages"],
+    },
+};
+/**
+ * Definition of the Perplexity Reason Tool.
+ * This tool performs reasoning queries using the Perplexity API.
+ */
+const PERPLEXITY_REASON_TOOL = {
+    name: "perplexity_reason",
+    description: "Performs reasoning tasks using the Perplexity API. " +
+        "Accepts an array of messages (each with a role and content) " +
+        "and returns a well-reasoned response using the sonar-reasoning-pro model.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            messages: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        role: {
+                            type: "string",
+                            description: "Role of the message (e.g., system, user, assistant)",
+                        },
+                        content: {
+                            type: "string",
+                            description: "The content of the message",
+                        },
+                    },
+                    required: ["role", "content"],
+                },
+                description: "Array of conversation messages",
+            },
+        },
+        required: ["messages"],
+    },
+};
+// Retrieve the Perplexity API key from environment variables
+const PERPLEXITY_API_KEY = process.env.PERPLEXITY_API_KEY;
+if (!PERPLEXITY_API_KEY) {
+    console.error("Error: PERPLEXITY_API_KEY environment variable is required");
+    process.exit(1);
+}
+/**
+ * Performs a chat completion by sending a request to the Perplexity API.
+ * Appends citations to the returned message content if they exist.
+ *
+ * @param {Array<{ role: string; content: string }>} messages - An array of message objects.
+ * @param {string} model - The model to use for the completion.
+ * @returns {Promise<string>} The chat completion result with appended citations.
+ * @throws Will throw an error if the API request fails.
+ */
+function performChatCompletion(messages_1) {
+    return __awaiter(this, arguments, void 0, function* (messages, model = "sonar-pro") {
+        // 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: 
+            // https://docs.perplexity.ai/api-reference/chat-completions
+        };
+        let response;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 90000); // 90秒超时
+        try {
+            response = yield fetch(url.toString(), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${PERPLEXITY_API_KEY}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error('Perplexity API request timed out after 90 seconds');
+            }
+            throw new Error(`Network error while calling Perplexity API: ${error}`);
+        }
+        // Check for non-successful HTTP status
+        if (!response.ok) {
+            let errorText;
+            try {
+                errorText = yield response.text();
+            }
+            catch (parseError) {
+                errorText = "Unable to parse error response";
+            }
+            throw new Error(`Perplexity API error: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        // Attempt to parse the JSON response from the API
+        let data;
+        try {
+            data = yield response.json();
+        }
+        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;
+        // 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";
+            data.citations.forEach((citation, index) => {
+                messageContent += `[${index + 1}] ${citation}\n`;
+            });
+        }
+        return messageContent;
+    });
+}
+// Initialize the server with tool metadata and capabilities
+const server = new Server({
+    name: "example-servers/perplexity-ask",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+/**
+ * Registers a handler for listing available tools.
+ * When the client requests a list of tools, this handler returns all available Perplexity tools.
+ */
+server.setRequestHandler(ListToolsRequestSchema, () => __awaiter(void 0, void 0, void 0, function* () {
+    return ({
+        tools: [PERPLEXITY_ASK_TOOL, PERPLEXITY_RESEARCH_TOOL, PERPLEXITY_REASON_TOOL],
+    });
+}));
+/**
+ * Registers a handler for calling a specific tool.
+ * Processes requests by validating input and invoking the appropriate tool.
+ *
+ * @param {object} request - The incoming tool call request.
+ * @returns {Promise<object>} The response containing the tool's result or an error.
+ */
+server.setRequestHandler(CallToolRequestSchema, (request) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { name, arguments: args } = request.params;
+        if (!args) {
+            throw new Error("No arguments provided");
+        }
+        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
+                const messages = args.messages;
+                const result = yield performChatCompletion(messages, "sonar-pro");
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            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
+                const messages = args.messages;
+                const result = yield performChatCompletion(messages, "sonar-deep-research");
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            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
+                const messages = args.messages;
+                const result = yield performChatCompletion(messages, "sonar-reasoning-pro");
+                return {
+                    content: [{ type: "text", text: result }],
+                    isError: false,
+                };
+            }
+            default:
+                // Respond with an error if an unknown tool is requested
+                return {
+                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        // Return error details in the response
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}));
+/**
+ * Initializes and runs the server using standard I/O for communication.
+ * Logs an error and exits if the server fails to start.
+ */
+function runServer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const PORT = process.env.PORT || 3001;
+            const sseServer = createSSEServer(server);
+            sseServer.listen(PORT);
+            console.error(`Perplexity MCP Server running on SSE and listening on port ${PORT} with Ask, Research, and Reason tools`);
+        }
+        catch (error) {
+            console.error("Fatal error running server:", error);
+            process.exit(1);
+        }
+    });
+}
+// Start the server and catch any startup errors
+runServer().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});