@paid-ai/paid-node 0.0.6 → 0.0.8-alpha0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Agent Paid Ltd 
+
+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

@@ -1,28 +1,45 @@
-# Paid TypeScript Library
 
-[![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2FAgentPaid%2Fpaid-node)
-[![npm shield](https://img.shields.io/npm/v/@paid-ai/paid-node)](https://www.npmjs.com/package/@paid-ai/paid-node)
+<div align="center">
+    <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="./assets/paid_light.svg" width=600>
+        <source media="(prefers-color-scheme: light)" srcset="./assets/paid_dark.svg" width=600>
+        <img alt="Fallback image description" src="./assets/paid_light.svg" width=600>
+    </picture>
+</div>
 
-The Paid TypeScript library provides convenient access to the Paid API from TypeScript.
+# 
+
+<div align="center">
+    <a href="https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2FAgentPaid%2Fpaid-node">
+        <img src="https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen" alt="fern shield">
+    </a>
+    <a href="https://www.npmjs.com/package/@paid-ai/paid-node">
+        <img src="https://img.shields.io/npm/v/@paid-ai/paid-node" alt="npm shield">
+    </a>
+</div>
+
+Paid is the all-in-one, drop-in Business Engine for AI Agents that handles your pricing, subscriptions, margins, billing, and renewals with just 5 lines of code. 
+The Paid TypeScript library provides convenient access to the Paid API from TypeScript. 
+
+## Documentation
+
+See the full API docs [here](https://paid.docs.buildwithfern.com/api-reference/api-reference/customers/list)
 
 ## Installation
 
 ```sh
-npm i -s @paid-ai/paid-node
+npm install -s @paid-ai/paid-node
 ```
 
-## Reference
-
-A full reference for this library is available [here](https://github.com/AgentPaid/paid-node/blob/HEAD/./reference.md).
-
 ## Usage
 
-Instantiate and use the client with the following:
+The client needs to be configured with your account's API key, which is available in the [Paid dashboard](https://app.paid.ai/agent-integration/api-keys). 
 
 ```typescript
 import { PaidClient } from "@paid-ai/paid-node";
 
-const client = new PaidClient({ token: "YOUR_TOKEN" });
+const client = new PaidClient({ token: "API_KEY" });
+
 await client.customers.create({
     name: "name",
 });
@@ -61,6 +78,73 @@ try {
 }
 ```
 
+## Cost Tracking
+
+It's possible to track usage costs by using Paid wrappers around you AI provider API.
+As of now, the following OpenAI APIs are supported:
+
+```
+chat.completions.create()
+responses.create()
+images.generate()
+embeddings.create()
+```
+
+Example usage:
+
+```typescript
+import { PaidClient, PaidOpenAI } from "@paid-ai/paid-node";
+import OpenAI from "openai";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+    const openaiClient = new OpenAI({ apiKey: "<your_openai_api_key" });
+
+    // initialize cost tracking
+    await client.initializeTracing()
+
+    // wrap openai in paid wrapper
+    const paidOpenAiWrapper = new PaidOpenAI(openaiClient);
+
+    // capture the call
+    await client.capture("<your_external_customer_id>", async () => {
+        const response = await paidOpenAiWrapper.images.generate({
+            prompt: "A beautiful sunset over the mountains",
+            n: 1,
+            size: "256x256"
+        });
+        if (response.data) {
+            console.log("Image generation:", response.data[0].url);
+        }
+    });
+}
+```
+
+## Manual Cost Tracking
+
+When using `client.usage.recordUsage()` API, it's possible to create cost traces manually
+just by passing in the cost data.
+
+```typescript
+const additionalData = {
+    costData: {
+        vendor: "<vendor_name>", // can be anything
+        cost : {
+            amount: 0.0001,
+            currency: "USD"
+        }
+    }
+};
+await client.usage.recordUsage({
+    agent_id: "<your_agent_id>",
+    event_name: "<your_signal_name>",
+    customer_id: "<your_customer_id>",
+    data: additionalData,
+})
+
+await client.usage.flush(); // need to flush to send usage immediately
+```
+
 ## Advanced
 
 ### Additional Headers

package/dist/cjs/Client.d.ts

@@ -7,7 +7,7 @@ import { Customers } from "./api/resources/customers/client/Client.js";
 import { Agents } from "./api/resources/agents/client/Client.js";
 import { Contacts } from "./api/resources/contacts/client/Client.js";
 import { Orders } from "./api/resources/orders/client/Client.js";
-import { Usage } from "./api/resources/usage/client/Client.js";
+import { Usage } from "./wrapper/BatchUsage.js";
 export declare namespace PaidClient {
     interface Options {
         environment?: core.Supplier<environments.PaidEnvironment | string>;
@@ -41,4 +41,6 @@ export declare class PaidClient {
     get contacts(): Contacts;
     get orders(): Orders;
     get usage(): Usage;
+    initializeTracing(): Promise<void>;
+    capture<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, ...args: Parameters<T>): Promise<ReturnType<T>>;
 }

package/dist/cjs/Client.js

@@ -35,6 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaidClient = void 0;
 const core = __importStar(require("./core/index.js"));
@@ -43,7 +52,8 @@ const Client_js_1 = require("./api/resources/customers/client/Client.js");
 const Client_js_2 = require("./api/resources/agents/client/Client.js");
 const Client_js_3 = require("./api/resources/contacts/client/Client.js");
 const Client_js_4 = require("./api/resources/orders/client/Client.js");
-const Client_js_5 = require("./api/resources/usage/client/Client.js");
+const BatchUsage_js_1 = require("./wrapper/BatchUsage.js");
+const tracing_js_1 = require("./tracing/tracing.js");
 class PaidClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: (0, headers_js_1.mergeHeaders)({
@@ -73,7 +83,20 @@ class PaidClient {
     }
     get usage() {
         var _a;
-        return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new Client_js_5.Usage(this._options)));
+        return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new BatchUsage_js_1.Usage(this._options)));
+    }
+    initializeTracing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenSupplier = this._options.token;
+            const token = typeof tokenSupplier === "function" ? yield tokenSupplier() : tokenSupplier;
+            const resolvedToken = yield Promise.resolve(token);
+            (0, tracing_js_1.initializeTracing)(resolvedToken);
+        });
+    }
+    capture(externalCustomerId, fn, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, tracing_js_1.capture)(externalCustomerId, fn, ...args);
+        });
     }
 }
 exports.PaidClient = PaidClient;

