@paid-ai/paid-node 0.0.8 → 0.2.0

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-wrapper/index.d.mts

@@ -0,0 +1 @@
+export { generateText as paidVercelGenerateText, streamText as paidVercelStreamText, generateObject as paidVercelGenerateObject, streamObject as paidVercelStreamObject, embed as paidVercelEmbed, embedMany as paidVercelEmbedMany, } from "../tracing/wrappers/vercelAIWrapper.mjs";

package/dist/esm/vercel-wrapper/index.mjs

@@ -0,0 +1 @@
+export { generateText as paidVercelGenerateText, streamText as paidVercelStreamText, generateObject as paidVercelGenerateObject, streamObject as paidVercelStreamObject, embed as paidVercelEmbed, embedMany as paidVercelEmbedMany, } from "../tracing/wrappers/vercelAIWrapper.mjs";

package/dist/esm/version.d.mts

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

package/dist/esm/version.mjs

@@ -1 +1 @@
-export const SDK_VERSION = "0.0.8";
+export const SDK_VERSION = "0.2.0";

package/dist/esm/wrapper/BatchUsage.d.mts

@@ -1,8 +1,8 @@
 import * as core from "../core/index.mjs";
-import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client.mjs";
 import * as Paid from "../api/types/Signal.mjs";
 export declare class Usage extends UsageClient {
     private signals;
-    flush(requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
-    recordUsage(signal?: Paid.Signal, requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<unknown[]>;
+    flush(requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<void>;
+    record(signal?: Paid.Signal, requestOptions?: UsageClient.RequestOptions): core.HttpResponsePromise<void>;
 }

package/dist/esm/wrapper/BatchUsage.mjs

@@ -1,5 +1,5 @@
 import * as core from "../core/index.mjs";
-import { Usage as UsageClient } from "../api/resources/usage/client/Client";
+import { Usage as UsageClient } from "../api/resources/usage/client/Client.mjs";
 export class Usage extends UsageClient {
     constructor() {
         super(...arguments);
@@ -8,7 +8,7 @@ export class Usage extends UsageClient {
     flush(requestOptions) {
         return this.recordBulk({ signals: this.signals }, requestOptions);
     }
-    recordUsage(signal = {}, requestOptions) {
+    record(signal = {}, requestOptions) {
         if (!this.signals) {
             this.signals = [];
         }
@@ -18,6 +18,6 @@ export class Usage extends UsageClient {
             this.signals = [];
             return response;
         }
-        return core.HttpResponsePromise.fromResult({ data: [], rawResponse: {} });
+        return core.HttpResponsePromise.fromResult({ data: undefined, rawResponse: {} });
     }
 }

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@paid-ai/paid-node",
-    "version": "0.0.8",
+    "version": "0.2.0",
     "private": false,
-    "repository": "https://github.com/AgentPaid/paid-node",
+    "repository": "https://github.com/paid-ai/paid-node",
     "type": "commonjs",
     "main": "./dist/cjs/index.js",
     "module": "./dist/esm/index.mjs",
@@ -20,6 +20,66 @@
             },
             "default": "./dist/cjs/index.js"
         },
+        "./openai": {
+            "types": "./dist/cjs/openai-wrapper/index.d.ts",
+            "import": {
+                "types": "./dist/esm/openai-wrapper/index.d.mts",
+                "default": "./dist/esm/openai-wrapper/index.mjs"
+            },
+            "require": {
+                "types": "./dist/cjs/openai-wrapper/index.d.ts",
+                "default": "./dist/cjs/openai-wrapper/index.js"
+            },
+            "default": "./dist/cjs/openai-wrapper/index.js"
+        },
+        "./anthropic": {
+            "types": "./dist/cjs/anthropic-wrapper/index.d.ts",
+            "import": {
+                "types": "./dist/esm/anthropic-wrapper/index.d.mts",
+                "default": "./dist/esm/anthropic-wrapper/index.mjs"
+            },
+            "require": {
+                "types": "./dist/cjs/anthropic-wrapper/index.d.ts",
+                "default": "./dist/cjs/anthropic-wrapper/index.js"
+            },
+            "default": "./dist/cjs/anthropic-wrapper/index.js"
+        },
+        "./mistral": {
+            "types": "./dist/cjs/mistral-wrapper/index.d.ts",
+            "import": {
+                "types": "./dist/esm/mistral-wrapper/index.d.mts",
+                "default": "./dist/esm/mistral-wrapper/index.mjs"
+            },
+            "require": {
+                "types": "./dist/cjs/mistral-wrapper/index.d.ts",
+                "default": "./dist/cjs/mistral-wrapper/index.js"
+            },
+            "default": "./dist/cjs/mistral-wrapper/index.js"
+        },
+        "./langchain": {
+            "types": "./dist/cjs/langchain-wrapper/index.d.ts",
+            "import": {
+                "types": "./dist/esm/langchain-wrapper/index.d.mts",
+                "default": "./dist/esm/langchain-wrapper/index.mjs"
+            },
+            "require": {
+                "types": "./dist/cjs/langchain-wrapper/index.d.ts",
+                "default": "./dist/cjs/langchain-wrapper/index.js"
+            },
+            "default": "./dist/cjs/langchain-wrapper/index.js"
+        },
+        "./vercel": {
+            "types": "./dist/cjs/vercel-wrapper/index.d.ts",
+            "import": {
+                "types": "./dist/esm/vercel-wrapper/index.d.mts",
+                "default": "./dist/esm/vercel-wrapper/index.mjs"
+            },
+            "require": {
+                "types": "./dist/cjs/vercel-wrapper/index.d.ts",
+                "default": "./dist/cjs/vercel-wrapper/index.js"
+            },
+            "default": "./dist/cjs/vercel-wrapper/index.js"
+        },
         "./package.json": "./package.json"
     },
     "files": [
@@ -42,7 +102,39 @@
         "node-fetch": "^2.7.0",
         "qs": "^6.13.1",
         "readable-stream": "^4.5.2",
-        "js-base64": "3.7.7"
+        "js-base64": "3.7.7",
+        "@opentelemetry/api": ">=1.9.0",
+        "@opentelemetry/exporter-trace-otlp-http": ">=0.202.0",
+        "@opentelemetry/sdk-node": ">=0.202.0",
+        "winston": ">=3.0.0"
+    },
+    "peerDependencies": {
+        "@ai-sdk/openai": ">=1.0.0",
+        "@anthropic-ai/sdk": ">=0.56.0",
+        "@langchain/core": ">=0.3.0",
+        "@mistralai/mistralai": ">=1.0.0",
+        "ai": ">=5.0.0",
+        "openai": ">=5.0.0"
+    },
+    "peerDependenciesMeta": {
+        "@ai-sdk/openai": {
+            "optional": true
+        },
+        "@anthropic-ai/sdk": {
+            "optional": true
+        },
+        "@langchain/core": {
+            "optional": true
+        },
+        "@mistralai/mistralai": {
+            "optional": true
+        },
+        "ai": {
+            "optional": true
+        },
+        "openai": {
+            "optional": true
+        }
     },
     "devDependencies": {
         "@types/url-join": "4.0.1",
@@ -59,7 +151,13 @@
         "msw": "^2.8.4",
         "@types/node": "^18.19.70",
         "prettier": "^3.4.2",
-        "typescript": "~5.7.2"
+        "typescript": "~5.7.2",
+        "@ai-sdk/openai": ">=1.0.0",
+        "@anthropic-ai/sdk": ">=0.56.0",
+        "@langchain/core": ">=0.3.0",
+        "@mistralai/mistralai": ">=1.0.0",
+        "ai": ">=5.0.0",
+        "openai": ">=5.0.0"
     },
     "browser": {
         "fs": false,