langsmith 0.5.22 → 0.5.23

package/dist/client.js

@@ -7,12 +7,12 @@ import { getEnvironmentVariable, getLangSmithEnvVarsMetadata, getLangSmithEnviro
 import { __version__ } from "./index.js";
 import { assertUuid } from "./utils/_uuid.js";
 import { warnOnce } from "./utils/warn.js";
-import { parsePromptIdentifier } from "./utils/prompts.js";
-import { raiseForStatus, isLangSmithNotFoundError } from "./utils/error.js";
+import { parseHubIdentifier } from "./utils/prompts.js";
+import { raiseForStatus, isLangSmithNotFoundError, isLangSmithConflictError, } from "./utils/error.js";
 import { promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 import * as fsUtils from "./utils/fs.js";
 import { _shouldStreamForGlobalFetchImplementation, _getFetchImplementation, } from "./singletons/fetch.js";
-import { serialize as serializePayloadForTracing } from "./utils/fast-safe-stringify/index.js";
+import { serialize as serializePayloadForTracing, estimateSerializedSize, } from "./utils/fast-safe-stringify/index.js";
 /**
  * Catches timestamps without a timezone suffix.
  */
@@ -152,7 +152,19 @@ export class AutoBatchQueue {
             // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
             itemPromiseResolve = resolve;
         });
-        const size = serializePayloadForTracing(item.item, `Serializing run with id: ${item.item.id}`).length;
+        // By default we compute the exact serialized size here by stringifying
+        // the payload. This is expensive: JSON.stringify on large payloads
+        // blocks the event loop on the user's hot path.
+        //
+        // Opting into LANGSMITH_PERF_OPTIMIZATION=true switches to a cheap
+        // structural estimate instead. The estimate is only used for soft
+        // memory accounting (queue size limit and downstream async caller
+        // memory tracking), never for anything correctness-critical -- the
+        // real serialization still happens later, off the hot path, when the
+        // batch is assembled for sending.
+        const size = getLangSmithEnvironmentVariable("PERF_OPTIMIZATION") === "true"
+            ? estimateSerializedSize(item.item)
+            : serializePayloadForTracing(item.item, `Serializing run with id: ${item.item.id}`).length;
         // Check if adding this item would exceed the size limit
         // Allow the run if the queue is empty (to support large single traces)
         if (this.sizeBytes + size > this.maxSizeBytes && this.items.length > 0) {
@@ -3783,7 +3795,7 @@ export class Client {
         return json.commits[0].commit_hash;
     }
     async _likeOrUnlikePrompt(promptIdentifier, like) {
-        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, _] = parseHubIdentifier(promptIdentifier);
         const body = JSON.stringify({ like: like });
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/likes/${owner}/${promptName}`, {
@@ -3802,7 +3814,7 @@ export class Client {
         return response.json();
     }
     async _getPromptUrl(promptIdentifier) {
-        const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, commitHash] = parseHubIdentifier(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             if (commitHash !== "latest") {
                 return `${this.getHostUrl()}/hub/${owner}/${promptName}/${commitHash.substring(0, 8)}`;
@@ -3894,7 +3906,7 @@ export class Client {
      * ```
      */
     async *listCommits(promptIdentifier) {
-        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, _] = parseHubIdentifier(promptIdentifier);
         for await (const commits of this._getPaginated(`/commits/${owner}/${promptName}/`, new URLSearchParams(), (res) => res.commits)) {
             yield* commits;
         }
@@ -3957,7 +3969,7 @@ export class Client {
      * ```
      */
     async getPrompt(promptIdentifier) {
-        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, _] = parseHubIdentifier(promptIdentifier);
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${promptName}`, {
                 method: "GET",
@@ -4014,7 +4026,7 @@ export class Client {
         You can add a handle by creating a public prompt at:\n
         https://smith.langchain.com/prompts`);
         }
-        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, _] = parseHubIdentifier(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("create a prompt", owner);
         }
@@ -4073,7 +4085,7 @@ export class Client {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
         }
-        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, _] = parseHubIdentifier(promptIdentifier);
         const resolvedParentCommitHash = options?.parentCommitHash === "latest" || !options?.parentCommitHash
             ? await this._getLatestCommitHash(`${owner}/${promptName}`)
             : options?.parentCommitHash;
@@ -4271,7 +4283,7 @@ export class Client {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
         }
-        const [owner, promptName] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName] = parseHubIdentifier(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("update a prompt", owner);
         }
@@ -4311,7 +4323,7 @@ export class Client {
         if (!(await this.promptExists(promptIdentifier))) {
             throw new Error("Prompt does not exist, you must create it first.");
         }
-        const [owner, promptName, _] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, _] = parseHubIdentifier(promptIdentifier);
         if (!(await this._currentTenantIsOwner(owner))) {
             throw await this._ownerConflictError("delete a prompt", owner);
         }
@@ -4339,7 +4351,7 @@ export class Client {
      * Fetch a prompt commit directly from the API (bypassing cache).
      */
     async _fetchPromptFromApi(promptIdentifier, options) {
-        const [owner, promptName, commitHash] = parsePromptIdentifier(promptIdentifier);
+        const [owner, promptName, commitHash] = parseHubIdentifier(promptIdentifier);
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/commits/${owner}/${promptName}/${commitHash}${options?.includeModel ? "?include_model=true" : ""}`, {
                 method: "GET",
@@ -4419,6 +4431,251 @@ export class Client {
         });
         return url;
     }
+    /**
+     * Check if an agent repo exists.
+     */
+    async agentExists(identifier) {
+        const [owner, name] = parseHubIdentifier(identifier);
+        return this._repoExists(owner, name);
+    }
+    /**
+     * Check if a skill repo exists.
+     */
+    async skillExists(identifier) {
+        const [owner, name] = parseHubIdentifier(identifier);
+        return this._repoExists(owner, name);
+    }
+    /**
+     * Pull an agent directory from Hub.
+     * @param identifier The identifier (owner/name[:version]).
+     * @param options.version Commit hash or tag; overrides identifier's version.
+     */
+    async pullAgent(identifier, options) {
+        return (await this._pullDirectory(identifier, "agent", options?.version));
+    }
+    /**
+     * Pull a skill directory from Hub.
+     */
+    async pullSkill(identifier, options) {
+        return (await this._pullDirectory(identifier, "skill", options?.version));
+    }
+    /**
+     * Push an agent to Hub. Creates the repo if missing, patches metadata if
+     * provided, then commits the given files.
+     * @returns The URL of the resulting commit.
+     */
+    async pushAgent(identifier, options) {
+        return this._pushDirectory(identifier, "agent", options);
+    }
+    /**
+     * Push a skill to Hub.
+     */
+    async pushSkill(identifier, options) {
+        return this._pushDirectory(identifier, "skill", options);
+    }
+    /**
+     * Delete an agent and all its owned child file repos.
+     */
+    async deleteAgent(identifier) {
+        return this._deleteDirectory(identifier);
+    }
+    /**
+     * Delete a skill and all its owned child file repos.
+     */
+    async deleteSkill(identifier) {
+        return this._deleteDirectory(identifier);
+    }
+    /**
+     * List agent repos. Yields one at a time, auto-paginating.
+     */
+    async *listAgents(options) {
+        yield* this._listReposByType("agent", options);
+    }
+    /**
+     * List skill repos. Yields one at a time, auto-paginating.
+     */
+    async *listSkills(options) {
+        yield* this._listReposByType("skill", options);
+    }
+    async *_listReposByType(repoType, options) {
+        const params = new URLSearchParams();
+        params.append("repo_type", repoType);
+        params.append("is_archived", (!!options?.isArchived).toString());
+        if (options?.isPublic !== undefined) {
+            params.append("is_public", options.isPublic.toString());
+        }
+        if (options?.query) {
+            params.append("query", options.query);
+        }
+        for await (const repos of this._getPaginated("/repos", params, (res) => res.repos)) {
+            yield* repos;
+        }
+    }
+    async _pullDirectory(identifier, repoType, version) {
+        const [owner, name, parsedVersion] = parseHubIdentifier(identifier);
+        const resolvedVersion = version ?? (parsedVersion !== "latest" ? parsedVersion : undefined);
+        const url = new URL(`${this.apiUrl}/v1/platform/hub/repos/${owner}/${name}/directories`);
+        url.searchParams.set("repo_type", repoType);
+        if (resolvedVersion) {
+            url.searchParams.set("commit", resolvedVersion);
+        }
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(url.toString(), {
+                method: "GET",
+                headers: this._mergedHeaders,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "pull directory");
+            return res;
+        });
+        return (await response.json());
+    }
+    async _pushDirectory(identifier, repoType, options) {
+        if (options.parentCommit !== undefined &&
+            (options.parentCommit.length < 8 || options.parentCommit.length > 64)) {
+            throw new Error("parent_commit must be 8-64 characters");
+        }
+        const [owner, name] = parseHubIdentifier(identifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError(`push ${repoType}`, owner);
+        }
+        if (await this._repoExists(owner, name)) {
+            if (options.description !== undefined ||
+                options.readme !== undefined ||
+                options.tags !== undefined ||
+                options.isPublic !== undefined) {
+                await this._updateRepoMetadata(owner, name, options);
+            }
+        }
+        else {
+            const REPO_HANDLE_PATTERN = /^[a-z][a-z0-9-_]*$/;
+            if (!REPO_HANDLE_PATTERN.test(name)) {
+                throw new Error(`Invalid repo_handle ${JSON.stringify(name)}: must match ${REPO_HANDLE_PATTERN}`);
+            }
+            await this._createRepo(name, repoType, options);
+        }
+        const body = { files: options.files };
+        if (options.parentCommit) {
+            body.parent_commit = options.parentCommit;
+        }
+        const response = await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/v1/platform/hub/repos/${owner}/${name}/directories/commits`, {
+                method: "POST",
+                headers: {
+                    ...this._mergedHeaders,
+                    "Content-Type": "application/json",
+                },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: JSON.stringify(body),
+            });
+            await raiseForStatus(res, `push ${repoType}`);
+            return res;
+        });
+        const data = (await response.json());
+        const commitHash = data.commit.commit_hash;
+        return `${this.getHostUrl()}/hub/${owner}/${name}:${commitHash.slice(0, 8)}`;
+    }
+    async _deleteDirectory(identifier) {
+        const [owner, name] = parseHubIdentifier(identifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError("delete", owner);
+        }
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/v1/platform/hub/repos/${owner}/${name}/directories`, {
+                method: "DELETE",
+                headers: this._mergedHeaders,
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+            });
+            await raiseForStatus(res, "delete directory");
+            return res;
+        });
+    }
+    async _repoExists(owner, name) {
+        try {
+            await this.caller.call(async () => {
+                const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${name}`, {
+                    method: "GET",
+                    headers: this._mergedHeaders,
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                });
+                await raiseForStatus(res, "check repo exists");
+                return res;
+            });
+            return true;
+        }
+        catch (e) {
+            if (isLangSmithNotFoundError(e)) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    async _createRepo(name, repoType, options) {
+        const body = {
+            repo_handle: name,
+            repo_type: repoType,
+            is_public: !!options.isPublic,
+        };
+        if (options.description !== undefined)
+            body.description = options.description;
+        if (options.readme !== undefined)
+            body.readme = options.readme;
+        if (options.tags !== undefined)
+            body.tags = options.tags;
+        try {
+            await this.caller.call(async () => {
+                const res = await this._fetch(`${this.apiUrl}/repos/`, {
+                    method: "POST",
+                    headers: {
+                        ...this._mergedHeaders,
+                        "Content-Type": "application/json",
+                    },
+                    signal: AbortSignal.timeout(this.timeout_ms),
+                    ...this.fetchOptions,
+                    body: JSON.stringify(body),
+                });
+                await raiseForStatus(res, `create ${repoType}`);
+                return res;
+            });
+        }
+        catch (e) {
+            if (isLangSmithConflictError(e)) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async _updateRepoMetadata(owner, name, options) {
+        const body = {};
+        if (options.description !== undefined)
+            body.description = options.description;
+        if (options.readme !== undefined)
+            body.readme = options.readme;
+        if (options.tags !== undefined)
+            body.tags = options.tags;
+        if (options.isPublic !== undefined)
+            body.is_public = options.isPublic;
+        if (Object.keys(body).length === 0)
+            return;
+        await this.caller.call(async () => {
+            const res = await this._fetch(`${this.apiUrl}/repos/${owner}/${name}`, {
+                method: "PATCH",
+                headers: {
+                    ...this._mergedHeaders,
+                    "Content-Type": "application/json",
+                },
+                signal: AbortSignal.timeout(this.timeout_ms),
+                ...this.fetchOptions,
+                body: JSON.stringify(body),
+            });
+            await raiseForStatus(res, "update repo metadata");
+            return res;
+        });
+    }
     /**
      * Clone a public dataset to your own langsmith tenant.
      * This operation is idempotent. If you already have a dataset with the given name,

package/dist/evaluation/_runner.cjs

@@ -726,10 +726,7 @@ async function _evaluate(target, fields) {
     const standardFields = fields;
     const [experiment_, newRuns] = await _resolveExperiment(fields.experiment ?? null, runs, client);
     let manager = await new _ExperimentManager({
-        data: Array.isArray(standardFields.data) ? undefined : standardFields.data,
-        examples: Array.isArray(standardFields.data)
-            ? standardFields.data
-            : undefined,
+        data: standardFields.data,
         client,
         metadata: fields.metadata,
         experiment: experiment_ ?? fields.experimentPrefix,

package/dist/evaluation/_runner.js

@@ -719,10 +719,7 @@ async function _evaluate(target, fields) {
     const standardFields = fields;
     const [experiment_, newRuns] = await _resolveExperiment(fields.experiment ?? null, runs, client);
     let manager = await new _ExperimentManager({
-        data: Array.isArray(standardFields.data) ? undefined : standardFields.data,
-        examples: Array.isArray(standardFields.data)
-            ? standardFields.data
-            : undefined,
+        data: standardFields.data,
         client,
         metadata: fields.metadata,
         experiment: experiment_ ?? fields.experimentPrefix,

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.22";
+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.22";
+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.22";
+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.
  *