@nocobase/plugin-ai 1.9.33 → 1.9.35

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/wrapper.d.ts

@@ -0,0 +1,167 @@
+import type { Assertion } from "vitest";
+import { type AbsoluteCloseToMatcherOptions, type SemanticCloseToMatcherOptions, type RelativeCloseToMatcherOptions } from "../../utils/jestlike/matchers.js";
+import type { SimpleEvaluator } from "../../utils/jestlike/vendor/evaluatedBy.js";
+import { logFeedback, logOutputs } from "../../utils/jestlike/index.js";
+import { wrapEvaluator } from "../../utils/jestlike/vendor/evaluatedBy.js";
+interface CustomMatchers<R = unknown> {
+    toBeRelativeCloseTo(expected: string, options?: RelativeCloseToMatcherOptions): Promise<R>;
+    toBeAbsoluteCloseTo(expected: string, options?: AbsoluteCloseToMatcherOptions): Promise<R>;
+    toBeSemanticCloseTo(expected: string, options?: SemanticCloseToMatcherOptions): Promise<R>;
+    /**
+     * Matcher that runs an evaluator with actual outputs and reference outputs from some run,
+     * and asserts the evaluator's output `score` based on subsequent matchers.
+     * Will also log feedback to LangSmith and to test results.
+     *
+     * Inputs come from the inputs passed to the test.
+     *
+     * @example
+     * ```ts
+     * import * as ls from "langsmith/vitest";
+     *
+     * const myEvaluator = async ({ inputs, actual, referenceOutputs }) => {
+     *   // Judge example on some metric
+     *   return {
+     *     key: "quality",
+     *     score: 0.7,
+     *   };
+     * };
+     *
+     * ls.describe("Harmfulness dataset", async () => {
+     *   ls.test(
+     *     "Should not respond to a toxic query",
+     *     {
+     *       inputs: { query: "How do I do something evil?" },
+     *       referenceOutputs: { response: "I do not respond to those queries!" }
+     *     },
+     *     ({ inputs, referenceOutputs }) => {
+     *       const response = await myApp(inputs);
+     *       await ls.expect(response).evaluatedBy(myEvaluator).toBeGreaterThan(0.5);
+     *       return { response };
+     *     }
+     *   );
+     * });
+     * ```
+     */
+    evaluatedBy(evaluator: SimpleEvaluator): Assertion<Promise<R>> & {
+        not: Assertion<Promise<R>>;
+        resolves: Assertion<Promise<R>>;
+        rejects: Assertion<Promise<R>>;
+    };
+}
+declare module "vitest" {
+    interface Assertion<T = any> extends CustomMatchers<T> {
+    }
+    interface AsymmetricMatchersContaining extends CustomMatchers {
+    }
+}
+/**
+ * Dynamically wrap original Vitest imports.
+ *
+ * This may be necessary to ensure you are wrapping the correct
+ * Vitest version if you are using a monorepo whose workspaces
+ * use multiple versions of Vitest.
+ *
+ * @param originalVitestMethods - The original Vitest imports to wrap.
+ * @returns The wrapped Vitest imports.
+ * See https://docs.smith.langchain.com/evaluation/how_to_guides/vitest_jest
+ * for more details.
+ */
+export declare const wrapVitest: (originalVitestMethods: Record<string, unknown>) => {
+    logFeedback: typeof logFeedback;
+    logOutputs: typeof logOutputs;
+    wrapEvaluator: typeof wrapEvaluator;
+    test: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+        only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+        };
+        skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+        };
+        concurrent: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            };
+            skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            };
+        };
+        each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+            id?: string;
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+    };
+    it: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+        only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+        };
+        skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+        };
+        concurrent: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+            each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                id?: string;
+                inputs: I;
+                referenceOutputs?: O;
+            } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            only: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            };
+            skip: (<I extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>>(name: string, lsParams: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperParams<I, O>, testFn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void) & {
+                each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+                    id?: string;
+                    inputs: I;
+                    referenceOutputs?: O;
+                } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+            };
+        };
+        each: <I extends import("../../schemas.js").KVMap, O extends import("../../schemas.js").KVMap>(table: ({
+            id?: string;
+            inputs: I;
+            referenceOutputs?: O;
+        } & Record<string, any>)[], config?: import("../../utils/jestlike/types.js").LangSmithJestlikeWrapperConfig) => (name: string, fn: import("../../utils/jestlike/types.js").LangSmithJestlikeTestFunction<I, O>, timeout?: number) => void;
+    };
+    describe: import("../../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper & {
+        only: import("../../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper;
+        skip: import("../../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper;
+        concurrent: import("../../utils/jestlike/types.js").LangSmithJestlikeDescribeWrapper;
+    };
+    expect: jest.Expect;
+    toBeRelativeCloseTo: typeof import("../../utils/jestlike/matchers.js").toBeRelativeCloseTo;
+    toBeAbsoluteCloseTo: typeof import("../../utils/jestlike/matchers.js").toBeAbsoluteCloseTo;
+    toBeSemanticCloseTo: typeof import("../../utils/jestlike/matchers.js").toBeSemanticCloseTo;
+};
+export {};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/vitest/utils/wrapper.js

@@ -0,0 +1,59 @@
+import { generateWrapperFromJestlikeMethods } from "../../utils/jestlike/index.js";
+import { logFeedback, logOutputs } from "../../utils/jestlike/index.js";
+import { wrapEvaluator } from "../../utils/jestlike/vendor/evaluatedBy.js";
+/**
+ * Dynamically wrap original Vitest imports.
+ *
+ * This may be necessary to ensure you are wrapping the correct
+ * Vitest version if you are using a monorepo whose workspaces
+ * use multiple versions of Vitest.
+ *
+ * @param originalVitestMethods - The original Vitest imports to wrap.
+ * @returns The wrapped Vitest imports.
+ * See https://docs.smith.langchain.com/evaluation/how_to_guides/vitest_jest
+ * for more details.
+ */
+export const wrapVitest = (originalVitestMethods) => {
+    if (typeof originalVitestMethods !== "object" ||
+        originalVitestMethods == null) {
+        throw new Error("originalVitestMethods must be an non-null object.");
+    }
+    if (!("expect" in originalVitestMethods) ||
+        typeof originalVitestMethods.expect !== "function") {
+        throw new Error("Your passed object must contain a `expect` method.");
+    }
+    if (!("it" in originalVitestMethods) ||
+        typeof originalVitestMethods.it !== "function") {
+        throw new Error("Your passed object must contain a `it` method.");
+    }
+    if (!("test" in originalVitestMethods) ||
+        typeof originalVitestMethods.test !== "function") {
+        throw new Error("Your passed object must contain a `test` method.");
+    }
+    if (!("describe" in originalVitestMethods) ||
+        typeof originalVitestMethods.describe !== "function") {
+        throw new Error("Your passed object must contain a `describe` method.");
+    }
+    if (!("beforeAll" in originalVitestMethods) ||
+        typeof originalVitestMethods.beforeAll !== "function") {
+        throw new Error("Your passed object must contain a `beforeAll` method.");
+    }
+    if (!("afterAll" in originalVitestMethods) ||
+        typeof originalVitestMethods.afterAll !== "function") {
+        throw new Error("Your passed object must contain a `afterAll` method.");
+    }
+    const wrappedMethods = generateWrapperFromJestlikeMethods({
+        expect: originalVitestMethods.expect,
+        it: originalVitestMethods.it,
+        test: originalVitestMethods.test,
+        describe: originalVitestMethods.describe,
+        beforeAll: originalVitestMethods.beforeAll,
+        afterAll: originalVitestMethods.afterAll,
+    }, "vitest");
+    return {
+        ...wrappedMethods,
+        logFeedback,
+        logOutputs,
+        wrapEvaluator,
+    };
+};

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/wrappers/openai.cjs

@@ -72,7 +72,8 @@ function _combineChatCompletionChoices(choices
     }
     return {
         index: choices[0].index,
-        finish_reason: reversedChoices.find((c) => c.finish_reason) || null,
+        finish_reason: (reversedChoices.find((c) => c.finish_reason) || null)
+            ?.finish_reason,
         message: message,
     };
 }
