@octaviaflow/flow-rules 0.1.0

package/dist/catalog/actions/http-request/config.d.ts

@@ -0,0 +1,114 @@
+/**
+ * HTTP Request Configuration
+ *
+ * Defines the configuration structure and default values for the HTTP Request action
+ */
+export interface ApiKeyValue {
+    key: string;
+    value: string;
+    description?: string;
+    enabled?: boolean;
+}
+export interface ApiAuthConfig {
+    type: 'none' | 'basic' | 'bearer' | 'apikey' | 'oauth2';
+    username?: string;
+    password?: string;
+    token?: string;
+    apiKeyName?: string;
+    apiKeyValue?: string;
+    apiKeyLocation?: 'header' | 'query';
+    accessToken?: string;
+}
+export interface ApiRetryConfig {
+    maxAttempts?: number;
+    retryOn?: number[];
+    initialDelayMs?: number;
+    backoffFactor?: number;
+    maxDelayMs?: number;
+}
+export interface ApiPaginationConfig {
+    type: 'none' | 'offset' | 'cursor' | 'link_header' | 'next_url';
+    limitParam?: string;
+    limitValue?: number;
+    offsetParam?: string;
+    cursorResponsePath?: string;
+    cursorRequestParam?: string;
+    nextUrlResponsePath?: string;
+    maxPages?: number;
+    mergeKey?: string;
+}
+export type ResponseType = 'json' | 'text' | 'binary';
+export interface HTTPRequestConfigType {
+    apiType?: 'rest' | 'graphql';
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+    baseUrl?: string;
+    url: string;
+    queryParams?: ApiKeyValue[];
+    headers?: ApiKeyValue[] | Record<string, string>;
+    bodyType?: 'none' | 'json' | 'raw' | 'form-data' | 'xml';
+    body?: unknown;
+    formData?: ApiKeyValue[];
+    graphqlQuery?: string;
+    graphqlVariables?: Record<string, unknown>;
+    auth?: ApiAuthConfig;
+    timeout?: number;
+    failOnError?: boolean;
+    followRedirects?: boolean;
+    retry?: ApiRetryConfig;
+    pagination?: ApiPaginationConfig;
+    extract?: Record<string, string>;
+    responseType?: ResponseType;
+    expectedContentTypes?: string[];
+}
+export declare const HTTPRequestConfig: {
+    /**
+     * Default configuration for HTTP Request
+     */
+    defaults: HTTPRequestConfigType;
+    /**
+     * Configuration schema for validation
+     */
+    schema: {
+        method: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        url: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        headers: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        body: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        timeout: {
+            type: string;
+            required: boolean;
+            description: string;
+            min: number;
+        };
+    };
+    /**
+     * Validate configuration
+     */
+    validate: (config: Partial<HTTPRequestConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Merge user config with defaults
+     */
+    merge: (userConfig: Partial<HTTPRequestConfigType>) => HTTPRequestConfigType;
+    /**
+     * Get display label for configuration
+     */
+    getLabel: (config: HTTPRequestConfigType) => string;
+};

package/dist/catalog/actions/http-request/config.js

@@ -0,0 +1,111 @@
+/**
+ * HTTP Request Configuration
+ *
+ * Defines the configuration structure and default values for the HTTP Request action
+ */
+export const HTTPRequestConfig = {
+    /**
+     * Default configuration for HTTP Request
+     */
+    defaults: {
+        apiType: 'rest',
+        method: 'GET',
+        url: '',
+        queryParams: [],
+        headers: [],
+        bodyType: 'json',
+        body: undefined,
+        formData: [],
+        graphqlQuery: '',
+        graphqlVariables: {},
+        auth: { type: 'none' },
+        timeout: 30000,
+        failOnError: true,
+        followRedirects: true,
+        retry: { maxAttempts: 1, retryOn: [429, 500, 502, 503, 504], initialDelayMs: 1000, backoffFactor: 2, maxDelayMs: 30000 },
+        pagination: { type: 'none' },
+        extract: {},
+        responseType: 'json',
+        expectedContentTypes: [],
+    },
+    /**
+     * Configuration schema for validation
+     */
+    schema: {
+        method: {
+            type: 'select',
+            required: true,
+            description: 'HTTP method to use',
+        },
+        url: {
+            type: 'url',
+            required: true,
+            description: 'The URL to send the request to',
+        },
+        headers: {
+            type: 'json',
+            required: false,
+            description: 'HTTP headers to send with the request',
+        },
+        body: {
+            type: 'json',
+            required: false,
+            description: 'Request body (for POST, PUT, PATCH)',
+        },
+        timeout: {
+            type: 'number',
+            required: false,
+            description: 'Request timeout in milliseconds',
+            min: 1000,
+        },
+    },
+    /**
+     * Validate configuration
+     */
+    validate: (config) => {
+        const errors = [];
+        const apiType = config.apiType ?? 'rest';
+        if (apiType === 'rest' && !config.method) {
+            errors.push('Method is required');
+        }
+        if (apiType === 'graphql' && !config.graphqlQuery?.trim()) {
+            errors.push('GraphQL query is required');
+        }
+        if (!config.url) {
+            errors.push('URL is required');
+        }
+        else if (typeof config.url === 'string') {
+            try {
+                new URL(config.url);
+            }
+            catch {
+                errors.push('Invalid URL format');
+            }
+        }
+        if (config.timeout !== undefined && typeof config.timeout === 'number') {
+            if (config.timeout < 1000) {
+                errors.push('Timeout must be at least 1000ms');
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    },
+    /**
+     * Merge user config with defaults
+     */
+    merge: (userConfig) => {
+        return {
+            ...HTTPRequestConfig.defaults,
+            ...userConfig,
+        };
+    },
+    /**
+     * Get display label for configuration
+     */
+    getLabel: (config) => {
+        const type = config.apiType === 'graphql' ? 'GraphQL' : (config.method ?? 'GET');
+        return `${type} ${config.url}`;
+    },
+};

package/dist/catalog/actions/http-request/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTTP Request Action
+ *
+ * Make HTTP requests to external APIs and services
+ */
+import { ActionDefinition } from '../../types';
+export declare const httpRequestDefinition: ActionDefinition;

package/dist/catalog/actions/http-request/index.js

@@ -0,0 +1,223 @@
+/**
+ * HTTP Request Action
+ *
+ * Make HTTP requests to external APIs and services
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const httpRequestDefinition = {
+    id: 'http_request',
+    name: 'HTTP Request',
+    description: 'Make HTTP requests to external APIs and services',
+    category: ActionCategory.API,
+    type: ActionType.HTTPRequest,
+    tags: ['api', 'http', 'request', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'CloudUpload',
+    color: '#0043ce',
+    inputSchema: {
+        fields: [
+            {
+                key: 'apiType',
+                label: 'API Type',
+                type: FieldType.Select,
+                description: 'Type of API request to make',
+                defaultValue: 'rest',
+                options: [
+                    { label: 'REST', value: 'rest' },
+                    { label: 'GraphQL', value: 'graphql' },
+                ],
+                validation: { required: true },
+            },
+            {
+                key: 'method',
+                label: 'Method',
+                type: FieldType.Select,
+                description: 'HTTP method to use (REST only)',
+                defaultValue: 'GET',
+                options: [
+                    { label: 'GET', value: 'GET' },
+                    { label: 'POST', value: 'POST' },
+                    { label: 'PUT', value: 'PUT' },
+                    { label: 'PATCH', value: 'PATCH' },
+                    { label: 'DELETE', value: 'DELETE' },
+                    { label: 'HEAD', value: 'HEAD' },
+                    { label: 'OPTIONS', value: 'OPTIONS' },
+                ],
+                validation: { required: false },
+            },
+            {
+                key: 'url',
+                label: 'URL',
+                type: FieldType.URL,
+                description: 'The URL to send the request to. Supports {{variable}} interpolation.',
+                placeholder: 'https://api.example.com/endpoint',
+                validation: { required: true },
+            },
+            {
+                key: 'headers',
+                label: 'Headers',
+                type: FieldType.JSON,
+                description: 'HTTP headers (JSON object or key-value array). Supports {{variable}} interpolation.',
+                defaultValue: {},
+                validation: { required: false },
+            },
+            {
+                key: 'body',
+                label: 'Request Body',
+                type: FieldType.JSON,
+                description: 'Request body for POST/PUT/PATCH. Supports {{variable}} interpolation.',
+                validation: { required: false },
+            },
+            {
+                key: 'graphqlQuery',
+                label: 'GraphQL Query',
+                type: FieldType.String,
+                description: 'GraphQL query or mutation string (GraphQL only)',
+                validation: { required: false },
+            },
+            {
+                key: 'graphqlVariables',
+                label: 'GraphQL Variables',
+                type: FieldType.JSON,
+                description: 'GraphQL variables object. Supports {{variable}} interpolation.',
+                defaultValue: {},
+                validation: { required: false },
+            },
+            {
+                key: 'auth',
+                label: 'Authentication',
+                type: FieldType.JSON,
+                description: 'Authentication config: { type: "none"|"basic"|"bearer"|"apikey", token?, username?, password?, apiKeyName?, apiKeyValue?, apiKeyLocation? }',
+                defaultValue: { type: 'none' },
+                validation: { required: false },
+            },
+            {
+                key: 'timeout',
+                label: 'Timeout (ms)',
+                type: FieldType.Number,
+                description: 'Request timeout in milliseconds',
+                defaultValue: 30000,
+                validation: { required: false, min: 1000 },
+            },
+            {
+                key: 'failOnError',
+                label: 'Fail on non-2xx',
+                type: FieldType.Boolean,
+                description: 'If true, step fails when response status is not 2xx. Default: true.',
+                defaultValue: true,
+                validation: { required: false },
+            },
+            {
+                key: 'responseType',
+                label: 'Response Type',
+                type: FieldType.Select,
+                description: 'How to parse the response body. JSON tries to parse as JSON; Text returns raw text; Binary returns Uint8Array bytes plus fileName/contentType/size.',
+                defaultValue: 'json',
+                options: [
+                    { label: 'JSON', value: 'json' },
+                    { label: 'Text', value: 'text' },
+                    { label: 'Binary', value: 'binary' },
+                ],
+                validation: { required: false },
+            },
+            {
+                key: 'expectedContentTypes',
+                label: 'Expected Content-Types',
+                type: FieldType.JSON,
+                description: 'Optional array of content-type prefixes (e.g. ["application/pdf"]). Logs a warning if the response content-type does not start with any of these.',
+                defaultValue: [],
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'status',
+                type: FieldType.Number,
+                description: 'HTTP status code',
+            },
+            {
+                key: 'statusText',
+                type: FieldType.String,
+                description: 'HTTP status text',
+            },
+            {
+                key: 'ok',
+                type: FieldType.Boolean,
+                description: 'True if status is 2xx',
+            },
+            {
+                key: 'headers',
+                type: FieldType.Object,
+                description: 'Response headers',
+            },
+            {
+                key: 'body',
+                type: FieldType.JSON,
+                description: 'Response body (parsed JSON or raw string)',
+            },
+            {
+                key: 'duration',
+                type: FieldType.Number,
+                description: 'Request duration in milliseconds',
+            },
+            {
+                key: 'graphqlErrors',
+                type: FieldType.JSON,
+                description: 'GraphQL errors array (GraphQL only, present when errors returned)',
+            },
+            {
+                key: 'pages',
+                type: FieldType.Number,
+                description: 'Number of pages fetched (pagination only)',
+            },
+            {
+                key: 'attempts',
+                type: FieldType.Number,
+                description: 'Total fetch attempts made (includes retries)',
+            },
+            {
+                key: 'extracted',
+                type: FieldType.Object,
+                description: 'Named fields extracted from response body via dot-notation paths',
+            },
+            {
+                key: 'fileName',
+                type: FieldType.String,
+                description: 'Derived file name (only present when Response Type is Binary). Sourced from Content-Disposition header or URL pathname.',
+            },
+            {
+                key: 'contentType',
+                type: FieldType.String,
+                description: 'Response content-type (only present when Response Type is Binary). Defaults to application/octet-stream when missing.',
+            },
+            {
+                key: 'size',
+                type: FieldType.Number,
+                description: 'Response body size in bytes (only present when Response Type is Binary).',
+            },
+        ],
+        sampleOutput: {
+            status: 200,
+            statusText: 'OK',
+            ok: true,
+            headers: { 'content-type': 'application/json' },
+            body: { success: true, data: {} },
+            duration: 245,
+            attempts: 1,
+            extracted: {},
+        },
+    },
+    execution: {
+        timeout: 30000,
+        retryable: true,
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/ai/ai-agent/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AI Agent Workflow Action — definition (DEV-92, epic DEV-85).
+ *
+ * Picks a saved Agent (chat or etl) and runs it as a workflow step.
+ * Config: { agentId, input?, overrides? }.
+ *
+ * The actual configuration UI lives in `components/AIAgentActionPanel.tsx`.
+ *
+ * See:
+ */
+import { type ActionDefinition } from '../../types';
+export declare const aiAgentDefinition: ActionDefinition;

package/dist/catalog/ai/ai-agent/index.js

@@ -0,0 +1,72 @@
+/**
+ * AI Agent Workflow Action — definition (DEV-92, epic DEV-85).
+ *
+ * Picks a saved Agent (chat or etl) and runs it as a workflow step.
+ * Config: { agentId, input?, overrides? }.
+ *
+ * The actual configuration UI lives in `components/AIAgentActionPanel.tsx`.
+ *
+ * See:
+ */
+import { ActionCategory, ActionStatus, ActionType, FieldType, } from '../../types';
+export const aiAgentDefinition = {
+    id: 'ai_agent',
+    name: 'AI Agent',
+    description: 'Run a reusable AI agent. Pick a saved agent from /ai/agents; optionally override model, temperature, or instructions per step.',
+    category: ActionCategory.AI,
+    type: ActionType.AIAgent,
+    tags: ['ai', 'agent', 'chat', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Bot',
+    color: '#7c3aed',
+    // The configuration UI is a custom panel (see components/AIAgentActionPanel.tsx).
+    // Fields below are the storage shape — the panel reads/writes them via
+    // setConfig but does NOT auto-render from this schema. This list keeps
+    // the action introspectable for downstream tooling (workflow validators,
+    // versioning) without duplicating the panel.
+    inputSchema: {
+        fields: [
+            {
+                key: 'agentId',
+                label: 'Agent',
+                type: FieldType.String,
+                description: 'Saved Agent public id (e.g. agt_xxx).',
+                validation: { required: true },
+            },
+            {
+                key: 'input',
+                label: 'Input',
+                type: FieldType.String,
+                description: 'Chat agents: a string (template-supported via {{step.field}}). ETL agents: rows array. When blank, falls back to upstream step output.',
+            },
+            {
+                key: 'overrides',
+                label: 'Overrides',
+                type: FieldType.JSON,
+                description: 'Optional per-step overrides of the agent\u2019s own settings: model, temperature, maxTokens, topP, instructions and instructionsMode.',
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'text', type: FieldType.String, description: 'Agent response text (chat agents)' },
+            { key: 'rows', type: FieldType.JSON, description: 'Output rows (etl agents)' },
+            { key: 'usage', type: FieldType.JSON, description: 'Token usage + cost: tokensIn, tokensOut, latencyMs, costUsd' },
+            { key: 'model', type: FieldType.String, description: 'Model that produced the response' },
+            { key: 'agentVersion', type: FieldType.Number, description: 'Version of the agent definition that ran' },
+        ],
+        sampleOutput: {
+            text: 'Sure — happy to help. What would you like to know?',
+            usage: { tokensIn: 42, tokensOut: 18, latencyMs: 612, costUsd: 0.000041 },
+            model: 'gpt-4o-mini',
+            agentVersion: 3,
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2026-05-27T00:00:00Z',
+    updatedAt: '2026-05-27T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/ai/idp-extract/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * IDP — Extract action.
+ *
+ * Workflow primitive that runs Intelligent Document Processing on files
+ * received from an upstream step (HTTP download, FTP get, query result,
+ * data stream from any connector that produces files).
+ *
+ * Engine resolves the configured LLM connector at execution time —
+ * same pattern as `_resolvedConnection` for HTTP steps — and calls
+ * the document-extraction service once per file. Results emit as one
+ * row per source file: { fileName, data, confidence, audit, error? }.
+ *
+ * The action does NOT take file uploads of its own. Wire an upstream
+ * step that emits files with `{ fileName, body | s3Key, contentType }`
+ * (HTTP binary response, FTP/Storage download, etc.) into this step.
+ */
+import { ActionDefinition } from '../../types';
+export declare const idpExtractDefinition: ActionDefinition;

package/dist/catalog/ai/idp-extract/index.js

@@ -0,0 +1,90 @@
+/**
+ * IDP — Extract action.
+ *
+ * Workflow primitive that runs Intelligent Document Processing on files
+ * received from an upstream step (HTTP download, FTP get, query result,
+ * data stream from any connector that produces files).
+ *
+ * Engine resolves the configured LLM connector at execution time —
+ * same pattern as `_resolvedConnection` for HTTP steps — and calls
+ * the document-extraction service once per file. Results emit as one
+ * row per source file: { fileName, data, confidence, audit, error? }.
+ *
+ * The action does NOT take file uploads of its own. Wire an upstream
+ * step that emits files with `{ fileName, body | s3Key, contentType }`
+ * (HTTP binary response, FTP/Storage download, etc.) into this step.
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const idpExtractDefinition = {
+    id: 'idp_extract',
+    name: 'IDP',
+    description: 'Extract structured data from documents received from an upstream step. Configure the model provider, model, and the JSON Schema to extract.',
+    category: ActionCategory.AI,
+    type: ActionType.IdpExtract,
+    tags: ['ai', 'idp', 'document', 'extract', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'DocumentImport',
+    color: '#0F62FE',
+    inputSchema: {
+        fields: [
+            {
+                key: 'llmConnectorId',
+                label: 'Model provider (connector)',
+                type: FieldType.Select,
+                description: 'Connected AI provider (OpenAI, Anthropic, Gemini, …). Resolved at execution time.',
+                validation: { required: true },
+            },
+            {
+                key: 'model',
+                label: 'Model',
+                type: FieldType.Select,
+                description: 'LLM available on the selected provider (e.g. gpt-4o, claude-3.5-sonnet, gemini-2.0-flash). Vision-capable models recommended.',
+                validation: { required: true },
+            },
+            {
+                key: 'expectedSchema',
+                label: 'Output schema',
+                type: FieldType.JSON,
+                description: 'JSON Schema describing the fields to extract. The LLM is forced to emit JSON matching this shape.',
+                // NOT required (DEV-220 rules parity, PO decision 2026-07-16): the
+                // schema is either LLM-generated at run time or user-supplied — an
+                // empty value is a valid "let the LLM infer it" configuration, so
+                // the rules engine must not flag it.
+                validation: { required: false },
+            },
+            {
+                key: 'systemPromptOverride',
+                label: 'System prompt override',
+                type: FieldType.String,
+                description: 'Optional extra instructions appended to the extraction prompt.',
+            },
+            {
+                key: 'strategy',
+                label: 'Strategy',
+                type: FieldType.Select,
+                description: 'vision-direct sends the file as an image to a vision LLM. auto picks based on PDF text content.',
+                defaultValue: 'vision-direct',
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            { key: 'state', type: FieldType.String, description: 'Aggregate state — completed | partial-success | failed.' },
+            {
+                key: 'pages',
+                type: FieldType.Array,
+                description: 'One row per file received from upstream: { fileName, data, confidence, audit, error? }',
+            },
+            {
+                key: 'totals',
+                type: FieldType.Object,
+                description: 'Summary { pages, completed, failed }',
+            },
+        ],
+    },
+    version: '2.0.0',
+    createdAt: '2026-05-06T00:00:00Z',
+    updatedAt: '2026-05-10T00:00:00Z',
+    createdBy: 'system',
+};

package/dist/catalog/api/graphql-query/config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * GraphQL Query Configuration
+ */
+export interface GraphQLQueryConfigType {
+    endpoint: string;
+    query: string;
+    variables?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+export declare const GraphQLQueryConfig: {
+    defaults: GraphQLQueryConfigType;
+    schema: {
+        endpoint: {
+            type: string;
+            required: boolean;
+        };
+        query: {
+            type: string;
+            required: boolean;
+        };
+        variables: {
+            type: string;
+            required: boolean;
+        };
+        headers: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<GraphQLQueryConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<GraphQLQueryConfigType>) => GraphQLQueryConfigType;
+    getLabel: (config: GraphQLQueryConfigType) => string;
+};