ugcinc 3.88.2 → 3.88.4

package/dist/ports.d.ts

@@ -5,7 +5,7 @@
  * 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';
+import type { PortType, NodeTypeEnum, PropertySchema } from './types';
 /**
  * Computed port definition
  */
@@ -13,6 +13,7 @@ export interface ComputedPort {
     id: string;
     type: PortType | PortType[];
     required: boolean;
+    itemSchema?: Record<string, PropertySchema>;
 }
 /**
  * Extract template variables from text (e.g., "Hello {{name}}" -> ["name"])
@@ -35,6 +36,10 @@ export declare function computeInputPorts({ node }: {
 }): ComputedPort[];
 /**
  * Compute the output ports for a node based on its type and config
+ *
+ * Uses resolvedPorts as the primary source of truth - modals save complete
+ * port definitions to resolvedPorts when the node is configured.
+ * Falls back to static outputs from getAllNodes() for nodes without dynamic ports.
  */
 export declare function computeOutputPorts({ node }: {
     node: NodeLike;

package/dist/ports.js

@@ -297,168 +297,26 @@ function computeInputPorts({ node }) {
 }
 /**
  * Compute the output ports for a node based on its type and config
+ *
+ * Uses resolvedPorts as the primary source of truth - modals save complete
+ * port definitions to resolvedPorts when the node is configured.
+ * Falls back to static outputs from getAllNodes() for nodes without dynamic ports.
  */
 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,
+    // Primary: use resolvedPorts if available (computed by modal)
+    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,
+            itemSchema: port.itemSchema,
         }));
     }
-    // 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;
+    // Fallback: use static outputs from getAllNodes() for nodes without dynamic ports
+    const nodeConfigs = (0, automations_1.getAllNodes)();
+    const nodeConfig = nodeConfigs.find(n => n.type === node.type);
+    return nodeConfig?.outputs ?? [];
 }
 /**
  * Check if an input port is required for a given node.

package/dist/types.d.ts

@@ -760,7 +760,7 @@ export type MediaType = 'video' | 'image' | 'audio' | 'text';
 /**
  * Array types for collections
  */
-export type ArrayType = 'image[]' | 'video[]' | 'audio[]' | 'text[]' | 'object[]';
+export type ArrayType = 'image[]' | 'video[]' | 'audio[]' | 'text[]' | 'object[]' | 'account[]' | 'social_audio[]' | 'boolean[]';
 /**
  * Extended port types (includes non-media types for special nodes)
  */
@@ -1000,7 +1000,7 @@ export interface WorkflowNodeDefinition {
 }
 export interface OutputInput {
     id: string;
-    title: string;
+    title?: string;
     type: 'image' | 'video' | 'audio' | 'text' | 'social_audio' | 'account' | 'boolean' | 'object';
     /** Individual tag for this input (overrides global tag) */
     tag?: string;

package/package.json

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