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

package/README.md

@@ -7,7 +7,7 @@
     </picture>
 </div>
 
-# 
+#
 
 <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">
@@ -18,8 +18,8 @@
     </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. 
+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
 
@@ -33,7 +33,7 @@ npm install -s @paid-ai/paid-node
 
 ## Usage
 
-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). 
+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";
@@ -78,17 +78,18 @@ try {
 }
 ```
 
+## Logging
+Logs are silent by default.
+
+To enable logs, set the `PAID_LOG_LEVEL` environment variable. Available levels include:
+`error`, `warn`, `info`, `http`, `verbose`, `debug`, and `silly`.
+
+Example: `PAID_LOG_LEVEL=debug node your-app.js`
+
 ## 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()
-```
+As of now, the following AI providers are supported: `OpenAI`, `Anthropic`, `Mistral` (OCR), and `Langchain`.
 
 Example usage:
 
@@ -98,16 +99,16 @@ 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 openaiClient = new OpenAI({ apiKey: "<your_openai_api_key" });
     const paidOpenAiWrapper = new PaidOpenAI(openaiClient);
 
-    // capture the call
-    await client.capture("<your_external_customer_id>", async () => {
+    // trace the call
+    await client.trace("<your_external_customer_id>", async () => {
         const response = await paidOpenAiWrapper.images.generate({
             prompt: "A beautiful sunset over the mountains",
             n: 1,
@@ -116,7 +117,7 @@ async function main() {
         if (response.data) {
             console.log("Image generation:", response.data[0].url);
         }
-    });
+    }, "<optional_external_agent_id>");
 }
 ```
 

package/dist/cjs/Client.d.ts

@@ -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/cjs/Client.js

@@ -54,6 +54,7 @@ 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");
+const signal_js_1 = require("./tracing/signal.js");
 class PaidClient {
     constructor(_options) {
         this._options = Object.assign(Object.assign({}, _options), { headers: (0, headers_js_1.mergeHeaders)({
@@ -85,17 +86,33 @@ class PaidClient {
         var _a;
         return ((_a = this._usage) !== null && _a !== void 0 ? _a : (this._usage = new BatchUsage_js_1.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);
-            (0, tracing_js_1.initializeTracing)(resolvedToken);
+            (0, tracing_js_1._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 (0, tracing_js_1.capture)(externalCustomerId, fn, ...args);
+            return yield (0, tracing_js_1._trace)(externalCustomerId, fn, externalAgentId, ...args);
+        });
+    }
+    // sends Paid signal. This needs to called as part of callback to Paid.trace()
+    signal(eventName, data) {
+        return (0, signal_js_1._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 (0, tracing_js_1._getSpanProcessorAndInitialize)(resolvedToken, collectorEndpoint);
         });
     }
 }

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.capture = exports.initializeTracing = exports.PaidOpenAI = exports.PaidEnvironment = exports.PaidTimeoutError = exports.PaidError = exports.PaidClient = exports.Paid = void 0;
+exports.PaidLangChainCallback = exports.PaidMistral = exports.PaidAnthropic = 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; } });
@@ -44,6 +44,9 @@ 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; } });
+var anthropicWrapper_js_1 = require("./tracing/wrappers/anthropicWrapper.js");
+Object.defineProperty(exports, "PaidAnthropic", { enumerable: true, get: function () { return anthropicWrapper_js_1.PaidAnthropic; } });
+var mistralWrapper_js_1 = require("./tracing/wrappers/mistralWrapper.js");
+Object.defineProperty(exports, "PaidMistral", { enumerable: true, get: function () { return mistralWrapper_js_1.PaidMistral; } });
+var langchainCallback_js_1 = require("./tracing/wrappers/langchainCallback.js");
+Object.defineProperty(exports, "PaidLangChainCallback", { enumerable: true, get: function () { return langchainCallback_js_1.PaidLangChainCallback; } });

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

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

package/dist/cjs/tracing/signal.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._signal = _signal;
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("./tracing.js");
+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 = api_1.trace.getActiveSpan();
+    if (!currentSpan) {
+        throw new Error("Cannot send signal: you should call signal() within trace()");
+    }
+    const externalCustomerId = (0, tracing_js_1.getCustomerIdStorage)();
+    const externalAgentId = (0, tracing_js_1.getAgentIdStorage)();
+    const token = (0, tracing_js_1.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 = api_1.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: api_1.SpanStatusCode.OK });
+        }
+        catch (error) {
+            span.setStatus({
+                code: api_1.SpanStatusCode.ERROR,
+                message: error.message,
+            });
+            span.recordException(error);
+        }
+        finally {
+            span.end();
+        }
+    });
+}

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

@@ -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>>;

package/dist/cjs/tracing/tracing.js

@@ -8,56 +8,128 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTokenStorage = exports.getCustomerId = void 0;
-exports.initializeTracing = initializeTracing;
-exports.capture = capture;
+exports.getTokenStorage = exports.getAgentIdStorage = exports.getCustomerIdStorage = exports.logger = void 0;
+exports._initializeTracing = _initializeTracing;
+exports._getSpanProcessorAndInitialize = _getSpanProcessorAndInitialize;
+exports._trace = _trace;
 const sdk_node_1 = require("@opentelemetry/sdk-node");
 const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
 const api_1 = require("@opentelemetry/api");
 const async_hooks_1 = require("async_hooks");
+const winston_1 = __importDefault(require("winston"));
+exports.logger = winston_1.default.createLogger({
+    level: "silent", // Default to 'silent' to avoid logging unless set via environment variable
+    format: winston_1.default.format.simple(),
+    transports: [new winston_1.default.transports.Console()],
+});
+const logLevel = process.env.PAID_LOG_LEVEL;
+if (logLevel) {
+    exports.logger.level = logLevel;
+}
+// storage for passing info to child spans
 const customerIdStorage = new async_hooks_1.AsyncLocalStorage();
+const agentIdStorage = new async_hooks_1.AsyncLocalStorage();
 const tokenStorage = new async_hooks_1.AsyncLocalStorage();
-const getCustomerId = () => customerIdStorage.getStore();
-exports.getCustomerId = getCustomerId;
+const getCustomerIdStorage = () => customerIdStorage.getStore();
+exports.getCustomerIdStorage = getCustomerIdStorage;
+const getAgentIdStorage = () => agentIdStorage.getStore();
+exports.getAgentIdStorage = getAgentIdStorage;
 const getTokenStorage = () => tokenStorage.getStore();
 exports.getTokenStorage = getTokenStorage;
 let _token;
-const setToken = (token) => { _token = token; };
-const getToken = () => { return _token; };
-function initializeTracing(apiKey) {
-    setToken(apiKey);
+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, () => {
+            if (_isShuttingDown) {
+                return;
+            }
+            _isShuttingDown = true;
+            shuttable
+                .shutdown()
+                .then(() => exports.logger.info(`Paid tracing SDK shut down from signal: ${signal}`))
+                .catch((error) => exports.logger.error(`Error shutting down Paid tracing SDK ${error}`));
+        });
+    });
+}
+function isOTELInitialized() {
+    const provider = api_1.trace.getTracerProvider();
+    if (!provider) {
+        return false;
+    }
+    if (provider.constructor.name !== "ProxyTracerProvider" && provider.constructor.name !== "NodeTracerProvider") {
+        return true;
+    }
+    if (provider._delegate) {
+        return provider._delegate.constructor.name !== "NoopTracerProvider";
+    }
+    return false;
+}
+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");
+    }
+    try {
+        new URL(collectorEndpoint);
+    }
+    catch (_a) {
+        throw new Error(`Collector endpoint [${collectorEndpoint}] must be a valid URL`);
+    }
+    if (isOTELInitialized()) {
+        throw new Error("OTEL SDK is already initialized with a different provider.\n" +
+            "If you're already using OTEL in your code - " +
+            "please use function Paid.getSpanProcessorAndInitialize() " +
+            "and add the span processor to your OTEL SDK initialization");
+    }
     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',
+            url: collectorEndpoint,
         }),
     });
     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));
-        });
-    });
+    setupGracefulShutdown(sdk);
+    setToken(apiKey);
+    exports.logger.info(`Paid tracing SDK initialized with collector endpoint: ${collectorEndpoint}`);
+}
+function _getSpanProcessorAndInitialize(apiKey, collectorEndpoint) {
+    setToken(apiKey);
+    const spanProcessor = new sdk_trace_base_1.BatchSpanProcessor(new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: collectorEndpoint }));
+    setupGracefulShutdown(spanProcessor);
+    return spanProcessor;
 }
-function capture(externalCustomerId, fn, ...args) {
+function _trace(externalCustomerId, fn, externalAgentId, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tracer = api_1.trace.getTracer('paid.node');
+        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);
+        if (!token || !externalCustomerId) {
+            throw new Error(`Token [${token}] or external customer ID [${externalCustomerId}] is missing`);
         }
         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: api_1.SpanStatusCode.OK });

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

@@ -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/cjs/tracing/wrappers/anthropicWrapper.js

@@ -0,0 +1,88 @@
+"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.PaidAnthropic = void 0;
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("../tracing.js");
+class PaidAnthropic {
+    constructor(anthropicClient) {
+        this.anthropic = anthropicClient;
+        this.tracer = api_1.trace.getTracer("paid.node");
+    }
+    get messages() {
+        return new MessagesWrapper(this.anthropic, this.tracer);
+    }
+}
+exports.PaidAnthropic = PaidAnthropic;
+class MessagesWrapper {
+    constructor(anthropic, tracer) {
+        this.anthropic = anthropic;
+        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) {
+                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.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: 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/langchainCallback.d.ts

@@ -0,0 +1,21 @@
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+interface SerializedData {
+    id?: string[];
+    [key: string]: any;
+}
+interface Metadata {
+    ls_model_type?: string;
+    ls_model_name?: string;
+    [key: string]: any;
+}
+export declare class PaidLangChainCallback extends BaseCallbackHandler {
+    name: string;
+    private tracer;
+    private spans;
+    constructor();
+    private extractProvider;
+    handleLLMStart(llm: SerializedData, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Metadata): Promise<void>;
+    handleLLMEnd(output: any, runId: string, parentRunId?: string): Promise<void>;
+    handleLLMError(err: Error, runId: string, parentRunId?: string): Promise<void>;
+}
+export {};