package/dist/cjs/index.d.ts

@@ -1,4 +1,6 @@
 export * as Paid from "./api/index.js";
 export { PaidClient } from "./Client.js";
-export { PaidEnvironment } from "./environments.js";
 export { PaidError, PaidTimeoutError } from "./errors/index.js";
+export { PaidEnvironment } from "./environments.js";
+export { PaidOpenAI } from "./tracing/wrappers/openAiWrapper.js";
+export { initializeTracing, capture } from "./tracing/tracing.js";

package/dist/cjs/index.js

@@ -33,12 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaidTimeoutError = exports.PaidError = exports.PaidEnvironment = exports.PaidClient = exports.Paid = void 0;
+exports.capture = exports.initializeTracing = exports.PaidOpenAI = exports.PaidEnvironment = exports.PaidTimeoutError = exports.PaidError = exports.PaidClient = exports.Paid = void 0;
 exports.Paid = __importStar(require("./api/index.js"));
 var Client_js_1 = require("./Client.js");
 Object.defineProperty(exports, "PaidClient", { enumerable: true, get: function () { return Client_js_1.PaidClient; } });
-var environments_js_1 = require("./environments.js");
-Object.defineProperty(exports, "PaidEnvironment", { enumerable: true, get: function () { return environments_js_1.PaidEnvironment; } });
 var index_js_1 = require("./errors/index.js");
 Object.defineProperty(exports, "PaidError", { enumerable: true, get: function () { return index_js_1.PaidError; } });
 Object.defineProperty(exports, "PaidTimeoutError", { enumerable: true, get: function () { return index_js_1.PaidTimeoutError; } });
+var environments_js_1 = require("./environments.js");
+Object.defineProperty(exports, "PaidEnvironment", { enumerable: true, get: function () { return environments_js_1.PaidEnvironment; } });
+var openAiWrapper_js_1 = require("./tracing/wrappers/openAiWrapper.js");
+Object.defineProperty(exports, "PaidOpenAI", { enumerable: true, get: function () { return openAiWrapper_js_1.PaidOpenAI; } });
+var tracing_js_1 = require("./tracing/tracing.js");
+Object.defineProperty(exports, "initializeTracing", { enumerable: true, get: function () { return tracing_js_1.initializeTracing; } });
+Object.defineProperty(exports, "capture", { enumerable: true, get: function () { return tracing_js_1.capture; } });