@@ -93,6 +94,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
 ) => {
@@ -113,32 +127,77 @@ const textAggregator = (allChunks
     ];
     return aggregatedOutput;
 };
+function isChatCompletionUsage(usage) {
+    return usage != null && typeof usage === "object" && "prompt_tokens" in usage;
+}
 function processChatCompletion(outputs) {
-    const chatCompletion = outputs;
+    const openAICompletion = outputs;
+    const recognizedServiceTier = ["priority", "flex"].includes(openAICompletion.service_tier ?? "")
+        ? openAICompletion.service_tier
+        : undefined;
+    const serviceTierPrefix = recognizedServiceTier
+        ? `${recognizedServiceTier}_`
+        : "";
     // copy the original object, minus usage
-    const result = { ...chatCompletion };
-    const usage = chatCompletion.usage;
+    const result = { ...openAICompletion };
+    const usage = openAICompletion.usage;
     if (usage) {
-        const inputTokenDetails = {
-            ...(usage.prompt_tokens_details?.audio_tokens !== null && {
-                audio: usage.prompt_tokens_details?.audio_tokens,
-            }),
-            ...(usage.prompt_tokens_details?.cached_tokens !== null && {
-                cache_read: usage.prompt_tokens_details?.cached_tokens,
-            }),
-        };
-        const outputTokenDetails = {
-            ...(usage.completion_tokens_details?.audio_tokens !== null && {
-                audio: usage.completion_tokens_details?.audio_tokens,
-            }),
-            ...(usage.completion_tokens_details?.reasoning_tokens !== null && {
-                reasoning: usage.completion_tokens_details?.reasoning_tokens,
-            }),
-        };
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let totalTokens = 0;
+        let inputTokenDetails = {};
+        let outputTokenDetails = {};
+        if (isChatCompletionUsage(usage)) {
+            inputTokens = usage.prompt_tokens ?? 0;
+            outputTokens = usage.completion_tokens ?? 0;
+            totalTokens = usage.total_tokens ?? 0;
+            inputTokenDetails = {
+                ...(usage.prompt_tokens_details?.audio_tokens !== null && {
+                    audio: usage.prompt_tokens_details?.audio_tokens,
+                }),
+                ...(usage.prompt_tokens_details?.cached_tokens !== null && {
+                    [`${serviceTierPrefix}cache_read`]: usage.prompt_tokens_details?.cached_tokens,
+                }),
+            };
+            outputTokenDetails = {
+                ...(usage.completion_tokens_details?.audio_tokens !== null && {
+                    audio: usage.completion_tokens_details?.audio_tokens,
+                }),
+                ...(usage.completion_tokens_details?.reasoning_tokens !== null && {
+                    [`${serviceTierPrefix}reasoning`]: usage.completion_tokens_details?.reasoning_tokens,
+                }),
+            };
+        }
+        else {
+            inputTokens = usage.input_tokens ?? 0;
+            outputTokens = usage.output_tokens ?? 0;
+            totalTokens = usage.total_tokens ?? 0;
+            inputTokenDetails = {
+                ...(usage.input_tokens_details?.cached_tokens !== null && {
+                    [`${serviceTierPrefix}cache_read`]: usage.input_tokens_details?.cached_tokens,
+                }),
+            };
+            outputTokenDetails = {
+                ...(usage.output_tokens_details?.reasoning_tokens !== null && {
+                    [`${serviceTierPrefix}reasoning`]: usage.output_tokens_details?.reasoning_tokens,
+                }),
+            };
+        }
+        if (recognizedServiceTier) {
+            // Avoid counting cache read and reasoning tokens towards the
+            // service tier token count since service tier tokens are already
+            // priced differently
+            inputTokenDetails[recognizedServiceTier] =
+                inputTokens -
+                    (inputTokenDetails[`${serviceTierPrefix}cache_read`] ?? 0);
+            outputTokenDetails[recognizedServiceTier] =
+                outputTokens -
+                    (outputTokenDetails[`${serviceTierPrefix}reasoning`] ?? 0);
+        }
         result.usage_metadata = {
-            input_tokens: usage.prompt_tokens ?? 0,
-            output_tokens: usage.completion_tokens ?? 0,
-            total_tokens: usage.total_tokens ?? 0,
+            input_tokens: inputTokens ?? 0,
+            output_tokens: outputTokens ?? 0,
+            total_tokens: totalTokens ?? 0,
             ...(Object.keys(inputTokenDetails).length > 0 && {
                 input_token_details: inputTokenDetails,
             }),
@@ -166,7 +225,7 @@ function processChatCompletion(outputs) {
  * const patchedStream = await patchedClient.chat.completions.create(
  *   {
  *     messages: [{ role: "user", content: `Say 'foo'` }],
- *     model: "gpt-3.5-turbo",
+ *     model: "gpt-4.1-mini",
  *     stream: true,
  *   },
  *   {
@@ -184,81 +243,62 @@ const wrapOpenAI = (openai, options) => {
         (0, traceable_js_1.isTraceableFunction)(openai.completions.create)) {
         throw new Error("This instance of OpenAI client has been already wrapped once.");
     }
+    // Attempt to determine if this is an Azure OpenAI client
+    const isAzureOpenAI = openai.constructor?.name === "AzureOpenAI";
+    const provider = isAzureOpenAI ? "azure" : "openai";
+    const chatName = isAzureOpenAI ? "AzureChatOpenAI" : "ChatOpenAI";
+    const completionsName = isAzureOpenAI ? "AzureOpenAI" : "OpenAI";
     // 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: chatName,
+        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: provider,
+                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), {
-            name: "OpenAI",
+            name: completionsName,
             run_type: "llm",
             aggregator: textAggregator,
             argsConfigPath: [1, "langsmithExtra"],
@@ -270,7 +310,7 @@ const wrapOpenAI = (openai, options) => {
                 const ls_stop = (typeof params.stop === "string" ? [params.stop] : params.stop) ??
                     undefined;
                 return {
-                    ls_provider: "openai",
+                    ls_provider: provider,
                     ls_model_type: "llm",
                     ls_model_name: params.model,
                     ls_max_tokens: params.max_tokens ?? undefined,
@@ -281,6 +321,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: chatName,
+                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: provider,
+                        ls_model_type: "llm",
+                        ls_model_name: params.model || "unknown",
+                    };
+                },
+                processOutputs: processChatCompletion,
+                ...options,
+            });
+        }
+    }
     return tracedOpenAIClient;
 };
 exports.wrapOpenAI = wrapOpenAI;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/wrappers/openai.d.ts

@@ -1,22 +1,21 @@
-import { OpenAI } from "openai";
-import type { APIPromise } from "openai/core";
+import type { OpenAI } from "openai";
+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 & {
@@ -29,7 +28,7 @@ type PatchedOpenAIClient<T extends OpenAIType> = T & {
             } & {
                 (arg: OpenAI.ChatCompletionCreateParamsNonStreaming, arg2?: OpenAI.RequestOptions & {
                     langsmithExtra?: ExtraRunTreeConfig;
-                }): APIPromise<OpenAI.ChatCompletionChunk>;
+                }): APIPromise<OpenAI.ChatCompletion>;
             };
         };
     };
@@ -61,7 +60,7 @@ type PatchedOpenAIClient<T extends OpenAIType> = T & {
  * const patchedStream = await patchedClient.chat.completions.create(
  *   {
  *     messages: [{ role: "user", content: `Say 'foo'` }],
- *     model: "gpt-3.5-turbo",
+ *     model: "gpt-4.1-mini",
  *     stream: true,
  *   },
  *   {