@paid-ai/paid-node 0.0.8-alpha1 → 0.0.8-alpha3

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

@@ -0,0 +1,81 @@
+"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.PaidMistral = void 0;
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("../tracing.js");
+class PaidMistral {
+    constructor(mistralClient) {
+        this.mistral = mistralClient;
+        this.tracer = tracing_js_1.paidTracer;
+    }
+    get ocr() {
+        return new OCRWrapper(this.mistral, this.tracer);
+    }
+}
+exports.PaidMistral = PaidMistral;
+class OCRWrapper {
+    constructor(mistral, tracer) {
+        this.mistral = mistral;
+        this.tracer = tracer;
+    }
+    process(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = (0, tracing_js_1.getCustomerIdStorage)();
+            const externalAgentId = (0, tracing_js_1.getAgentIdStorage)();
+            const token = (0, tracing_js_1.getTokenStorage)();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.mistral.ocr", (span) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const attributes = {
+                    "gen_ai.system": "mistral",
+                    "gen_ai.operation.name": "ocr",
+                    external_customer_id: externalCustomerId,
+                    token: token,
+                };
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                // Check if annotations are requested
+                if (request.bboxAnnotationFormat || request.documentAnnotationFormat) {
+                    attributes["gen_ai.ocr.annotated"] = "true";
+                }
+                // Set request model
+                if (request.model) {
+                    attributes["gen_ai.request.model"] = request.model;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.mistral.ocr.process(request, options);
+                    // Add usage information from response
+                    if (((_a = response.usageInfo) === null || _a === void 0 ? void 0 : _a.pagesProcessed) !== undefined) {
+                        span.setAttribute("gen_ai.ocr.pages_processed", response.usageInfo.pagesProcessed);
+                    }
+                    if (response.model) {
+                        span.setAttribute("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();
+                }
+            }));
+        });
+    }
+}

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

@@ -11,11 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaidOpenAI = void 0;
 const api_1 = require("@opentelemetry/api");
-const tracing_1 = require("../tracing");
+const tracing_js_1 = require("../tracing.js");
 class PaidOpenAI {
     constructor(openaiClient) {
         this.openai = openaiClient;
-        this.tracer = api_1.trace.getTracer("paid.node");
+        this.tracer = tracing_js_1.paidTracer;
     }
     get chat() {
         return new ChatWrapper(this.openai, this.tracer);
@@ -47,25 +47,21 @@ class ChatCompletionsWrapper {
     }
     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_js_1.getCustomerIdStorage)();
+            const externalAgentId = (0, tracing_js_1.getAgentIdStorage)();
+            const token = (0, tracing_js_1.getTokenStorage)();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
             }