package/dist/cjs/tracing/index.d.ts

@@ -0,0 +1 @@
+export * from "./wrappers/openAiWrapper";

package/dist/cjs/tracing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./wrappers/openAiWrapper"), exports);

package/dist/cjs/tracing/tracing.d.ts

@@ -0,0 +1,4 @@
+export declare const getCustomerId: () => string | null | undefined;
+export declare const getTokenStorage: () => string | null | undefined;
+export declare function initializeTracing(apiKey: string): void;
+export declare function capture<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, ...args: Parameters<T>): Promise<ReturnType<T>>;

package/dist/cjs/tracing/tracing.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenStorage = exports.getCustomerId = void 0;
+exports.initializeTracing = initializeTracing;
+exports.capture = capture;
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const api_1 = require("@opentelemetry/api");
+const async_hooks_1 = require("async_hooks");
+const customerIdStorage = new async_hooks_1.AsyncLocalStorage();
+const tokenStorage = new async_hooks_1.AsyncLocalStorage();
+const getCustomerId = () => customerIdStorage.getStore();
+exports.getCustomerId = getCustomerId;
+const getTokenStorage = () => tokenStorage.getStore();
+exports.getTokenStorage = getTokenStorage;
+let _token;
+const setToken = (token) => { _token = token; };
+const getToken = () => { return _token; };
+function initializeTracing(apiKey) {
+    setToken(apiKey);
+    const sdk = new sdk_node_1.NodeSDK({
+        traceExporter: new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            url: 'https://collector.agentpaid.io:4318/v1/traces',
+            // url: 'http://localhost:4318/v1/traces',
+        }),
+    });
+    sdk.start();
+    // Graceful shutdown
+    ['SIGINT', 'SIGTERM'].forEach(signal => {
+        process.on(signal, () => {
+            sdk.shutdown()
+                .then(() => console.log('Paid tracing SDK shut down'))
+                .catch(error => console.error('Error shutting down Paid tracing SDK', error));
+        });
+    });
+}
+function capture(externalCustomerId, fn, ...args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tracer = api_1.trace.getTracer('paid.node');
+        const token = getToken();
+        if (!token) {
+            console.warn('No token found - tracing will not be captured');
+            return fn(...args);
+        }
+        return tracer.startActiveSpan("paid.node", (span) => __awaiter(this, void 0, void 0, function* () {
+            span.setAttribute('external_customer_id', externalCustomerId);
+            span.setAttribute('token', token);
+            try {
+                const result = yield customerIdStorage.run(externalCustomerId, () => __awaiter(this, void 0, void 0, function* () {
+                    return yield tokenStorage.run(token, () => __awaiter(this, void 0, void 0, function* () {
+                        return yield fn(...args);
+                    }));
+                }));
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: error.message,
+                });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}

package/dist/cjs/tracing/wrappers/openAiWrapper.d.ts

@@ -0,0 +1,48 @@
+import OpenAI from "openai";
+import { Tracer } from "@opentelemetry/api";
+import { ChatCompletion, ChatCompletionCreateParams } from "openai/resources/chat/completions";
+import { EmbeddingCreateParams } from "openai/resources/embeddings";
+import { ImagesResponse, ImageGenerateParams } from "openai/resources/images";
+import { CreateEmbeddingResponse } from "openai/resources/embeddings";
+export declare class PaidOpenAI {
+    private readonly openai;
+    private readonly tracer;
+    constructor(openaiClient: any);
+    get chat(): ChatWrapper;
+    get embeddings(): EmbeddingsWrapper;
+    get images(): ImagesWrapper;
+    get responses(): ResponsesWrapper;
+}
+declare class ChatWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    get completions(): ChatCompletionsWrapper;
+}
+declare class ChatCompletionsWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    create(params: ChatCompletionCreateParams): Promise<ChatCompletion>;
+}
+type ResponseCreateParams = any;
+type Response = any;
+declare class ResponsesWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: any, tracer: Tracer);
+    create(params: ResponseCreateParams): Promise<Response>;
+}
+declare class EmbeddingsWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    create(params: EmbeddingCreateParams): Promise<CreateEmbeddingResponse>;
+}
+declare class ImagesWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    generate(params: ImageGenerateParams): Promise<ImagesResponse>;
+}
+export {};

