@revenium/perplexity 1.0.25 → 2.0.1

package/src/v1/perplexityV1.service.ts

@@ -1,230 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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

@@ -1,260 +0,0 @@
-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;
-  }
-}