ugcinc 3.85.1 → 3.87.0

package/dist/automations.d.ts

@@ -1,5 +1,20 @@
-import type { NodeControlConfig, NodeCategory, MediaType, NodePort, NodeTypeEnum, WorkflowDefinition, AutomationTemplate, AutomationRun, ExecutorNode, ExecutionEdge, ApiResponse, AutomationExport, AutomationRunExport, PropertySchema } from './types';
+import type { NodeControlConfig, NodeCategory, MediaType, NodePort, NodeTypeEnum, PortType, WorkflowDefinition, AutomationTemplate, AutomationRun, ExecutorNode, ExecutionEdge, ApiResponse, AutomationExport, AutomationRunExport, PropertySchema } from './types';
 import { BaseClient } from './base';
+/**
+ * Check if two port types are compatible for connection
+ * A connection is valid if:
+ * 1. The types match exactly, OR
+ * 2. The source is an array type and target is 'object', OR
+ * 3. The source is a PortType[] and includes the target type, OR
+ * 4. The target is a PortType[] and includes the source type, OR
+ * 5. Both are PortType[] and have at least one common type
+ *
+ * Note: Array inputs are strict - they only accept exact matches
+ */
+export declare function areTypesCompatible({ sourceType, targetType, }: {
+    sourceType: PortType | PortType[];
+    targetType: PortType | PortType[];
+}): boolean;
 export declare class AutomationsClient extends BaseClient {
     /**
      * List all automation templates for an organization

package/dist/automations.js

@@ -1,10 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutomationsClient = void 0;
+exports.areTypesCompatible = areTypesCompatible;
 exports.getAllNodes = getAllNodes;
 exports.getNodeByType = getNodeByType;
 exports.getOutputSchema = getOutputSchema;
 const base_1 = require("./base");
+/**
+ * Array types for collections
+ */
+const ARRAY_TYPES = ['image[]', 'video[]', 'audio[]', 'text[]', 'object[]', 'account[]', 'social_audio[]', 'boolean[]'];
+/**
+ * Check if two port types are compatible for connection
+ * A connection is valid if:
+ * 1. The types match exactly, OR
+ * 2. The source is an array type and target is 'object', OR
+ * 3. The source is a PortType[] and includes the target type, OR
+ * 4. The target is a PortType[] and includes the source type, OR
+ * 5. Both are PortType[] and have at least one common type
+ *
+ * Note: Array inputs are strict - they only accept exact matches
+ */
+function areTypesCompatible({ sourceType, targetType, }) {
+    const sourceTypes = Array.isArray(sourceType) ? sourceType : [sourceType];
+    const targetTypes = Array.isArray(targetType) ? targetType : [targetType];
+    return sourceTypes.some(st => {
+        return targetTypes.some(tt => {
+            // Exact match
+            if (st === tt)
+                return true;
+            // Object inputs accept any array type (backwards compatibility with for-each, etc.)
+            if (tt === 'object' && ARRAY_TYPES.includes(st)) {
+                return true;
+            }
+            // Array inputs are strict - no other compatibility
+            if (ARRAY_TYPES.includes(tt)) {
+                return false;
+            }
+            return false;
+        });
+    });
+}
 class AutomationsClient extends base_1.BaseClient {
     /**
      * List all automation templates for an organization

package/dist/index.d.ts

@@ -10,7 +10,9 @@ export { PostsClient } from './posts';
 export { StatsClient } from './stats';
 export { OrganizationClient } from './org';
 export { RenderClient } from './render';
-export { AutomationsClient, getAllNodes, getNodeByType, getOutputSchema } from './automations';
+export { AutomationsClient, getAllNodes, getNodeByType, getOutputSchema, areTypesCompatible } from './automations';
+export { computeInputPorts, computeOutputPorts, isInputPortRequired, extractTemplateVariables } from './ports';
+export type { ComputedPort } from './ports';
 export { NodeTypes, isAsyncExecutor, isEditModel, isImageToVideoModel } from './types';
 export type { PropertySchema } from './automations';
 export { portId, isValidPortId, portIdToTitle, normalizeToPortId, PortIdSchema } from './port-id';

package/dist/index.js

@@ -5,7 +5,7 @@
  * Official TypeScript/JavaScript client for the UGC Inc API
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommentsClient = exports.MediaClient = exports.PortIdSchema = exports.normalizeToPortId = exports.portIdToTitle = exports.isValidPortId = exports.portId = exports.isImageToVideoModel = exports.isEditModel = exports.isAsyncExecutor = exports.NodeTypes = exports.getOutputSchema = exports.getNodeByType = exports.getAllNodes = exports.AutomationsClient = exports.RenderClient = exports.OrganizationClient = exports.StatsClient = exports.PostsClient = exports.TasksClient = exports.AccountsClient = exports.UGCClient = void 0;
+exports.CommentsClient = exports.MediaClient = exports.PortIdSchema = exports.normalizeToPortId = exports.portIdToTitle = exports.isValidPortId = exports.portId = exports.isImageToVideoModel = exports.isEditModel = exports.isAsyncExecutor = exports.NodeTypes = exports.extractTemplateVariables = exports.isInputPortRequired = exports.computeOutputPorts = exports.computeInputPorts = exports.areTypesCompatible = exports.getOutputSchema = exports.getNodeByType = exports.getAllNodes = exports.AutomationsClient = exports.RenderClient = exports.OrganizationClient = exports.StatsClient = exports.PostsClient = exports.TasksClient = exports.AccountsClient = exports.UGCClient = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "UGCClient", { enumerable: true, get: function () { return client_1.UGCClient; } });
 var accounts_1 = require("./accounts");
@@ -25,6 +25,12 @@ Object.defineProperty(exports, "AutomationsClient", { enumerable: true, get: fun
 Object.defineProperty(exports, "getAllNodes", { enumerable: true, get: function () { return automations_1.getAllNodes; } });
 Object.defineProperty(exports, "getNodeByType", { enumerable: true, get: function () { return automations_1.getNodeByType; } });
 Object.defineProperty(exports, "getOutputSchema", { enumerable: true, get: function () { return automations_1.getOutputSchema; } });
+Object.defineProperty(exports, "areTypesCompatible", { enumerable: true, get: function () { return automations_1.areTypesCompatible; } });
+var ports_1 = require("./ports");
+Object.defineProperty(exports, "computeInputPorts", { enumerable: true, get: function () { return ports_1.computeInputPorts; } });
+Object.defineProperty(exports, "computeOutputPorts", { enumerable: true, get: function () { return ports_1.computeOutputPorts; } });
+Object.defineProperty(exports, "isInputPortRequired", { enumerable: true, get: function () { return ports_1.isInputPortRequired; } });
+Object.defineProperty(exports, "extractTemplateVariables", { enumerable: true, get: function () { return ports_1.extractTemplateVariables; } });
 var types_1 = require("./types");
 Object.defineProperty(exports, "NodeTypes", { enumerable: true, get: function () { return types_1.NodeTypes; } });
 Object.defineProperty(exports, "isAsyncExecutor", { enumerable: true, get: function () { return types_1.isAsyncExecutor; } });

package/dist/ports.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Port computation utilities for automation nodes
+ *
+ * These functions dynamically compute input and output ports for nodes
+ * based on their type and configuration. Used by both webapp (for UI rendering)
+ * and API (for validation and execution).
+ */
+import type { PortType, NodeTypeEnum } from './types';
+/**
+ * Computed port definition
+ */
+export interface ComputedPort {
+    id: string;
+    type: PortType | PortType[];
+    required: boolean;
+}
+/**
+ * Extract template variables from text (e.g., "Hello {{name}}" -> ["name"])
+ */
+export declare function extractTemplateVariables(texts: string[]): string[];
+/**
+ * Minimal node interface for port computation
+ * Allows both WorkflowNodeDefinition and webapp's Node type to be used
+ */
+interface NodeLike {
+    id: string;
+    type: NodeTypeEnum;
+    config?: Record<string, unknown>;
+}
+/**
+ * Compute the input ports for a node based on its type and config
+ */
+export declare function computeInputPorts({ node }: {
+    node: NodeLike;
+}): ComputedPort[];
+/**
+ * Compute the output ports for a node based on its type and config
+ */
+export declare function computeOutputPorts({ node }: {
+    node: NodeLike;
+}): ComputedPort[];
+/**
+ * Check if an input port is required for a given node.
+ */
+export declare function isInputPortRequired({ node, portId, }: {
+    node: NodeLike;
+    portId: string;
+}): boolean;
+export {};

package/dist/ports.js

@@ -0,0 +1,470 @@
+"use strict";
+/**
+ * Port computation utilities for automation nodes
+ *
+ * These functions dynamically compute input and output ports for nodes
+ * based on their type and configuration. Used by both webapp (for UI rendering)
+ * and API (for validation and execution).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTemplateVariables = extractTemplateVariables;
+exports.computeInputPorts = computeInputPorts;
+exports.computeOutputPorts = computeOutputPorts;
+exports.isInputPortRequired = isInputPortRequired;
+const automations_1 = require("./automations");
+/**
+ * Extract template variables from text (e.g., "Hello {{name}}" -> ["name"])
+ */
+function extractTemplateVariables(texts) {
+    const variables = new Set();
+    const regex = /\{\{(\w+)\}\}/g;
+    for (const text of texts) {
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            if (match[1])
+                variables.add(match[1]);
+        }
+    }
+    return Array.from(variables);
+}
+/**
+ * Compute the input ports for a node based on its type and config
+ */
+function computeInputPorts({ node }) {
+    const nodeConfigs = (0, automations_1.getAllNodes)();
+    const nodeConfig = nodeConfigs.find(n => n.type === node.type);
+    const baseInputs = nodeConfig?.inputs ?? [];
+    // Text nodes: generate inputs from template variables
+    if (node.type === 'text') {
+        const textOptions = (node.config?.textOptions ?? []);
+        const variables = extractTemplateVariables(textOptions);
+        if (variables.length === 0)
+            return baseInputs;
+        return variables.map(variable => ({
+            id: variable,
+            type: 'text',
+            required: false,
+        }));
+    }
+    // Image-editor nodes: generate inputs from elements
+    if (node.type === 'image-composer') {
+        const editorConfig = node.config?.imageEditor;
+        if (!editorConfig)
+            return baseInputs;
+        const dynamicInputs = [];
+        // Only add background input if backgroundType is 'image'
+        if (editorConfig.backgroundType !== 'color') {
+            dynamicInputs.push({
+                id: 'background',
+                type: 'image',
+                required: true,
+            });
+        }
+        // Add inputs for each element that has an inputId or textInputId
+        editorConfig.elements.forEach(elem => {
+            if (elem.type === 'image' && elem.inputId) {
+                dynamicInputs.push({
+                    id: elem.inputId,
+                    type: 'image',
+                    required: true,
+                });
+            }
+            else if (elem.type === 'text' && elem.textInputId) {
+                dynamicInputs.push({
+                    id: elem.textInputId,
+                    type: 'text',
+                    required: true,
+                });
+            }
+        });
+        // Add crop boundary inputs (not required)
+        const addedCropInputs = new Set();
+        const cropConfig = editorConfig.dynamicCrop;
+        [
+            cropConfig?.vertical?.startBoundary?.inputRef,
+            cropConfig?.vertical?.endBoundary?.inputRef,
+            cropConfig?.horizontal?.startBoundary?.inputRef,
+            cropConfig?.horizontal?.endBoundary?.inputRef,
+        ].forEach(inputRef => {
+            if (inputRef && !addedCropInputs.has(inputRef)) {
+                addedCropInputs.add(inputRef);
+                dynamicInputs.push({
+                    id: inputRef,
+                    type: 'text',
+                    required: false,
+                });
+            }
+        });
+        return dynamicInputs;
+    }
+    // Video-editor nodes: generate inputs from segments
+    if (node.type === 'video-composer') {
+        const editorConfig = node.config?.videoEditor;
+        if (!editorConfig)
+            return [];
+        const dynamicInputs = [];
+        const addedIds = new Set();
+        editorConfig.channels.forEach(channel => {
+            channel.segments.forEach(segment => {
+                if ('inputRef' in segment && segment.inputRef && !addedIds.has(segment.inputRef)) {
+                    addedIds.add(segment.inputRef);
+                    const inputType = segment.type === 'video' ? 'video'
+                        : segment.type === 'audio' ? 'audio'
+                            : 'image';
+                    dynamicInputs.push({
+                        id: segment.inputRef,
+                        type: inputType,
+                        required: true,
+                    });
+                }
+                if ('textInputRef' in segment && segment.textInputRef && !addedIds.has(segment.textInputRef)) {
+                    addedIds.add(segment.textInputRef);
+                    dynamicInputs.push({
+                        id: segment.textInputRef,
+                        type: 'text',
+                        required: true,
+                    });
+                }
+            });
+        });
+        return dynamicInputs;
+    }
+    // Workflow nodes: generate inputs from embedded workflow's variable nodes
+    if (node.type === 'compose-workflow') {
+        const variableNodes = node.config?.workflowVariableNodes;
+        if (!variableNodes || variableNodes.length === 0)
+            return baseInputs;
+        const passThrough = (node.config?.workflowPassThrough ?? {});
+        return variableNodes
+            .filter(v => {
+            const varName = v.name ?? v.id;
+            return !passThrough[varName];
+        })
+            .map(v => ({
+            id: v.id,
+            type: (v.variableType === 'dropdown' ? 'text' : (v.variableType ?? 'text')),
+            required: false,
+        }));
+    }
+    // Output nodes: generate inputs from outputConfig.inputs
+    if (node.type === 'output') {
+        const outputConfig = node.config?.outputConfig;
+        const configInputs = outputConfig?.inputs;
+        if (!configInputs || configInputs.length === 0)
+            return baseInputs;
+        return configInputs.map((input) => ({
+            id: input.id,
+            type: input.type,
+            required: false,
+        }));
+    }
+    // Auto-post nodes: video or slideshow mode
+    if (node.type === 'auto-post') {
+        const autoPostConfig = node.config?.autoPostConfig;
+        const mode = autoPostConfig?.mode ?? 'video';
+        const dynamicInputs = [];
+        if (mode === 'video') {
+            // Video mode: video input required
+            dynamicInputs.push({ id: 'video', type: 'video', required: true });
+        }
+        else {
+            // Slideshow mode
+            const inputType = autoPostConfig?.inputType ?? 'static';
+            if (inputType === 'variable') {
+                // Variable mode: single images array port
+                dynamicInputs.push({ id: 'images', type: 'object', required: true });
+            }
+            else {
+                // Static mode: individual image inputs
+                const imageInputs = autoPostConfig?.inputs ?? [
+                    { id: 'image1' },
+                    { id: 'image2' },
+                    { id: 'image3' },
+                ];
+                imageInputs.forEach((input) => {
+                    dynamicInputs.push({ id: input.id, type: 'image', required: true });
+                });
+            }
+        }
+        // Add static inputs (same for both modes)
+        dynamicInputs.push({ id: 'account', type: 'account', required: true }, { id: 'caption', type: 'text', required: false });
+        // Only add social-audio port if isVariable is true
+        if (autoPostConfig?.socialAudio?.isVariable) {
+            dynamicInputs.push({ id: 'social-audio', type: 'audio', required: false });
+        }
+        return dynamicInputs;
+    }
+    // Save-to-media nodes: generate inputs from saveToMediaConfig.inputs
+    if (node.type === 'save-to-media') {
+        const saveConfig = node.config?.saveToMediaConfig;
+        const configInputs = saveConfig?.inputs;
+        if (!configInputs || configInputs.length === 0)
+            return baseInputs;
+        return configInputs.map((input) => ({
+            id: input.id,
+            type: input.type,
+            required: true,
+        }));
+    }
+    // LLM nodes: generate inputs from systemPrompt variables + media refs
+    if (node.type === 'llm') {
+        const llmConfig = node.config?.llm;
+        const dynamicInputs = [];
+        // Extract {{variables}} from systemPrompt
+        // Variable inputs accept text, object (for JSON data), and boolean types
+        const systemPrompt = llmConfig?.systemPrompt ?? '';
+        const variables = extractTemplateVariables([systemPrompt]);
+        variables.forEach(v => dynamicInputs.push({
+            id: v,
+            type: ['text', 'object', 'boolean'],
+            required: true,
+        }));
+        // Add image input refs
+        llmConfig?.imageInputRefs?.forEach((ref) => dynamicInputs.push({ id: ref, type: 'image', required: true }));
+        // Add video input refs
+        llmConfig?.videoInputRefs?.forEach((ref) => dynamicInputs.push({ id: ref, type: 'video', required: true }));
+        return dynamicInputs.length > 0 ? dynamicInputs : baseInputs;
+    }
+    // For-each nodes: array input + passthrough inputs
+    if (node.type === 'for-each') {
+        const forEachConfig = node.config?.forEachConfig;
+        const inputPorts = forEachConfig?.inputPorts ?? [];
+        return [
+            { id: 'array', type: 'object', required: true },
+            ...inputPorts.map((port) => ({
+                id: port.id,
+                type: port.type,
+                required: false,
+            })),
+        ];
+    }
+    // If nodes: boolean inputs + passthrough inputs from resolvedPorts
+    if (node.type === 'if') {
+        const resolvedPorts = node.config?.resolvedPorts;
+        if (resolvedPorts?.inputs && resolvedPorts.inputs.length > 0) {
+            return resolvedPorts.inputs.map(port => ({
+                id: port.id,
+                type: port.type,
+                required: port.required,
+            }));
+        }
+        return baseInputs;
+    }
+    // Transcript nodes: media input
+    if (node.type === 'transcript') {
+        return [{ id: 'media', type: ['video', 'audio'], required: true }];
+    }
+    // Video import nodes: url input
+    if (node.type === 'video-import') {
+        return [{ id: 'url', type: 'text', required: true }];
+    }
+    // Image Generation nodes: prompt + optional image for edit models
+    if (node.type === 'generate-image') {
+        const imageGenConfig = node.config?.imageGeneration;
+        const model = imageGenConfig?.model ?? '';
+        const isEditModel = model.includes('/edit');
+        const dynamicInputs = [
+            { id: 'prompt', type: 'text', required: true },
+        ];
+        if (isEditModel) {
+            dynamicInputs.push({ id: 'image', type: 'image', required: true });
+        }
+        return dynamicInputs;
+    }
+    // Custom Model nodes: generate inputs from inputParams
+    if (node.type === 'custom-model') {
+        const customModelConfig = node.config?.customModelConfig;
+        const inputParams = customModelConfig?.inputParams ?? [];
+        const dynamicInputs = [];
+        inputParams.forEach((param) => {
+            if (param.name === 'prompt' || param.type === 'image' || param.type === 'video' || param.type === 'audio') {
+                dynamicInputs.push({
+                    id: param.name,
+                    type: (param.type === 'image' || param.type === 'video' || param.type === 'audio'
+                        ? param.type
+                        : 'text'),
+                    required: param.required,
+                });
+            }
+        });
+        return dynamicInputs;
+    }
+    // Deduplicate nodes: video input
+    if (node.type === 'deduplicate') {
+        return [{ id: 'video', type: 'video', required: true }];
+    }
+    return baseInputs;
+}
+/**
+ * Compute the output ports for a node based on its type and config
+ */
+function computeOutputPorts({ node }) {
+    const nodeConfigs = (0, automations_1.getAllNodes)();
+    const nodeConfig = nodeConfigs.find(n => n.type === node.type);
+    const baseOutputs = nodeConfig?.outputs ?? [];
+    // Sub-agent: outputs from resolvedPorts or workflow output schema
+    if (node.type === 'compose-workflow') {
+        // Prefer resolvedPorts if available (has correct array types computed)
+        const resolvedPorts = node.config?.resolvedPorts;
+        if (resolvedPorts?.outputs && resolvedPorts.outputs.length > 0) {
+            return resolvedPorts.outputs.map(port => ({
+                id: port.id,
+                type: port.type,
+                required: port.required,
+            }));
+        }
+        // Fallback to workflowOutputSchema with isArray handling
+        const outputSchema = node.config?.workflowOutputSchema;
+        if (!outputSchema || Object.keys(outputSchema).length === 0)
+            return baseOutputs;
+        return Object.entries(outputSchema).map(([id, schema]) => ({
+            id,
+            type: (schema.isArray ? `${schema.type}[]` : schema.type),
+            required: true,
+        }));
+    }
+    // LLM nodes: outputs from outputFields
+    // Array types output 'object', others output 'text'
+    if (node.type === 'llm') {
+        const llmConfig = node.config?.llm;
+        const outputFields = llmConfig?.outputFields ?? [{ name: 'output', type: 'string' }];
+        return outputFields.map((f) => ({
+            id: f.name,
+            type: (f.type === 'array' ? 'object' : 'text'),
+            required: true,
+        }));
+    }
+    // For-each nodes: outputs based on forEachConfig
+    if (node.type === 'for-each') {
+        // Prefer resolvedPorts if available (computed by modal with accurate item types)
+        const resolvedPorts = node.config?.resolvedPorts;
+        if (resolvedPorts?.outputs && resolvedPorts.outputs.length > 0) {
+            return resolvedPorts.outputs.map(port => ({
+                id: port.id,
+                type: port.type,
+                required: port.required,
+            }));
+        }
+        // Fallback to manual computation (for backwards compatibility)
+        const forEachConfig = node.config?.forEachConfig;
+        const outputProperties = forEachConfig?.outputProperties ?? [];
+        const inputPorts = forEachConfig?.inputPorts ?? [];
+        const exposeItem = forEachConfig?.exposeItem ?? false;
+        const exposeIndex = forEachConfig?.exposeIndex ?? false;
+        const outputs = [];
+        if (exposeItem) {
+            outputs.push({ id: 'item', type: 'object', required: true });
+        }
+        if (exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', required: true });
+        }
+        for (const prop of outputProperties) {
+            outputs.push({
+                id: prop.portId,
+                type: prop.type,
+                required: true,
+            });
+        }
+        for (const port of inputPorts) {
+            outputs.push({
+                id: port.id,
+                type: port.type,
+                required: true,
+            });
+        }
+        return outputs;
+    }
+    // If nodes: outputs from resolvedPorts
+    if (node.type === 'if') {
+        const resolvedPorts = node.config?.resolvedPorts;
+        if (resolvedPorts?.outputs && resolvedPorts.outputs.length > 0) {
+            return resolvedPorts.outputs.map(port => ({
+                id: port.id,
+                type: port.type,
+                required: port.required,
+            }));
+        }
+        return baseOutputs;
+    }
+    // Transcript nodes: text and segments outputs
+    if (node.type === 'transcript') {
+        return [
+            { id: 'text', type: 'text', required: true },
+            { id: 'segments', type: 'object', required: true },
+        ];
+    }
+    // Video import nodes: video output
+    if (node.type === 'video-import') {
+        return [{ id: 'output', type: 'video', required: true }];
+    }
+    // Deduplicate nodes: video output
+    if (node.type === 'deduplicate') {
+        return [{ id: 'output', type: 'video', required: true }];
+    }
+    // Manual Trigger nodes: outputs from resolvedPorts or config
+    if (node.type === 'manual-trigger') {
+        // Prefer resolvedPorts if available (computed by modal with correct array types)
+        const resolvedPorts = node.config?.resolvedPorts;
+        if (resolvedPorts?.outputs && resolvedPorts.outputs.length > 0) {
+            return resolvedPorts.outputs.map(port => ({
+                id: port.id,
+                type: port.type,
+                required: port.required,
+            }));
+        }
+        // Fallback to config (handle isArray flag)
+        const triggerConfig = node.config?.manualTriggerConfig;
+        const configOutputs = triggerConfig?.outputs ?? [];
+        if (configOutputs.length === 0)
+            return baseOutputs;
+        return configOutputs.map((output) => ({
+            id: output.id,
+            type: (output.isArray ? `${output.type}[]` : output.type),
+            required: true,
+        }));
+    }
+    // Recurrence nodes: add account output if enabled
+    if (node.type === 'recurrence') {
+        const recurrenceConfig = node.config?.recurrenceConfig;
+        const collectionInput = recurrenceConfig?.collectionInput;
+        if (collectionInput?.enabled && (collectionInput.accountIds?.length ?? 0) > 0) {
+            return [
+                ...baseOutputs,
+                { id: 'account', type: 'account', required: true },
+            ];
+        }
+    }
+    // Media nodes: outputs based on outputs array
+    if (node.type === 'media') {
+        const mediaConfig = node.config?.mediaConfig;
+        const configOutputs = mediaConfig?.outputs ?? [];
+        // Only include outputs with actual selections
+        const activeOutputs = configOutputs.filter(o => o.selectedMediaIds.length > 0);
+        if (activeOutputs.length === 0)
+            return baseOutputs;
+        return activeOutputs.map(o => ({
+            id: o.id,
+            type: (o.isArray ? `${o.type}[]` : o.type),
+            required: true,
+        }));
+    }
+    // Account nodes
+    if (node.type === 'account') {
+        return [{ id: 'account', type: 'account', required: true }];
+    }
+    // Custom Model nodes: single output based on outputType
+    if (node.type === 'custom-model') {
+        const customModelConfig = node.config?.customModelConfig;
+        const outputType = customModelConfig?.outputType ?? 'image';
+        return [{ id: 'output', type: outputType, required: true }];
+    }
+    return baseOutputs;
+}
+/**
+ * Check if an input port is required for a given node.
+ */
+function isInputPortRequired({ node, portId, }) {
+    const ports = computeInputPorts({ node });
+    const port = ports.find(p => p.id === portId);
+    return port?.required ?? true; // Default to required for safety
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ugcinc",
-  "version": "3.85.1",
+  "version": "3.87.0",
   "description": "TypeScript/JavaScript client for the UGC Inc API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",