@paid-ai/paid-node 0.0.7 → 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

@@ -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"));
@@ -44,6 +53,7 @@ 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 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)({
@@ -75,5 +85,18 @@ class PaidClient {
         var _a;
         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.7";
+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.7";
+exports.SDK_VERSION = "0.0.8-alpha0";

package/dist/cjs/wrapper/BatchUsage.d.ts

@@ -1,6 +1,8 @@
-import { Usage as UsageFernClient } from "../api/resources/usage/client/Client";
-export declare class Usage extends UsageFernClient {
+import * as core from "../core/index.js";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+import * as Paid from "../api/types/Signal.js";
+export declare class Usage extends UsageClient {
     private signals;
-    flush(requestOptions?: any): Promise<unknown[]>;
-    recordUsage(signal: any, requestOptions?: any): void;
+    flush(requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
+    record(signal?: Paid.Signal, requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
 }

package/dist/cjs/wrapper/BatchUsage.js

@@ -1,6 +1,40 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Usage = void 0;
+const core = __importStar(require("../core/index.js"));
 const Client_1 = require("../api/resources/usage/client/Client");
 class Usage extends Client_1.Usage {
     constructor() {
@@ -10,15 +44,17 @@ class Usage extends Client_1.Usage {
     flush(requestOptions) {
         return this.recordBulk({ signals: this.signals }, requestOptions);
     }
-    recordUsage(signal, requestOptions) {
+    record(signal = {}, requestOptions) {
         if (!this.signals) {
             this.signals = [];
         }
         this.signals.push(signal);
         if (this.signals.length >= 100) {
-            this.recordBulk({ signals: this.signals }, requestOptions);
+            const response = this.recordBulk({ signals: this.signals }, requestOptions);
             this.signals = [];
+            return response;
         }
+        return core.HttpResponsePromise.fromResult({ data: [], rawResponse: {} });
     }
 }
 exports.Usage = Usage;

package/dist/esm/Client.d.mts

@@ -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/esm/Client.mjs

@@ -1,6 +1,15 @@
 /**
  * This file was auto-generated by Fern from our API Definition.
  */
+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());
+    });
+};
 import * as core from "./core/index.mjs";
 import { mergeHeaders } from "./core/headers.mjs";
 import { Customers } from "./api/resources/customers/client/Client.mjs";
@@ -8,6 +17,7 @@ import { Agents } from "./api/resources/agents/client/Client.mjs";
 import { Contacts } from "./api/resources/contacts/client/Client.mjs";
 import { Orders } from "./api/resources/orders/client/Client.mjs";
 import { Usage } from "./wrapper/BatchUsage.mjs";
+import { capture, initializeTracing } from "./tracing/tracing.mjs";
 export class PaidClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: mergeHeaders({
@@ -39,4 +49,17 @@ export class PaidClient {
         var _a;
         return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new 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);
+            initializeTracing(resolvedToken);
+        });
+    }
+    capture(externalCustomerId, fn, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield capture(externalCustomerId, fn, ...args);
+        });
+    }
 }

package/dist/esm/index.d.mts

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

package/dist/esm/index.mjs

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

package/dist/esm/tracing/index.d.mts

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

package/dist/esm/tracing/index.mjs

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

package/dist/esm/tracing/tracing.d.mts

@@ -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/esm/tracing/tracing.mjs

@@ -0,0 +1,72 @@
+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());
+    });
+};
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+import { AsyncLocalStorage } from 'async_hooks';
+const customerIdStorage = new AsyncLocalStorage();
+const tokenStorage = new AsyncLocalStorage();
+export const getCustomerId = () => customerIdStorage.getStore();
+export const getTokenStorage = () => tokenStorage.getStore();
+let _token;
+const setToken = (token) => { _token = token; };
+const getToken = () => { return _token; };
+export function initializeTracing(apiKey) {
+    setToken(apiKey);
+    const sdk = new NodeSDK({
+        traceExporter: new 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));
+        });
+    });
+}
+export function capture(externalCustomerId, fn, ...args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tracer = 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: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error.message,
+                });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}

package/dist/esm/tracing/wrappers/openAiWrapper.d.mts

@@ -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/esm/tracing/wrappers/openAiWrapper.mjs

