@revenium/perplexity 1.0.0

package/src/perplexity-ai/middleware.ts

@@ -0,0 +1,259 @@
+import { logger, Logger } from "../models";
+import {
+  OperationType,
+  Provider,
+  UsageMetadata,
+  StreamTracker,
+} from "../types";
+import {
+  formatTimestamp,
+  calculateDurationMs,
+  extractPerplexityTokenCounts,
+  extractStopReason,
+  extractModelName,
+  extractUsageMetadata,
+  createMeteringRequest,
+  sendMeteringData,
+  generateTransactionId,
+} from "../utils";
+import { ConfigurationError, StreamTrackingError } from "../models";
+import {
+  DEBUG_MIDDLEWARE_ALREADY_INITIALIZED_MESSAGE,
+  DEBUG_MIDDLEWARE_FAILED_TO_INITIALIZE_MESSAGE,
+  DEBUG_MIDDLEWARE_INITIALIZED_MESSAGE,
+  FAILED_TO_INITIALIZE_PERPLEXITY_MIDDLEWARE_MESSAGE,
+  DEBUG_MIDDLEWARE_INTERCEPTING_PERPLEXITY_REQUESTS_MESSAGE,
+  WARNING_REVENIUM_METERING_API_KEY_NOT_FOUND_MESSAGE,
+  FAILED_TO_PARSE_REQUEST_BODY_FOR_METADATA_EXTRACTION_MESSAGE,
+  DEBUG_MIDDLEWARE_PERPLEXITY_API_REQUEST_INTERCEPTED_MESSAGE,
+  ERROR_PERPLEXITY_API_REQUEST_FAILED_MESSAGE,
+  WARNING_FAILED_TO_SEND_METERING_DATA_MESSAGE,
+  DEBUG_MIDDLEWARE_PERPLEXITY_API_RESPONSE_METERING_COMPLETED_MESSAGE,
+  DEBUG_SKIPPING_METERING_DATA_SEND_MESSAGE,
+  ERROR_FAILED_TO_PROCESS_PERPLEXITY_RESPONSE_MESSAGE,
+} from "../utils/constants/messages";
+import {
+  CURRENT_PERPLEXITY_BASE_URL,
+  DEFAULT_PERPLEXITY_MODEL,
+  REVENIUM_METERING_BASE_URL,
+} from "../utils/constants/constants";
+import { Subscriber } from "../types/subscriber";
+import {
+  getPerplexityBaseUrl,
+  getReveniumApiKey,
+  getReveniumBaseUrl,
+} from "../utils/getEnv";
+
+// Stream tracking storage
+const streamTrackers: Map<string, StreamTracker> = new Map<
+  string,
+  StreamTracker
+>();
+
+// Track if middleware has been initialized to avoid double initialization
+let middlewareInitialized: boolean = false;
+
+//Initialize Perplexity AI middleware.
+function initializePerplexityMiddleware(): void {
+  if (middlewareInitialized) {
+    console.log(DEBUG_MIDDLEWARE_ALREADY_INITIALIZED_MESSAGE);
+    return;
+  }
+
+  // Always initialize middleware, even without API key
+  if (!getReveniumApiKey()) {
+    Logger.warning(WARNING_REVENIUM_METERING_API_KEY_NOT_FOUND_MESSAGE);
+  }
+
+  try {
+    // Intercept HTTP requests to Perplexity API
+    interceptPerplexityHTTPRequests();
+
+    // Mark as initialized
+    middlewareInitialized = true;
+    console.log(DEBUG_MIDDLEWARE_INITIALIZED_MESSAGE);
+  } catch (error) {
+    console.error(DEBUG_MIDDLEWARE_FAILED_TO_INITIALIZE_MESSAGE, error);
+    throw new ConfigurationError(
+      `${FAILED_TO_INITIALIZE_PERPLEXITY_MIDDLEWARE_MESSAGE}: ${error}`
+    );
+  }
+}
+
+//Intercept HTTP requests to Perplexity API
+function interceptPerplexityHTTPRequests(): void {
+  // Store original fetch function
+  const originalFetch = global.fetch;
+
+  // Override fetch to intercept Perplexity API calls
+  global.fetch = async function (
+    input: string | URL | Request,
+    init?: RequestInit
+  ): Promise<Response> {
+    const url = typeof input === "string" ? input : input.toString();
+    console.log("🔍 [DEBUG] URL:", url);
+
+    // Check if this is a Perplexity API request
+    if (
+      url.includes(getPerplexityBaseUrl()) ||
+      url.includes("api.perplexity.ai")
+    ) {
+      return await handlePerplexityRequest(url, init, originalFetch);
+    }
+
+    // For non-Perplexity requests, use original fetch
+    return originalFetch(input, init);
+  };
+
+  console.log(DEBUG_MIDDLEWARE_INTERCEPTING_PERPLEXITY_REQUESTS_MESSAGE);
+}
+
+//Handle Perplexity API requests
+async function handlePerplexityRequest(
+  url: string,
+  init: RequestInit | undefined,
+  originalFetch: typeof fetch
+): Promise<Response> {
+  const startTime = new Date();
+  const transactionId = generateTransactionId();
+
+  // Extract request body for metadata
+  let requestBody: any = {};
+  if (init?.body) {
+    try {
+      requestBody =
+        typeof init.body === "string" ? JSON.parse(init.body) : init.body;
+    } catch (error) {
+      Logger.warning(
+        FAILED_TO_PARSE_REQUEST_BODY_FOR_METADATA_EXTRACTION_MESSAGE
+      );
+    }
+  }
+
+  // Extract usage metadata
+  const usageMetadata = extractUsageMetadata(requestBody, null);
+  const model = requestBody.model || DEFAULT_PERPLEXITY_MODEL;
+
+  Logger.debug(DEBUG_MIDDLEWARE_PERPLEXITY_API_REQUEST_INTERCEPTED_MESSAGE, {
+    transactionId,
+    model,
+    url,
+  });
+
+  try {
+    // Make the original request
+    const response = await originalFetch(url, init);
+
+    // Clone the response so we can read it and still return it
+    const responseClone = response.clone();
+
+    // Process the response asynchronously (don't wait for it)
+    processPerplexityResponse(
+      responseClone,
+      transactionId,
+      model,
+      startTime,
+      usageMetadata
+    );
+
+    // Return the original response immediately
+    return response;
+  } catch (error) {
+    Logger.error(ERROR_PERPLEXITY_API_REQUEST_FAILED_MESSAGE, {
+      transactionId,
+      error,
+    });
+    throw error;
+  }
+}
+
+//Process Perplexity API response
+async function processPerplexityResponse(
+  response: Response,
+  transactionId: string,
+  model: string,
+  startTime: Date,
+  usageMetadata?: UsageMetadata,
+  subscriber?: Subscriber,
+  taskType?: string,
+  costType?: string,
+  operationType?: string,
+  organizationId?: string,
+  productId?: string,
+  isStreamed?: boolean
+): Promise<void> {
+  try {
+    const endTime = new Date();
+    const duration = calculateDurationMs(startTime, endTime);
+
+    // Parse response body
+    const responseData = await response.json();
+
+    // Extract token counts and other data
+    const tokenCounts = extractPerplexityTokenCounts(responseData);
+    const stopReason = extractStopReason(responseData);
+    const modelName = extractModelName(responseData, model);
+
+    // Send metering data (only if API key is available)
+    if (getReveniumApiKey()) {
+      try {
+        await sendMeteringData(
+          {
+            stopReason: "END",
+            costType: costType || "AI",
+            isStreamed: isStreamed || true,
+            taskType: taskType || "chat",
+            agent: "perplexity-ai",
+            operationType: operationType || "CHAT",
+            inputTokenCount: tokenCounts.inputTokens,
+            outputTokenCount: tokenCounts.outputTokens,
+            reasoningTokenCount: 0,
+            cacheCreationTokenCount: 0,
+            cacheReadTokenCount: 0,
+            totalTokenCount: tokenCounts.totalTokens,
+            organizationId: organizationId || "my-customers-name",
+            productId: productId || "free-trial",
+            subscriber: subscriber || {
+              id: `user-${generateTransactionId()}`,
+              email: `user@perplexity.ai`,
+              credential: {
+                name: "keyname",
+                value: "keyValue",
+              },
+            },
+            model: modelName,
+            transactionId,
+            responseTime: formatTimestamp(endTime),
+            requestDuration: duration,
+            provider: Provider.PERPLEXITY,
+            requestTime: formatTimestamp(startTime),
+            completionStartTime: formatTimestamp(endTime),
+            timeToFirstToken: 0,
+            middleware_source: "node",
+          },
+          getReveniumApiKey(),
+          getReveniumBaseUrl()
+        );
+      } catch (error) {
+        Logger.warning(WARNING_FAILED_TO_SEND_METERING_DATA_MESSAGE, { error });
+      }
+    } else {
+      Logger.debug(DEBUG_SKIPPING_METERING_DATA_SEND_MESSAGE);
+    }
+
+    Logger.debug(
+      DEBUG_MIDDLEWARE_PERPLEXITY_API_RESPONSE_METERING_COMPLETED_MESSAGE,
+      {
+        transactionId,
+      }
+    );
+  } catch (error) {
+    Logger.error(ERROR_FAILED_TO_PROCESS_PERPLEXITY_RESPONSE_MESSAGE, {
+      transactionId,
+      error,
+    });
+  }
+}
+
+// Initialize middleware when this module is imported
+initializePerplexityMiddleware();

