ugcinc 4.1.22 → 4.1.24

package/dist/automations/nodes/destructure.js

@@ -28,16 +28,13 @@ const definition = (0, types_1.defineNode)({
             },
         ];
         const outputs = [];
+        // Get connected array info for type derivation
+        const connectedArray = getConnectedOutput?.('array');
+        const connectedSchema = connectedArray?.objectSchema;
         // Determine base type from connected input
         let baseType = 'object';
-        if (getConnectedOutput) {
-            const connectedOutput = getConnectedOutput('array');
-            if (connectedOutput?.type && connectedOutput.isArray) {
-                const connType = connectedOutput.type;
-                if (!Array.isArray(connType)) {
-                    baseType = connType;
-                }
-            }
+        if (connectedArray?.type && !Array.isArray(connectedArray.type)) {
+            baseType = connectedArray.type;
         }
         for (const selection of selections) {
             // If variable, add input port for index expression
@@ -49,13 +46,35 @@ const definition = (0, types_1.defineNode)({
                     required: true,
                 });
             }
-            // Output type depends on index expression:
-            // - 'single' -> single item (isArray: false)
-            // - 'range' or 'list' -> array of items (isArray: true)
-            const outputIsArray = selection.indexExpr.type !== 'single';
+            // Derive type and isArray from selection settings + connected schema
+            let outputType = baseType;
+            let outputIsArray = selection.indexExpr.type !== 'single';
+            // If propertyPath is set and we have schema, derive type from property
+            if (selection.propertyPath && connectedSchema) {
+                const propSchema = connectedSchema.find(f => f.name === selection.propertyPath);
+                if (propSchema) {
+                    if (propSchema.type === 'array') {
+                        outputType = 'object';
+                        outputIsArray = true;
+                    }
+                    else if (propSchema.type === 'object') {
+                        outputType = 'object';
+                        outputIsArray = false;
+                    }
+                    else {
+                        // Primitive type (string -> text, number, boolean)
+                        outputType = (propSchema.type === 'string' ? 'text' : propSchema.type);
+                        outputIsArray = false;
+                    }
+                }
+            }
+            // Variable input means output is always array (unknown indexes at config time)
+            if (selection.inputType === 'variable') {
+                outputIsArray = true;
+            }
             outputs.push({
                 id: selection.portId,
-                type: baseType,
+                type: outputType,
                 isArray: outputIsArray,
                 required: true,
             });

package/dist/automations/nodes/for-each.js

@@ -22,9 +22,9 @@ const definition = (0, types_1.defineNode)({
         const inputPorts = config?.inputPorts ?? [];
         const exposeItem = config?.exposeItem ?? false;
         const exposeIndex = config?.exposeIndex ?? false;
-        // Inputs: array + passthrough inputs
+        // Inputs: array (accepts any array type) + passthrough inputs
         const inputs = [
-            { id: 'array', type: 'object', isArray: false, required: true },
+            { id: 'array', type: ['image', 'video', 'audio', 'text', 'object', 'account', 'boolean', 'number'], isArray: true, required: true },
         ];
         for (const port of inputPorts) {
             inputs.push({

package/dist/automations/nodes/if.js

@@ -23,7 +23,7 @@ const definition = (0, types_1.defineNode)({
         outputMode: 'per-input',
         selectionMode: null,
     },
-    computePorts: ({ config }) => {
+    computePorts: ({ config, getConnectedOutput }) => {
         const booleanInputs = config?.booleanInputs ?? [];
         const passthroughInputs = config?.passthroughInputs ?? [];
         const inputs = [];
@@ -35,8 +35,11 @@ const definition = (0, types_1.defineNode)({
         // Passthrough inputs and true/false outputs
         for (const passthrough of passthroughInputs) {
             inputs.push({ id: passthrough.id, type: passthrough.type, isArray: passthrough.isArray, required: true });
-            outputs.push({ id: `true-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
-            outputs.push({ id: `false-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true });
+            // Get schema from connected input to propagate to outputs
+            const connectedOutput = getConnectedOutput?.(passthrough.id);
+            const objectSchema = connectedOutput?.objectSchema;
+            outputs.push({ id: `true-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true, objectSchema });
+            outputs.push({ id: `false-${passthrough.id}`, type: passthrough.type, isArray: passthrough.isArray, required: true, objectSchema });
         }
         return { inputs, outputs };
     },

package/dist/automations/nodes/random-route.js

@@ -20,7 +20,7 @@ const definition = (0, types_1.defineNode)({
         outputMode: 'single',
         selectionMode: null,
     },
-    computePorts: ({ config }) => {
+    computePorts: ({ config, getConnectedOutput }) => {
         const branches = config?.branches ?? [];
         const passthroughInputs = config?.passthroughInputs ?? [];
         const inputs = [];
@@ -39,11 +39,15 @@ const definition = (0, types_1.defineNode)({
         // Output ports: {branch.id}-{passthrough.id} for each combination
         for (const branch of branches) {
             for (const passthrough of passthroughInputs) {
+                // Get schema from connected input to propagate to outputs
+                const connectedOutput = getConnectedOutput?.(passthrough.id);
+                const objectSchema = connectedOutput?.objectSchema;
                 outputs.push({
                     id: `${branch.id}-${passthrough.id}`,
                     type: passthrough.type,
                     isArray: passthrough.isArray ?? false,
                     required: true,
+                    objectSchema,
                 });
             }
         }

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export { selectFromPool } from './automations/selection';
 export { portId, isValidPortId, portIdToTitle, normalizeToPortId, PortIdSchema } from './port-id';
 export type { PortId } from './port-id';
 export { extractTemplateVariables } from './internal-utils';
+export type { InputType } from './automations/nodes/types';
 export type { ClientConfig } from './base';
 export type { Account, AccountStat, AccountTask, EditProfileInfo, GetAccountsParams, GetAccountStatsParams, GetAccountStatusParams, AccountInfoUpdate, UpdateAccountInfoParams, AccountInfoUpdateResult, UpdateAccountInfoResponse, AccountSocialUpdate, UpdateAccountSocialParams, AccountSocialUpdateResult, UpdateAccountSocialResponse, DeleteAccountPostsParams, DeleteAccountPostsResponse, ResetWarmupParams, ResetWarmupResponse, } from './accounts';
 export type { TaskType, Task, GetTasksParams } from './tasks';

package/package.json

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

package/dist/automations.d.ts

@@ -1,173 +0,0 @@
-/**
- * Automations API Client
- *
- * Provides methods to interact with the UGC Inc Automations API.
- * For graph logic (validation, port computation, connections), use graph-controller.ts
- */
-import type { WorkflowDefinition, AutomationTemplate, AutomationRun, ExecutorNode, ExecutionEdge, ApiResponse, AutomationExport, AutomationRunExport } from './types';
-import { BaseClient } from './base';
-export declare class AutomationsClient extends BaseClient {
-    /**
-     * List all automation templates for an organization
-     */
-    listTemplates(params: {
-        orgId: string;
-    }): Promise<ApiResponse<AutomationTemplate[]>>;
-    /**
-     * Get a specific automation template
-     */
-    getTemplate(params: {
-        templateId: string;
-    }): Promise<ApiResponse<AutomationTemplate>>;
-    /**
-     * Create or update an automation template
-     * @param templateId - If provided, updates existing template instead of creating new one
-     * @param skipValidation - If true, skips workflow validation (for saving drafts)
-     */
-    createTemplate(params: {
-        orgId: string;
-        name: string;
-        description?: string;
-        workflowDefinition: WorkflowDefinition;
-        templateId?: string;
-        skipValidation?: boolean;
-    }): Promise<ApiResponse<string>>;
-    /**
-     * Delete an automation template
-     */
-    deleteTemplate(params: {
-        templateId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Run an automation template
-     * @param variableInputs - Optional map of variable node IDs to their runtime values
-     * @param saveAsPreview - If true, saves the output as a preview for sub-workflows
-     * @param tag - Optional tag for organizing runs
-     */
-    run(params: {
-        templateId: string;
-        orgId: string;
-        variableInputs?: Record<string, string>;
-        saveAsPreview?: boolean;
-        tag?: string;
-    }): Promise<ApiResponse<{
-        runId: string;
-    }>>;
-    /**
-     * Get automation run status
-     * Returns executors (expanded nodes) and edges (data flow connections)
-     */
-    getStatus(params: {
-        runId: string;
-    }): Promise<ApiResponse<{
-        run: AutomationRun;
-        executors: ExecutorNode[];
-        edges: ExecutionEdge[];
-    }>>;
-    /**
-     * List automation runs for a template
-     */
-    listRuns(params: {
-        templateId: string;
-        limit?: number;
-    }): Promise<ApiResponse<Array<{
-        run: AutomationRun;
-        nodeCount: number;
-    }>>>;
-    /**
-     * List all automation runs for the organization (across all templates)
-     * @param templateId - Optional filter to show runs from a specific automation only
-     */
-    listAllRuns(params: {
-        limit?: number;
-        reviewStatus?: 'pending_review' | 'approved' | 'rejected' | 'all';
-        templateId?: string;
-    }): Promise<ApiResponse<Array<{
-        run: AutomationRun;
-        templateName: string;
-        nodeCount: number;
-        completedNodeCount: number;
-    }>>>;
-    /**
-     * Update review status for a run
-     */
-    updateReviewStatus(params: {
-        runId: string;
-        reviewStatus: 'approved' | 'rejected';
-    }): Promise<ApiResponse<{
-        success: boolean;
-    }>>;
-    /**
-     * Validate a workflow definition without creating it
-     */
-    validateWorkflow(params: {
-        workflowDefinition: WorkflowDefinition;
-    }): Promise<ApiResponse<{
-        valid: boolean;
-        errors: string[];
-    }>>;
-    /**
-     * Delete an automation run
-     */
-    deleteRun(params: {
-        runId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Export automation template for debugging
-     * Returns the complete template definition with nodes and connections
-     */
-    exportTemplate(params: {
-        templateId: string;
-    }): Promise<ApiResponse<AutomationExport>>;
-    /**
-     * Export automation run for debugging
-     * Returns the complete run data including execution state, executor outputs, and edge values
-     */
-    exportRun(params: {
-        runId: string;
-    }): Promise<ApiResponse<AutomationRunExport>>;
-    /**
-     * Stop a running automation
-     * Marks the run as failed and all pending executors as failed.
-     * In-flight executors will complete gracefully.
-     */
-    stop(params: {
-        runId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Get the recurrence status for an automation template
-     * Returns whether the template has a recurrence node, if it's published, and schedule info
-     */
-    getRecurrenceStatus(params: {
-        templateId: string;
-    }): Promise<ApiResponse<{
-        hasRecurrence: boolean;
-        isPublished: boolean;
-        nextRunAt: string | null;
-        lastRunAt: string | null;
-    }>>;
-    /**
-     * Publish an automation - enables recurrence scheduling
-     * The automation will run automatically based on its recurrence configuration
-     */
-    publish(params: {
-        templateId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Unpublish an automation - disables recurrence and stops the scheduler workflow
-     * No more scheduled runs will occur until the automation is published again
-     */
-    unpublish(params: {
-        templateId: string;
-    }): Promise<ApiResponse<null>>;
-    /**
-     * Run an automation once immediately
-     * If the automation is published, this also updates the schedule (restarts the scheduler)
-     * This is used for the "Run Once" button on recurrence automations
-     */
-    runOnce(params: {
-        templateId: string;
-    }): Promise<ApiResponse<{
-        runIds: string[];
-    }>>;
-}

package/dist/automations.js

@@ -1,194 +0,0 @@
-"use strict";
-/**
- * Automations API Client
- *
- * Provides methods to interact with the UGC Inc Automations API.
- * For graph logic (validation, port computation, connections), use graph-controller.ts
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationsClient = void 0;
-const base_1 = require("./base");
-class AutomationsClient extends base_1.BaseClient {
-    /**
-     * List all automation templates for an organization
-     */
-    async listTemplates(params) {
-        return this.request('/automations/list', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Get a specific automation template
-     */
-    async getTemplate(params) {
-        return this.request('/automations/get', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Create or update an automation template
-     * @param templateId - If provided, updates existing template instead of creating new one
-     * @param skipValidation - If true, skips workflow validation (for saving drafts)
-     */
-    async createTemplate(params) {
-        return this.request('/automations/create', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Delete an automation template
-     */
-    async deleteTemplate(params) {
-        return this.request('/automations/delete', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Run an automation template
-     * @param variableInputs - Optional map of variable node IDs to their runtime values
-     * @param saveAsPreview - If true, saves the output as a preview for sub-workflows
-     * @param tag - Optional tag for organizing runs
-     */
-    async run(params) {
-        return this.request('/automations/run', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Get automation run status
-     * Returns executors (expanded nodes) and edges (data flow connections)
-     */
-    async getStatus(params) {
-        return this.request('/automations/status', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * List automation runs for a template
-     */
-    async listRuns(params) {
-        return this.request('/automations/list-runs', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * List all automation runs for the organization (across all templates)
-     * @param templateId - Optional filter to show runs from a specific automation only
-     */
-    async listAllRuns(params) {
-        return this.request('/automations/list-all-runs', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Update review status for a run
-     */
-    async updateReviewStatus(params) {
-        return this.request('/automations/update-review-status', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Validate a workflow definition without creating it
-     */
-    async validateWorkflow(params) {
-        return this.request('/automations/validate', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Delete an automation run
-     */
-    async deleteRun(params) {
-        return this.request('/automations/delete-run', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Export automation template for debugging
-     * Returns the complete template definition with nodes and connections
-     */
-    async exportTemplate(params) {
-        return this.request('/automations/export', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Export automation run for debugging
-     * Returns the complete run data including execution state, executor outputs, and edge values
-     */
-    async exportRun(params) {
-        return this.request('/automations/export-run', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Stop a running automation
-     * Marks the run as failed and all pending executors as failed.
-     * In-flight executors will complete gracefully.
-     */
-    async stop(params) {
-        return this.request('/automations/stop', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    // ===========================================================================
-    // Recurrence Scheduling
-    // ===========================================================================
-    /**
-     * Get the recurrence status for an automation template
-     * Returns whether the template has a recurrence node, if it's published, and schedule info
-     */
-    async getRecurrenceStatus(params) {
-        return this.request('/automations/recurrence-status', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Publish an automation - enables recurrence scheduling
-     * The automation will run automatically based on its recurrence configuration
-     */
-    async publish(params) {
-        return this.request('/automations/publish', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Unpublish an automation - disables recurrence and stops the scheduler workflow
-     * No more scheduled runs will occur until the automation is published again
-     */
-    async unpublish(params) {
-        return this.request('/automations/unpublish', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-    /**
-     * Run an automation once immediately
-     * If the automation is published, this also updates the schedule (restarts the scheduler)
-     * This is used for the "Run Once" button on recurrence automations
-     */
-    async runOnce(params) {
-        return this.request('/automations/run-once', {
-            method: 'POST',
-            body: JSON.stringify(params),
-        });
-    }
-}
-exports.AutomationsClient = AutomationsClient;

package/dist/node-runtime.d.ts

@@ -1,57 +0,0 @@
-/**
- * Runtime types for node execution
- * These types are used during workflow execution
- */
-/**
- * Media type classification
- */
-export type MediaType = 'video' | 'image' | 'audio' | 'text';
-/**
- * Selection mode for source nodes
- */
-export type SelectionMode = 'random' | 'sequential';
-/**
- * Behavior when all items have been used
- */
-export type ExhaustionBehavior = 'restart' | 'error';
-/**
- * Selection configuration for source nodes (image, video, audio)
- */
-export interface SelectionConfig {
-    mode: SelectionMode;
-    enforceUniqueness: boolean;
-    exhaustionBehavior: ExhaustionBehavior;
-}
-/**
- * Runtime state for tracking selection progress (persisted in node config)
- */
-export interface SelectionState {
-    usedIndices: number[];
-    currentIndex: number;
-}
-/**
- * Output mode for source nodes
- * - 'per-input': Generate a unique value for each consumer input (default)
- * - 'single': Use the same value for all consumer inputs
- */
-export type OutputMode = 'per-input' | 'single';
-/**
- * Output node input configuration
- */
-export interface OutputInput {
-    id: string;
-    title: string;
-    type: MediaType;
-    tag?: string;
-}
-/**
- * Output node configuration
- */
-export interface OutputNodeConfig {
-    inputs: OutputInput[];
-    saveToMedia: boolean;
-    globalTag?: string;
-    makeUnique: boolean;
-    createPost?: boolean;
-    requireReview?: boolean;
-}

package/dist/node-runtime.js

@@ -1,6 +0,0 @@
-"use strict";
-/**
- * Runtime types for node execution
- * These types are used during workflow execution
- */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/account.d.ts

@@ -1,7 +0,0 @@
-declare const definition: import("./types").NodeDefinition<"source", {
-    accountIds: never[];
-    outputMode: "per-input";
-    selectionMode: "random";
-}>;
-export default definition;
-export type AccountConfig = typeof definition.defaults;

package/dist/nodes/account.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'account',
-    label: 'Account',
-    description: 'Select accounts to post from',
-    type: 'source',
-    category: 'Sources',
-    outputModes: ['per-input', 'single'],
-    selectionModes: ['random', 'sequential'],
-    defaults: {
-        accountIds: [],
-        outputMode: 'per-input',
-        selectionMode: 'random',
-    },
-    computePorts: () => ({
-        inputs: [],
-        outputs: [
-            {
-                id: 'account',
-                type: 'account',
-                isArray: false,
-                required: true,
-            },
-        ],
-    }),
-});
-exports.default = definition;

package/dist/nodes/auto-caption.d.ts

@@ -1,17 +0,0 @@
-declare const definition: import("./types").NodeDefinition<"generator", {
-    fontName: string;
-    fontSize: number;
-    fontWeight: string;
-    fontColor: string;
-    highlightColor: string;
-    strokeColor: string;
-    strokeWidth: number;
-    position: string;
-    wordsPerSubtitle: number;
-    enableAnimation: boolean;
-    language: string;
-    outputMode: "per-input";
-    selectionMode: null;
-}>;
-export default definition;
-export type AutoCaptionConfig = typeof definition.defaults;

package/dist/nodes/auto-caption.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const definition = (0, types_1.defineNode)({
-    nodeId: 'auto-caption',
-    label: 'Auto Caption',
-    description: 'Add TikTok-style captions to videos',
-    type: 'generator',
-    category: 'Generation',
-    outputModes: ['per-input', 'single'],
-    selectionModes: null,
-    defaults: {
-        fontName: 'Montserrat',
-        fontSize: 80,
-        fontWeight: 'bold',
-        fontColor: 'white',
-        highlightColor: 'yellow',
-        strokeColor: 'black',
-        strokeWidth: 3,
-        position: 'bottom',
-        wordsPerSubtitle: 3,
-        enableAnimation: true,
-        language: 'en',
-        outputMode: 'per-input',
-        selectionMode: null,
-    },
-    computePorts: () => ({
-        inputs: [
-            {
-                id: 'video',
-                type: 'video',
-                isArray: false,
-                required: true,
-            },
-        ],
-        outputs: [
-            {
-                id: 'output',
-                type: 'video',
-                isArray: false,
-                required: true,
-            },
-        ],
-    }),
-});
-exports.default = definition;