@octaviaflow/flow-rules 0.12.0 → 0.13.1

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

@@ -39,6 +39,12 @@ export interface AiAgentConfigType {
      */
     input?: string;
     overrides?: AiAgentOverrides;
+    /**
+     * Per-row mode only: the most model calls the step may make (one per
+     * upstream row). Default 50, at most 1000 — a run with more rows stops
+     * before any call (DEV-428).
+     */
+    maxRows?: number;
 }
 export declare const AiAgentConfig: {
     defaults: AiAgentConfigType;
@@ -58,6 +64,12 @@ export declare const AiAgentConfig: {
             required: boolean;
             description: string;
         };
+        maxRows: {
+            type: string;
+            required: boolean;
+            min: number;
+            description: string;
+        };
     };
     validate: (config: Partial<AiAgentConfigType>) => {
         valid: boolean;

package/dist/catalog/general/aggregate/config.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Aggregate Action — Config Contract
+ *
+ * Fold the upstream records into ONE row — or one row per group — of computed
+ * values. It exists because nothing else could total a column (DEV-422): a
+ * Transform maps one record at a time and cannot see the others, and the only
+ * built-in sum was ForEach's `collect: 'reduce'`, which reduces loop-body
+ * results and is reachable from nowhere an author, or an agent reading
+ * `describe_action_type`, would look.
+ *
+ * Output: `{ data: [ { ...groupKeys, ...metrics } ], _meta }` — the same
+ * `data: row[]` envelope Query, Transform and Variables emit, so the Transform
+ * after it maps `{{totals[].TotalAmount}}` exactly as it maps a Query's rows.
+ *
+ * The Engine's `aggregateExecutor.ts` reads this shape; the two stay in step.
+ */
+/** The functions a metric can apply. `describe_action_type` lists them. */
+export declare const AGGREGATE_FUNCTIONS: readonly ["sum", "count", "avg", "min", "max", "count_distinct", "first", "last"];
+export type AggregateFn = (typeof AGGREGATE_FUNCTIONS)[number];
+/** What each function computes — the panel's help text and the contract's description. */
+export declare const AGGREGATE_FUNCTION_DESCRIPTIONS: Readonly<Record<AggregateFn, string>>;
+export interface AggregateMetric {
+    /** One of `AGGREGATE_FUNCTIONS`. */
+    fn: AggregateFn;
+    /**
+     * The record field it reads — a dot-path such as "Balance" or
+     * "CustomerRef.name". `count` may omit it to count records.
+     */
+    field?: string;
+    /** The key the value lands under on the output row. An identifier, unique within the step. */
+    as: string;
+    /** Round a sum or avg to this many decimal places (0–10). Omit to keep the value as computed. */
+    decimals?: number;
+}
+export interface AggregateConfigType {
+    /**
+     * Which upstream records: a path to an array in the upstream step's output.
+     * Empty means the records the previous step produced (its `data`). Resolved
+     * exactly as ForEach's `arrayPath`.
+     */
+    arrayPath?: string;
+    /**
+     * Record fields (dot-paths) to group by. Empty: one row for all records.
+     * Each key lands on the output row under its last segment
+     * ("CustomerRef.name" → "name").
+     */
+    groupBy?: string[];
+    /** The values to compute. At least one. */
+    metrics: AggregateMetric[];
+    /**
+     * The name later steps use for this result, e.g. `totals` →
+     * `{{totals[].TotalAmount}}`. Defaults to the step's name.
+     */
+    outputAs?: string;
+    /**
+     * The output ROW's schema, written by the panel at save time so the picker
+     * shows the keys before a run. The Backend contributor derives the same
+     * thing from the config with `computeOutputSchema`.
+     */
+    _outputSchema?: {
+        type: 'object';
+        properties: Record<string, unknown>;
+    };
+}
+/** A JSON-schema-like node, as the DataStream and `_outputSchema` carry it. */
+export interface AggregateSchemaNode {
+    type?: string;
+    properties?: Record<string, AggregateSchemaNode>;
+    items?: AggregateSchemaNode;
+    description?: string;
+}
+/**
+ * The output key a group-by field lands under: its last path segment, with a
+ * trailing `[]` removed. "CustomerRef.name" → "name"; "Region" → "Region".
+ * The Engine names the group keys the same way.
+ */
+export declare function groupKeyName(path: string): string;
+export declare const AggregateConfig: {
+    schema: {
+        arrayPath: {
+            type: string;
+            required: boolean;
+            dynamic: boolean;
+            description: string;
+        };
+        groupBy: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        metrics: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        outputAs: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+    };
+    defaults: AggregateConfigType;
+    /**
+     * What blocks execution, refused before the run (a 409 on an active flow
+     * over MCP, a warning on a draft): no metrics, an unknown function, a
+     * function with nothing to read, an output key that is not an identifier or
+     * is taken, decimals outside 0–10, an outputAs that is not a single name.
+     */
+    validate(config: Partial<AggregateConfigType>): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * The schema of ONE output row: the group keys (typed from the source record
+     * when `source` is known) and each metric under its `as`. The panel writes
+     * it to `_outputSchema`; the Backend contributor wraps it as `array<row>` at
+     * the step's output path. One implementation, two callers.
+     */
+    computeOutputSchema(config: Partial<AggregateConfigType>, source?: AggregateSchemaNode): {
+        type: "object";
+        properties: Record<string, unknown>;
+    };
+    merge(userConfig: Partial<AggregateConfigType>): AggregateConfigType;
+    /** "sum(Balance), count by name" — the node's auto label. */
+    getLabel(config: Partial<AggregateConfigType>): string;
+};

package/dist/catalog/general/aggregate/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Aggregate Action
+ *
+ * Totals, counts, averages, min/max, distinct counts and first/last over the
+ * upstream records — one output row, or one per group. Sits after the step
+ * that produces the rows and before the step that writes the result (the
+ * "TOTAL row" case: Query → Transform (insert rows) → Aggregate → Transform
+ * (insert one row)). The config contract is `./config.ts` (DEV-422).
+ */
+import { ActionDefinition } from '../../types';
+export declare const aggregateDefinition: ActionDefinition;

package/dist/catalog/index.d.ts

@@ -16,6 +16,7 @@ import { forEachDefinition } from './logic/for-each';
 import { groupDefinition } from './logic/group';
 import { queryDefinition } from './general/query';
 import { transformDefinition } from './general/transform';
+import { aggregateDefinition } from './general/aggregate';
 import { csvActionDefinition } from './storage/csv-action';
 import { jsonActionDefinition } from './storage/json-action';
 import { xmlActionDefinition } from './storage/xml-action';
@@ -54,4 +55,4 @@ export declare const getActionById: (id: string) => ActionDefinition | undefined
  * Get actions by category
  */
 export declare const getActionsByCategory: (category: ActionCategory) => ActionDefinition[];
-export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };
+export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, aggregateDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };

package/dist/catalog/isOneOf.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Membership test for a readonly string tuple, narrowing the value to the
+ * tuple's union. Shared by the contracts that refuse a value outside a fixed
+ * set (Transform's mode/operation, Aggregate's function) so each names the
+ * allowed values in its message instead of failing at run time.
+ */
+export declare const isOneOf: <T extends string>(set: readonly T[], value: unknown) => value is T;

package/dist/catalog/logic/for-each/recordSchema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The shape of ONE record at a path in an upstream step's output — what a
+ * step that reads those records sees per row — and the field names it
+ * carries. Pure and framework-free, so a panel that picks a record field
+ * (Aggregate's group-by and metric fields, DEV-422) offers the fields the
+ * Engine's `resolveArrayPath` will actually hand the step.
+ *
+ * Resolution order mirrors the ForEach panel's source resolution: the
+ * upstream node's static schema (`outputSchema`, else the editor's
+ * `config._outputSchema`) walked along the path; then the last run's sample
+ * output; then the static schema as a whole. Only the first upstream node is
+ * consulted — it is the one the step is wired from.
+ */
+import { type UpstreamNodeRef } from './pathOptions';
+export interface RecordSchemaLike {
+    type?: string;
+    properties?: Record<string, any>;
+    items?: any;
+}
+export declare function resolveRecordSchema(upstreamNodes: UpstreamNodeRef[] | undefined, arrayPath: string): RecordSchemaLike | undefined;
+/**
+ * The field names a record at `arrayPath` carries: the resolved schema's
+ * keys, unioned with the ACTUAL keys of the last run's records — live rows
+ * can be sparse or carry system fields a describe-derived schema omits.
+ */
+export declare function detectRecordFields(upstreamNodes: UpstreamNodeRef[] | undefined, arrayPath: string): string[];

package/dist/catalog/types.d.ts

@@ -47,6 +47,7 @@ export declare enum ActionType {
     SpeechToText = "speech_to_text",
     TextToSpeech = "text_to_speech",
     Transform = "transform",
+    Aggregate = "aggregate",
     FileOperation = "file_operation",
     FileAction = "file_action",
     CsvAction = "csv_action",