@n8n/n8n-nodes-langchain 2.5.1 → 2.6.0

package/dist/nodes/llms/LMChatOpenAi/LmChatOpenAi.node.js

@@ -1,71 +1,44 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var LmChatOpenAi_node_exports = {};
-__export(LmChatOpenAi_node_exports, {
-  LmChatOpenAi: () => LmChatOpenAi
-});
-module.exports = __toCommonJS(LmChatOpenAi_node_exports);
-var import_openai = require("@langchain/openai");
-var import_pick = __toESM(require("lodash/pick"));
-var import_n8n_workflow = require("n8n-workflow");
-var import_httpProxyAgent = require("../../../utils/httpProxyAgent");
-var import_sharedFields = require("../../../utils/sharedFields");
-var import_error_handling = require("../../vendors/OpenAi/helpers/error-handling");
-var import_n8nLlmFailedAttemptHandler = require("../n8nLlmFailedAttemptHandler");
-var import_N8nLlmTracing = require("../N8nLlmTracing");
-var import_common = require("./common");
-var import_loadModels = require("./methods/loadModels");
-var import_di = require("@n8n/di");
-var import_config = require("@n8n/config");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmChatOpenAi = void 0;
+const openai_1 = require("@langchain/openai");
+const pick_1 = __importDefault(require("lodash/pick"));
+const n8n_workflow_1 = require("n8n-workflow");
+const httpProxyAgent_1 = require("../../../utils/httpProxyAgent");
+const sharedFields_1 = require("../../../utils/sharedFields");
+const error_handling_1 = require("../../vendors/OpenAi/helpers/error-handling");
+const n8nLlmFailedAttemptHandler_1 = require("../n8nLlmFailedAttemptHandler");
+const N8nLlmTracing_1 = require("../N8nLlmTracing");
+const common_1 = require("./common");
+const loadModels_1 = require("./methods/loadModels");
+const di_1 = require("@n8n/di");
+const config_1 = require("@n8n/config");
 const INCLUDE_JSON_WARNING = {
-  displayName: 'If using JSON response format, you must include word "json" in the prompt in your chain or agent. Also, make sure to select latest models released post November 2023.',
-  name: "notice",
-  type: "notice",
-  default: ""
+    displayName: 'If using JSON response format, you must include word "json" in the prompt in your chain or agent. Also, make sure to select latest models released post November 2023.',
+    name: 'notice',
+    type: 'notice',
+    default: '',
 };
 const completionsResponseFormat = {
-  displayName: "Response Format",
-  name: "responseFormat",
-  default: "text",
-  type: "options",
-  options: [
-    {
-      name: "Text",
-      value: "text",
-      description: "Regular text response"
-    },
-    {
-      name: "JSON",
-      value: "json_object",
-      description: "Enables JSON mode, which should guarantee the message the model generates is valid JSON"
-    }
-  ]
+    displayName: 'Response Format',
+    name: 'responseFormat',
+    default: 'text',
+    type: 'options',
+    options: [
+        {
+            name: 'Text',
+            value: 'text',
+            description: 'Regular text response',
+        },
+        {
+            name: 'JSON',
+            value: 'json_object',
+            description: 'Enables JSON mode, which should guarantee the message the model generates is valid JSON',
+        },
+    ],
 };
 const jsonSchemaExample = `{
   "type": "object",
@@ -78,728 +51,726 @@ const jsonSchemaExample = `{
   "required": ["message"]
 }`;
 class LmChatOpenAi {
-  constructor() {
-    this.methods = {
-      listSearch: {
-        searchModels: import_loadModels.searchModels
-      }
-    };
-    this.description = {
-      displayName: "OpenAI Chat Model",
-      name: "lmChatOpenAi",
-      icon: { light: "file:openAiLight.svg", dark: "file:openAiLight.dark.svg" },
-      group: ["transform"],
-      version: [1, 1.1, 1.2, 1.3],
-      description: "For advanced usage with an AI chain",
-      defaults: {
-        name: "OpenAI Chat Model"
-      },
-      codex: {
-        categories: ["AI"],
-        subcategories: {
-          AI: ["Language Models", "Root Nodes"],
-          "Language Models": ["Chat Models (Recommended)"]
-        },
-        resources: {
-          primaryDocumentation: [
-            {
-              url: "https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/"
-            }
-          ]
-        }
-      },
-      inputs: [],
-      outputs: [import_n8n_workflow.NodeConnectionTypes.AiLanguageModel],
-      outputNames: ["Model"],
-      credentials: [
-        {
-          name: "openAiApi",
-          required: true
-        }
-      ],
-      requestDefaults: {
-        ignoreHttpStatusErrors: true,
-        baseURL: '={{ $parameter.options?.baseURL?.split("/").slice(0,-1).join("/") || $credentials?.url?.split("/").slice(0,-1).join("/") || "https://api.openai.com" }}'
-      },
-      properties: [
-        (0, import_sharedFields.getConnectionHintNoticeField)([import_n8n_workflow.NodeConnectionTypes.AiChain, import_n8n_workflow.NodeConnectionTypes.AiAgent]),
-        {
-          ...INCLUDE_JSON_WARNING,
-          displayOptions: {
-            show: {
-              "/options.responseFormat": ["json_object"]
-            }
-          }
-        },
-        {
-          ...INCLUDE_JSON_WARNING,
-          displayOptions: {
-            show: {
-              "/options.textFormat.textOptions.type": ["json_object"]
-            }
-          }
-        },
-        {
-          displayName: "Model",
-          name: "model",
-          type: "options",
-          description: 'The model which will generate the completion. <a href="https://beta.openai.com/docs/models/overview">Learn more</a>.',
-          typeOptions: {
-            loadOptions: {
-              routing: {
-                request: {
-                  method: "GET",
-                  url: '={{ $parameter.options?.baseURL?.split("/").slice(-1).pop() || $credentials?.url?.split("/").slice(-1).pop() || "v1" }}/models'
-                },
-                output: {
-                  postReceive: [
-                    {
-                      type: "rootProperty",
-                      properties: {
-                        property: "data"
-                      }
-                    },
-                    {
-                      type: "filter",
-                      properties: {
-                        // If the baseURL is not set or is set to api.openai.com, include only chat models
-                        pass: `={{
-												($parameter.options?.baseURL && !$parameter.options?.baseURL?.startsWith('https://api.openai.com/')) ||
-												($credentials?.url && !$credentials.url.startsWith('https://api.openai.com/')) ||
-												$responseItem.id.startsWith('ft:') ||
-												$responseItem.id.startsWith('o1') ||
-												$responseItem.id.startsWith('o3') ||
-												($responseItem.id.startsWith('gpt-') && !$responseItem.id.includes('instruct'))
-											}}`
-                      }
-                    },
-                    {
-                      type: "setKeyValue",
-                      properties: {
-                        name: "={{$responseItem.id}}",
-                        value: "={{$responseItem.id}}"
-                      }
-                    },
-                    {
-                      type: "sort",
-                      properties: {
-                        key: "name"
-                      }
-                    }
-                  ]
-                }
-              }
-            }
-          },
-          routing: {
-            send: {
-              type: "body",
-              property: "model"
-            }
-          },
-          default: "gpt-5-mini",
-          displayOptions: {
-            hide: {
-              "@version": [{ _cnd: { gte: 1.2 } }]
-            }
-          }
-        },
-        {
-          displayName: "Model",
-          name: "model",
-          type: "resourceLocator",
-          default: { mode: "list", value: "gpt-5-mini" },
-          required: true,
-          modes: [
-            {
-              displayName: "From List",
-              name: "list",
-              type: "list",
-              placeholder: "Select a model...",
-              typeOptions: {
-                searchListMethod: "searchModels",
-                searchable: true
-              }
+    constructor() {
+        this.methods = {
+            listSearch: {
+                searchModels: loadModels_1.searchModels,
             },
-            {
-              displayName: "ID",
-              name: "id",
-              type: "string",
-              placeholder: "gpt-5-mini"
-            }
-          ],
-          description: "The model. Choose from the list, or specify an ID.",
-          displayOptions: {
-            hide: {
-              "@version": [{ _cnd: { lte: 1.1 } }]
-            }
-          }
-        },
-        {
-          displayName: 'When using non-OpenAI models via "Base URL" override, not all models might be chat-compatible or support other features, like tools calling or JSON response format',
-          name: "notice",
-          type: "notice",
-          default: "",
-          displayOptions: {
-            show: {
-              "/options.baseURL": [{ _cnd: { exists: true } }]
-            }
-          }
-        },
-        {
-          displayName: "Use Responses API",
-          name: "responsesApiEnabled",
-          type: "boolean",
-          default: true,
-          description: 'Whether to use the Responses API to generate the response. <a href="https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/#use-responses-api">Learn more</a>.',
-          displayOptions: {
-            show: {
-              "@version": [{ _cnd: { gte: 1.3 } }]
-            }
-          }
-        },
-        {
-          displayName: "Built-in Tools",
-          name: "builtInTools",
-          placeholder: "Add Built-in Tool",
-          type: "collection",
-          default: {},
-          options: [
-            {
-              displayName: "Web Search",
-              name: "webSearch",
-              type: "collection",
-              default: { searchContextSize: "medium" },
-              options: [
-                {
-                  displayName: "Search Context Size",
-                  name: "searchContextSize",
-                  type: "options",
-                  default: "medium",
-                  description: "High level guidance for the amount of context window space to use for the search",
-                  options: [
-                    { name: "Low", value: "low" },
-                    { name: "Medium", value: "medium" },
-                    { name: "High", value: "high" }
-                  ]
-                },
-                {
-                  displayName: "Web Search Allowed Domains",
-                  name: "allowedDomains",
-                  type: "string",
-                  default: "",
-                  description: "Comma-separated list of domains to search. Only domains in this list will be searched.",
-                  placeholder: "e.g. google.com, wikipedia.org"
+        };
+        this.description = {
+            displayName: 'OpenAI Chat Model',
+            name: 'lmChatOpenAi',
+            icon: { light: 'file:openAiLight.svg', dark: 'file:openAiLight.dark.svg' },
+            group: ['transform'],
+            version: [1, 1.1, 1.2, 1.3],
+            description: 'For advanced usage with an AI chain',
+            defaults: {
+                name: 'OpenAI Chat Model',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Language Models', 'Root Nodes'],
+                    'Language Models': ['Chat Models (Recommended)'],
                 },
-                {
-                  displayName: "Country",
-                  name: "country",
-                  type: "string",
-                  default: "",
-                  placeholder: "e.g. US, GB"
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: 'https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/',
+                        },
+                    ],
                 },
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiLanguageModel],
+            outputNames: ['Model'],
+            credentials: [
                 {
-                  displayName: "City",
-                  name: "city",
-                  type: "string",
-                  default: "",
-                  placeholder: "e.g. New York, London"
+                    name: 'openAiApi',
+                    required: true,
                 },
-                {
-                  displayName: "Region",
-                  name: "region",
-                  type: "string",
-                  default: "",
-                  placeholder: "e.g. New York, London"
-                }
-              ]
+            ],
+            requestDefaults: {
+                ignoreHttpStatusErrors: true,
+                baseURL: '={{ $parameter.options?.baseURL?.split("/").slice(0,-1).join("/") || $credentials?.url?.split("/").slice(0,-1).join("/") || "https://api.openai.com" }}',
             },
-            {
-              displayName: "File Search",
-              name: "fileSearch",
-              type: "collection",
-              default: { vectorStoreIds: "[]" },
-              options: [
+            properties: [
+                (0, sharedFields_1.getConnectionHintNoticeField)([n8n_workflow_1.NodeConnectionTypes.AiChain, n8n_workflow_1.NodeConnectionTypes.AiAgent]),
                 {
-                  displayName: "Vector Store IDs",
-                  name: "vectorStoreIds",
-                  description: 'The vector store IDs to use for the file search. Vector stores are managed via OpenAI Dashboard. <a href="https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/#built-in-tools">Learn more</a>.',
-                  type: "json",
-                  default: "[]",
-                  required: true
+                    ...INCLUDE_JSON_WARNING,
+                    displayOptions: {
+                        show: {
+                            '/options.responseFormat': ['json_object'],
+                        },
+                    },
                 },
                 {
-                  displayName: "Filters",
-                  name: "filters",
-                  type: "json",
-                  default: "{}"
+                    ...INCLUDE_JSON_WARNING,
+                    displayOptions: {
+                        show: {
+                            '/options.textFormat.textOptions.type': ['json_object'],
+                        },
+                    },
                 },
                 {
-                  displayName: "Max Results",
-                  name: "maxResults",
-                  type: "number",
-                  default: 1,
-                  typeOptions: { minValue: 1, maxValue: 50 }
-                }
-              ]
-            },
-            {
-              displayName: "Code Interpreter",
-              name: "codeInterpreter",
-              type: "boolean",
-              default: true,
-              description: "Whether to allow the model to execute code in a sandboxed environment"
-            }
-          ],
-          displayOptions: {
-            show: {
-              "@version": [{ _cnd: { gte: 1.3 } }],
-              "/responsesApiEnabled": [true]
-            }
-          }
-        },
-        {
-          displayName: "Options",
-          name: "options",
-          placeholder: "Add Option",
-          description: "Additional options to add",
-          type: "collection",
-          default: {},
-          options: [
-            {
-              displayName: "Base URL",
-              name: "baseURL",
-              default: "https://api.openai.com/v1",
-              description: "Override the default base URL for the API",
-              type: "string",
-              displayOptions: {
-                hide: {
-                  "@version": [{ _cnd: { gte: 1.1 } }]
-                }
-              }
-            },
-            {
-              displayName: "Frequency Penalty",
-              name: "frequencyPenalty",
-              default: 0,
-              typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
-              description: "Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim",
-              type: "number"
-            },
-            {
-              displayName: "Maximum Number of Tokens",
-              name: "maxTokens",
-              default: -1,
-              description: "The maximum number of tokens to generate in the completion. Most models have a context length of 2048 tokens (except for the newest models, which support 32,768).",
-              type: "number",
-              typeOptions: {
-                maxValue: 32768
-              }
-            },
-            {
-              ...completionsResponseFormat,
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { lt: 1.3 } }]
-                }
-              }
-            },
-            {
-              ...completionsResponseFormat,
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [false]
-                }
-              }
-            },
-            {
-              displayName: "Response Format",
-              name: "textFormat",
-              type: "fixedCollection",
-              default: { textOptions: [{ type: "text" }] },
-              options: [
-                {
-                  displayName: "Text",
-                  name: "textOptions",
-                  values: [
-                    {
-                      displayName: "Type",
-                      name: "type",
-                      type: "options",
-                      default: "",
-                      options: [
-                        { name: "Text", value: "text" },
-                        // eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
-                        { name: "JSON Schema (recommended)", value: "json_schema" },
-                        { name: "JSON Object", value: "json_object" }
-                      ]
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    description: 'The model which will generate the completion. <a href="https://beta.openai.com/docs/models/overview">Learn more</a>.',
+                    typeOptions: {
+                        loadOptions: {
+                            routing: {
+                                request: {
+                                    method: 'GET',
+                                    url: '={{ $parameter.options?.baseURL?.split("/").slice(-1).pop() || $credentials?.url?.split("/").slice(-1).pop() || "v1" }}/models',
+                                },
+                                output: {
+                                    postReceive: [
+                                        {
+                                            type: 'rootProperty',
+                                            properties: {
+                                                property: 'data',
+                                            },
+                                        },
+                                        {
+                                            type: 'filter',
+                                            properties: {
+                                                pass: `={{
+												($parameter.options?.baseURL && !$parameter.options?.baseURL?.startsWith('https://api.openai.com/')) ||
+												($credentials?.url && !$credentials.url.startsWith('https://api.openai.com/')) ||
+												$responseItem.id.startsWith('ft:') ||
+												$responseItem.id.startsWith('o1') ||
+												$responseItem.id.startsWith('o3') ||
+												($responseItem.id.startsWith('gpt-') && !$responseItem.id.includes('instruct'))
+											}}`,
+                                            },
+                                        },
+                                        {
+                                            type: 'setKeyValue',
+                                            properties: {
+                                                name: '={{$responseItem.id}}',
+                                                value: '={{$responseItem.id}}',
+                                            },
+                                        },
+                                        {
+                                            type: 'sort',
+                                            properties: {
+                                                key: 'name',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
                     },
-                    {
-                      displayName: "Verbosity",
-                      name: "verbosity",
-                      type: "options",
-                      default: "medium",
-                      options: [
-                        { name: "Low", value: "low" },
-                        { name: "Medium", value: "medium" },
-                        { name: "High", value: "high" }
-                      ]
+                    routing: {
+                        send: {
+                            type: 'body',
+                            property: 'model',
+                        },
                     },
-                    {
-                      displayName: "Name",
-                      name: "name",
-                      type: "string",
-                      default: "my_schema",
-                      description: "The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.",
-                      displayOptions: {
-                        show: {
-                          type: ["json_schema"]
-                        }
-                      }
+                    default: 'gpt-5-mini',
+                    displayOptions: {
+                        hide: {
+                            '@version': [{ _cnd: { gte: 1.2 } }],
+                        },
                     },
-                    {
-                      displayName: 'All properties in the schema must be set to "required", when using "strict" mode.',
-                      name: "requiredNotice",
-                      type: "notice",
-                      default: "",
-                      displayOptions: {
-                        show: {
-                          strict: [true]
-                        }
-                      }
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: 'gpt-5-mini' },
+                    required: true,
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            placeholder: 'Select a model...',
+                            typeOptions: {
+                                searchListMethod: 'searchModels',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'ID',
+                            name: 'id',
+                            type: 'string',
+                            placeholder: 'gpt-5-mini',
+                        },
+                    ],
+                    description: 'The model. Choose from the list, or specify an ID.',
+                    displayOptions: {
+                        hide: {
+                            '@version': [{ _cnd: { lte: 1.1 } }],
+                        },
                     },
-                    {
-                      displayName: "Schema",
-                      name: "schema",
-                      type: "json",
-                      default: jsonSchemaExample,
-                      description: "The schema of the response format",
-                      displayOptions: {
+                },
+                {
+                    displayName: 'When using non-OpenAI models via "Base URL" override, not all models might be chat-compatible or support other features, like tools calling or JSON response format',
+                    name: 'notice',
+                    type: 'notice',
+                    default: '',
+                    displayOptions: {
                         show: {
-                          type: ["json_schema"]
-                        }
-                      }
+                            '/options.baseURL': [{ _cnd: { exists: true } }],
+                        },
                     },
-                    {
-                      displayName: "Description",
-                      name: "description",
-                      type: "string",
-                      default: "",
-                      description: "The description of the response format",
-                      displayOptions: {
+                },
+                {
+                    displayName: 'Use Responses API',
+                    name: 'responsesApiEnabled',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to use the Responses API to generate the response. <a href="https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/#use-responses-api">Learn more</a>.',
+                    displayOptions: {
                         show: {
-                          type: ["json_schema"]
-                        }
-                      }
+                            '@version': [{ _cnd: { gte: 1.3 } }],
+                        },
                     },
-                    {
-                      displayName: "Strict",
-                      name: "strict",
-                      type: "boolean",
-                      default: false,
-                      description: "Whether to require that the AI will always generate responses that match the provided JSON Schema",
-                      displayOptions: {
-                        show: {
-                          type: ["json_schema"]
-                        }
-                      }
-                    }
-                  ]
-                }
-              ],
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Presence Penalty",
-              name: "presencePenalty",
-              default: 0,
-              typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
-              description: "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics",
-              type: "number"
-            },
-            {
-              displayName: "Sampling Temperature",
-              name: "temperature",
-              default: 0.7,
-              typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
-              description: "Controls randomness: Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.",
-              type: "number"
-            },
-            {
-              displayName: "Reasoning Effort",
-              name: "reasoningEffort",
-              default: "medium",
-              description: 'Controls the amount of reasoning tokens to use. A value of "low" will favor speed and economical token usage, "high" will favor more complete reasoning at the cost of more tokens generated and slower responses.',
-              type: "options",
-              options: [
-                {
-                  name: "Low",
-                  value: "low",
-                  description: "Favors speed and economical token usage"
                 },
                 {
-                  name: "Medium",
-                  value: "medium",
-                  description: "Balance between speed and reasoning accuracy"
+                    displayName: 'Built-in Tools',
+                    name: 'builtInTools',
+                    placeholder: 'Add Built-in Tool',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Web Search',
+                            name: 'webSearch',
+                            type: 'collection',
+                            default: { searchContextSize: 'medium' },
+                            options: [
+                                {
+                                    displayName: 'Search Context Size',
+                                    name: 'searchContextSize',
+                                    type: 'options',
+                                    default: 'medium',
+                                    description: 'High level guidance for the amount of context window space to use for the search',
+                                    options: [
+                                        { name: 'Low', value: 'low' },
+                                        { name: 'Medium', value: 'medium' },
+                                        { name: 'High', value: 'high' },
+                                    ],
+                                },
+                                {
+                                    displayName: 'Web Search Allowed Domains',
+                                    name: 'allowedDomains',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Comma-separated list of domains to search. Only domains in this list will be searched.',
+                                    placeholder: 'e.g. google.com, wikipedia.org',
+                                },
+                                {
+                                    displayName: 'Country',
+                                    name: 'country',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: 'e.g. US, GB',
+                                },
+                                {
+                                    displayName: 'City',
+                                    name: 'city',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: 'e.g. New York, London',
+                                },
+                                {
+                                    displayName: 'Region',
+                                    name: 'region',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: 'e.g. New York, London',
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'File Search',
+                            name: 'fileSearch',
+                            type: 'collection',
+                            default: { vectorStoreIds: '[]' },
+                            options: [
+                                {
+                                    displayName: 'Vector Store IDs',
+                                    name: 'vectorStoreIds',
+                                    description: 'The vector store IDs to use for the file search. Vector stores are managed via OpenAI Dashboard. <a href="https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatopenai/#built-in-tools">Learn more</a>.',
+                                    type: 'json',
+                                    default: '[]',
+                                    required: true,
+                                },
+                                {
+                                    displayName: 'Filters',
+                                    name: 'filters',
+                                    type: 'json',
+                                    default: '{}',
+                                },
+                                {
+                                    displayName: 'Max Results',
+                                    name: 'maxResults',
+                                    type: 'number',
+                                    default: 1,
+                                    typeOptions: { minValue: 1, maxValue: 50 },
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'Code Interpreter',
+                            name: 'codeInterpreter',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to allow the model to execute code in a sandboxed environment',
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            '@version': [{ _cnd: { gte: 1.3 } }],
+                            '/responsesApiEnabled': [true],
+                        },
+                    },
                 },
                 {
-                  name: "High",
-                  value: "high",
-                  description: "Favors more complete reasoning at the cost of more tokens generated and slower responses"
-                }
-              ],
-              displayOptions: {
-                show: {
-                  // reasoning_effort is only available on o1, o1-versioned, or on o3-mini and beyond, and gpt-5 models. Not on o1-mini or other GPT-models.
-                  "/model": [{ _cnd: { regex: "(^o1([-\\d]+)?$)|(^o[3-9].*)|(^gpt-5.*)" } }]
-                }
-              }
-            },
-            {
-              displayName: "Timeout",
-              name: "timeout",
-              default: 6e4,
-              description: "Maximum amount of time a request is allowed to take in milliseconds",
-              type: "number"
-            },
-            {
-              displayName: "Max Retries",
-              name: "maxRetries",
-              default: 2,
-              description: "Maximum number of retries to attempt",
-              type: "number"
-            },
-            {
-              displayName: "Top P",
-              name: "topP",
-              default: 1,
-              typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },
-              description: "Controls diversity via nucleus sampling: 0.5 means half of all likelihood-weighted options are considered. We generally recommend altering this or temperature but not both.",
-              type: "number"
-            },
-            {
-              displayName: "Conversation ID",
-              name: "conversationId",
-              default: "",
-              description: "The conversation that this response belongs to. Input items and output items from this response are automatically added to this conversation after this response completes.",
-              type: "string",
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Prompt Cache Key",
-              name: "promptCacheKey",
-              type: "string",
-              default: "",
-              description: "Used by OpenAI to cache responses for similar requests to optimize your cache hit rates",
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Safety Identifier",
-              name: "safetyIdentifier",
-              type: "string",
-              default: "",
-              description: "A stable identifier used to help detect users of your application that may be violating OpenAI's usage policies. The IDs should be a string that uniquely identifies each user.",
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Service Tier",
-              name: "serviceTier",
-              type: "options",
-              default: "auto",
-              description: "The service tier to use for the request",
-              options: [
-                { name: "Auto", value: "auto" },
-                { name: "Flex", value: "flex" },
-                { name: "Default", value: "default" },
-                { name: "Priority", value: "priority" }
-              ],
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Metadata",
-              name: "metadata",
-              type: "json",
-              description: "Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.",
-              default: "{}",
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Top Logprobs",
-              name: "topLogprobs",
-              type: "number",
-              default: 0,
-              description: "An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability",
-              typeOptions: {
-                minValue: 0,
-                maxValue: 20
-              },
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
-            },
-            {
-              displayName: "Prompt",
-              name: "promptConfig",
-              type: "fixedCollection",
-              description: 'Configure the reusable prompt template configured via OpenAI Dashboard. <a href="https://platform.openai.com/docs/guides/prompt-engineering#reusable-prompts">Learn more</a>.',
-              default: { promptOptions: [{ promptId: "" }] },
-              options: [
-                {
-                  displayName: "Prompt",
-                  name: "promptOptions",
-                  values: [
-                    {
-                      displayName: "Prompt ID",
-                      name: "promptId",
-                      type: "string",
-                      default: "",
-                      description: "The unique identifier of the prompt template to use"
-                    },
-                    {
-                      displayName: "Version",
-                      name: "version",
-                      type: "string",
-                      default: "",
-                      description: "Optional version of the prompt template"
-                    },
-                    {
-                      displayName: "Variables",
-                      name: "variables",
-                      type: "json",
-                      default: "{}",
-                      description: "Variables to be substituted into the prompt template"
-                    }
-                  ]
-                }
-              ],
-              displayOptions: {
-                show: {
-                  "@version": [{ _cnd: { gte: 1.3 } }],
-                  "/responsesApiEnabled": [true]
-                }
-              }
+                    displayName: 'Options',
+                    name: 'options',
+                    placeholder: 'Add Option',
+                    description: 'Additional options to add',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Base URL',
+                            name: 'baseURL',
+                            default: 'https://api.openai.com/v1',
+                            description: 'Override the default base URL for the API',
+                            type: 'string',
+                            displayOptions: {
+                                hide: {
+                                    '@version': [{ _cnd: { gte: 1.1 } }],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Frequency Penalty',
+                            name: 'frequencyPenalty',
+                            default: 0,
+                            typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
+                            description: "Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim",
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Maximum Number of Tokens',
+                            name: 'maxTokens',
+                            default: -1,
+                            description: 'The maximum number of tokens to generate in the completion. Most models have a context length of 2048 tokens (except for the newest models, which support 32,768).',
+                            type: 'number',
+                            typeOptions: {
+                                maxValue: 32768,
+                            },
+                        },
+                        {
+                            ...completionsResponseFormat,
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { lt: 1.3 } }],
+                                },
+                            },
+                        },
+                        {
+                            ...completionsResponseFormat,
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [false],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Response Format',
+                            name: 'textFormat',
+                            type: 'fixedCollection',
+                            default: { textOptions: [{ type: 'text' }] },
+                            options: [
+                                {
+                                    displayName: 'Text',
+                                    name: 'textOptions',
+                                    values: [
+                                        {
+                                            displayName: 'Type',
+                                            name: 'type',
+                                            type: 'options',
+                                            default: '',
+                                            options: [
+                                                { name: 'Text', value: 'text' },
+                                                { name: 'JSON Schema (recommended)', value: 'json_schema' },
+                                                { name: 'JSON Object', value: 'json_object' },
+                                            ],
+                                        },
+                                        {
+                                            displayName: 'Verbosity',
+                                            name: 'verbosity',
+                                            type: 'options',
+                                            default: 'medium',
+                                            options: [
+                                                { name: 'Low', value: 'low' },
+                                                { name: 'Medium', value: 'medium' },
+                                                { name: 'High', value: 'high' },
+                                            ],
+                                        },
+                                        {
+                                            displayName: 'Name',
+                                            name: 'name',
+                                            type: 'string',
+                                            default: 'my_schema',
+                                            description: 'The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.',
+                                            displayOptions: {
+                                                show: {
+                                                    type: ['json_schema'],
+                                                },
+                                            },
+                                        },
+                                        {
+                                            displayName: 'All properties in the schema must be set to "required", when using "strict" mode.',
+                                            name: 'requiredNotice',
+                                            type: 'notice',
+                                            default: '',
+                                            displayOptions: {
+                                                show: {
+                                                    strict: [true],
+                                                },
+                                            },
+                                        },
+                                        {
+                                            displayName: 'Schema',
+                                            name: 'schema',
+                                            type: 'json',
+                                            default: jsonSchemaExample,
+                                            description: 'The schema of the response format',
+                                            displayOptions: {
+                                                show: {
+                                                    type: ['json_schema'],
+                                                },
+                                            },
+                                        },
+                                        {
+                                            displayName: 'Description',
+                                            name: 'description',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'The description of the response format',
+                                            displayOptions: {
+                                                show: {
+                                                    type: ['json_schema'],
+                                                },
+                                            },
+                                        },
+                                        {
+                                            displayName: 'Strict',
+                                            name: 'strict',
+                                            type: 'boolean',
+                                            default: false,
+                                            description: 'Whether to require that the AI will always generate responses that match the provided JSON Schema',
+                                            displayOptions: {
+                                                show: {
+                                                    type: ['json_schema'],
+                                                },
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Presence Penalty',
+                            name: 'presencePenalty',
+                            default: 0,
+                            typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
+                            description: "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics",
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Sampling Temperature',
+                            name: 'temperature',
+                            default: 0.7,
+                            typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
+                            description: 'Controls randomness: Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Reasoning Effort',
+                            name: 'reasoningEffort',
+                            default: 'medium',
+                            description: 'Controls the amount of reasoning tokens to use. A value of "low" will favor speed and economical token usage, "high" will favor more complete reasoning at the cost of more tokens generated and slower responses.',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Low',
+                                    value: 'low',
+                                    description: 'Favors speed and economical token usage',
+                                },
+                                {
+                                    name: 'Medium',
+                                    value: 'medium',
+                                    description: 'Balance between speed and reasoning accuracy',
+                                },
+                                {
+                                    name: 'High',
+                                    value: 'high',
+                                    description: 'Favors more complete reasoning at the cost of more tokens generated and slower responses',
+                                },
+                            ],
+                            displayOptions: {
+                                show: {
+                                    '/model': [{ _cnd: { regex: '(^o1([-\\d]+)?$)|(^o[3-9].*)|(^gpt-5.*)' } }],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Timeout',
+                            name: 'timeout',
+                            default: 60000,
+                            description: 'Maximum amount of time a request is allowed to take in milliseconds',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Max Retries',
+                            name: 'maxRetries',
+                            default: 2,
+                            description: 'Maximum number of retries to attempt',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Top P',
+                            name: 'topP',
+                            default: 1,
+                            typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },
+                            description: 'Controls diversity via nucleus sampling: 0.5 means half of all likelihood-weighted options are considered. We generally recommend altering this or temperature but not both.',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Conversation ID',
+                            name: 'conversationId',
+                            default: '',
+                            description: 'The conversation that this response belongs to. Input items and output items from this response are automatically added to this conversation after this response completes.',
+                            type: 'string',
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Prompt Cache Key',
+                            name: 'promptCacheKey',
+                            type: 'string',
+                            default: '',
+                            description: 'Used by OpenAI to cache responses for similar requests to optimize your cache hit rates',
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Safety Identifier',
+                            name: 'safetyIdentifier',
+                            type: 'string',
+                            default: '',
+                            description: "A stable identifier used to help detect users of your application that may be violating OpenAI's usage policies. The IDs should be a string that uniquely identifies each user.",
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Service Tier',
+                            name: 'serviceTier',
+                            type: 'options',
+                            default: 'auto',
+                            description: 'The service tier to use for the request',
+                            options: [
+                                { name: 'Auto', value: 'auto' },
+                                { name: 'Flex', value: 'flex' },
+                                { name: 'Default', value: 'default' },
+                                { name: 'Priority', value: 'priority' },
+                            ],
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Metadata',
+                            name: 'metadata',
+                            type: 'json',
+                            description: 'Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format, and querying for objects via API or the dashboard. Keys are strings with a maximum length of 64 characters. Values are strings with a maximum length of 512 characters.',
+                            default: '{}',
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Top Logprobs',
+                            name: 'topLogprobs',
+                            type: 'number',
+                            default: 0,
+                            description: 'An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability',
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 20,
+                            },
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Prompt',
+                            name: 'promptConfig',
+                            type: 'fixedCollection',
+                            description: 'Configure the reusable prompt template configured via OpenAI Dashboard. <a href="https://platform.openai.com/docs/guides/prompt-engineering#reusable-prompts">Learn more</a>.',
+                            default: { promptOptions: [{ promptId: '' }] },
+                            options: [
+                                {
+                                    displayName: 'Prompt',
+                                    name: 'promptOptions',
+                                    values: [
+                                        {
+                                            displayName: 'Prompt ID',
+                                            name: 'promptId',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'The unique identifier of the prompt template to use',
+                                        },
+                                        {
+                                            displayName: 'Version',
+                                            name: 'version',
+                                            type: 'string',
+                                            default: '',
+                                            description: 'Optional version of the prompt template',
+                                        },
+                                        {
+                                            displayName: 'Variables',
+                                            name: 'variables',
+                                            type: 'json',
+                                            default: '{}',
+                                            description: 'Variables to be substituted into the prompt template',
+                                        },
+                                    ],
+                                },
+                            ],
+                            displayOptions: {
+                                show: {
+                                    '@version': [{ _cnd: { gte: 1.3 } }],
+                                    '/responsesApiEnabled': [true],
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        const credentials = await this.getCredentials('openAiApi');
+        const version = this.getNode().typeVersion;
+        const modelName = version >= 1.2
+            ? this.getNodeParameter('model.value', itemIndex)
+            : this.getNodeParameter('model', itemIndex);
+        const responsesApiEnabled = this.getNodeParameter('responsesApiEnabled', itemIndex, false);
+        const options = this.getNodeParameter('options', itemIndex, {});
+        const { openAiDefaultHeaders: defaultHeaders } = di_1.Container.get(config_1.AiConfig);
+        const configuration = {
+            defaultHeaders,
+        };
+        if (options.baseURL) {
+            configuration.baseURL = options.baseURL;
+        }
+        else if (credentials.url) {
+            configuration.baseURL = credentials.url;
+        }
+        const timeout = options.timeout;
+        configuration.fetchOptions = {
+            dispatcher: (0, httpProxyAgent_1.getProxyAgent)(configuration.baseURL ?? 'https://api.openai.com/v1', {
+                headersTimeout: timeout,
+                bodyTimeout: timeout,
+            }),
+        };
+        if (credentials.header &&
+            typeof credentials.headerName === 'string' &&
+            credentials.headerName &&
+            typeof credentials.headerValue === 'string') {
+            configuration.defaultHeaders = {
+                ...configuration.defaultHeaders,
+                [credentials.headerName]: credentials.headerValue,
+            };
+        }
+        const modelKwargs = {};
+        if (responsesApiEnabled) {
+            const kwargs = (0, common_1.prepareAdditionalResponsesParams)(options);
+            Object.assign(modelKwargs, kwargs);
+        }
+        else {
+            if (options.responseFormat)
+                modelKwargs.response_format = { type: options.responseFormat };
+            if (options.reasoningEffort && ['low', 'medium', 'high'].includes(options.reasoningEffort)) {
+                modelKwargs.reasoning_effort = options.reasoningEffort;
             }
-          ]
         }
-      ]
-    };
-  }
-  async supplyData(itemIndex) {
-    const credentials = await this.getCredentials("openAiApi");
-    const version = this.getNode().typeVersion;
-    const modelName = version >= 1.2 ? this.getNodeParameter("model.value", itemIndex) : this.getNodeParameter("model", itemIndex);
-    const responsesApiEnabled = this.getNodeParameter("responsesApiEnabled", itemIndex, false);
-    const options = this.getNodeParameter("options", itemIndex, {});
-    const { openAiDefaultHeaders: defaultHeaders } = import_di.Container.get(import_config.AiConfig);
-    const configuration = {
-      defaultHeaders
-    };
-    if (options.baseURL) {
-      configuration.baseURL = options.baseURL;
-    } else if (credentials.url) {
-      configuration.baseURL = credentials.url;
-    }
-    const timeout = options.timeout;
-    configuration.fetchOptions = {
-      dispatcher: (0, import_httpProxyAgent.getProxyAgent)(configuration.baseURL ?? "https://api.openai.com/v1", {
-        headersTimeout: timeout,
-        bodyTimeout: timeout
-      })
-    };
-    if (credentials.header && typeof credentials.headerName === "string" && credentials.headerName && typeof credentials.headerValue === "string") {
-      configuration.defaultHeaders = {
-        ...configuration.defaultHeaders,
-        [credentials.headerName]: credentials.headerValue
-      };
-    }
-    const modelKwargs = {};
-    if (responsesApiEnabled) {
-      const kwargs = (0, import_common.prepareAdditionalResponsesParams)(options);
-      Object.assign(modelKwargs, kwargs);
-    } else {
-      if (options.responseFormat) modelKwargs.response_format = { type: options.responseFormat };
-      if (options.reasoningEffort && ["low", "medium", "high"].includes(options.reasoningEffort)) {
-        modelKwargs.reasoning_effort = options.reasoningEffort;
-      }
-    }
-    const includedOptions = (0, import_pick.default)(options, [
-      "frequencyPenalty",
-      "maxTokens",
-      "presencePenalty",
-      "temperature",
-      "topP",
-      "baseURL"
-    ]);
-    const fields = {
-      apiKey: credentials.apiKey,
-      model: modelName,
-      ...includedOptions,
-      timeout,
-      maxRetries: options.maxRetries ?? 2,
-      configuration,
-      callbacks: [new import_N8nLlmTracing.N8nLlmTracing(this)],
-      modelKwargs,
-      onFailedAttempt: (0, import_n8nLlmFailedAttemptHandler.makeN8nLlmFailedAttemptHandler)(this, import_error_handling.openAiFailedAttemptHandler),
-      // Set to false to ensure compatibility with OpenAI-compatible backends (LM Studio, vLLM, etc.)
-      // that reject strict: null in tool definitions
-      supportsStrictToolCalling: false
-    };
-    if (responsesApiEnabled) {
-      fields.useResponsesApi = true;
-    }
-    const model = new import_openai.ChatOpenAI(fields);
-    if (responsesApiEnabled) {
-      const tools = (0, import_common.formatBuiltInTools)(
-        this.getNodeParameter("builtInTools", itemIndex, {})
-      );
-      if (tools.length) {
-        model.metadata = {
-          ...model.metadata,
-          tools
+        const includedOptions = (0, pick_1.default)(options, [
+            'frequencyPenalty',
+            'maxTokens',
+            'presencePenalty',
+            'temperature',
+            'topP',
+            'baseURL',
+        ]);
+        const fields = {
+            apiKey: credentials.apiKey,
+            model: modelName,
+            ...includedOptions,
+            timeout,
+            maxRetries: options.maxRetries ?? 2,
+            configuration,
+            callbacks: [new N8nLlmTracing_1.N8nLlmTracing(this)],
+            modelKwargs,
+            onFailedAttempt: (0, n8nLlmFailedAttemptHandler_1.makeN8nLlmFailedAttemptHandler)(this, error_handling_1.openAiFailedAttemptHandler),
+            supportsStrictToolCalling: false,
+        };
+        if (responsesApiEnabled) {
+            fields.useResponsesApi = true;
+        }
+        const model = new openai_1.ChatOpenAI(fields);
+        if (responsesApiEnabled) {
+            const tools = (0, common_1.formatBuiltInTools)(this.getNodeParameter('builtInTools', itemIndex, {}));
+            if (tools.length) {
+                model.metadata = {
+                    ...model.metadata,
+                    tools,
+                };
+            }
+        }
+        return {
+            response: model,
         };
-      }
     }
-    return {
-      response: model
-    };
-  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LmChatOpenAi
-});
+exports.LmChatOpenAi = LmChatOpenAi;
 //# sourceMappingURL=LmChatOpenAi.node.js.map