package/src/types/context.ts

@@ -0,0 +1,9 @@
+import { UsageMetadata } from "./usageMetadata";
+
+export interface Context {
+  transactionId: string;
+  startTime: Date;
+  model: string;
+  operationType: string;
+  usageMetadata?: UsageMetadata;
+}

package/src/types/index.ts

@@ -0,0 +1,11 @@
+export * from "./context";
+export * from "./perplexityConfig";
+export * from "./metering";
+export * from "./modelInfo";
+export * from "./operation";
+export * from "./provider";
+export * from "./reveniumConfig";
+export * from "./streamTracker";
+export * from "./tokenCounts";
+export * from "./usageData";
+export * from "./usageMetadata";

package/src/types/metering.ts

@@ -0,0 +1,28 @@
+import { Subscriber } from "./subscriber";
+
+export interface MeteringRequest {
+  stopReason: string;
+  costType: string;
+  isStreamed: boolean;
+  taskType: string;
+  agent: string;
+  operationType: string;
+  inputTokenCount: number;
+  outputTokenCount: number;
+  reasoningTokenCount: number;
+  cacheCreationTokenCount: number;
+  cacheReadTokenCount: number;
+  totalTokenCount: number;
+  organizationId: string;
+  productId: string;
+  subscriber: Subscriber;
+  model: string;
+  transactionId: string;
+  responseTime: string;
+  requestDuration: number;
+  provider: string;
+  requestTime: string;
+  completionStartTime: string;
+  timeToFirstToken: number;
+  middleware_source: string;
+}

