langsmith 0.7.5 → 0.7.6

package/dist/sandbox/types.d.ts

@@ -249,6 +249,27 @@ export interface SandboxAccessControl {
     /** Hosts the sandbox is blocked from reaching. */
     deny_list?: string[];
 }
+/** Secret value reference for sandbox proxy rules. */
+export interface SandboxProxySecret {
+    /** `workspace_secret` references a workspace secret; `opaque` is write-only. */
+    type: "workspace_secret" | "opaque";
+    /** Workspace secret reference or opaque secret value. */
+    value: string;
+}
+/** AWS auth rule for sandbox proxy SigV4 signing. */
+export interface SandboxAwsAuthRule {
+    /** Rule name. */
+    name: string;
+    /** AWS auth rules are matched by the sandbox proxy's AWS endpoint matcher. */
+    type: "aws";
+    /** Whether the rule is enabled. */
+    enabled?: boolean;
+    /** AWS credentials used by the proxy signer. */
+    aws: {
+        access_key_id: SandboxProxySecret;
+        secret_access_key: SandboxProxySecret;
+    };
+}
 /**
  * Full proxy configuration forwarded to the sandbox server as-is (snake_case
  * so it's wire-compatible with the backend). Mirrors the server's
@@ -312,7 +333,8 @@ export interface CreateSandboxOptions {
      * Per-sandbox proxy configuration. Use
      * `{ access_control: { allow_list: ["github.com", "*.example.com"] } }`
      * to restrict outbound HTTPS to a set of host patterns. Forwarded to the
-     * server as-is on the wire.
+     * server as-is on the wire. Use `awsAuthProxyConfig` to let the proxy sign
+     * supported AWS HTTPS requests on the sandbox's behalf.
      */
     proxyConfig?: SandboxProxyConfig;
 }

package/dist/utils/fs.browser.cjs

@@ -20,6 +20,9 @@ exports.writeFileSync = writeFileSync;
 exports.renameSync = renameSync;
 exports.unlinkSync = unlinkSync;
 exports.readFileSync = readFileSync;
