langsmith 0.1.39 → 0.1.40

package/dist/client.cjs

@@ -31,6 +31,7 @@ const env_js_1 = require("./utils/env.cjs");
 const index_js_1 = require("./index.cjs");
 const _uuid_js_1 = require("./utils/_uuid.cjs");
 const warn_js_1 = require("./utils/warn.cjs");
+const prompts_js_1 = require("./utils/prompts.cjs");
 async function mergeRuntimeEnvIntoRunCreates(runs) {
     const runtimeEnv = await (0, env_js_1.getRuntimeEnvironment)();
     const envVars = (0, env_js_1.getLangChainEnvVarsMetadata)();
@@ -268,6 +269,12 @@ class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         const defaultConfig = Client.getDefaultClientConfig();
         this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
@@ -389,7 +396,7 @@ class Client {
         const response = await this._getResponse(path, queryParams);
         return response.json();
     }
-    async *_getPaginated(path, queryParams = new URLSearchParams()) {
+    async *_getPaginated(path, queryParams = new URLSearchParams(), transform) {
         let offset = Number(queryParams.get("offset")) || 0;
         const limit = Number(queryParams.get("limit")) || 100;
         while (true) {
@@ -405,7 +412,9 @@ class Client {
             if (!response.ok) {
                 throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
             }
-            const items = await response.json();
+            const items = transform
+                ? transform(await response.json())
+                : await response.json();
             if (items.length === 0) {
                 break;
             }
@@ -536,6 +545,12 @@ class Client {
         }
         return true;
     }
+    async _getSettings() {
+        if (!this.settings) {
+            this.settings = this._get("/settings");
+        }
+        return await this.settings;
+    }
     async createRun(run) {
         if (!this._filterForSampling([run]).length) {
             return;
@@ -2035,5 +2050,307 @@ class Client {
         const [results] = await this._logEvaluationFeedback(evaluatorResponse, run, sourceInfo);
         return results;
     }
+    async _currentTenantIsOwner(owner) {
+        const settings = await this._getSettings();
+        return owner == "-" || settings.tenant_handle === owner;
+    }
+    async _ownerConflictError(action, owner) {
+        const settings = await this._getSettings();
+        return new Error(`Cannot ${action} for another tenant.\n
+      Current tenant: ${settings.tenant_handle}\n
+      Requested tenant: ${owner}`);
+    }
+    async _getLatestCommitHash(promptOwnerAndName) {
+        const res = await this.caller.call(fetch, `${this.apiUrl}/commits/${promptOwnerAndName}/?limit=${1}&offset=${0}`, {
+            method: "GET",
+            headers: this.headers,
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        const json = await res.json();
+        if (!res.ok) {
+            const detail = typeof json.detail === "string"
+                ? json.detail
+                : JSON.stringify(json.detail);
+            const error = new Error(`Error ${res.status}: ${res.statusText}\n${detail}`);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            error.statusCode = res.status;
+            throw error;
+        }
+        if (json.commits.length === 0) {
+            return undefined;
+        }
+        return json.commits[0].commit_hash;
+    }
+    async _likeOrUnlikePrompt(promptIdentifier, like) {
+        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const response = await this.caller.call(fetch, `${this.apiUrl}/likes/${owner}/${promptName}`, {
+            method: "POST",
+            body: JSON.stringify({ like: like }),
+            headers: { ...this.headers, "Content-Type": "application/json" },
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to ${like ? "like" : "unlike"} prompt: ${response.status} ${await response.text()}`);
+        }
+        return await response.json();
+    }
+    async _getPromptUrl(promptIdentifier) {
+        const [owner, promptName, commitHash] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            if (commitHash !== "latest") {
+                return `${this.getHostUrl()}/hub/${owner}/${promptName}/${commitHash.substring(0, 8)}`;
+            }
+            else {
+                return `${this.getHostUrl()}/hub/${owner}/${promptName}`;
+            }
+        }
+        else {
+            const settings = await this._getSettings();
+            if (commitHash !== "latest") {
+                return `${this.getHostUrl()}/prompts/${promptName}/${commitHash.substring(0, 8)}?organizationId=${settings.id}`;
+            }
+            else {
+                return `${this.getHostUrl()}/prompts/${promptName}?organizationId=${settings.id}`;
+            }
+        }
+    }
+    async promptExists(promptIdentifier) {
+        const prompt = await this.getPrompt(promptIdentifier);
+        return !!prompt;
+    }
+    async likePrompt(promptIdentifier) {
+        return this._likeOrUnlikePrompt(promptIdentifier, true);
+    }
+    async unlikePrompt(promptIdentifier) {
+        return this._likeOrUnlikePrompt(promptIdentifier, false);
+    }
+    async *listCommits(promptOwnerAndName) {
+        for await (const commits of this._getPaginated(`/commits/${promptOwnerAndName}/`, {}, (res) => res.commits)) {
+            yield* commits;
+        }
+    }
+    async *listPrompts(options) {
+        const params = new URLSearchParams();
+        params.append("sort_field", options?.sortField ?? "updated_at");
+        params.append("sort_direction", "desc");
+        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 prompts of this._getPaginated("/repos", params, (res) => res.repos)) {
+            yield* prompts;
+        }
+    }
+    async getPrompt(promptIdentifier) {
+        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const response = await this.caller.call(fetch, `${this.apiUrl}/repos/${owner}/${promptName}`, {
+            method: "GET",
+            headers: this.headers,
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        if (response.status === 404) {
+            return null;
+        }
+        if (!response.ok) {
+            throw new Error(`Failed to get prompt: ${response.status} ${await response.text()}`);
+        }
+        const result = await response.json();
+        if (result.repo) {
+            return result.repo;
+        }
+        else {
+            return null;
+        }
+    }
+    async createPrompt(promptIdentifier, options) {
+        const settings = await this._getSettings();
+        if (options?.isPublic && !settings.tenant_handle) {
+            throw new Error(`Cannot create a public prompt without first\n
+        creating a LangChain Hub handle. 
+        You can add a handle by creating a public prompt at:\n
+        https://smith.langchain.com/prompts`);
+        }
+        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError("create a prompt", owner);
+        }
+        const data = {
+            repo_handle: promptName,
+            ...(options?.description && { description: options.description }),
+            ...(options?.readme && { readme: options.readme }),
+            ...(options?.tags && { tags: options.tags }),
+            is_public: !!options?.isPublic,
+        };
+        const response = await this.caller.call(fetch, `${this.apiUrl}/repos/`, {
+            method: "POST",
+            headers: { ...this.headers, "Content-Type": "application/json" },
+            body: JSON.stringify(data),
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to create prompt: ${response.status} ${await response.text()}`);
+        }
+        const { repo } = await response.json();
+        return repo;
+    }
+    async createCommit(promptIdentifier, object, options) {
+        if (!(await this.promptExists(promptIdentifier))) {
+            throw new Error("Prompt does not exist, you must create it first.");
+        }
+        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const resolvedParentCommitHash = options?.parentCommitHash === "latest" || !options?.parentCommitHash
+            ? await this._getLatestCommitHash(`${owner}/${promptName}`)
+            : options?.parentCommitHash;
+        const payload = {
+            manifest: JSON.parse(JSON.stringify(object)),
+            parent_commit: resolvedParentCommitHash,
+        };
+        const response = await this.caller.call(fetch, `${this.apiUrl}/commits/${owner}/${promptName}`, {
+            method: "POST",
+            headers: { ...this.headers, "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to create commit: ${response.status} ${await response.text()}`);
+        }
+        const result = await response.json();
+        return this._getPromptUrl(`${owner}/${promptName}${result.commit_hash ? `:${result.commit_hash}` : ""}`);
+    }
+    async updatePrompt(promptIdentifier, options) {
+        if (!(await this.promptExists(promptIdentifier))) {
+            throw new Error("Prompt does not exist, you must create it first.");
+        }
+        const [owner, promptName] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError("update a prompt", owner);
+        }
+        const payload = {};
+        if (options?.description !== undefined)
+            payload.description = options.description;
+        if (options?.readme !== undefined)
+            payload.readme = options.readme;
+        if (options?.tags !== undefined)
+            payload.tags = options.tags;
+        if (options?.isPublic !== undefined)
+            payload.is_public = options.isPublic;
+        if (options?.isArchived !== undefined)
+            payload.is_archived = options.isArchived;
+        // Check if payload is empty
+        if (Object.keys(payload).length === 0) {
+            throw new Error("No valid update options provided");
+        }
+        const response = await this.caller.call(fetch, `${this.apiUrl}/repos/${owner}/${promptName}`, {
+            method: "PATCH",
+            body: JSON.stringify(payload),
+            headers: {
+                ...this.headers,
+                "Content-Type": "application/json",
+            },
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP Error: ${response.status} - ${await response.text()}`);
+        }
+        return response.json();
+    }
+    async deletePrompt(promptIdentifier) {
+        if (!(await this.promptExists(promptIdentifier))) {
+            throw new Error("Prompt does not exist, you must create it first.");
+        }
+        const [owner, promptName, _] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        if (!(await this._currentTenantIsOwner(owner))) {
+            throw await this._ownerConflictError("delete a prompt", owner);
+        }
+        const response = await this.caller.call(fetch, `${this.apiUrl}/repos/${owner}/${promptName}`, {
+            method: "DELETE",
+            headers: this.headers,
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        return await response.json();
+    }
+    async pullPromptCommit(promptIdentifier, options) {
+        const [owner, promptName, commitHash] = (0, prompts_js_1.parsePromptIdentifier)(promptIdentifier);
+        const serverInfo = await this._getServerInfo();
+        const useOptimization = (0, prompts_js_1.isVersionGreaterOrEqual)(serverInfo.version, "0.5.23");
+        let passedCommitHash = commitHash;
+        if (!useOptimization && commitHash === "latest") {
+            const latestCommitHash = await this._getLatestCommitHash(`${owner}/${promptName}`);
+            if (!latestCommitHash) {
+                throw new Error("No commits found");
+            }
+            else {
+                passedCommitHash = latestCommitHash;
+            }
+        }
+        const response = await this.caller.call(fetch, `${this.apiUrl}/commits/${owner}/${promptName}/${passedCommitHash}${options?.includeModel ? "?include_model=true" : ""}`, {
+            method: "GET",
+            headers: this.headers,
+            signal: AbortSignal.timeout(this.timeout_ms),
+            ...this.fetchOptions,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to pull prompt commit: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            owner,
+            repo: promptName,
+            commit_hash: result.commit_hash,
+            manifest: result.manifest,
+            examples: result.examples,
+        };
+    }
+    /**
+     *
+     * This method should not be used directly, use `import { pull } from "langchain/hub"` instead.
+     * Using this method directly returns the JSON string of the prompt rather than a LangChain object.
+     * @private
+     *
+     */
+    async _pullPrompt(promptIdentifier, options) {
+        const promptObject = await this.pullPromptCommit(promptIdentifier, {
+            includeModel: options?.includeModel,
+        });
+        const prompt = JSON.stringify(promptObject.manifest);
+        return prompt;
+    }
+    async pushPrompt(promptIdentifier, options) {
+        // Create or update prompt metadata
+        if (await this.promptExists(promptIdentifier)) {
+            await this.updatePrompt(promptIdentifier, {
+                description: options?.description,
+                readme: options?.readme,
+                tags: options?.tags,
+                isPublic: options?.isPublic,
+            });
+        }
+        else {
+            await this.createPrompt(promptIdentifier, {
+                description: options?.description,
+                readme: options?.readme,
+                tags: options?.tags,
+                isPublic: options?.isPublic,
+            });
+        }
+        if (!options?.object) {
+            return await this._getPromptUrl(promptIdentifier);
+        }
+        // Create a commit with the new manifest
+        const url = await this.createCommit(promptIdentifier, options?.object, {
+            parentCommitHash: options?.parentCommitHash,
+        });
+        return url;
+    }
 }
 exports.Client = Client;

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { AsyncCallerParams } from "./utils/async_caller.js";
-import { ComparativeExperiment, DataType, Dataset, DatasetDiffInfo, DatasetShareSchema, Example, ExampleUpdate, ExampleUpdateWithId, Feedback, FeedbackConfig, FeedbackIngestToken, KVMap, LangChainBaseMessage, Run, RunCreate, RunUpdate, ScoreType, TimeDelta, TracerSession, TracerSessionResult, ValueType } from "./schemas.js";
+import { ComparativeExperiment, DataType, Dataset, DatasetDiffInfo, DatasetShareSchema, Example, ExampleUpdate, ExampleUpdateWithId, Feedback, FeedbackConfig, FeedbackIngestToken, KVMap, LangChainBaseMessage, LangSmithSettings, LikePromptResponse, Prompt, PromptCommit, PromptSortField, Run, RunCreate, RunUpdate, ScoreType, TimeDelta, TracerSession, TracerSessionResult, ValueType } from "./schemas.js";
 import { EvaluationResult, EvaluationResults, RunEvaluator } from "./evaluation/evaluator.js";
 interface ClientConfig {
     apiUrl?: string;
@@ -176,6 +176,7 @@ export declare class Client {
     private autoBatchAggregationDelayMs;
     private serverInfo;
     private fetchOptions;
+    private settings;
     constructor(config?: ClientConfig);
     static getDefaultClientConfig(): {
         apiUrl: string;
@@ -198,6 +199,7 @@ export declare class Client {
     private processRunOperation;
     protected _getServerInfo(): Promise<any>;
     protected batchEndpointIsSupported(): Promise<boolean>;
+    protected _getSettings(): Promise<LangSmithSettings>;
     createRun(run: CreateRunParams): Promise<void>;
     /**
      * Batch ingest/upsert multiple runs in the Langsmith system.
@@ -537,5 +539,59 @@ export declare class Client {
     logEvaluationFeedback(evaluatorResponse: EvaluationResult | EvaluationResults, run?: Run, sourceInfo?: {
         [key: string]: any;
     }): Promise<EvaluationResult[]>;
+    protected _currentTenantIsOwner(owner: string): Promise<boolean>;
+    protected _ownerConflictError(action: string, owner: string): Promise<Error>;
+    protected _getLatestCommitHash(promptOwnerAndName: string): Promise<string | undefined>;
+    protected _likeOrUnlikePrompt(promptIdentifier: string, like: boolean): Promise<LikePromptResponse>;
+    protected _getPromptUrl(promptIdentifier: string): Promise<string>;
+    promptExists(promptIdentifier: string): Promise<boolean>;
+    likePrompt(promptIdentifier: string): Promise<LikePromptResponse>;
+    unlikePrompt(promptIdentifier: string): Promise<LikePromptResponse>;
+    listCommits(promptOwnerAndName: string): AsyncIterableIterator<PromptCommit>;
+    listPrompts(options?: {
+        isPublic?: boolean;
+        isArchived?: boolean;
+        sortField?: PromptSortField;
+        query?: string;
+    }): AsyncIterableIterator<Prompt>;
+    getPrompt(promptIdentifier: string): Promise<Prompt | null>;
+    createPrompt(promptIdentifier: string, options?: {
+        description?: string;
+        readme?: string;
+        tags?: string[];
+        isPublic?: boolean;
+    }): Promise<Prompt>;
+    createCommit(promptIdentifier: string, object: any, options?: {
+        parentCommitHash?: string;
+    }): Promise<string>;
+    updatePrompt(promptIdentifier: string, options?: {
+        description?: string;
+        readme?: string;
+        tags?: string[];
+        isPublic?: boolean;
+        isArchived?: boolean;
+    }): Promise<Record<string, any>>;
+    deletePrompt(promptIdentifier: string): Promise<void>;
+    pullPromptCommit(promptIdentifier: string, options?: {
+        includeModel?: boolean;
+    }): Promise<PromptCommit>;
+    /**
+     *
+     * This method should not be used directly, use `import { pull } from "langchain/hub"` instead.
+     * Using this method directly returns the JSON string of the prompt rather than a LangChain object.
+     * @private
+     *
+     */
+    _pullPrompt(promptIdentifier: string, options?: {
+        includeModel?: boolean;
+    }): Promise<any>;
+    pushPrompt(promptIdentifier: string, options?: {
+        object?: any;
+        parentCommitHash?: string;
+        isPublic?: boolean;
+        description?: string;
+        readme?: string;
+        tags?: string[];
+    }): Promise<string>;
 }
 export {};