@revenium/perplexity 1.0.22 → 1.0.25

package/src/v1/perplexityV1.service.ts

@@ -0,0 +1,230 @@
+import OpenAI from "openai";
+import { logger } from "../models/Logger";
+import { Metering } from "../models/Metering";
+import { generateTransactionId } from "../utils/generateTransactionId";
+import { IOperationType } from "../interfaces/operation";
+import { IUsageMetadata } from "../interfaces/usageMetadata";
+import { ITokenCounts } from "../interfaces/tokenCounts";
+import {
+  IChatCompletionRequest,
+  IPerplexityMessage,
+} from "../interfaces/chatCompletionRequest";
+import {
+  IPerplexityResponseChat,
+  IPerplexityRawResponse,
+} from "../interfaces/perplexityResponse";
+import {
+  IPerplexityStreamingResponse,
+  IPerplexityStreamChunk,
+} from "../interfaces/perplexityStreaming";
+
+import {
+  PERPLEXITY_API_BASE_URL,
+  PERPLEXITY_API_KEY,
+  PERPLEXITY_CLIENT_INITIALIZED_MESSAGE,
+  REVENIUM_METERING_API_KEY,
+  REVENIUM_METERING_BASE_URL,
+} from "../utils";
+
+export class PerplexityV1Service {
+  private client: OpenAI;
+  private working: boolean = true;
+
+  constructor() {
+    this.client = new OpenAI({
+      apiKey: PERPLEXITY_API_KEY,
+      baseURL: PERPLEXITY_API_BASE_URL,
+    });
+    logger.info(PERPLEXITY_CLIENT_INITIALIZED_MESSAGE);
+  }
+
+  async createChatCompletion(
+    params: IChatCompletionRequest,
+    model: string
+  ): Promise<IPerplexityResponseChat> {
+    const transactionId = generateTransactionId();
+    const startTime = new Date();
+
+    try {
+      const { usageMetadata, ...openaiParams } = params;
+      const requestParams = {
+        ...openaiParams,
+        model,
+      };
+
+      const result = (await this.client.chat.completions.create({
+        ...requestParams,
+        stream: false,
+      })) as IPerplexityRawResponse;
+
+      // Build V1 response format
+      const perplexityResponse: IPerplexityResponseChat = {
+        responses: [
+          {
+            text: result.choices[0]?.message?.content || "",
+            role: "assistant",
+            finishReason: result.choices[0]?.finish_reason,
+          },
+        ],
+        usageMetadata: {
+          inputTokenCount: result.usage?.prompt_tokens || 0,
+          outputTokenCount: result.usage?.completion_tokens || 0,
+          totalTokenCount: result.usage?.total_tokens || 0,
+        },
+        modelVersion: result.model,
+        transactionId,
+      };
+
+      // Send metering data (using current middleware logic)
+      if (this.working) {
+        const tokenCounts: ITokenCounts = {
+          inputTokens: result.usage?.prompt_tokens || 0,
+          outputTokens: result.usage?.completion_tokens || 0,
+          totalTokens: result.usage?.total_tokens || 0,
+        };
+        const endTime = new Date();
+        logger.info("Metering is working.");
+
+        const metering = new Metering(
+          REVENIUM_METERING_API_KEY ?? "",
+          REVENIUM_METERING_BASE_URL ?? ""
+        );
+
+        // Combine user metadata with transaction ID
+        const combinedMetadata: IUsageMetadata = {
+          ...usageMetadata,
+          transactionId,
+        };
+
+        const getMetering = metering.createMetering(
+          {
+            modelName: model,
+            endTime,
+            startTime,
+            operationType: IOperationType.CHAT,
+            stopReason: "END",
+            tokenCounts,
+            usageMetadata: combinedMetadata,
+          },
+          false
+        );
+
+        await metering.sendMeteringData(getMetering);
+      } else {
+        logger.warning("Metering is not working. Check your configuration.");
+      }
+
+      return perplexityResponse;
+    } catch (error) {
+      logger.error("Error in Perplexity V1 chat completion:", error);
+      throw error;
+    }
+  }
+
+  async createStreamingCompletion(
+    params: IChatCompletionRequest,
+    model: string
+  ): Promise<IPerplexityStreamingResponse> {
+    const transactionId = generateTransactionId();
+    const startTime = new Date();
+
+    try {
+      const { usageMetadata, ...openaiParams } = params;
+      const requestParams = {
+        ...openaiParams,
+        model,
+      };
+
+      const stream = await this.client.chat.completions.create({
+        ...requestParams,
+        stream: true,
+      });
+
+      const wrappedStream = this.wrapStream(
+        stream as any,
+        transactionId,
+        model,
+        startTime,
+        usageMetadata
+      );
+
+      return {
+        stream: wrappedStream,
+        usageMetadata: {
+          inputTokenCount: 0, // Will be updated when stream completes
+          outputTokenCount: 0,
+          totalTokenCount: 0,
+        },
+        modelVersion: model,
+        transactionId,
+      };
+    } catch (error) {
+      logger.error("Error in Perplexity V1 streaming:", error);
+      throw error;
+    }
+  }
+
+  private async *wrapStream(
+    stream: AsyncIterable<any>,
+    transactionId: string,
+    model: string,
+    startTime: Date,
+    usageMetadata?: IUsageMetadata
+  ): AsyncGenerator<IPerplexityStreamChunk> {
+    let lastChunk: any = null;
+
+    try {
+      for await (const chunk of stream) {
+        lastChunk = chunk;
+        yield chunk as IPerplexityStreamChunk;
+      }
+
+      // Send metering data when stream completes (using current middleware logic)
+      if (this.working) {
+        // For streaming, we'll use the last chunk's usage data if available
+        const tokenCounts: ITokenCounts = {
+          inputTokens: 0, // Will be updated if lastChunk has usage data
+          outputTokens: 0,
+          totalTokens: 0,
+        };
+        const endTime = new Date();
+        logger.info("Metering is working.");
+
+        const metering = new Metering(
+          REVENIUM_METERING_API_KEY ?? "",
+          REVENIUM_METERING_BASE_URL ?? ""
+        );
+
+        // Combine user metadata with transaction ID
+        const combinedMetadata: IUsageMetadata = {
+          ...usageMetadata,
+          transactionId,
+        };
+
+        const getMetering = metering.createMetering(
+          {
+            modelName: model,
+            endTime,
+            startTime,
+            operationType: IOperationType.CHAT,
+            stopReason: "END",
+            tokenCounts,
+            usageMetadata: combinedMetadata,
+          },
+          true
+        );
+
+        await metering.sendMeteringData(getMetering);
+      } else {
+        logger.warning("Metering is not working. Check your configuration.");
+      }
+    } catch (error) {
+      logger.error("Error in Perplexity V1 stream processing:", error);
+      throw error;
+    }
+  }
+
+  setWorking(working: boolean) {
+    this.working = working;
+  }
+}

