@revenium/openai 1.0.13 → 1.0.14

package/src/core/tracking/payload-builder.ts

@@ -1,137 +0,0 @@
-/**
- * Payload Builder Module
- *
- * Handles construction of Revenium API payloads.
- * Extracted from tracking.ts for single responsibility.
- */
-
-import { randomUUID } from 'crypto';
-import { ReveniumPayload, ProviderInfo } from '../../types/index.js';
-import {
-  OpenAIChatResponse,
-  OpenAIEmbeddingResponse,
-  OpenAIChatRequest,
-  OpenAIEmbeddingRequest,
-} from '../../types/function-parameters.js';
-import { getLogger } from '../config/index.js';
-import { mapStopReason } from '../../utils/stop-reason-mapper.js';
-import { buildMetadataFields } from '../../utils/metadata-builder.js';
-import { resolveAzureModelName } from '../../utils/azure-model-resolver.js';
-import { getProviderMetadata } from '../providers/index.js';
-
-// Global logger
-const logger = getLogger();
-
-/**
- * Build payload for Revenium API
- *
- * This shared payload builder eliminates payload duplication between
- * chat completions and embeddings. Handles both CHAT and EMBED operation types.
- *
- * @param operationType - Type of operation (CHAT or EMBED)
- * @param response - API response from OpenAI/Azure
- * @param request - Original request parameters
- * @param startTime - Request start timestamp
- * @param duration - Request duration in milliseconds
- * @param providerInfo - Provider information for Azure support
- * @returns Constructed payload for Revenium API
- */
-export function buildPayload(
-  operationType: 'CHAT' | 'EMBED',
-  response: OpenAIChatResponse | OpenAIEmbeddingResponse,
-  request: OpenAIChatRequest | OpenAIEmbeddingRequest,
-  startTime: number,
-  duration: number,
-  providerInfo?: ProviderInfo
-): ReveniumPayload {
-  const now = new Date().toISOString();
-  const requestTime = new Date(startTime).toISOString();
-  const usage = response.usage;
-
-  // Resolve model name for Azure deployments
-  const originalModel = response.model;
-  const resolvedModel = providerInfo?.isAzure
-    ? resolveAzureModelName(originalModel)
-    : originalModel;
-
-  // Get provider metadata (fallback: OpenAI direct)
-  const providerMetadata = providerInfo
-    ? getProviderMetadata(providerInfo)
-    : { provider: 'OpenAI', modelSource: 'OPENAI' };
-
-  if (providerInfo?.isAzure && resolvedModel !== originalModel) {
-    logger.debug('Azure model name resolved for pricing', {
-      deployment: originalModel,
-      resolved: resolvedModel,
-      provider: providerMetadata.provider,
-    });
-  }
-
-  // Build metadata fields using utility (eliminates repetitive spreading)
-  const metadataFields = buildMetadataFields(request.usageMetadata);
-
-  // Common fields for all operations
-  const commonPayload = {
-    costType: 'AI' as const,
-    model: resolvedModel, // Use resolved model name for accurate pricing
-    responseTime: now,
-    requestDuration: duration,
-    provider: providerMetadata.provider,
-    modelSource: providerMetadata.modelSource,
-    requestTime,
-    completionStartTime: now,
-
-    // Common token counts
-    inputTokenCount: usage.prompt_tokens,
-    totalTokenCount: usage.total_tokens,
-
-    // Metadata fields (processed by utility)
-    ...metadataFields,
-
-    // Fixed middleware source identifier (spec format: revenium-{provider}-{language})
-    middlewareSource: 'revenium-openai-node',
-
-    // Backend calculates costs
-    inputTokenCost: undefined,
-    outputTokenCost: undefined,
-    totalCost: undefined,
-  };
-
-  // Operation-specific fields
-
-  if (operationType !== 'CHAT') {
-    // For embeddings, we don't need the response cast since we use commonPayload
-    return {
-      ...commonPayload,
-      operationType: 'EMBED',
-      transactionId: `embed-${randomUUID()}`,
-      outputTokenCount: 0,
-      // Embeddings don't support reasoning or caching
-      reasoningTokenCount: undefined,
-      cacheCreationTokenCount: undefined,
-      cacheReadTokenCount: undefined,
-      stopReason: 'END',
-      isStreamed: false,
-      timeToFirstToken: undefined,  // Not applicable for embeddings
-    };
-  }
-  const chatResponse = response as OpenAIChatResponse;
-  const chatUsage = chatResponse.usage;
-
-  return {
-    ...commonPayload,
-    operationType: 'CHAT',
-    transactionId: chatResponse.id || `chat-${randomUUID()}`,
-    outputTokenCount: chatUsage.completion_tokens || 0,
-    // Leave null for models without reasoning capabilities (API spec)
-    reasoningTokenCount: chatUsage.reasoning_tokens ?? undefined,
-    // OpenAI doesn't report cache creation tokens
-    cacheCreationTokenCount: undefined,
-    // Only include if provider reports cache hits
-    cacheReadTokenCount: chatUsage.cached_tokens ?? undefined,
-    stopReason: mapStopReason(chatResponse.choices?.[0]?.finish_reason, logger),
-    isStreamed: Boolean((request as OpenAIChatRequest).stream),
-    // TODO: Implement real TTFB tracking for streaming requests
-    timeToFirstToken: undefined,
-  };
-}

