@n8n/n8n-nodes-langchain 2.18.2 → 2.18.4

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v21/resource_image/operation_edit.ts

@@ -23,7 +23,7 @@ export type LcOpenAiV21ImageEditParams = {
     prompt?: string | Expression<string> | PlaceholderValue;
 /**
  * Add one or more binary fields to include images with your prompt. Each image should be a png, webp, or jpg file less than 50MB. You can provide up to 16 images.
- * @displayOptions.show { /model: ["gpt-image-1"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default {"values":[{"binaryPropertyName":"data"}]}
  */
     images?: {
@@ -39,7 +39,7 @@ export type LcOpenAiV21ImageEditParams = {
 /**
  * Name of the binary property which contains the image. It should be a square png file less than 4MB.
  * @hint The name of the input field containing the binary file data to be processed
- * @displayOptions.show { /model: ["dall-e-2"] }
+ * @displayOptions.show { /model: ["dall-e-2"], /modelId: [{"_cnd":{"includes":"dall-e"}}] }
  * @default data
  */
     binaryPropertyName?: string | Expression<string> | PlaceholderValue;
@@ -55,25 +55,25 @@ export type LcOpenAiV21ImageEditParams = {
     size?: '256x256' | '512x512' | '1024x1024' | '1024x1536' | '1536x1024' | 'auto' | Expression<string>;
 /**
  * The quality of the image that will be generated
- * @displayOptions.show { /model: ["gpt-image-1"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default auto
  */
     quality?: 'auto' | 'high' | 'medium' | 'low' | 'standard' | Expression<string>;
 /**
  * The format in which the generated images are returned. URLs are only valid for 60 minutes after generation.
- * @displayOptions.show { /model: ["dall-e-2"] }
+ * @displayOptions.show { /model: ["dall-e-2"], /modelId: [{"_cnd":{"includes":"dall-e"}}] }
  * @default url
  */
     responseFormat?: 'url' | 'b64_json' | Expression<string>;
 /**
  * The format in which the generated images are returned. Only supported for gpt-image-1.
- * @displayOptions.show { /model: ["gpt-image-1"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default png
  */
     outputFormat?: 'png' | 'jpeg' | 'webp' | Expression<string>;
 /**
  * The compression level (0-100%) for the generated images. Only supported for gpt-image-1 with webp or jpeg output formats.
- * @displayOptions.show { /model: ["gpt-image-1"], outputFormat: ["webp", "jpeg"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], outputFormat: ["webp", "jpeg"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default 100
  */
     outputCompression?: number | Expression<number>;

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v22/resource_image/operation_edit.schema.js

@@ -24,14 +24,14 @@ module.exports = function getSchema({ parameters, z, expressionSchema, stringOrE
       operation: z.literal('edit'),
       model: z.union([z.literal('dall-e-2'), z.literal('gpt-image-1'), expressionSchema]).optional(),
       prompt: stringOrExpression.optional(),
-      images: resolveSchema({ parameters, schema: z.object({ values: z.array(z.object({ binaryPropertyName: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"/model":["gpt-image-1"]}} }),
-      binaryPropertyName: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"/model":["dall-e-2"]}} }),
+      images: resolveSchema({ parameters, schema: z.object({ values: z.array(z.object({ binaryPropertyName: stringOrExpression.optional() })).optional() }), required: false, displayOptions: {"show":{"/model":["gpt-image-1"],"/modelId":[{"_cnd":{"includes":"gpt-image"}}]}} }),
+      binaryPropertyName: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"/model":["dall-e-2"],"/modelId":[{"_cnd":{"includes":"dall-e"}}]}} }),
       n: numberOrExpression.optional(),
       size: z.union([z.literal('256x256'), z.literal('512x512'), z.literal('1024x1024'), z.literal('1024x1536'), z.literal('1536x1024'), z.literal('auto'), expressionSchema]).optional(),
-      quality: resolveSchema({ parameters, schema: z.union([z.literal('auto'), z.literal('high'), z.literal('medium'), z.literal('low'), z.literal('standard'), expressionSchema]), required: false, displayOptions: {"show":{"/model":["gpt-image-1"]}} }),
-      responseFormat: resolveSchema({ parameters, schema: z.union([z.literal('url'), z.literal('b64_json'), expressionSchema]), required: false, displayOptions: {"show":{"/model":["dall-e-2"]}} }),
-      outputFormat: resolveSchema({ parameters, schema: z.union([z.literal('png'), z.literal('jpeg'), z.literal('webp'), expressionSchema]), required: false, displayOptions: {"show":{"/model":["gpt-image-1"]}} }),
-      outputCompression: resolveSchema({ parameters, schema: numberOrExpression, required: false, displayOptions: {"show":{"/model":["gpt-image-1"],"outputFormat":["webp","jpeg"]}}, defaults: {"outputFormat":"png"} }),
+      quality: resolveSchema({ parameters, schema: z.union([z.literal('auto'), z.literal('high'), z.literal('medium'), z.literal('low'), z.literal('standard'), expressionSchema]), required: false, displayOptions: {"show":{"/model":["gpt-image-1"],"/modelId":[{"_cnd":{"includes":"gpt-image"}}]}} }),
+      responseFormat: resolveSchema({ parameters, schema: z.union([z.literal('url'), z.literal('b64_json'), expressionSchema]), required: false, displayOptions: {"show":{"/model":["dall-e-2"],"/modelId":[{"_cnd":{"includes":"dall-e"}}]}} }),
+      outputFormat: resolveSchema({ parameters, schema: z.union([z.literal('png'), z.literal('jpeg'), z.literal('webp'), expressionSchema]), required: false, displayOptions: {"show":{"/model":["gpt-image-1"],"/modelId":[{"_cnd":{"includes":"gpt-image"}}]}} }),
+      outputCompression: resolveSchema({ parameters, schema: numberOrExpression, required: false, displayOptions: {"show":{"/model":["gpt-image-1"],"outputFormat":["webp","jpeg"],"/modelId":[{"_cnd":{"includes":"gpt-image"}}]}}, defaults: {"outputFormat":"png"} }),
       options: z.object({ user: stringOrExpression.optional(), background: z.union([z.literal('auto'), z.literal('transparent'), z.literal('opaque'), expressionSchema]).optional(), inputFidelity: z.union([z.literal('low'), z.literal('high'), expressionSchema]).optional(), imageMask: stringOrExpression.optional() }).optional(),
     }).optional(),
     subnodes: subnodesSchema.optional(),

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v22/resource_image/operation_edit.ts

