@n8n/n8n-nodes-langchain 2.18.2 → 2.18.4

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

@@ -0,0 +1,31 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=conversation, operation=get
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Get a conversation */
+export type LcOpenAiV23ConversationGetParams = {
+  resource: 'conversation';
+  operation: 'get';
+/**
+ * The ID of the conversation to retrieve
+ */
+    conversationId?: string | Expression<string> | PlaceholderValue;
+};
+
+export interface LcOpenAiV23ConversationGetSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23ConversationGetNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23ConversationGetParams> & { subnodes?: LcOpenAiV23ConversationGetSubnodeConfig };
+};

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

@@ -0,0 +1,29 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=conversation, operation=remove
+ *
+ * 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('remove'),
+      conversationId: stringOrExpression.optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

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

@@ -0,0 +1,31 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=conversation, operation=remove
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Remove a conversation */
+export type LcOpenAiV23ConversationRemoveParams = {
+  resource: 'conversation';
+  operation: 'remove';
+/**
+ * The ID of the conversation to delete
+ */
+    conversationId?: string | Expression<string> | PlaceholderValue;
+};
+
+export interface LcOpenAiV23ConversationRemoveSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23ConversationRemoveNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23ConversationRemoveParams> & { subnodes?: LcOpenAiV23ConversationRemoveSubnodeConfig };
+};

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

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=conversation, operation=update
+ *
+ * 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('update'),
+      conversationId: stringOrExpression.optional(),
+      metadata: z.union([iDataObjectSchema, z.string()]).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

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

@@ -0,0 +1,36 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=conversation, operation=update
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Update a conversation */
+export type LcOpenAiV23ConversationUpdateParams = {
+  resource: 'conversation';
+  operation: 'update';
+/**
+ * The ID of the conversation to update
+ */
+    conversationId?: string | Expression<string> | PlaceholderValue;
+/**
+ * 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 LcOpenAiV23ConversationUpdateSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23ConversationUpdateNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23ConversationUpdateParams> & { subnodes?: LcOpenAiV23ConversationUpdateSubnodeConfig };
+};

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

@@ -0,0 +1,24 @@
+/**
+ * OpenAI - File 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 getDeleteFileSchema = require('./operation_delete_file.schema');
+const getListSchema = require('./operation_list.schema');
+const getUploadSchema = require('./operation_upload.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([
+    getDeleteFileSchema({ ...helpers, parameters: effectiveParams }),
+    getListSchema({ ...helpers, parameters: effectiveParams }),
+    getUploadSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

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

@@ -0,0 +1,18 @@
+/**
+ * OpenAI - File Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcOpenAiV23FileDeleteFileNode } from './operation_delete_file';
+import type { LcOpenAiV23FileListNode } from './operation_list';
+import type { LcOpenAiV23FileUploadNode } from './operation_upload';
+
+export * from './operation_delete_file';
+export * from './operation_list';
+export * from './operation_upload';
+
+export type LcOpenAiV23FileNode =
+  | LcOpenAiV23FileDeleteFileNode
+  | LcOpenAiV23FileListNode
+  | LcOpenAiV23FileUploadNode
+  ;

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

@@ -0,0 +1,29 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=file, operation=deleteFile
+ *
+ * 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('file'),
+      operation: z.literal('deleteFile'),
+      fileId: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

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

@@ -0,0 +1,33 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=file, operation=deleteFile
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Delete a file from the server */
+export type LcOpenAiV23FileDeleteFileParams = {
+  resource: 'file';
+  operation: 'deleteFile';
+/**
+ * File
+ * @searchListMethod fileSearch
+ * @default {"mode":"list","value":""}
+ */
+    fileId?: { __rl: true; mode: 'list' | 'id'; value: string; cachedResultName?: string };
+};
+
+export interface LcOpenAiV23FileDeleteFileSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23FileDeleteFileNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23FileDeleteFileParams> & { subnodes?: LcOpenAiV23FileDeleteFileSubnodeConfig };
+};

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

@@ -0,0 +1,29 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=file, operation=list
+ *
+ * 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('file'),
+      operation: z.literal('list'),
+      options: z.object({ purpose: z.union([z.literal('any'), z.literal('assistants'), z.literal('fine-tune'), z.literal('vision'), z.literal('user_data'), expressionSchema]).optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

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

@@ -0,0 +1,37 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=file, operation=list
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Returns a list of files that belong to the user's organization */
+export type LcOpenAiV23FileListParams = {
+  resource: 'file';
+  operation: 'list';
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Only return files with the given purpose
+     * @default any
+     */
+    purpose?: 'any' | 'assistants' | 'fine-tune' | 'vision' | 'user_data' | Expression<string>;
+  };
+};
+
+export interface LcOpenAiV23FileListSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23FileListNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23FileListParams> & { subnodes?: LcOpenAiV23FileListSubnodeConfig };
+};

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

@@ -0,0 +1,30 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=file, operation=upload
+ *
+ * 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('file'),
+      operation: z.literal('upload'),
+      binaryPropertyName: stringOrExpression.optional(),
+      options: z.object({ purpose: z.union([z.literal('assistants'), z.literal('fine-tune'), z.literal('vision'), z.literal('user_data'), expressionSchema]).optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

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

@@ -0,0 +1,43 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=file, operation=upload
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Upload a file that can be used across various endpoints */
+export type LcOpenAiV23FileUploadParams = {
+  resource: 'file';
+  operation: 'upload';
+/**
+ * Name of the binary property which contains the file. The size of individual files can be a maximum of 512 MB or 2 million tokens for Assistants.
+ * @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 intended purpose of the uploaded file, the 'Fine-tuning' only supports .jsonl files
+     * @default user_data
+     */
+    purpose?: 'assistants' | 'fine-tune' | 'vision' | 'user_data' | Expression<string>;
+  };
+};
+
+export interface LcOpenAiV23FileUploadSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23FileUploadNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23FileUploadParams> & { subnodes?: LcOpenAiV23FileUploadSubnodeConfig };
+};

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

