@paid-ai/paid-node 0.5.0-alpha2 → 0.5.0

package/dist/esm/integrations/adapters/expressjs/routes.d.mts

@@ -0,0 +1,162 @@
+/**
+ * ExpressJS route helpers for Paid SDK
+ * These functions create handlers compatible with ExpressJS controllers
+ */
+import { Request, Response } from "express";
+import { BaseHandlerConfig } from "../../utils/base-handler.mjs";
+import { OrderOptions } from "../../types.mjs";
+export interface ActivateOrderSyncRouteConfig extends BaseHandlerConfig {
+    defaultReturnUrl?: string;
+}
+/**
+ * Create an Express handler for synchronous order activation
+ *
+ * Use this in your Express app to handle order activation with payment.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createActivateOrderSyncRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * const activateOrderSyncHandler = createActivateOrderSyncRoute();
+ *
+ * app.post('/paid/payments/activate-order-sync', activateOrderSyncHandler);
+ * ```
+ *
+ * @example With NestJS
+ * ```typescript
+ * import { Controller, Post, Req, Res } from '@nestjs/common';
+ * import { Request, Response } from 'express';
+ * import { createActivateOrderSyncRoute } from '@paid-ai/paid-node/integrations/nestjs';
+ *
+ * @Controller('paid/payments')
+ * export class PaymentsController {
+ *   private activateOrderSyncHandler = createActivateOrderSyncRoute();
+ *
+ *   @Post('activate-order-sync')
+ *   async activateOrderSync(@Req() req: Request, @Res() res: Response) {
+ *     return this.activateOrderSyncHandler(req, res);
+ *   }
+ * }
+ * ```
+ */
+export declare function createActivateOrderSyncRoute(config?: ActivateOrderSyncRouteConfig): (req: Request, res: Response) => Promise<any>;
+/**
+ * Create an Express handler for contact creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createContactsRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/contacts', createContactsRoute());
+ * ```
+ */
+export declare function createContactsRoute(config?: BaseHandlerConfig): (req: Request, res: Response) => Promise<any>;
+/**
+ * Create an Express handler for fetching customer invoices
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createCustomerInvoicesRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.get('/paid/customers/:customerExternalId/invoices', createCustomerInvoicesRoute());
+ * ```
+ */
+export declare function createCustomerInvoicesRoute(config?: BaseHandlerConfig): (req: Request, res: Response) => Promise<any>;
+/**
+ * Create an Express handler for fetching a customer by external ID
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createGetCustomerRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.get('/paid/customers/:customerExternalId', createGetCustomerRoute());
+ * ```
+ */
+export declare function createGetCustomerRoute(config?: BaseHandlerConfig): (req: Request, res: Response) => Promise<any>;
+/**
+ * Create an Express handler for customer creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createCustomersRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/customers', createCustomersRoute());
+ * ```
+ */
+export declare function createCustomersRoute(config?: BaseHandlerConfig): (req: Request, res: Response) => Promise<any>;
+export interface OrdersRouteConfig extends BaseHandlerConfig {
+    helperOptions?: OrderOptions;
+}
+/**
+ * Create an Express handler for order creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createOrdersRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/orders', createOrdersRoute({ helperOptions: { autoActivate: true } }));
+ * ```
+ */
+export declare function createOrdersRoute(config?: OrdersRouteConfig): (req: Request, res: Response) => Promise<any>;
+/**
+ * Create an Express handler for invoice payment
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createPayInvoiceRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/invoices/:invoiceId/pay', createPayInvoiceRoute());
+ * ```
+ */
+export declare function createPayInvoiceRoute(config?: BaseHandlerConfig): (req: Request, res: Response) => Promise<any>;
+export interface ProvisioningRouteConfig extends BaseHandlerConfig {
+    defaultAgentExternalId?: string;
+    orderOptions?: OrderOptions;
+}
+/**
+ * Create an Express handler for user provisioning
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createProvisioningRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/provision', createProvisioningRoute({
+ *   defaultAgentExternalId: process.env.PAID_AGENT_ID
+ * }));
+ * ```
+ */
+export declare function createProvisioningRoute(config?: ProvisioningRouteConfig): (req: Request, res: Response) => Promise<any>;
+export interface SetupIntentRouteConfig extends BaseHandlerConfig {
+    defaultReturnUrl?: string;
+}
+/**
+ * Create an Express handler for setup intent creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createSetupIntentRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/payments/setup-intent', createSetupIntentRoute({
+ *   defaultReturnUrl: process.env.APP_URL + '/billing'
+ * }));
+ * ```
+ */
+export declare function createSetupIntentRoute(config?: SetupIntentRouteConfig): (req: Request, res: Response) => Promise<any>;

