@paid-ai/paid-node 0.0.8 → 0.2.0

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

@@ -0,0 +1,80 @@
+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";
+export class PaidAnthropic {
+    constructor(anthropicClient) {
+        this.anthropic = anthropicClient;
+        this.tracer = paidTracer;
+    }
+    get messages() {
+        return new MessagesWrapper(this.anthropic, this.tracer);
+    }
+}
+class MessagesWrapper {
+    constructor(anthropic, tracer) {
+        this.anthropic = anthropic;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.anthropic.messages", (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "anthropic",
+                    "gen_ai.operation.name": "messages",
+                    external_customer_id: externalCustomerId,
+                    token: token,
+                };
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                // Set request model from params
+                if (params.model) {
+                    attributes["gen_ai.request.model"] = params.model;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = (yield this.anthropic.messages.create(params));
+                    // Add usage information from response
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.input_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.output_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                        // Add Anthropic-specific cache usage if available
+                        if ("cache_creation_input_tokens" in response.usage && response.usage.cache_creation_input_tokens) {
+                            span.setAttribute("gen_ai.usage.cache_creation_input_tokens", response.usage.cache_creation_input_tokens);
+                        }
+                        if ("cache_read_input_tokens" in response.usage && response.usage.cache_read_input_tokens) {
+                            span.setAttribute("gen_ai.usage.cache_read_input_tokens", response.usage.cache_read_input_tokens);
+                        }
+                    }
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}

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

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

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

