langsmith 0.5.21 → 0.5.23

package/dist/experimental/sandbox/types.d.ts

@@ -11,59 +11,6 @@ export interface ExecutionResult {
     stderr: string;
     exit_code: number;
 }
-/**
- * Resource specification for a sandbox.
- */
-export interface ResourceSpec {
-    cpu?: string;
-    memory?: string;
-    storage?: string;
-}
-/**
- * Specification for mounting a volume in a sandbox template.
- */
-export interface VolumeMountSpec {
-    volume_name: string;
-    mount_path: string;
-}
-/**
- * Represents a persistent volume.
- */
-export interface Volume {
-    id?: string;
-    name: string;
-    size: string;
-    storage_class: string;
-    created_at?: string;
-    updated_at?: string;
-}
-/**
- * Represents a SandboxTemplate.
- *
- * Templates define the image, resource limits, and volume mounts for sandboxes.
- */
-export interface SandboxTemplate {
-    id?: string;
-    name: string;
-    image: string;
-    resources: ResourceSpec;
-    volume_mounts?: VolumeMountSpec[];
-    created_at?: string;
-    updated_at?: string;
-}
-/**
- * Represents a Sandbox Pool for pre-provisioned sandboxes.
- *
- * Pools pre-provision sandboxes from a template for faster startup.
- */
-export interface Pool {
-    id?: string;
-    name: string;
-    template_name: string;
-    replicas: number;
-    created_at?: string;
-    updated_at?: string;
-}
 /**
  * Lightweight provisioning status for any async-created resource.
  */