package/src/v2/perplexityV2.controller.ts

@@ -0,0 +1,219 @@
+import { logger } from "../models/Logger";
+import { IUsageMetadata } from "../interfaces/usageMetadata";
+import {
+  IChatCompletionRequest,
+  IPerplexityMessage,
+} from "../interfaces/chatCompletionRequest";
+import { IPerplexityV2Response } from "../interfaces/perplexityResponse";
+import { IPerplexityV2StreamingResponse } from "../interfaces/perplexityStreaming";
+import {
+  DEFAULT_CHAT_MODEL,
+  PERPLEXITY_MODELS,
+  MODEL_CAPABILITIES,
+} from "../utils/constants/perplexityModels";
+import { PerplexityV2Service } from "./perplexityV2.service";
+import { models } from "../utils";
+
+export class PerplexityV2Controller {
+  private service: PerplexityV2Service;
+
+  constructor() {
+    this.service = new PerplexityV2Service();
+    logger.info(
+      "Perplexity V2 Controller initialized (Enhanced Response Format)"
+    );
+  }
+
+  /**
+   * Create a chat completion using Perplexity V2 API (Enhanced Response Format following OpenAI Responses API)
+   * @param messages Array of message strings or OpenAI message objects
+   * @param model Optional model name (defaults to sonar-pro)
+   * @param customMetadata Optional custom metadata for tracking
+   * @returns Promise<IPerplexityV2Response>
+   */
+  async createChat(
+    messages: string[] | Array<{ role: string; content: string }>,
+    model: string = DEFAULT_CHAT_MODEL,
+    customMetadata?: IUsageMetadata
+  ): Promise<IPerplexityV2Response> {
+    try {
+      // Normalize messages to OpenAI format
+      const normalizedMessages = this.normalizeMessages(messages);
+
+      // Validate model
+      this.validateModel(model);
+
+      // Create chat completion request
+      const request: IChatCompletionRequest = {
+        messages: normalizedMessages,
+        usageMetadata: customMetadata,
+      };
+
+      logger.info(
+        `Creating Perplexity V2 chat completion with model: ${model}`
+      );
+
+      return await this.service.createChatCompletion(request, model);
+    } catch (error) {
+      logger.error("Error in Perplexity V2 createChat:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Create a streaming chat completion using Perplexity V2 API (Enhanced Response Format following OpenAI Responses API)
+   * @param messages Array of message strings or OpenAI message objects
+   * @param model Optional model name (defaults to sonar-pro)
+   * @param customMetadata Optional custom metadata for tracking
+   * @returns Promise<IPerplexityV2StreamingResponse>
+   */
+  async createStreaming(
+    messages: string[] | Array<{ role: string; content: string }>,
+    model: string = DEFAULT_CHAT_MODEL,
+    customMetadata?: IUsageMetadata
+  ): Promise<IPerplexityV2StreamingResponse> {
+    try {
+      // Normalize messages to OpenAI format
+      const normalizedMessages = this.normalizeMessages(messages);
+
+      // Validate model
+      this.validateModel(model);
+
+      // Create streaming request
+      const request: IChatCompletionRequest = {
+        messages: normalizedMessages,
+        usageMetadata: customMetadata,
+      };
+
+      logger.info(
+        `Creating Perplexity V2 streaming completion with model: ${model}`
+      );
+
+      return await this.service.createStreamingCompletion(request, model);
+    } catch (error) {
+      logger.error("Error in Perplexity V2 createStreaming:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get available models for Perplexity V2
+   * @returns Array of available model names
+   */
+  getAvailableModels(): string[] {
+    return models; // Use the existing models from utils
+  }
+
+  /**
+   * Check if a model supports a specific capability
+   * @param model Model name
+   * @param capability Capability to check (chat, streaming, online)
+   * @returns boolean
+   */
+  supportsCapability(
+    model: string,
+    capability: "chat" | "streaming" | "online"
+  ): boolean {
+    return MODEL_CAPABILITIES[model]?.[capability] || false;
+  }
+
+  /**
+   * Get model information including capabilities and context window (V2 Enhanced)
+   * @param model Model name
+   * @returns Enhanced model information object
+   */
+  getModelInfo(model: string) {
+    const capabilities = MODEL_CAPABILITIES[model];
+    if (!capabilities) {
+      throw new Error(`Model "${model}" is not supported`);
+    }
+
+    return {
+      model,
+      capabilities: {
+        chat: capabilities.chat,
+        streaming: capabilities.streaming,
+        online: capabilities.online,
+      },
+      contextWindow: capabilities.contextWindow,
+      version: "v2",
+      enhanced: true,
+      responseFormat: "openai-responses-api",
+    };
+  }
+
+  /**
+   * Get recommended model for a specific use case (V2 Enhanced)
+   * @param useCase Use case (chat, streaming, online-search, offline-chat)
+   * @returns Recommended model name with reasoning
+   */
+  getRecommendedModel(
+    useCase: "chat" | "streaming" | "online-search" | "offline-chat"
+  ) {
+    const recommendations = {
+      "online-search": {
+        model: PERPLEXITY_MODELS.SONAR_PRO,
+        reason: "Best for online search with high accuracy",
+      },
+      "offline-chat": {
+        model: PERPLEXITY_MODELS.LLAMA_3_1_70B,
+        reason: "Powerful offline model for complex conversations",
+      },
+      chat: {
+        model: DEFAULT_CHAT_MODEL,
+        reason: "Balanced performance for general chat",
+      },
+      streaming: {
+        model: DEFAULT_CHAT_MODEL,
+        reason: "Optimized for real-time streaming responses",
+      },
+    };
+
+    return recommendations[useCase] || recommendations.chat;
+  }
+
+  /**
+   * Get performance metrics for a model (V2 Enhanced)
+   * @param model Model name
+   * @returns Performance metrics
+   */
+  getModelPerformance(model: string) {
+    const capabilities = MODEL_CAPABILITIES[model];
+    if (!capabilities) {
+      throw new Error(`Model "${model}" is not supported`);
+    }
+
+    return {
+      model,
+      contextWindow: capabilities.contextWindow,
+      online: capabilities.online,
+      estimatedLatency: capabilities.online ? "2-4s" : "1-2s",
+      costTier: model.includes("sonar") ? "premium" : "standard",
+      version: "v2",
+    };
+  }
+
+  private normalizeMessages(
+    messages: string[] | Array<{ role: string; content: string }>
+  ): IPerplexityMessage[] {
+    if (Array.isArray(messages) && typeof messages[0] === "string") {
+      // Convert string array to message objects
+      return (messages as string[]).map((content, index) => ({
+        role: index === 0 ? "user" : "assistant",
+        content,
+      })) as IPerplexityMessage[];
+    }
+
+    return messages as IPerplexityMessage[];
+  }
+
+  private validateModel(model: string): void {
+    if (!models.includes(model)) {
+      throw new Error(
+        `Model "${model}" is not supported. Available models: ${models.join(
+          ", "
+        )}`
+      );
+    }
+  }
+}

package/src/v2/perplexityV2.service.ts

@@ -0,0 +1,260 @@
+import OpenAI from "openai";
+import { logger } from "../models/Logger";
+import { Metering } from "../models/Metering";
+import { generateTransactionId } from "../utils/generateTransactionId";
+import { IOperationType } from "../interfaces/operation";
+import { IUsageMetadata } from "../interfaces/usageMetadata";
+import { ITokenCounts } from "../interfaces/tokenCounts";
+import {
+  IChatCompletionRequest,
+  IPerplexityMessage,
+} from "../interfaces/chatCompletionRequest";
+import {
+  IPerplexityV2Response,
+  IPerplexityRawResponse,
+} from "../interfaces/perplexityResponse";
+import {
+  IPerplexityV2StreamingResponse,
+  IPerplexityV2StreamChunk,
+} from "../interfaces/perplexityStreaming";
+import {
+  PERPLEXITY_API_BASE_URL,
+  PERPLEXITY_API_KEY,
+  PERPLEXITY_CLIENT_INITIALIZED_MESSAGE,
+  REVENIUM_METERING_API_KEY,
+  REVENIUM_METERING_BASE_URL,
+} from "../utils";
+
+export class PerplexityV2Service {
+  private client: OpenAI;
+  private working: boolean = true;
+
+  constructor() {
+    this.client = new OpenAI({
+      apiKey: PERPLEXITY_API_KEY,
+      baseURL: PERPLEXITY_API_BASE_URL,
+    });
+    logger.info(`${PERPLEXITY_CLIENT_INITIALIZED_MESSAGE} (V2)`);
+  }
+
+  async createChatCompletion(
+    params: IChatCompletionRequest,
+    model: string
+  ): Promise<IPerplexityV2Response> {
+    const transactionId = generateTransactionId();
+    const startTime = Date.now();
+
+    try {
+      const { usageMetadata, ...openaiParams } = params;
+      const requestParams = {
+        ...openaiParams,
+        model,
+      };
+
+      const result = (await this.client.chat.completions.create({
+        ...requestParams,
+        stream: false,
+      })) as IPerplexityRawResponse;
+
+      const endTime = Date.now();
+      const processingTime = endTime - startTime;
+
+      // Build V2 enhanced response format (following OpenAI Responses API)
+      const perplexityV2Response: IPerplexityV2Response = {
+        id: result.id,
+        object: "chat.completion",
+        created: result.created,
+        model: result.model,
+        choices: result.choices,
+        usage: {
+          prompt_tokens: result.usage?.prompt_tokens || 0,
+          completion_tokens: result.usage?.completion_tokens || 0,
+          total_tokens: result.usage?.total_tokens || 0,
+        },
+        metadata: {
+          transactionId,
+          processingTime,
+          version: "v2",
+        },
+      };
+
+      // Send metering data (modernized approach)
+      await this.sendMeteringData(
+        transactionId,
+        model,
+        IOperationType.CHAT,
+        {
+          inputTokenCount: perplexityV2Response.usage.prompt_tokens,
+          outputTokenCount: perplexityV2Response.usage.completion_tokens,
+          totalTokenCount: perplexityV2Response.usage.total_tokens,
+        },
+        processingTime,
+        usageMetadata
+      );
+
+      return perplexityV2Response;
+    } catch (error) {
+      logger.error("Error in Perplexity V2 chat completion:", error);
+      throw error;
+    }
+  }
+
+  async createStreamingCompletion(
+    params: IChatCompletionRequest,
+    model: string
+  ): Promise<IPerplexityV2StreamingResponse> {
+    const transactionId = generateTransactionId();
+    const startTime = Date.now();
+
+    try {
+      const { usageMetadata, ...openaiParams } = params;
+      const requestParams = {
+        ...openaiParams,
+        model,
+      };
+
+      const stream = await this.client.chat.completions.create({
+        ...requestParams,
+        stream: true,
+      });
+
+      const wrappedStream = this.wrapStreamV2(
+        stream as any,
+        transactionId,
+        model,
+        startTime,
+        usageMetadata
+      );
+
+      return {
+        id: transactionId,
+        object: "chat.completion.chunk",
+        stream: wrappedStream,
+        metadata: {
+          transactionId,
+          startTime,
+          version: "v2",
+        },
+      };
+    } catch (error) {
+      logger.error("Error in Perplexity V2 streaming:", error);
+      throw error;
+    }
+  }
+
+  private async *wrapStreamV2(
+    stream: AsyncIterable<any>,
+    transactionId: string,
+    model: string,
+    startTime: number,
+    usageMetadata?: IUsageMetadata
+  ): AsyncGenerator<IPerplexityV2StreamChunk> {
+    let lastChunk: any = null;
+
+    try {
+      for await (const chunk of stream) {
+        lastChunk = chunk;
+
+        // Transform to V2 format (following OpenAI Responses API)
+        const v2Chunk: IPerplexityV2StreamChunk = {
+          id: chunk.id,
+          object: "chat.completion.chunk",
+          created: chunk.created,
+          model: chunk.model,
+          choices: chunk.choices,
+          usage: chunk.usage
+            ? {
+                prompt_tokens: chunk.usage.prompt_tokens || 0,
+                completion_tokens: chunk.usage.completion_tokens || 0,
+                total_tokens: chunk.usage.total_tokens || 0,
+              }
+            : undefined,
+        };
+
+        yield v2Chunk;
+      }
+
+      // Send metering data when stream completes
+      const endTime = Date.now();
+      const processingTime = endTime - startTime;
+
+      if (lastChunk?.usage) {
+        await this.sendMeteringData(
+          transactionId,
+          model,
+          IOperationType.CHAT,
+          {
+            inputTokenCount: lastChunk.usage.prompt_tokens || 0,
+            outputTokenCount: lastChunk.usage.completion_tokens || 0,
+            totalTokenCount: lastChunk.usage.total_tokens || 0,
+          },
+          processingTime,
+          usageMetadata
+        );
+      }
+    } catch (error) {
+      logger.error("Error in Perplexity V2 stream processing:", error);
+      throw error;
+    }
+  }
+
+  private async sendMeteringData(
+    transactionId: string,
+    model: string,
+    operationType: IOperationType,
+    usageData: IUsageMetadata,
+    processingTime: number,
+    customMetadata?: IUsageMetadata
+  ): Promise<void> {
+    if (!this.working) {
+      logger.warning("Metering is not working. Check your configuration.");
+      return;
+    }
+
+    try {
+      const startTime = new Date(Date.now() - processingTime);
+      const endTime = new Date();
+
+      const metering = new Metering(
+        REVENIUM_METERING_API_KEY ?? "",
+        REVENIUM_METERING_BASE_URL ?? ""
+      );
+
+      // Convert IUsageMetadata to ITokenCounts for metering
+      const tokenCounts: ITokenCounts = {
+        inputTokens: usageData.inputTokenCount || 0,
+        outputTokens: usageData.outputTokenCount || 0,
+        totalTokens: usageData.totalTokenCount || 0,
+      };
+
+      // Combine custom metadata with transaction ID (token counts are handled separately)
+      const combinedMetadata: IUsageMetadata = {
+        ...customMetadata,
+        transactionId,
+      };
+
+      // Use the same approach as V1 but with V2 enhancements
+      const meteringData = metering.createMetering(
+        {
+          modelName: model,
+          endTime,
+          startTime,
+          operationType,
+          stopReason: "END",
+          tokenCounts,
+          usageMetadata: combinedMetadata,
+        },
+        false
+      );
+
+      await metering.sendMeteringData(meteringData);
+      logger.info("V2 Metering data sent successfully.");
+    } catch (error) {
+      logger.error("Error sending V2 metering data:", error);
+    }
+  }
+
+  setWorking(working: boolean) {
+    this.working = working;
+  }
+}