-            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* () {
+            return this.tracer.startActiveSpan("trace.openai.chat", (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;
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
                 }
                 span.setAttributes(attributes);
                 try {
@@ -99,24 +95,22 @@ class ResponsesWrapper {
     }
     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.responses.create(params);
+            const externalCustomerId = (0, tracing_js_1.getCustomerIdStorage)();
+            const externalAgentId = (0, tracing_js_1.getAgentIdStorage)();
+            const token = (0, tracing_js_1.getTokenStorage)();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
             }
-            const externalCustomerId = (0, tracing_1.getCustomerId)();
-            const token = (0, tracing_1.getTokenStorage)();
             return this.tracer.startActiveSpan("trace.openai.responses", (span) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 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;
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
                 }
                 span.setAttributes(attributes);
                 try {
@@ -156,26 +150,21 @@ class EmbeddingsWrapper {
     }
     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_js_1.getCustomerIdStorage)();
+            const externalAgentId = (0, tracing_js_1.getAgentIdStorage)();
+            const token = (0, tracing_js_1.getTokenStorage)();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
             }
-            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* () {
+            return this.tracer.startActiveSpan("trace.openai.embeddings", (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;
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
                 }
                 span.setAttributes(attributes);
                 try {
@@ -209,27 +198,24 @@ class ImagesWrapper {
     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 externalCustomerId = (0, tracing_js_1.getCustomerIdStorage)();
+            const externalAgentId = (0, tracing_js_1.getAgentIdStorage)();
+            const token = (0, tracing_js_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* () {
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.openai.images", (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;
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
                 }
                 span.setAttributes(attributes);
                 try {

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.0.8-alpha1";
+export declare const SDK_VERSION = "0.0.8-alpha3";

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.8-alpha1";
+exports.SDK_VERSION = "0.0.8-alpha3";

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

@@ -1,5 +1,5 @@
 import * as core from "../core/index.js";
-import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client.js";
 import * as Paid from "../api/types/Signal.js";
 export declare class Usage extends UsageClient {
     private signals;

package/dist/cjs/wrapper/BatchUsage.js

@@ -35,8 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 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 {
+const Client_js_1 = require("../api/resources/usage/client/Client.js");
+class Usage extends Client_js_1.Usage {
     constructor() {
         super(...arguments);
         this.signals = [];

package/dist/esm/Client.d.mts

@@ -41,6 +41,7 @@ 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>>;
+    initializeTracing(collectorEndpoint?: string): Promise<void>;
+    trace<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, externalAgentId?: string, ...args: Parameters<T>): Promise<ReturnType<T>>;
+    signal(eventName: string, data?: Record<string, any>): void;
 }

package/dist/esm/Client.mjs

@@ -17,7 +17,8 @@ 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";
+import { _trace, _initializeTracing } from "./tracing/tracing.mjs";
+import { _signal } from "./tracing/signal.mjs";
 export class PaidClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: mergeHeaders({
@@ -49,17 +50,24 @@ export class PaidClient {
         var _a;
         return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new Usage(this._options)));
     }
-    initializeTracing() {
+    // Need to call this method before using tracing or creating wrappers.
+    initializeTracing(collectorEndpoint) {
         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);
+            _initializeTracing(resolvedToken, collectorEndpoint);
         });
     }
-    capture(externalCustomerId, fn, ...args) {
+    // Use this method to track actions like LLM usage and sending signals.
+    // The callback to this function is the work that you want to trace.
+    trace(externalCustomerId, fn, externalAgentId, ...args) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield capture(externalCustomerId, fn, ...args);
+            return yield _trace(externalCustomerId, fn, externalAgentId, ...args);
         });
     }
+    // sends Paid signal. This needs to called as part of callback to Paid.trace()
+    signal(eventName, data) {
+        return _signal(eventName, data);
+    }
 }

package/dist/esm/index.d.mts

@@ -3,4 +3,6 @@ export { PaidClient } from "./Client.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";
+export { PaidAnthropic } from "./tracing/wrappers/anthropicWrapper.mjs";
+export { PaidMistral } from "./tracing/wrappers/mistralWrapper.mjs";
+export { PaidLangChainCallback } from "./tracing/wrappers/langchainCallback.mjs";

package/dist/esm/index.mjs

@@ -3,4 +3,6 @@ export { PaidClient } from "./Client.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";
+export { PaidAnthropic } from "./tracing/wrappers/anthropicWrapper.mjs";
+export { PaidMistral } from "./tracing/wrappers/mistralWrapper.mjs";
+export { PaidLangChainCallback } from "./tracing/wrappers/langchainCallback.mjs";

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

@@ -0,0 +1 @@
+export declare function _signal(eventName: string, data?: Record<string, any>): void;

package/dist/esm/tracing/signal.mjs

@@ -0,0 +1,42 @@
+import { SpanStatusCode } from "@opentelemetry/api";
+import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "./tracing.mjs";
+import { paidTracer } from "./tracing.mjs";
+export function _signal(eventName, data) {
+    if (!eventName) {
+        throw new Error("Event name is required for signal.");
+    }
+    const externalCustomerId = getCustomerIdStorage();
+    const externalAgentId = getAgentIdStorage();
+    const token = getTokenStorage();
+    if (!externalCustomerId || !externalAgentId || !token) {
+        throw new Error(`Missing some of: external_customer_id: ${externalCustomerId}, external_agent_id: ${externalAgentId}, or token. Make sure to call signal() within trace()`);
+    }
+    const tracer = paidTracer;
+    tracer.startActiveSpan("trace.signal", (span) => {
+        try {
+            const attributes = {
+                external_customer_id: externalCustomerId,
+                external_agent_id: externalAgentId,
+                event_name: eventName,
+                token: token,
+            };
+            // Optional data (ex. manual cost tracking)
+            if (data) {
+                attributes["data"] = JSON.stringify(data);
+            }
+            span.setAttributes(attributes);
+            // Mark span as successful
+            span.setStatus({ code: SpanStatusCode.OK });
+        }
+        catch (error) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            span.recordException(error);
+        }
+        finally {
+            span.end();
+        }
+    });
+}

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

@@ -1,4 +1,8 @@
-export declare const getCustomerId: () => string | null | undefined;
+import winston from "winston";
+export declare const logger: winston.Logger;
+export declare let paidTracer: import("@opentelemetry/api").Tracer;
+export declare const getCustomerIdStorage: () => string | null | undefined;
+export declare const getAgentIdStorage: () => 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>>;
+export declare function _initializeTracing(apiKey: string, collectorEndpoint?: string): void;
+export declare function _trace<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, externalAgentId: string | undefined, ...args: Parameters<T>): Promise<ReturnType<T>>;

package/dist/esm/tracing/tracing.mjs

@@ -7,50 +7,93 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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';
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { AsyncLocalStorage } from "async_hooks";
+import winston from "winston";
+export const logger = winston.createLogger({
+    level: "silent", // Default to 'silent' to avoid logging unless set via environment variable
+    format: winston.format.simple(),
+    transports: [new winston.transports.Console()],
+});
+const logLevel = process.env.PAID_LOG_LEVEL;
+if (logLevel) {
+    logger.level = logLevel;
+}
+const COLLECTOR_ENDPOINT = process.env.PAID_COLLECTOR_ENDPOINT || "https://collector.agentpaid.io:4318/v1/traces";
+// set up default tracing provider
+let paidExporter = new OTLPTraceExporter({ url: COLLECTOR_ENDPOINT });
+let spanProcessor = new BatchSpanProcessor(paidExporter);
+let paidTracerProvider = new NodeTracerProvider({ spanProcessors: [spanProcessor] });
+export let paidTracer = paidTracerProvider.getTracer("paid.node");
+// storage for passing info to child spans
 const customerIdStorage = new AsyncLocalStorage();
+const agentIdStorage = new AsyncLocalStorage();
 const tokenStorage = new AsyncLocalStorage();
-export const getCustomerId = () => customerIdStorage.getStore();
+export const getCustomerIdStorage = () => customerIdStorage.getStore();
+export const getAgentIdStorage = () => agentIdStorage.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 => {
+const setToken = (token) => {
+    _token = token;
+};
+const getToken = () => {
+    return _token;
+};
+let _isShuttingDown = false;
+function setupGracefulShutdown(shuttable) {
+    ["SIGINT", "SIGTERM", "beforeExit", "uncaughtException", "unhandledRejection"].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));
+            if (_isShuttingDown) {
+                return;
+            }
+            _isShuttingDown = true;
+            shuttable
+                .shutdown()
+                .then(() => logger.info(`Paid tracing SDK shut down from signal: ${signal}`))
+                .catch((error) => logger.error(`Error shutting down Paid tracing SDK ${error}`));
         });
     });
 }