package/src/core/tracking/usage-tracker.ts

@@ -1,189 +0,0 @@
-/**
- * Usage Tracker Module
- *
- * High-level tracking functions that combine payload building and API communication.
- * Extracted from tracking.ts for better organization.
- */
-
-import { randomUUID } from 'crypto';
-import { UsageMetadata, ProviderInfo } from '../../types/index.js';
-import {
-  OpenAIChatResponse,
-  OpenAIEmbeddingResponse,
-  OpenAIChatRequest,
-  OpenAIEmbeddingRequest,
-} from '../../types/function-parameters.js';
-import { getLogger } from '../config/index.js';
-import { sendToRevenium } from './api-client.js';
-import { buildPayload } from './payload-builder.js';
-import { safeAsyncOperation } from '../../utils/error-handler.js';
-
-// Global logger
-const logger = getLogger();
-
-/**
- * Chat completions tracking - now a thin wrapper with Azure support
- */
-export async function sendReveniumMetrics(
-  response: OpenAIChatResponse,
-  request: OpenAIChatRequest,
-  startTime: number,
-  duration: number,
-  providerInfo?: ProviderInfo
-): Promise<void> {
-  await safeAsyncOperation(
-    async () => {
-      const payload = buildPayload('CHAT', response, request, startTime, duration, providerInfo);
-      await sendToRevenium(payload);
-    },
-    'Chat completion tracking',
-    {
-      logError: true,
-      rethrow: false, // Don't rethrow to maintain fire-and-forget behavior
-      messagePrefix: 'Chat completion tracking failed: ',
-    },
-    logger
-  );
-}
-
-/**
- * Embeddings tracking - now a thin wrapper with Azure support
- */
-export async function sendReveniumEmbeddingsMetrics(
-  response: OpenAIEmbeddingResponse,
-  request: OpenAIEmbeddingRequest,
-  startTime: number,
-  duration: number,
-  providerInfo?: ProviderInfo
-): Promise<void> {
-  await safeAsyncOperation(
-    async () => {
-      const payload = buildPayload('EMBED', response, request, startTime, duration, providerInfo);
-      await sendToRevenium(payload);
-    },
-    'Embeddings tracking',
-    {
-      logError: true,
-      rethrow: false, // Don't rethrow to maintain fire-and-forget behavior
-      messagePrefix: 'Embeddings tracking failed: ',
-    },
-    logger
-  );
-}
-
-/**
- * Fire-and-forget wrapper for chat completions with Azure support
- */
-export function trackUsageAsync(trackingData: {
-  requestId: string;
-  model: string;
-  promptTokens: number;
-  completionTokens: number;
-  totalTokens: number;
-  reasoningTokens?: number;
-  cachedTokens?: number;
-  duration: number;
-  finishReason: string | null;
-  usageMetadata?: UsageMetadata;
-  isStreamed?: boolean;
-  timeToFirstToken?: number;
-  providerInfo?: ProviderInfo;
-}): void {
-  const mockResponse = {
-    id: trackingData.requestId,
-    model: trackingData.model,
-    usage: {
-      prompt_tokens: trackingData.promptTokens,
-      completion_tokens: trackingData.completionTokens,
-      total_tokens: trackingData.totalTokens,
-      ...(trackingData.reasoningTokens && { reasoning_tokens: trackingData.reasoningTokens }),
-      ...(trackingData.cachedTokens && { cached_tokens: trackingData.cachedTokens }),
-    },
-    choices: [
-      {
-        finish_reason: trackingData.finishReason,
-      },
-    ],
-  };
-
-  const mockRequest: OpenAIChatRequest = {
-    model: trackingData.model,
-    messages: [], // Mock empty messages array for type compliance
-    usageMetadata: trackingData.usageMetadata,
-    stream: trackingData.isStreamed,
-  };
-
-  const startTime = Date.now() - trackingData.duration;
-
-  sendReveniumMetrics(
-    mockResponse,
-    mockRequest,
-    startTime,
-    trackingData.duration,
-    trackingData.providerInfo
-  )
-    .then(() => {
-      logger.debug('Usage tracking completed successfully', {
-        requestId: trackingData.requestId,
-        model: trackingData.model,
-        totalTokens: trackingData.totalTokens,
-        isStreamed: trackingData.isStreamed,
-      });
-    })
-    .catch(error => {
-      logger.warn('Usage tracking failed', {
-        error: error instanceof Error ? error.message : String(error),
-        requestId: trackingData.requestId,
-        model: trackingData.model,
-      });
-    });
-}
-
-/**
- * Fire-and-forget wrapper for embeddings with Azure support
- */
-export function trackEmbeddingsUsageAsync(trackingData: {
-  transactionId: string;
-  model: string;
-  promptTokens: number;
-  totalTokens: number;
-  duration: number;
-  usageMetadata?: UsageMetadata;
-  requestStartTime: number;
-  providerInfo?: ProviderInfo;
-}): void {
-  const mockResponse: OpenAIEmbeddingResponse = {
-    model: trackingData.model,
-    usage: {
-      prompt_tokens: trackingData.promptTokens,
-      total_tokens: trackingData.totalTokens,
-    },
-    data: [], // Mock empty data array for type compliance
-    object: 'list',
-  };
-
-  const mockRequest: OpenAIEmbeddingRequest = {
-    model: trackingData.model,
-    input: '', // Mock empty input for type compliance
-    usageMetadata: trackingData.usageMetadata,
-  };
-
-  sendReveniumEmbeddingsMetrics(
-    mockResponse,
-    mockRequest,
-    trackingData.requestStartTime,
-    trackingData.duration,
-    trackingData.providerInfo
-  )
-    .then(() => {
-      logger.debug('Embeddings tracking completed successfully', {
-        transactionId: trackingData.transactionId,
-      });
-    })
-    .catch(error => {
-      logger.warn('Embeddings tracking failed', {
-        error: error instanceof Error ? error.message : String(error),
-        transactionId: trackingData.transactionId,
-      });
-    });
-}

