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

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

@@ -0,0 +1,146 @@
+"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.PaidLangChainCallback = void 0;
+const base_1 = require("@langchain/core/callbacks/base");
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("../tracing.js");
+class PaidLangChainCallback extends base_1.BaseCallbackHandler {
+    constructor() {
+        super();
+        this.name = "PaidLangChainCallback";
+        this.spans = new Map();
+        this.tracer = api_1.trace.getTracer("paid.node");
+    }
+    extractProvider(serialized) {
+        if (!(serialized === null || serialized === void 0 ? void 0 : serialized.id))
+            return "unknown";
+        const idStr = serialized.id.join(" ").toLowerCase();
+        if (idStr.includes("openai"))
+            return "openai";
+        if (idStr.includes("anthropic"))
+            return "anthropic";
+        if (idStr.includes("mistral"))
+            return "mistral";
+        if (idStr.includes("cohere"))
+            return "cohere";
+        if (idStr.includes("huggingface"))
+            return "huggingface";
+        if (idStr.includes("azure"))
+            return "azure";
+        return "unknown";
+    }
+    handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentSpan = api_1.trace.getSpan(api_1.context.active());
+            if (!currentSpan) {
+                throw new Error("No active span found, make sure to call this inside of a callback to paid.trace().");
+            }
+            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 modelType = (metadata === null || metadata === void 0 ? void 0 : metadata.ls_model_type) || "unknown";
+            const modelName = (metadata === null || metadata === void 0 ? void 0 : metadata.ls_model_name) || "unknown";
+            const spanName = `trace.langchain.${modelType}`;
+            const span = this.tracer.startSpan(spanName);
+            const attributes = {
+                "gen_ai.system": this.extractProvider(llm),
+                "gen_ai.operation.name": modelType,
+                "gen_ai.request.model": modelName,
+                external_customer_id: externalCustomerId,
+                token: token,
+            };
+            if (externalAgentId) {
+                attributes["external_agent_id"] = externalAgentId;
+            }
+            span.setAttributes(attributes);
+            this.spans.set(runId, span);
+        });
+    }
+    handleLLMEnd(output, runId, parentRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const span = this.spans.get(runId);
+            if (!span)
+                return;
+            try {
+                const attributes = {};
+                // Extract token usage information
+                if ((_a = output.llmOutput) === null || _a === void 0 ? void 0 : _a.tokenUsage) {
+                    const usage = output.llmOutput.tokenUsage;
+                    if (usage.promptTokens !== undefined) {
+                        attributes["gen_ai.usage.input_tokens"] = usage.promptTokens;
+                    }
+                    if (usage.completionTokens !== undefined) {
+                        attributes["gen_ai.usage.output_tokens"] = usage.completionTokens;
+                    }
+                    if (usage.cachedInputTokens !== undefined) {
+                        attributes["gen_ai.usage.cached_input_tokens"] = usage.cachedInputTokens;
+                    }
+                    if (usage.reasoningOutputTokens !== undefined) {
+                        attributes["gen_ai.usage.reasoning_output_tokens"] = usage.reasoningOutputTokens;
+                    }
+                }
+                // Alternative token usage format (some providers use different field names)
+                if ((_b = output.llmOutput) === null || _b === void 0 ? void 0 : _b.token_usage) {
+                    const usage = output.llmOutput.token_usage;
+                    if (usage.prompt_tokens !== undefined) {
+                        attributes["gen_ai.usage.input_tokens"] = usage.prompt_tokens;
+                    }
+                    if (usage.completion_tokens !== undefined) {
+                        attributes["gen_ai.usage.output_tokens"] = usage.completion_tokens;
+                    }
+                    if (usage.cached_input_tokens !== undefined) {
+                        attributes["gen_ai.usage.cached_input_tokens"] = usage.cached_input_tokens;
+                    }
+                    if (usage.reasoning_output_tokens !== undefined) {
+                        attributes["gen_ai.usage.reasoning_output_tokens"] = usage.reasoning_output_tokens;
+                    }
+                }
+                // Add model from response if available
+                if ((_c = output.llmOutput) === null || _c === void 0 ? void 0 : _c.modelName) {
+                    attributes["gen_ai.response.model"] = output.llmOutput.modelName;
+                }
+                else if ((_d = output.llmOutput) === null || _d === void 0 ? void 0 : _d.model_name) {
+                    attributes["gen_ai.response.model"] = output.llmOutput.model_name;
+                }
+                else if ((_j = (_h = (_g = (_f = (_e = output.generations) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.message) === null || _h === void 0 ? void 0 : _h["response_metadata"]) === null || _j === void 0 ? void 0 : _j.model_name) {
+                    attributes["gen_ai.response.model"] = output.generations[0][0].message["response_metadata"].model_name;
+                }
+                span.setAttributes(attributes);
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+            }
+            finally {
+                span.end();
+                this.spans.delete(runId);
+            }
+        });
+    }
+    handleLLMError(err, runId, parentRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const span = this.spans.get(runId);
+            if (!span)
+                return;
+            try {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: err.message });
+                span.recordException(err);
+            }
+            finally {
+                span.end();
+                this.spans.delete(runId);
+            }
+        });
+    }
+}
+exports.PaidLangChainCallback = PaidLangChainCallback;

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

