fix(js): Fix overzealous circular reference detection

js/package.json

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

js/src/client.ts

@@ -56,9 +56,10 @@
   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";
+
 export interface ClientConfig {
   apiUrl?: string;
   apiKey?: string;
@@ -1288,7 +1289,7 @@
     treeFilter?: string;
     isRoot?: boolean;
     dataSourceType?: string;
   }): Promise<any> {
     let projectIds_ = projectIds || [];
     if (projectNames) {
       projectIds_ = [
@@ -1576,7 +1577,7 @@
         `Failed to list shared examples: ${response.status} ${response.statusText}`
       );
     }
     return result.map((example: any) => ({
       ...example,
       _hostUrl: this.getHostUrl(),
     }));
@@ -2719,7 +2720,7 @@
     }
 
     const feedbackResult = await evaluator.evaluateRun(run_, referenceExample);
     const [_, feedbacks] = await this._logEvaluationFeedback(
       feedbackResult,
       run_,
       sourceInfo
@@ -3053,7 +3054,7 @@
   async _logEvaluationFeedback(
     evaluatorResponse: EvaluationResult | EvaluationResults,
     run?: Run,
     sourceInfo?: { [key: string]: any }
   ): Promise<[results: EvaluationResult[], feedbacks: Feedback[]]> {
     const evalResults: Array<EvaluationResult> =
       this._selectEvalResults(evaluatorResponse);
@@ -3092,7 +3093,7 @@
   public async logEvaluationFeedback(
     evaluatorResponse: EvaluationResult | EvaluationResults,
     run?: Run,
     sourceInfo?: { [key: string]: any }
   ): Promise<EvaluationResult[]> {
     const [results] = await this._logEvaluationFeedback(
       evaluatorResponse,
@@ -3158,7 +3159,7 @@
     promptIdentifier: string,
     like: boolean
   ): Promise<LikePromptResponse> {
     const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
     const response = await this.caller.call(
       _getFetchImplementation(),
       `${this.apiUrl}/likes/${owner}/${promptName}`,
@@ -3263,7 +3264,7 @@
   }
 
   public async getPrompt(promptIdentifier: string): Promise<Prompt | null> {
     const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
     const response = await this.caller.call(
       _getFetchImplementation(),
       `${this.apiUrl}/repos/${owner}/${promptName}`,
@@ -3307,7 +3308,7 @@
       );
     }
 
     const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
     if (!(await this._currentTenantIsOwner(owner))) {
       throw await this._ownerConflictError("create a prompt", owner);
     }
@@ -3340,7 +3341,7 @@
 
   public async createCommit(
     promptIdentifier: string,
     object: any,
     options?: {
       parentCommitHash?: string;
     }
@@ -3349,7 +3350,7 @@
       throw new Error("Prompt does not exist, you must create it first.");
     }
 
     const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
     const resolvedParentCommitHash =
       options?.parentCommitHash === "latest" || !options?.parentCommitHash
         ? await this._getLatestCommitHash(`${owner}/${promptName}`)

js/src/index.ts

@@ -14,4 +14,4 @@ export { RunTree, type RunTreeConfig } 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";

js/src/tests/batch_client.test.ts

@@ -3,7 +3,6 @@ import { jest } from "@jest/globals";
 import { v4 as uuidv4 } from "uuid";
 import { Client } from "../client.js";
 import { convertToDottedOrderFormat } from "../run_trees.js";
-import { CIRCULAR_VALUE_REPLACEMENT_STRING } from "../utils/serde.js";
 import { _getFetchImplementation } from "../singletons/fetch.js";
 
 describe("Batch client tracing", () => {
@@ -568,12 +567,14 @@ describe("Batch client tracing", () => {
           inputs: {
             b: {
               a: {
-                result: CIRCULAR_VALUE_REPLACEMENT_STRING,
+                result: "[Circular]",
               },
             },
           },
           outputs: {
-            result: CIRCULAR_VALUE_REPLACEMENT_STRING,
+            a: {
+              result: "[Circular]",
+            },
           },
           end_time: endTime,
           trace_id: runId,

js/src/tests/traceable.test.ts

@@ -2,7 +2,6 @@ import { RunTree, RunTreeConfig } from "../run_trees.js";
 import { ROOT, traceable, withRunTree } from "../traceable.js";
 import { getAssumedTreeFromCalls } from "./utils/tree.js";
 import { mockClient } from "./utils/mock_client.js";
-import { CIRCULAR_VALUE_REPLACEMENT_STRING } from "../utils/serde.js";
 
 test("basic traceable implementation", async () => {
   const { client, callSpy } = mockClient();
@@ -78,28 +77,51 @@ test("trace circular input and output objects", async () => {
   a.b = b;
   b.a = a;
   const llm = traceable(
-    async function foo(_: any) {
+    async function foo(_: Record<string, any>) {
       return a;
     },
     { client, tracingEnabled: true }
   );
 
-  await llm(a);
+  const input = {
+    a,
+    a2: a,
+    normalParam: {
+      test: true,
+    },
+  };
+  await llm(input);
 
   expect(getAssumedTreeFromCalls(callSpy.mock.calls)).toMatchObject({
     nodes: ["foo:0"],
     edges: [],
     data: {
       "foo:0": {
         inputs: {
-          b: {
-            a: {
-              result: CIRCULAR_VALUE_REPLACEMENT_STRING,
+          a: {
+            b: {
+              a: {
+                result: "[Circular]",
+              },
+            },
+          },
+          a2: {
+            b: {
+              a: {
+                result: "[Circular]",
+              },
             },
           },
+          normalParam: {
+            test: true,
+          },
         },
         outputs: {
-          result: CIRCULAR_VALUE_REPLACEMENT_STRING,
+          b: {
+            a: {
+              result: "[Circular]",
+            },
+          },
         },
       },
     },

js/src/utils/fast-safe-stringify/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 David Mark Clements
+Copyright (c) 2017 David Mark Clements & Matteo Collina
+Copyright (c) 2018 David Mark Clements, Matteo Collina & Ruben Bridgewater 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

js/src/utils/fast-safe-stringify/index.ts

@@ -0,0 +1,230 @@
+/* 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);
+  };
+}