@@ -101,7 +48,6 @@ export interface Snapshot {
 export interface SandboxData {
     id?: string;
     name: string;
-    template_name?: string;
     dataplane_url?: string;
     status?: string;
     status_message?: string;
@@ -297,10 +243,11 @@ export interface SandboxProxyConfig {
  */
 export interface CreateSandboxOptions {
     /**
-     * Snapshot ID to boot from.
-     * Mutually exclusive with the `templateName` positional arg.
+     * Snapshot name to boot from. Mutually exclusive with the positional
+     * `snapshotId` argument on `createSandbox`; exactly one must be provided.
+     * Resolved server-side to a snapshot owned by the caller's tenant.
      */
-    snapshotId?: string;
+    snapshotName?: string;
     /**
      * Optional sandbox name (auto-generated if not provided).
      */
@@ -361,13 +308,39 @@ export interface CreateSnapshotOptions {
  * Options for capturing a snapshot from a running sandbox.
  */
 export interface CaptureSnapshotOptions {
-    /** Checkpoint timestamp to use. If omitted, creates a fresh checkpoint. */
-    checkpoint?: string;
     /** Timeout in seconds when waiting for ready. Default: 60. */
     timeout?: number;
     /** AbortSignal for cancellation. */
     signal?: AbortSignal;
 }
+/**
+ * Options for listing snapshots. All fields are optional and independent.
+ *
+ * The backend always paginates: when `limit` is omitted the server applies
+ * a default page size (currently 50), so a single call will not necessarily
+ * return every snapshot visible to the caller's tenant.
+ */
+export interface ListSnapshotsOptions {
+    /**
+     * Case-insensitive substring filter applied server-side to snapshot
+     * names.
+     */
+    nameContains?: string;
+    /**
+     * Maximum number of snapshots to return for a single request. Must be
+     * between 1 and 500 (inclusive); the server rejects values outside that
+     * range. Defaults to 50 server-side when omitted.
+     */
+    limit?: number;
+    /**
+     * Number of snapshots to skip before returning results. Must be `>= 0`.
+     * Useful for paginating through large result sets in combination with
+     * `limit`.
+     */
+    offset?: number;
+    /** AbortSignal for cancellation. */
+    signal?: AbortSignal;
+}
 /**
  * Options for waiting for a snapshot to become ready.
  */
@@ -421,93 +394,3 @@ export interface WaitForSandboxOptions {
     /** AbortSignal for cancellation. */
     signal?: AbortSignal;
 }
-/**
- * Options for creating a volume.
- */
-export interface CreateVolumeOptions {
-    /**
-     * Storage size (e.g., "1Gi", "10Gi").
-     */
-    size: string;
-    /**
-     * Timeout in seconds when waiting for volume to be ready. Default: 60.
-     */
-    timeout?: number;
-}
-/**
- * Options for creating a template.
- */
-export interface CreateTemplateOptions {
-    /**
-     * Container image (e.g., "python:3.12-slim", "node:20-slim").
-     */
-    image: string;
-    /**
-     * CPU limit (e.g., "500m", "1", "2"). Default: "500m".
-     */
-    cpu?: string;
-    /**
-     * Memory limit (e.g., "256Mi", "1Gi"). Default: "512Mi".
-     */
-    memory?: string;
-    /**
-     * Ephemeral storage limit (e.g., "1Gi"). Optional.
-     */
-    storage?: string;
-    /**
-     * List of volumes to mount in the sandbox. Optional.
-     */
-    volumeMounts?: VolumeMountSpec[];
-}
-/**
- * Options for updating a template.
- */
-export interface UpdateTemplateOptions {
-    /**
-     * New display name (optional).
-     */
-    newName?: string;
-}
-/**
- * Options for creating a pool.
- */
-export interface CreatePoolOptions {
-    /**
-     * Name of the template to use for sandboxes in this pool.
-     */
-    templateName: string;
-    /**
-     * Number of pre-warmed sandboxes to maintain (0-100).
-     */
-    replicas: number;
-    /**
-     * Timeout in seconds when waiting for pool to be ready. Default: 30.
-     */
-    timeout?: number;
-}
-/**
- * Options for updating a volume.
- */
-export interface UpdateVolumeOptions {
-    /**
-     * New display name (optional).
-     */
-    newName?: string;
-    /**
-     * New storage size (must be >= current size). Optional.
-     */
-    size?: string;
-}
-/**
- * Options for updating a pool.
- */
-export interface UpdatePoolOptions {
-    /**
-     * New display name (optional).
-     */
-    newName?: string;
-    /**
-     * New number of replicas (0-100). Set to 0 to pause.
-     */
-    replicas?: number;
-}

package/dist/index.cjs

@@ -18,4 +18,4 @@ Object.defineProperty(exports, "PromptCache", { enumerable: true, get: function
 Object.defineProperty(exports, "configureGlobalPromptCache", { enumerable: true, get: function () { return index_js_1.configureGlobalPromptCache; } });
 Object.defineProperty(exports, "promptCacheSingleton", { enumerable: true, get: function () { return index_js_1.promptCacheSingleton; } });
 // Update using pnpm bump-version
-exports.__version__ = "0.5.21";
+exports.__version__ = "0.5.23";

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, PromptCache, type CacheConfig, type CacheMetrics, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
-export declare const __version__ = "0.5.21";
+export declare const __version__ = "0.5.23";

package/dist/index.js

@@ -5,4 +5,4 @@ export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, PromptCache, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 // Update using pnpm bump-version
-export const __version__ = "0.5.21";
+export const __version__ = "0.5.23";

package/dist/schemas.d.ts

@@ -435,6 +435,60 @@ export type PromptSortField = "num_downloads" | "num_views" | "updated_at" | "nu
 export interface LikePromptResponse {
     likes: number;
 }
+export interface FileEntry {
+    type: "file";
+    content: string;
+}
+export interface AgentEntry {
+    type: "agent";
+    repo_handle: string;
+    commit_id?: string;
+    owner?: string;
+    commit_hash?: string;
+}
+export interface SkillEntry {
+    type: "skill";
+    repo_handle: string;
+    commit_id?: string;
+    owner?: string;
+    commit_hash?: string;
+}
+export type Entry = FileEntry | AgentEntry | SkillEntry;
+/** The type of a non-prompt hub repo. */
+export type HubRepoType = "agent" | "skill";
+/**
+ * An agent pulled from hub.
+ */
+export interface AgentContext {
+    /** The commit ID. */
+    commit_id: string;
+    /** The commit hash. */
+    commit_hash: string;
+    /** The files in the agent. */
+    files: Record<string, Entry>;
+}
+/**
+ * A skill pulled from hub.
+ */
+export interface SkillContext {
+    /** The commit ID. */
+    commit_id: string;
+    /** The commit hash. */
+    commit_hash: string;
+    /** The files in the skill. */
+    files: Record<string, Entry>;
+}
+/** Response body for `POST /directories/commits`. */
+export interface DirectoryCommitResponse {
+    commit: {
+        /** The commit ID. */
+        id: string;
+        /** The commit hash. */
+        commit_hash: string;
+        /** When the commit was created. */
+        created_at: string;
+    };
+}
 export interface LangSmithSettings {
     id: string;
     display_name: string;

package/dist/utils/error.cjs

@@ -4,6 +4,7 @@ exports.ConflictingEndpointsError = exports.LangSmithNotFoundError = exports.Lan
 exports.getInvalidPromptIdentifierMsg = getInvalidPromptIdentifierMsg;
 exports.printErrorStackTrace = printErrorStackTrace;
 exports.isLangSmithNotFoundError = isLangSmithNotFoundError;
+exports.isLangSmithConflictError = isLangSmithConflictError;
 exports.raiseForStatus = raiseForStatus;
 exports.isConflictingEndpointsError = isConflictingEndpointsError;
 /**
@@ -115,6 +116,12 @@ function isLangSmithNotFoundError(error) {
         "name" in error &&
         error?.name === "LangSmithNotFoundError");
 }
+function isLangSmithConflictError(error) {
+    return (error != null &&
+        typeof error === "object" &&
+        "name" in error &&
+        error?.name === "LangSmithConflictError");
+}
 /**
  * Throws an appropriate error based on the response status and body.
  *

package/dist/utils/error.d.ts

@@ -55,6 +55,7 @@ export declare class LangSmithNotFoundError extends Error {
     constructor(message: string);
 }
 export declare function isLangSmithNotFoundError(error: unknown): error is LangSmithNotFoundError;
+export declare function isLangSmithConflictError(error: unknown): error is LangSmithConflictError;
 /**
  * Throws an appropriate error based on the response status and body.
  *

package/dist/utils/error.js

@@ -105,6 +105,12 @@ export function isLangSmithNotFoundError(error) {
         "name" in error &&
         error?.name === "LangSmithNotFoundError");
 }
+export function isLangSmithConflictError(error) {
+    return (error != null &&
+        typeof error === "object" &&
+        "name" in error &&
+        error?.name === "LangSmithConflictError");
+}
 /**
  * Throws an appropriate error based on the response status and body.
  *

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSerializedSize = estimateSerializedSize;
 exports.serialize = serialize;
 /* eslint-disable */
 // @ts-nocheck
@@ -60,6 +61,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).
+ */
+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
 function serialize(obj, errorContext, replacer, spacer, options) {
     try {

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

@@ -1 +1,34 @@
+/**
+ * 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 declare function estimateSerializedSize(value: unknown): number;
 export declare function serialize(obj: any, errorContext?: any, replacer?: any, spacer?: any, options?: any): Uint8Array<ArrayBuffer>;