package/src/types/modelInfo.ts

@@ -0,0 +1,5 @@
+export interface ModelInfo {
+  name: string;
+  provider: string;
+  contextLength?: number;
+}

package/src/types/operation.ts

@@ -0,0 +1,4 @@
+export enum OperationType {
+  CHAT = "chat",
+  STREAMING = "streaming"
+}

package/src/types/perplexityConfig.ts

@@ -0,0 +1,4 @@
+export interface PerplexityConfig {
+  apiKey: string;
+  baseUrl: string;
+}

package/src/types/provider.ts

@@ -0,0 +1,3 @@
+export enum Provider {
+  PERPLEXITY = "Perplexity"
+}

package/src/types/reveniumConfig.ts

@@ -0,0 +1,5 @@
+export interface ReveniumConfig {
+  apiKey: string;
+  baseUrl: string;
+  logLevel: string;
+}

package/src/types/streamTracker.ts

@@ -0,0 +1,9 @@
+import { UsageMetadata } from "./usageMetadata";
+
+export interface StreamTracker {
+  transactionId: string;
+  startTime: Date;
+  firstTokenTime?: Date;
+  isComplete: boolean;
+  usageMetadata?: UsageMetadata;
+}

package/src/types/subscriber.ts

@@ -0,0 +1,8 @@
+export interface Subscriber {
+  id: string;
+  email: string;
+  credential: {
+    name: string;
+    value: string;
+  };
+}