@@ -0,0 +1,138 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { getCustomerIdStorage, getAgentIdStorage, getTokenStorage, paidTracer } from "../tracing.mjs";
+export class PaidLangChainCallback extends BaseCallbackHandler {
+    constructor() {
+        super();
+        this.name = "PaidLangChainCallback";
+        this.spans = new Map();
+        this.tracer = paidTracer;
+    }
+    extractProvider(serialized) {
+        if (!(serialized === null || serialized === void 0 ? void 0 : serialized.id))
+            return "unknown";
+        const idStr = serialized.id.join(" ").toLowerCase();
+        if (idStr.includes("openai"))
+            return "openai";
+        if (idStr.includes("anthropic"))
+            return "anthropic";
+        if (idStr.includes("mistral"))
+            return "mistral";
+        if (idStr.includes("cohere"))
+            return "cohere";
+        if (idStr.includes("huggingface"))
+            return "huggingface";
+        if (idStr.includes("azure"))
+            return "azure";
+        return "unknown";
+    }
+    handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            const modelType = (metadata === null || metadata === void 0 ? void 0 : metadata.ls_model_type) || "unknown";
+            const modelName = (metadata === null || metadata === void 0 ? void 0 : metadata.ls_model_name) || "unknown";
+            const spanName = `trace.langchain.${modelType}`;
+            const span = this.tracer.startSpan(spanName);
+            const attributes = {
+                "gen_ai.system": this.extractProvider(llm),
+                "gen_ai.operation.name": modelType,
+                "gen_ai.request.model": modelName,
+                external_customer_id: externalCustomerId,
+                token: token,
+            };
+            if (externalAgentId) {
+                attributes["external_agent_id"] = externalAgentId;
+            }
+            span.setAttributes(attributes);
+            this.spans.set(runId, span);
+        });
+    }
+    handleLLMEnd(output, runId, parentRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            const span = this.spans.get(runId);
+            if (!span)
+                return;
+            try {
+                const attributes = {};
+                // Extract token usage information
+                if ((_a = output.llmOutput) === null || _a === void 0 ? void 0 : _a.tokenUsage) {
+                    const usage = output.llmOutput.tokenUsage;
+                    if (usage.promptTokens !== undefined) {
+                        attributes["gen_ai.usage.input_tokens"] = usage.promptTokens;
+                    }
+                    if (usage.completionTokens !== undefined) {
+                        attributes["gen_ai.usage.output_tokens"] = usage.completionTokens;
+                    }
+                    if (usage.cachedInputTokens !== undefined) {
+                        attributes["gen_ai.usage.cached_input_tokens"] = usage.cachedInputTokens;
+                    }
+                    if (usage.reasoningOutputTokens !== undefined) {
+                        attributes["gen_ai.usage.reasoning_output_tokens"] = usage.reasoningOutputTokens;
+                    }
+                }
+                // Alternative token usage format (some providers use different field names)
+                if ((_b = output.llmOutput) === null || _b === void 0 ? void 0 : _b.token_usage) {
+                    const usage = output.llmOutput.token_usage;
+                    if (usage.prompt_tokens !== undefined) {
+                        attributes["gen_ai.usage.input_tokens"] = usage.prompt_tokens;
+                    }
+                    if (usage.completion_tokens !== undefined) {
+                        attributes["gen_ai.usage.output_tokens"] = usage.completion_tokens;
+                    }
+                    if (usage.cached_input_tokens !== undefined) {
+                        attributes["gen_ai.usage.cached_input_tokens"] = usage.cached_input_tokens;
+                    }
+                    if (usage.reasoning_output_tokens !== undefined) {
+                        attributes["gen_ai.usage.reasoning_output_tokens"] = usage.reasoning_output_tokens;
+                    }
+                }
+                // Add model from response if available
+                if ((_c = output.llmOutput) === null || _c === void 0 ? void 0 : _c.modelName) {
+                    attributes["gen_ai.response.model"] = output.llmOutput.modelName;
+                }
+                else if ((_d = output.llmOutput) === null || _d === void 0 ? void 0 : _d.model_name) {
+                    attributes["gen_ai.response.model"] = output.llmOutput.model_name;
+                }
+                else if ((_j = (_h = (_g = (_f = (_e = output.generations) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.message) === null || _h === void 0 ? void 0 : _h["response_metadata"]) === null || _j === void 0 ? void 0 : _j.model_name) {
+                    attributes["gen_ai.response.model"] = output.generations[0][0].message["response_metadata"].model_name;
+                }
+                span.setAttributes(attributes);
+                span.setStatus({ code: SpanStatusCode.OK });
+            }
+            finally {
+                span.end();
+                this.spans.delete(runId);
+            }
+        });
+    }
+    handleLLMError(err, runId, parentRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const span = this.spans.get(runId);
+            if (!span)
+                return;
+            try {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+                span.recordException(err);
+            }
+            finally {
+                span.end();
+                this.spans.delete(runId);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Mistral } from "@mistralai/mistralai";
+import { Tracer } from "@opentelemetry/api";
+import { OCRRequest, OCRResponse } from "@mistralai/mistralai/models/components";
+import { RequestOptions } from "@mistralai/mistralai/lib/sdks";
+export declare class PaidMistral {
+    private readonly mistral;
+    private readonly tracer;
+    constructor(mistralClient: Mistral);
+    get ocr(): OCRWrapper;
+}
+declare class OCRWrapper {
+    private mistral;
+    private tracer;
+    constructor(mistral: Mistral, tracer: Tracer);
+    process(request: OCRRequest, options?: RequestOptions): Promise<OCRResponse>;
+}
+export {};

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

@@ -0,0 +1,77 @@
+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";
+export class PaidMistral {
+    constructor(mistralClient) {
+        this.mistral = mistralClient;
+        this.tracer = paidTracer;
+    }
+    get ocr() {
+        return new OCRWrapper(this.mistral, this.tracer);
+    }
+}
+class OCRWrapper {
+    constructor(mistral, tracer) {
+        this.mistral = mistral;
+        this.tracer = tracer;
+    }
+    process(request, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.mistral.ocr", (span) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const attributes = {
+                    "gen_ai.system": "mistral",
+                    "gen_ai.operation.name": "ocr",
+                    external_customer_id: externalCustomerId,
+                    token: token,
+                };
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                // Check if annotations are requested
+                if (request.bboxAnnotationFormat || request.documentAnnotationFormat) {
+                    attributes["gen_ai.ocr.annotated"] = "true";
+                }
+                // Set request model
+                if (request.model) {
+                    attributes["gen_ai.request.model"] = request.model;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.mistral.ocr.process(request, options);
+                    // Add usage information from response
+                    if (((_a = response.usageInfo) === null || _a === void 0 ? void 0 : _a.pagesProcessed) !== undefined) {
+                        span.setAttribute("gen_ai.ocr.pages_processed", response.usageInfo.pagesProcessed);
+                    }
+                    if (response.model) {
+                        span.setAttribute("gen_ai.response.model", response.model);
+                    }
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}

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

@@ -0,0 +1,48 @@
+import OpenAI from "openai";
+import { Tracer } from "@opentelemetry/api";
+import { ChatCompletion, ChatCompletionCreateParams } from "openai/resources/chat/completions";
+import { EmbeddingCreateParams } from "openai/resources/embeddings";
+import { ImagesResponse, ImageGenerateParams } from "openai/resources/images";
+import { CreateEmbeddingResponse } from "openai/resources/embeddings";
+export declare class PaidOpenAI {
+    private readonly openai;
+    private readonly tracer;
+    constructor(openaiClient: any);
+    get chat(): ChatWrapper;
+    get embeddings(): EmbeddingsWrapper;
+    get images(): ImagesWrapper;
+    get responses(): ResponsesWrapper;
+}
+declare class ChatWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    get completions(): ChatCompletionsWrapper;
+}
+declare class ChatCompletionsWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    create(params: ChatCompletionCreateParams): Promise<ChatCompletion>;
+}
+type ResponseCreateParams = any;
+type Response = any;
+declare class ResponsesWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: any, tracer: Tracer);
+    create(params: ResponseCreateParams): Promise<Response>;
+}
+declare class EmbeddingsWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    create(params: EmbeddingCreateParams): Promise<CreateEmbeddingResponse>;
+}
+declare class ImagesWrapper {
+    private openai;
+    private tracer;
+    constructor(openai: OpenAI, tracer: Tracer);
+    generate(params: ImageGenerateParams): Promise<ImagesResponse>;
+}
+export {};

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

