langsmith 0.3.37 → 0.3.38

package/dist/index.cjs

@@ -10,4 +10,4 @@ Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true
 var project_js_1 = require("./utils/project.cjs");
 Object.defineProperty(exports, "getDefaultProjectName", { enumerable: true, get: function () { return project_js_1.getDefaultProjectName; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.37";
+exports.__version__ = "0.3.38";

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, }
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
-export declare const __version__ = "0.3.37";
+export declare const __version__ = "0.3.38";

package/dist/index.js

@@ -3,4 +3,4 @@ export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.37";
+export const __version__ = "0.3.38";

package/dist/singletons/traceable.cjs

@@ -4,7 +4,6 @@ exports.ROOT = exports.AsyncLocalStorageProviderSingleton = void 0;
 exports.getCurrentRunTree = getCurrentRunTree;
 exports.withRunTree = withRunTree;
 exports.isTraceableFunction = isTraceableFunction;
-const run_trees_js_1 = require("../run_trees.cjs");
 class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -31,7 +30,7 @@ class AsyncLocalStorageProvider {
 exports.AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
 function getCurrentRunTree(permitAbsentRunTree = false) {
     const runTree = exports.AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    if (!permitAbsentRunTree && !(0, run_trees_js_1.isRunTree)(runTree)) {
+    if (!permitAbsentRunTree && runTree === undefined) {
         throw new Error("Could not get the current run tree.\n\nPlease make sure you are calling this method within a traceable function and that tracing is enabled.");
     }
     return runTree;

package/dist/singletons/traceable.d.ts

@@ -1,8 +1,8 @@
-import { RunTree } from "../run_trees.js";
-import { TraceableFunction } from "./types.js";
+import type { RunTree } from "../run_trees.js";
+import type { ContextPlaceholder, TraceableFunction } from "./types.js";
 interface AsyncLocalStorageInterface {
-    getStore: () => RunTree | undefined;
-    run: (context: RunTree | undefined, fn: () => void) => void;
+    getStore: () => RunTree | ContextPlaceholder | undefined;
+    run: (context: RunTree | ContextPlaceholder | undefined, fn: () => void) => void;
 }
 declare class AsyncLocalStorageProvider {
     getInstance(): AsyncLocalStorageInterface;

package/dist/singletons/traceable.js

@@ -1,4 +1,3 @@
-import { isRunTree } from "../run_trees.js";
 class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -25,7 +24,7 @@ class AsyncLocalStorageProvider {
 export const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
 export function getCurrentRunTree(permitAbsentRunTree = false) {
     const runTree = AsyncLocalStorageProviderSingleton.getInstance().getStore();
-    if (!permitAbsentRunTree && !isRunTree(runTree)) {
+    if (!permitAbsentRunTree && runTree === undefined) {
         throw new Error("Could not get the current run tree.\n\nPlease make sure you are calling this method within a traceable function and that tracing is enabled.");
     }
     return runTree;

package/dist/singletons/types.cjs

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const constants_js_1 = require("./constants.cjs");

package/dist/singletons/types.d.ts

@@ -1,5 +1,6 @@
 import { RunTree, RunnableConfigLike } from "../run_trees.js";
 import { ROOT } from "./traceable.js";
+import { _LC_CONTEXT_VARIABLES_KEY } from "./constants.js";
 type SmartPromise<T> = T extends AsyncGenerator ? T : T extends Promise<unknown> ? T : Promise<T>;
 type WrapArgReturnPair<Pair> = Pair extends [
     infer Args extends any[],
@@ -37,4 +38,7 @@ export type TraceableFunction<Func extends (...args: any[]) => any> = (Func exte
     [K in keyof Func]: Func[K];
 };
 export type RunTreeLike = RunTree;
+export type ContextPlaceholder = {
+    [_LC_CONTEXT_VARIABLES_KEY]?: Record<string, unknown>;
+};
 export {};

package/dist/singletons/types.js

@@ -1 +1 @@
-export {};
+import { _LC_CONTEXT_VARIABLES_KEY } from "./constants.js";

package/dist/traceable.cjs

@@ -143,7 +143,7 @@ const handleRunAttachments = (rawInputs, extractAttachments) => {
 };
 const getTracingRunTree = (runTree, inputs, getInvocationParams, processInputs, extractAttachments) => {
     if (!(0, env_js_1.isTracingEnabled)(runTree.tracingEnabled)) {
-        return undefined;
+        return {};
     }
     const [attached, args] = handleRunAttachments(inputs, extractAttachments);
     runTree.attachments = attached;
@@ -364,7 +364,7 @@ function traceable(wrappedFunc, config) {
         for (let i = 0; i < processedArgs.length; i++) {
             processedArgs[i] = convertSerializableArg(processedArgs[i]);
         }
-        const [currentRunTree, rawInputs] = (() => {
+        const [currentContext, rawInputs] = (() => {
             const [firstArg, ...restArgs] = processedArgs;
             // used for handoff between LangChain.JS and traceable functions
             if ((0, run_trees_js_1.isRunnableConfigLike)(firstArg)) {
@@ -391,24 +391,32 @@ function traceable(wrappedFunc, config) {
             // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
             // to allow storing context
             const prevRunFromStore = asyncLocalStorage.getStore();
-            if ((0, run_trees_js_1.isRunTree)(prevRunFromStore)) {
-                return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn),
-                    processedArgs,
-                ];
-            }
-            const currentRunTree = getTracingRunTree(new run_trees_js_1.RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            let lc_contextVars;
             // If a context var is set by LangChain outside of a traceable,
             // it will be an object with a single property and we should copy
             // context vars over into the new run tree.
             if (prevRunFromStore !== undefined &&
                 constants_js_1._LC_CONTEXT_VARIABLES_KEY in prevRunFromStore) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                currentRunTree[constants_js_1._LC_CONTEXT_VARIABLES_KEY] =
-                    prevRunFromStore[constants_js_1._LC_CONTEXT_VARIABLES_KEY];
+                lc_contextVars = prevRunFromStore[constants_js_1._LC_CONTEXT_VARIABLES_KEY];
+            }
+            if ((0, run_trees_js_1.isRunTree)(prevRunFromStore)) {
+                const currentRunTree = getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+                if (lc_contextVars) {
+                    (currentRunTree ?? {})[constants_js_1._LC_CONTEXT_VARIABLES_KEY] =
+                        lc_contextVars;
+                }
+                return [currentRunTree, processedArgs];
+            }
+            const currentRunTree = getTracingRunTree(new run_trees_js_1.RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            if (lc_contextVars) {
+                (currentRunTree ?? {})[constants_js_1._LC_CONTEXT_VARIABLES_KEY] =
+                    lc_contextVars;
             }
             return [currentRunTree, processedArgs];
         })();
+        const currentRunTree = (0, run_trees_js_1.isRunTree)(currentContext)
+            ? currentContext
+            : undefined;
         const otelContextManager = maybeCreateOtelContext(currentRunTree, config?.tracer);
         const otel_context = (0, otel_js_1.getOTELContext)();
         const runWithContext = () => {
@@ -648,10 +656,10 @@ function traceable(wrappedFunc, config) {
         };
         // Wrap with OTEL context if available, similar to Python's implementation
         if (otelContextManager) {
-            return asyncLocalStorage.run(currentRunTree, () => otelContextManager(runWithContext));
+            return asyncLocalStorage.run(currentContext, () => otelContextManager(runWithContext));
         }
         else {
-            return asyncLocalStorage.run(currentRunTree, runWithContext);
+            return asyncLocalStorage.run(currentContext, runWithContext);
         }
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {

package/dist/traceable.d.ts

@@ -1,22 +1,8 @@
 import { RunTreeConfig } from "./run_trees.js";
 import { Attachments, InvocationParamsSchema, KVMap } from "./schemas.js";
-import { TraceableFunction } from "./singletons/types.js";
+import type { TraceableFunction } from "./singletons/types.js";
 import { OTELTracer } from "./experimental/otel/types.js";
-/**
- * Higher-order function that takes function as input and returns a
- * "TraceableFunction" - a wrapped version of the input that
- * automatically handles tracing. If the returned traceable function calls any
- * traceable functions, those are automatically traced as well.
- *
- * The returned TraceableFunction can accept a run tree or run tree config as
- * its first argument. If omitted, it will default to the caller's run tree,
- * or will be treated as a root run.
- *
- * @param wrappedFunc Targeted function to be traced
- * @param config Additional metadata such as name, tags or providing
- *     a custom LangSmith client instance
- */
-export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: Partial<Omit<RunTreeConfig, "inputs" | "outputs">> & {
+export type TraceableConfig<Func extends (...args: any[]) => any> = Partial<Omit<RunTreeConfig, "inputs" | "outputs">> & {
     aggregator?: (args: any[]) => any;
     argsConfigPath?: [number] | [number, string];
     tracer?: OTELTracer;
@@ -54,6 +40,21 @@ export declare function traceable<Func extends (...args: any[]) => any>(wrappedF
      * @returns Transformed key-value map
      */
     processOutputs?: (outputs: Readonly<KVMap>) => KVMap;
-}): TraceableFunction<Func>;
+};
+/**
+ * Higher-order function that takes function as input and returns a
+ * "TraceableFunction" - a wrapped version of the input that
+ * automatically handles tracing. If the returned traceable function calls any
+ * traceable functions, those are automatically traced as well.
+ *
+ * The returned TraceableFunction can accept a run tree or run tree config as
+ * its first argument. If omitted, it will default to the caller's run tree,
+ * or will be treated as a root run.
+ *
+ * @param wrappedFunc Targeted function to be traced
+ * @param config Additional metadata such as name, tags or providing
+ *     a custom LangSmith client instance
+ */
+export declare function traceable<Func extends (...args: any[]) => any>(wrappedFunc: Func, config?: TraceableConfig<Func>): TraceableFunction<Func>;
 export { getCurrentRunTree, isTraceableFunction, withRunTree, ROOT, } from "./singletons/traceable.js";
 export type { RunTreeLike, TraceableFunction } from "./singletons/types.js";

package/dist/traceable.js

@@ -139,7 +139,7 @@ const handleRunAttachments = (rawInputs, extractAttachments) => {
 };
 const getTracingRunTree = (runTree, inputs, getInvocationParams, processInputs, extractAttachments) => {
     if (!isTracingEnabled(runTree.tracingEnabled)) {
-        return undefined;
+        return {};
     }
     const [attached, args] = handleRunAttachments(inputs, extractAttachments);
     runTree.attachments = attached;
@@ -360,7 +360,7 @@ export function traceable(wrappedFunc, config) {
         for (let i = 0; i < processedArgs.length; i++) {
             processedArgs[i] = convertSerializableArg(processedArgs[i]);
         }
-        const [currentRunTree, rawInputs] = (() => {
+        const [currentContext, rawInputs] = (() => {
             const [firstArg, ...restArgs] = processedArgs;
             // used for handoff between LangChain.JS and traceable functions
             if (isRunnableConfigLike(firstArg)) {
@@ -387,24 +387,32 @@ export function traceable(wrappedFunc, config) {
             // Node.JS uses AsyncLocalStorage (ALS) and AsyncResource
             // to allow storing context
             const prevRunFromStore = asyncLocalStorage.getStore();
-            if (isRunTree(prevRunFromStore)) {
-                return [
-                    getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn),
-                    processedArgs,
-                ];
-            }
-            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            let lc_contextVars;
             // If a context var is set by LangChain outside of a traceable,
             // it will be an object with a single property and we should copy
             // context vars over into the new run tree.
             if (prevRunFromStore !== undefined &&
                 _LC_CONTEXT_VARIABLES_KEY in prevRunFromStore) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                currentRunTree[_LC_CONTEXT_VARIABLES_KEY] =
-                    prevRunFromStore[_LC_CONTEXT_VARIABLES_KEY];
+                lc_contextVars = prevRunFromStore[_LC_CONTEXT_VARIABLES_KEY];
+            }
+            if (isRunTree(prevRunFromStore)) {
+                const currentRunTree = getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+                if (lc_contextVars) {
+                    (currentRunTree ?? {})[_LC_CONTEXT_VARIABLES_KEY] =
+                        lc_contextVars;
+                }
+                return [currentRunTree, processedArgs];
+            }
+            const currentRunTree = getTracingRunTree(new RunTree(ensuredConfig), processedArgs, config?.getInvocationParams, processInputsFn, extractAttachmentsFn);
+            if (lc_contextVars) {
+                (currentRunTree ?? {})[_LC_CONTEXT_VARIABLES_KEY] =
+                    lc_contextVars;
             }
             return [currentRunTree, processedArgs];
         })();
+        const currentRunTree = isRunTree(currentContext)
+            ? currentContext
+            : undefined;
         const otelContextManager = maybeCreateOtelContext(currentRunTree, config?.tracer);
         const otel_context = getOTELContext();
         const runWithContext = () => {
@@ -644,10 +652,10 @@ export function traceable(wrappedFunc, config) {
         };
         // Wrap with OTEL context if available, similar to Python's implementation
         if (otelContextManager) {
-            return asyncLocalStorage.run(currentRunTree, () => otelContextManager(runWithContext));
+            return asyncLocalStorage.run(currentContext, () => otelContextManager(runWithContext));
         }
         else {
-            return asyncLocalStorage.run(currentRunTree, runWithContext);
+            return asyncLocalStorage.run(currentContext, runWithContext);
         }
     };
     Object.defineProperty(traceableFunc, "langsmith:traceable", {

package/dist/wrappers/openai.cjs

@@ -93,6 +93,19 @@ const chatAggregator = (chunks) => {
     aggregatedOutput.choices = Object.values(choicesByIndex).map((choices) => _combineChatCompletionChoices(choices));
     return aggregatedOutput;
 };
+const responsesAggregator = (events) => {
+    if (!events || events.length === 0) {
+        return {};
+    }
+    // Find the response.completed event which contains the final response
+    for (const event of events) {
+        if (event.type === "response.completed" && event.response) {
+            return event.response;
+        }
+    }
+    // If no completed event found, return the last event
+    return events[events.length - 1] || {};
+};
 const textAggregator = (allChunks
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) => {
@@ -187,74 +200,50 @@ const wrapOpenAI = (openai, options) => {
     // 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,
-                    }),
-                },
-            },
-        };
+    const chatCompletionParseMetadata = {
+        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_completion_tokens ?? params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+            };
+        },
+        processOutputs: processChatCompletion,
+        ...options,
+    };
+    if (openai.beta) {
+        tracedOpenAIClient.beta = openai.beta;
+        if (openai.beta.chat &&
+            openai.beta.chat.completions &&
+            typeof openai.beta.chat.completions.parse === "function") {
+            tracedOpenAIClient.beta.chat.completions.parse = (0, traceable_js_1.traceable)(openai.beta.chat.completions.parse.bind(openai.beta.chat.completions), chatCompletionParseMetadata);
+        }
     }
     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,
-                    };
-                },
-                processOutputs: processChatCompletion,
-                ...options,
-            }),
-        },
+        completions: Object.create(Object.getPrototypeOf(openai.chat.completions)),
     };
+    // Copy all own properties and then wrap specific methods
+    Object.assign(tracedOpenAIClient.chat.completions, openai.chat.completions);
+    // Wrap chat.completions.create
+    tracedOpenAIClient.chat.completions.create = (0, traceable_js_1.traceable)(openai.chat.completions.create.bind(openai.chat.completions), chatCompletionParseMetadata);
+    // Wrap chat.completions.parse if it exists
+    if (typeof openai.chat.completions.parse === "function") {
+        tracedOpenAIClient.chat.completions.parse = (0, traceable_js_1.traceable)(openai.chat.completions.parse.bind(openai.chat.completions), chatCompletionParseMetadata);
+    }
     tracedOpenAIClient.completions = {
         ...openai.completions,
         create: (0, traceable_js_1.traceable)(openai.completions.create.bind(openai.completions), {
@@ -281,6 +270,38 @@ const wrapOpenAI = (openai, options) => {
             ...options,
         }),
     };
+    // Add responses API support if it exists
+    if (openai.responses) {
+        // Create a new object with the same prototype to preserve all methods
+        tracedOpenAIClient.responses = Object.create(Object.getPrototypeOf(openai.responses));
+        // Copy all own properties
+        if (tracedOpenAIClient.responses) {
+            Object.assign(tracedOpenAIClient.responses, openai.responses);
+        }
+        // Wrap responses.create method
+        if (tracedOpenAIClient.responses &&
+            typeof tracedOpenAIClient.responses.create === "function") {
+            tracedOpenAIClient.responses.create = (0, traceable_js_1.traceable)(openai.responses.create.bind(openai.responses), {
+                name: "ChatOpenAI",
+                run_type: "llm",
+                aggregator: responsesAggregator,
+                argsConfigPath: [1, "langsmithExtra"],
+                getInvocationParams: (payload) => {
+                    if (typeof payload !== "object" || payload == null)
+                        return undefined;
+                    // Handle responses API parameters
+                    const params = payload;
+                    return {
+                        ls_provider: "openai",
+                        ls_model_type: "llm",
+                        ls_model_name: params.model || "unknown",
+                    };
+                },
+                processOutputs: processChatCompletion,
+                ...options,
+            });
+        }
+    }
     return tracedOpenAIClient;
 };
 exports.wrapOpenAI = wrapOpenAI;

package/dist/wrappers/openai.d.ts

@@ -1,22 +1,21 @@
 import { OpenAI } from "openai";
-import type { APIPromise } from "openai/core";
+import type { APIPromise } from "openai";
 import type { RunTreeConfig } from "../index.js";
 type OpenAIType = {
-    beta?: {
-        chat?: {
-            completions?: {
-                parse?: (...args: any[]) => any;
-            };
-        };
-    };
+    beta?: any;
     chat: {
         completions: {
             create: (...args: any[]) => any;
+            parse: (...args: any[]) => any;
         };
     };
     completions: {
         create: (...args: any[]) => any;
     };
+    responses?: {
+        create: (...args: any[]) => any;
+        retrieve: (...args: any[]) => any;
+    };
 };
 type ExtraRunTreeConfig = Pick<Partial<RunTreeConfig>, "name" | "metadata" | "tags">;
 type PatchedOpenAIClient<T extends OpenAIType> = T & {

package/dist/wrappers/openai.js

@@ -1,4 +1,4 @@
-import { isTraceableFunction, traceable } from "../traceable.js";
+import { isTraceableFunction, traceable, } from "../traceable.js";
 function _combineChatCompletionChoices(choices
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
@@ -90,6 +90,19 @@ const chatAggregator = (chunks) => {
     aggregatedOutput.choices = Object.values(choicesByIndex).map((choices) => _combineChatCompletionChoices(choices));
     return aggregatedOutput;
 };
+const responsesAggregator = (events) => {
+    if (!events || events.length === 0) {
+        return {};
+    }
+    // Find the response.completed event which contains the final response
+    for (const event of events) {
+        if (event.type === "response.completed" && event.response) {
+            return event.response;
+        }
+    }
+    // If no completed event found, return the last event
+    return events[events.length - 1] || {};
+};
 const textAggregator = (allChunks
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) => {
@@ -184,74 +197,50 @@ export const wrapOpenAI = (openai, options) => {
     // 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,
-                    }),
-                },
-            },
-        };
+    const chatCompletionParseMetadata = {
+        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_completion_tokens ?? params.max_tokens ?? undefined,
+                ls_temperature: params.temperature ?? undefined,
+                ls_stop,
+            };
+        },
+        processOutputs: processChatCompletion,
+        ...options,
+    };
+    if (openai.beta) {
+        tracedOpenAIClient.beta = openai.beta;
+        if (openai.beta.chat &&
+            openai.beta.chat.completions &&
+            typeof openai.beta.chat.completions.parse === "function") {
+            tracedOpenAIClient.beta.chat.completions.parse = traceable(openai.beta.chat.completions.parse.bind(openai.beta.chat.completions), chatCompletionParseMetadata);
+        }
     }
     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,
-                    };
-                },
-                processOutputs: processChatCompletion,
-                ...options,
-            }),
-        },
+        completions: Object.create(Object.getPrototypeOf(openai.chat.completions)),
     };
+    // Copy all own properties and then wrap specific methods
+    Object.assign(tracedOpenAIClient.chat.completions, openai.chat.completions);
+    // Wrap chat.completions.create
+    tracedOpenAIClient.chat.completions.create = traceable(openai.chat.completions.create.bind(openai.chat.completions), chatCompletionParseMetadata);
+    // Wrap chat.completions.parse if it exists
+    if (typeof openai.chat.completions.parse === "function") {
+        tracedOpenAIClient.chat.completions.parse = traceable(openai.chat.completions.parse.bind(openai.chat.completions), chatCompletionParseMetadata);
+    }
     tracedOpenAIClient.completions = {
         ...openai.completions,
         create: traceable(openai.completions.create.bind(openai.completions), {
@@ -278,5 +267,37 @@ export const wrapOpenAI = (openai, options) => {
             ...options,
         }),
     };
+    // Add responses API support if it exists
+    if (openai.responses) {
+        // Create a new object with the same prototype to preserve all methods
+        tracedOpenAIClient.responses = Object.create(Object.getPrototypeOf(openai.responses));
+        // Copy all own properties
+        if (tracedOpenAIClient.responses) {
+            Object.assign(tracedOpenAIClient.responses, openai.responses);
+        }
+        // Wrap responses.create method
+        if (tracedOpenAIClient.responses &&
+            typeof tracedOpenAIClient.responses.create === "function") {
+            tracedOpenAIClient.responses.create = traceable(openai.responses.create.bind(openai.responses), {
+                name: "ChatOpenAI",
+                run_type: "llm",
+                aggregator: responsesAggregator,
+                argsConfigPath: [1, "langsmithExtra"],
+                getInvocationParams: (payload) => {
+                    if (typeof payload !== "object" || payload == null)
+                        return undefined;
+                    // Handle responses API parameters
+                    const params = payload;
+                    return {
+                        ls_provider: "openai",
+                        ls_model_type: "llm",
+                        ls_model_name: params.model || "unknown",
+                    };
+                },
+                processOutputs: processChatCompletion,
+                ...options,
+            });
+        }
+    }
     return tracedOpenAIClient;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.3.37",
+  "version": "0.3.38",
   "description": "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform.",
   "packageManager": "yarn@1.22.19",
   "files": [
@@ -145,9 +145,9 @@
     "@faker-js/faker": "^8.4.1",
     "@jest/globals": "^29.5.0",
     "@jest/reporters": "^29.7.0",
-    "@langchain/core": "^0.3.14",
-    "@langchain/langgraph": "^0.2.20",
-    "@langchain/openai": "^0.3.11",
+    "@langchain/core": "^0.3.61",
+    "@langchain/langgraph": "^0.3.6",
+    "@langchain/openai": "^0.5.16",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-node": "^0.58.0",
     "@opentelemetry/sdk-node": "^0.200.0",
@@ -155,6 +155,7 @@
     "@opentelemetry/sdk-trace-node": "^2.0.0",
     "@tsconfig/recommended": "^1.0.2",
     "@types/jest": "^29.5.1",
+    "@types/node-fetch": "^2.6.12",
     "@typescript-eslint/eslint-plugin": "^5.59.8",
     "@typescript-eslint/parser": "^5.59.8",
     "ai": "^4.3.10",
@@ -167,9 +168,9 @@
     "eslint-plugin-no-instanceof": "^1.0.1",
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
-    "langchain": "^0.3.3",
+    "langchain": "^0.3.29",
     "node-fetch": "^2.7.0",
-    "openai": "^4.67.3",
+    "openai": "^5.8.2",
     "prettier": "^2.8.8",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
@@ -180,10 +181,10 @@
     "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "openai": "*",
     "@opentelemetry/api": "*",
     "@opentelemetry/exporter-trace-otlp-proto": "*",
-    "@opentelemetry/sdk-trace-base": "*"
+    "@opentelemetry/sdk-trace-base": "*",
+    "openai": "*"
   },
   "peerDependenciesMeta": {
     "openai": {