@revenium/perplexity 1.0.0

package/examples/simple-test.ts

@@ -0,0 +1,278 @@
+import { config } from "dotenv";
+import "../src/index"; // Import middleware to activate automatic tracking
+
+config();
+
+async function perplexityBasicExample(): Promise<boolean> {
+  console.log("\n🤖 Perplexity AI - Basic Example");
+  console.log("=".repeat(50));
+
+  const perplexityApiKey = process.env.PERPLEXITY_API_KEY;
+  const reveniumKey = process.env.REVENIUM_METERING_API_KEY;
+
+  if (!perplexityApiKey) {
+    console.log("❌ PERPLEXITY_API_KEY not found");
+    console.log("   Set: export PERPLEXITY_API_KEY=your-perplexity-api-key");
+    return false;
+  }
+
+  if (!reveniumKey) {
+    console.log("⚠️  REVENIUM_METERING_API_KEY not found - metering will fail");
+    console.log("   Set: export REVENIUM_METERING_API_KEY=your-revenium-key");
+  }
+
+  console.log(`✅ Perplexity API Key: ${perplexityApiKey.substring(0, 10)}...`);
+  if (reveniumKey) {
+    console.log(`✅ Revenium Key: ${reveniumKey.substring(0, 10)}...`);
+  }
+
+  try {
+    const response = await fetch("https://api.perplexity.ai/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${perplexityApiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "perplexity-online",
+        messages: [
+          {
+            role: "user",
+            content:
+              "What is the meaning of life, the universe and everything?",
+          },
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const result = await response.json();
+    console.log(
+      `✅ Response: ${result.choices[0].message.content.substring(0, 100)}...`
+    );
+    console.log("✅ Response received successfully");
+    console.log("📊 Token usage will be tracked by the middleware");
+    console.log("🎉 Zero-config integration successful!");
+    console.log("   Your usage is automatically tracked in Revenium");
+    return true;
+  } catch (error) {
+    console.log(`❌ Perplexity test failed: ${error}`);
+    console.error(error);
+    return false;
+  }
+}
+
+async function perplexityEnhancedExample(): Promise<boolean> {
+  console.log("\n📊 Perplexity AI - Enhanced Tracking Example");
+  console.log("=".repeat(50));
+
+  const perplexityApiKey = process.env.PERPLEXITY_API_KEY;
+  if (!perplexityApiKey) {
+    console.log("❌ PERPLEXITY_API_KEY not found");
+    return false;
+  }
+
+  try {
+    const response = await fetch("https://api.perplexity.ai/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${perplexityApiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "perplexity-online",
+        messages: [
+          {
+            role: "user",
+            content: "Analyze this quarterly report for key insights",
+          },
+        ],
+        usageMetadata: {
+          traceId: "conv-28a7e9d4",
+          taskType: "document-analysis",
+          subscriberEmail: "user@example.com",
+          subscriberId: "user-12345",
+          organizationId: "acme-corp",
+          subscriptionId: "premium-plan",
+          productId: "business-intelligence",
+          agent: "report-analyzer-v2",
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const result = await response.json();
+    console.log(
+      `✅ Enhanced response: ${result.choices[0].message.content.substring(
+        0,
+        100
+      )}...`
+    );
+    console.log("🎯 Enhanced tracking with metadata successful!");
+    return true;
+  } catch (error) {
+    console.log(`❌ Perplexity enhanced test failed: ${error}`);
+    console.error(error);
+    return false;
+  }
+}
+
+async function perplexityStreamingExample(): Promise<boolean> {
+  console.log("\n🌊 Perplexity AI - Streaming Example");
+  console.log("=".repeat(50));
+
+  const perplexityApiKey = process.env.PERPLEXITY_API_KEY;
+  if (!perplexityApiKey) {
+    console.log("❌ PERPLEXITY_API_KEY not found");
+    return false;
+  }
+
+  try {
+    const response = await fetch("https://api.perplexity.ai/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${perplexityApiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "perplexity-online",
+        messages: [
+          {
+            role: "user",
+            content: "Write a creative story about AI",
+          },
+        ],
+        stream: true,
+        usageMetadata: {
+          organizationId: "creative-studio",
+          taskType: "creative-writing",
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    if (!response.body) {
+      throw new Error("No response body for streaming");
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let streamedContent = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split("\n");
+
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") break;
+
+          try {
+            const parsed = JSON.parse(data);
+            if (parsed.choices[0]?.delta?.content) {
+              const content = parsed.choices[0].delta.content;
+              streamedContent += content;
+              process.stdout.write(content);
+            }
+          } catch (e) {
+            // Ignore parsing errors for incomplete chunks
+          }
+        }
+      }
+    }
+
+    console.log("\n✅ Streaming completed successfully");
+    console.log("📊 Streaming usage will be tracked by the middleware");
+    return true;
+  } catch (error) {
+    console.log(`❌ Perplexity streaming test failed: ${error}`);
+    console.error(error);
+    return false;
+  }
+}
+
+async function perplexityDifferentModelExample(): Promise<boolean> {
+  console.log("\n🔧 Perplexity AI - Different Model Example");
+  console.log("=".repeat(50));
+
+  const perplexityApiKey = process.env.PERPLEXITY_API_KEY;
+  if (!perplexityApiKey) {
+    console.log("❌ PERPLEXITY_API_KEY not found");
+    return false;
+  }
+
+  try {
+    const response = await fetch("https://api.perplexity.ai/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${perplexityApiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "llama-3.1-8b-online",
+        messages: [
+          {
+            role: "user",
+            content: "Explain quantum computing in simple terms",
+          },
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const result = await response.json();
+    console.log(
+      `✅ Llama response: ${result.choices[0].message.content.substring(
+        0,
+        100
+      )}...`
+    );
+    console.log("✅ Different model test successful!");
+    return true;
+  } catch (error) {
+    console.log(`❌ Perplexity different model test failed: ${error}`);
+    console.error(error);
+    return false;
+  }
+}
+
+async function main(): Promise<void> {
+  console.log("🚀 Starting Revenium Perplexity AI Middleware Tests");
+  console.log("=".repeat(60));
+
+  let successCount = 0;
+  const totalTests: number = 4;
+
+  // Run Perplexity AI tests
+  if (await perplexityBasicExample()) successCount++;
+  if (await perplexityEnhancedExample()) successCount++;
+  if (await perplexityStreamingExample()) successCount++;
+  if (await perplexityDifferentModelExample()) successCount++;
+
+  console.log("\n" + "=".repeat(60));
+  console.log(`📊 Test Results: ${successCount}/${totalTests} tests passed`);
+
+  if (successCount === totalTests) {
+    console.log("🎉 All tests passed! Middleware is working correctly.");
+  } else {
+    console.log("⚠️  Some tests failed. Check the logs above for details.");
+  }
+}
+
+main().catch(console.error);

package/examples/streaming-example.ts

@@ -0,0 +1,46 @@
+import { config } from "dotenv";
+import { createPerplexityClient } from "../src/perplexity-ai";
+
+config();
+
+async function streamingExample() {
+  console.log("\n🌊 Perplexity AI - Streaming Example");
+  console.log("=".repeat(50));
+
+  try {
+    // Create client instance
+    const client = createPerplexityClient();
+
+    // Create streaming chat completion
+    const stream = await client.createStreamingChatCompletion({
+      model: "sonar-pro",
+      messages: [
+        {
+          role: "user",
+          content: "Write a creative story about AI and the future of technology",
+        },
+      ],
+    });
+
+    console.log("📝 Streaming response:");
+    console.log("-".repeat(30));
+
+    let fullContent = "";
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) {
+        fullContent += content;
+        process.stdout.write(content);
+      }
+    }
+
+    console.log("\n\n✅ Streaming completed successfully");
+    console.log("📊 Streaming usage automatically tracked by middleware");
+    console.log("🎉 Streaming example successful!");
+
+  } catch (error) {
+    console.error("❌ Error:", error);
+  }
+}
+
+streamingExample().catch(console.error);

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@revenium/perplexity",
+  "version": "1.0.0",
+  "description": "NodeJS middleware for perplexity's AI API",
+  "homepage": "https://github.com/revenium/revenium-middleware-perplexity-node#readme",
+  "bugs": {
+    "url": "https://github.com/revenium/revenium-middleware-perplexity-node/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/revenium/revenium-middleware-perplexity-node.git"
+  },
+  "license": "ISC",
+  "author": "",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean",
+    "simple-test": "npx ts-node examples/simple-test.ts",
+    "perplexity-basic-example": "npx ts-node examples/perplexity_basic_example.ts",
+    "perplexity-middleware-example": "npx ts-node examples/perplexity_middleware_example.ts",
+    "basic-client-example": "npx ts-node examples/basic-client-example.ts",
+    "streaming-example": "npx ts-node examples/streaming-example.ts",
+    "multiple-models-example": "npx ts-node examples/multiple-models-example.ts",
+    "openai-client-example": "npx ts-node examples/openai-client-example.ts",
+    "metadata-example": "npx ts-node examples/metadata-example.ts",
+    "run-all-examples": "npx ts-node examples/run-all-examples.ts"
+  },
+  "keywords": [
+    "revenium",
+    "middleware",
+    "perplexity",
+    "ai",
+    "chat",
+    "completion",
+    "metering",
+    "monitoring",
+    "typescript"
+  ],
+  "dependencies": {
+    "axios": "^1.11.0",
+    "dotenv": "^17.2.1",
+    "openai": "^5.15.0",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.9.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+import { config } from "dotenv";
+import { Logger } from "./models";
+import { activeMiddleware } from "./utils/activeMiddleware";
+import { verifyLogVerbose } from "./utils/verifyLogVerbose";
+
+// Import the Perplexity middleware to activate it
+import "./perplexity-ai/middleware";
+
+config();
+
+const verboseStartup:boolean =
+  process.env.REVENIUM_VERBOSE_STARTUP?.toLowerCase() === "true";
+
+verifyLogVerbose(
+  verboseStartup,
+  "Revenium Perplexity middleware initialization starting"
+);
+
+// Activate middleware for Perplexity AI
+let activeSDKs: string[] = [];
+activeMiddleware(verboseStartup, activeSDKs, "perplexity-ai");
+
+// Export all utilities, types, and models
+export * from "./utils";
+export * from "./types";
+export * from "./models";
+
+// Export Perplexity client and middleware
+export * from "./perplexity-ai";
+
+// Log the active SDKs
+Logger.info(
+  "Revenium Perplexity middleware activated for: %s",
+  activeSDKs.length > 0 ? activeSDKs.join(", ") : "none"
+);
+
+export const version:string = "0.1.0";
+export const activeSDKList:string[] = activeSDKs;

package/src/models/Exception/ApiResponseError.ts

@@ -0,0 +1,6 @@
+export class ApiResponseError extends Error {
+  constructor(message: string, public statusCode?: number, public response?: any) {
+    super(message);
+    this.name = 'ApiResponseError';
+  }
+}

package/src/models/Exception/ConfigurationError.ts

@@ -0,0 +1,6 @@
+export class ConfigurationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ConfigurationError';
+  }
+}

package/src/models/Exception/MeteringError.ts

@@ -0,0 +1,6 @@
+export class MeteringError extends Error {
+  constructor(message: string, public originalError?: Error) {
+    super(message);
+    this.name = 'MeteringError';
+  }
+}

package/src/models/Exception/MiddlewareActivationError.ts

@@ -0,0 +1,6 @@
+export class MiddlewareActivationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'MiddlewareActivationError';
+  }
+}

