ugcinc 4.0.2 → 4.1.0

package/dist/automations/nodes/llm.d.ts

@@ -0,0 +1,27 @@
+import { type ObjectSchemaField } from './types';
+declare const LLMProviders: readonly ["groq", "openai", "claude", "gemini"];
+type LLMProvider = typeof LLMProviders[number];
+interface LLMApiKeys {
+    openai?: string;
+    claude?: string;
+    gemini?: string;
+    groq?: string;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    provider: LLMProvider;
+    model: string;
+    temperature: number;
+    maxTokens: number | undefined;
+    systemPrompt: string;
+    outputFields: ObjectSchemaField[];
+    useStructuredOutput: boolean;
+    imageInputRefs: string[];
+    videoInputRefs: string[];
+    apiKeys: LLMApiKeys | undefined;
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export { LLMProviders };
+export type { LLMProvider, LLMApiKeys };
+export type LLMConfig = typeof definition.defaults;

package/dist/automations/nodes/llm.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMProviders = void 0;
+const internal_utils_1 = require("../../internal-utils");
+const types_1 = require("./types");
+const LLMProviders = ['groq', 'openai', 'claude', 'gemini'];
+exports.LLMProviders = LLMProviders;
+const definition = (0, types_1.defineNode)({
+    nodeId: 'llm',
+    label: 'LLM',
+    description: 'Generate LLM output',
+    type: 'generator',
+    category: 'AI Generation',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        provider: 'claude',
+        model: 'claude-sonnet-4-5',
+        temperature: 0.7,
+        maxTokens: undefined,
+        systemPrompt: '',
+        outputFields: [{ name: 'output', type: 'string' }],
+        useStructuredOutput: true,
+        imageInputRefs: [],
+        videoInputRefs: [],
+        apiKeys: undefined,
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        // Input ports from template variables + media refs
+        const systemPrompt = config?.systemPrompt ?? '';
+        const variables = (0, internal_utils_1.extractTemplateVariables)([systemPrompt]);
+        const imageInputRefs = config?.imageInputRefs ?? [];
+        const videoInputRefs = config?.videoInputRefs ?? [];
+        const inputs = [
+            ...variables.map(v => ({
+                id: v,
+                type: ['text', 'object', 'boolean'],
+                isArray: false,
+                required: true,
+            })),
+            ...imageInputRefs.map(ref => ({
+                id: ref,
+                type: 'image',
+                isArray: false,
+                required: true,
+            })),
+            ...videoInputRefs.map(ref => ({
+                id: ref,
+                type: 'video',
+                isArray: false,
+                required: true,
+            })),
+        ];
+        // Output ports from outputFields
+        const outputFields = (config?.outputFields ?? [{ name: 'output', type: 'string' }]);
+        const outputs = outputFields.map(f => {
+            let pType;
+            let pIsArray;
+            if (f.type === 'array') {
+                pType = f.items === 'object' ? 'object' : 'text';
+                pIsArray = true;
+            }
+            else if (f.type === 'object') {
+                pType = 'object';
+                pIsArray = false;
+            }
+            else {
+                pType = 'text';
+                pIsArray = false;
+            }
+            return {
+                id: f.name,
+                type: pType,
+                isArray: pIsArray,
+                required: f.required ?? true,
+                // Include objectSchema for object/array-of-object types
+                ...(f.objectSchema && { objectSchema: f.objectSchema }),
+            };
+        });
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/manual-trigger.d.ts

@@ -0,0 +1,34 @@
+import type { EnumOption } from '../types';
+import { type ObjectSchemaField } from './types';
+interface ManualTriggerOutputLocal {
+    id: string;
+    type: string;
+    isArray?: boolean;
+    objectSchema?: ObjectSchemaField[];
+    enumOptions?: EnumOption[];
+}
+/**
+ * Manual Trigger node output definition
+ */
+export interface ManualTriggerOutput {
+    id: string;
+    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio' | 'account' | 'boolean' | 'object' | 'enum';
+    isArray?: boolean;
+    /** Schema for object types - describes the structure of the object */
+    objectSchema?: ObjectSchemaField[];
+    /** Options for enum types */
+    enumOptions?: EnumOption[];
+}
+/**
+ * Manual Trigger node configuration - defines outputs that users provide when running
+ */
+export interface ManualTriggerNodeConfig {
+    outputs: ManualTriggerOutput[];
+}
+declare const definition: import("./types").NodeDefinition<"trigger", {
+    outputs: ManualTriggerOutputLocal[];
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type ManualTriggerConfig = typeof definition.defaults;

package/dist/automations/nodes/manual-trigger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'manual-trigger',
+    label: 'Manual Trigger',
+    description: 'Trigger manually',
+    type: 'trigger',
+    category: 'Triggers',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        outputs: [{ id: 'input-1', type: 'image' }],
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configOutputs = (config?.outputs ?? []);
+        const outputs = configOutputs.map(output => ({
+            id: output.id,
+            type: output.type,
+            isArray: output.isArray ?? false,
+            required: true,
+            ...(output.type === 'enum' && output.enumOptions ? { enumOptions: output.enumOptions } : {}),
+        }));
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/media.d.ts

@@ -0,0 +1,17 @@
+import { type SelectionConfig } from './types';
+type MediaNodeEnabledType = 'image' | 'video' | 'audio';
+declare const definition: import("./types").NodeDefinition<"source", {
+    outputs: {
+        id: string;
+        type: MediaNodeEnabledType;
+        isArray: boolean;
+        selectedMediaIds: string[];
+        selectionConfig: SelectionConfig | undefined;
+    }[];
+    outputMode: "per-input";
+    selectionMode: "random";
+}>;
+export default definition;
+export type { MediaNodeEnabledType };
+export type MediaConfig = typeof definition.defaults;
+export type MediaNodeOutput = MediaConfig['outputs'][number];

package/dist/automations/nodes/media.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'media',
+    label: 'Media',
+    description: 'Use saved media',
+    type: 'source',
+    category: 'Sources',
+    outputModes: ['per-input', 'single'],
+    selectionModes: ['random', 'sequential'],
+    defaults: {
+        outputs: [{
+                id: 'image-1',
+                type: 'image',
+                isArray: false,
+                selectedMediaIds: [],
+                selectionConfig: undefined,
+            }],
+        outputMode: 'per-input',
+        selectionMode: 'random',
+    },
+    computePorts: ({ config }) => {
+        const outputConfigs = config?.outputs ?? [];
+        // Generate output ports from config (only those with selected media)
+        const outputs = outputConfigs
+            .filter(o => o.selectedMediaIds.length > 0)
+            .map(o => ({
+            id: o.id,
+            type: o.type,
+            isArray: o.isArray,
+            required: true,
+        }));
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/not.d.ts

@@ -0,0 +1,6 @@
+declare const definition: import("./types").NodeDefinition<"generator", {
+    outputMode: "per-input";
+    selectionMode: null;
+}>;
+export default definition;
+export type NotConfig = typeof definition.defaults;

package/dist/automations/nodes/not.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'not',
+    label: 'Not',
+    description: 'Invert a boolean value',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        outputMode: 'per-input',
+        selectionMode: null,
+    },
+    computePorts: () => ({
+        inputs: [
+            {
+                id: 'input',
+                type: 'boolean',
+                isArray: false,
+                required: true,
+            },
+        ],
+        outputs: [
+            {
+                id: 'output',
+                type: 'boolean',
+                isArray: false,
+                required: true,
+            },
+        ],
+    }),
+});
+exports.default = definition;

package/dist/automations/nodes/output.d.ts

@@ -0,0 +1,30 @@
+import { type ObjectSchemaField } from './types';
+/**
+ * Output node input definition
+ */
+export interface OutputInput {
+    id: string;
+    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio' | 'account' | 'boolean' | 'object';
+    /** Individual tag for this input (overrides global tag) */
+    tag?: string;
+    /** Whether this input accepts an array */
+    isArray?: boolean;
+    /** Schema of object properties (when type is object) */
+    objectSchema?: ObjectSchemaField[];
+}
+/**
+ * Output node configuration
+ */
+export interface OutputNodeConfig {
+    inputs: OutputInput[];
+    /** Which input is the main visual preview for the workflow */
+    mainPreviewInputId?: string;
+}
+declare const definition: import("./types").NodeDefinition<"terminal", {
+    inputs: OutputInput[];
+    mainPreviewInputId: string | undefined;
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type PassthroughConfig = typeof definition.defaults;

package/dist/automations/nodes/output.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'passthrough',
+    label: 'Pass-Through',
+    description: 'Pass data to parent workflow',
+    type: 'terminal',
+    category: 'Output',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        inputs: [{ id: 'result', type: 'image' }],
+        mainPreviewInputId: undefined,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const configInputs = config?.inputs ?? [];
+        const inputs = configInputs.map(input => ({
+            id: input.id,
+            type: input.type,
+            isArray: input.isArray ?? false,
+            required: false,
+        }));
+        return {
+            inputs,
+            outputs: [],
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/random-route.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Random Branch branch definition
+ */
+export interface RandomRouteBranch {
+    /** Unique ID for this branch (e.g., "branch-1") */
+    id: string;
+    /** Probability weight (0-100, all branches must sum to 100) */
+    probability: number;
+}
+/**
+ * Object field definition for Random Branch passthrough input default values
+ */
+export interface RandomRouteObjectField {
+    /** Field name */
+    name: string;
+    /** Field type */
+    type: 'string' | 'number' | 'boolean';
+}
+/**
+ * Random Branch passthrough input definition
+ */
+export interface RandomRoutePassthroughInput {
+    /** The input port ID (lowercase, hyphens/underscores only) */
+    id: string;
+    /** The value type */
+    type: 'image' | 'video' | 'audio' | 'text' | 'number' | 'boolean' | 'account' | 'object';
+    /** Whether this is an array type */
+    isArray?: boolean;
+    /** Whether this input comes from a variable (input port) vs static default value. Defaults to false. */
+    isVariable?: boolean;
+    /** Default value when isVariable is false (type depends on type field) */
+    defaultValue?: unknown;
+    /** Object schema for object type (when type is 'object') */
+    objectSchema?: RandomRouteObjectField[];
+}
+/**
+ * Random Branch node configuration - routes inputs to a randomly selected branch based on probability
+ */
+export interface RandomRouteNodeConfig {
+    /** Output branches with probability weights (must sum to 100) */
+    branches: RandomRouteBranch[];
+    /** Passthrough inputs that get routed to one branch's outputs */
+    passthroughInputs: RandomRoutePassthroughInput[];
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    branches: RandomRouteBranch[];
+    passthroughInputs: RandomRoutePassthroughInput[];
+    outputMode: "single";
+    selectionMode: null;
+}>;
+export default definition;
+export type RandomRouteConfig = typeof definition.defaults;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'random-route',
+    label: 'Random Branch',
+    description: 'Route inputs to a randomly selected branch',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        branches: [
+            { id: 'branch-1', probability: 50 },
+            { id: 'branch-2', probability: 50 },
+        ],
+        passthroughInputs: [
+            { id: 'input', type: 'image', isArray: false, isVariable: false },
+        ],
+        outputMode: 'single',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const branches = (config?.branches ?? []);
+        const passthroughInputs = (config?.passthroughInputs ?? []);
+        const inputs = [];
+        const outputs = [];
+        // Input ports: only passthroughs where isVariable is true
+        for (const passthrough of passthroughInputs) {
+            if (passthrough.isVariable) {
+                inputs.push({
+                    id: passthrough.id,
+                    type: passthrough.type,
+                    isArray: passthrough.isArray ?? false,
+                    required: true,
+                });
+            }
+        }
+        // Output ports: {branch.id}-{passthrough.id} for each combination
+        for (const branch of branches) {
+            for (const passthrough of passthroughInputs) {
+                outputs.push({
+                    id: `${branch.id}-${passthrough.id}`,
+                    type: passthrough.type,
+                    isArray: passthrough.isArray ?? false,
+                    required: true,
+                });
+            }
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/random.d.ts

@@ -0,0 +1,16 @@
+export interface RandomInputPort {
+    id: string;
+    probability: number;
+    isVariable: boolean;
+    defaultValue?: unknown;
+}
+declare const definition: import("./types").NodeDefinition<"generator", {
+    mode: "array" | "multi-input";
+    valueType: string;
+    exposeIndex: boolean;
+    inputPorts: RandomInputPort[];
+    outputMode: "single";
+    selectionMode: null;
+}>;
+export default definition;
+export type RandomConfig = typeof definition.defaults;

package/dist/automations/nodes/random.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'random',
+    label: 'Random Select',
+    description: 'Randomly select from an array or weighted inputs',
+    type: 'generator',
+    category: 'Control Flow',
+    outputModes: ['per-input', 'single'],
+    selectionModes: null,
+    defaults: {
+        mode: 'array',
+        valueType: 'object',
+        exposeIndex: false,
+        inputPorts: [],
+        outputMode: 'single',
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const mode = config?.mode ?? 'array';
+        const valueType = (config?.valueType ?? 'object');
+        const exposeIndex = config?.exposeIndex ?? false;
+        const inputPorts = (config?.inputPorts ?? []);
+        const inputs = [];
+        const outputs = [];
+        if (mode === 'array') {
+            inputs.push({ id: 'array', type: 'object', isArray: false, required: true });
+        }
+        else {
+            // Multi-input mode: only add ports where isVariable is true
+            for (const port of inputPorts) {
+                if (port.isVariable) {
+                    inputs.push({
+                        id: port.id,
+                        type: valueType,
+                        isArray: false,
+                        required: true,
+                    });
+                }
+            }
+        }
+        outputs.push({ id: 'output', type: valueType, isArray: false, required: true });
+        if (mode === 'array' && exposeIndex) {
+            outputs.push({ id: 'index', type: 'number', isArray: false, required: true });
+        }
+        return { inputs, outputs };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/recurrence.d.ts

@@ -0,0 +1,69 @@
+import { type TriggerCollectionConfig } from './types';
+/**
+ * Days of the week for recurrence scheduling
+ */
+export type DayOfWeek = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+/**
+ * Recurrence media output port definition
+ * Each output is a named port with a specific media type and its own selection config
+ */
+export interface RecurrenceMediaOutput {
+    /** Unique ID for this output port (e.g., "background-image", "overlay") */
+    id: string;
+    /** Media type for this port */
+    type: 'image' | 'video' | 'audio' | 'text' | 'social_audio';
+    /** Selection mode for this output's media source */
+    selectionMode: 'specific' | 'by-tag';
+    /** Media IDs for this output (used when selectionMode is 'specific') */
+    selectedMediaIds?: string[];
+    /** Tag to query media by at runtime (used when selectionMode is 'by-tag') */
+    mediaTag?: string;
+}
+/**
+ * Media input configuration for recurrence nodes
+ * Each output has its own selection configuration
+ */
+export interface RecurrenceMediaConfig {
+    /** Whether media input is enabled */
+    enabled: boolean;
+    /** Named output ports - each has its own selection config */
+    outputs: RecurrenceMediaOutput[];
+}
+/**
+ * Recurrence node configuration - defines when the automation runs on a schedule
+ */
+export interface RecurrenceNodeConfig {
+    frequencyType: 'per-day' | 'periodic';
+    runsPerDay: number;
+    periodDays: number;
+    daysOfWeek: DayOfWeek[];
+    timingType: 'specific' | 'random-window';
+    specificTimes: string[];
+    randomWindowStart: string;
+    randomWindowEnd: string;
+    timezone: string;
+    collectionInput?: TriggerCollectionConfig;
+    mediaInput?: RecurrenceMediaConfig;
+}
+/**
+ * Recurrence media enabled type
+ * Includes all media types that can be output from recurrence nodes
+ */
+export type RecurrenceMediaEnabledType = 'image' | 'video' | 'audio' | 'text' | 'social_audio';
+declare const definition: import("./types").NodeDefinition<"trigger", {
+    frequencyType: "per-day" | "periodic";
+    runsPerDay: number;
+    periodDays: number;
+    daysOfWeek: DayOfWeek[];
+    timingType: "specific" | "random-window";
+    specificTimes: string[];
+    randomWindowStart: string;
+    randomWindowEnd: string;
+    timezone: string;
+    collectionInput: TriggerCollectionConfig | undefined;
+    mediaInput: RecurrenceMediaConfig | undefined;
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type RecurrenceConfig = typeof definition.defaults;

package/dist/automations/nodes/recurrence.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+const definition = (0, types_1.defineNode)({
+    nodeId: 'recurrence',
+    label: 'Recurring',
+    description: 'Run continuously',
+    type: 'trigger',
+    category: 'Triggers',
+    outputModes: null,
+    selectionModes: null,
+    defaults: {
+        frequencyType: 'per-day',
+        runsPerDay: 1,
+        periodDays: 7,
+        daysOfWeek: ['monday', 'tuesday', 'wednesday', 'thursday', 'friday'],
+        timingType: 'random-window',
+        specificTimes: ['09:00'],
+        randomWindowStart: '09:00',
+        randomWindowEnd: '17:00',
+        timezone: 'America/New_York',
+        collectionInput: undefined,
+        mediaInput: undefined,
+        outputMode: null,
+        selectionMode: null,
+    },
+    computePorts: ({ config }) => {
+        const collectionInputEnabled = config?.collectionInput?.enabled;
+        const mediaOutputs = (config?.mediaInput?.outputs ?? []);
+        const outputs = [];
+        // Add account output if collection input is enabled
+        if (collectionInputEnabled) {
+            outputs.push({ id: 'account', type: 'account', isArray: false, required: true });
+        }
+        // Add media outputs
+        for (const output of mediaOutputs) {
+            outputs.push({
+                id: output.id,
+                type: output.type,
+                isArray: false,
+                required: true,
+            });
+        }
+        return {
+            inputs: [],
+            outputs,
+        };
+    },
+});
+exports.default = definition;

package/dist/automations/nodes/save-to-media.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Save To Media node input definition
+ */
+export interface SaveToMediaInput {
+    id: string;
+    type: 'image' | 'video' | 'audio' | 'text';
+    /** Optional individual tag for this input (overrides global tag) */
+    tag?: string;
+}
+/**
+ * Save To Media node configuration - saves outputs to media library
+ */
+export interface SaveToMediaNodeConfig {
+    /** Dynamic inputs to save */
+    inputs: SaveToMediaInput[];
+    /** Global tag applied to all saved items */
+    globalTag?: string;
+    /** If true, append date in mm-dd-yy format to tag */
+    includeDateTag?: boolean;
+    /** If true, append run ID to make tags unique */
+    makeUnique?: boolean;
+}
+declare const definition: import("./types").NodeDefinition<"terminal", {
+    inputs: SaveToMediaInput[];
+    globalTag: string | undefined;
+    includeDateTag: boolean;
+    makeUnique: boolean;
+    outputMode: null;
+    selectionMode: null;
+}>;
+export default definition;
+export type SaveToMediaConfig = typeof definition.defaults;