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

package/README.md

@@ -136,16 +136,42 @@ const additionalData = {
         }
     }
 };
-await client.usage.recordUsage({
-    agent_id: "<your_agent_id>",
-    event_name: "<your_signal_name>",
-    customer_id: "<your_customer_id>",
-    data: additionalData,
+await client.usage.recordBulk({
+    signals: [{
+        agent_id: "<your_agent_id>",
+        event_name: "<your_signal_name>",
+        customer_id: "<your_customer_id>",
+        data: additionalData,
+    }]
 })
 
 await client.usage.flush(); // need to flush to send usage immediately
 ```
 
+## Send signals over OTLP
+
+Besides sending signals over REST, it's also possible to send signals as part or tracing
+context, just like with cost tracking.
+
+Example usage:
+
+```typescript
+import { PaidClient } from "@paid-ai/paid-node";
+
+async function main() {
+    const client = new PaidClient({ token: "<your_paid_api_key>" });
+
+    // initialize cost tracking
+    await client.initializeTracing()
+
+    // trace the call
+    await client.trace("<your_external_customer_id>", async () => {
+        // ... your app logic, cost tracking LLM wrapper calls
+        client.signal("signal_name", { "data": { // ... additional data, e.g. costs } });
+    }, "<optional_external_agent_id>");
+}
+```
+
 ## Advanced
 
 ### Additional Headers

package/dist/cjs/Client.d.ts

@@ -43,5 +43,24 @@ export declare class PaidClient {
     get usage(): Usage;
     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;
+    /**
+     * Sends Paid signal. Needs to be called as part of callback to Paid.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.
+     */
+    signal(eventName: string): void;
+    signal(eventName: string, data: Record<string, any>): void;
+    signal(eventName: string, enableCostTracing: boolean, data?: Record<string, any>): void;
 }

package/dist/cjs/Client.js

@@ -95,16 +95,28 @@ class PaidClient {
             (0, tracing_js_1._initializeTracing)(resolvedToken, collectorEndpoint);
         });
     }
-    // Use this method to track actions like LLM usage and sending signals.
+    // Use this method to track actions like LLM costs 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._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);
+    signal(eventName, enableCostTracingOrData, data) {
+        let enableCostTracing = false;
+        let finalData;
+        if (typeof enableCostTracingOrData === 'boolean') {
+            // Case: signal(eventName, boolean, data?)
+            enableCostTracing = enableCostTracingOrData;
+            finalData = data;
+        }
+        else if (typeof enableCostTracingOrData === 'object') {
+            // Case: signal(eventName, data)
+            enableCostTracing = false;
+            finalData = enableCostTracingOrData;
+        }
+        // Case: signal(eventName) - both remain default/undefined
+        return (0, signal_js_1._signal)(eventName, enableCostTracing, finalData);
     }
 }
 exports.PaidClient = PaidClient;

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

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

package/dist/cjs/tracing/signal.js

@@ -4,7 +4,7 @@ exports._signal = _signal;
 const api_1 = require("@opentelemetry/api");
 const tracing_js_1 = require("./tracing.js");
 const tracing_js_2 = require("./tracing.js");
-function _signal(eventName, data) {
+function _signal(eventName, enableCostTracing, data) {
     if (!eventName) {
         throw new Error("Event name is required for signal.");
     }
@@ -14,8 +14,7 @@ function _signal(eventName, data) {
     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 = tracing_js_2.paidTracer;
-    tracer.startActiveSpan("trace.signal", (span) => {
+    tracing_js_2.paidTracer.startActiveSpan("trace.signal", (span) => {
         try {
             const attributes = {
                 external_customer_id: externalCustomerId,
@@ -23,6 +22,16 @@ function _signal(eventName, data) {
                 event_name: eventName,
                 token: token,
             };
+            if (enableCostTracing) {
+                // let the app know to associate this signal with cost traces
+                attributes["enable_cost_tracing"] = true;
+                if (data === undefined) {
+                    data = { paid: { enable_cost_tracing: true } };
+                }
+                else {
+                    data["paid"] = { enable_cost_tracing: true };
+                }
+            }
             // Optional data (ex. manual cost tracking)
             if (data) {
                 attributes["data"] = JSON.stringify(data);

package/dist/cjs/tracing/tracing.js

@@ -35,6 +35,7 @@ const COLLECTOR_ENDPOINT = process.env.PAID_COLLECTOR_ENDPOINT || "https://colle
 let paidExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: COLLECTOR_ENDPOINT });
 let spanProcessor = new sdk_trace_base_1.BatchSpanProcessor(paidExporter);
 let paidTracerProvider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [spanProcessor] });
+paidTracerProvider.register();
 exports.paidTracer = paidTracerProvider.getTracer("paid.node");
 // storage for passing info to child spans
 const customerIdStorage = new async_hooks_1.AsyncLocalStorage();
@@ -79,6 +80,7 @@ function _initializeTracing(apiKey, collectorEndpoint) {
         paidExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({ url: collectorEndpoint });
         spanProcessor = new sdk_trace_base_1.BatchSpanProcessor(paidExporter);
         paidTracerProvider = new sdk_trace_node_1.NodeTracerProvider({ spanProcessors: [spanProcessor] });
+        paidTracerProvider.register();
         exports.paidTracer = paidTracerProvider.getTracer("paid.node");
     }
     setupGracefulShutdown(spanProcessor);
@@ -88,12 +90,11 @@ function _initializeTracing(apiKey, collectorEndpoint) {
 }
 function _trace(externalCustomerId, fn, externalAgentId, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tracer = exports.paidTracer;
         const token = getToken();
         if (!token || !externalCustomerId) {
             throw new Error(`Paid tracing is not initialized. Make sure to call initializeTracing() first.`);
         }
-        return tracer.startActiveSpan("paid.node", (span) => __awaiter(this, void 0, void 0, function* () {
+        return exports.paidTracer.startActiveSpan("paid.node", (span) => __awaiter(this, void 0, void 0, function* () {
             span.setAttribute("external_customer_id", externalCustomerId);
             span.setAttribute("token", token);
             if (externalAgentId) {

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

@@ -197,16 +197,15 @@ class ImagesWrapper {
     }
     generate(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             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 model = params.model || "";
             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;
+                var _a;
                 const attributes = {
                     "gen_ai.request.model": model,
                     "gen_ai.system": "openai",
@@ -222,8 +221,8 @@ class ImagesWrapper {
                     const response = yield this.openai.images.generate(params);
                     span.setAttributes({
                         "gen_ai.image.count": (_a = params.n) !== null && _a !== void 0 ? _a : 1,
-                        "gen_ai.image.size": (_b = params.size) !== null && _b !== void 0 ? _b : "1024x1024",
-                        "gen_ai.image.quality": (_c = params.quality) !== null && _c !== void 0 ? _c : "standard",
+                        "gen_ai.image.size": params.size || "",
+                        "gen_ai.image.quality": params.quality || "",
                     });
                     span.setStatus({ code: api_1.SpanStatusCode.OK });
                     return response;

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

@@ -0,0 +1,22 @@
+import { generateText as originalGenerateText, streamText as originalStreamText, generateObject as originalGenerateObject, streamObject as originalStreamObject, embed as originalEmbed, embedMany as originalEmbedMany } from "ai";
+type GenerateTextParams = Parameters<typeof originalGenerateText>[0];
+type StreamTextParams = Parameters<typeof originalStreamText>[0];
+type GenerateObjectParams = Parameters<typeof originalGenerateObject>[0];
+type StreamObjectParams = Parameters<typeof originalStreamObject>[0];
+type EmbedParams = Parameters<typeof originalEmbed>[0];
+type EmbedManyParams = Parameters<typeof originalEmbedMany>[0];
+export declare function generateText(params: GenerateTextParams): Promise<ReturnType<typeof originalGenerateText>>;
+export declare function streamText(params: StreamTextParams): Promise<ReturnType<typeof originalStreamText>>;
+export declare function generateObject(params: GenerateObjectParams): Promise<ReturnType<typeof originalGenerateObject>>;
+export declare function streamObject(params: StreamObjectParams): Promise<ReturnType<typeof originalStreamObject>>;
+export declare function embed(params: EmbedParams): Promise<ReturnType<typeof originalEmbed>>;
+export declare function embedMany(params: EmbedManyParams): Promise<ReturnType<typeof originalEmbedMany>>;
+declare const _default: {
+    generateText: typeof generateText;
+    streamText: typeof streamText;
+    generateObject: typeof generateObject;
+    streamObject: typeof streamObject;
+    embed: typeof embed;
+    embedMany: typeof embedMany;
+};
+export default _default;

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

@@ -0,0 +1,327 @@
+"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.generateText = generateText;
+exports.streamText = streamText;
+exports.generateObject = generateObject;
+exports.streamObject = streamObject;
+exports.embed = embed;
+exports.embedMany = embedMany;
+const api_1 = require("@opentelemetry/api");
+const tracing_js_1 = require("../tracing.js");
+const ai_1 = require("ai");
+function getModelInfo(model) {
+    if (model === null || model === void 0 ? void 0 : model.modelId) {
+        const modelId = model.modelId;
+        if (modelId.startsWith('gpt-') || modelId.startsWith('text-embedding-') || modelId.startsWith('dall-e-')) {
+            return { system: 'openai', modelName: modelId };
+        }
+        if (modelId.startsWith('claude-')) {
+            return { system: 'anthropic', modelName: modelId };
+        }
+        if (modelId.startsWith('mistral-') || modelId.startsWith('codestral-')) {
+            return { system: 'mistral', modelName: modelId };
+        }
+        if (modelId.includes('gemini')) {
+            return { system: 'google', modelName: modelId };
+        }
+    }
+    if (model === null || model === void 0 ? void 0 : model.provider) {
+        return { system: model.provider, modelName: model.modelId };
+    }
+    return { system: 'unknown' };
+}
+function extractUsageMetrics(usage) {
+    const usageAttrs = {};
+    const inputTokens = usage.promptTokens || usage.prompt_tokens || usage.inputTokens;
+    const outputTokens = usage.completionTokens || usage.completion_tokens || usage.outputTokens;
+    const cachedTokens = usage.cachedPromptTokens || usage.cached_prompt_tokens || usage.cachedInputTokens;
+    if (inputTokens !== undefined) {
+        usageAttrs["gen_ai.usage.input_tokens"] = inputTokens;
+    }
+    if (outputTokens !== undefined) {
+        usageAttrs["gen_ai.usage.output_tokens"] = outputTokens;
+    }
+    if (cachedTokens !== undefined) {
+        usageAttrs["gen_ai.usage.cached_input_tokens"] = cachedTokens;
+    }
+    if (usage.tokens !== undefined && inputTokens === undefined) {
+        usageAttrs["gen_ai.usage.input_tokens"] = usage.tokens;
+    }
+    return usageAttrs;
+}
+function validateContext() {
+    const externalCustomerId = (0, tracing_js_1.getCustomerIdStorage)();
+    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 {
+        externalCustomerId,
+        externalAgentId: (0, tracing_js_1.getAgentIdStorage)(),
+        token,
+    };
+}
+function generateText(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.generateText", (span) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.generateText)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                if ((_a = result.response) === null || _a === void 0 ? void 0 : _a.modelId) {
+                    span.setAttribute("gen_ai.response.model", result.response.modelId);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function streamText(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.streamText", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const originalOnFinish = params.onFinish;
+                const wrappedParams = Object.assign(Object.assign({}, params), { onFinish: (result) => {
+                        if (result.usage) {
+                            const usageAttrs = extractUsageMetrics(result.usage);
+                            span.setAttributes(usageAttrs);
+                        }
+                        if (originalOnFinish) {
+                            originalOnFinish(result);
+                        }
+                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                        span.end();
+                    } });
+                const result = (0, ai_1.streamText)(wrappedParams);
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function generateObject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.generateObject", (span) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.generateObject)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                if ((_a = result.response) === null || _a === void 0 ? void 0 : _a.modelId) {
+                    span.setAttribute("gen_ai.response.model", result.response.modelId);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function streamObject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.streamObject", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const originalOnFinish = params.onFinish;
+                const wrappedParams = Object.assign(Object.assign({}, params), { onFinish: (result) => {
+                        if (result.usage) {
+                            const usageAttrs = extractUsageMetrics(result.usage);
+                            span.setAttributes(usageAttrs);
+                        }
+                        if (originalOnFinish) {
+                            originalOnFinish(result);
+                        }
+                        span.setStatus({ code: api_1.SpanStatusCode.OK });
+                        span.end();
+                    } });
+                const result = (0, ai_1.streamObject)(wrappedParams);
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+        }));
+    });
+}
+function embed(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.embed", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "embeddings",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.embed)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+function embedMany(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return tracing_js_1.paidTracer.startActiveSpan("trace.ai-sdk.embedMany", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "embeddings",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield (0, ai_1.embedMany)(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                span.setStatus({ code: api_1.SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+exports.default = {
+    generateText,
+    streamText,
+    generateObject,
+    streamObject,
+    embed,
+    embedMany,
+};

package/dist/cjs/vercel/index.d.ts

@@ -0,0 +1 @@
+export { generateText as paidGenerateText, streamText as paidStreamText, generateObject as paidGenerateObject, streamObject as paidStreamObject, embed as paidEmbed, embedMany as paidEmbedMany, } from "../tracing/wrappers/vercelAIWrapper.js";

package/dist/cjs/vercel/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paidEmbedMany = exports.paidEmbed = exports.paidStreamObject = exports.paidGenerateObject = exports.paidStreamText = exports.paidGenerateText = void 0;
+var vercelAIWrapper_js_1 = require("../tracing/wrappers/vercelAIWrapper.js");
+Object.defineProperty(exports, "paidGenerateText", { enumerable: true, get: function () { return vercelAIWrapper_js_1.generateText; } });
+Object.defineProperty(exports, "paidStreamText", { enumerable: true, get: function () { return vercelAIWrapper_js_1.streamText; } });
+Object.defineProperty(exports, "paidGenerateObject", { enumerable: true, get: function () { return vercelAIWrapper_js_1.generateObject; } });
+Object.defineProperty(exports, "paidStreamObject", { enumerable: true, get: function () { return vercelAIWrapper_js_1.streamObject; } });
+Object.defineProperty(exports, "paidEmbed", { enumerable: true, get: function () { return vercelAIWrapper_js_1.embed; } });
+Object.defineProperty(exports, "paidEmbedMany", { enumerable: true, get: function () { return vercelAIWrapper_js_1.embedMany; } });

package/dist/cjs/version.d.ts

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

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

package/dist/esm/Client.d.mts

@@ -43,5 +43,24 @@ export declare class PaidClient {
     get usage(): Usage;
     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;
+    /**
+     * Sends Paid signal. Needs to be called as part of callback to Paid.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.
+     */
+    signal(eventName: string): void;
+    signal(eventName: string, data: Record<string, any>): void;
+    signal(eventName: string, enableCostTracing: boolean, data?: Record<string, any>): void;
 }

package/dist/esm/Client.mjs

@@ -59,15 +59,27 @@ export class PaidClient {
             _initializeTracing(resolvedToken, collectorEndpoint);
         });
     }
-    // Use this method to track actions like LLM usage and sending signals.
+    // Use this method to track actions like LLM costs 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 _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);
+    signal(eventName, enableCostTracingOrData, data) {
+        let enableCostTracing = false;
+        let finalData;
+        if (typeof enableCostTracingOrData === 'boolean') {
+            // Case: signal(eventName, boolean, data?)
+            enableCostTracing = enableCostTracingOrData;
+            finalData = data;
+        }
+        else if (typeof enableCostTracingOrData === 'object') {
+            // Case: signal(eventName, data)
+            enableCostTracing = false;
+            finalData = enableCostTracingOrData;
+        }
+        // Case: signal(eventName) - both remain default/undefined
+        return _signal(eventName, enableCostTracing, finalData);
     }
 }

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

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

package/dist/esm/tracing/signal.mjs

@@ -1,7 +1,7 @@
 import { SpanStatusCode } from "@opentelemetry/api";
 import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage } from "./tracing.mjs";
 import { paidTracer } from "./tracing.mjs";
-export function _signal(eventName, data) {
+export function _signal(eventName, enableCostTracing, data) {
     if (!eventName) {
         throw new Error("Event name is required for signal.");
     }
@@ -11,8 +11,7 @@ export function _signal(eventName, data) {
     if (!externalCustomerId || !externalAgentId || !token) {
         throw new Error(`Missing some of: external_customer_id: ${externalCustomerId}, external_agent_id: ${externalAgentId}, or token. Make sure to call signal() within trace()`);
     }
-    const tracer = paidTracer;
-    tracer.startActiveSpan("trace.signal", (span) => {
+    paidTracer.startActiveSpan("trace.signal", (span) => {
         try {
             const attributes = {
                 external_customer_id: externalCustomerId,
@@ -20,6 +19,16 @@ export function _signal(eventName, data) {
                 event_name: eventName,
                 token: token,
             };
+            if (enableCostTracing) {
+                // let the app know to associate this signal with cost traces
+                attributes["enable_cost_tracing"] = true;
+                if (data === undefined) {
+                    data = { paid: { enable_cost_tracing: true } };
+                }
+                else {
+                    data["paid"] = { enable_cost_tracing: true };
+                }
+            }
             // Optional data (ex. manual cost tracking)
             if (data) {
                 attributes["data"] = JSON.stringify(data);

package/dist/esm/tracing/tracing.mjs

@@ -27,6 +27,7 @@ const COLLECTOR_ENDPOINT = process.env.PAID_COLLECTOR_ENDPOINT || "https://colle
 let paidExporter = new OTLPTraceExporter({ url: COLLECTOR_ENDPOINT });
 let spanProcessor = new BatchSpanProcessor(paidExporter);
 let paidTracerProvider = new NodeTracerProvider({ spanProcessors: [spanProcessor] });
+paidTracerProvider.register();
 export let paidTracer = paidTracerProvider.getTracer("paid.node");
 // storage for passing info to child spans
 const customerIdStorage = new AsyncLocalStorage();
@@ -68,6 +69,7 @@ export function _initializeTracing(apiKey, collectorEndpoint) {
         paidExporter = new OTLPTraceExporter({ url: collectorEndpoint });
         spanProcessor = new BatchSpanProcessor(paidExporter);
         paidTracerProvider = new NodeTracerProvider({ spanProcessors: [spanProcessor] });
+        paidTracerProvider.register();
         paidTracer = paidTracerProvider.getTracer("paid.node");
     }
     setupGracefulShutdown(spanProcessor);
@@ -77,12 +79,11 @@ export function _initializeTracing(apiKey, collectorEndpoint) {
 }
 export function _trace(externalCustomerId, fn, externalAgentId, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tracer = paidTracer;
         const token = getToken();
         if (!token || !externalCustomerId) {
             throw new Error(`Paid tracing is not initialized. Make sure to call initializeTracing() first.`);
         }
-        return tracer.startActiveSpan("paid.node", (span) => __awaiter(this, void 0, void 0, function* () {
+        return paidTracer.startActiveSpan("paid.node", (span) => __awaiter(this, void 0, void 0, function* () {
             span.setAttribute("external_customer_id", externalCustomerId);
             span.setAttribute("token", token);
             if (externalAgentId) {

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

@@ -193,16 +193,15 @@ class ImagesWrapper {
     }
     generate(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const externalCustomerId = getCustomerIdStorage();
             const externalAgentId = getAgentIdStorage();
             const token = getTokenStorage();
-            const model = (_a = params.model) !== null && _a !== void 0 ? _a : "dall-e-3";
+            const model = params.model || "";
             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;
+                var _a;
                 const attributes = {
                     "gen_ai.request.model": model,
                     "gen_ai.system": "openai",
@@ -218,8 +217,8 @@ class ImagesWrapper {
                     const response = yield this.openai.images.generate(params);
                     span.setAttributes({
                         "gen_ai.image.count": (_a = params.n) !== null && _a !== void 0 ? _a : 1,
-                        "gen_ai.image.size": (_b = params.size) !== null && _b !== void 0 ? _b : "1024x1024",
-                        "gen_ai.image.quality": (_c = params.quality) !== null && _c !== void 0 ? _c : "standard",
+                        "gen_ai.image.size": params.size || "",
+                        "gen_ai.image.quality": params.quality || "",
                     });
                     span.setStatus({ code: SpanStatusCode.OK });
                     return response;

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

@@ -0,0 +1,22 @@
+import { generateText as originalGenerateText, streamText as originalStreamText, generateObject as originalGenerateObject, streamObject as originalStreamObject, embed as originalEmbed, embedMany as originalEmbedMany } from "ai";
+type GenerateTextParams = Parameters<typeof originalGenerateText>[0];
+type StreamTextParams = Parameters<typeof originalStreamText>[0];
+type GenerateObjectParams = Parameters<typeof originalGenerateObject>[0];
+type StreamObjectParams = Parameters<typeof originalStreamObject>[0];
+type EmbedParams = Parameters<typeof originalEmbed>[0];
+type EmbedManyParams = Parameters<typeof originalEmbedMany>[0];
+export declare function generateText(params: GenerateTextParams): Promise<ReturnType<typeof originalGenerateText>>;
+export declare function streamText(params: StreamTextParams): Promise<ReturnType<typeof originalStreamText>>;
+export declare function generateObject(params: GenerateObjectParams): Promise<ReturnType<typeof originalGenerateObject>>;
+export declare function streamObject(params: StreamObjectParams): Promise<ReturnType<typeof originalStreamObject>>;
+export declare function embed(params: EmbedParams): Promise<ReturnType<typeof originalEmbed>>;
+export declare function embedMany(params: EmbedManyParams): Promise<ReturnType<typeof originalEmbedMany>>;
+declare const _default: {
+    generateText: typeof generateText;
+    streamText: typeof streamText;
+    generateObject: typeof generateObject;
+    streamObject: typeof streamObject;
+    embed: typeof embed;
+    embedMany: typeof embedMany;
+};
+export default _default;

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

@@ -0,0 +1,319 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SpanStatusCode } from "@opentelemetry/api";
+import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage, paidTracer } from "../tracing.mjs";
+import { generateText as originalGenerateText, streamText as originalStreamText, generateObject as originalGenerateObject, streamObject as originalStreamObject, embed as originalEmbed, embedMany as originalEmbedMany, } from "ai";
+function getModelInfo(model) {
+    if (model === null || model === void 0 ? void 0 : model.modelId) {
+        const modelId = model.modelId;
+        if (modelId.startsWith('gpt-') || modelId.startsWith('text-embedding-') || modelId.startsWith('dall-e-')) {
+            return { system: 'openai', modelName: modelId };
+        }
+        if (modelId.startsWith('claude-')) {
+            return { system: 'anthropic', modelName: modelId };
+        }
+        if (modelId.startsWith('mistral-') || modelId.startsWith('codestral-')) {
+            return { system: 'mistral', modelName: modelId };
+        }
+        if (modelId.includes('gemini')) {
+            return { system: 'google', modelName: modelId };
+        }
+    }
+    if (model === null || model === void 0 ? void 0 : model.provider) {
+        return { system: model.provider, modelName: model.modelId };
+    }
+    return { system: 'unknown' };
+}
+function extractUsageMetrics(usage) {
+    const usageAttrs = {};
+    const inputTokens = usage.promptTokens || usage.prompt_tokens || usage.inputTokens;
+    const outputTokens = usage.completionTokens || usage.completion_tokens || usage.outputTokens;
+    const cachedTokens = usage.cachedPromptTokens || usage.cached_prompt_tokens || usage.cachedInputTokens;
+    if (inputTokens !== undefined) {
+        usageAttrs["gen_ai.usage.input_tokens"] = inputTokens;
+    }
+    if (outputTokens !== undefined) {
+        usageAttrs["gen_ai.usage.output_tokens"] = outputTokens;
+    }
+    if (cachedTokens !== undefined) {
+        usageAttrs["gen_ai.usage.cached_input_tokens"] = cachedTokens;
+    }
+    if (usage.tokens !== undefined && inputTokens === undefined) {
+        usageAttrs["gen_ai.usage.input_tokens"] = usage.tokens;
+    }
+    return usageAttrs;
+}
+function validateContext() {
+    const externalCustomerId = getCustomerIdStorage();
+    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 {
+        externalCustomerId,
+        externalAgentId: getAgentIdStorage(),
+        token,
+    };
+}
+export function generateText(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return paidTracer.startActiveSpan("trace.ai-sdk.generateText", (span) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield originalGenerateText(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                if ((_a = result.response) === null || _a === void 0 ? void 0 : _a.modelId) {
+                    span.setAttribute("gen_ai.response.model", result.response.modelId);
+                }
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+export function streamText(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return paidTracer.startActiveSpan("trace.ai-sdk.streamText", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const originalOnFinish = params.onFinish;
+                const wrappedParams = Object.assign(Object.assign({}, params), { onFinish: (result) => {
+                        if (result.usage) {
+                            const usageAttrs = extractUsageMetrics(result.usage);
+                            span.setAttributes(usageAttrs);
+                        }
+                        if (originalOnFinish) {
+                            originalOnFinish(result);
+                        }
+                        span.setStatus({ code: SpanStatusCode.OK });
+                        span.end();
+                    } });
+                const result = originalStreamText(wrappedParams);
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+export function generateObject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return paidTracer.startActiveSpan("trace.ai-sdk.generateObject", (span) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield originalGenerateObject(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                if ((_a = result.response) === null || _a === void 0 ? void 0 : _a.modelId) {
+                    span.setAttribute("gen_ai.response.model", result.response.modelId);
+                }
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+export function streamObject(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return paidTracer.startActiveSpan("trace.ai-sdk.streamObject", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "chat",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const originalOnFinish = params.onFinish;
+                const wrappedParams = Object.assign(Object.assign({}, params), { onFinish: (result) => {
+                        if (result.usage) {
+                            const usageAttrs = extractUsageMetrics(result.usage);
+                            span.setAttributes(usageAttrs);
+                        }
+                        if (originalOnFinish) {
+                            originalOnFinish(result);
+                        }
+                        span.setStatus({ code: SpanStatusCode.OK });
+                        span.end();
+                    } });
+                const result = originalStreamObject(wrappedParams);
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+        }));
+    });
+}
+export function embed(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return paidTracer.startActiveSpan("trace.ai-sdk.embed", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "embeddings",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield originalEmbed(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+export function embedMany(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const context = validateContext();
+        const { system: aiSystem, modelName } = getModelInfo(params.model);
+        return paidTracer.startActiveSpan("trace.ai-sdk.embedMany", (span) => __awaiter(this, void 0, void 0, function* () {
+            const attributes = {
+                "gen_ai.system": aiSystem,
+                "gen_ai.operation.name": "embeddings",
+                "external_customer_id": context.externalCustomerId,
+                "token": context.token,
+            };
+            if (context.externalAgentId) {
+                attributes["external_agent_id"] = context.externalAgentId;
+            }
+            if (modelName) {
+                attributes["gen_ai.request.model"] = modelName;
+            }
+            span.setAttributes(attributes);
+            try {
+                const result = yield originalEmbedMany(params);
+                if (result.usage) {
+                    const usageAttrs = extractUsageMetrics(result.usage);
+                    span.setAttributes(usageAttrs);
+                }
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        }));
+    });
+}
+export default {
+    generateText,
+    streamText,
+    generateObject,
+    streamObject,
+    embed,
+    embedMany,
+};

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

@@ -0,0 +1 @@
+export { generateText as paidGenerateText, streamText as paidStreamText, generateObject as paidGenerateObject, streamObject as paidStreamObject, embed as paidEmbed, embedMany as paidEmbedMany, } from "../tracing/wrappers/vercelAIWrapper.mjs";

package/dist/esm/vercel/index.mjs

@@ -0,0 +1 @@
+export { generateText as paidGenerateText, streamText as paidStreamText, generateObject as paidGenerateObject, streamObject as paidStreamObject, embed as paidEmbed, embedMany as paidEmbedMany, } from "../tracing/wrappers/vercelAIWrapper.mjs";

package/dist/esm/version.d.mts

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

package/dist/esm/version.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@paid-ai/paid-node",
-    "version": "0.0.8-alpha3",
+    "version": "0.0.8-alpha5",
     "private": false,
     "repository": "https://github.com/AgentPaid/paid-node",
     "type": "commonjs",
@@ -20,6 +20,18 @@
             },
             "default": "./dist/cjs/index.js"
         },
+        "./vercel": {
+           "types": "./dist/cjs/vercel/index.d.ts",
+           "import": {
+               "types": "./dist/esm/vercel/index.d.mts",
+               "default": "./dist/esm/vercel/index.mjs"
+           },
+           "require": {
+               "types": "./dist/cjs/vercel/index.d.ts",
+               "default": "./dist/cjs/vercel/index.js"
+           },
+           "default": "./dist/cjs/vercel/index.js"
+       },
         "./package.json": "./package.json"
     },
     "files": [
@@ -36,12 +48,14 @@
         "wire:test": "yarn test:wire"
     },
     "dependencies": {
+        "@ai-sdk/openai": "^1.3.23",
         "@anthropic-ai/sdk": "^0.56.0",
         "@langchain/core": "^0.3.64",
         "@mistralai/mistralai": "^1.7.4",
         "@opentelemetry/api": "^1.9.0",
         "@opentelemetry/exporter-trace-otlp-http": "^0.202.0",
         "@opentelemetry/sdk-node": "^0.202.0",
+        "ai": "^5.0.2",
         "form-data": "^4.0.0",
         "formdata-node": "^6.0.3",
         "js-base64": "3.7.7",