langsmith 0.1.54 → 0.1.55-rc.1

package/dist/client.cjs

@@ -33,8 +33,8 @@ const _uuid_js_1 = require("./utils/_uuid.cjs");
 const warn_js_1 = require("./utils/warn.cjs");
 const prompts_js_1 = require("./utils/prompts.cjs");
 const error_js_1 = require("./utils/error.cjs");
-const serde_js_1 = require("./utils/serde.cjs");
 const fetch_js_1 = require("./singletons/fetch.cjs");
+const index_js_2 = require("./utils/fast-safe-stringify/index.cjs");
 async function mergeRuntimeEnvIntoRunCreates(runs) {
     const runtimeEnv = await (0, env_js_1.getRuntimeEnvironment)();
     const envVars = (0, env_js_1.getLangChainEnvVarsMetadata)();
@@ -570,7 +570,7 @@ class Client {
         const response = await this.caller.call((0, fetch_js_1._getFetchImplementation)(), `${this.apiUrl}/runs`, {
             method: "POST",
             headers,
-            body: (0, serde_js_1.stringifyForTracing)(mergedRunCreateParams[0]),
+            body: (0, index_js_2.stringify)(mergedRunCreateParams[0]),
             signal: AbortSignal.timeout(this.timeout_ms),
             ...this.fetchOptions,
         });
@@ -644,10 +644,10 @@ class Client {
             const batchItems = rawBatch[key].reverse();
             let batchItem = batchItems.pop();
             while (batchItem !== undefined) {
-                const stringifiedBatchItem = (0, serde_js_1.stringifyForTracing)(batchItem);
+                const stringifiedBatchItem = (0, index_js_2.stringify)(batchItem);
                 if (currentBatchSizeBytes > 0 &&
                     currentBatchSizeBytes + stringifiedBatchItem.length > sizeLimitBytes) {
-                    await this._postBatchIngestRuns((0, serde_js_1.stringifyForTracing)(batchChunks));
+                    await this._postBatchIngestRuns((0, index_js_2.stringify)(batchChunks));
                     currentBatchSizeBytes = 0;
                     batchChunks.post = [];
                     batchChunks.patch = [];
@@ -658,7 +658,7 @@ class Client {
             }
         }
         if (batchChunks.post.length > 0 || batchChunks.patch.length > 0) {
-            await this._postBatchIngestRuns((0, serde_js_1.stringifyForTracing)(batchChunks));
+            await this._postBatchIngestRuns((0, index_js_2.stringify)(batchChunks));
         }
     }
     async _postBatchIngestRuns(body) {
@@ -707,7 +707,7 @@ class Client {
         const response = await this.caller.call((0, fetch_js_1._getFetchImplementation)(), `${this.apiUrl}/runs/${runId}`, {
             method: "PATCH",
             headers,
-            body: (0, serde_js_1.stringifyForTracing)(run),
+            body: (0, index_js_2.stringify)(run),
             signal: AbortSignal.timeout(this.timeout_ms),
             ...this.fetchOptions,
         });

package/dist/client.js

@@ -7,8 +7,8 @@ import { assertUuid } from "./utils/_uuid.js";
 import { warnOnce } from "./utils/warn.js";
 import { isVersionGreaterOrEqual, parsePromptIdentifier, } from "./utils/prompts.js";
 import { raiseForStatus } from "./utils/error.js";
-import { stringifyForTracing } from "./utils/serde.js";
 import { _getFetchImplementation } from "./singletons/fetch.js";
+import { stringify as stringifyForTracing } from "./utils/fast-safe-stringify/index.js";
 async function mergeRuntimeEnvIntoRunCreates(runs) {
     const runtimeEnv = await getRuntimeEnvironment();
     const envVars = getLangChainEnvVarsMetadata();

package/dist/index.cjs

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () {
 var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
 // Update using yarn bump-version
-exports.__version__ = "0.1.54";
+exports.__version__ = "0.1.55-rc.1";

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { Client, type ClientConfig } from "./client.js";
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
-export declare const __version__ = "0.1.54";
+export declare const __version__ = "0.1.55-rc.1";

package/dist/index.js

@@ -2,4 +2,4 @@ export { Client } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 // Update using yarn bump-version
-export const __version__ = "0.1.54";
+export const __version__ = "0.1.55-rc.1";

package/dist/utils/fast-safe-stringify/index.cjs

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = void 0;
+/* eslint-disable */
+// @ts-nocheck
+var LIMIT_REPLACE_NODE = "[...]";
+var CIRCULAR_REPLACE_NODE = { result: "[Circular]" };
+var arr = [];
+var replacerStack = [];
+function defaultOptions() {
+    return {
+        depthLimit: Number.MAX_SAFE_INTEGER,
+        edgesLimit: Number.MAX_SAFE_INTEGER,
+    };
+}
+// Regular stringify
+function stringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    decirc(obj, "", 0, [], undefined, 0, options);
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(obj, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+exports.stringify = stringify;
+function setReplace(replace, val, k, parent) {
+    var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+    if (propertyDescriptor.get !== undefined) {
+        if (propertyDescriptor.configurable) {
+            Object.defineProperty(parent, k, { value: replace });
+            arr.push([parent, k, val, propertyDescriptor]);
+        }
+        else {
+            replacerStack.push([val, k, replace]);
+        }
+    }
+    else {
+        parent[k] = replace;
+        arr.push([parent, k, val]);
+    }
+}
+function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                decirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            var keys = Object.keys(val);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                decirc(val[key], key, i, stack, val, depth, options);
+            }
+        }
+        stack.pop();
+    }
+}
+// Stable-stringify
+function compareFunction(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function deterministicStringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    var tmp = deterministicDecirc(obj, "", 0, [], undefined, 0, options) || obj;
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(tmp, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        // Ensure that we restore the object as it was.
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        try {
+            if (typeof val.toJSON === "function") {
+                return;
+            }
+        }
+        catch (_) {
+            return;
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                deterministicDecirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            // Create a temporary object in the required way
+            var tmp = {};
+            var keys = Object.keys(val).sort(compareFunction);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                deterministicDecirc(val[key], key, i, stack, val, depth, options);
+                tmp[key] = val[key];
+            }
+            if (typeof parent !== "undefined") {
+                arr.push([parent, k, val]);
+                parent[k] = tmp;
+            }
+            else {
+                return tmp;
+            }
+        }
+        stack.pop();
+    }
+}
+// wraps replacer function to handle values we couldn't replace
+// and mark them as replaced value
+function replaceGetterValues(replacer) {
+    replacer =
+        typeof replacer !== "undefined"
+            ? replacer
+            : function (k, v) {
+                return v;
+            };
+    return function (key, val) {
+        if (replacerStack.length > 0) {
+            for (var i = 0; i < replacerStack.length; i++) {
+                var part = replacerStack[i];
+                if (part[1] === key && part[0] === val) {
+                    val = part[2];
+                    replacerStack.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        return replacer.call(this, key, val);
+    };
+}

package/dist/utils/fast-safe-stringify/index.d.ts

@@ -0,0 +1 @@
+export declare function stringify(obj: any, replacer?: any, spacer?: any, options?: any): string;

package/dist/utils/fast-safe-stringify/index.js

@@ -0,0 +1,215 @@
+/* eslint-disable */
+// @ts-nocheck
+var LIMIT_REPLACE_NODE = "[...]";
+var CIRCULAR_REPLACE_NODE = { result: "[Circular]" };
+var arr = [];
+var replacerStack = [];
+function defaultOptions() {
+    return {
+        depthLimit: Number.MAX_SAFE_INTEGER,
+        edgesLimit: Number.MAX_SAFE_INTEGER,
+    };
+}
+// Regular stringify
+export function stringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    decirc(obj, "", 0, [], undefined, 0, options);
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(obj, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+function setReplace(replace, val, k, parent) {
+    var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+    if (propertyDescriptor.get !== undefined) {
+        if (propertyDescriptor.configurable) {
+            Object.defineProperty(parent, k, { value: replace });
+            arr.push([parent, k, val, propertyDescriptor]);
+        }
+        else {
+            replacerStack.push([val, k, replace]);
+        }
+    }
+    else {
+        parent[k] = replace;
+        arr.push([parent, k, val]);
+    }
+}
+function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                decirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            var keys = Object.keys(val);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                decirc(val[key], key, i, stack, val, depth, options);
+            }
+        }
+        stack.pop();
+    }
+}
+// Stable-stringify
+function compareFunction(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function deterministicStringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    var tmp = deterministicDecirc(obj, "", 0, [], undefined, 0, options) || obj;
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(tmp, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        // Ensure that we restore the object as it was.
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        try {
+            if (typeof val.toJSON === "function") {
+                return;
+            }
+        }
+        catch (_) {
+            return;
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                deterministicDecirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            // Create a temporary object in the required way
+            var tmp = {};
+            var keys = Object.keys(val).sort(compareFunction);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                deterministicDecirc(val[key], key, i, stack, val, depth, options);
+                tmp[key] = val[key];
+            }
+            if (typeof parent !== "undefined") {
+                arr.push([parent, k, val]);
+                parent[k] = tmp;
+            }
+            else {
+                return tmp;
+            }
+        }
+        stack.pop();
+    }
+}
+// wraps replacer function to handle values we couldn't replace
+// and mark them as replaced value
+function replaceGetterValues(replacer) {
+    replacer =
+        typeof replacer !== "undefined"
+            ? replacer
+            : function (k, v) {
+                return v;
+            };
+    return function (key, val) {
+        if (replacerStack.length > 0) {
+            for (var i = 0; i < replacerStack.length; i++) {
+                var part = replacerStack[i];
+                if (part[1] === key && part[0] === val) {
+                    val = part[2];
+                    replacerStack.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        return replacer.call(this, key, val);
+    };
+}

package/package.json

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

package/dist/utils/serde.cjs

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyForTracing = exports.CIRCULAR_VALUE_REPLACEMENT_STRING = void 0;
-exports.CIRCULAR_VALUE_REPLACEMENT_STRING = "[Circular]";
-/**
- * JSON.stringify version that handles circular references by replacing them
- * with an object marking them as such ({ result: "[Circular]" }).
- */
-const stringifyForTracing = (value) => {
-    const seen = new WeakSet();
-    const serializer = (_, value) => {
-        if (typeof value === "object" && value !== null) {
-            if (seen.has(value)) {
-                return {
-                    result: exports.CIRCULAR_VALUE_REPLACEMENT_STRING,
-                };
-            }
-            seen.add(value);
-        }
-        return value;
-    };
-    return JSON.stringify(value, serializer);
-};
-exports.stringifyForTracing = stringifyForTracing;

package/dist/utils/serde.d.ts

@@ -1,6 +0,0 @@
-export declare const CIRCULAR_VALUE_REPLACEMENT_STRING = "[Circular]";
-/**
- * JSON.stringify version that handles circular references by replacing them
- * with an object marking them as such ({ result: "[Circular]" }).
- */
-export declare const stringifyForTracing: (value: any) => string;

package/dist/utils/serde.js

@@ -1,20 +0,0 @@
-export const CIRCULAR_VALUE_REPLACEMENT_STRING = "[Circular]";
-/**
- * JSON.stringify version that handles circular references by replacing them
- * with an object marking them as such ({ result: "[Circular]" }).
- */
-export const stringifyForTracing = (value) => {
-    const seen = new WeakSet();
-    const serializer = (_, value) => {
-        if (typeof value === "object" && value !== null) {
-            if (seen.has(value)) {
-                return {
-                    result: CIRCULAR_VALUE_REPLACEMENT_STRING,
-                };
-            }
-            seen.add(value);
-        }
-        return value;
-    };
-    return JSON.stringify(value, serializer);
-};