package/src/types/tokenCounts.ts

@@ -0,0 +1,5 @@
+export interface TokenCounts {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+}

package/src/types/usageData.ts

@@ -0,0 +1,16 @@
+import { TokenCounts } from "./tokenCounts";
+import { UsageMetadata } from "./usageMetadata";
+
+export interface UsageData {
+  transactionId: string;
+  model: string;
+  tokenCounts: TokenCounts;
+  stopReason: string;
+  startTime: string;
+  endTime: string;
+  duration: number;
+  operationType: string;
+  isStreaming: boolean;
+  streamId: string;
+  usageMetadata?: UsageMetadata;
+}

package/src/types/usageMetadata.ts

@@ -0,0 +1,13 @@
+export interface UsageMetadata {
+  traceId?: string;
+  taskType?: string;
+  subscriberEmail?: string;
+  subscriberId?: string;
+  subscriberCredentialName?: string;
+  subscriberCredential?: string;
+  organizationId?: string;
+  subscriptionId?: string;
+  productId?: string;
+  agent?: string;
+  responseQualityScore?: number;
+}

package/src/utils/activeMiddleware.ts

@@ -0,0 +1,34 @@
+import { Logger } from "../models";
+import { MiddlewareActivationError } from "../models";
+import { verifyLogVerbose } from "./verifyLogVerbose";
+
+export function activeMiddleware(
+  verboseStartup: boolean,
+  activeSDKs: string[],
+  sdkType: string
+): void {
+  try {
+    verifyLogVerbose(
+      verboseStartup,
+      `Attempting to activate ${sdkType} middleware...`
+    );
+
+    // For Perplexity, we'll intercept HTTP requests to the Perplexity API
+    // This is a simpler approach since Perplexity doesn't have an official SDK
+    interceptPerplexityRequests();
+
+    activeSDKs.push(sdkType);
+    verifyLogVerbose(
+      verboseStartup,
+      `${sdkType} middleware activated successfully`
+    );
+  } catch (error) {
+    Logger.warning(`Failed to activate ${sdkType} middleware: ${error}`);
+  }
+}
+
+function interceptPerplexityRequests(): void {
+  // This will be implemented in the main middleware file
+  // For now, we just log that we're ready to intercept
+  Logger.debug("Perplexity request interceptor ready");
+}

package/src/utils/askConsole.ts

@@ -0,0 +1,15 @@
+import readline from "readline";
+
+export function askConsole(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (content) => {
+      rl.close();
+      resolve(content);
+    });
+  });
+}

package/src/utils/calculateDurationMs.ts

@@ -0,0 +1,3 @@
+export function calculateDurationMs(startTime: Date, endTime: Date): number {
+  return endTime.getTime() - startTime.getTime();
+}

package/src/utils/constants/constants.ts

@@ -0,0 +1,17 @@
+export const TIMEOUT_MS = 10000; // 10 seconds
+export const STATUS_CODE: Record<string, number> = {
+  SUCCESS: 200,
+  CREATED: 201,
+};
+export const SAFE_EXTRACT: Record<string, string> = {
+  INPUT_TOKENS: "usage.prompt_tokens",
+  OUTPUT_TOKENS: "usage.completion_tokens",
+  TOTAL_TOKENS: "usage.total_tokens",
+};
+
+export const MODEL: string = "model";
+export const REVENIUM_METERING_BASE_URL: string =
+  "https://api.revenium.io/meter/v2";
+export const CURRENT_PERPLEXITY_BASE_URL: string = "https://api.perplexity.ai";
+export const DEFAULT_PERPLEXITY_MODEL: string = "perplexity-online";
+export const LOG_LEVELS: string[] = ["DEBUG", "INFO", "WARNING", "ERROR"];

