@reaatech/llm-cost-telemetry-providers 0.1.0

package/dist/index.js

@@ -0,0 +1,434 @@
+// src/base.ts
+import { generateId } from "@reaatech/llm-cost-telemetry";
+var BaseProviderWrapper = class {
+  /** The wrapped client */
+  client;
+  /** Callback for cost spans */
+  onSpanCallback = null;
+  /** Default telemetry context */
+  defaultContext = {};
+  /**
+   * Create a new provider wrapper
+   */
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Set the callback for cost spans
+   */
+  onSpan(callback) {
+    this.onSpanCallback = callback;
+  }
+  /**
+   * Set default telemetry context
+   */
+  setDefaultContext(context) {
+    this.defaultContext = context;
+  }
+  /**
+   * Create a cost span from request and response metadata
+   */
+  createSpan(request, response) {
+    const duration = response.endTime.getTime() - request.startTime.getTime();
+    return {
+      id: generateId(),
+      provider: this.provider,
+      model: request.model,
+      inputTokens: response.inputTokens,
+      outputTokens: response.outputTokens,
+      totalTokens: response.inputTokens + response.outputTokens,
+      costUsd: 0,
+      // Will be calculated by the cost calculator
+      startTime: request.startTime,
+      endTime: response.endTime,
+      durationMs: Math.max(0, duration),
+      cacheReadTokens: response.cacheReadTokens,
+      cacheCreationTokens: response.cacheCreationTokens,
+      telemetry: {
+        ...this.defaultContext,
+        ...request.telemetry
+      },
+      metadata: {
+        estimated: false
+      }
+    };
+  }
+  /**
+   * Emit a cost span
+   */
+  emitSpan(span) {
+    if (this.onSpanCallback) {
+      try {
+        this.onSpanCallback(span);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Extract telemetry context from request options
+   */
+  extractTelemetryContext(options) {
+    const telemetry = options.telemetry;
+    if (telemetry && typeof telemetry === "object") {
+      const ctx = {};
+      if ("tenant" in telemetry && typeof telemetry.tenant === "string") {
+        ctx.tenant = telemetry.tenant;
+      }
+      if ("feature" in telemetry && typeof telemetry.feature === "string") {
+        ctx.feature = telemetry.feature;
+      }
+      if ("route" in telemetry && typeof telemetry.route === "string") {
+        ctx.route = telemetry.route;
+      }
+      return Object.keys(ctx).length > 0 ? ctx : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Dispose of the wrapper and release resources
+   */
+  dispose() {
+    this.onSpanCallback = null;
+    this.defaultContext = {};
+  }
+  /**
+   * Get the underlying client
+   */
+  unwrap() {
+    return this.client;
+  }
+};
+
+// src/openai.ts
+import { now } from "@reaatech/llm-cost-telemetry";
+var OpenAIWrapper = class extends BaseProviderWrapper {
+  /**
+   * Get the provider name
+   */
+  get provider() {
+    return "openai";
+  }
+  /**
+   * Wrap the OpenAI client to intercept chat completions
+   */
+  wrap() {
+    const originalClient = this.client;
+    const originalChatCreate = originalClient.chat.completions.create.bind(
+      originalClient.chat.completions
+    );
+    originalClient.chat.completions.create = (async (options, ...rest) => {
+      const startTime = now();
+      const telemetry = this.extractTelemetryContext(options);
+      const model = options.model;
+      const optionsObj = options;
+      const { telemetry: _, ...cleanOptionsObj } = optionsObj;
+      const cleanOptions = cleanOptionsObj;
+      try {
+        const response = await originalChatCreate(cleanOptions, ...rest);
+        const endTime = now();
+        const requestMetadata = {
+          model,
+          params: cleanOptions,
+          telemetry,
+          startTime
+        };
+        const responseMetadata = {
+          inputTokens: response.usage?.prompt_tokens ?? 0,
+          outputTokens: response.usage?.completion_tokens ?? 0,
+          endTime
+        };
+        const span = this.createSpan(requestMetadata, responseMetadata);
+        this.emitSpan(span);
+        return response;
+      } catch (error) {
+        const endTime = now();
+        const requestMetadata = {
+          model,
+          params: cleanOptions,
+          telemetry,
+          startTime
+        };
+        const responseMetadata = {
+          inputTokens: 0,
+          outputTokens: 0,
+          endTime,
+          error
+        };
+        const span = this.createSpan(requestMetadata, responseMetadata);
+        this.emitSpan(span);
+        throw error;
+      }
+    });
+    const originalCompletionCreate = originalClient.completions.create.bind(
+      originalClient.completions
+    );
+    originalClient.completions.create = (async (options, ...rest) => {
+      const startTime = now();
+      const telemetry = this.extractTelemetryContext(options);
+      const model = options.model;
+      const optionsObj = options;
+      const { telemetry: _, ...cleanOptionsObj } = optionsObj;
+      const cleanOptions = cleanOptionsObj;
+      try {
+        const response = await originalCompletionCreate(cleanOptions, ...rest);
+        const endTime = now();
+        const requestMetadata = {
+          model,
+          params: cleanOptions,
+          telemetry,
+          startTime
+        };
+        const responseMetadata = {
+          inputTokens: response.usage?.prompt_tokens ?? 0,
+          outputTokens: response.usage?.completion_tokens ?? 0,
+          endTime
+        };
+        const span = this.createSpan(requestMetadata, responseMetadata);
+        this.emitSpan(span);
+        return response;
+      } catch (error) {
+        const endTime = now();
+        const requestMetadata = {
+          model,
+          params: cleanOptions,
+          telemetry,
+          startTime
+        };
+        const responseMetadata = {
+          inputTokens: 0,
+          outputTokens: 0,
+          endTime,
+          error
+        };
+        const span = this.createSpan(requestMetadata, responseMetadata);
+        this.emitSpan(span);
+        throw error;
+      }
+    });
+    return originalClient;
+  }
+};
+function wrapOpenAI(client) {
+  const wrapper = new OpenAIWrapper(client);
+  return wrapper.wrap();
+}
+
+// src/anthropic.ts
+import { now as now2 } from "@reaatech/llm-cost-telemetry";
+var AnthropicWrapper = class extends BaseProviderWrapper {
+  /**
+   * Get the provider name
+   */
+  get provider() {
+    return "anthropic";
+  }
+  /**
+   * Wrap the Anthropic client to intercept messages.create
+   */
+  wrap() {
+    const originalClient = this.client;
+    const originalCreate = originalClient.messages.create.bind(originalClient.messages);
+    originalClient.messages.create = (async (options, ...rest) => {
+      const startTime = now2();
+      const telemetry = this.extractTelemetryContext(
+        options
+      );
+      const model = options.model;
+      const { telemetry: _, ...cleanOptions } = options;
+      try {
+        const response = await originalCreate(
+          cleanOptions,
+          ...rest
+        );
+        const endTime = now2();
+        const requestMetadata = {
+          model,
+          params: cleanOptions,
+          telemetry,
+          startTime
+        };
+        const inputTokens = response.usage.input_tokens ?? 0;
+        const outputTokens = response.usage.output_tokens ?? 0;
+        let cacheReadTokens;
+        let cacheCreationTokens;
+        const usage = response.usage;
+        if ("cache_read_input_tokens" in usage) {
+          cacheReadTokens = usage.cache_read_input_tokens;
+        }
+        if ("cache_creation_input_tokens" in usage) {
+          cacheCreationTokens = usage.cache_creation_input_tokens;
+        }
+        const responseMetadata = {
+          inputTokens,
+          outputTokens,
+          cacheReadTokens,
+          cacheCreationTokens,
+          endTime
+        };
+        const span = this.createSpan(requestMetadata, responseMetadata);
+        this.emitSpan(span);
+        return response;
+      } catch (error) {
+        const endTime = now2();
+        const requestMetadata = {
+          model,
+          params: cleanOptions,
+          telemetry,
+          startTime
+        };
+        const responseMetadata = {
+          inputTokens: 0,
+          outputTokens: 0,
+          endTime,
+          error
+        };
+        const span = this.createSpan(requestMetadata, responseMetadata);
+        this.emitSpan(span);
+        throw error;
+      }
+    });
+    return originalClient;
+  }
+};
+function wrapAnthropic(client) {
+  const wrapper = new AnthropicWrapper(client);
+  return wrapper.wrap();
+}
+
+// src/google.ts
+import { now as now3 } from "@reaatech/llm-cost-telemetry";
+var GoogleGenerativeAIWrapper = class extends BaseProviderWrapper {
+  /**
+   * Get the provider name
+   */
+  get provider() {
+    return "google";
+  }
+  /**
+   * Wrap the GoogleGenerativeAI client to intercept generateContent
+   */
+  wrap() {
+    const wrapper = this;
+    const originalClient = this.client;
+    const originalGetModel = originalClient.getGenerativeModel.bind(originalClient);
+    originalClient.getGenerativeModel = ((modelParams, ...rest) => {
+      const model = originalGetModel(modelParams, ...rest);
+      const originalGenerate = model.generateContent.bind(model);
+      model.generateContent = (async (request, options) => {
+        const startTime = now3();
+        const telemetry = options?.telemetry ? wrapper.extractTelemetryContext(options.telemetry) : void 0;
+        const modelId = modelParams.model;
+        try {
+          const response = await originalGenerate(request, options);
+          const endTime = now3();
+          const requestMetadata = {
+            model: modelId,
+            params: typeof request === "string" ? { prompt: request } : request,
+            telemetry,
+            startTime
+          };
+          const responseAny = response;
+          const responseMetadata = {
+            inputTokens: responseAny.usageMetadata?.promptTokenCount ?? 0,
+            outputTokens: responseAny.usageMetadata?.candidatesTokenCount ?? 0,
+            endTime
+          };
+          const span = wrapper.createSpan(requestMetadata, responseMetadata);
+          wrapper.emitSpan(span);
+          return response;
+        } catch (error) {
+          const endTime = now3();
+          const requestMetadata = {
+            model: modelId,
+            params: typeof request === "string" ? { prompt: request } : request,
+            telemetry,
+            startTime
+          };
+          const responseMetadata = {
+            inputTokens: 0,
+            outputTokens: 0,
+            endTime,
+            error
+          };
+          const span = wrapper.createSpan(requestMetadata, responseMetadata);
+          wrapper.emitSpan(span);
+          throw error;
+        }
+      });
+      const originalGenerateStream = model.generateContentStream.bind(model);
+      model.generateContentStream = (async (request, options) => {
+        const startTime = now3();
+        const telemetry = options?.telemetry ? wrapper.extractTelemetryContext(options.telemetry) : void 0;
+        const modelId = modelParams.model;
+        const responseStream = await originalGenerateStream(request, options);
+        const originalStream = responseStream.stream;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        const wrappedStream = new ReadableStream({
+          async start(controller) {
+            try {
+              for await (const chunk of originalStream) {
+                if (chunk.usageMetadata) {
+                  totalInputTokens = chunk.usageMetadata.promptTokenCount ?? totalInputTokens;
+                  totalOutputTokens = chunk.usageMetadata.candidatesTokenCount ?? totalOutputTokens;
+                }
+                controller.enqueue(chunk);
+              }
+              const endTime = now3();
+              const requestMetadata = {
+                model: modelId,
+                params: typeof request === "string" ? { prompt: request } : request,
+                telemetry,
+                startTime
+              };
+              const responseMetadata = {
+                inputTokens: totalInputTokens,
+                outputTokens: totalOutputTokens,
+                endTime
+              };
+              const span = wrapper.createSpan(requestMetadata, responseMetadata);
+              wrapper.emitSpan(span);
+              controller.close();
+            } catch (error) {
+              const endTime = now3();
+              const requestMetadata = {
+                model: modelId,
+                params: typeof request === "string" ? { prompt: request } : request,
+                telemetry,
+                startTime
+              };
+              const responseMetadata = {
+                inputTokens: 0,
+                outputTokens: 0,
+                endTime,
+                error
+              };
+              const span = wrapper.createSpan(requestMetadata, responseMetadata);
+              wrapper.emitSpan(span);
+              controller.error(error);
+            }
+          }
+        });
+        return {
+          stream: wrappedStream,
+          response: responseStream.response
+        };
+      });
+      return model;
+    });
+    return originalClient;
+  }
+};
+function wrapGoogleGenerativeAI(client) {
+  const wrapper = new GoogleGenerativeAIWrapper(client);
+  return wrapper.wrap();
+}
+export {
+  AnthropicWrapper,
+  BaseProviderWrapper,
+  GoogleGenerativeAIWrapper,
+  OpenAIWrapper,
+  wrapAnthropic,
+  wrapGoogleGenerativeAI,
+  wrapOpenAI
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@reaatech/llm-cost-telemetry-providers",
+  "version": "0.1.0",
+  "description": "LLM provider SDK wrappers — OpenAI, Anthropic, and Google Generative AI",
+  "license": "MIT",
+  "author": "Rick Somers <rick@reaatech.com> (https://reaatech.com)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reaatech/llm-cost-telemetry.git",
+    "directory": "packages/providers"
+  },
+  "homepage": "https://github.com/reaatech/llm-cost-telemetry/tree/main/packages/providers#readme",
+  "bugs": {
+    "url": "https://github.com/reaatech/llm-cost-telemetry/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@reaatech/llm-cost-telemetry": "0.1.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": "^0.24.0",
+    "@google/generative-ai": "^0.21.0",
+    "openai": "^4.52.0"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@google/generative-ai": {
+      "optional": true
+    },
+    "openai": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "clean": "rm -rf dist"
+  }
+}