langsmith 0.7.0 → 0.7.2

package/dist/experimental/vercel/utils.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertMessageToTracedFormat = exports.normalizeFileDataAsDataURL = void 0;
+exports.setUsageMetadataOnRunTree = exports.convertMessageToTracedFormat = exports.normalizeFileDataAsDataURL = void 0;
+const types_js_1 = require("../../utils/types.cjs");
+const vercel_js_1 = require("../../utils/vercel.cjs");
 const guessMimetypeFromBase64 = (data) => {
     // Check magic bytes from base64 data
     const bytes = atob(data.substring(0, 20)); // Decode first few bytes
@@ -42,62 +44,89 @@ const guessMimetypeFromBase64 = (data) => {
     }
     return undefined;
 };
+function _isAISDKFileData(input) {
+    if (!(0, types_js_1.isRecord)(input))
+        return false;
+    if (input.type === "data" && "data" in input)
+        return true;
+    if (input.type === "url" && "url" in input)
+        return true;
+    if (input.type === "reference" && "reference" in input)
+        return true;
+    if (input.type === "text" && "text" in input)
+        return true;
+    return false;
+}
+function _toUint8Array(fileData) {
+    // Covers `fileData: ArrayBuffer | Buffer | Uint8Array`
+    if (fileData instanceof Uint8Array) {
+        return fileData;
+    }
+    if (fileData != null &&
+        typeof fileData === "object" &&
+        "type" in fileData &&
+        "data" in fileData &&
+        typeof fileData.data === "object" &&
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        fileData.data instanceof Uint8Array) {
+        return fileData.data;
+        // eslint-disable-next-line no-instanceof/no-instanceof
+    }
+    if (fileData instanceof ArrayBuffer) {
+        return new Uint8Array(fileData);
+    }
+    return undefined;
+}
 const normalizeFileDataAsDataURL = (fileData, mimeType) => {
-    // eslint-disable-next-line no-instanceof/no-instanceof
+    if (_isAISDKFileData(fileData)) {
+        if (fileData.type === "data") {
+            return (0, exports.normalizeFileDataAsDataURL)(fileData.data, mimeType);
+        }
+        if (fileData.type === "url") {
+            return fileData.url.toString();
+        }
+        if (fileData.type === "reference") {
+            // TODO: figure out if we can store the reference in a more reasonable format
+            return `data:application/octet-stream;base64,${btoa(JSON.stringify(fileData.reference))}`;
+        }
+        if (fileData.type === "text") {
+            return `data:text/plain;base64,${btoa(fileData.text)}`;
+        }
+        throw new Error("AISDKFileData is not supported");
+    }
     if (fileData instanceof URL) {
         return fileData.toString();
     }
-    let normalizedFileData;
     if (typeof fileData !== "string") {
-        let uint8Array;
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (fileData instanceof Uint8Array) {
-            uint8Array = fileData;
-        }
-        else if (fileData != null &&
-            typeof fileData === "object" &&
-            "type" in fileData &&
-            "data" in fileData &&
-            typeof fileData.data === "object" &&
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            fileData.data instanceof Uint8Array) {
-            uint8Array = fileData.data;
-            // eslint-disable-next-line no-instanceof/no-instanceof
-        }
-        else if (fileData instanceof ArrayBuffer) {
-            uint8Array = new Uint8Array(fileData);
-        }
+        const uint8Array = _toUint8Array(fileData);
         if (uint8Array) {
             let binary = "";
             for (let i = 0; i < uint8Array.length; i++) {
                 binary += String.fromCharCode(uint8Array[i]);
             }
             const base64 = btoa(binary);
-            normalizedFileData = `data:${mimeType ??
+            const dataType = mimeType ??
                 guessMimetypeFromBase64(base64) ??
-                "application/octet-stream"};base64,${base64}`;
-        }
-        else {
-            normalizedFileData = "";
+                "application/octet-stream";
+            return `data:${dataType};base64,${base64}`;
         }
     }
-    else {
+    if (typeof fileData === "string") {
         if (fileData.startsWith("http://") || fileData.startsWith("https://")) {
-            normalizedFileData = fileData;
+            return fileData;
         }
-        else if (!fileData.startsWith("data:")) {
-            normalizedFileData = `data:${mimeType ??
+        if (!fileData.startsWith("data:")) {
+            return `data:${mimeType ??
                 guessMimetypeFromBase64(fileData) ??
                 "application/octet-stream"};base64,${fileData}`;
         }
-        else {
-            normalizedFileData = fileData;
-        }
+        return fileData;
     }
-    return normalizedFileData;
+    return "";
 };
 exports.normalizeFileDataAsDataURL = normalizeFileDataAsDataURL;
-const convertMessageToTracedFormat = (message, responseMetadata) => {
+const convertMessageToTracedFormat = (rawMessage, responseMetadata) => {
+    const message = rawMessage;
     const formattedMessage = {
         ...message,
     };
@@ -179,3 +208,81 @@ const convertMessageToTracedFormat = (message, responseMetadata) => {
     return formattedMessage;
 };
 exports.convertMessageToTracedFormat = convertMessageToTracedFormat;
+const setUsageMetadataOnRunTree = (result, runTree) => {
+    if (result.usage == null || typeof result.usage !== "object") {
+        return;
+    }
+    const usage = result.usage;
+    let inputTokens;
+    let outputTokens;
+    let totalTokens;
+    // AI SDK 6: Check for object-based token structures first
+    if ((0, types_js_1.isRecord)(usage.inputTokens) &&
+        usage.inputTokens?.total != null &&
+        typeof usage.inputTokens.total === "number") {
+        // AI SDK 6 detected
+        inputTokens = usage.inputTokens.total;
+        if ((0, types_js_1.isRecord)(usage.outputTokens) &&
+            usage.outputTokens?.total != null &&
+            typeof usage.outputTokens.total === "number") {
+            outputTokens = usage.outputTokens.total;
+        }
+        totalTokens = result.usage?.totalTokens;
+        if (typeof totalTokens !== "number" &&
+            typeof inputTokens === "number" &&
+            typeof outputTokens === "number") {
+            totalTokens = inputTokens + outputTokens;
+        }
+    }
+    else if (typeof usage.inputTokens === "number") {
+        // AI SDK 5 detected
+        inputTokens = usage.inputTokens;
+        if (typeof usage.outputTokens === "number") {
+            outputTokens = usage.outputTokens;
+        }
+        totalTokens = result.usage?.totalTokens;
+        if (typeof totalTokens !== "number" &&
+            typeof inputTokens === "number" &&
+            typeof outputTokens === "number") {
+            totalTokens = inputTokens + outputTokens;
+        }
+    }
+    else {
+        // AI SDK 4 fallback
+        if (typeof usage.promptTokens === "number") {
+            inputTokens = usage.promptTokens;
+        }
+        if (typeof usage.completionTokens === "number") {
+            outputTokens = usage.completionTokens;
+        }
+        totalTokens = result.usage?.totalTokens;
+        if (typeof totalTokens !== "number" &&
+            typeof inputTokens === "number" &&
+            typeof outputTokens === "number") {
+            totalTokens = inputTokens + outputTokens;
+        }
+    }
+    const langsmithUsage = {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+    };
+    const inputTokenDetails = (0, vercel_js_1.extractInputTokenDetails)(result.usage, result.providerMetadata);
+    const outputTokenDetails = (0, vercel_js_1.extractOutputTokenDetails)(result.usage, result.providerMetadata);
+    runTree.extra = {
+        ...runTree.extra,
+        metadata: {
+            ...runTree.extra?.metadata,
+            usage_metadata: {
+                ...langsmithUsage,
+                input_token_details: {
+                    ...inputTokenDetails,
+                },
+                output_token_details: {
+                    ...outputTokenDetails,
+                },
+            },
+        },
+    };
+};
+exports.setUsageMetadataOnRunTree = setUsageMetadataOnRunTree;

package/dist/experimental/vercel/utils.d.ts

@@ -1,3 +1,28 @@
-import type { LanguageModelV2DataContent } from "@ai-sdk/provider";
-export declare const normalizeFileDataAsDataURL: (fileData: LanguageModelV2DataContent | ArrayBuffer, mimeType?: string) => string;
-export declare const convertMessageToTracedFormat: (message: Record<string, unknown>, responseMetadata?: Record<string, unknown>) => Record<string, unknown>;
+import type { LanguageModelV2DataContent, LanguageModelV2Usage, SharedV2ProviderMetadata } from "@ai-sdk/provider";
+import { RunTree } from "../../run_trees.js";
+type AISDKDataContent = string | Uint8Array | ArrayBuffer | Buffer;
+type AISDKProviderReference = {
+    [provider: string]: string;
+} & {
+    type?: never;
+};
+type AISDKFileData = {
+    type: "data";
+    data: AISDKDataContent;
+} | {
+    type: "url";
+    url: URL;
+} | {
+    type: "reference";
+    reference: AISDKProviderReference;
+} | {
+    type: "text";
+    text: string;
+};
+export declare const normalizeFileDataAsDataURL: (fileData: AISDKFileData | AISDKDataContent | LanguageModelV2DataContent | AISDKProviderReference | URL, mimeType: string | undefined) => string;
+export declare const convertMessageToTracedFormat: (rawMessage: Record<string, unknown>, responseMetadata?: Record<string, unknown>) => Record<string, unknown>;
+export declare const setUsageMetadataOnRunTree: (result: {
+    usage?: LanguageModelV2Usage;
+    providerMetadata?: SharedV2ProviderMetadata;
+}, runTree: RunTree) => void;
+export {};

package/dist/experimental/vercel/utils.js

@@ -1,3 +1,5 @@
+import { isRecord } from "../../utils/types.js";
+import { extractInputTokenDetails, extractOutputTokenDetails, } from "../../utils/vercel.js";
 const guessMimetypeFromBase64 = (data) => {
     // Check magic bytes from base64 data
     const bytes = atob(data.substring(0, 20)); // Decode first few bytes
@@ -39,61 +41,88 @@ const guessMimetypeFromBase64 = (data) => {
     }
     return undefined;
 };
+function _isAISDKFileData(input) {
+    if (!isRecord(input))
+        return false;
+    if (input.type === "data" && "data" in input)
+        return true;
+    if (input.type === "url" && "url" in input)
+        return true;
+    if (input.type === "reference" && "reference" in input)
+        return true;
+    if (input.type === "text" && "text" in input)
+        return true;
+    return false;
+}
+function _toUint8Array(fileData) {
+    // Covers `fileData: ArrayBuffer | Buffer | Uint8Array`
+    if (fileData instanceof Uint8Array) {
+        return fileData;
+    }
+    if (fileData != null &&
+        typeof fileData === "object" &&
+        "type" in fileData &&
+        "data" in fileData &&
+        typeof fileData.data === "object" &&
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        fileData.data instanceof Uint8Array) {
+        return fileData.data;
+        // eslint-disable-next-line no-instanceof/no-instanceof
+    }
+    if (fileData instanceof ArrayBuffer) {
+        return new Uint8Array(fileData);
+    }
+    return undefined;
+}
 export const normalizeFileDataAsDataURL = (fileData, mimeType) => {
-    // eslint-disable-next-line no-instanceof/no-instanceof
+    if (_isAISDKFileData(fileData)) {
+        if (fileData.type === "data") {
+            return normalizeFileDataAsDataURL(fileData.data, mimeType);
+        }
+        if (fileData.type === "url") {
+            return fileData.url.toString();
+        }
+        if (fileData.type === "reference") {
+            // TODO: figure out if we can store the reference in a more reasonable format
+            return `data:application/octet-stream;base64,${btoa(JSON.stringify(fileData.reference))}`;
+        }
+        if (fileData.type === "text") {
+            return `data:text/plain;base64,${btoa(fileData.text)}`;
+        }
+        throw new Error("AISDKFileData is not supported");
+    }
     if (fileData instanceof URL) {
         return fileData.toString();
     }
-    let normalizedFileData;
     if (typeof fileData !== "string") {
-        let uint8Array;
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (fileData instanceof Uint8Array) {
-            uint8Array = fileData;
-        }
-        else if (fileData != null &&
-            typeof fileData === "object" &&
-            "type" in fileData &&
-            "data" in fileData &&
-            typeof fileData.data === "object" &&
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            fileData.data instanceof Uint8Array) {
-            uint8Array = fileData.data;
-            // eslint-disable-next-line no-instanceof/no-instanceof
-        }
-        else if (fileData instanceof ArrayBuffer) {
-            uint8Array = new Uint8Array(fileData);
-        }
+        const uint8Array = _toUint8Array(fileData);
         if (uint8Array) {
             let binary = "";
             for (let i = 0; i < uint8Array.length; i++) {
                 binary += String.fromCharCode(uint8Array[i]);
             }
             const base64 = btoa(binary);
-            normalizedFileData = `data:${mimeType ??
+            const dataType = mimeType ??
                 guessMimetypeFromBase64(base64) ??
-                "application/octet-stream"};base64,${base64}`;
-        }
-        else {
-            normalizedFileData = "";
+                "application/octet-stream";
+            return `data:${dataType};base64,${base64}`;
         }
     }
-    else {
+    if (typeof fileData === "string") {
         if (fileData.startsWith("http://") || fileData.startsWith("https://")) {
-            normalizedFileData = fileData;
+            return fileData;
         }
-        else if (!fileData.startsWith("data:")) {
-            normalizedFileData = `data:${mimeType ??
+        if (!fileData.startsWith("data:")) {
+            return `data:${mimeType ??
                 guessMimetypeFromBase64(fileData) ??
                 "application/octet-stream"};base64,${fileData}`;
         }
-        else {
-            normalizedFileData = fileData;
-        }
+        return fileData;
     }
-    return normalizedFileData;
+    return "";
 };
-export const convertMessageToTracedFormat = (message, responseMetadata) => {
+export const convertMessageToTracedFormat = (rawMessage, responseMetadata) => {
+    const message = rawMessage;
     const formattedMessage = {
         ...message,
     };
@@ -174,3 +203,80 @@ export const convertMessageToTracedFormat = (message, responseMetadata) => {
     }
     return formattedMessage;
 };
+export const setUsageMetadataOnRunTree = (result, runTree) => {
+    if (result.usage == null || typeof result.usage !== "object") {
+        return;
+    }
+    const usage = result.usage;
+    let inputTokens;
+    let outputTokens;
+    let totalTokens;
+    // AI SDK 6: Check for object-based token structures first
+    if (isRecord(usage.inputTokens) &&
+        usage.inputTokens?.total != null &&
+        typeof usage.inputTokens.total === "number") {
+        // AI SDK 6 detected
+        inputTokens = usage.inputTokens.total;
+        if (isRecord(usage.outputTokens) &&
+            usage.outputTokens?.total != null &&
+            typeof usage.outputTokens.total === "number") {
+            outputTokens = usage.outputTokens.total;
+        }
+        totalTokens = result.usage?.totalTokens;
+        if (typeof totalTokens !== "number" &&
+            typeof inputTokens === "number" &&
+            typeof outputTokens === "number") {
+            totalTokens = inputTokens + outputTokens;
+        }
+    }
+    else if (typeof usage.inputTokens === "number") {
+        // AI SDK 5 detected
+        inputTokens = usage.inputTokens;
+        if (typeof usage.outputTokens === "number") {
+            outputTokens = usage.outputTokens;
+        }
+        totalTokens = result.usage?.totalTokens;
+        if (typeof totalTokens !== "number" &&
+            typeof inputTokens === "number" &&
+            typeof outputTokens === "number") {
+            totalTokens = inputTokens + outputTokens;
+        }
+    }
+    else {
+        // AI SDK 4 fallback
+        if (typeof usage.promptTokens === "number") {
+            inputTokens = usage.promptTokens;
+        }
+        if (typeof usage.completionTokens === "number") {
+            outputTokens = usage.completionTokens;
+        }
+        totalTokens = result.usage?.totalTokens;
+        if (typeof totalTokens !== "number" &&
+            typeof inputTokens === "number" &&
+            typeof outputTokens === "number") {
+            totalTokens = inputTokens + outputTokens;
+        }
+    }
+    const langsmithUsage = {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+    };
+    const inputTokenDetails = extractInputTokenDetails(result.usage, result.providerMetadata);
+    const outputTokenDetails = extractOutputTokenDetails(result.usage, result.providerMetadata);
+    runTree.extra = {
+        ...runTree.extra,
+        metadata: {
+            ...runTree.extra?.metadata,
+            usage_metadata: {
+                ...langsmithUsage,
+                input_token_details: {
+                    ...inputTokenDetails,
+                },
+                output_token_details: {
+                    ...outputTokenDetails,
+                },
+            },
+        },
+    };
+};