@reaatech/llm-cost-telemetry-providers 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 llm-cost-telemetry contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,205 @@
+# @reaatech/llm-cost-telemetry-providers
+
+[![npm version](https://img.shields.io/npm/v/@reaatech/llm-cost-telemetry-providers.svg)](https://www.npmjs.com/package/@reaatech/llm-cost-telemetry-providers)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/reaatech/llm-cost-telemetry/blob/main/LICENSE)
+[![CI](https://img.shields.io/github/actions/workflow/status/reaatech/llm-cost-telemetry/ci.yml?branch=main&label=CI)](https://github.com/reaatech/llm-cost-telemetry/actions/workflows/ci.yml)
+
+> **Status:** Pre-1.0 — APIs may change in minor versions. Pin to a specific version in production.
+
+LLM provider SDK wrappers for automatic cost telemetry. Wraps the official OpenAI, Anthropic, and Google Generative AI SDKs to capture token usage, timing, and telemetry context from every API call without changing your application code.
+
+## Installation
+
+```bash
+npm install @reaatech/llm-cost-telemetry-providers
+# or
+pnpm add @reaatech/llm-cost-telemetry-providers
+```
+
+Provider SDKs are peer dependencies — install only the ones you use:
+
+```bash
+pnpm add openai                    # for wrapOpenAI
+pnpm add @anthropic-ai/sdk         # for wrapAnthropic
+pnpm add @google/generative-ai     # for wrapGoogleGenerativeAI
+```
+
+## Feature Overview
+
+- **OpenAI wrapper** — intercepts `chat.completions.create` and `completions.create`
+- **Anthropic wrapper** — intercepts `messages.create` with cache token awareness
+- **Google wrapper** — intercepts `generateContent` and `generateContentStream` with streaming support
+- **Telemetry context injection** — attach tenant, feature, and route metadata to each call
+- **Cost span emission** — every intercepted call produces a `CostSpan` with token counts and timing
+- **Pluggable span handler** — register a callback to forward spans to aggregators, exporters, or your own pipeline
+
+## Quick Start
+
+```typescript
+import { wrapOpenAI } from "@reaatech/llm-cost-telemetry-providers";
+import OpenAI from "openai";
+
+const client = wrapOpenAI(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
+
+const response = await client.chat.completions.create({
+  model: "gpt-4",
+  messages: [{ role: "user", content: "Hello!" }],
+  telemetry: {
+    tenant: "acme-corp",
+    feature: "chat-support",
+    route: "/api/chat",
+  },
+});
+
+// A CostSpan was automatically emitted with:
+//   provider: "openai", model: "gpt-4"
+//   inputTokens: response.usage.prompt_tokens
+//   outputTokens: response.usage.completion_tokens
+//   timing: request duration
+//   telemetry: { tenant, feature, route }
+```
+
+## API Reference
+
+### `wrapOpenAI(client: OpenAI): WrappedOpenAI`
+
+Wraps an OpenAI client instance. The returned object preserves the full OpenAI API surface. Intercepted methods:
+
+| Method | Telemetry Added |
+|--------|----------------|
+| `chat.completions.create(params)` | `telemetry?` on `params` |
+| `completions.create(params)` | `telemetry?` on `params` |
+
+```typescript
+import { wrapOpenAI, type WrappedOpenAI } from "@reaatech/llm-cost-telemetry-providers";
+
+const client: WrappedOpenAI = wrapOpenAI(new OpenAI());
+```
+
+### `wrapAnthropic(client: Anthropic): WrappedAnthropic`
+
+Wraps an Anthropic client. Automatically captures cache read and cache creation tokens:
+
+```typescript
+import { wrapAnthropic, type WrappedAnthropic } from "@reaatech/llm-cost-telemetry-providers";
+import Anthropic from "@anthropic-ai/sdk";
+
+const client: WrappedAnthropic = wrapAnthropic(new Anthropic());
+
+const response = await client.messages.create({
+  model: "claude-sonnet-20240229",
+  max_tokens: 1024,
+  system: "You are a helpful assistant.", // eligible for prompt caching
+  messages: [{ role: "user", content: "Hello!" }],
+  telemetry: { tenant: "acme-corp" },
+});
+
+// CostSpan includes: cacheReadTokens, cacheCreationTokens from response.usage
+```
+
+### `wrapGoogleGenerativeAI(client: GoogleGenerativeAI): WrappedGoogleGenerativeAI`
+
+Wraps a Google Generative AI client. Supports both streaming and non-streaming:
+
+```typescript
+import {
+  wrapGoogleGenerativeAI,
+  type WrappedGoogleGenerativeAI,
+  type WrappedGenerativeModel,
+} from "@reaatech/llm-cost-telemetry-providers";
+import { GoogleGenerativeAI } from "@google/generative-ai";
+
+const genAI: WrappedGoogleGenerativeAI = wrapGoogleGenerativeAI(
+  new GoogleGenerativeAI(process.env.GOOGLE_API_KEY)
+);
+
+const model: WrappedGenerativeModel = genAI.getGenerativeModel({ model: "gemini-pro" });
+
+// Non-streaming
+const result = await model.generateContent("Hello!", {
+  telemetry: { tenant: "acme-corp" },
+});
+
+// Streaming — span emitted when the stream completes
+const stream = await model.generateContentStream("Count to 10", {
+  telemetry: { tenant: "acme-corp" },
+});
+for await (const chunk of stream.stream) {
+  console.log(chunk.text());
+}
+```
+
+### `BaseProviderWrapper<TClient>`
+
+Abstract base class for building custom provider wrappers:
+
+```typescript
+import { BaseProviderWrapper } from "@reaatech/llm-cost-telemetry-providers";
+import type { RequestMetadata, ResponseMetadata, SpanCallback } from "@reaatech/llm-cost-telemetry-providers";
+
+class MyProviderWrapper extends BaseProviderWrapper<MyClient> {
+  get provider(): Provider { return "openai"; }
+}
+```
+
+### Span Callback
+
+Register a callback to receive emitted `CostSpan` objects:
+
+```typescript
+import { wrapOpenAI, type SpanCallback } from "@reaatech/llm-cost-telemetry-providers";
+
+const onSpan: SpanCallback = (span) => {
+  console.log(`Cost: $${span.costUsd}`);
+  // Forward to aggregator, exporter, or your own pipeline
+};
+
+const client = wrapOpenAI(new OpenAI());
+// Set the callback on the wrapper
+client.__telemetry.onSpan = onSpan;
+```
+
+## Usage Patterns
+
+### Multi-Tenant Cost Tracking
+
+```typescript
+const client = wrapOpenAI(new OpenAI());
+
+// Different tenants attach different telemetry
+const acmeResp = await client.chat.completions.create({
+  model: "gpt-3.5-turbo",
+  messages: [{ role: "user", content: "Hi" }],
+  telemetry: { tenant: "acme-corp", feature: "support" },
+});
+
+const startupResp = await client.chat.completions.create({
+  model: "gpt-3.5-turbo",
+  messages: [{ role: "user", content: "Hi" }],
+  telemetry: { tenant: "startup-inc", feature: "onboarding" },
+});
+
+// Each span is tagged with the correct tenant
+```
+
+### Wrapping Multiple Providers
+
+```typescript
+import { wrapOpenAI, wrapAnthropic, wrapGoogleGenerativeAI } from "@reaatech/llm-cost-telemetry-providers";
+
+const openai = wrapOpenAI(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
+const anthropic = wrapAnthropic(new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY }));
+const google = wrapGoogleGenerativeAI(new GoogleGenerativeAI(process.env.GOOGLE_API_KEY));
+
+// Use each as normal — telemetry is transparent
+```
+
+## Related Packages
+
+- [@reaatech/llm-cost-telemetry](https://www.npmjs.com/package/@reaatech/llm-cost-telemetry) — Core types and utilities
+- [@reaatech/llm-cost-telemetry-calculator](https://www.npmjs.com/package/@reaatech/llm-cost-telemetry-calculator) — Cost calculation engine
+- [@reaatech/llm-cost-telemetry-aggregation](https://www.npmjs.com/package/@reaatech/llm-cost-telemetry-aggregation) — Span collection and aggregation
+
+## License
+
+[MIT](https://github.com/reaatech/llm-cost-telemetry/blob/main/LICENSE)

package/dist/index.cjs

@@ -0,0 +1,467 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnthropicWrapper: () => AnthropicWrapper,
+  BaseProviderWrapper: () => BaseProviderWrapper,
+  GoogleGenerativeAIWrapper: () => GoogleGenerativeAIWrapper,
+  OpenAIWrapper: () => OpenAIWrapper,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapGoogleGenerativeAI: () => wrapGoogleGenerativeAI,
+  wrapOpenAI: () => wrapOpenAI
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/base.ts
+var import_llm_cost_telemetry = require("@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: (0, import_llm_cost_telemetry.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
+var import_llm_cost_telemetry2 = require("@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 = (0, import_llm_cost_telemetry2.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 = (0, import_llm_cost_telemetry2.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 = (0, import_llm_cost_telemetry2.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 = (0, import_llm_cost_telemetry2.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 = (0, import_llm_cost_telemetry2.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 = (0, import_llm_cost_telemetry2.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
+var import_llm_cost_telemetry3 = require("@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 = (0, import_llm_cost_telemetry3.now)();
+      const telemetry = this.extractTelemetryContext(
+        options
+      );
+      const model = options.model;
+      const { telemetry: _, ...cleanOptions } = options;
+      try {
+        const response = await originalCreate(
+          cleanOptions,
+          ...rest
+        );
+        const endTime = (0, import_llm_cost_telemetry3.now)();
+        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 = (0, import_llm_cost_telemetry3.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 wrapAnthropic(client) {
+  const wrapper = new AnthropicWrapper(client);
+  return wrapper.wrap();
+}
+
+// src/google.ts
+var import_llm_cost_telemetry4 = require("@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 = (0, import_llm_cost_telemetry4.now)();
+        const telemetry = options?.telemetry ? wrapper.extractTelemetryContext(options.telemetry) : void 0;
+        const modelId = modelParams.model;
+        try {
+          const response = await originalGenerate(request, options);
+          const endTime = (0, import_llm_cost_telemetry4.now)();
+          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 = (0, import_llm_cost_telemetry4.now)();
+          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 = (0, import_llm_cost_telemetry4.now)();
+        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 = (0, import_llm_cost_telemetry4.now)();
+              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 = (0, import_llm_cost_telemetry4.now)();
+              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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicWrapper,
+  BaseProviderWrapper,
+  GoogleGenerativeAIWrapper,
+  OpenAIWrapper,
+  wrapAnthropic,
+  wrapGoogleGenerativeAI,
+  wrapOpenAI
+});