@n8n/n8n-nodes-langchain 1.115.0 → 1.116.0

package/dist/nodes/vendors/OpenAi/v2/actions/text/response.operation.js

@@ -0,0 +1,777 @@
+"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 __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 response_operation_exports = {};
+__export(response_operation_exports, {
+  description: () => description,
+  execute: () => execute
+});
+module.exports = __toCommonJS(response_operation_exports);
+var import_helpers = require("../../../../../../utils/helpers");
+var import_get = __toESM(require("lodash/get"));
+var import_n8n_workflow = require("n8n-workflow");
+var import_constants = require("../../../helpers/constants");
+var import_utils = require("../../../helpers/utils");
+var import_polling = require("../../../helpers/polling");
+var import_transport = require("../../../transport");
+var import_descriptions = require("../descriptions");
+var import_responses = require("./helpers/responses");
+const properties = [
+  (0, import_descriptions.modelRLC)("modelSearch"),
+  {
+    displayName: "Messages",
+    name: "responses",
+    type: "fixedCollection",
+    typeOptions: {
+      sortable: true,
+      multipleValues: true
+    },
+    placeholder: "Add Message",
+    default: { values: [{ type: "text" }] },
+    options: import_descriptions.messageOptions
+  },
+  {
+    displayName: "Simplify Output",
+    name: "simplify",
+    type: "boolean",
+    default: true,
+    description: "Whether to return a simplified version of the response instead of the raw data"
+  },
+  {
+    displayName: "Hide Tools",
+    name: "hideTools",
+    type: "hidden",
+    default: "hide",
+    displayOptions: {
+      show: {
+        modelId: import_constants.MODELS_NOT_SUPPORT_FUNCTION_CALLS
+      }
+    }
+  },
+  {
+    displayName: "Connect your own custom n8n tools to this node on the canvas",
+    name: "noticeTools",
+    type: "notice",
+    default: "",
+    displayOptions: {
+      hide: {
+        hideTools: ["hide"]
+      }
+    }
+  },
+  {
+    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",
+            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: "MCP Servers",
+        name: "mcpServers",
+        type: "fixedCollection",
+        placeholder: "Add MCP Server",
+        typeOptions: {
+          multipleValues: true,
+          sortable: true
+        },
+        default: { mcpServerOptions: [{ serverLabel: "" }] },
+        options: [
+          {
+            displayName: "MCP Server",
+            name: "mcpServerOptions",
+            values: [
+              {
+                displayName: "Server Label",
+                name: "serverLabel",
+                type: "string",
+                default: "",
+                description: "A label to identify this MCP server",
+                placeholder: "e.g. My Database Server"
+              },
+              {
+                displayName: "Connection Type",
+                name: "connectionType",
+                type: "options",
+                default: "url",
+                options: [
+                  { name: "URL", value: "url" },
+                  { name: "Connector ID", value: "connector_id" }
+                ],
+                description: "Choose how to connect to the MCP server"
+              },
+              {
+                displayName: "Server URL",
+                name: "serverUrl",
+                type: "string",
+                default: "",
+                description: "The URL of the MCP server",
+                placeholder: "e.g. https://api.example.com/mcp",
+                displayOptions: {
+                  show: {
+                    connectionType: ["url"]
+                  }
+                }
+              },
+              {
+                displayName: "Connector ID",
+                name: "connectorId",
+                type: "string",
+                default: "",
+                description: "The connector ID for the MCP server",
+                placeholder: "e.g. connector_gmail",
+                displayOptions: {
+                  show: {
+                    connectionType: ["connector_id"]
+                  }
+                }
+              },
+              {
+                displayName: "Authorization",
+                name: "authorization",
+                type: "string",
+                default: "",
+                description: "Authorization token or credentials for the MCP server"
+              },
+              {
+                displayName: "Headers",
+                name: "headers",
+                type: "json",
+                default: "{}",
+                description: "Additional headers to send with requests to the MCP server",
+                placeholder: '{"X-Custom-Header": "value"}'
+              },
+              {
+                displayName: "Server Description",
+                name: "serverDescription",
+                type: "string",
+                default: "",
+                description: "A description of what this MCP server provides",
+                placeholder: "e.g. Database access for user management",
+                typeOptions: {
+                  rows: 2
+                }
+              },
+              {
+                displayName: "Allowed Tools",
+                name: "allowedTools",
+                type: "string",
+                default: "",
+                description: "Comma-separated list of tools to allow. If not provided, all tools will be allowed.",
+                placeholder: "e.g. tool1,tool2"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        displayName: "File Search",
+        name: "fileSearch",
+        type: "collection",
+        default: { vectorStoreIds: "[]" },
+        options: [
+          {
+            displayName: "Vector Store IDs",
+            name: "vectorStoreIds",
+            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 local environment"
+      }
+    ]
+  },
+  {
+    displayName: "Options",
+    name: "options",
+    placeholder: "Add Option",
+    type: "collection",
+    default: {},
+    options: [
+      {
+        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"
+      },
+      {
+        displayName: "Include Additional Data",
+        name: "include",
+        default: [],
+        type: "multiOptions",
+        description: "Specify additional output data to include in the model response",
+        options: [
+          {
+            name: "Code Interpreter Call Outputs",
+            value: "code_interpreter_call.outputs"
+          },
+          {
+            name: "Computer Call Output Image URL",
+            value: "computer_call_output.output.image_url"
+          },
+          {
+            name: "File Search Call Results",
+            value: "file_search_call.results"
+          },
+          {
+            name: "Message Input Image URL",
+            value: "message.input_image.image_url"
+          },
+          {
+            name: "Message Output Text Logprobs",
+            value: "message.output_text.logprobs"
+          },
+          {
+            name: "Reasoning Encrypted Content",
+            value: "reasoning.encrypted_content"
+          },
+          {
+            name: "Web Search Tool Call Sources",
+            value: "web_search_call.action.sources"
+          }
+        ]
+      },
+      {
+        displayName: "Instructions",
+        name: "instructions",
+        type: "string",
+        default: "",
+        description: "Instructions for the model to follow",
+        typeOptions: {
+          rows: 2
+        }
+      },
+      {
+        displayName: "Maximum Number of Tokens",
+        name: "maxTokens",
+        default: 16,
+        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
+        }
+      },
+      {
+        displayName: "Max Tool Calls Iterations",
+        name: "maxToolsIterations",
+        type: "number",
+        default: 15,
+        description: "The maximum number of tool iteration cycles the LLM will run before stopping. A single iteration can contain multiple tool calls. Set to 0 for no limit."
+      },
+      {
+        displayName: "Max Built-in Tool Calls",
+        name: "maxToolCalls",
+        type: "number",
+        default: 15,
+        description: "The maximum number of total calls to built-in tools that can be processed in a response. This maximum number applies across all built-in tool calls, not per individual tool. Any further attempts to call a tool by the model will be ignored."
+      },
+      import_descriptions.metadataProperty,
+      {
+        displayName: "Parallel Tool Calls",
+        name: "parallelToolCalls",
+        type: "boolean",
+        default: false,
+        description: "Whether to allow parallel tool calls. If true, the model can call multiple tools at once."
+      },
+      {
+        displayName: "Previous Response ID",
+        name: "previousResponseId",
+        type: "string",
+        default: "",
+        // TODO: add display options?
+        description: "The ID of the previous response to continue from. Cannot be used in conjunction with Conversation ID."
+      },
+      {
+        displayName: "Prompt",
+        name: "promptConfig",
+        type: "fixedCollection",
+        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"
+              }
+            ]
+          }
+        ]
+      },
+      {
+        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"
+      },
+      {
+        displayName: "Reasoning",
+        name: "reasoning",
+        type: "fixedCollection",
+        default: { reasoningOptions: [{ effort: "medium", summary: "none" }] },
+        options: [
+          {
+            displayName: "Reasoning",
+            name: "reasoningOptions",
+            values: [
+              {
+                displayName: "Effort",
+                name: "effort",
+                type: "options",
+                default: "medium",
+                // TODO: allow only high for gpt-5-pro
+                options: [
+                  { name: "Low", value: "low" },
+                  { name: "Medium", value: "medium" },
+                  { name: "High", value: "high" }
+                ]
+              },
+              {
+                displayName: "Summary",
+                name: "summary",
+                type: "options",
+                default: "auto",
+                description: "A summary of the reasoning performed by the model. This can be useful for debugging and understanding the model's reasoning process.",
+                options: [
+                  { name: "None", value: "none" },
+                  { name: "Auto", value: "auto" },
+                  { name: "Concise", value: "concise" },
+                  { name: "Detailed", value: "detailed" }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      {
+        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."
+      },
+      {
+        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" }
+        ]
+      },
+      {
+        displayName: "Store",
+        name: "store",
+        type: "boolean",
+        default: true,
+        description: "Whether to store the generated model response for later retrieval via API"
+      },
+      {
+        displayName: "Output Format",
+        name: "textFormat",
+        type: "fixedCollection",
+        default: { textOptions: [{ type: "text" }] },
+        options: [
+          {
+            displayName: "Text",
+            name: "textOptions",
+            values: [
+              {
+                displayName: "Type",
+                name: "type",
+                type: "options",
+                default: "text",
+                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: "",
+                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: "Schema",
+                name: "schema",
+                type: "json",
+                default: "",
+                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 enforce the response format strictly",
+                displayOptions: {
+                  show: {
+                    type: ["json_schema"]
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      },
+      {
+        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
+        }
+      },
+      {
+        displayName: "Output Randomness (Temperature)",
+        name: "temperature",
+        type: "number",
+        default: 1,
+        description: "What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or top_p but not both",
+        typeOptions: {
+          minValue: 0,
+          maxValue: 2,
+          numberPrecision: 1
+        }
+      },
+      {
+        displayName: "Output Randomness (Top P)",
+        name: "topP",
+        default: 1,
+        typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },
+        description: "An alternative to sampling with temperature, 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: "Truncation",
+        name: "truncation",
+        type: "boolean",
+        default: false,
+        description: "Whether to truncate the input to the model's context window size. When disabled will throw a 400 error instead."
+      },
+      {
+        displayName: "Background Mode",
+        name: "backgroundMode",
+        type: "fixedCollection",
+        default: { values: [{ backgroundMode: true }] },
+        options: [
+          {
+            displayName: "Bakground",
+            name: "values",
+            values: [
+              {
+                displayName: "Background Mode",
+                name: "enabled",
+                type: "boolean",
+                default: false,
+                description: "Whether to run the model in background mode. If true, the model will run in background mode."
+              },
+              {
+                displayName: "Timeout",
+                name: "timeout",
+                type: "number",
+                default: 300,
+                description: "The timeout for the background mode in seconds. If 0, the timeout is infinite.",
+                typeOptions: {
+                  minValue: 0,
+                  maxValue: 3600
+                }
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+];
+const displayOptions = {
+  show: {
+    operation: ["response"],
+    resource: ["text"]
+  }
+};
+const description = (0, import_n8n_workflow.updateDisplayOptions)(displayOptions, properties);
+async function execute(i) {
+  const model = this.getNodeParameter("modelId", i, "", { extractValue: true });
+  const messages = this.getNodeParameter("responses.values", i, []);
+  const options = this.getNodeParameter("options", i, {});
+  const maxToolsIterations = this.getNodeParameter("options.maxToolsIterations", i, 15);
+  const builtInTools = this.getNodeParameter("builtInTools", i, {});
+  const abortSignal = this.getExecutionCancelSignal();
+  const hideTools = this.getNodeParameter("hideTools", i, "");
+  let tools;
+  let externalTools = [];
+  if (hideTools !== "hide") {
+    const enforceUniqueNames = true;
+    externalTools = await (0, import_helpers.getConnectedTools)(this, enforceUniqueNames, false);
+  }
+  if (externalTools.length) {
+    tools = externalTools.length ? externalTools?.map(import_utils.formatToOpenAIResponsesTool) : void 0;
+  }
+  const body = await import_responses.createRequest.call(this, i, {
+    model,
+    messages,
+    options,
+    tools,
+    builtInTools
+  });
+  let response = await import_transport.apiRequest.call(this, "POST", "/responses", {
+    body
+  });
+  if (body.background) {
+    const timeoutSeconds = (0, import_get.default)(options, "backgroundMode.values.timeout", 300);
+    response = await (0, import_polling.pollUntilAvailable)(
+      this,
+      async () => {
+        return await import_transport.apiRequest.call(this, "GET", `/responses/${response.id}`);
+      },
+      (response2) => {
+        if (response2.error) {
+          throw new import_n8n_workflow.NodeOperationError(this.getNode(), "Background mode error", {
+            description: response2.error.message
+          });
+        }
+        return response2.status === "completed";
+      },
+      timeoutSeconds,
+      10
+    );
+  }
+  if (!response) return [];
+  const isToolRelatedCall = (item) => item.type === "function_call" || item.type === "reasoning";
+  let toolCalls = response.output.filter(isToolRelatedCall);
+  const hasFunctionCall = () => toolCalls.some((item) => item.type === "function_call");
+  const answeredToolCalls = /* @__PURE__ */ new Set();
+  let currentIteration = 1;
+  while (toolCalls.length && hasFunctionCall()) {
+    if (abortSignal?.aborted || maxToolsIterations > 0 && currentIteration > maxToolsIterations) {
+      break;
+    }
+    for (const item of toolCalls) {
+      if (item.type === "function_call" && answeredToolCalls.has(item.call_id)) {
+        continue;
+      }
+      body.input.push(item);
+      if (item.type === "function_call") {
+        const functionName = item.name;
+        const functionArgs = item.arguments;
+        const callId = item.call_id;
+        let functionResponse;
+        for (const tool of externalTools ?? []) {
+          if (tool.name === functionName) {
+            const parsedArgs = (0, import_n8n_workflow.jsonParse)(functionArgs);
+            const functionInput = parsedArgs.input ?? parsedArgs ?? functionArgs;
+            functionResponse = await tool.invoke(functionInput);
+          }
+          if (typeof functionResponse === "object") {
+            functionResponse = JSON.stringify(functionResponse);
+          }
+        }
+        body.input.push({
+          type: "function_call_output",
+          call_id: callId,
+          output: functionResponse
+        });
+        answeredToolCalls.add(callId);
+      }
+    }
+    response = await import_transport.apiRequest.call(this, "POST", "/responses", {
+      body
+    });
+    toolCalls = response.output.filter(isToolRelatedCall);
+    currentIteration++;
+  }
+  const formatType = (0, import_get.default)(body, "text.format.type");
+  if (formatType === "json_object" || formatType === "json_schema") {
+    try {
+      response.output = response.output.map((item) => {
+        if (item.type === "message") {
+          item.content = item.content.map((content) => {
+            if (content.type === "output_text") {
+              content.text = JSON.parse(content.text);
+            }
+            return content;
+          });
+        }
+        return item;
+      });
+    } catch (error) {
+    }
+  }
+  const simplify = this.getNodeParameter("simplify", i);
+  const returnData = [];
+  if (simplify) {
+    const messages2 = response.output.filter((item) => item.type === "message");
+    returnData.push({
+      json: {
+        output: messages2
+      },
+      pairedItem: { item: i }
+    });
+  } else {
+    returnData.push({ json: response, pairedItem: { item: i } });
+  }
+  return returnData;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  description,
+  execute
+});
+//# sourceMappingURL=response.operation.js.map