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

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-alpha4";

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-alpha4";

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-alpha4";

package/dist/esm/version.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@paid-ai/paid-node",
-    "version": "0.0.8-alpha3",
+    "version": "0.0.8-alpha4",
     "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",