package/src/utils/constants/messages.ts

@@ -0,0 +1,35 @@
+export const PERPLEXITY_REQUIRED_API_KEY_MESSAGE =
+  "PERPLEXITY_API_KEY is required. Set it in environment variables or pass it to the constructor.";
+export const PERPLEXITY_CLIENT_INITIALIZED_MESSAGE =
+  "Perplexity AI client initialized with middleware";
+export const PERPLEXITY_CHAT_COMPLETION_FAILED_MESSAGE =
+  "Chat completion failed";
+export const PERPLEXITY_STREAMING_CHAT_COMPLETION_FAILED_MESSAGE =
+  "Streaming chat completion failed";
+export const PERPLEXITY_GET_MODELS_FAILED_MESSAGE = "Failed to get models";
+export const DEBUG_MIDDLEWARE_ALREADY_INITIALIZED_MESSAGE =
+  "[DEBUG] Middleware already initialized, skipping...";
+export const WARNING_REVENIUM_METERING_API_KEY_NOT_FOUND_MESSAGE =
+  "REVENIUM_METERING_API_KEY not found - metering will be disabled but middleware will still intercept calls";
+export const DEBUG_MIDDLEWARE_INITIALIZED_MESSAGE =
+  "🔍 [DEBUG] Perplexity middleware initialized successfully";
+export const DEBUG_MIDDLEWARE_FAILED_TO_INITIALIZE_MESSAGE =
+  "🔍 [DEBUG] Failed to initialize Perplexity middleware";
+export const FAILED_TO_INITIALIZE_PERPLEXITY_MIDDLEWARE_MESSAGE =
+  "Failed to initialize Perplexity middleware";
+export const DEBUG_MIDDLEWARE_INTERCEPTING_PERPLEXITY_REQUESTS_MESSAGE =
+  "🔍 [DEBUG] Perplexity HTTP interceptor installed";
+export const FAILED_TO_PARSE_REQUEST_BODY_FOR_METADATA_EXTRACTION_MESSAGE =
+  "Failed to parse request body for metadata extraction";
+export const DEBUG_MIDDLEWARE_PERPLEXITY_API_REQUEST_INTERCEPTED_MESSAGE =
+  "🔍 [DEBUG] Perplexity API request intercepted";
+export const ERROR_PERPLEXITY_API_REQUEST_FAILED_MESSAGE =
+  "Perplexity API request failed";
+export const WARNING_FAILED_TO_SEND_METERING_DATA_MESSAGE =
+  "Failed to send metering data, but continuing with response";
+export const DEBUG_MIDDLEWARE_PERPLEXITY_API_RESPONSE_METERING_COMPLETED_MESSAGE =
+  "🔍 [DEBUG] Perplexity API response metering completed";
+export const DEBUG_SKIPPING_METERING_DATA_SEND_MESSAGE =
+  "Skipping metering data send - no API key available";
+export const ERROR_FAILED_TO_PROCESS_PERPLEXITY_RESPONSE_MESSAGE =
+  "Failed to process Perplexity response";

package/src/utils/createMeteringRequest.ts

@@ -0,0 +1,16 @@
+import {
+  MeteringRequest,
+  OperationType,
+  Provider,
+  UsageMetadata,
+} from "../types";
+import { formatTimestamp } from "./formatTimestamp";
+
+export function createMeteringRequest(
+  request: MeteringRequest
+): MeteringRequest {
+  return {
+    ...request,
+    middleware_source: "node",
+  };
+}

package/src/utils/createPerplexityMetadata.ts

@@ -0,0 +1,11 @@
+import { UsageMetadata } from "../types";
+
+export function createPerplexityMetadata(metadata?: UsageMetadata): any {
+  if (!metadata) {
+    return {};
+  }
+
+  return {
+    usageMetadata: metadata,
+  };
+}

package/src/utils/extractModelName.ts

@@ -0,0 +1,14 @@
+import { MODEL } from "./constants/constants";
+import { safeExtract } from "./safeExtract";
+
+export function extractModelName(response: any, defaultModel: string): string {
+  // Try to extract model name from response
+  const modelFromResponse = safeExtract(response, MODEL, "");
+
+  if (modelFromResponse) {
+    return modelFromResponse;
+  }
+
+  // Fallback to default model
+  return defaultModel;
+}

package/src/utils/extractPerplexityTokenCounts.ts

@@ -0,0 +1,16 @@
+import { TokenCounts } from "../types";
+import { SAFE_EXTRACT } from "./constants/constants";
+import { safeExtract } from "./safeExtract";
+
+export function extractPerplexityTokenCounts(response: any): TokenCounts {
+  // Extract token counts from Perplexity response
+  const inputTokens = safeExtract(response, SAFE_EXTRACT.INPUT_TOKENS, 0);
+  const outputTokens = safeExtract(response, SAFE_EXTRACT.OUTPUT_TOKENS, 0);
+  const totalTokens = safeExtract(response, SAFE_EXTRACT.TOTAL_TOKENS, 0);
+
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: totalTokens || inputTokens + outputTokens,
+  };
+}

package/src/utils/extractStopReason.ts

@@ -0,0 +1,13 @@
+import { safeExtract } from "./safeExtract";
+
+export function extractStopReason(response: any): string {
+  // Try to extract stop reason from Perplexity response
+  const stopReason = safeExtract(response, "choices.0.finish_reason", "");
+
+  if (stopReason) {
+    return stopReason;
+  }
+
+  // Fallback to a default reason
+  return "completed";
+}

package/src/utils/extractUsageMetadata.ts

@@ -0,0 +1,15 @@
+import { UsageMetadata } from '../types';
+
+export function extractUsageMetadata(request: any, context: any): UsageMetadata | undefined {
+  // Check if usageMetadata is directly in the request
+  if (request && request.usageMetadata) {
+    return request.usageMetadata;
+  }
+
+  // Check if usageMetadata is in the context (for model-level metadata)
+  if (context && context._reveniumUsageMetadata) {
+    return context._reveniumUsageMetadata;
+  }
+
+  return undefined;
+}

package/src/utils/formatTimestamp.ts

@@ -0,0 +1,3 @@
+export function formatTimestamp(date: Date): string {
+  return date.toISOString();
+}

package/src/utils/generateTransactionId.ts

@@ -0,0 +1,5 @@
+import { v4 as uuidv4 } from 'uuid';
+
+export function generateTransactionId(): string {
+  return uuidv4();
+}

package/src/utils/getEnv.ts

@@ -0,0 +1,16 @@
+import {
+  CURRENT_PERPLEXITY_BASE_URL,
+  REVENIUM_METERING_BASE_URL,
+} from "./constants/constants";
+
+export function getReveniumApiKey(): string {
+  return process.env.REVENIUM_METERING_API_KEY ?? "";
+}
+
+export function getReveniumBaseUrl(): string {
+  return process.env.REVENIUM_METERING_BASE_URL || REVENIUM_METERING_BASE_URL;
+}
+
+export function getPerplexityBaseUrl(): string {
+  return process.env.PERPLEXITY_BASE_URL || CURRENT_PERPLEXITY_BASE_URL;
+}

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+export * from "./activeMiddleware";
+export * from "./calculateDurationMs";
+export * from "./createMeteringRequest";
+export * from "./createPerplexityMetadata";
+export * from "./extractModelName";
+export * from "./extractPerplexityTokenCounts";
+export * from "./extractStopReason";
+export * from "./extractUsageMetadata";
+export * from "./formatTimestamp";
+export * from "./generateTransactionId";
+export * from "./safeExtract";
+export * from "./sendMeteringData";

package/src/utils/safeExtract.ts

@@ -0,0 +1,18 @@
+export function safeExtract<T>(obj: any, path: string, defaultValue: T): T {
+  try {
+    const keys = path.split(".");
+    let result = obj;
+
+    for (const key of keys) {
+      if (result && typeof result === "object" && key in result) {
+        result = result[key];
+      } else {
+        return defaultValue;
+      }
+    }
+
+    return result ?? defaultValue;
+  } catch (error) {
+    return defaultValue;
+  }
+}