@@ -0,0 +1,17 @@
+import { Mistral } from "@mistralai/mistralai";
+import { Tracer } from "@opentelemetry/api";
+import { OCRRequest, OCRResponse } from "@mistralai/mistralai/models/components";
+import { RequestOptions } from "@mistralai/mistralai/lib/sdks";
+export declare class PaidMistral {
+    private readonly mistral;
+    private readonly tracer;
+    constructor(mistralClient: Mistral);
+    get ocr(): OCRWrapper;
+}
+declare class OCRWrapper {
+    private mistral;
+    private tracer;
+    constructor(mistral: Mistral, tracer: Tracer);
+    process(request: OCRRequest, options?: RequestOptions): Promise<OCRResponse>;
+}
+export {};

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

@@ -0,0 +1,85 @@
+"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 = api_1.trace.getTracer("paid.node");
+    }
+    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 currentSpan = api_1.trace.getSpan(api_1.context.active());
+            if (!currentSpan) {
+                throw new Error("No active span found, make sure to call this inside of a callback to paid.trace().");
+            }
+            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,7 +11,7 @@ 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;
@@ -49,23 +49,23 @@ class ChatCompletionsWrapper {
         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);
+                throw new Error("No active span found, make sure to call this inside of 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* () {
+            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.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,36 +99,42 @@ class ResponsesWrapper {
     }
     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);
+                throw new Error("No active span found, make sure to call this inside of 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.responses ${model}`;
-            return this.tracer.startActiveSpan(spanName, (span) => __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.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 {
                     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.usage.input_tokens": response.usage.input_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.output_tokens,
                             "gen_ai.response.model": response.model,
                         });
+                        if ((_a = response.usage.input_tokens_details) === null || _a === void 0 ? void 0 : _a.cached_tokens) {
+                            span.setAttribute("gen_ai.usage.cached_input_tokens", response.usage.input_tokens_details.cached_tokens);
+                        }
+                        if ((_b = response.usage.output_tokens_details) === null || _b === void 0 ? void 0 : _b.reasoning_tokens) {
+                            span.setAttribute("gen_ai.usage.reasoning_output_tokens", response.usage.output_tokens_details.reasoning_tokens);
+                        }
                     }
                     span.setStatus({ code: api_1.SpanStatusCode.OK });
                     return response;
@@ -152,26 +158,25 @@ 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);
+                throw new Error("No active span found, make sure to call this inside of a callback to paid.trace().");
+            }
+            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 {
@@ -207,25 +212,26 @@ class ImagesWrapper {
             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);
+                throw new Error("No active span found, make sure to call this inside of a callback to paid.trace().");
             }
-            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-alpha0";
+export declare const SDK_VERSION = "0.0.8-alpha2";

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-alpha0";
+exports.SDK_VERSION = "0.0.8-alpha2";

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,8 @@ 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;
+    getSpanProcessorAndInitialize(collectorEndpoint?: string): Promise<import("@opentelemetry/sdk-trace-base").SpanProcessor>;
 }

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, _getSpanProcessorAndInitialize } 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,33 @@ export class PaidClient {
         var _a;
         return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new Usage(this._options)));
     }
+    // Use this method if you want paid to initialize tracing automatically.
     initializeTracing() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (collectorEndpoint = "https://collector.agentpaid.io:4318/v1/traces") {
             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);
+    }
+    // Use this method if you're setting up OTEL SDK in your code and want to add Paid's span processor.
+    getSpanProcessorAndInitialize() {
+        return __awaiter(this, arguments, void 0, function* (collectorEndpoint = "https://collector.agentpaid.io:4318/v1/traces") {
+            const tokenSupplier = this._options.token;
+            const token = typeof tokenSupplier === "function" ? yield tokenSupplier() : tokenSupplier;
+            const resolvedToken = yield Promise.resolve(token);
+            return _getSpanProcessorAndInitialize(resolvedToken, collectorEndpoint);
         });
     }
 }

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,46 @@
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "./tracing.mjs";
+export function _signal(eventName, data) {
+    if (!eventName) {
+        throw new Error("Event name is required for signal.");
+    }
+    // Check if there's an active span (from _trace())
+    const currentSpan = trace.getActiveSpan();
+    if (!currentSpan) {
+        throw new Error("Cannot send signal: you should call signal() within trace()");
+    }
+    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 = trace.getTracer("paid.node");
+    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,9 @@
-export declare const getCustomerId: () => string | null | undefined;
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import winston from "winston";
+export declare const logger: winston.Logger;
+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 _getSpanProcessorAndInitialize(apiKey: string, collectorEndpoint: string): SpanProcessor;
+export declare function _trace<T extends (...args: any[]) => any>(externalCustomerId: string, fn: T, externalAgentId: string | undefined, ...args: Parameters<T>): Promise<ReturnType<T>>;