+exports.mkdirExclusive = mkdirExclusive;
+exports.statMtimeMs = statMtimeMs;
+exports.rmRecursive = rmRecursive;
 exports.path = {
     join: (...parts) => parts.join("/"),
     dirname: (p) => p.split("/").slice(0, -1).join("/"),
@@ -49,3 +52,11 @@ function unlinkSync(_filePath) { }
 function readFileSync(_filePath) {
     return "";
 }
+// ---------------------------------------------------------------------------
+// Lock primitives – no-op / safe defaults in browser
+// ---------------------------------------------------------------------------
+async function mkdirExclusive(_dir) { }
+function statMtimeMs(_filePath) {
+    return undefined;
+}
+async function rmRecursive(_filePath) { }

package/dist/utils/fs.browser.d.ts

@@ -23,3 +23,6 @@ export declare function writeFileSync(_filePath: string, _content: string): void
 export declare function renameSync(_oldPath: string, _newPath: string): void;
 export declare function unlinkSync(_filePath: string): void;
 export declare function readFileSync(_filePath: string): string;
+export declare function mkdirExclusive(_dir: string): Promise<void>;
+export declare function statMtimeMs(_filePath: string): number | undefined;
+export declare function rmRecursive(_filePath: string): Promise<void>;

package/dist/utils/fs.browser.js

@@ -35,3 +35,11 @@ export function unlinkSync(_filePath) { }
 export function readFileSync(_filePath) {
     return "";
 }
+// ---------------------------------------------------------------------------
+// Lock primitives – no-op / safe defaults in browser
+// ---------------------------------------------------------------------------
+export async function mkdirExclusive(_dir) { }
+export function statMtimeMs(_filePath) {
+    return undefined;
+}
+export async function rmRecursive(_filePath) { }

package/dist/utils/fs.cjs

@@ -51,6 +51,9 @@ exports.writeFileSync = writeFileSync;
 exports.renameSync = renameSync;
 exports.unlinkSync = unlinkSync;
 exports.readFileSync = readFileSync;
+exports.mkdirExclusive = mkdirExclusive;
+exports.statMtimeMs = statMtimeMs;
+exports.rmRecursive = rmRecursive;
 const nodeFs = __importStar(require("node:fs"));
 const nodeFsPromises = __importStar(require("node:fs/promises"));
 const nodePath = __importStar(require("node:path"));
@@ -99,3 +102,22 @@ function unlinkSync(filePath) {
 function readFileSync(filePath) {
     return nodeFs.readFileSync(filePath, "utf-8");
 }
+// ---------------------------------------------------------------------------
+// Lock primitives (used by the OAuth refresh directory lock)
+// ---------------------------------------------------------------------------
+async function mkdirExclusive(dir) {
+    // Non-recursive mkdir throws EEXIST if the directory already exists, which
+    // is the atomic test-and-set the cross-process lock relies on.
+    await nodeFsPromises.mkdir(dir, { mode: 0o700 });
+}
+function statMtimeMs(filePath) {
+    try {
+        return nodeFs.statSync(filePath).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function rmRecursive(filePath) {
+    await nodeFsPromises.rm(filePath, { recursive: true, force: true });
+}

package/dist/utils/fs.d.ts

@@ -19,3 +19,6 @@ export declare function writeFileSync(filePath: string, content: string): void;
 export declare function renameSync(oldPath: string, newPath: string): void;
 export declare function unlinkSync(filePath: string): void;
 export declare function readFileSync(filePath: string): string;
+export declare function mkdirExclusive(dir: string): Promise<void>;
+export declare function statMtimeMs(filePath: string): number | undefined;
+export declare function rmRecursive(filePath: string): Promise<void>;

package/dist/utils/fs.js

@@ -52,3 +52,22 @@ export function unlinkSync(filePath) {
 export function readFileSync(filePath) {
     return nodeFs.readFileSync(filePath, "utf-8");
 }
+// ---------------------------------------------------------------------------
+// Lock primitives (used by the OAuth refresh directory lock)
+// ---------------------------------------------------------------------------
+export async function mkdirExclusive(dir) {
+    // Non-recursive mkdir throws EEXIST if the directory already exists, which
+    // is the atomic test-and-set the cross-process lock relies on.
+    await nodeFsPromises.mkdir(dir, { mode: 0o700 });
+}
+export function statMtimeMs(filePath) {
+    try {
+        return nodeFs.statSync(filePath).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function rmRecursive(filePath) {
+    await nodeFsPromises.rm(filePath, { recursive: true, force: true });
+}

package/dist/utils/profile-lock.cjs

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._internal = void 0;
+exports.acquireOAuthRefreshLock = acquireOAuthRefreshLock;
+const fsUtils = __importStar(require("./fs.cjs"));
+const LOCK_POLL_INTERVAL_MS = 10;
+const LOCK_STALE_AFTER_MS = 10_000;
+const LOCK_METADATA_FILE = "created_at";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isEEXIST(err) {
+    return (typeof err === "object" &&
+        err !== null &&
+        err.code === "EEXIST");
+}
+function lockMetadataLines(lockDir) {
+    try {
+        return fsUtils
+            .readFileSync(fsUtils.path.join(lockDir, LOCK_METADATA_FILE))
+            .split("\n");
+    }
+    catch {
+        return undefined;
+    }
+}
+function lockCreatedAtMs(lockDir) {
+    const lines = lockMetadataLines(lockDir);
+    if (lines && lines[0] && lines[0].trim()) {
+        const parsed = Date.parse(lines[0].trim());
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    return fsUtils.statMtimeMs(lockDir);
+}
+function lockOwner(lockDir) {
+    const lines = lockMetadataLines(lockDir);
+    if (lines && lines.length >= 2 && lines[1].trim()) {
+        return lines[1].trim();
+    }
+    return undefined;
+}
+async function removeStaleLock(lockDir) {
+    const createdAt = lockCreatedAtMs(lockDir);
+    if (createdAt === undefined ||
+        Date.now() - createdAt <= LOCK_STALE_AFTER_MS) {
+        return false;
+    }
+    await fsUtils.rmRecursive(lockDir);
+    return true;
+}
+/**
+ * Acquire an exclusive cross-process lock for refreshing OAuth tokens.
+ *
+ * Uses an atomic-`mkdir` directory lock at `<configPath>.oauth.lock.lock` with a
+ * stale-break heuristic and owner-checked release, mirroring langsmith-go's
+ * non-POSIX path. `deadline` is a `Date.now()`-based timestamp; acquisition
+ * rejects once it passes. Callers treat any rejection as "skip refresh, use the
+ * current token".
+ */
+async function acquireOAuthRefreshLock(configPath, deadline) {
+    const lockDir = `${configPath}.oauth.lock.lock`;
+    const parent = fsUtils.path.dirname(lockDir);
+    if (parent) {
+        await fsUtils.mkdir(parent);
+    }
+    const owner = globalThis.crypto.randomUUID();
+    for (;;) {
+        try {
+            await fsUtils.mkdirExclusive(lockDir);
+        }
+        catch (err) {
+            if (!isEEXIST(err)) {
+                throw err;
+            }
+            if (!(await removeStaleLock(lockDir))) {
+                if (Date.now() >= deadline) {
+                    throw new Error("timed out acquiring OAuth refresh lock");
+                }
+                await sleep(Math.min(LOCK_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+            }
+            continue;
+        }
+        try {
+            await fsUtils.writeFileAtomic(fsUtils.path.join(lockDir, LOCK_METADATA_FILE), `${new Date().toISOString()}\n${owner}\n`);
+        }
+        catch (err) {
+            await fsUtils.rmRecursive(lockDir);
+            throw err;
+        }
+        break;
+    }
+    return {
+        async release() {
+            if (lockOwner(lockDir) === owner) {
+                await fsUtils.rmRecursive(lockDir);
+            }
+        },
+    };
+}
+// Exposed for tests only.
+exports._internal = {
+    LOCK_METADATA_FILE,
+    LOCK_STALE_AFTER_MS,
+    lockOwner,
+};

package/dist/utils/profile-lock.d.ts

@@ -0,0 +1,20 @@
+export interface OAuthRefreshLock {
+    release(): Promise<void>;
+}
+declare function lockOwner(lockDir: string): string | undefined;
+/**
+ * Acquire an exclusive cross-process lock for refreshing OAuth tokens.
+ *
+ * Uses an atomic-`mkdir` directory lock at `<configPath>.oauth.lock.lock` with a
+ * stale-break heuristic and owner-checked release, mirroring langsmith-go's
+ * non-POSIX path. `deadline` is a `Date.now()`-based timestamp; acquisition
+ * rejects once it passes. Callers treat any rejection as "skip refresh, use the
+ * current token".
+ */
+export declare function acquireOAuthRefreshLock(configPath: string, deadline: number): Promise<OAuthRefreshLock>;
+export declare const _internal: {
+    LOCK_METADATA_FILE: string;
+    LOCK_STALE_AFTER_MS: number;
+    lockOwner: typeof lockOwner;
+};
+export {};

package/dist/utils/profile-lock.js

@@ -0,0 +1,103 @@
+import * as fsUtils from "./fs.js";
+const LOCK_POLL_INTERVAL_MS = 10;
+const LOCK_STALE_AFTER_MS = 10_000;
+const LOCK_METADATA_FILE = "created_at";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isEEXIST(err) {
+    return (typeof err === "object" &&
+        err !== null &&
+        err.code === "EEXIST");
+}
+function lockMetadataLines(lockDir) {
+    try {
+        return fsUtils
+            .readFileSync(fsUtils.path.join(lockDir, LOCK_METADATA_FILE))
+            .split("\n");
+    }
+    catch {
+        return undefined;
+    }
+}
+function lockCreatedAtMs(lockDir) {
+    const lines = lockMetadataLines(lockDir);
+    if (lines && lines[0] && lines[0].trim()) {
+        const parsed = Date.parse(lines[0].trim());
+        if (!Number.isNaN(parsed)) {
+            return parsed;
+        }
+    }
+    return fsUtils.statMtimeMs(lockDir);
+}
+function lockOwner(lockDir) {
+    const lines = lockMetadataLines(lockDir);
+    if (lines && lines.length >= 2 && lines[1].trim()) {
+        return lines[1].trim();
+    }
+    return undefined;
+}
+async function removeStaleLock(lockDir) {
+    const createdAt = lockCreatedAtMs(lockDir);
+    if (createdAt === undefined ||
+        Date.now() - createdAt <= LOCK_STALE_AFTER_MS) {
+        return false;
+    }
+    await fsUtils.rmRecursive(lockDir);
+    return true;
+}
+/**
+ * Acquire an exclusive cross-process lock for refreshing OAuth tokens.
+ *
+ * Uses an atomic-`mkdir` directory lock at `<configPath>.oauth.lock.lock` with a
+ * stale-break heuristic and owner-checked release, mirroring langsmith-go's
+ * non-POSIX path. `deadline` is a `Date.now()`-based timestamp; acquisition
+ * rejects once it passes. Callers treat any rejection as "skip refresh, use the
+ * current token".
+ */
+export async function acquireOAuthRefreshLock(configPath, deadline) {
+    const lockDir = `${configPath}.oauth.lock.lock`;
+    const parent = fsUtils.path.dirname(lockDir);
+    if (parent) {
+        await fsUtils.mkdir(parent);
+    }
+    const owner = globalThis.crypto.randomUUID();
+    for (;;) {
+        try {
+            await fsUtils.mkdirExclusive(lockDir);
+        }
+        catch (err) {
+            if (!isEEXIST(err)) {
+                throw err;
+            }
+            if (!(await removeStaleLock(lockDir))) {
+                if (Date.now() >= deadline) {
+                    throw new Error("timed out acquiring OAuth refresh lock");
+                }
+                await sleep(Math.min(LOCK_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+            }
+            continue;
+        }
+        try {
+            await fsUtils.writeFileAtomic(fsUtils.path.join(lockDir, LOCK_METADATA_FILE), `${new Date().toISOString()}\n${owner}\n`);
+        }
+        catch (err) {
+            await fsUtils.rmRecursive(lockDir);
+            throw err;
+        }
+        break;
+    }
+    return {
+        async release() {
+            if (lockOwner(lockDir) === owner) {
+                await fsUtils.rmRecursive(lockDir);
+            }
+        },
+    };
+}
+// Exposed for tests only.
+export const _internal = {
+    LOCK_METADATA_FILE,
+    LOCK_STALE_AFTER_MS,
+    lockOwner,
+};

package/dist/utils/profiles.cjs

@@ -38,6 +38,7 @@ exports.hasValue = hasValue;
 exports.loadProfileClientConfig = loadProfileClientConfig;
 const env_js_1 = require("./env.cjs");
 const fsUtils = __importStar(require("./fs.cjs"));
+const profile_lock_js_1 = require("./profile-lock.cjs");
 exports.DEFAULT_API_URL = "https://api.smith.langchain.com";
 const OAUTH_CLIENT_ID = "langsmith-cli";
 const TOKEN_REFRESH_LEEWAY_MS = 60_000;
@@ -227,17 +228,39 @@ class ProfileAuth {
     isProfileAuthorizationHeader(value) {
         return value === this.managedAuthorizationValue;
     }
+    reloadProfile() {
+        try {
+            const config = JSON.parse(fsUtils.readFileSync(this.state.configPath));
+            const profile = config.profiles?.[this.state.profileName];
+            if (!profile) {
+                return undefined;
+            }
+            this.state.config = config;
+            this.state.profile = profile;
+            return profile;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async refreshOAuthToken(fetchImplementation) {
         const refreshToken = this.state.profile.oauth?.refresh_token;
         if (!refreshToken) {
             return;
         }
         const refreshApiUrl = trimConfigValue(this.state.profile.api_url) ?? exports.DEFAULT_API_URL;
+        const deadline = Date.now() + TOKEN_REFRESH_TIMEOUT_MS;
+        let lock;
         try {
+            lock = await (0, profile_lock_js_1.acquireOAuthRefreshLock)(this.state.configPath, deadline);
+            const fresh = this.reloadProfile();
+            if (fresh && !shouldRefreshProfileToken(this.state.profile)) {
+                return;
+            }
             const body = new URLSearchParams({
                 grant_type: "refresh_token",
                 client_id: OAUTH_CLIENT_ID,
-                refresh_token: refreshToken,
+                refresh_token: this.state.profile.oauth?.refresh_token ?? refreshToken,
             });
             const response = await fetchImplementation(`${normalizeConfigUrl(refreshApiUrl)}/oauth/token`, {
                 method: "POST",
@@ -245,7 +268,7 @@ class ProfileAuth {
                     "Content-Type": "application/x-www-form-urlencoded",
                 },
                 body: body.toString(),
-                signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS),
+                signal: AbortSignal.timeout(Math.max(0, deadline - Date.now())),
             });
             if (!response.ok) {
                 return;
@@ -262,6 +285,9 @@ class ProfileAuth {
         catch {
             return;
         }
+        finally {
+            await lock?.release();
+        }
     }
     rememberProfileAuthHeader(header) {
         this.managedAuthorizationValue =

package/dist/utils/profiles.d.ts

@@ -42,6 +42,7 @@ export declare class ProfileAuth {
     currentAuthHeader(): ProfileAuthHeader | undefined;
     getAuthHeader(fetchImplementation: typeof fetch, signal?: AbortSignal | null): Promise<ProfileAuthHeader | undefined>;
     isProfileAuthorizationHeader(value: string): boolean;
+    private reloadProfile;
     private refreshOAuthToken;
     private rememberProfileAuthHeader;
 }

package/dist/utils/profiles.js

@@ -1,5 +1,6 @@
 import { getEnv, getEnvironmentVariable } from "./env.js";
 import * as fsUtils from "./fs.js";
+import { acquireOAuthRefreshLock } from "./profile-lock.js";
 export const DEFAULT_API_URL = "https://api.smith.langchain.com";
 const OAUTH_CLIENT_ID = "langsmith-cli";
 const TOKEN_REFRESH_LEEWAY_MS = 60_000;
@@ -189,17 +190,39 @@ export class ProfileAuth {
     isProfileAuthorizationHeader(value) {
         return value === this.managedAuthorizationValue;
     }
+    reloadProfile() {
+        try {
+            const config = JSON.parse(fsUtils.readFileSync(this.state.configPath));
+            const profile = config.profiles?.[this.state.profileName];
+            if (!profile) {
+                return undefined;
+            }
+            this.state.config = config;
+            this.state.profile = profile;
+            return profile;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async refreshOAuthToken(fetchImplementation) {
         const refreshToken = this.state.profile.oauth?.refresh_token;
         if (!refreshToken) {
             return;
         }
         const refreshApiUrl = trimConfigValue(this.state.profile.api_url) ?? DEFAULT_API_URL;
+        const deadline = Date.now() + TOKEN_REFRESH_TIMEOUT_MS;
+        let lock;
         try {
+            lock = await acquireOAuthRefreshLock(this.state.configPath, deadline);
+            const fresh = this.reloadProfile();
+            if (fresh && !shouldRefreshProfileToken(this.state.profile)) {
+                return;
+            }
             const body = new URLSearchParams({
                 grant_type: "refresh_token",
                 client_id: OAUTH_CLIENT_ID,
-                refresh_token: refreshToken,
+                refresh_token: this.state.profile.oauth?.refresh_token ?? refreshToken,
             });
             const response = await fetchImplementation(`${normalizeConfigUrl(refreshApiUrl)}/oauth/token`, {
                 method: "POST",
@@ -207,7 +230,7 @@ export class ProfileAuth {
                     "Content-Type": "application/x-www-form-urlencoded",
                 },
                 body: body.toString(),
-                signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS),
+                signal: AbortSignal.timeout(Math.max(0, deadline - Date.now())),
             });
             if (!response.ok) {
                 return;
@@ -224,6 +247,9 @@ export class ProfileAuth {
         catch {
             return;
         }
+        finally {
+            await lock?.release();
+        }
     }
     rememberProfileAuthHeader(header) {
         this.managedAuthorizationValue =

package/dist/wrappers/gemini.cjs

@@ -2,44 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapGemini = wrapGemini;
 const traceable_js_1 = require("../traceable.cjs");
-const _createUsageMetadata = (usage) => {
-    const usageMetadata = {
-        input_tokens: usage.promptTokenCount || 0,
-        output_tokens: (() => {
-            if ("responseTokenCount" in usage) {
-                return usage.responseTokenCount || 0;
-            }
-            if ("candidatesTokenCount" in usage) {
-                return usage.candidatesTokenCount || 0;
-            }
-            return 0;
-        })(),
-        total_tokens: usage.totalTokenCount || 0,
-    };
-    // Add input token details if available
-    usageMetadata.input_token_details = {
-        ...(usage.cachedContentTokenCount && {
-            cache_read_over_200k: Math.max(0, usage.cachedContentTokenCount - 200000),
-        }),
-        ...(usage.promptTokenCount && {
-            over_200k: Math.max(0, usage.promptTokenCount - 200000),
-        }),
-        ...(usage.cachedContentTokenCount && {
-            cache_read: usage.cachedContentTokenCount,
-        }),
-    };
-    // Add output token details if available
-    usageMetadata.output_token_details = {
-        ...("candidatesTokenCount" in usage &&
-            usage.candidatesTokenCount != null && {
-            over_200k: Math.max(0, usage.candidatesTokenCount - 200000),
-        }),
-        ...(usage.thoughtsTokenCount && {
-            reasoning: usage.thoughtsTokenCount,
-        }),
-    };
-    return usageMetadata;
-};
+const gemini_utils_js_1 = require("./gemini.utils.cjs");
 const chatAggregator = (input) => {
     const chunks = Array.isArray(input) &&
         input.every((item) => typeof item === "object" && item !== null)
@@ -161,7 +124,7 @@ const chatAggregator = (input) => {
         result.safety_ratings = safetyRatings;
     }
     if (usageMetadata) {
-        result.usage_metadata = _createUsageMetadata(usageMetadata);
+        result.usage_metadata = (0, gemini_utils_js_1.createGeminiUsageMetadata)(usageMetadata);
     }
     return result;
 };
@@ -354,7 +317,7 @@ function processGeminiOutputs(outputs) {
         result.safety_ratings = safetyRatings;
     }
     if ("usageMetadata" in response && response.usageMetadata) {
-        result.usage_metadata = _createUsageMetadata(response.usageMetadata);
+        result.usage_metadata = (0, gemini_utils_js_1.createGeminiUsageMetadata)(response.usageMetadata);
     }
     return result;
 }

package/dist/wrappers/gemini.js

@@ -1,42 +1,5 @@
 import { isTraceableFunction, traceable, } from "../traceable.js";
-const _createUsageMetadata = (usage) => {
-    const usageMetadata = {
-        input_tokens: usage.promptTokenCount || 0,
-        output_tokens: (() => {
-            if ("responseTokenCount" in usage) {
-                return usage.responseTokenCount || 0;
-            }
-            if ("candidatesTokenCount" in usage) {
-                return usage.candidatesTokenCount || 0;
-            }
-            return 0;
-        })(),
-        total_tokens: usage.totalTokenCount || 0,
-    };
-    // Add input token details if available
-    usageMetadata.input_token_details = {
-        ...(usage.cachedContentTokenCount && {
-            cache_read_over_200k: Math.max(0, usage.cachedContentTokenCount - 200000),
-        }),
-        ...(usage.promptTokenCount && {
-            over_200k: Math.max(0, usage.promptTokenCount - 200000),
-        }),
-        ...(usage.cachedContentTokenCount && {
-            cache_read: usage.cachedContentTokenCount,
-        }),
-    };
-    // Add output token details if available
-    usageMetadata.output_token_details = {
-        ...("candidatesTokenCount" in usage &&
-            usage.candidatesTokenCount != null && {
-            over_200k: Math.max(0, usage.candidatesTokenCount - 200000),
-        }),
-        ...(usage.thoughtsTokenCount && {
-            reasoning: usage.thoughtsTokenCount,
-        }),
-    };
-    return usageMetadata;
-};
+import { createGeminiUsageMetadata } from "./gemini.utils.js";
 const chatAggregator = (input) => {
     const chunks = Array.isArray(input) &&
         input.every((item) => typeof item === "object" && item !== null)
@@ -158,7 +121,7 @@ const chatAggregator = (input) => {
         result.safety_ratings = safetyRatings;
     }
     if (usageMetadata) {
-        result.usage_metadata = _createUsageMetadata(usageMetadata);
+        result.usage_metadata = createGeminiUsageMetadata(usageMetadata);
     }
     return result;
 };
@@ -351,7 +314,7 @@ function processGeminiOutputs(outputs) {
         result.safety_ratings = safetyRatings;
     }
     if ("usageMetadata" in response && response.usageMetadata) {
-        result.usage_metadata = _createUsageMetadata(response.usageMetadata);
+        result.usage_metadata = createGeminiUsageMetadata(response.usageMetadata);
     }
     return result;
 }