@@ -0,0 +1,248 @@
+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());
+    });
+};
+import { trace, SpanStatusCode, context } from "@opentelemetry/api";
+import { getCustomerId, getTokenStorage } from "../tracing";
+export class PaidOpenAI {
+    constructor(openaiClient) {
+        this.openai = openaiClient;
+        this.tracer = 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);
+    }
+}
+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 = trace.getSpan(context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.chat.completions.create(params);
+            }
+            const externalCustomerId = getCustomerId();
+            const token = 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: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: 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 = trace.getSpan(context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.responses.create(params);
+            }
+            const externalCustomerId = getCustomerId();
+            const token = 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: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: 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 = trace.getSpan(context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.embeddings.create(params);
+            }
+            const externalCustomerId = getCustomerId();
+            const token = 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: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: 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 = trace.getSpan(context.active());
+            if (!currentSpan) {
+                console.warn("No active span found, calling OpenAI directly without tracing.");
+                return this.openai.images.generate(params);
+            }
+            const externalCustomerId = getCustomerId();
+            const token = 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: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}

package/dist/esm/version.d.mts

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

package/dist/esm/version.mjs

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

package/dist/esm/wrapper/BatchUsage.d.mts

@@ -1,6 +1,8 @@
-import { Usage as UsageFernClient } from "../api/resources/usage/client/Client";
-export declare class Usage extends UsageFernClient {
+import * as core from "../core/index.mjs";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+import * as Paid from "../api/types/Signal.mjs";
+export declare class Usage extends UsageClient {
     private signals;
-    flush(requestOptions?: any): Promise<unknown[]>;
-    recordUsage(signal: any, requestOptions?: any): void;
+    flush(requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
+    record(signal?: Paid.Signal, requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
 }

package/dist/esm/wrapper/BatchUsage.mjs

@@ -1,5 +1,6 @@
-import { Usage as UsageFernClient } from "../api/resources/usage/client/Client";
-export class Usage extends UsageFernClient {
+import * as core from "../core/index.mjs";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+export class Usage extends UsageClient {
     constructor() {
         super(...arguments);
         this.signals = [];
@@ -7,14 +8,16 @@ export class Usage extends UsageFernClient {
     flush(requestOptions) {
         return this.recordBulk({ signals: this.signals }, requestOptions);
     }
-    recordUsage(signal, requestOptions) {
+    record(signal = {}, requestOptions) {
         if (!this.signals) {
             this.signals = [];
         }
         this.signals.push(signal);
         if (this.signals.length >= 100) {
-            this.recordBulk({ signals: this.signals }, requestOptions);
+            const response = this.recordBulk({ signals: this.signals }, requestOptions);
             this.signals = [];
+            return response;
         }
+        return core.HttpResponsePromise.fromResult({ data: [], rawResponse: {} });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@paid-ai/paid-node",
-    "version": "0.0.7",
+    "version": "0.0.8-alpha0",
     "private": false,
     "repository": "https://github.com/AgentPaid/paid-node",
     "type": "commonjs",
@@ -36,30 +36,34 @@
         "wire:test": "yarn test:wire"
     },
     "dependencies": {
-        "url-join": "4.0.1",
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.202.0",
+        "@opentelemetry/sdk-node": "^0.202.0",
+        "openai": "^5.5.1",
         "form-data": "^4.0.0",
         "formdata-node": "^6.0.3",
+        "js-base64": "3.7.7",
         "node-fetch": "^2.7.0",
         "qs": "^6.13.1",
         "readable-stream": "^4.5.2",
-        "js-base64": "3.7.7"
+        "url-join": "4.0.1"
     },
     "devDependencies": {
-        "@types/url-join": "4.0.1",
-        "@types/qs": "^6.9.17",
+        "@jest/globals": "^29.7.0",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^18.19.70",
         "@types/node-fetch": "^2.6.12",
+        "@types/qs": "^6.9.17",
         "@types/readable-stream": "^4.0.18",
-        "webpack": "^5.97.1",
-        "ts-loader": "^9.5.1",
+        "@types/url-join": "4.0.1",
         "jest": "^29.7.0",
-        "@jest/globals": "^29.7.0",
-        "@types/jest": "^29.5.14",
-        "ts-jest": "^29.3.4",
         "jest-environment-jsdom": "^29.7.0",
         "msw": "^2.8.4",
-        "@types/node": "^18.19.70",
         "prettier": "^3.4.2",
-        "typescript": "~5.7.2"
+        "ts-jest": "^29.3.4",
+        "ts-loader": "^9.5.1",
+        "typescript": "~5.7.2",
+        "webpack": "^5.97.1"
     },
     "browser": {
         "fs": false,