langsmith 0.3.36 → 0.3.38

package/dist/experimental/otel/exporter.cjs

@@ -70,10 +70,10 @@ function parseHeadersString(headersStr) {
  */
 class LangSmithOTLPTraceExporter extends exporter_trace_otlp_proto_1.OTLPTraceExporter {
     constructor(config) {
-        const lsEndpoint = (0, env_js_2.getEnvironmentVariable)("OTEL_EXPORTER_OTLP_ENDPOINT") ||
+        const defaultLsEndpoint = (0, env_js_2.getEnvironmentVariable)("OTEL_EXPORTER_OTLP_ENDPOINT") ||
             (0, env_js_2.getLangSmithEnvironmentVariable)("ENDPOINT") ||
             "https://api.smith.langchain.com";
-        const defaultBaseUrl = lsEndpoint.replace(/\/$/, "");
+        const defaultBaseUrl = defaultLsEndpoint.replace(/\/$/, "");
         const defaultUrl = `${defaultBaseUrl}/otel/v1/traces`;
         // Configure headers with API key and project if available
         let defaultHeaderString = (0, env_js_2.getEnvironmentVariable)("OTEL_EXPORTER_OTLP_HEADERS") ?? "";
@@ -92,82 +92,100 @@ class LangSmithOTLPTraceExporter extends exporter_trace_otlp_proto_1.OTLPTraceEx
             headers: parseHeadersString(defaultHeaderString),
             ...config,
         });
+        Object.defineProperty(this, "transformExportedSpan", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transformExportedSpan = config?.transformExportedSpan;
     }
     export(spans, resultCallback) {
         if (!(0, env_js_1.isTracingEnabled)()) {
             return resultCallback({ code: 0 });
         }
-        for (const span of spans) {
-            if (!span.attributes[constants.GENAI_PROMPT]) {
-                if (span.attributes["ai.prompt"]) {
-                    span.attributes[constants.GENAI_PROMPT] =
-                        span.attributes["ai.prompt"];
+        const runExport = async () => {
+            for (let span of spans) {
+                if (this.transformExportedSpan) {
+                    span = await this.transformExportedSpan(span);
                 }
-                if (span.attributes["ai.prompt.messages"] &&
-                    typeof span.attributes["ai.prompt.messages"] === "string") {
-                    let messages;
-                    try {
-                        messages = JSON.parse(span.attributes["ai.prompt.messages"]);
+                if (!span.attributes[constants.GENAI_PROMPT]) {
+                    if (span.attributes["ai.prompt"]) {
+                        span.attributes[constants.GENAI_PROMPT] =
+                            span.attributes["ai.prompt"];
                     }
-                    catch (e) {
-                        console.error("Failed to parse ai.prompt.messages", e);
+                    if (span.attributes["ai.prompt.messages"] &&
+                        typeof span.attributes["ai.prompt.messages"] === "string") {
+                        let messages;
+                        try {
+                            messages = JSON.parse(span.attributes["ai.prompt.messages"]);
+                        }
+                        catch (e) {
+                            console.error("Failed to parse ai.prompt.messages", e);
+                        }
+                        if (messages && Array.isArray(messages)) {
+                            span.attributes[constants.GENAI_PROMPT] = JSON.stringify({
+                                input: messages,
+                            });
+                        }
                     }
-                    if (messages && Array.isArray(messages)) {
-                        span.attributes[constants.GENAI_PROMPT] = JSON.stringify({
-                            input: messages,
-                        });
+                    if (span.attributes["ai.toolCall.args"]) {
+                        span.attributes[constants.GENAI_PROMPT] =
+                            span.attributes["ai.toolCall.args"];
                     }
                 }
-                if (span.attributes["ai.toolCall.args"]) {
-                    span.attributes[constants.GENAI_PROMPT] =
-                        span.attributes["ai.toolCall.args"];
-                }
-            }
-            // Iterate over all attributes starting with "ai.telemetry.metadata"
-            for (const [key, value] of Object.entries(span.attributes)) {
-                if (key.startsWith("ai.telemetry.metadata.")) {
-                    const metadataKey = key.replace("ai.telemetry.metadata.", "");
-                    span.attributes[`${constants.LANGSMITH_METADATA}.${metadataKey}`] =
-                        value;
-                    delete span.attributes[key];
-                }
-            }
-            if (!span.attributes[constants.GENAI_COMPLETION]) {
-                if (span.attributes["ai.response.text"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.text"];
-                }
-                if (span.attributes["ai.response.choices"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.choices"];
+                // Iterate over all attributes starting with "ai.telemetry.metadata"
+                for (const [key, value] of Object.entries(span.attributes)) {
+                    if (key.startsWith("ai.telemetry.metadata.")) {
+                        const metadataKey = key.replace("ai.telemetry.metadata.", "");
+                        span.attributes[`${constants.LANGSMITH_METADATA}.${metadataKey}`] =
+                            value;
+                        delete span.attributes[key];
+                    }
                 }
-                if (span.attributes["ai.response.object"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.object"];
+                if (!span.attributes[constants.GENAI_COMPLETION]) {
+                    if (span.attributes["ai.response.text"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.text"];
+                    }
+                    if (span.attributes["ai.response.choices"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.choices"];
+                    }
+                    if (span.attributes["ai.response.object"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.object"];
+                    }
+                    if (span.attributes["ai.response.toolCalls"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.toolCalls"];
+                    }
+                    if (span.attributes["ai.toolCall.result"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.toolCall.result"];
+                    }
                 }
-                if (span.attributes["ai.response.toolCalls"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.toolCalls"];
+                if (typeof span.attributes["ai.operationId"] === "string" &&
+                    constants.AI_SDK_LLM_OPERATIONS.includes(span.attributes["ai.operationId"])) {
+                    span.attributes[constants.LANGSMITH_RUN_TYPE] = "llm";
                 }
-                if (span.attributes["ai.toolCall.result"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.toolCall.result"];
+                else if (typeof span.attributes["ai.operationId"] === "string" &&
+                    constants.AI_SDK_TOOL_OPERATIONS.includes(span.attributes["ai.operationId"])) {
+                    span.attributes[constants.LANGSMITH_RUN_TYPE] = "tool";
+                    if (span.attributes["ai.toolCall.name"]) {
+                        span.attributes[constants.LANGSMITH_NAME] =
+                            span.attributes["ai.toolCall.name"];
+                    }
                 }
-            }
-            if (typeof span.attributes["ai.operationId"] === "string" &&
-                constants.AI_SDK_LLM_OPERATIONS.includes(span.attributes["ai.operationId"])) {
-                span.attributes[constants.LANGSMITH_RUN_TYPE] = "llm";
-            }
-            else if (typeof span.attributes["ai.operationId"] === "string" &&
-                constants.AI_SDK_TOOL_OPERATIONS.includes(span.attributes["ai.operationId"])) {
-                span.attributes[constants.LANGSMITH_RUN_TYPE] = "tool";
-                if (span.attributes["ai.toolCall.name"]) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    span.name = span.attributes["ai.toolCall.name"];
+                if (span.attributes[`${constants.LANGSMITH_METADATA}.ls_run_name`]) {
+                    span.attributes[constants.LANGSMITH_NAME] =
+                        span.attributes[`${constants.LANGSMITH_METADATA}.ls_run_name`];
+                    delete span.attributes[`${constants.LANGSMITH_METADATA}.ls_run_name`];
                 }
             }
-        }
-        super.export(spans, resultCallback);
+            super.export(spans, resultCallback);
+        };
+        void runExport();
     }
 }
 exports.LangSmithOTLPTraceExporter = LangSmithOTLPTraceExporter;

package/dist/experimental/otel/exporter.d.ts

@@ -1,5 +1,30 @@
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
+export type LangSmithOTLPTraceExporterConfig = ConstructorParameters<typeof OTLPTraceExporter>[0] & {
+    /**
+     * A function that takes an exported span and returns a transformed version of it.
+     * May be used to add or remove attributes from the span.
+     *
+     * For example, to add a custom attribute to the span, you can do:
+     *
+     * ```ts
+     * import { LangSmithOTLPTraceExporter } from "langsmith/experimental/otel/exporter";
+     *
+     * const exporter = new LangSmithOTLPTraceExporter({
+     *   transformExportedSpan: (span) => {
+     *     if (span.name === "foo") {
+     *       span.attributes["langsmith.metadata.bar"] = "baz";
+     *     }
+     *     return span;
+     *   }
+     * });
+     * ```
+     *
+     * @param span - The span to transform.
+     * @returns A transformed version of the span.
+     */
+    transformExportedSpan?: (span: ReadableSpan) => ReadableSpan | Promise<ReadableSpan>;
+};
 /**
  * LangSmith OpenTelemetry trace exporter that extends the standard OTLP trace exporter
  * with LangSmith-specific configuration and span attribute transformations.
@@ -16,6 +41,7 @@ import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
  *                 Any provided config will override these defaults.
  */
 export declare class LangSmithOTLPTraceExporter extends OTLPTraceExporter {
-    constructor(config?: ConstructorParameters<typeof OTLPTraceExporter>[0]);
+    private transformExportedSpan?;
+    constructor(config?: LangSmithOTLPTraceExporterConfig);
     export(spans: ReadableSpan[], resultCallback: Parameters<OTLPTraceExporter["export"]>[1]): void;
 }

package/dist/experimental/otel/exporter.js

@@ -34,10 +34,10 @@ function parseHeadersString(headersStr) {
  */
 export class LangSmithOTLPTraceExporter extends OTLPTraceExporter {
     constructor(config) {
-        const lsEndpoint = getEnvironmentVariable("OTEL_EXPORTER_OTLP_ENDPOINT") ||
+        const defaultLsEndpoint = getEnvironmentVariable("OTEL_EXPORTER_OTLP_ENDPOINT") ||
             getLangSmithEnvironmentVariable("ENDPOINT") ||
             "https://api.smith.langchain.com";
-        const defaultBaseUrl = lsEndpoint.replace(/\/$/, "");
+        const defaultBaseUrl = defaultLsEndpoint.replace(/\/$/, "");
         const defaultUrl = `${defaultBaseUrl}/otel/v1/traces`;
         // Configure headers with API key and project if available
         let defaultHeaderString = getEnvironmentVariable("OTEL_EXPORTER_OTLP_HEADERS") ?? "";
@@ -56,81 +56,99 @@ export class LangSmithOTLPTraceExporter extends OTLPTraceExporter {
             headers: parseHeadersString(defaultHeaderString),
             ...config,
         });
+        Object.defineProperty(this, "transformExportedSpan", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transformExportedSpan = config?.transformExportedSpan;
     }
     export(spans, resultCallback) {
         if (!isTracingEnabled()) {
             return resultCallback({ code: 0 });
         }
-        for (const span of spans) {
-            if (!span.attributes[constants.GENAI_PROMPT]) {
-                if (span.attributes["ai.prompt"]) {
-                    span.attributes[constants.GENAI_PROMPT] =
-                        span.attributes["ai.prompt"];
+        const runExport = async () => {
+            for (let span of spans) {
+                if (this.transformExportedSpan) {
+                    span = await this.transformExportedSpan(span);
                 }
-                if (span.attributes["ai.prompt.messages"] &&
-                    typeof span.attributes["ai.prompt.messages"] === "string") {
-                    let messages;
-                    try {
-                        messages = JSON.parse(span.attributes["ai.prompt.messages"]);
+                if (!span.attributes[constants.GENAI_PROMPT]) {
+                    if (span.attributes["ai.prompt"]) {
+                        span.attributes[constants.GENAI_PROMPT] =
+                            span.attributes["ai.prompt"];
                     }
-                    catch (e) {
-                        console.error("Failed to parse ai.prompt.messages", e);
+                    if (span.attributes["ai.prompt.messages"] &&
+                        typeof span.attributes["ai.prompt.messages"] === "string") {
+                        let messages;
+                        try {
+                            messages = JSON.parse(span.attributes["ai.prompt.messages"]);
+                        }
+                        catch (e) {
+                            console.error("Failed to parse ai.prompt.messages", e);
+                        }
+                        if (messages && Array.isArray(messages)) {
+                            span.attributes[constants.GENAI_PROMPT] = JSON.stringify({
+                                input: messages,
+                            });
+                        }
                     }
-                    if (messages && Array.isArray(messages)) {
-                        span.attributes[constants.GENAI_PROMPT] = JSON.stringify({
-                            input: messages,
-                        });
+                    if (span.attributes["ai.toolCall.args"]) {
+                        span.attributes[constants.GENAI_PROMPT] =
+                            span.attributes["ai.toolCall.args"];
                     }
                 }
-                if (span.attributes["ai.toolCall.args"]) {
-                    span.attributes[constants.GENAI_PROMPT] =
-                        span.attributes["ai.toolCall.args"];
-                }
-            }
-            // Iterate over all attributes starting with "ai.telemetry.metadata"
-            for (const [key, value] of Object.entries(span.attributes)) {
-                if (key.startsWith("ai.telemetry.metadata.")) {
-                    const metadataKey = key.replace("ai.telemetry.metadata.", "");
-                    span.attributes[`${constants.LANGSMITH_METADATA}.${metadataKey}`] =
-                        value;
-                    delete span.attributes[key];
-                }
-            }
-            if (!span.attributes[constants.GENAI_COMPLETION]) {
-                if (span.attributes["ai.response.text"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.text"];
-                }
-                if (span.attributes["ai.response.choices"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.choices"];
+                // Iterate over all attributes starting with "ai.telemetry.metadata"
+                for (const [key, value] of Object.entries(span.attributes)) {
+                    if (key.startsWith("ai.telemetry.metadata.")) {
+                        const metadataKey = key.replace("ai.telemetry.metadata.", "");
+                        span.attributes[`${constants.LANGSMITH_METADATA}.${metadataKey}`] =
+                            value;
+                        delete span.attributes[key];
+                    }
                 }
-                if (span.attributes["ai.response.object"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.object"];
+                if (!span.attributes[constants.GENAI_COMPLETION]) {
+                    if (span.attributes["ai.response.text"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.text"];
+                    }
+                    if (span.attributes["ai.response.choices"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.choices"];
+                    }
+                    if (span.attributes["ai.response.object"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.object"];
+                    }
+                    if (span.attributes["ai.response.toolCalls"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.response.toolCalls"];
+                    }
+                    if (span.attributes["ai.toolCall.result"]) {
+                        span.attributes[constants.GENAI_COMPLETION] =
+                            span.attributes["ai.toolCall.result"];
+                    }
                 }
-                if (span.attributes["ai.response.toolCalls"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.response.toolCalls"];
+                if (typeof span.attributes["ai.operationId"] === "string" &&
+                    constants.AI_SDK_LLM_OPERATIONS.includes(span.attributes["ai.operationId"])) {
+                    span.attributes[constants.LANGSMITH_RUN_TYPE] = "llm";
                 }
-                if (span.attributes["ai.toolCall.result"]) {
-                    span.attributes[constants.GENAI_COMPLETION] =
-                        span.attributes["ai.toolCall.result"];
+                else if (typeof span.attributes["ai.operationId"] === "string" &&
+                    constants.AI_SDK_TOOL_OPERATIONS.includes(span.attributes["ai.operationId"])) {
+                    span.attributes[constants.LANGSMITH_RUN_TYPE] = "tool";
+                    if (span.attributes["ai.toolCall.name"]) {
+                        span.attributes[constants.LANGSMITH_NAME] =
+                            span.attributes["ai.toolCall.name"];
+                    }
                 }
-            }
-            if (typeof span.attributes["ai.operationId"] === "string" &&
-                constants.AI_SDK_LLM_OPERATIONS.includes(span.attributes["ai.operationId"])) {
-                span.attributes[constants.LANGSMITH_RUN_TYPE] = "llm";
-            }
-            else if (typeof span.attributes["ai.operationId"] === "string" &&
-                constants.AI_SDK_TOOL_OPERATIONS.includes(span.attributes["ai.operationId"])) {
-                span.attributes[constants.LANGSMITH_RUN_TYPE] = "tool";
-                if (span.attributes["ai.toolCall.name"]) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    span.name = span.attributes["ai.toolCall.name"];
+                if (span.attributes[`${constants.LANGSMITH_METADATA}.ls_run_name`]) {
+                    span.attributes[constants.LANGSMITH_NAME] =
+                        span.attributes[`${constants.LANGSMITH_METADATA}.ls_run_name`];
+                    delete span.attributes[`${constants.LANGSMITH_METADATA}.ls_run_name`];
                 }
             }
-        }
-        super.export(spans, resultCallback);
+            super.export(spans, resultCallback);
+        };
+        void runExport();
     }
 }

package/dist/experimental/otel/setup.cjs

@@ -40,7 +40,8 @@ const otel_js_1 = require("../../singletons/otel.cjs");
  * initializeOTEL({ globalTracerProvider: customProvider });
  * ```
  */
-const initializeOTEL = ({ globalTracerProvider, globalContextManager, } = {}) => {
+const initializeOTEL = (config = {}) => {
+    const { globalTracerProvider, globalContextManager, exporterConfig } = config;
     const otel = {
         trace: api_1.trace,
         context: api_1.context,
@@ -51,7 +52,7 @@ const initializeOTEL = ({ globalTracerProvider, globalContextManager, } = {}) =>
         contextManager.enable();
         api_1.context.setGlobalContextManager(contextManager);
     }
-    const DEFAULT_LANGSMITH_SPAN_EXPORTER = new exporter_js_1.LangSmithOTLPTraceExporter({});
+    const DEFAULT_LANGSMITH_SPAN_EXPORTER = new exporter_js_1.LangSmithOTLPTraceExporter(exporterConfig);
     const DEFAULT_LANGSMITH_SPAN_PROCESSOR = new sdk_trace_base_1.BatchSpanProcessor(DEFAULT_LANGSMITH_SPAN_EXPORTER);
     if (!globalTracerProvider) {
         const DEFAULT_LANGSMITH_TRACER_PROVIDER = new sdk_trace_base_1.BasicTracerProvider({

package/dist/experimental/otel/setup.d.ts

@@ -1,6 +1,25 @@
 import { type TracerProvider, type ContextManager } from "@opentelemetry/api";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { LangSmithOTLPTraceExporter } from "./exporter.js";
+import { LangSmithOTLPTraceExporter, LangSmithOTLPTraceExporterConfig } from "./exporter.js";
+/**
+ * Configuration options for initializing OpenTelemetry with LangSmith.
+ */
+export type InitializeOTELConfig = {
+    /**
+     * Optional custom OTEL TracerProvider to use instead of
+     * creating and globally setting a new one.
+     */
+    globalTracerProvider?: TracerProvider;
+    /**
+     * Optional custom OTEL ContextManager to use instead of
+     * creating and globally setting a new one with AsyncHooksContextManager.
+     */
+    globalContextManager?: ContextManager;
+    /**
+     * Optional configuration passed to the default LangSmith OTLP trace exporter.
+     */
+    exporterConfig?: LangSmithOTLPTraceExporterConfig;
+};
 /**
  * Initializes OpenTelemetry with LangSmith-specific configuration for tracing.
  *
@@ -32,10 +51,7 @@ import { LangSmithOTLPTraceExporter } from "./exporter.js";
  * initializeOTEL({ globalTracerProvider: customProvider });
  * ```
  */
-export declare const initializeOTEL: ({ globalTracerProvider, globalContextManager, }?: {
-    globalTracerProvider?: TracerProvider;
-    globalContextManager?: ContextManager;
-}) => {
+export declare const initializeOTEL: (config?: InitializeOTELConfig) => {
     DEFAULT_LANGSMITH_TRACER_PROVIDER: TracerProvider;
     DEFAULT_LANGSMITH_SPAN_PROCESSOR: BatchSpanProcessor;
     DEFAULT_LANGSMITH_SPAN_EXPORTER: LangSmithOTLPTraceExporter;

package/dist/experimental/otel/setup.js

@@ -4,7 +4,7 @@
 import { AsyncHooksContextManager } from "@opentelemetry/context-async-hooks";
 import { trace as otel_trace, context as otel_context, } from "@opentelemetry/api";
 import { BatchSpanProcessor, BasicTracerProvider, } from "@opentelemetry/sdk-trace-base";
-import { LangSmithOTLPTraceExporter } from "./exporter.js";
+import { LangSmithOTLPTraceExporter, } from "./exporter.js";
 import { setDefaultOTLPTracerComponents, setOTELInstances, } from "../../singletons/otel.js";
 /**
  * Initializes OpenTelemetry with LangSmith-specific configuration for tracing.
@@ -37,7 +37,8 @@ import { setDefaultOTLPTracerComponents, setOTELInstances, } from "../../singlet
  * initializeOTEL({ globalTracerProvider: customProvider });
  * ```
  */
-export const initializeOTEL = ({ globalTracerProvider, globalContextManager, } = {}) => {
+export const initializeOTEL = (config = {}) => {
+    const { globalTracerProvider, globalContextManager, exporterConfig } = config;
     const otel = {
         trace: otel_trace,
         context: otel_context,
@@ -48,7 +49,7 @@ export const initializeOTEL = ({ globalTracerProvider, globalContextManager, } =
         contextManager.enable();
         otel_context.setGlobalContextManager(contextManager);
     }
-    const DEFAULT_LANGSMITH_SPAN_EXPORTER = new LangSmithOTLPTraceExporter({});
+    const DEFAULT_LANGSMITH_SPAN_EXPORTER = new LangSmithOTLPTraceExporter(exporterConfig);
     const DEFAULT_LANGSMITH_SPAN_PROCESSOR = new BatchSpanProcessor(DEFAULT_LANGSMITH_SPAN_EXPORTER);
     if (!globalTracerProvider) {
         const DEFAULT_LANGSMITH_TRACER_PROVIDER = new BasicTracerProvider({

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.36";
+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.36";
+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.36";
+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.36",
+  "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": {