langsmith 0.1.61 → 0.1.63

package/dist/client.cjs

@@ -116,11 +116,15 @@ class Queue {
         return this.items.length;
     }
     push(item) {
-        // this.items.push is synchronous with promise creation:
-        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
-        return new Promise((resolve) => {
-            this.items.push([item, resolve]);
-        });
+        let itemPromiseResolve;
+        const itemPromise = new Promise((resolve) => {
+            // Setting itemPromiseResolve is synchronous with promise creation:
+            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
+            itemPromiseResolve = resolve;
+        });
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.items.push([item, itemPromiseResolve, itemPromise]);
+        return itemPromise;
     }
     pop(upToN) {
         if (upToN < 1) {
@@ -270,6 +274,12 @@ class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "blockOnRootRunFinalization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         const defaultConfig = Client.getDefaultClientConfig();
         this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
@@ -292,6 +302,8 @@ class Client {
         this.hideOutputs =
             config.hideOutputs ?? config.anonymizer ?? defaultConfig.hideOutputs;
         this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
+        this.blockOnRootRunFinalization =
+            config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
         this.pendingAutoBatchedRunLimit =
             config.pendingAutoBatchedRunLimit ?? this.pendingAutoBatchedRunLimit;
         this.fetchOptions = config.fetchOptions || {};
@@ -698,7 +710,9 @@ class Client {
         if (this.autoBatchTracing &&
             data.trace_id !== undefined &&
             data.dotted_order !== undefined) {
-            if (run.end_time !== undefined && data.parent_run_id === undefined) {
+            if (run.end_time !== undefined &&
+                data.parent_run_id === undefined &&
+                this.blockOnRootRunFinalization) {
                 // Trigger a batch as soon as a root trace ends and block to ensure trace finishes
                 // in serverless environments.
                 await this.processRunOperation({ action: "update", item: data }, true);
@@ -2656,5 +2670,29 @@ class Client {
             throw new Error(`Invalid public ${kind} URL or token: ${urlOrToken}`);
         }
     }
+    /**
+     * Awaits all pending trace batches. Useful for environments where
+     * you need to be sure that all tracing requests finish before execution ends,
+     * such as serverless environments.
+     *
+     * @example
+     * ```
+     * import { Client } from "langsmith";
+     *
+     * const client = new Client();
+     *
+     * try {
+     *   // Tracing happens here
+     *   ...
+     * } finally {
+     *   await client.awaitPendingTraceBatches();
+     * }
+     * ```
+     *
+     * @returns A promise that resolves once all currently pending traces have sent.
+     */
+    awaitPendingTraceBatches() {
+        return Promise.all(this.autoBatchQueue.items.map(([, , promise]) => promise));
+    }
 }
 exports.Client = Client;

package/dist/client.d.ts

@@ -12,6 +12,7 @@ export interface ClientConfig {
     hideOutputs?: boolean | ((outputs: KVMap) => KVMap);
     autoBatchTracing?: boolean;
     pendingAutoBatchedRunLimit?: number;
+    blockOnRootRunFinalization?: boolean;
     fetchOptions?: RequestInit;
 }
 /**
@@ -157,7 +158,7 @@ export type CreateExampleOptions = {
     sourceRunId?: string;
 };
 export declare class Queue<T> {
-    items: [T, () => void][];
+    items: [T, () => void, Promise<void>][];
     get size(): number;
     push(item: T): Promise<void>;
     pop(upToN: number): [T[], () => void];
@@ -185,6 +186,7 @@ export declare class Client {
     private serverInfo;
     private fetchOptions;
     private settings;
+    private blockOnRootRunFinalization;
     constructor(config?: ClientConfig);
     static getDefaultClientConfig(): {
         apiUrl: string;
@@ -736,5 +738,27 @@ export declare class Client {
         datasetName?: string;
     }): Promise<void>;
     private parseTokenOrUrl;
+    /**
+     * Awaits all pending trace batches. Useful for environments where
+     * you need to be sure that all tracing requests finish before execution ends,
+     * such as serverless environments.
+     *
+     * @example
+     * ```
+     * import { Client } from "langsmith";
+     *
+     * const client = new Client();
+     *
+     * try {
+     *   // Tracing happens here
+     *   ...
+     * } finally {
+     *   await client.awaitPendingTraceBatches();
+     * }
+     * ```
+     *
+     * @returns A promise that resolves once all currently pending traces have sent.
+     */
+    awaitPendingTraceBatches(): Promise<void[]>;
 }
 export {};

package/dist/client.js

@@ -90,11 +90,15 @@ export class Queue {
         return this.items.length;
     }
     push(item) {
-        // this.items.push is synchronous with promise creation:
-        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
-        return new Promise((resolve) => {
-            this.items.push([item, resolve]);
-        });
+        let itemPromiseResolve;
+        const itemPromise = new Promise((resolve) => {
+            // Setting itemPromiseResolve is synchronous with promise creation:
+            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/Promise
+            itemPromiseResolve = resolve;
+        });
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.items.push([item, itemPromiseResolve, itemPromise]);
+        return itemPromise;
     }
     pop(upToN) {
         if (upToN < 1) {
@@ -243,6 +247,12 @@ export class Client {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "blockOnRootRunFinalization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         const defaultConfig = Client.getDefaultClientConfig();
         this.tracingSampleRate = getTracingSamplingRate();
         this.apiUrl = trimQuotes(config.apiUrl ?? defaultConfig.apiUrl) ?? "";
@@ -265,6 +275,8 @@ export class Client {
         this.hideOutputs =
             config.hideOutputs ?? config.anonymizer ?? defaultConfig.hideOutputs;
         this.autoBatchTracing = config.autoBatchTracing ?? this.autoBatchTracing;
+        this.blockOnRootRunFinalization =
+            config.blockOnRootRunFinalization ?? this.blockOnRootRunFinalization;
         this.pendingAutoBatchedRunLimit =
             config.pendingAutoBatchedRunLimit ?? this.pendingAutoBatchedRunLimit;
         this.fetchOptions = config.fetchOptions || {};
@@ -671,7 +683,9 @@ export class Client {
         if (this.autoBatchTracing &&
             data.trace_id !== undefined &&
             data.dotted_order !== undefined) {
-            if (run.end_time !== undefined && data.parent_run_id === undefined) {
+            if (run.end_time !== undefined &&
+                data.parent_run_id === undefined &&
+                this.blockOnRootRunFinalization) {
                 // Trigger a batch as soon as a root trace ends and block to ensure trace finishes
                 // in serverless environments.
                 await this.processRunOperation({ action: "update", item: data }, true);
@@ -2629,4 +2643,28 @@ export class Client {
             throw new Error(`Invalid public ${kind} URL or token: ${urlOrToken}`);
         }
     }
+    /**
+     * Awaits all pending trace batches. Useful for environments where
+     * you need to be sure that all tracing requests finish before execution ends,
+     * such as serverless environments.
+     *
+     * @example
+     * ```
+     * import { Client } from "langsmith";
+     *
+     * const client = new Client();
+     *
+     * try {
+     *   // Tracing happens here
+     *   ...
+     * } finally {
+     *   await client.awaitPendingTraceBatches();
+     * }
+     * ```
+     *
+     * @returns A promise that resolves once all currently pending traces have sent.
+     */
+    awaitPendingTraceBatches() {
+        return Promise.all(this.autoBatchQueue.items.map(([, , promise]) => promise));
+    }
 }

package/dist/index.cjs

@@ -8,4 +8,4 @@ Object.defineProperty(exports, "RunTree", { enumerable: true, get: function () {
 var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
 // Update using yarn bump-version
-exports.__version__ = "0.1.61";
+exports.__version__ = "0.1.63";

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { Client, type ClientConfig } from "./client.js";
 export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, } from "./schemas.js";
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
-export declare const __version__ = "0.1.61";
+export declare const __version__ = "0.1.63";

package/dist/index.js

@@ -2,4 +2,4 @@ export { Client } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 // Update using yarn bump-version
-export const __version__ = "0.1.61";
+export const __version__ = "0.1.63";

package/dist/wrappers/openai.cjs

@@ -142,52 +142,102 @@ const wrapOpenAI = (openai, options) => {
         (0, traceable_js_1.isTraceableFunction)(openai.completions.create)) {
         throw new Error("This instance of OpenAI client has been already wrapped once.");
     }
-    openai.chat.completions.create = (0, traceable_js_1.traceable)(openai.chat.completions.create.bind(openai.chat.completions), {
-        name: "ChatOpenAI",
-        run_type: "llm",
-        aggregator: chatAggregator,
-        argsConfigPath: [1, "langsmithExtra"],
-        getInvocationParams: (payload) => {
-            if (typeof payload !== "object" || payload == null)
-                return undefined;
-            // we can safely do so, as the types are not exported in TSC
-            const params = payload;
-            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
-                undefined;
-            return {
-                ls_provider: "openai",
-                ls_model_type: "chat",
-                ls_model_name: params.model,
-                ls_max_tokens: params.max_tokens ?? undefined,
-                ls_temperature: params.temperature ?? undefined,
-                ls_stop,
-            };
-        },
-        ...options,
-    });
-    openai.completions.create = (0, traceable_js_1.traceable)(openai.completions.create.bind(openai.completions), {
-        name: "OpenAI",
-        run_type: "llm",
-        aggregator: textAggregator,
-        argsConfigPath: [1, "langsmithExtra"],
-        getInvocationParams: (payload) => {
-            if (typeof payload !== "object" || payload == null)
-                return undefined;
-            // we can safely do so, as the types are not exported in TSC
-            const params = payload;
-            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
-                undefined;
-            return {
-                ls_provider: "openai",
-                ls_model_type: "llm",
-                ls_model_name: params.model,
-                ls_max_tokens: params.max_tokens ?? undefined,
-                ls_temperature: params.temperature ?? undefined,
-                ls_stop,
-            };
+    // Some internal OpenAI methods call each other, so we need to preserve original
+    // OpenAI methods.
+    const tracedOpenAIClient = { ...openai };
+    if (openai.beta &&
+        openai.beta.chat &&
+        openai.beta.chat.completions &&
+        typeof openai.beta.chat.completions.parse === "function") {
+        tracedOpenAIClient.beta = {
+            ...openai.beta,
+            chat: {
+                ...openai.beta.chat,
+                completions: {
+                    ...openai.beta.chat.completions,
+                    parse: (0, traceable_js_1.traceable)(openai.beta.chat.completions.parse.bind(openai.beta.chat.completions), {
+                        name: "ChatOpenAI",
+                        run_type: "llm",
+                        aggregator: chatAggregator,
+                        argsConfigPath: [1, "langsmithExtra"],
+                        getInvocationParams: (payload) => {
+                            if (typeof payload !== "object" || payload == null)
+                                return undefined;
+                            // we can safely do so, as the types are not exported in TSC
+                            const params = payload;
+                            const ls_stop = (typeof params.stop === "string"
+                                ? [params.stop]
+                                : params.stop) ?? undefined;
+                            return {
+                                ls_provider: "openai",
+                                ls_model_type: "chat",
+                                ls_model_name: params.model,
+                                ls_max_tokens: params.max_tokens ?? undefined,
+                                ls_temperature: params.temperature ?? undefined,
+                                ls_stop,
+                            };
+                        },
+                        ...options,
+                    }),
+                },
+            },
+        };
+    }
+    tracedOpenAIClient.chat = {
+        ...openai.chat,
+        completions: {
+            ...openai.chat.completions,
+            create: (0, traceable_js_1.traceable)(openai.chat.completions.create.bind(openai.chat.completions), {
+                name: "ChatOpenAI",
+                run_type: "llm",
+                aggregator: chatAggregator,
+                argsConfigPath: [1, "langsmithExtra"],
+                getInvocationParams: (payload) => {
+                    if (typeof payload !== "object" || payload == null)
+                        return undefined;
+                    // we can safely do so, as the types are not exported in TSC
+                    const params = payload;
+                    const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                        undefined;
+                    return {
+                        ls_provider: "openai",
+                        ls_model_type: "chat",
+                        ls_model_name: params.model,
+                        ls_max_tokens: params.max_tokens ?? undefined,
+                        ls_temperature: params.temperature ?? undefined,
+                        ls_stop,
+                    };
+                },
+                ...options,
+            }),
         },
-        ...options,
-    });
-    return openai;
+    };
+    tracedOpenAIClient.completions = {
+        ...openai.completions,
+        create: (0, traceable_js_1.traceable)(openai.completions.create.bind(openai.completions), {
+            name: "OpenAI",
+            run_type: "llm",
+            aggregator: textAggregator,
+            argsConfigPath: [1, "langsmithExtra"],
+            getInvocationParams: (payload) => {
+                if (typeof payload !== "object" || payload == null)
+                    return undefined;
+                // we can safely do so, as the types are not exported in TSC
+                const params = payload;
+                const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                    undefined;
+                return {
+                    ls_provider: "openai",
+                    ls_model_type: "llm",
+                    ls_model_name: params.model,
+                    ls_max_tokens: params.max_tokens ?? undefined,
+                    ls_temperature: params.temperature ?? undefined,
+                    ls_stop,
+                };
+            },
+            ...options,
+        }),
+    };
+    return tracedOpenAIClient;
 };
 exports.wrapOpenAI = wrapOpenAI;

package/dist/wrappers/openai.d.ts

@@ -2,6 +2,13 @@ import { OpenAI } from "openai";
 import type { APIPromise } from "openai/core";
 import type { RunTreeConfig } from "../index.js";
 type OpenAIType = {
+    beta?: {
+        chat?: {
+            completions?: {
+                parse?: (...args: any[]) => any;
+            };
+        };
+    };
     chat: {
         completions: {
             create: (...args: any[]) => any;

package/dist/wrappers/openai.js

@@ -139,51 +139,101 @@ export const wrapOpenAI = (openai, options) => {
         isTraceableFunction(openai.completions.create)) {
         throw new Error("This instance of OpenAI client has been already wrapped once.");
     }
-    openai.chat.completions.create = traceable(openai.chat.completions.create.bind(openai.chat.completions), {
-        name: "ChatOpenAI",
-        run_type: "llm",
-        aggregator: chatAggregator,
-        argsConfigPath: [1, "langsmithExtra"],
-        getInvocationParams: (payload) => {
-            if (typeof payload !== "object" || payload == null)
-                return undefined;
-            // we can safely do so, as the types are not exported in TSC
-            const params = payload;
-            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
-                undefined;
-            return {
-                ls_provider: "openai",
-                ls_model_type: "chat",
-                ls_model_name: params.model,
-                ls_max_tokens: params.max_tokens ?? undefined,
-                ls_temperature: params.temperature ?? undefined,
-                ls_stop,
-            };
-        },
-        ...options,
-    });
-    openai.completions.create = traceable(openai.completions.create.bind(openai.completions), {
-        name: "OpenAI",
-        run_type: "llm",
-        aggregator: textAggregator,
-        argsConfigPath: [1, "langsmithExtra"],
-        getInvocationParams: (payload) => {
-            if (typeof payload !== "object" || payload == null)
-                return undefined;
-            // we can safely do so, as the types are not exported in TSC
-            const params = payload;
-            const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
-                undefined;
-            return {
-                ls_provider: "openai",
-                ls_model_type: "llm",
-                ls_model_name: params.model,
-                ls_max_tokens: params.max_tokens ?? undefined,
-                ls_temperature: params.temperature ?? undefined,
-                ls_stop,
-            };
+    // Some internal OpenAI methods call each other, so we need to preserve original
+    // OpenAI methods.
+    const tracedOpenAIClient = { ...openai };
+    if (openai.beta &&
+        openai.beta.chat &&
+        openai.beta.chat.completions &&
+        typeof openai.beta.chat.completions.parse === "function") {
+        tracedOpenAIClient.beta = {
+            ...openai.beta,
+            chat: {
+                ...openai.beta.chat,
+                completions: {
+                    ...openai.beta.chat.completions,
+                    parse: traceable(openai.beta.chat.completions.parse.bind(openai.beta.chat.completions), {
+                        name: "ChatOpenAI",
+                        run_type: "llm",
+                        aggregator: chatAggregator,
+                        argsConfigPath: [1, "langsmithExtra"],
+                        getInvocationParams: (payload) => {
+                            if (typeof payload !== "object" || payload == null)
+                                return undefined;
+                            // we can safely do so, as the types are not exported in TSC
+                            const params = payload;
+                            const ls_stop = (typeof params.stop === "string"
+                                ? [params.stop]
+                                : params.stop) ?? undefined;
+                            return {
+                                ls_provider: "openai",
+                                ls_model_type: "chat",
+                                ls_model_name: params.model,
+                                ls_max_tokens: params.max_tokens ?? undefined,
+                                ls_temperature: params.temperature ?? undefined,
+                                ls_stop,
+                            };
+                        },
+                        ...options,
+                    }),
+                },
+            },
+        };
+    }
+    tracedOpenAIClient.chat = {
+        ...openai.chat,
+        completions: {
+            ...openai.chat.completions,
+            create: traceable(openai.chat.completions.create.bind(openai.chat.completions), {
+                name: "ChatOpenAI",
+                run_type: "llm",
+                aggregator: chatAggregator,
+                argsConfigPath: [1, "langsmithExtra"],
+                getInvocationParams: (payload) => {
+                    if (typeof payload !== "object" || payload == null)
+                        return undefined;
+                    // we can safely do so, as the types are not exported in TSC
+                    const params = payload;
+                    const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                        undefined;
+                    return {
+                        ls_provider: "openai",
+                        ls_model_type: "chat",
+                        ls_model_name: params.model,
+                        ls_max_tokens: params.max_tokens ?? undefined,
+                        ls_temperature: params.temperature ?? undefined,
+                        ls_stop,
+                    };
+                },
+                ...options,
+            }),
         },
-        ...options,
-    });
-    return openai;
+    };
+    tracedOpenAIClient.completions = {
+        ...openai.completions,
+        create: traceable(openai.completions.create.bind(openai.completions), {
+            name: "OpenAI",
+            run_type: "llm",
+            aggregator: textAggregator,
+            argsConfigPath: [1, "langsmithExtra"],
+            getInvocationParams: (payload) => {
+                if (typeof payload !== "object" || payload == null)
+                    return undefined;
+                // we can safely do so, as the types are not exported in TSC
+                const params = payload;
+                const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
+                    undefined;
+                return {
+                    ls_provider: "openai",
+                    ls_model_type: "llm",
+                    ls_model_name: params.model,
+                    ls_max_tokens: params.max_tokens ?? undefined,
+                    ls_temperature: params.temperature ?? undefined,
+                    ls_stop,
+                };
+            },
+            ...options,
+        }),
+    };
+    return tracedOpenAIClient;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -127,7 +127,7 @@
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
     "langchain": "^0.3.2",
-    "openai": "^4.38.5",
+    "openai": "^4.67.3",
     "prettier": "^2.8.8",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",