langsmith 0.5.21 → 0.5.23

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

@@ -57,6 +57,233 @@ function createDefaultReplacer(userReplacer) {
         return serializeWellKnownTypes(val);
     };
 }
+/**
+ * Estimate the serialized JSON byte size of a value without actually
+ * serializing it. Used on hot paths (enqueuing runs for batched tracing)
+ * where the exact serialized size is not required -- only a reasonable
+ * approximation for soft memory accounting.
+ *
+ * Walks the object graph in O(n) without allocating a JSON string,
+ * avoiding the event-loop blocking that JSON.stringify causes on large
+ * payloads.
+ *
+ * Accuracy notes (all estimates are approximate, never exact):
+ * - Strings: UTF-8 byte length via Buffer.byteLength when available,
+ *   falling back to code-unit length for non-Node environments. Does
+ *   not account for escape expansion (\", \\, control chars, surrogate
+ *   escapes) which is usually a small fraction of total size.
+ * - Binary data (Buffer / typed arrays / ArrayBuffer / DataView): sized
+ *   from their JSON.stringify representations where practical
+ *   ({ type: "Buffer", data: [...] } for Buffer, keyed objects for typed
+ *   arrays). DataView and ArrayBuffer themselves have no enumerable own
+ *   properties and serialize as "{}". Each byte contributes ~3.5
+ *   characters on average in Buffer's decimal-array representation
+ *   (digit(s) + comma).
+ * - Other objects with toJSON(): we invoke toJSON() once and estimate
+ *   the result. This matches JSON.stringify semantics for libraries
+ *   like Decimal.js, Moment, Luxon, Mongoose documents, etc.
+ * - Cycles: detected via an ancestor-path set that is pushed/popped
+ *   during recursion. This matches JSON.stringify semantics --
+ *   repeated references that are *not* on the current ancestor chain
+ *   (shared subobjects) are counted every time they appear, because
+ *   JSON.stringify will serialize them every time.
+ * - No depth limit (JSON.stringify has none either).
+ */
+export function estimateSerializedSize(value) {
+    try {
+        // Ancestor set for cycle detection. An object is only treated as
+        // circular if it appears on the current recursion path, not merely
+        // if it has been seen before elsewhere in the graph.
+        const ancestors = new Set();
+        // In Node / Bun, Buffer.byteLength is a fast native way to get UTF-8
+        // byte length without allocating an encoded copy. In other runtimes
+        // we fall back to code-unit length (a small under-estimate for
+        // non-ASCII text, which is acceptable for soft limits).
+        const byteLen = typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function"
+            ? (s) => Buffer.byteLength(s, "utf8")
+            : (s) => s.length;
+        function estimateString(s) {
+            // +2 for the surrounding quotes. Escape expansion is not counted.
+            return byteLen(s) + 2;
+        }
+        // Size of a byte sequence when rendered as a JSON array of decimal
+        // numbers: "[b0,b1,b2,...]". Each byte averages ~3.5 chars (value 0-9
+        // => 1 char, 10-99 => 2 chars, 100-255 => 3 chars; weighted mean over
+        // a uniform distribution is ~2.81, plus one comma per element except
+        // the last). Round up to 4 bytes/element for a small safety margin.
+        function estimateByteArrayJson(byteLength) {
+            if (byteLength === 0)
+                return 2; // "[]"
+            return 2 + byteLength * 4;
+        }
+        // Returns true for values that JSON.stringify drops when they appear
+        // as an object property (as opposed to an array element, where they
+        // become "null").
+        function isDropped(v) {
+            return (v === undefined || typeof v === "function" || typeof v === "symbol");
+        }
+        // In arrays, undefined / function / symbol become "null" (4 bytes).
+        function estimateInArray(v) {
+            if (v === undefined || typeof v === "function" || typeof v === "symbol") {
+                return 4;
+            }
+            return estimate(v);
+        }
+        function estimate(val) {
+            if (val === null)
+                return 4; // "null"
+            if (val === undefined)
+                return 0; // top-level or property context; array handled separately
+            const t = typeof val;
+            if (t === "boolean")
+                return 5; // "true" / "false" upper bound
+            if (t === "number") {
+                if (!Number.isFinite(val))
+                    return 4; // "null"
+                // Convert to string to get exact length. This is cheap for numbers
+                // (V8 caches small-number strings) and makes the estimate far
+                // tighter for common cases like integer arrays.
+                return val.toString().length;
+            }
+            if (t === "bigint") {
+                // Our replacer renders BigInt via .toString(), then JSON.stringify
+                // quotes it.
+                return val.toString().length + 2;
+            }
+            if (t === "string")
+                return estimateString(val);
+            if (t === "function" || t === "symbol")
+                return 0;
+            // Objects from here on.
+            const obj = val;
+            // Well-known types handled by our replacer.
+            if (obj instanceof Date)
+                return 26; // "2024-01-01T00:00:00.000Z"
+            if (obj instanceof RegExp)
+                return byteLen(obj.toString()) + 2;
+            if (obj instanceof Error) {
+                const name = obj.name ?? "";
+                const message = obj.message ?? "";
+                // {"name":"...","message":"..."}
+                return 22 + byteLen(name) + byteLen(message);
+            }
+            // Binary data types. These commonly appear in LLM payloads (images,
+            // audio) and their JSON representations vary widely.
+            if (typeof Buffer !== "undefined" && obj instanceof Buffer) {
+                // { "type": "Buffer", "data": [0, 1, 2, ...] }
+                return 28 + estimateByteArrayJson(obj.byteLength);
+            }
+            if (ArrayBuffer.isView(obj)) {
+                if (obj instanceof DataView) {
+                    // DataView has no enumerable own properties; serializes as "{}".
+                    return 2;
+                }
+                // Typed arrays serialize as {"0":v0,"1":v1,...} (keyed objects),
+                // which is much larger than a plain array would be. Per element
+                // cost: digits for index + digits for value + ":" + "," + quotes.
+                const len = obj.length ?? 0;
+                const isFloat = obj instanceof Float32Array || obj instanceof Float64Array;
+                // Index digits grow with len; worst-case per element:
+                //   "NNN":V,   where NNN = log10(len) digits and V depends on type.
+                // Loose but safe bounds: integer views ~12 chars/element, float
+                // views ~30 chars/element (Float32 ToString can be up to ~17 chars).
+                const perElement = isFloat ? 30 : 12;
+                return 2 + len * perElement;
+            }
+            if (obj instanceof ArrayBuffer) {
+                // Plain ArrayBuffer has no enumerable properties; serializes as "{}".
+                return 2;
+            }
+            if (ancestors.has(obj)) {
+                // Cycle: our decirc fallback replaces with { result: "[Circular]" }.
+                return 24;
+            }
+            // Custom toJSON (Decimal.js, Moment, Luxon, Mongoose docs, etc.).
+            // This runs after explicit built-in / binary cases above so known
+            // types (for example Buffer) use their dedicated fast-path sizing
+            // logic instead of duck-typing through toJSON().
+            if (typeof obj.toJSON === "function") {
+                let projected;
+                try {
+                    projected = obj.toJSON("");
+                }
+                catch {
+                    // If toJSON throws, JSON.stringify would also throw and our
+                    // serializer would emit "[Unserializable]" (~16 bytes).
+                    return 16;
+                }
+                ancestors.add(obj);
+                const size = estimate(projected);
+                ancestors.delete(obj);
+                return size;
+            }
+            ancestors.add(obj);
+            let size;
+            if (Array.isArray(obj)) {
+                size = 2; // []
+                const len = obj.length;
+                for (let i = 0; i < len; i++) {
+                    size += estimateInArray(obj[i]);
+                    if (i < len - 1)
+                        size += 1; // comma
+                }
+            }
+            else if (obj instanceof Map) {
+                // Rendered as { k: v, ... } via Object.fromEntries.
+                size = 2;
+                let emitted = 0;
+                for (const [k, v] of obj) {
+                    if (isDropped(v))
+                        continue;
+                    if (emitted > 0)
+                        size += 1; // comma
+                    const keyStr = typeof k === "string" ? k : String(k);
+                    size += byteLen(keyStr) + 3; // "key":
+                    size += estimate(v);
+                    emitted++;
+                }
+            }
+            else if (obj instanceof Set) {
+                // Rendered as [v, ...] via Array.from.
+                size = 2;
+                let emitted = 0;
+                for (const v of obj) {
+                    if (emitted > 0)
+                        size += 1; // comma
+                    size += estimateInArray(v);
+                    emitted++;
+                }
+            }
+            else {
+                size = 2; // {}
+                let emitted = 0;
+                // Object.keys only returns own enumerable string keys, matching
+                // JSON.stringify.
+                const keys = Object.keys(obj);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const v = obj[key];
+                    if (isDropped(v))
+                        continue;
+                    if (emitted > 0)
+                        size += 1; // comma
+                    size += byteLen(key) + 3; // "key":
+                    size += estimate(v);
+                    emitted++;
+                }
+            }
+            ancestors.delete(obj);
+            return size;
+        }
+        return estimate(value);
+    }
+    catch {
+        // If the estimator itself hits an unexpected edge case, fall back to the
+        // exact serialized size. This preserves correctness of queue-size
+        // accounting at the cost of a slower hot path for that one payload.
+        return serialize(value).length;
+    }
+}
 // Regular stringify
 export function serialize(obj, errorContext, replacer, spacer, options) {
     try {

package/dist/utils/prompts.cjs

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePromptIdentifier = parsePromptIdentifier;
+exports.parseHubIdentifier = parseHubIdentifier;
 const error_js_1 = require("./error.cjs");
-function parsePromptIdentifier(identifier) {
+/**
+ * Parse a hub repo identifier (owner/name:hash, name, etc.).
+ *
+ * Prompts, agents, and skills share the same identifier grammar on Hub.
+ */
+function parseHubIdentifier(identifier) {
     if (!identifier ||
         identifier.split("/").length > 2 ||
         identifier.startsWith("/") ||

package/dist/utils/prompts.d.ts

@@ -1 +1,6 @@
-export declare function parsePromptIdentifier(identifier: string): [string, string, string];
+/**
+ * Parse a hub repo identifier (owner/name:hash, name, etc.).
+ *
+ * Prompts, agents, and skills share the same identifier grammar on Hub.
+ */
+export declare function parseHubIdentifier(identifier: string): [string, string, string];

package/dist/utils/prompts.js

@@ -1,5 +1,10 @@
 import { getInvalidPromptIdentifierMsg } from "./error.js";
-export function parsePromptIdentifier(identifier) {
+/**
+ * Parse a hub repo identifier (owner/name:hash, name, etc.).
+ *
+ * Prompts, agents, and skills share the same identifier grammar on Hub.
+ */
+export function parseHubIdentifier(identifier) {
     if (!identifier ||
         identifier.split("/").length > 2 ||
         identifier.startsWith("/") ||