@@ -0,0 +1,237 @@
+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";
+export class PaidOpenAI {
+    constructor(openaiClient) {
+        this.openai = openaiClient;
+        this.tracer = paidTracer;
+    }
+    get chat() {
+        return new ChatWrapper(this.openai, this.tracer);
+    }
+    get embeddings() {
+        return new EmbeddingsWrapper(this.openai, this.tracer);
+    }
+    get images() {
+        return new ImagesWrapper(this.openai, this.tracer);
+    }
+    get responses() {
+        return new ResponsesWrapper(this.openai, this.tracer);
+    }
+}
+class ChatWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    get completions() {
+        return new ChatCompletionsWrapper(this.openai, this.tracer);
+    }
+}
+class ChatCompletionsWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.openai.chat", (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "chat",
+                };
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = (yield this.openai.chat.completions.create(params));
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.prompt_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.completion_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                    }
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}
+class ResponsesWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.openai.responses", (span) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                const attributes = {
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "chat", // Equivalent to chat.completions
+                };
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.openai.responses.create(params);
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.input_tokens,
+                            "gen_ai.usage.output_tokens": response.usage.output_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                        if ((_a = response.usage.input_tokens_details) === null || _a === void 0 ? void 0 : _a.cached_tokens) {
+                            span.setAttribute("gen_ai.usage.cached_input_tokens", response.usage.input_tokens_details.cached_tokens);
+                        }
+                        if ((_b = response.usage.output_tokens_details) === null || _b === void 0 ? void 0 : _b.reasoning_tokens) {
+                            span.setAttribute("gen_ai.usage.reasoning_output_tokens", response.usage.output_tokens_details.reasoning_tokens);
+                        }
+                    }
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}
+class EmbeddingsWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            if (!token || !externalCustomerId) {
+                throw new Error("No token or externalCustomerId: This wrapper should be used inside a callback to paid.trace().");
+            }
+            return this.tracer.startActiveSpan("trace.openai.embeddings", (span) => __awaiter(this, void 0, void 0, function* () {
+                const attributes = {
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "embeddings",
+                };
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                span.setAttributes(attributes);
+                try {
+                    const response = yield this.openai.embeddings.create(params);
+                    if (response.usage) {
+                        span.setAttributes({
+                            "gen_ai.usage.input_tokens": response.usage.prompt_tokens,
+                            "gen_ai.response.model": response.model,
+                        });
+                    }
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}
+class ImagesWrapper {
+    constructor(openai, tracer) {
+        this.openai = openai;
+        this.tracer = tracer;
+    }
+    generate(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const externalCustomerId = getCustomerIdStorage();
+            const externalAgentId = getAgentIdStorage();
+            const token = getTokenStorage();
+            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;
+                const attributes = {
+                    "gen_ai.request.model": model,
+                    "gen_ai.system": "openai",
+                    "gen_ai.operation.name": "image_generation",
+                };
+                attributes["external_customer_id"] = externalCustomerId;
+                attributes["token"] = token;
+                if (externalAgentId) {
+                    attributes["external_agent_id"] = externalAgentId;
+                }
+                span.setAttributes(attributes);
+                try {
+                    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": params.size || "",
+                        "gen_ai.image.quality": params.quality || "",
+                    });
+                    span.setStatus({ code: SpanStatusCode.OK });
+                    return response;
+                }
+                catch (error) {
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    span.recordException(error);
+                    throw error;
+                }
+                finally {
+                    span.end();
+                }
+            }));
+        });
+    }
+}

package/dist/esm/tracing/wrappers/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;