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

package/dist/esm/tracing/tracing.mjs

@@ -7,50 +7,117 @@ 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 { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { trace, SpanStatusCode } from "@opentelemetry/api";
-import { AsyncLocalStorage } from 'async_hooks';
+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;
+}
+// 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 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(() => logger.info(`Paid tracing SDK shut down from signal: ${signal}`))
+                .catch((error) => logger.error(`Error shutting down Paid tracing SDK ${error}`));
+        });
+    });
+}
+function isOTELInitialized() {
+    const provider = 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;
+}
+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");
+    }
+    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 NodeSDK({
         traceExporter: new 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);
+    logger.info(`Paid tracing SDK initialized with collector endpoint: ${collectorEndpoint}`);
+}
+export function _getSpanProcessorAndInitialize(apiKey, collectorEndpoint) {
+    setToken(apiKey);
+    const spanProcessor = new BatchSpanProcessor(new OTLPTraceExporter({ url: collectorEndpoint }));
+    setupGracefulShutdown(spanProcessor);
+    return spanProcessor;
 }
-export function capture(externalCustomerId, fn, ...args) {
+export function _trace(externalCustomerId, fn, externalAgentId, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tracer = trace.getTracer('paid.node');
+        const tracer = 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: 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,84 @@
+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 { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "../tracing.mjs";
+export class PaidAnthropic {
+    constructor(anthropicClient) {
+        this.anthropic = anthropicClient;
+        this.tracer = trace.getTracer("paid.node");
+    }
+    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 currentSpan = trace.getSpan(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 = 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();
+                }
+            }));
+        });
+    }
+}

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

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

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

@@ -0,0 +1,142 @@
+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 { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { trace, SpanStatusCode, context } from "@opentelemetry/api";
+import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "../tracing.mjs";
+export class PaidLangChainCallback extends BaseCallbackHandler {
+    constructor() {
+        super();
+        this.name = "PaidLangChainCallback";
+        this.spans = new Map();
+        this.tracer = 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 = trace.getSpan(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 = 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().");
+            }
+            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: 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: SpanStatusCode.ERROR, message: err.message });
+                span.recordException(err);
+            }
+            finally {
+                span.end();
+                this.spans.delete(runId);
+            }
+        });
+    }
+}

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

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

@@ -0,0 +1,81 @@
+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 { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "../tracing.mjs";
+export class PaidMistral {
+    constructor(mistralClient) {
+        this.mistral = mistralClient;
+        this.tracer = trace.getTracer("paid.node");
+    }
+    get ocr() {
+        return new OCRWrapper(this.mistral, this.tracer);
+    }
+}
+class OCRWrapper {
+    constructor(mistral, tracer) {
+        this.mistral = mistral;
+        this.tracer = tracer;
+    }
+    process(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentSpan = trace.getSpan(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 = 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.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: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}