package/dist/esm/integrations/adapters/expressjs/routes.mjs

@@ -0,0 +1,258 @@
+/**
+ * ExpressJS route helpers for Paid SDK
+ * These functions create handlers compatible with ExpressJS controllers
+ */
+import { createExpressJSResponseContext } from "./base-adapter.mjs";
+import { createContactsHandler } from "../../controllers/contacts.mjs";
+import { createCustomerInvoicesHandler } from "../../controllers/invoices.mjs";
+import { createCustomersHandler, createGetCustomerHandler } from "../../controllers/customers.mjs";
+import { createOrdersHandler } from "../../controllers/orders.mjs";
+import { createProvisioningHandler } from "../../controllers/provision-users.mjs";
+import { createActivateOrderSyncHandler, createPayInvoiceHandler, createSetupIntentHandler, } from "../../controllers/billing.mjs";
+/**
+ * Helper to extract headers from Express Request
+ */
+function extractHeaders(req) {
+    const headers = {};
+    Object.entries(req.headers).forEach(([key, value]) => {
+        if (typeof value === "string") {
+            headers[key] = value;
+        }
+        else if (Array.isArray(value)) {
+            headers[key] = value.join(", ");
+        }
+    });
+    return headers;
+}
+/**
+ * Create an Express handler for synchronous order activation
+ *
+ * Use this in your Express app to handle order activation with payment.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createActivateOrderSyncRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * const activateOrderSyncHandler = createActivateOrderSyncRoute();
+ *
+ * app.post('/paid/payments/activate-order-sync', activateOrderSyncHandler);
+ * ```
+ *
+ * @example With NestJS
+ * ```typescript
+ * import { Controller, Post, Req, Res } from '@nestjs/common';
+ * import { Request, Response } from 'express';
+ * import { createActivateOrderSyncRoute } from '@paid-ai/paid-node/integrations/nestjs';
+ *
+ * @Controller('paid/payments')
+ * export class PaymentsController {
+ *   private activateOrderSyncHandler = createActivateOrderSyncRoute();
+ *
+ *   @Post('activate-order-sync')
+ *   async activateOrderSync(@Req() req: Request, @Res() res: Response) {
+ *     return this.activateOrderSyncHandler(req, res);
+ *   }
+ * }
+ * ```
+ */
+export function createActivateOrderSyncRoute(config = {}) {
+    const handler = createActivateOrderSyncHandler(config.defaultReturnUrl);
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for contact creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createContactsRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/contacts', createContactsRoute());
+ * ```
+ */
+export function createContactsRoute(config = {}) {
+    const handler = createContactsHandler();
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for fetching customer invoices
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createCustomerInvoicesRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.get('/paid/customers/:customerExternalId/invoices', createCustomerInvoicesRoute());
+ * ```
+ */
+export function createCustomerInvoicesRoute(config = {}) {
+    const handler = createCustomerInvoicesHandler();
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "GET",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for fetching a customer by external ID
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createGetCustomerRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.get('/paid/customers/:customerExternalId', createGetCustomerRoute());
+ * ```
+ */
+export function createGetCustomerRoute(config = {}) {
+    const handler = createGetCustomerHandler();
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "GET",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for customer creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createCustomersRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/customers', createCustomersRoute());
+ * ```
+ */
+export function createCustomersRoute(config = {}) {
+    const handler = createCustomersHandler();
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for order creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createOrdersRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/orders', createOrdersRoute({ helperOptions: { autoActivate: true } }));
+ * ```
+ */
+export function createOrdersRoute(config = {}) {
+    const handler = createOrdersHandler(config.helperOptions);
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for invoice payment
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createPayInvoiceRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/invoices/:invoiceId/pay', createPayInvoiceRoute());
+ * ```
+ */
+export function createPayInvoiceRoute(config = {}) {
+    const handler = createPayInvoiceHandler();
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for user provisioning
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createProvisioningRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/provision', createProvisioningRoute({
+ *   defaultAgentExternalId: process.env.PAID_AGENT_ID
+ * }));
+ * ```
+ */
+export function createProvisioningRoute(config = {}) {
+    const handler = createProvisioningHandler(config.orderOptions, config.defaultAgentExternalId);
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}
+/**
+ * Create an Express handler for setup intent creation
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createSetupIntentRoute } from '@paid-ai/paid-node/integrations/express';
+ *
+ * const app = express();
+ * app.post('/paid/payments/setup-intent', createSetupIntentRoute({
+ *   defaultReturnUrl: process.env.APP_URL + '/billing'
+ * }));
+ * ```
+ */
+export function createSetupIntentRoute(config = {}) {
+    const handler = createSetupIntentHandler(config.defaultReturnUrl);
+    return (req, res) => {
+        return handler({
+            body: req.body,
+            headers: extractHeaders(req),
+            method: "POST",
+            params: req.params,
+        }, createExpressJSResponseContext(res), config);
+    };
+}

package/dist/esm/integrations/adapters/nestjs/index.d.mts

@@ -0,0 +1,7 @@
+/**
+ * NestJS integration for Paid SDK
+ *
+ * NestJS uses Express under the hood, so this is a re-export of the Express adapter.
+ * All functionality is identical to the Express adapter.
+ */
+export * from "../expressjs/index.mjs";

package/dist/esm/integrations/adapters/nestjs/index.mjs

@@ -0,0 +1,7 @@
+/**
+ * NestJS integration for Paid SDK
+ *
+ * NestJS uses Express under the hood, so this is a re-export of the Express adapter.
+ * All functionality is identical to the Express adapter.
+ */
+export * from "../expressjs/index.mjs";

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

@@ -0,0 +1,10 @@
+import type * as openai from "openai";
+import type * as anthropic from "@anthropic-ai/sdk";
+import type * as bedrock from "@aws-sdk/client-bedrock-runtime";
+interface SupportedLibraries {
+    openai?: typeof openai.OpenAI;
+    anthropic?: typeof anthropic.Anthropic;
+    bedrock?: typeof bedrock;
+}
+export declare function paidAutoInstrument(libraries?: SupportedLibraries): void;
+export {};

package/dist/esm/tracing/autoInstrumentation.mjs

@@ -0,0 +1,54 @@
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { OpenAIInstrumentation } from "@arizeai/openinference-instrumentation-openai";
+import { BedrockInstrumentation } from "@traceloop/instrumentation-bedrock";
+import { AnthropicInstrumentation } from "@arizeai/openinference-instrumentation-anthropic";
+import { getPaidTracerProvider, initializeTracing, logger } from "./tracing";
+let IS_INITIALIZED = false;
+const getInstrumentations = (tracerProvider) => {
+    const instrumentations = [
+        new OpenAIInstrumentation({ tracerProvider }),
+        new AnthropicInstrumentation({ tracerProvider }),
+        new BedrockInstrumentation(),
+    ];
+    return instrumentations;
+};
+const getManualInstrumentations = (tracerProvider, libraries) => {
+    const instrumentations = [];
+    if (libraries.openai) {
+        const openaiInstrumentation = new OpenAIInstrumentation({ tracerProvider });
+        instrumentations.push(openaiInstrumentation);
+        openaiInstrumentation.manuallyInstrument(libraries.openai);
+    }
+    if (libraries.anthropic) {
+        const anthropicInstrumentation = new AnthropicInstrumentation({ tracerProvider });
+        instrumentations.push(anthropicInstrumentation);
+        anthropicInstrumentation.manuallyInstrument(libraries.anthropic);
+    }
+    if (libraries.bedrock) {
+        const bedrockInstrumentation = new BedrockInstrumentation();
+        instrumentations.push(bedrockInstrumentation);
+        bedrockInstrumentation.manuallyInstrument(libraries.bedrock);
+    }
+    return instrumentations;
+};
+export function paidAutoInstrument(libraries) {
+    if (IS_INITIALIZED) {
+        logger.info("Auto instrumentation is already initialized");
+        return;
+    }
+    initializeTracing(); // try initializing tracing
+    const tracerProvider = getPaidTracerProvider();
+    if (!tracerProvider) {
+        logger.error("Could not get tracer provider, make sure you ran 'initializeTracing()' or check your environment variables");
+        return;
+    }
+    const isManualInstrumentation = libraries && Object.keys(libraries).length > 0;
+    const instrumentations = isManualInstrumentation
+        ? getManualInstrumentations(tracerProvider, libraries)
+        : getInstrumentations(tracerProvider);
+    registerInstrumentations({
+        instrumentations,
+        tracerProvider,
+    });
+    IS_INITIALIZED = true;
+}

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

@@ -0,0 +1,4 @@
+import { getPaidTracer, getPaidTracerProvider, initializeTracing, trace } from "./tracing.mjs";
+import { paidAutoInstrument } from "./autoInstrumentation.mjs";
+import { signal } from "./signal.mjs";
+export { getPaidTracer, getPaidTracerProvider, initializeTracing, trace, signal, paidAutoInstrument };

package/dist/esm/tracing/index.mjs

@@ -0,0 +1,4 @@
+import { getPaidTracer, getPaidTracerProvider, initializeTracing, trace } from "./tracing.mjs";
+import { paidAutoInstrument } from "./autoInstrumentation.mjs";
+import { signal } from "./signal.mjs";
+export { getPaidTracer, getPaidTracerProvider, initializeTracing, trace, signal, paidAutoInstrument };

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

@@ -1 +1,18 @@
-export declare function _signal(eventName: string, enableCostTracing: boolean, data?: Record<string, any>): void;
+/**
+ * Sends Paid signal. Needs to be called as part of callback to trace().
+ * When enableCostTracing flag is on, signal is associated
+ * with cost traces from the same Paid.trace() context.
+ *
+ * @param eventName - The name of the signal.
+ * @param enableCostTracing - Whether to associate this signal with cost traces
+ * from the current Paid.trace() context (default: false)
+ * @param data - Optional additional data to include with the signal
+ *
+ * @remarks
+ * When enableCostTracing is on, the signal will be associated with cost
+ * traces within the same Paid.trace() context.
+ * It is advised to only make one call to this function
+ * with enableCostTracing per Paid.trace() context.
+ * Otherwise, there will be multiple signals that refer to the same costs.
+ */
+export declare function signal(eventName: string, enableCostTracing?: boolean, data?: Record<string, any>): void;

package/dist/esm/tracing/signal.mjs

@@ -1,21 +1,38 @@
 import { SpanStatusCode } from "@opentelemetry/api";
-import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "./tracing.mjs";
-import { paidTracer } from "./tracing.mjs";
-export function _signal(eventName, enableCostTracing, data) {
-    if (!eventName) {
-        throw new Error("Event name is required for signal.");
+import { getPaidTracer, getToken } from "./tracing.mjs";
+import { getTracingContext } from "./tracingContext.mjs";
+/**
+ * Sends Paid signal. Needs to be called as part of callback to trace().
+ * When enableCostTracing flag is on, signal is associated
+ * with cost traces from the same Paid.trace() context.
+ *
+ * @param eventName - The name of the signal.
+ * @param enableCostTracing - Whether to associate this signal with cost traces
+ * from the current Paid.trace() context (default: false)
+ * @param data - Optional additional data to include with the signal
+ *
+ * @remarks
+ * When enableCostTracing is on, the signal will be associated with cost
+ * traces within the same Paid.trace() context.
+ * It is advised to only make one call to this function
+ * with enableCostTracing per Paid.trace() context.
+ * Otherwise, there will be multiple signals that refer to the same costs.
+ */
+export function signal(eventName, enableCostTracing = false, data) {
+    const paidTracer = getPaidTracer();
+    const token = getToken();
+    const { externalCustomerId, externalProductId } = getTracingContext();
+    if (!token || !paidTracer) {
+        throw new Error(`Tracing is not initialized. Make sure you called 'initializeTracing()'`);
     }
-    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()`);
+    if (!externalCustomerId || !externalProductId) {
+        throw new Error(`Missing some of: external_customer_id: ${externalCustomerId}, external_product_id: ${externalProductId}, or token. Make sure to call signal() within trace()`);
     }
     paidTracer.startActiveSpan("trace.signal", (span) => {
         try {
             const attributes = {
                 external_customer_id: externalCustomerId,
-                external_agent_id: externalAgentId,
+                external_agent_id: externalProductId,
                 event_name: eventName,
                 token: token,
             };
@@ -34,7 +51,6 @@ export function _signal(eventName, enableCostTracing, data) {
                 attributes["data"] = JSON.stringify(data);
             }
             span.setAttributes(attributes);
-            // Mark span as successful
             span.setStatus({ code: SpanStatusCode.OK });
         }
         catch (error) {

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

@@ -0,0 +1,10 @@
+import { Context } from "@opentelemetry/api";
+import { SpanProcessor, Span } from "@opentelemetry/sdk-trace-base";
+export declare class PaidSpanProcessor implements SpanProcessor {
+    private static readonly SPAN_NAME_PREFIX;
+    private static readonly PROMPT_ATTRIBUTES_SUBSTRINGS;
+    onStart(span: Span, _parentContext?: Context): void;
+    onEnd(): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/esm/tracing/spanProcessor.mjs

@@ -0,0 +1,78 @@
+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 { getTracingContext } from "./tracingContext.mjs";
+import { getToken } from "./tracing.mjs";
+export class PaidSpanProcessor {
+    onStart(span, _parentContext) {
+        const { name } = span;
+        const { storePrompt, externalCustomerId, externalProductId: externalAgentId } = getTracingContext();
+        if (!storePrompt) {
+            const originalSetAttribute = span.setAttribute;
+            span.setAttribute = function (key, value) {
+                const isPromptRelated = PaidSpanProcessor.PROMPT_ATTRIBUTES_SUBSTRINGS.some((substr) => key.includes(substr));
+                if (isPromptRelated)
+                    return this;
+                return originalSetAttribute.call(this, key, value);
+            };
+            const originalSetAttributes = span.setAttributes;
+            span.setAttributes = function (attributes) {
+                const newAttributes = Object.entries(attributes).reduce((acc, [key, value]) => {
+                    const isPromptRelated = PaidSpanProcessor.PROMPT_ATTRIBUTES_SUBSTRINGS.some((substr) => key.includes(substr));
+                    if (isPromptRelated)
+                        return acc;
+                    return Object.assign(Object.assign({}, acc), { [key]: value });
+                }, {});
+                return originalSetAttributes.call(this, newAttributes);
+            };
+        }
+        if (name && !name.startsWith(PaidSpanProcessor.SPAN_NAME_PREFIX)) {
+            span.updateName(`${PaidSpanProcessor.SPAN_NAME_PREFIX}${name}`);
+        }
+        if (externalCustomerId) {
+            span.setAttribute("external_customer_id", externalCustomerId);
+        }
+        if (externalAgentId) {
+            span.setAttribute("external_agent_id", externalAgentId);
+        }
+        const token = getToken();
+        if (token) {
+            span.setAttribute("token", token);
+        }
+    }
+    onEnd() {
+        // mutating this span object doesn't do anything
+        // so we achieve filtering within the onStart method by monkey patching
+        // setAttribute method
+        return;
+    }
+    shutdown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    forceFlush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+}
+PaidSpanProcessor.SPAN_NAME_PREFIX = "paid.trace.";
+PaidSpanProcessor.PROMPT_ATTRIBUTES_SUBSTRINGS = [
+    "gen_ai.completion",
+    "gen_ai.request.messages",
+    "gen_ai.response.messages",
+    "llm.output_message",
+    "llm.input_message",
+    "llm.invocation_parameters",
+    "gen_ai.prompt",
+    "langchain.prompt",
+    "output.value",
+    "input.value",
+];