-export function capture(externalCustomerId, fn, ...args) {
+export function _initializeTracing(apiKey, collectorEndpoint) {
+    if (getToken()) {
+        throw new Error("Tracing SDK is already initialized.");
+    }
+    if (!apiKey) {
+        throw new Error("Cannot initialize tracing SDK - first initialize the PaidClient with an API key");
+    }
+    if (collectorEndpoint) {
+        paidExporter = new OTLPTraceExporter({ url: collectorEndpoint });
+        spanProcessor = new BatchSpanProcessor(paidExporter);
+        paidTracerProvider = new NodeTracerProvider({ spanProcessors: [spanProcessor] });
+        paidTracer = paidTracerProvider.getTracer("paid.node");
+    }
+    setupGracefulShutdown(spanProcessor);
+    setToken(apiKey);
+    const collectorAddress = collectorEndpoint || COLLECTOR_ENDPOINT;
+    logger.info(`Paid tracing SDK initialized with collector endpoint: ${collectorAddress}`);
+}
+export function _trace(externalCustomerId, fn, externalAgentId, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tracer = trace.getTracer('paid.node');
+        const tracer = paidTracer;
         const token = getToken();
-        if (!token) {
-            console.warn('No token found - tracing will not be captured');
-            return fn(...args);
+        if (!token || !externalCustomerId) {
+            throw new Error(`Paid tracing is not initialized. Make sure to call initializeTracing() first.`);
         }
         return tracer.startActiveSpan("paid.node", (span) => __awaiter(this, void 0, void 0, function* () {
-            span.setAttribute('external_customer_id', externalCustomerId);
-            span.setAttribute('token', token);
+            span.setAttribute("external_customer_id", externalCustomerId);
+            span.setAttribute("token", token);
+            if (externalAgentId) {
+                span.setAttribute("external_agent_id", externalAgentId);
+            }
             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);
+                    return yield agentIdStorage.run(externalAgentId !== null && externalAgentId !== void 0 ? externalAgentId : null, () => __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 });

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

@@ -0,0 +1,16 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { Tracer } from "@opentelemetry/api";
+import { MessageCreateParams } from "@anthropic-ai/sdk/resources/messages";
+export declare class PaidAnthropic {
+    private readonly anthropic;
+    private readonly tracer;
+    constructor(anthropicClient: Anthropic);
+    get messages(): MessagesWrapper;
+}
+declare class MessagesWrapper {
+    private anthropic;
+    private tracer;
+    constructor(anthropic: Anthropic, tracer: Tracer);
+    create(params: MessageCreateParams): Promise<any>;
+}
+export {};

package/dist/esm/tracing/wrappers/anthropicWrapper.mjs

@@ -0,0 +1,80 @@
+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 { SpanStatusCode } from "@opentelemetry/api";
+import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage, paidTracer } from "../tracing.mjs";
+export class PaidAnthropic {
+    constructor(anthropicClient) {
+        this.anthropic = anthropicClient;
+        this.tracer = paidTracer;
+    }
+    get messages() {
+        return new MessagesWrapper(this.anthropic, this.tracer);
+    }
+}
+class MessagesWrapper {
+    constructor(anthropic, tracer) {
+        this.anthropic = anthropic;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.anthropic.messages", (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "anthropic",
+                    "gen_ai.operation.name": "messages",
+                    external_customer_id: externalCustomerId,
+                    token: token,
+                };
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                // Set request model from params
+                if (params.model) {
+                    attributes["gen_ai.request.model"] = params.model;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = (yield this.anthropic.messages.create(params));
+                    // Add usage information from response
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.input_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.output_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                        // Add Anthropic-specific cache usage if available
+                        if ("cache_creation_input_tokens" in response.usage && response.usage.cache_creation_input_tokens) {
+                            span.setAttribute("gen_ai.usage.cache_creation_input_tokens", response.usage.cache_creation_input_tokens);
+                        }
+                        if ("cache_read_input_tokens" in response.usage && response.usage.cache_read_input_tokens) {
+                            span.setAttribute("gen_ai.usage.cache_read_input_tokens", response.usage.cache_read_input_tokens);
+                        }
+                    }
+                    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();
+                }
+            }));
+        });
+    }
+}