@@ -23,7 +23,7 @@ export type LcOpenAiV22ImageEditParams = {
     prompt?: string | Expression<string> | PlaceholderValue;
 /**
  * Add one or more binary fields to include images with your prompt. Each image should be a png, webp, or jpg file less than 50MB. You can provide up to 16 images.
- * @displayOptions.show { /model: ["gpt-image-1"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default {"values":[{"binaryPropertyName":"data"}]}
  */
     images?: {
@@ -39,7 +39,7 @@ export type LcOpenAiV22ImageEditParams = {
 /**
  * Name of the binary property which contains the image. It should be a square png file less than 4MB.
  * @hint The name of the input field containing the binary file data to be processed
- * @displayOptions.show { /model: ["dall-e-2"] }
+ * @displayOptions.show { /model: ["dall-e-2"], /modelId: [{"_cnd":{"includes":"dall-e"}}] }
  * @default data
  */
     binaryPropertyName?: string | Expression<string> | PlaceholderValue;
@@ -55,25 +55,25 @@ export type LcOpenAiV22ImageEditParams = {
     size?: '256x256' | '512x512' | '1024x1024' | '1024x1536' | '1536x1024' | 'auto' | Expression<string>;
 /**
  * The quality of the image that will be generated
- * @displayOptions.show { /model: ["gpt-image-1"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default auto
  */
     quality?: 'auto' | 'high' | 'medium' | 'low' | 'standard' | Expression<string>;
 /**
  * The format in which the generated images are returned. URLs are only valid for 60 minutes after generation.
- * @displayOptions.show { /model: ["dall-e-2"] }
+ * @displayOptions.show { /model: ["dall-e-2"], /modelId: [{"_cnd":{"includes":"dall-e"}}] }
  * @default url
  */
     responseFormat?: 'url' | 'b64_json' | Expression<string>;
 /**
  * The format in which the generated images are returned. Only supported for gpt-image-1.
- * @displayOptions.show { /model: ["gpt-image-1"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default png
  */
     outputFormat?: 'png' | 'jpeg' | 'webp' | Expression<string>;
 /**
  * The compression level (0-100%) for the generated images. Only supported for gpt-image-1 with webp or jpeg output formats.
- * @displayOptions.show { /model: ["gpt-image-1"], outputFormat: ["webp", "jpeg"] }
+ * @displayOptions.show { /model: ["gpt-image-1"], outputFormat: ["webp", "jpeg"], /modelId: [{"_cnd":{"includes":"gpt-image"}}] }
  * @default 100
  */
     outputCompression?: number | Expression<number>;

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/index.schema.js

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema Factory
+ * Exports a factory that unions all discriminator schemas.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getTextSchema = require('./resource_text/index.schema');
+const getImageSchema = require('./resource_image/index.schema');
+const getAudioSchema = require('./resource_audio/index.schema');
+const getFileSchema = require('./resource_file/index.schema');
+const getConversationSchema = require('./resource_conversation/index.schema');
+const getVideoSchema = require('./resource_video/index.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply discriminator default if not set
+  const effectiveParams = parameters.resource === undefined ? { ...parameters, resource: 'text' } : parameters;
+  return z.union([
+    getTextSchema({ ...helpers, parameters: effectiveParams }),
+    getImageSchema({ ...helpers, parameters: effectiveParams }),
+    getAudioSchema({ ...helpers, parameters: effectiveParams }),
+    getFileSchema({ ...helpers, parameters: effectiveParams }),
+    getConversationSchema({ ...helpers, parameters: effectiveParams }),
+    getVideoSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/index.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Re-exports all discriminator combinations.
+ */
+
+import type { LcOpenAiV23TextNode } from './resource_text';
+import type { LcOpenAiV23ImageNode } from './resource_image';
+import type { LcOpenAiV23AudioNode } from './resource_audio';
+import type { LcOpenAiV23FileNode } from './resource_file';
+import type { LcOpenAiV23ConversationNode } from './resource_conversation';
+import type { LcOpenAiV23VideoNode } from './resource_video';
+
+export * from './resource_text';
+export * from './resource_image';
+export * from './resource_audio';
+export * from './resource_file';
+export * from './resource_conversation';
+export * from './resource_video';
+
+export type LcOpenAiV23Node =
+  | LcOpenAiV23TextNode
+  | LcOpenAiV23ImageNode
+  | LcOpenAiV23AudioNode
+  | LcOpenAiV23FileNode
+  | LcOpenAiV23ConversationNode
+  | LcOpenAiV23VideoNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/index.schema.js

@@ -0,0 +1,24 @@
+/**
+ * OpenAI - Audio Resource - Zod Schema Factory
+ * Exports a factory that unions all operation schemas for this resource.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getGenerateSchema = require('./operation_generate.schema');
+const getTranscribeSchema = require('./operation_transcribe.schema');
+const getTranslateSchema = require('./operation_translate.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'generate' } : parameters;
+  return z.union([
+    getGenerateSchema({ ...helpers, parameters: effectiveParams }),
+    getTranscribeSchema({ ...helpers, parameters: effectiveParams }),
+    getTranslateSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/index.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenAI - Audio Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcOpenAiV23AudioGenerateNode } from './operation_generate';
+import type { LcOpenAiV23AudioTranscribeNode } from './operation_transcribe';
+import type { LcOpenAiV23AudioTranslateNode } from './operation_translate';
+
+export * from './operation_generate';
+export * from './operation_transcribe';
+export * from './operation_translate';
+
+export type LcOpenAiV23AudioNode =
+  | LcOpenAiV23AudioGenerateNode
+  | LcOpenAiV23AudioTranscribeNode
+  | LcOpenAiV23AudioTranslateNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/operation_generate.schema.js

@@ -0,0 +1,32 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=audio, operation=generate
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, toolInstanceSchema, memoryInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+    memory: memoryInstanceSchema.optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('audio'),
+      operation: z.literal('generate').default('generate'),
+      model: z.union([z.literal('tts-1'), z.literal('tts-1-hd'), expressionSchema]).optional(),
+      input: stringOrExpression.optional(),
+      voice: z.union([z.literal('alloy'), z.literal('echo'), z.literal('fable'), z.literal('nova'), z.literal('onyx'), z.literal('shimmer'), expressionSchema]).optional(),
+      options: z.object({ response_format: z.union([z.literal('mp3'), z.literal('opus'), z.literal('aac'), z.literal('flac'), expressionSchema]).optional(), speed: numberOrExpression.optional(), binaryPropertyOutput: stringOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/operation_generate.ts

@@ -0,0 +1,60 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=audio, operation=generate
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Creates audio from a text prompt */
+export type LcOpenAiV23AudioGenerateParams = {
+  resource: 'audio';
+  operation: 'generate';
+/**
+ * Model
+ * @default tts-1
+ */
+    model?: 'tts-1' | 'tts-1-hd' | Expression<string>;
+/**
+ * The text to generate audio for. The maximum length is 4096 characters.
+ */
+    input?: string | Expression<string> | PlaceholderValue;
+/**
+ * The voice to use when generating the audio
+ * @default alloy
+ */
+    voice?: 'alloy' | 'echo' | 'fable' | 'nova' | 'onyx' | 'shimmer' | Expression<string>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Response Format
+     * @default mp3
+     */
+    response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | Expression<string>;
+    /** Audio Speed
+     * @default 1
+     */
+    speed?: number | Expression<number>;
+    /** Put Output in Field
+     * @hint The name of the output field to put the binary file data in
+     * @default data
+     */
+    binaryPropertyOutput?: string | Expression<string> | PlaceholderValue;
+  };
+};
+
+export interface LcOpenAiV23AudioGenerateSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23AudioGenerateNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23AudioGenerateParams> & { subnodes?: LcOpenAiV23AudioGenerateSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/operation_transcribe.schema.js

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=audio, operation=transcribe
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, toolInstanceSchema, memoryInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+    memory: memoryInstanceSchema.optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('audio'),
+      operation: z.literal('transcribe'),
+      binaryPropertyName: stringOrExpression.optional(),
+      options: z.object({ language: stringOrExpression.optional(), temperature: numberOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/operation_transcribe.ts

@@ -0,0 +1,46 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=audio, operation=transcribe
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Transcribes audio into text */
+export type LcOpenAiV23AudioTranscribeParams = {
+  resource: 'audio';
+  operation: 'transcribe';
+/**
+ * Name of the binary property which contains the audio file in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm
+ * @hint The name of the input field containing the binary file data to be processed
+ * @default data
+ */
+    binaryPropertyName?: string | Expression<string> | PlaceholderValue;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** The language of the input audio. Supplying the input language in &lt;a href="https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes" target="_blank"&gt;ISO-639-1&lt;/a&gt; format will improve accuracy and latency.
+     */
+    language?: string | Expression<string> | PlaceholderValue;
+    /** Output Randomness (Temperature)
+     * @default 0
+     */
+    temperature?: number | Expression<number>;
+  };
+};
+
+export interface LcOpenAiV23AudioTranscribeSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23AudioTranscribeNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23AudioTranscribeParams> & { subnodes?: LcOpenAiV23AudioTranscribeSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/operation_translate.schema.js

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=audio, operation=translate
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, toolInstanceSchema, memoryInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+    memory: memoryInstanceSchema.optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('audio'),
+      operation: z.literal('translate'),
+      binaryPropertyName: stringOrExpression.optional(),
+      options: z.object({ temperature: numberOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_audio/operation_translate.ts

@@ -0,0 +1,43 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=audio, operation=translate
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Translates audio into text in English */
+export type LcOpenAiV23AudioTranslateParams = {
+  resource: 'audio';
+  operation: 'translate';
+/**
+ * Name of the binary property which contains the audio file in one of these formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm
+ * @hint The name of the input field containing the binary file data to be processed
+ * @default data
+ */
+    binaryPropertyName?: string | Expression<string> | PlaceholderValue;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Output Randomness (Temperature)
+     * @default 0
+     */
+    temperature?: number | Expression<number>;
+  };
+};
+
+export interface LcOpenAiV23AudioTranslateSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23AudioTranslateNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23AudioTranslateParams> & { subnodes?: LcOpenAiV23AudioTranslateSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_conversation/index.schema.js

@@ -0,0 +1,26 @@
+/**
+ * OpenAI - Conversation Resource - Zod Schema Factory
+ * Exports a factory that unions all operation schemas for this resource.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+const getCreateSchema = require('./operation_create.schema');
+const getGetSchema = require('./operation_get.schema');
+const getRemoveSchema = require('./operation_remove.schema');
+const getUpdateSchema = require('./operation_update.schema');
+
+module.exports = function getSchema(helpers) {
+  const { parameters, z } = helpers;
+  // Apply operation default if not set
+  const effectiveParams = parameters.operation === undefined ? { ...parameters, operation: 'generate' } : parameters;
+  return z.union([
+    getCreateSchema({ ...helpers, parameters: effectiveParams }),
+    getGetSchema({ ...helpers, parameters: effectiveParams }),
+    getRemoveSchema({ ...helpers, parameters: effectiveParams }),
+    getUpdateSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_conversation/index.ts

@@ -0,0 +1,21 @@
+/**
+ * OpenAI - Conversation Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcOpenAiV23ConversationCreateNode } from './operation_create';
+import type { LcOpenAiV23ConversationGetNode } from './operation_get';
+import type { LcOpenAiV23ConversationRemoveNode } from './operation_remove';
+import type { LcOpenAiV23ConversationUpdateNode } from './operation_update';
+
+export * from './operation_create';
+export * from './operation_get';
+export * from './operation_remove';
+export * from './operation_update';
+
+export type LcOpenAiV23ConversationNode =
+  | LcOpenAiV23ConversationCreateNode
+  | LcOpenAiV23ConversationGetNode
+  | LcOpenAiV23ConversationRemoveNode
+  | LcOpenAiV23ConversationUpdateNode
+  ;

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_conversation/operation_create.schema.js

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=conversation, operation=create
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, toolInstanceSchema, memoryInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+    memory: memoryInstanceSchema.optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('conversation'),
+      operation: z.literal('create'),
+      messages: z.object({ values: z.array(z.object({ role: z.union([z.literal('user'), z.literal('assistant'), z.literal('system'), expressionSchema]).optional(), content: stringOrExpression.optional() })).optional() }).optional(),
+      options: z.object({ metadata: z.union([iDataObjectSchema, z.string()]).optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_conversation/operation_create.ts

@@ -0,0 +1,54 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=conversation, operation=create
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Create a conversation */
+export type LcOpenAiV23ConversationCreateParams = {
+  resource: 'conversation';
+  operation: 'create';
+/**
+ * Messages
+ * @default {"values":[{"type":"text"}]}
+ */
+    messages?: {
+        /** Message
+     */
+    values?: Array<{
+      /** Role in shaping the model's response, it tells the model how it should behave and interact with the user
+       * @default user
+       */
+      role?: 'user' | 'assistant' | 'system' | Expression<string>;
+      /** The content of the message to be send
+       */
+      content?: string | Expression<string> | PlaceholderValue;
+    }>;
+  };
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** 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 {}
+     */
+    metadata?: IDataObject | string | Expression<string>;
+  };
+};
+
+export interface LcOpenAiV23ConversationCreateSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23ConversationCreateNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23ConversationCreateParams> & { subnodes?: LcOpenAiV23ConversationCreateSubnodeConfig };
+};

package/dist/node-definitions/nodes/n8n-nodes-langchain/openAi/v23/resource_conversation/operation_get.schema.js

@@ -0,0 +1,29 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=conversation, operation=get
+ *
+ * Use .parse() for strict validation or .safeParse() for error handling.
+ *
+ * Schema helpers (z, expressionSchema, etc.) are passed as parameters
+ * by the schema-validator, not imported from external files.
+ *
+ * @generated - CommonJS JavaScript for runtime loading
+ */
+
+module.exports = function getSchema({ parameters, z, expressionSchema, stringOrExpression, numberOrExpression, booleanOrExpression, resourceLocatorValueSchema, resourceMapperValueSchema, filterValueSchema, assignmentCollectionValueSchema, iDataObjectSchema, toolInstanceSchema, memoryInstanceSchema }) {
+
+  // Static subnode schema
+  const subnodesSchema = z.object({
+    tools: z.array(toolInstanceSchema).optional(),
+    memory: memoryInstanceSchema.optional(),
+  }).strict();
+
+  return z.object({
+    parameters: z.object({
+      resource: z.literal('conversation'),
+      operation: z.literal('get'),
+      conversationId: stringOrExpression.optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};