langsmith 0.4.7 → 0.4.9

package/dist/experimental/anthropic/usage.js

@@ -0,0 +1,175 @@
+import { convertAnthropicUsageToInputTokenDetails } from "../../utils/usage.js";
+import { getNumberProperty } from "./utils.js";
+/**
+ * Aggregates usage from modelUsage breakdown (includes all models, including hidden ones).
+ * This provides accurate totals when multiple models are used.
+ * @internal
+ */
+export function aggregateUsageFromModelUsage(modelUsage) {
+    const metrics = {};
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheCreationTokens = 0;
+    // Aggregate across all models
+    for (const modelStats of Object.values(modelUsage)) {
+        totalInputTokens += modelStats.inputTokens || 0;
+        totalOutputTokens += modelStats.outputTokens || 0;
+        totalCacheReadTokens += modelStats.cacheReadInputTokens || 0;
+        totalCacheCreationTokens += modelStats.cacheCreationInputTokens || 0;
+    }
+    // Build input_token_details if we have cache tokens
+    if (totalCacheReadTokens > 0 || totalCacheCreationTokens > 0) {
+        metrics.input_token_details = {
+            cache_read: totalCacheReadTokens,
+            cache_creation: totalCacheCreationTokens,
+        };
+    }
+    // Sum all input tokens (new + cache read + cache creation)
+    const totalPromptTokens = totalInputTokens + totalCacheReadTokens + totalCacheCreationTokens;
+    metrics.input_tokens = totalPromptTokens;
+    metrics.output_tokens = totalOutputTokens;
+    metrics.total_tokens = totalPromptTokens + totalOutputTokens;
+    return metrics;
+}
+/**
+ * Extracts and normalizes usage metrics from a Claude Agent SDK message.
+ * @internal
+ */
+export function extractUsageFromMessage(message) {
+    const metrics = {};
+    // Assistant messages contain usage in message.message.usage
+    // Result messages contain usage in message.usage
+    let usage;
+    if (message.type === "assistant") {
+        usage = message.message?.usage;
+    }
+    else if (message.type === "result") {
+        usage = message.usage;
+    }
+    if (!usage || typeof usage !== "object") {
+        return metrics;
+    }
+    // Standard token counts - use LangSmith's expected field names
+    const inputTokens = getNumberProperty(usage, "input_tokens") || 0;
+    const outputTokens = getNumberProperty(usage, "output_tokens") || 0;
+    // Get cache tokens
+    const cacheRead = getNumberProperty(usage, "cache_read_input_tokens") || 0;
+    const cacheCreation = getNumberProperty(usage, "cache_creation_input_tokens") || 0;
+    // Build input_token_details if we have cache tokens
+    if (cacheRead > 0 || cacheCreation > 0) {
+        const inputTokenDetails = convertAnthropicUsageToInputTokenDetails(usage);
+        if (Object.keys(inputTokenDetails).length > 0) {
+            metrics.input_token_details = inputTokenDetails;
+        }
+    }
+    // Sum cache tokens into input_tokens total (matching Python's sum_anthropic_tokens)
+    const totalInputTokens = inputTokens + cacheRead + cacheCreation;
+    metrics.input_tokens = totalInputTokens;
+    metrics.output_tokens = outputTokens;
+    metrics.total_tokens = totalInputTokens + outputTokens;
+    return metrics;
+}
+/**
+ * Corrects usage metrics for assistant runs based on the results of the runs.
+ * @internal
+ */
+export function correctUsageFromResults(resultUsages, assistantRuns) {
+    const runByModel = assistantRuns.reduce((acc, run) => {
+        const modelId = run.extra?.metadata?.ls_model_name;
+        if (!modelId)
+            return acc;
+        acc[modelId] ??= [];
+        acc[modelId].push(run);
+        return acc;
+    }, {});
+    const runUsageByModel = assistantRuns.reduce((acc, run) => {
+        const modelId = run.extra?.metadata?.ls_model_name;
+        if (!modelId)
+            return acc;
+        const usageMetadata = { ...run.extra?.metadata?.usage_metadata };
+        usageMetadata.input_tokens ??= 0;
+        usageMetadata.output_tokens ??= 0;
+        usageMetadata.total_tokens ??= 0;
+        usageMetadata.input_token_details = {
+            ...usageMetadata.input_token_details,
+        };
+        usageMetadata.input_token_details.cache_read ??= 0;
+        usageMetadata.input_token_details.ephemeral_5m_input_tokens ??= 0;
+        usageMetadata.input_token_details.ephemeral_1h_input_tokens ??= 0;
+        acc[modelId] ??= {
+            input_tokens: 0,
+            output_tokens: 0,
+            total_tokens: 0,
+            input_token_details: {
+                cache_read: 0,
+                cache_creation: 0,
+            },
+        };
+        acc[modelId].input_tokens += usageMetadata.input_tokens;
+        acc[modelId].output_tokens += usageMetadata.output_tokens;
+        acc[modelId].total_tokens += usageMetadata.total_tokens;
+        acc[modelId].input_token_details.cache_read +=
+            usageMetadata.input_token_details.cache_read;
+        acc[modelId].input_token_details.cache_creation +=
+            usageMetadata.input_token_details.ephemeral_5m_input_tokens;
+        acc[modelId].input_token_details.cache_creation +=
+            usageMetadata.input_token_details.ephemeral_1h_input_tokens;
+        return acc;
+    }, {});
+    const resultUsageMap = Object.fromEntries(Object.entries(resultUsages).map(([modelId, usage]) => [
+        modelId,
+        {
+            input_tokens: usage.inputTokens +
+                usage.cacheReadInputTokens +
+                usage.cacheCreationInputTokens,
+            output_tokens: usage.outputTokens,
+            total_tokens: usage.inputTokens +
+                usage.cacheReadInputTokens +
+                usage.cacheCreationInputTokens +
+                usage.outputTokens,
+            input_token_details: {
+                cache_read: usage.cacheReadInputTokens,
+                cache_creation: usage.cacheCreationInputTokens,
+            },
+        },
+    ]));
+    for (const modelId in resultUsageMap) {
+        const lastRun = runByModel[modelId]?.at(-1);
+        const runsUsage = runUsageByModel[modelId];
+        const resultUsage = resultUsageMap[modelId];
+        if (!runsUsage || !lastRun)
+            continue;
+        const difference = {
+            input_tokens: Math.max(0, resultUsage.input_tokens - runsUsage.input_tokens),
+            output_tokens: Math.max(0, resultUsage.output_tokens - runsUsage.output_tokens),
+            total_tokens: Math.max(0, resultUsage.total_tokens - runsUsage.total_tokens),
+            cache_read: Math.max(0, resultUsage.input_token_details.cache_read -
+                runsUsage.input_token_details.cache_read),
+            cache_creation: Math.max(0, resultUsage.input_token_details.cache_creation -
+                runsUsage.input_token_details.cache_creation),
+        };
+        if (Object.values(difference).some((value) => value > 0)) {
+            // apply difference to the last run
+            lastRun.extra ??= {};
+            lastRun.extra.metadata ??= {};
+            lastRun.extra.metadata.usage_metadata ??= {};
+            lastRun.extra.metadata.usage_metadata.input_tokens ??= 0;
+            lastRun.extra.metadata.usage_metadata.input_tokens +=
+                difference.input_tokens;
+            lastRun.extra.metadata.usage_metadata.output_tokens ??= 0;
+            lastRun.extra.metadata.usage_metadata.output_tokens +=
+                difference.output_tokens;
+            lastRun.extra.metadata.usage_metadata.total_tokens ??= 0;
+            lastRun.extra.metadata.usage_metadata.total_tokens +=
+                difference.total_tokens;
+            lastRun.extra.metadata.usage_metadata.input_token_details ??= {};
+            lastRun.extra.metadata.usage_metadata.input_token_details.cache_read ??= 0;
+            lastRun.extra.metadata.usage_metadata.input_token_details.cache_read +=
+                difference.cache_read;
+            lastRun.extra.metadata.usage_metadata.input_token_details.ephemeral_5m_input_tokens ??= 0;
+            lastRun.extra.metadata.usage_metadata.input_token_details.ephemeral_5m_input_tokens +=
+                difference.cache_creation;
+        }
+    }
+}