package/src/models/Exception/StreamTrackingError.ts

@@ -0,0 +1,6 @@
+export class StreamTrackingError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'StreamTrackingError';
+  }
+}

package/src/models/Exception/TokenCountingError.ts

@@ -0,0 +1,6 @@
+export class TokenCountingError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'TokenCountingError';
+  }
+}

package/src/models/Exception/index.ts

@@ -0,0 +1,6 @@
+export * from "./ApiResponseError";
+export * from "./ConfigurationError";
+export * from "./MeteringError";
+export * from "./MiddlewareActivationError";
+export * from "./StreamTrackingError";
+export * from "./TokenCountingError";

package/src/models/Logger.ts

@@ -0,0 +1,38 @@
+import { LOG_LEVELS } from "../utils/constants/constants";
+
+export class Logger {
+  private static logLevel: string = process.env.REVENIUM_LOG_LEVEL || "INFO";
+
+  static debug(message: string, data?: any): void {
+    if (this.shouldLog(LOG_LEVELS[0])) {
+      console.log(`${LOG_LEVELS[0]} ${message}`, data || "");
+    }
+  }
+
+  static info(message: string, data?: any): void {
+    if (this.shouldLog(LOG_LEVELS[1])) {
+      console.log(`${LOG_LEVELS[1]} ${message}`, data || "");
+    }
+  }
+
+  static warning(message: string, data?: any): void {
+    if (this.shouldLog(LOG_LEVELS[2])) {
+      console.warn(`${LOG_LEVELS[2]} ${message}`, data || "");
+    }
+  }
+
+  static error(message: string, data?: any): void {
+    if (this.shouldLog(LOG_LEVELS[3])) {
+      console.error(`${LOG_LEVELS[3]} ${message}`, data || "");
+    }
+  }
+
+  private static shouldLog(level: string): boolean {
+    const levels = LOG_LEVELS;
+    const currentLevel = levels.indexOf(this.logLevel.toUpperCase());
+    const messageLevel = levels.indexOf(level);
+    return messageLevel >= currentLevel;
+  }
+}
+
+export const logger = Logger;