package/src/core/wrapper/index.ts

@@ -1,9 +0,0 @@
-/**
- * Wrapper module - Main exports
- *
- * This module provides a clean interface for OpenAI client wrapping,
- * separating concerns into focused sub-modules.
- */
-
-// Re-export all wrapper functionality
-export { patchOpenAI, patchOpenAIInstance, getProviderInfo } from './instance-patcher.js';

package/src/core/wrapper/instance-patcher.ts

@@ -1,288 +0,0 @@
-/**
- * Instance Patcher Module
- *
- * Handles patching of OpenAI client instances.
- * Extracted from wrapper.ts for better organization.
- */
-
-import OpenAI from 'openai';
-import type { ChatCompletionCreateParams } from 'openai/resources/chat/completions';
-import type { EmbeddingCreateParams } from 'openai/resources/embeddings';
-import { ProviderInfo } from '../../types/index.js';
-import {
-  OpenAIClientInstance,
-  OpenAIChatRequest,
-  OpenAIEmbeddingRequest,
-  OpenAIRequestOptions,
-  OpenAIResponsesOriginalFunction,
-} from '../../types/function-parameters.js';
-import { isOpenAIClientInstance } from '../../utils/type-guards.js';
-import { extractMetadata, createLoggingContext } from '../../utils/metadata-builder.js';
-import {
-  requestHandlerFactory,
-  ensureFactoryInitialized,
-} from '../../utils/request-handler-factory.js';
-import { getLogger, getConfig } from '../config/index.js';
-import { detectProvider } from '../providers/index.js';
-import { OpenAIResponsesRequest } from '../../types/responses-api.js';
-
-// Import the type augmentations to ensure they're available
-import '../../types/openai-augmentation.js';
-
-// Interface for OpenAI instance with Responses API
-interface OpenAIWithResponses extends OpenAIClientInstance {
-  responses?: {
-    create: (params: OpenAIResponsesRequest, options?: OpenAIRequestOptions) => Promise<unknown>;
-  };
-}
-
-/**
- * Set to track patched instances
- */
-const patchedInstances = new WeakSet();
-
-/**
- * WeakMap to store provider information for each client instance
- */
-const instanceProviders = new WeakMap<OpenAIClientInstance, ProviderInfo>();
-
-// Global logger
-const logger = getLogger();
-
-/**
- * Get provider information for a client instance
- */
-export function getProviderInfo(instance: OpenAIClientInstance): ProviderInfo | undefined {
-  return instanceProviders.get(instance);
-}
-
-/**
- * Simple approach: Only patch instances when users create them
- * No global patching, no dummy keys - just clean instance patching
- */
-export function patchOpenAI(): void {
-  logger.info('Revenium OpenAI middleware loaded and ready');
-  logger.debug('Use patchOpenAIInstance() to patch specific OpenAI instances');
-}
-
-/**
- * Manually patch an existing OpenAI instance
- * This is the main function users should call
- */
-export function patchOpenAIInstance(instance: OpenAI): OpenAI {
-  // Check if middleware is initialized
-  const config = getConfig();
-  if (!config) {
-    logger.warn('Revenium middleware not initialized.');
-    logger.warn(
-      'Auto-initialization may have failed. Try calling initializeReveniumFromEnv() explicitly.'
-    );
-    logger.warn('Check that REVENIUM_METERING_API_KEY environment variable is set.');
-    logger.warn(
-      'OpenAI instance will be patched but tracking may not work without proper configuration.'
-    );
-  } else {
-    logger.debug('Revenium middleware is properly configured');
-  }
-
-  if (patchedInstances.has(instance)) {
-    logger.debug('OpenAI instance already patched, skipping');
-    return instance;
-  }
-
-  patchInstance(instance as unknown as OpenAIClientInstance);
-  logger.debug('OpenAI instance patched successfully');
-
-  return instance;
-}
-
-/**
- * Patch an individual OpenAI instance
- */
-function patchInstance(instance: OpenAIClientInstance): void {
-  try {
-    // Validate instance
-    if (!isOpenAIClientInstance(instance)) {
-      logger.error('Invalid OpenAI client instance provided to patchInstance');
-      return;
-    }
-
-    // Detect provider type for this instance
-    const providerInfo = detectProvider(instance);
-    instanceProviders.set(instance, providerInfo);
-
-    logger.debug('Provider detection completed for instance', {
-      provider: providerInfo.provider,
-      isAzure: providerInfo.isAzure,
-      hasAzureConfig: !!providerInfo.azureConfig,
-    });
-
-    // Patch chat completions
-    patchChatCompletions(instance);
-
-    // Patch embeddings
-    patchEmbeddings(instance);
-
-    // Patch responses API (new OpenAI Responses API)
-    patchResponses(instance);
-
-    // Mark as patched
-    patchedInstances.add(instance);
-  } catch (error) {
-    logger.error('Failed to patch OpenAI instance', {
-      error: error instanceof Error ? error.message : String(error),
-    });
-  }
-}
-
-/**
- * Patch chat completions endpoint
- */
-function patchChatCompletions(instance: OpenAIClientInstance): void {
-  if (!instance.chat || !instance.chat.completions || !instance.chat.completions.create) {
-    return logger.warn('OpenAI instance missing chat.completions.create, skipping chat patch');
-  }
-
-  // Store the original create method
-  const originalCreate = instance.chat.completions.create.bind(instance.chat.completions);
-
-  // Replace the create method with our wrapped version
-  instance.chat.completions.create = async function (
-    params: ChatCompletionCreateParams,
-    options?: OpenAIRequestOptions
-  ) {
-    // Extract metadata using utility
-    const { metadata, cleanParams } = extractMetadata(params as OpenAIChatRequest);
-    const typedParams = params as OpenAIChatRequest;
-
-    logger.debug('OpenAI chat.completions.create intercepted', {
-      ...createLoggingContext(metadata),
-      model: typedParams.model,
-      stream: !!typedParams.stream,
-    });
-
-    // Record request start time
-    const requestStartTime = Date.now();
-
-    // Ensure factory is initialized and route request
-    try {
-      await ensureFactoryInitialized();
-    } catch (error) {
-      logger.error('Failed to initialize request handler factory', { error });
-      throw new Error('Middleware initialization failed - cannot process request');
-    }
-    return requestHandlerFactory.routeChatRequest(
-      originalCreate,
-      cleanParams,
-      options,
-      metadata,
-      requestStartTime,
-      instance
-    );
-  };
-}
-
-/**
- * Patch embeddings endpoint
- */
-function patchEmbeddings(instance: OpenAIClientInstance): void {
-  if (!instance.embeddings || !instance.embeddings.create) {
-    return logger.warn('OpenAI instance missing embeddings.create, skipping embeddings patch');
-  }
-  // Store the original embeddings create method
-  const originalEmbeddingsCreate = instance.embeddings.create.bind(instance.embeddings);
-
-  // Replace the embeddings create method with our wrapped version
-  instance.embeddings.create = async function (
-    params: EmbeddingCreateParams,
-    options?: OpenAIRequestOptions
-  ) {
-    // Extract metadata using utility
-    const { metadata, cleanParams } = extractMetadata(params as OpenAIEmbeddingRequest);
-    const typedParams = params as OpenAIEmbeddingRequest;
-
-    logger.debug('OpenAI embeddings.create intercepted', {
-      ...createLoggingContext(metadata),
-      model: typedParams.model,
-      inputType: typeof typedParams.input,
-    });
-
-    // Record request start time
-    const requestStartTime = Date.now();
-
-    // Ensure factory is initialized and route request
-    try {
-      await ensureFactoryInitialized();
-    } catch (error) {
-      logger.error('Failed to initialize request handler factory', { error });
-      throw new Error('Middleware initialization failed - cannot process request');
-    }
-    return requestHandlerFactory.routeEmbeddingsRequest(
-      originalEmbeddingsCreate,
-      cleanParams,
-      options,
-      metadata,
-      requestStartTime,
-      instance
-    );
-  };
-}
-
-/**
- * Patch responses endpoint (new OpenAI Responses API)
- */
-function patchResponses(instance: OpenAIClientInstance): void {
-  // Type assertion for new Responses API (not yet in OpenAI types)
-  const responsesAPI = instance as OpenAIWithResponses;
-
-  // Check if the instance has the responses API (it's a newer feature)
-  if (!responsesAPI.responses || !responsesAPI.responses.create) {
-    logger.debug(
-      'OpenAI instance missing responses.create, skipping responses patch (this is normal for older SDK versions)'
-    );
-    return;
-  }
-
-  // Store the original responses create method
-  const originalResponsesCreate = responsesAPI.responses.create.bind(responsesAPI.responses);
-
-  // Replace the responses create method with our wrapped version
-  responsesAPI.responses.create = async function (
-    params: OpenAIResponsesRequest,
-    options?: OpenAIRequestOptions
-  ) {
-    // Extract metadata using utility (similar to chat completions)
-    const { metadata, cleanParams } = extractMetadata(params);
-
-    logger.debug('OpenAI responses.create intercepted', {
-      ...createLoggingContext(metadata),
-      model: params.model,
-      stream: !!params.stream,
-      inputType: typeof params.input,
-    });
-
-    // Record request start time
-    const requestStartTime = Date.now();
-
-    // Ensure factory is initialized and route request
-    try {
-      await ensureFactoryInitialized();
-    } catch (error) {
-      logger.error('Failed to initialize request handler factory', { error });
-      throw new Error('Middleware initialization failed - cannot process request');
-    }
-    return requestHandlerFactory.routeResponsesRequest(
-      originalResponsesCreate as OpenAIResponsesOriginalFunction,
-      cleanParams,
-      options,
-      metadata,
-      requestStartTime,
-      instance
-    );
-  };
-}
-
-/**
- * Export instance providers for request handlers
- */
-export { instanceProviders };