package/dist/experimental/anthropic/utils.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumberProperty = getNumberProperty;
+exports.isIterable = isIterable;
+/**
+ * Gets a number property from an object.
+ * @internal
+ */
+function getNumberProperty(obj, key) {
+    if (!obj || typeof obj !== "object" || !(key in obj)) {
+        return undefined;
+    }
+    const value = Reflect.get(obj, key);
+    return typeof value === "number" ? value : undefined;
+}
+/**
+ * Checks if a value is iterable.
+ * @internal
+ */
+function isIterable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value[Symbol.iterator] === "function");
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/experimental/anthropic/utils.js

@@ -0,0 +1,20 @@
+/**
+ * Gets a number property from an object.
+ * @internal
+ */
+export function getNumberProperty(obj, key) {
+    if (!obj || typeof obj !== "object" || !(key in obj)) {
+        return undefined;
+    }
+    const value = Reflect.get(obj, key);
+    return typeof value === "number" ? value : undefined;
+}
+/**
+ * Checks if a value is iterable.
+ * @internal
+ */
+export function isIterable(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value[Symbol.iterator] === "function");
+}

package/dist/index.cjs

@@ -15,4 +15,4 @@ Object.defineProperty(exports, "uuid7FromTime", { enumerable: true, get: functio
 var prompts_cache_js_1 = require("./utils/prompts_cache.cjs");
 Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return prompts_cache_js_1.Cache; } });
 // Update using yarn bump-version
