langsmith 0.3.50 → 0.3.52

package/dist/client.cjs

@@ -588,11 +588,11 @@ class Client {
         if (patch) {
             const sampled = [];
             for (const run of runs) {
-                if (!this.filteredPostUuids.has(run.id)) {
+                if (!this.filteredPostUuids.has(run.trace_id)) {
                     sampled.push(run);
                 }
-                else {
-                    this.filteredPostUuids.delete(run.id);
+                else if (run.id === run.trace_id) {
+                    this.filteredPostUuids.delete(run.trace_id);
                 }
             }
             return sampled;

package/dist/client.js

@@ -550,11 +550,11 @@ export class Client {
         if (patch) {
             const sampled = [];
             for (const run of runs) {
-                if (!this.filteredPostUuids.has(run.id)) {
+                if (!this.filteredPostUuids.has(run.trace_id)) {
                     sampled.push(run);
                 }
-                else {
-                    this.filteredPostUuids.delete(run.id);
+                else if (run.id === run.trace_id) {
+                    this.filteredPostUuids.delete(run.trace_id);
                 }
             }
             return sampled;

package/dist/index.cjs

@@ -10,4 +10,4 @@ Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true
 var project_js_1 = require("./utils/project.cjs");
 Object.defineProperty(exports, "getDefaultProjectName", { enumerable: true, get: function () { return project_js_1.getDefaultProjectName; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.50";
+exports.__version__ = "0.3.52";

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, }
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
-export declare const __version__ = "0.3.50";
+export declare const __version__ = "0.3.52";

package/dist/index.js

@@ -3,4 +3,4 @@ export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.50";
+export const __version__ = "0.3.52";

package/dist/run_trees.cjs

@@ -776,17 +776,62 @@ function _getWriteReplicasFromEnv() {
         return [];
     try {
         const parsed = JSON.parse(envVar);
-        _checkEndpointEnvUnset(parsed);
-        return Object.entries(parsed).map(([url, key]) => ({
-            apiUrl: url.replace(/\/$/, ""),
-            apiKey: key,
-        }));
+        if (Array.isArray(parsed)) {
+            const replicas = [];
+            for (const item of parsed) {
+                if (typeof item !== "object" || item === null) {
+                    console.warn(`Invalid item type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected object, got ${typeof item}`);
+                    continue;
+                }
+                if (typeof item.api_url !== "string") {
+                    console.warn(`Invalid api_url type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected string, got ${typeof item.api_url}`);
+                    continue;
+                }
+                if (typeof item.api_key !== "string") {
+                    console.warn(`Invalid api_key type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected string, got ${typeof item.api_key}`);
+                    continue;
+                }
+                replicas.push({
+                    apiUrl: item.api_url.replace(/\/$/, ""),
+                    apiKey: item.api_key,
+                });
+            }
+            return replicas;
+        }
+        else if (typeof parsed === "object" && parsed !== null) {
+            _checkEndpointEnvUnset(parsed);
+            const replicas = [];
+            for (const [url, key] of Object.entries(parsed)) {
+                const cleanUrl = url.replace(/\/$/, "");
+                if (typeof key === "string") {
+                    replicas.push({
+                        apiUrl: cleanUrl,
+                        apiKey: key,
+                    });
+                }
+                else {
+                    console.warn(`Invalid value type in LANGSMITH_RUNS_ENDPOINTS for URL ${url}: ` +
+                        `expected string, got ${typeof key}`);
+                    continue;
+                }
+            }
+            return replicas;
+        }
+        else {
+            console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of " +
+                `objects with api_url and api_key properties, or object mapping url->apiKey, got ${typeof parsed}`);
+            return [];
+        }
     }
     catch (e) {
         if ((0, error_js_1.isConflictingEndpointsError)(e)) {
             throw e;
         }
-        console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON mapping of url->apiKey");
+        console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of " +
+            "objects with api_url and api_key properties, or object mapping url->apiKey");
         return [];
     }
 }

package/dist/run_trees.js

@@ -735,17 +735,62 @@ function _getWriteReplicasFromEnv() {
         return [];
     try {
         const parsed = JSON.parse(envVar);
-        _checkEndpointEnvUnset(parsed);
-        return Object.entries(parsed).map(([url, key]) => ({
-            apiUrl: url.replace(/\/$/, ""),
-            apiKey: key,
-        }));
+        if (Array.isArray(parsed)) {
+            const replicas = [];
+            for (const item of parsed) {
+                if (typeof item !== "object" || item === null) {
+                    console.warn(`Invalid item type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected object, got ${typeof item}`);
+                    continue;
+                }
+                if (typeof item.api_url !== "string") {
+                    console.warn(`Invalid api_url type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected string, got ${typeof item.api_url}`);
+                    continue;
+                }
+                if (typeof item.api_key !== "string") {
+                    console.warn(`Invalid api_key type in LANGSMITH_RUNS_ENDPOINTS: ` +
+                        `expected string, got ${typeof item.api_key}`);
+                    continue;
+                }
+                replicas.push({
+                    apiUrl: item.api_url.replace(/\/$/, ""),
+                    apiKey: item.api_key,
+                });
+            }
+            return replicas;
+        }
+        else if (typeof parsed === "object" && parsed !== null) {
+            _checkEndpointEnvUnset(parsed);
+            const replicas = [];
+            for (const [url, key] of Object.entries(parsed)) {
+                const cleanUrl = url.replace(/\/$/, "");
+                if (typeof key === "string") {
+                    replicas.push({
+                        apiUrl: cleanUrl,
+                        apiKey: key,
+                    });
+                }
+                else {
+                    console.warn(`Invalid value type in LANGSMITH_RUNS_ENDPOINTS for URL ${url}: ` +
+                        `expected string, got ${typeof key}`);
+                    continue;
+                }
+            }
+            return replicas;
+        }
+        else {
+            console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of " +
+                `objects with api_url and api_key properties, or object mapping url->apiKey, got ${typeof parsed}`);
+            return [];
+        }
     }
     catch (e) {
         if (isConflictingEndpointsError(e)) {
             throw e;
         }
-        console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON mapping of url->apiKey");
+        console.warn("Invalid LANGSMITH_RUNS_ENDPOINTS – must be valid JSON array of " +
+            "objects with api_url and api_key properties, or object mapping url->apiKey");
         return [];
     }
 }

package/dist/vercel.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AISDKExporter = void 0;
+exports.AISDKExporter = exports.toStrippedIsoTime = exports.parseStrippedIsoTime = void 0;
+exports.getMutableRunCreate = getMutableRunCreate;
 const vercel_js_1 = require("./utils/vercel.cjs");
 const index_js_1 = require("./index.cjs");
 const uuid_1 = require("uuid");
@@ -172,20 +173,58 @@ function reparentDotOrder(dotOrder, sourceRunId, parentDotOrder) {
         return dotOrder;
     return joinDotOrder(...parentDotOrder.split("."), ...segments.slice(sourceIndex));
 }
+// Helper function to convert stripped ISO string back to parseable format
+const parseStrippedIsoTime = (stripped) => {
+    // Insert back the removed characters: YYYYMMDDTHHMMSSSSSSSS -> YYYY-MM-DDTHH:MM:SS.SSSZ
+    // The stripped format is timestamp part only (no Z - that becomes the separator)
+    // Format includes microseconds: 20231201T120000000000 (milliseconds + microseconds)
+    const year = stripped.slice(0, 4);
+    const month = stripped.slice(4, 6);
+    const day = stripped.slice(6, 8);
+    const hour = stripped.slice(9, 11); // Skip 'T'
+    const minute = stripped.slice(11, 13);
+    const second = stripped.slice(13, 15);
+    const ms = stripped.slice(15, 18); // Only use first 3 digits for milliseconds
+    // Ignore microseconds (18-21) as Date only has millisecond precision
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`);
+};
+exports.parseStrippedIsoTime = parseStrippedIsoTime;
+// Helper function to convert Date back to stripped format
+const toStrippedIsoTime = (date) => {
+    return stripNonAlphanumeric(date.toISOString().slice(0, -1)) + "000";
+};
+exports.toStrippedIsoTime = toStrippedIsoTime;
 function getMutableRunCreate(dotOrder) {
     const segments = dotOrder.split(".").map((i) => {
         const [startTime, runId] = i.split("Z");
         return { startTime, runId };
     });
+    // Iteratively check and fix timing to ensure each segment is greater than its parent
+    for (let i = 1; i < segments.length; i++) {
+        const parentTime = (0, exports.parseStrippedIsoTime)(segments[i - 1].startTime);
+        const currentTime = (0, exports.parseStrippedIsoTime)(segments[i].startTime);
+        if (currentTime.getTime() <= parentTime.getTime()) {
+            // Increment by 1 millisecond to make it greater than parent
+            const newTime = new Date(parentTime.getTime() + 1);
+            segments[i].startTime = (0, exports.toStrippedIsoTime)(newTime);
+        }
+    }
+    // Reconstruct the dotted order with potentially updated timestamps
+    const updatedDotOrder = segments
+        .map((segment) => `${segment.startTime}Z${segment.runId}`)
+        .join(".");
     const traceId = segments[0].runId;
     const parentRunId = segments.at(-2)?.runId;
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const runId = segments.at(-1).runId;
+    // If this is the last segment (current run), set start_time to its ISO timestamp
+    const lastSegmentTime = (0, exports.parseStrippedIsoTime)(segments.at(-1).startTime);
     return {
         id: runId,
         trace_id: traceId,
-        dotted_order: dotOrder,
+        dotted_order: updatedDotOrder,
         parent_run_id: parentRunId,
+        start_time: lastSegmentTime.toISOString(),
     };
 }
 function convertToTimestamp([seconds, nanoseconds]) {
@@ -777,10 +816,15 @@ class AISDKExporter {
                         }
                         this.seenSpanInfo[task.id].dotOrder = taskDotOrder;
                         if (!this.seenSpanInfo[task.id].sent) {
-                            sampled.push({
+                            const updated = {
                                 ...task.run,
                                 ...getMutableRunCreate(taskDotOrder),
-                            });
+                            };
+                            if (updated.end_time !== undefined &&
+                                updated.end_time < updated.start_time) {
+                                updated.end_time = new Date(new Date(updated.start_time).getTime() + 1).toISOString();
+                            }
+                            sampled.push(updated);
                         }
                         this.seenSpanInfo[task.id].sent = true;
                     }

package/dist/vercel.d.ts

@@ -7,6 +7,16 @@ export interface TelemetrySettings extends AITelemetrySettings {
     /** Name of the run sent to LangSmith */
     runName?: string;
 }
+interface MutableRunCreate {
+    id: string;
+    trace_id: string;
+    dotted_order: string;
+    parent_run_id: string | undefined;
+    start_time: string;
+}
+export declare const parseStrippedIsoTime: (stripped: string) => Date;
+export declare const toStrippedIsoTime: (date: Date) => string;
+export declare function getMutableRunCreate(dotOrder: string): MutableRunCreate;
 /**
  * OpenTelemetry trace exporter for Vercel AI SDK.
  *
@@ -81,3 +91,4 @@ export declare class AISDKExporter {
     forceFlush(): Promise<void>;
     protected logDebug(...args: Parameters<typeof console.debug>): void;
 }
+export {};

package/dist/vercel.js

@@ -169,20 +169,56 @@ function reparentDotOrder(dotOrder, sourceRunId, parentDotOrder) {
         return dotOrder;
     return joinDotOrder(...parentDotOrder.split("."), ...segments.slice(sourceIndex));
 }
-function getMutableRunCreate(dotOrder) {
+// Helper function to convert stripped ISO string back to parseable format
+export const parseStrippedIsoTime = (stripped) => {
+    // Insert back the removed characters: YYYYMMDDTHHMMSSSSSSSS -> YYYY-MM-DDTHH:MM:SS.SSSZ
+    // The stripped format is timestamp part only (no Z - that becomes the separator)
+    // Format includes microseconds: 20231201T120000000000 (milliseconds + microseconds)
+    const year = stripped.slice(0, 4);
+    const month = stripped.slice(4, 6);
+    const day = stripped.slice(6, 8);
+    const hour = stripped.slice(9, 11); // Skip 'T'
+    const minute = stripped.slice(11, 13);
+    const second = stripped.slice(13, 15);
+    const ms = stripped.slice(15, 18); // Only use first 3 digits for milliseconds
+    // Ignore microseconds (18-21) as Date only has millisecond precision
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}.${ms}Z`);
+};
+// Helper function to convert Date back to stripped format
+export const toStrippedIsoTime = (date) => {
+    return stripNonAlphanumeric(date.toISOString().slice(0, -1)) + "000";
+};
+export function getMutableRunCreate(dotOrder) {
     const segments = dotOrder.split(".").map((i) => {
         const [startTime, runId] = i.split("Z");
         return { startTime, runId };
     });
+    // Iteratively check and fix timing to ensure each segment is greater than its parent
+    for (let i = 1; i < segments.length; i++) {
+        const parentTime = parseStrippedIsoTime(segments[i - 1].startTime);
+        const currentTime = parseStrippedIsoTime(segments[i].startTime);
+        if (currentTime.getTime() <= parentTime.getTime()) {
+            // Increment by 1 millisecond to make it greater than parent
+            const newTime = new Date(parentTime.getTime() + 1);
+            segments[i].startTime = toStrippedIsoTime(newTime);
+        }
+    }
+    // Reconstruct the dotted order with potentially updated timestamps
+    const updatedDotOrder = segments
+        .map((segment) => `${segment.startTime}Z${segment.runId}`)
+        .join(".");
     const traceId = segments[0].runId;
     const parentRunId = segments.at(-2)?.runId;
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const runId = segments.at(-1).runId;
+    // If this is the last segment (current run), set start_time to its ISO timestamp
+    const lastSegmentTime = parseStrippedIsoTime(segments.at(-1).startTime);
     return {
         id: runId,
         trace_id: traceId,
-        dotted_order: dotOrder,
+        dotted_order: updatedDotOrder,
         parent_run_id: parentRunId,
+        start_time: lastSegmentTime.toISOString(),
     };
 }
 function convertToTimestamp([seconds, nanoseconds]) {
@@ -774,10 +810,15 @@ export class AISDKExporter {
                         }
                         this.seenSpanInfo[task.id].dotOrder = taskDotOrder;
                         if (!this.seenSpanInfo[task.id].sent) {
-                            sampled.push({
+                            const updated = {
                                 ...task.run,
                                 ...getMutableRunCreate(taskDotOrder),
-                            });
+                            };
+                            if (updated.end_time !== undefined &&
+                                updated.end_time < updated.start_time) {
+                                updated.end_time = new Date(new Date(updated.start_time).getTime() + 1).toISOString();
+                            }
+                            sampled.push(updated);
                         }
                         this.seenSpanInfo[task.id].sent = true;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [