@langchain/openai 0.5.12 → 0.5.14

package/dist/chat_models.cjs

@@ -1,6 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatOpenAI = exports._convertMessagesToOpenAIParams = exports.messageToOpenAIRole = void 0;
+exports.ChatOpenAI = void 0;
+exports.messageToOpenAIRole = messageToOpenAIRole;
+exports._convertMessagesToOpenAIParams = _convertMessagesToOpenAIParams;
+const z4 = __importStar(require("zod/v4/core"));
 const openai_1 = require("openai");
 const messages_1 = require("@langchain/core/messages");
 const outputs_1 = require("@langchain/core/outputs");
@@ -10,8 +46,9 @@ const base_1 = require("@langchain/core/language_models/base");
 const runnables_1 = require("@langchain/core/runnables");
 const output_parsers_1 = require("@langchain/core/output_parsers");
 const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
 const zod_1 = require("openai/helpers/zod");
+const types_1 = require("@langchain/core/utils/types");
+const json_schema_1 = require("@langchain/core/utils/json_schema");
 const azure_js_1 = require("./utils/azure.cjs");
 const openai_js_1 = require("./utils/openai.cjs");
 const openai_format_fndef_js_1 = require("./utils/openai-format-fndef.cjs");
@@ -49,7 +86,6 @@ function messageToOpenAIRole(message) {
             throw new Error(`Unknown message type: ${type}`);
     }
 }
-exports.messageToOpenAIRole = messageToOpenAIRole;
 const completionsApiContentBlockConverter = {
     providerName: "ChatOpenAI",
     fromStandardTextBlock(block) {
@@ -138,7 +174,7 @@ const completionsApiContentBlockConverter = {
             return {
                 type: "file",
                 file: {
-                    file_data: block.url,
+                    file_data: block.url, // formatted as base64 data URL
                     ...(block.metadata?.filename || block.metadata?.name
                         ? {
                             filename: (block.metadata?.filename ||
@@ -230,7 +266,6 @@ function _convertMessagesToOpenAIParams(messages, model) {
         return completionParam;
     });
 }
-exports._convertMessagesToOpenAIParams = _convertMessagesToOpenAIParams;
 const _FUNCTION_CALL_IDS_MAP_KEY = "__openai_function_call_ids__";
 function _convertReasoningSummaryToOpenAIResponsesParams(reasoning) {
     // combine summary parts that have the the same index and then remove the indexes
@@ -252,12 +287,8 @@ function _convertReasoningSummaryToOpenAIResponsesParams(reasoning) {
     };
 }
 function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
-    const lastAIMessage = messages.filter((m) => (0, messages_1.isAIMessage)(m)).pop();
-    const lastAIMessageId = lastAIMessage?.response_metadata?.id;
-    const newMessages = lastAIMessageId && lastAIMessageId.startsWith("resp_") && !zdrEnabled
-        ? messages.slice(messages.indexOf(lastAIMessage) + 1)
-        : messages;
-    return newMessages.flatMap((lcMsg) => {
+    return messages.flatMap((lcMsg) => {
+        const additional_kwargs = lcMsg.additional_kwargs;
         let role = messageToOpenAIRole(lcMsg);
         if (role === "system" && isReasoningModel(model))
             role = "developer";
@@ -267,7 +298,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
         if (role === "tool") {
             const toolMessage = lcMsg;
             // Handle computer call output
-            if (toolMessage.additional_kwargs?.type === "computer_call_output") {
+            if (additional_kwargs?.type === "computer_call_output") {
                 const output = (() => {
                     if (typeof toolMessage.content === "string") {
                         return {
@@ -318,25 +349,19 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
             // otherwise, try to reconstruct the response from what we have
             const input = [];
             // reasoning items
-            if (!zdrEnabled && lcMsg.additional_kwargs.reasoning != null) {
-                const isReasoningItem = (item) => typeof item === "object" &&
-                    item != null &&
-                    "type" in item &&
-                    item.type === "reasoning";
-                if (isReasoningItem(lcMsg.additional_kwargs.reasoning)) {
-                    const reasoningItem = _convertReasoningSummaryToOpenAIResponsesParams(lcMsg.additional_kwargs.reasoning);
-                    input.push(reasoningItem);
-                }
+            if (additional_kwargs?.reasoning && !zdrEnabled) {
+                const reasoningItem = _convertReasoningSummaryToOpenAIResponsesParams(additional_kwargs.reasoning);
+                input.push(reasoningItem);
             }
             // ai content
             let { content } = lcMsg;
-            if (lcMsg.additional_kwargs.refusal != null) {
+            if (additional_kwargs?.refusal) {
                 if (typeof content === "string") {
                     content = [{ type: "output_text", text: content, annotations: [] }];
                 }
                 content = [
                     ...content,
-                    { type: "refusal", refusal: lcMsg.additional_kwargs.refusal },
+                    { type: "refusal", refusal: additional_kwargs.refusal },
                 ];
             }
             input.push({
@@ -360,10 +385,7 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
                         return [];
                     }),
             });
-            // function tool calls and computer use tool calls
-            const functionCallIds = 
-            // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            lcMsg.additional_kwargs[_FUNCTION_CALL_IDS_MAP_KEY];
+            const functionCallIds = additional_kwargs?.[_FUNCTION_CALL_IDS_MAP_KEY];
             if ((0, messages_1.isAIMessage)(lcMsg) && !!lcMsg.tool_calls?.length) {
                 input.push(...lcMsg.tool_calls.map((toolCall) => ({
                     type: "function_call",
@@ -373,44 +395,64 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
                     ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                 })));
             }
-            else if (lcMsg.additional_kwargs.tool_calls != null) {
-                input.push(...lcMsg.additional_kwargs.tool_calls.map((toolCall) => ({
+            else if (additional_kwargs?.tool_calls) {
+                input.push(...additional_kwargs.tool_calls.map((toolCall) => ({
                     type: "function_call",
                     name: toolCall.function.name,
                     call_id: toolCall.id,
-                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                     arguments: toolCall.function.arguments,
+                    ...(zdrEnabled ? { id: functionCallIds?.[toolCall.id] } : {}),
                 })));
             }
             const toolOutputs = lcMsg.response_metadata.output?.length
                 ? lcMsg.response_metadata.output
-                : lcMsg.additional_kwargs.tool_outputs;
-            let computerCalls = [];
+                : additional_kwargs.tool_outputs;
+            const fallthroughCallTypes = [
+                "computer_call",
+                "mcp_call",
+                "code_interpreter_call",
+                "image_generation_call",
+            ];
             if (toolOutputs != null) {
                 const castToolOutputs = toolOutputs;
-                computerCalls = castToolOutputs?.filter((item) => item.type === "computer_call");
-                if (computerCalls.length > 0)
-                    input.push(...computerCalls);
+                const fallthroughCalls = castToolOutputs?.filter((item) => fallthroughCallTypes.includes(item.type));
+                if (fallthroughCalls.length > 0)
+                    input.push(...fallthroughCalls);
             }
             return input;
         }
-        const content = typeof lcMsg.content === "string"
-            ? lcMsg.content
-            : lcMsg.content.flatMap((item) => {
+        if (role === "user" || role === "system" || role === "developer") {
+            if (typeof lcMsg.content === "string") {
+                return { type: "message", role, content: lcMsg.content };
+            }
+            const messages = [];
+            const content = lcMsg.content.flatMap((item) => {
+                if (item.type === "mcp_approval_response") {
+                    messages.push({
+                        type: "mcp_approval_response",
+                        approval_request_id: item.approval_request_id,
+                        approve: item.approve,
+                    });
+                }
                 if ((0, messages_1.isDataContentBlock)(item)) {
                     return (0, messages_1.convertToProviderContentBlock)(item, completionsApiContentBlockConverter);
                 }
                 if (item.type === "text") {
-                    return { type: "input_text", text: item.text };
+                    return {
+                        type: "input_text",
+                        text: item.text,
+                    };
                 }
                 if (item.type === "image_url") {
-                    const image_url = typeof item.image_url === "string"
-                        ? item.image_url
-                        : item.image_url.url;
-                    const detail = typeof item.image_url === "string"
-                        ? "auto"
-                        : item.image_url.detail;
-                    return { type: "input_image", image_url, detail };
+                    return {
+                        type: "input_image",
+                        image_url: typeof item.image_url === "string"
+                            ? item.image_url
+                            : item.image_url.url,
+                        detail: typeof item.image_url === "string"
+                            ? "auto"
+                            : item.image_url.detail,
+                    };
                 }
                 if (item.type === "input_text" ||
                     item.type === "input_image" ||
@@ -419,8 +461,10 @@ function _convertMessagesToOpenAIResponsesParams(messages, model, zdrEnabled) {
                 }
                 return [];
             });
-        if (role === "user" || role === "system" || role === "developer") {
-            return { type: "message", role, content };
+            if (content.length > 0) {
+                messages.push({ type: "message", role, content });
+            }
+            return messages;
         }
         console.warn(`Unsupported role found when converting to OpenAI Responses API: ${role}`);
         return [];
@@ -527,7 +571,7 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
             index: chunk.content_index,
         });
     }
-    else if (chunk.type === "response.output_text.annotation.added") {
+    else if (chunk.type === "response.output_text_annotation.added") {
         content.push({
             type: "text",
             text: "",
@@ -553,9 +597,16 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
         };
     }
     else if (chunk.type === "response.output_item.done" &&
-        (chunk.item.type === "web_search_call" ||
-            chunk.item.type === "file_search_call" ||
-            chunk.item.type === "computer_call")) {
+        [
+            "web_search_call",
+            "file_search_call",
+            "computer_call",
+            "code_interpreter_call",
+            "mcp_call",
+            "mcp_list_tools",
+            "mcp_approval_request",
+            "image_generation_call",
+        ].includes(chunk.item.type)) {
         additional_kwargs.tool_outputs = [chunk.item];
     }
     else if (chunk.type === "response.created") {
@@ -627,6 +678,11 @@ function _convertOpenAIResponsesDeltaToBaseMessageChunk(chunk) {
             ],
         };
     }
+    else if (chunk.type === "response.image_generation_call.partial_image") {
+        // noop/fixme: retaining partial images in a message chunk means that _all_
+        // partial images get kept in history, so we don't do anything here.
+        return null;
+    }
     else {
         return null;
     }
@@ -653,6 +709,29 @@ function isBuiltInToolChoice(tool_choice) {
         "type" in tool_choice &&
         tool_choice.type !== "function");
 }
+function _reduceChatOpenAIToolsForResponses(tools, fields) {
+    const reducedTools = [];
+    for (const tool of tools) {
+        if (isBuiltInTool(tool)) {
+            if (tool.type === "image_generation" && fields?.stream) {
+                // OpenAI sends a 400 error if partial_images is not set and we want to stream.
+                // We also set it to 1 since we don't support partial images yet.
+                tool.partial_images = 1;
+            }
+            reducedTools.push(tool);
+        }
+        else if ((0, base_1.isOpenAITool)(tool)) {
+            reducedTools.push({
+                type: "function",
+                name: tool.function.name,
+                parameters: tool.function.parameters,
+                description: tool.function.description,
+                strict: fields?.strict ?? null,
+            });
+        }
+    }
+    return reducedTools;
+}
 function _convertChatOpenAIToolTypeToOpenAITool(tool, fields) {
     if ((0, base_1.isOpenAITool)(tool)) {
         if (fields?.strict !== undefined) {
@@ -1587,8 +1666,8 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         if (resFormat &&
             resFormat.type === "json_schema" &&
             resFormat.json_schema.schema &&
-            isZodSchema(resFormat.json_schema.schema)) {
-            return (0, zod_1.zodResponseFormat)(resFormat.json_schema.schema, resFormat.json_schema.name, {
+            (0, types_1.isInteropZodSchema)(resFormat.json_schema.schema)) {
+            return interopZodResponseFormat(resFormat.json_schema.schema, resFormat.json_schema.name, {
                 description: resFormat.json_schema.description,
             });
         }
@@ -1646,25 +1725,10 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                 truncation: options?.truncation,
                 include: options?.include,
                 tools: options?.tools?.length
-                    ? options.tools
-                        .map((tool) => {
-                        if (isBuiltInTool(tool)) {
-                            return tool;
-                        }
-                        else if ((0, base_1.isOpenAITool)(tool)) {
-                            return {
-                                type: "function",
-                                name: tool.function.name,
-                                parameters: tool.function.parameters,
-                                description: tool.function.description,
-                                strict,
-                            };
-                        }
-                        else {
-                            return null;
-                        }
+                    ? _reduceChatOpenAIToolsForResponses(options.tools, {
+                        stream: this.streaming,
+                        strict,
                     })
-                        .filter((tool) => tool !== null)
                     : undefined,
                 tool_choice: isBuiltInToolChoice(options?.tool_choice)
                     ? options?.tool_choice
@@ -1907,17 +1971,10 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
     }
     async *_streamResponseChunks(messages, options, runManager) {
         if (this._useResponseApi(options)) {
-            const lastAIMessage = messages.filter((m) => (0, messages_1.isAIMessage)(m)).pop();
-            const lastAIMessageId = lastAIMessage?.response_metadata?.id;
             const streamIterable = await this.responseApiWithRetry({
                 ...this.invocationParams(options, { streaming: true }),
                 input: _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled),
                 stream: true,
-                ...(lastAIMessageId &&
-                    lastAIMessageId.startsWith("resp_") &&
-                    !this.zdrEnabled
-                    ? { previous_response_id: lastAIMessageId }
-                    : {}),
             }, options);
             for await (const data of streamIterable) {
                 const chunk = _convertOpenAIResponsesDeltaToBaseMessageChunk(data);
@@ -2051,17 +2108,10 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                 },
             };
         }
-        const lastAIMessage = messages.filter((m) => (0, messages_1.isAIMessage)(m)).pop();
-        const lastAIMessageId = lastAIMessage?.response_metadata?.id;
         const input = _convertMessagesToOpenAIResponsesParams(messages, this.model, this.zdrEnabled);
         const data = await this.responseApiWithRetry({
             input,
             ...invocationParams,
-            ...(lastAIMessageId &&
-                lastAIMessageId.startsWith("resp_") &&
-                !this.zdrEnabled
-                ? { previous_response_id: lastAIMessageId }
-                : {}),
         }, { signal: options?.signal, ...options?.options });
         return {
             generations: [
@@ -2371,7 +2421,7 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         const requestOptions = this._getClientOptions(options);
         return this.caller.call(async () => {
             try {
-                const res = await this.client.beta.chat.completions.parse(request, requestOptions);
+                const res = await this.client.chat.completions.parse(request, requestOptions);
                 return res;
             }
             catch (e) {
@@ -2458,15 +2508,21 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             console.warn(`[WARNING]: JSON Schema is not supported for model "${this.model}". Falling back to tool calling.`);
         }
         if (method === "jsonMode") {
-            llm = this.withConfig({
-                response_format: { type: "json_object" },
-            });
-            if (isZodSchema(schema)) {
+            let outputFormatSchema;
+            if ((0, types_1.isInteropZodSchema)(schema)) {
                 outputParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
+                outputFormatSchema = (0, json_schema_1.toJsonSchema)(schema);
             }
             else {
                 outputParser = new output_parsers_1.JsonOutputParser();
             }
+            llm = this.withConfig({
+                response_format: { type: "json_object" },
+                ls_structured_output_format: {
+                    kwargs: { method: "jsonMode" },
+                    schema: outputFormatSchema,
+                },
+            });
         }
         else if (method === "jsonSchema") {
             llm = this.withConfig({
@@ -2474,13 +2530,17 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                     type: "json_schema",
                     json_schema: {
                         name: name ?? "extract",
-                        description: schema.description,
+                        description: (0, types_1.getSchemaDescription)(schema),
                         schema,
                         strict: config?.strict,
                     },
                 },
+                ls_structured_output_format: {
+                    kwargs: { method: "jsonSchema" },
+                    schema: (0, json_schema_1.toJsonSchema)(schema),
+                },
             });
-            if (isZodSchema(schema)) {
+            if ((0, types_1.isInteropZodSchema)(schema)) {
                 const altParser = output_parsers_1.StructuredOutputParser.fromZodSchema(schema);
                 outputParser = runnables_1.RunnableLambda.from((aiMessage) => {
                     if ("parsed" in aiMessage.additional_kwargs) {
@@ -2496,8 +2556,8 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         else {
             let functionName = name ?? "extract";
             // Is function calling
-            if (isZodSchema(schema)) {
-                const asJsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(schema);
+            if ((0, types_1.isInteropZodSchema)(schema)) {
+                const asJsonSchema = (0, json_schema_1.toJsonSchema)(schema);
                 llm = this.withConfig({
                     tools: [
                         {
@@ -2515,6 +2575,10 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                             name: functionName,
                         },
                     },
+                    ls_structured_output_format: {
+                        kwargs: { method: "functionCalling" },
+                        schema: asJsonSchema,
+                    },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
@@ -2553,6 +2617,10 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
                             name: functionName,
                         },
                     },
+                    ls_structured_output_format: {
+                        kwargs: { method: "functionCalling" },
+                        schema: (0, json_schema_1.toJsonSchema)(schema),
+                    },
                     // Do not pass `strict` argument to OpenAI if `config.strict` is undefined
                     ...(config?.strict !== undefined ? { strict: config.strict } : {}),
                 });
@@ -2579,12 +2647,6 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
     }
 }
 exports.ChatOpenAI = ChatOpenAI;
-function isZodSchema(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-input) {
-    // Check for a characteristic method of Zod schemas
-    return typeof input?.parse === "function";
-}
 function isStructuredOutputMethodParams(x
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
@@ -2593,3 +2655,49 @@ function isStructuredOutputMethodParams(x
         typeof x.schema ===
             "object");
 }
+// inlined from openai/lib/parser.ts
+function makeParseableResponseFormat(response_format, parser) {
+    const obj = { ...response_format };
+    Object.defineProperties(obj, {
+        $brand: {
+            value: "auto-parseable-response-format",
+            enumerable: false,
+        },
+        $parseRaw: {
+            value: parser,
+            enumerable: false,
+        },
+    });
+    return obj;
+}
+function interopZodResponseFormat(zodSchema, name, props) {
+    if ((0, types_1.isZodSchemaV3)(zodSchema)) {
+        return (0, zod_1.zodResponseFormat)(zodSchema, name, props);
+    }
+    if ((0, types_1.isZodSchemaV4)(zodSchema)) {
+        return makeParseableResponseFormat({
+            type: "json_schema",
+            json_schema: {
+                ...props,
+                name,
+                strict: true,
+                schema: z4.toJSONSchema(zodSchema, {
+                    cycles: "ref", // equivalent to nameStrategy: 'duplicate-ref'
+                    reused: "ref", // equivalent to $refStrategy: 'extract-to-root'
+                    override(ctx) {
+                        ctx.jsonSchema.title = name; // equivalent to `name` property
+                        // TODO: implement `nullableStrategy` patch-fix (zod doesn't support openApi3 json schema target)
+                        // TODO: implement `openaiStrictMode` patch-fix (where optional properties without `nullable` are not supported)
+                    },
+                    /// property equivalents from native `zodResponseFormat` fn
+                    // openaiStrictMode: true,
+                    // name,
+                    // nameStrategy: 'duplicate-ref',
+                    // $refStrategy: 'extract-to-root',
+                    // nullableStrategy: 'property',
+                }),
+            },
+        }, (content) => z4.parse(zodSchema, JSON.parse(content)));
+    }
+    throw new Error("Unsupported schema response format");
+}

package/dist/chat_models.d.ts

@@ -4,8 +4,8 @@ import { AIMessageChunk, type BaseMessage, ChatMessageChunk, FunctionMessageChun
 import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { BaseChatModel, type BindToolsInput, type LangSmithParams, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { type BaseFunctionCallOptions, type BaseLanguageModelInput, type StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
-import { z } from "zod";
 import { Runnable } from "@langchain/core/runnables";
+import { InteropZodType } from "@langchain/core/utils/types";
 import { type OpenAICallOptions, type OpenAIChatInput, type OpenAICoreRequestOptions, type ChatOpenAIResponseFormat } from "./types.js";
 import { OpenAIToolChoice } from "./utils/openai.js";
 export type { OpenAICallOptions, OpenAIChatInput };
@@ -841,17 +841,17 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
      * @param {OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming} request
      * @param {OpenAICoreRequestOptions | undefined} options
      */
-    betaParsedCompletionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<ReturnType<OpenAIClient["beta"]["chat"]["completions"]["parse"]>>;
+    betaParsedCompletionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<ReturnType<OpenAIClient["chat"]["completions"]["parse"]>>;
     protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;
-    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: InteropZodType<RunOutput> | Record<string, any>, config?: ChatOpenAIStructuredOutputMethodOptions<boolean>): Runnable<BaseLanguageModelInput, RunOutput> | Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;
         parsed: RunOutput;
     }>;