-exports.__version__ = "0.4.7";
+exports.__version__ = "0.4.9";

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, type CacheConfig, type CacheMetrics, } from "./utils/prompts_cache.js";
-export declare const __version__ = "0.4.7";
+export declare const __version__ = "0.4.9";

package/dist/index.js

@@ -5,4 +5,4 @@ export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, } from "./utils/prompts_cache.js";
 // Update using yarn bump-version
-export const __version__ = "0.4.7";
+export const __version__ = "0.4.9";

package/dist/traceable.cjs

@@ -297,7 +297,7 @@ const getSerializablePromise = (arg) => {
     });
     return promiseProxy;
 };
-const convertSerializableArg = (arg) => {
+const convertSerializableArg = (arg, options) => {
     if ((0, asserts_js_1.isReadableStream)(arg)) {
         const proxyState = [];
         const transform = new TransformStream({
@@ -386,7 +386,42 @@ const convertSerializableArg = (arg) => {
         return { converted, deferredInputs: true };
     }
     if ((0, asserts_js_1.isThenable)(arg)) {
-        return { converted: getSerializablePromise(arg), deferredInputs: true };
+        return {
+            converted: getSerializablePromise(arg),
+            deferredInputs: true,
+        };
+    }
+    const maxDepth = options?.maxDepth ?? 0;
+    const currentDepth = options?.depth ?? 0;
+    if (currentDepth < maxDepth) {
+        if (Array.isArray(arg)) {
+            const converted = [];
+            let deferredInputs = false;
+            for (let i = 0; i < arg.length; i++) {
+                const res = convertSerializableArg(arg[i], {
+                    depth: currentDepth + 1,
+                    maxDepth,
+                });
+                converted.push(res.converted);
+                deferredInputs = deferredInputs || res.deferredInputs;
+            }
+            return { converted, deferredInputs };
+        }
+        if (typeof arg === "object" && arg != null) {
+            const converted = {};
+            let deferredInputs = false;
+            for (const key in arg) {
+                if (Object.prototype.hasOwnProperty.call(arg, key)) {
+                    const res = convertSerializableArg(arg[key], {
+                        ...options,
+                        depth: currentDepth + 1,
+                    });
+                    converted[key] = res.converted;
+                    deferredInputs = deferredInputs || res.deferredInputs;
+                }
+            }
+            return { converted, deferredInputs };
+        }
     }
     return { converted: arg, deferredInputs: false };
 };
@@ -472,11 +507,10 @@ function traceable(wrappedFunc, config) {
             runEndedPromiseResolver();
         };
         const asyncLocalStorage = traceable_js_1.AsyncLocalStorageProviderSingleton.getInstance();
-        // TODO: deal with possible nested promises and async iterables
         const processedArgs = args;
         let deferredInputs = false;
         for (let i = 0; i < processedArgs.length; i++) {
-            const { converted, deferredInputs: argDefersInput } = convertSerializableArg(processedArgs[i]);
+            const { converted, deferredInputs: argDefersInput } = convertSerializableArg(processedArgs[i], config?.__deferredSerializableArgOptions);
             processedArgs[i] = converted;
             deferredInputs = deferredInputs || argDefersInput;
         }

package/dist/traceable.d.ts

@@ -19,6 +19,10 @@ export type TraceableConfig<Func extends (...args: any[]) => any> = Partial<Omit
     argsConfigPath?: [number] | [number, string];
     tracer?: OTELTracer;
     __finalTracedIteratorKey?: string;
+    __deferredSerializableArgOptions?: {
+        depth?: number;
+        maxDepth?: number;
+    };
     /**
      * Extract attachments from args and return remaining args.
      * @param args Arguments of the traced function

package/dist/traceable.js

@@ -293,7 +293,7 @@ const getSerializablePromise = (arg) => {
     });
     return promiseProxy;
 };
-const convertSerializableArg = (arg) => {
+const convertSerializableArg = (arg, options) => {
     if (isReadableStream(arg)) {
         const proxyState = [];
         const transform = new TransformStream({
@@ -382,7 +382,42 @@ const convertSerializableArg = (arg) => {
         return { converted, deferredInputs: true };
     }
     if (isThenable(arg)) {
-        return { converted: getSerializablePromise(arg), deferredInputs: true };
+        return {
+            converted: getSerializablePromise(arg),
+            deferredInputs: true,
+        };
+    }
+    const maxDepth = options?.maxDepth ?? 0;
+    const currentDepth = options?.depth ?? 0;
+    if (currentDepth < maxDepth) {
+        if (Array.isArray(arg)) {
+            const converted = [];
+            let deferredInputs = false;
+            for (let i = 0; i < arg.length; i++) {
+                const res = convertSerializableArg(arg[i], {
+                    depth: currentDepth + 1,
+                    maxDepth,
+                });
+                converted.push(res.converted);
+                deferredInputs = deferredInputs || res.deferredInputs;
+            }
+            return { converted, deferredInputs };
+        }
+        if (typeof arg === "object" && arg != null) {
+            const converted = {};
+            let deferredInputs = false;
+            for (const key in arg) {
+                if (Object.prototype.hasOwnProperty.call(arg, key)) {
+                    const res = convertSerializableArg(arg[key], {
+                        ...options,
+                        depth: currentDepth + 1,
+                    });
+                    converted[key] = res.converted;
+                    deferredInputs = deferredInputs || res.deferredInputs;
+                }
+            }
+            return { converted, deferredInputs };
+        }
     }
     return { converted: arg, deferredInputs: false };
 };
@@ -468,11 +503,10 @@ export function traceable(wrappedFunc, config) {
             runEndedPromiseResolver();
         };
         const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
-        // TODO: deal with possible nested promises and async iterables
         const processedArgs = args;
         let deferredInputs = false;
         for (let i = 0; i < processedArgs.length; i++) {
-            const { converted, deferredInputs: argDefersInput } = convertSerializableArg(processedArgs[i]);
+            const { converted, deferredInputs: argDefersInput } = convertSerializableArg(processedArgs[i], config?.__deferredSerializableArgOptions);
             processedArgs[i] = converted;
             deferredInputs = deferredInputs || argDefersInput;
         }

package/dist/utils/usage.cjs

@@ -2,28 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertAnthropicUsageToInputTokenDetails = void 0;
 const convertAnthropicUsageToInputTokenDetails = (usage) => {
-    const inputTokenDetails = {};
+    const result = {};
     if (usage.cache_creation != null &&
         typeof usage.cache_creation === "object") {
         const cacheCreation = usage.cache_creation;
         if (typeof cacheCreation.ephemeral_5m_input_tokens === "number") {
-            inputTokenDetails.ephemeral_5m_input_tokens =
+            result.ephemeral_5m_input_tokens =
                 cacheCreation.ephemeral_5m_input_tokens;
         }
         if (typeof cacheCreation.ephemeral_1h_input_tokens === "number") {
-            inputTokenDetails.ephemeral_1hr_input_tokens =
+            result.ephemeral_1hr_input_tokens =
                 cacheCreation.ephemeral_1h_input_tokens;
         }
         // If cache_creation not returned (no beta header passed),
         // fallback to assuming 5m cache tokens
     }
     else if (typeof usage.cache_creation_input_tokens === "number") {
-        inputTokenDetails.ephemeral_5m_input_tokens =
-            usage.cache_creation_input_tokens;
+        result.ephemeral_5m_input_tokens = usage.cache_creation_input_tokens;
     }
     if (typeof usage.cache_read_input_tokens === "number") {
-        inputTokenDetails.cache_read = usage.cache_read_input_tokens;
+        result.cache_read = usage.cache_read_input_tokens;
     }
-    return inputTokenDetails;
+    return result;
 };
 exports.convertAnthropicUsageToInputTokenDetails = convertAnthropicUsageToInputTokenDetails;

package/dist/utils/usage.js

@@ -1,25 +1,24 @@
 export const convertAnthropicUsageToInputTokenDetails = (usage) => {
-    const inputTokenDetails = {};
+    const result = {};
     if (usage.cache_creation != null &&
         typeof usage.cache_creation === "object") {
         const cacheCreation = usage.cache_creation;
         if (typeof cacheCreation.ephemeral_5m_input_tokens === "number") {
-            inputTokenDetails.ephemeral_5m_input_tokens =
+            result.ephemeral_5m_input_tokens =
                 cacheCreation.ephemeral_5m_input_tokens;
         }
         if (typeof cacheCreation.ephemeral_1h_input_tokens === "number") {
-            inputTokenDetails.ephemeral_1hr_input_tokens =
+            result.ephemeral_1hr_input_tokens =
                 cacheCreation.ephemeral_1h_input_tokens;
         }
         // If cache_creation not returned (no beta header passed),
         // fallback to assuming 5m cache tokens
     }
     else if (typeof usage.cache_creation_input_tokens === "number") {
-        inputTokenDetails.ephemeral_5m_input_tokens =
-            usage.cache_creation_input_tokens;
+        result.ephemeral_5m_input_tokens = usage.cache_creation_input_tokens;
     }
     if (typeof usage.cache_read_input_tokens === "number") {
-        inputTokenDetails.cache_read = usage.cache_read_input_tokens;
+        result.cache_read = usage.cache_read_input_tokens;
     }
-    return inputTokenDetails;
+    return result;
 };