package/src/models/index.ts

@@ -0,0 +1,2 @@
+export * from "./Logger";
+export * from "./Exception";

package/src/perplexity-ai/client.ts

@@ -0,0 +1,97 @@
+import { OpenAI } from "openai";
+import type { ChatCompletionMessageParam } from "openai/resources/chat/completions";
+import { Logger } from "../models";
+import {
+  PERPLEXITY_CHAT_COMPLETION_FAILED_MESSAGE,
+  PERPLEXITY_CLIENT_INITIALIZED_MESSAGE,
+  PERPLEXITY_GET_MODELS_FAILED_MESSAGE,
+  PERPLEXITY_REQUIRED_API_KEY_MESSAGE,
+  PERPLEXITY_STREAMING_CHAT_COMPLETION_FAILED_MESSAGE,
+} from "../utils/constants/messages";
+
+// Import middleware to activate automatic tracking
+import "./middleware";
+import { CURRENT_PERPLEXITY_BASE_URL } from "../utils/constants/constants";
+
+//Perplexity AI Client with middleware integration
+export class PerplexityClient {
+  private client: OpenAI;
+
+  constructor(apiKey?: string) {
+    const perplexityApiKey = apiKey || process.env.PERPLEXITY_API_KEY;
+
+    if (!perplexityApiKey) {
+      throw new Error(PERPLEXITY_REQUIRED_API_KEY_MESSAGE);
+    }
+
+    this.client = new OpenAI({
+      apiKey: perplexityApiKey,
+      baseURL: CURRENT_PERPLEXITY_BASE_URL,
+    });
+
+    Logger.info(PERPLEXITY_CLIENT_INITIALIZED_MESSAGE);
+  }
+
+  //Create a chat completion
+  async createChatCompletion(params: {
+    model: string;
+    messages: ChatCompletionMessageParam[];
+    stream?: false;
+    usageMetadata?: any;
+    [key: string]: any;
+  }) {
+    try {
+      // Remove usageMetadata from params as it's not part of OpenAI API
+      const { usageMetadata, ...openaiParams } = params;
+      const response = await this.client.chat.completions.create(openaiParams);
+      return response;
+    } catch (error) {
+      Logger.error(PERPLEXITY_CHAT_COMPLETION_FAILED_MESSAGE, { error });
+      throw error;
+    }
+  }
+
+  //Create a streaming chat completion
+  async createStreamingChatCompletion(params: {
+    model: string;
+    messages: ChatCompletionMessageParam[];
+    usageMetadata?: any;
+    [key: string]: any;
+  }) {
+    try {
+      // Remove usageMetadata from params as it's not part of OpenAI API
+      const { usageMetadata, ...openaiParams } = params;
+      const stream = await this.client.chat.completions.create({
+        ...openaiParams,
+        stream: true,
+      });
+      return stream;
+    } catch (error) {
+      Logger.error(PERPLEXITY_STREAMING_CHAT_COMPLETION_FAILED_MESSAGE, {
+        error,
+      });
+      throw error;
+    }
+  }
+
+  //Get available models
+  async getModels() {
+    try {
+      const models = await this.client.models.list();
+      return models;
+    } catch (error) {
+      Logger.error(PERPLEXITY_GET_MODELS_FAILED_MESSAGE, { error });
+      throw error;
+    }
+  }
+}
+
+/**
+ * Create a Perplexity client instance
+ */
+export function createPerplexityClient(apiKey?: string): PerplexityClient {
+  return new PerplexityClient(apiKey);
+}
+
+// Export the OpenAI client for advanced usage
+export { OpenAI };

package/src/perplexity-ai/index.ts

@@ -0,0 +1,2 @@
+export * from "./middleware";
+export * from "./client";