@@ -0,0 +1,24 @@
+/**
+ * OpenAI - Image 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 getAnalyzeSchema = require('./operation_analyze.schema');
+const getEditSchema = require('./operation_edit.schema');
+const getGenerateSchema = require('./operation_generate.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([
+    getAnalyzeSchema({ ...helpers, parameters: effectiveParams }),
+    getEditSchema({ ...helpers, parameters: effectiveParams }),
+    getGenerateSchema({ ...helpers, parameters: effectiveParams }),
+  ]);
+};

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

@@ -0,0 +1,18 @@
+/**
+ * OpenAI - Image Resource
+ * Re-exports all operation types for this resource.
+ */
+
+import type { LcOpenAiV23ImageAnalyzeNode } from './operation_analyze';
+import type { LcOpenAiV23ImageEditNode } from './operation_edit';
+import type { LcOpenAiV23ImageGenerateNode } from './operation_generate';
+
+export * from './operation_analyze';
+export * from './operation_edit';
+export * from './operation_generate';
+
+export type LcOpenAiV23ImageNode =
+  | LcOpenAiV23ImageAnalyzeNode
+  | LcOpenAiV23ImageEditNode
+  | LcOpenAiV23ImageGenerateNode
+  ;

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

@@ -0,0 +1,35 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=image, operation=analyze
+ *
+ * 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, resolveSchema, 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('image'),
+      operation: z.literal('analyze'),
+      modelId: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), expressionSchema]).optional(),
+      text: stringOrExpression.optional(),
+      inputType: z.union([z.literal('url'), z.literal('base64'), expressionSchema]).optional(),
+      imageUrls: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"inputType":["url"]}}, defaults: {"inputType":"url"} }),
+      binaryPropertyName: resolveSchema({ parameters, schema: stringOrExpression, required: false, displayOptions: {"show":{"inputType":["base64"]}}, defaults: {"inputType":"url"} }),
+      simplify: booleanOrExpression.optional(),
+      options: z.object({ detail: z.union([z.literal('auto'), z.literal('low'), z.literal('high'), expressionSchema]).optional(), maxTokens: numberOrExpression.optional() }).optional(),
+    }).optional(),
+    subnodes: subnodesSchema.optional(),
+  });
+};

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

@@ -0,0 +1,74 @@
+/**
+ * OpenAI Node - Version 2.3
+ * Discriminator: resource=image, operation=analyze
+ */
+
+
+interface Credentials {
+  openAiApi: CredentialReference;
+}
+
+/** Take in images and answer questions about them */
+export type LcOpenAiV23ImageAnalyzeParams = {
+  resource: 'image';
+  operation: 'analyze';
+/**
+ * Model
+ * @searchListMethod imageModelSearch
+ * @default {"mode":"list","value":""}
+ */
+    modelId?: { __rl: true; mode: 'list' | 'id'; value: string; cachedResultName?: string };
+/**
+ * Text Input
+ * @default What's in this image?
+ */
+    text?: string | Expression<string> | PlaceholderValue;
+/**
+ * Input Type
+ * @default url
+ */
+    inputType?: 'url' | 'base64' | Expression<string>;
+/**
+ * URL(s) of the image(s) to analyze, multiple URLs can be added separated by comma
+ * @displayOptions.show { inputType: ["url"] }
+ */
+    imageUrls?: string | Expression<string> | PlaceholderValue;
+/**
+ * Name of the binary property which contains the image(s)
+ * @hint The name of the input field containing the binary file data to be processed
+ * @displayOptions.show { inputType: ["base64"] }
+ * @default data
+ */
+    binaryPropertyName?: string | Expression<string> | PlaceholderValue;
+/**
+ * Whether to simplify the response or not
+ * @default true
+ */
+    simplify?: boolean | Expression<boolean>;
+/**
+ * Options
+ * @default {}
+ */
+    options?: {
+    /** Detail
+     * @default auto
+     */
+    detail?: 'auto' | 'low' | 'high' | Expression<string>;
+    /** Fewer tokens will result in shorter, less detailed image description
+     * @default 300
+     */
+    maxTokens?: number | Expression<number>;
+  };
+};
+
+export interface LcOpenAiV23ImageAnalyzeSubnodeConfig {
+  tools?: ToolInstance[];
+  memory?: MemoryInstance;
+}
+
+export type LcOpenAiV23ImageAnalyzeNode = {
+  type: '@n8n/n8n-nodes-langchain.openAi';
+  version: 2.3;
+  credentials?: Credentials;
+  config: NodeConfig<LcOpenAiV23ImageAnalyzeParams> & { subnodes?: LcOpenAiV23ImageAnalyzeSubnodeConfig };
+};

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

@@ -0,0 +1,39 @@
+/**
+ * OpenAI Node - Version 2.3 - Zod Schema
+ * Discriminator: resource=image, operation=edit
+ *
+ * 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, resolveSchema, 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('image'),
+      operation: z.literal('edit'),
+      modelId: z.union([z.object({ __rl: z.literal(true), mode: z.union([z.literal('list'), z.literal('id')]), value: z.union([z.string(), z.number()]), cachedResultName: z.string().optional(), cachedResultUrl: z.string().optional() }), 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"],"/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"],"/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(),
+  });
+};