package/dist/cjs/tracing/wrappers/openAiWrapper.js

@@ -0,0 +1,252 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaidOpenAI = void 0;
+const api_1 = require("@opentelemetry/api");
+const tracing_1 = require("../tracing");
+class PaidOpenAI {
+    constructor(openaiClient) {
+        this.openai = openaiClient;
+        this.tracer = api_1.trace.getTracer("paid.node");
+    }
+    get chat() {
+        return new ChatWrapper(this.openai, this.tracer);
+    }
+    get embeddings() {
+        return new EmbeddingsWrapper(this.openai, this.tracer);
+    }
+    get images() {
+        return new ImagesWrapper(this.openai, this.tracer);
+    }
+    get responses() {
+        return new ResponsesWrapper(this.openai, this.tracer);
+    }
+}
+exports.PaidOpenAI = PaidOpenAI;
+class ChatWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    get completions() {
+        return new ChatCompletionsWrapper(this.openai, this.tracer);
+    }
+}
+class ChatCompletionsWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentSpan = api_1.trace.getSpan(api_1.context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.chat.completions.create(params);
+            }
+            const externalCustomerId = (0, tracing_1.getCustomerId)();
+            const token = (0, tracing_1.getTokenStorage)();
+            const model = params.model;
+            const spanName = `trace.chat ${model}`;
+            return this.tracer.startActiveSpan(spanName, (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "chat",
+                };
+                if (externalCustomerId) {
+                    attributes["external_customer_id"] = externalCustomerId;
+                }
+                if (token) {
+                    attributes["token"] = token;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = (yield this.openai.chat.completions.create(params));
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.prompt_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.completion_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                    }
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}
+class ResponsesWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentSpan = api_1.trace.getSpan(api_1.context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.responses.create(params);
+            }
+            const externalCustomerId = (0, tracing_1.getCustomerId)();
+            const token = (0, tracing_1.getTokenStorage)();
+            const model = (_a = params.model) !== null && _a !== void 0 ? _a : "unknown";
+            const spanName = `trace.responses ${model}`;
+            return this.tracer.startActiveSpan(spanName, (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "chat", // Equivalent to chat.completions
+                };
+                if (externalCustomerId) {
+                    attributes["external_customer_id"] = externalCustomerId;
+                }
+                if (token) {
+                    attributes["token"] = token;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.openai.responses.create(params);
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.prompt_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.completion_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                    }
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}
+class EmbeddingsWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentSpan = api_1.trace.getSpan(api_1.context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.embeddings.create(params);
+            }
+            const externalCustomerId = (0, tracing_1.getCustomerId)();
+            const token = (0, tracing_1.getTokenStorage)();
+            const model = (_a = params.model) !== null && _a !== void 0 ? _a : "unknown";
+            const spanName = `trace.embeddings ${model}`;
+            return this.tracer.startActiveSpan(spanName, (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "embeddings",
+                };
+                if (externalCustomerId) {
+                    attributes["external_customer_id"] = externalCustomerId;
+                }
+                if (token) {
+                    attributes["token"] = token;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.openai.embeddings.create(params);
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.prompt_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                    }
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}
+class ImagesWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    generate(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const currentSpan = api_1.trace.getSpan(api_1.context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.images.generate(params);
+            }
+            const externalCustomerId = (0, tracing_1.getCustomerId)();
+            const token = (0, tracing_1.getTokenStorage)();
+            const model = (_a = params.model) !== null && _a !== void 0 ? _a : "dall-e-3";
+            const spanName = `trace.images ${model}`;
+            return this.tracer.startActiveSpan(spanName, (span) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const attributes = {
+                    "gen_ai.request.model": model,
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "image_generation",
+                };
+                if (externalCustomerId) {
+                    attributes["external_customer_id"] = externalCustomerId;
+                }
+                if (token) {
+                    attributes["token"] = token;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.openai.images.generate(params);
+                    span.setAttributes({
+                        "gen_ai.image.count": (_a = params.n) !== null && _a !== void 0 ? _a : 1,
+                        "gen_ai.image.size": (_b = params.size) !== null && _b !== void 0 ? _b : "1024x1024",
+                        "gen_ai.image.quality": (_c = params.quality) !== null && _c !== void 0 ? _c : "standard",
+                    });
+                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.6";
+export declare const SDK_VERSION = "0.0.8-alpha0";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.0.6";
+exports.SDK_VERSION = "0.0.8-alpha0";