aimeat 1.23.3 → 1.24.0

package/dist/src/generated/api-types.d.ts

@@ -8134,6 +8134,159 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/workflows": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the owner's workflows
+         * @description Agent Workflows are declared, ordered agent pipelines with per-step input/output signals — the abstraction the bare scheduler lacks ("did it produce", not just "did it fire"). Definitions live in the owner's own memory (`workflows.def.<id>`). Readable by the owner or an agent holding `workflow:read`.
+         */
+        get: operations["listWorkflows"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/workflows/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Workflow id (lowercase slug) */
+                id: string;
+            };
+            cookie?: never;
+        };
+        /** Get one workflow definition */
+        get: operations["getWorkflow"];
+        /**
+         * Create or update a workflow (save-time validated)
+         * @description Rejected (400 WORKFLOW_INVALID, `error.details.errors[]`) unless the `after` graph is a DAG and every step's agent/offer is workflow-compatible — i.e. publishes `success_signal` + `required_to_function` + `deliverable.location`. A step using an `llm` signal leaf requires `llm.approved=true` (owner consent to node-LLM use). Authorable by the owner or an agent holding `workflow:write`.
+         */
+        put: operations["putWorkflow"];
+        post?: never;
+        /** Delete a workflow definition */
+        delete: operations["deleteWorkflow"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/workflows/{id}/blueprint": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * The derived "whole workflow" graph
+         * @description Composes the steps into one structural blueprint (nodes + dependency edges + the memory key templates each step reads/writes), derived from the agents' CURRENT offers along the step order — not hand-authored. Returns 409 WORKFLOW_STALE if the workflow no longer resolves against the current offers.
+         */
+        get: operations["getWorkflowBlueprint"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/workflows/{id}/run": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start a workflow run (manual / test)
+         * @description `mode=signals-only` evaluates every step's signals against existing memory with NO dispatch (an instant health check — the run completes synchronously) · `mode=full` executes the steps live (dispatches the agent tasks; poll the run for progress). `vars` overrides the workflow's declared variables for this run. Requires `workflow:write` (owners bypass). Returns the runId.
+         */
+        post: operations["runWorkflow"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/workflows/{id}/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * Run-health trend over recent runs
+         * @description The "did it produce" trend derived from the recent runs: per-step green/red counts, last run status + time, last success time, and the mean run duration. Requires `workflow:read`.
+         */
+        get: operations["getWorkflowHealth"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/workflows/{id}/runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        /**
+         * List a workflow's runs
+         * @description Newest first. Empty until the deterministic engine ships (Phase 4).
+         */
+        get: operations["listWorkflowRuns"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/workflows/{id}/runs/{runId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                runId: string;
+            };
+            cookie?: never;
+        };
+        /** Get one workflow run (per-step state + observed values) */
+        get: operations["getWorkflowRun"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/agents/{name}/schedules": {
         parameters: {
             query?: never;
@@ -11101,6 +11254,122 @@ export interface components {
             instance_id?: string;
             input?: Record<string, never>;
         };
+        /** @description A plain string, or a locale-keyed map (e.g. en_US / fi_FI text). */
+        LocalizedString: string | {
+            [key: string]: string;
+        };
+        /** @description A signal tree evaluated against owner memory, with {var} templated from the run params. A leaf is deterministic ({ kind: deterministic, key|key_glob, op: exists|nonempty| count_nonempty|json_valid|json_schema|json_field, … }) or llm ({ kind: llm, key|key_glob, ask }); composites are { all: [...] }, { any: [...] }, or { when, then }. See workflow-schemas.ts for the full grammar. */
+        WorkflowSignal: {
+            [key: string]: unknown;
+        };
+        WorkflowVar: {
+            name: string;
+            /** @description 'date' | 'enum[a,b]' | 'string' | … */
+            type: string;
+            description: components["schemas"]["LocalizedString"];
+            default?: string;
+            example?: string;
+        };
+        WorkflowStep: {
+            id: string;
+            /** @description One agent name, or a list (a list runs in parallel within the step). */
+            agent: string | string[];
+            /** @description Inherit success_signal + required_to_function from this offer. */
+            offer: string;
+            /** @description Dependency order (DAG). */
+            after?: string[];
+            description: components["schemas"]["LocalizedString"];
+            /** @description Input gate (consumer-owned). A signal, or the literal 'none'. Inherited from the offer if omitted. */
+            required_to_function?: components["schemas"]["WorkflowSignal"] | "none";
+            success_signal?: components["schemas"]["WorkflowSignal"];
+            retry?: {
+                max?: number;
+                backoff_min?: number;
+            };
+            /** @description Max minutes to wait for this step's success signal before timed-out. Default 60. */
+            timeout_min?: number;
+        };
+        WorkflowTrigger: {
+            /** @enum {string} */
+            kind: "schedule" | "manual" | "event";
+            /** @description schedule kind */
+            cron?: string;
+            timezone?: string;
+            /**
+             * @description event kind
+             * @enum {string}
+             */
+            on?: "memory.write" | "offer.ordered";
+            /** @description event kind */
+            match?: {
+                [key: string]: string;
+            };
+        };
+        WorkflowDefInput: {
+            title: components["schemas"]["LocalizedString"];
+            description: components["schemas"]["LocalizedString"];
+            trigger: components["schemas"]["WorkflowTrigger"];
+            vars: components["schemas"]["WorkflowVar"][];
+            steps: components["schemas"]["WorkflowStep"][];
+            /** @enum {string} */
+            on_step_fail: "inspect";
+            /** @description Owner consent to use the node OpenRouter for `llm` signal leaves. */
+            llm?: {
+                approved?: boolean;
+            };
+            /** @description Optional per-workflow cap. */
+            costCapMorsels?: number | null;
+        };
+        WorkflowDef: components["schemas"]["WorkflowDefInput"] & {
+            id?: string;
+            /** @description Author GAII/GHII (audit). */
+            createdBy?: string;
+            /** Format: date-time */
+            createdAt?: string;
+            /** Format: date-time */
+            updatedAt?: string;
+        };
+        WorkflowBlueprint: {
+            workflowId?: string;
+            nodes?: {
+                stepId?: string;
+                agents?: string[];
+                offerId?: string;
+                /** @description Key templates the input gate checks. */
+                reads?: string[];
+                /** @description Key templates the output check + deliverable touch. */
+                writes?: string[];
+            }[];
+            edges?: {
+                from?: string;
+                to?: string;
+            }[];
+        };
+        WorkflowRun: {
+            runId?: string;
+            workflowId?: string;
+            /** @enum {string} */
+            status?: "running" | "waiting-step" | "red" | "partial" | "done";
+            /** @enum {string} */
+            mode?: "full-live" | "full-sandbox" | "signals-only";
+            vars?: {
+                [key: string]: string;
+            };
+            steps?: {
+                [key: string]: {
+                    /** @enum {string} */
+                    state?: "pending" | "input-red" | "dispatched" | "green" | "output-red" | "timed-out" | "skipped";
+                    attempt?: number;
+                    taskIds?: string[];
+                    reads?: string[];
+                    writes?: string[];
+                };
+            };
+            /** Format: date-time */
+            startedAt?: string;
+            /** Format: date-time */
+            endedAt?: string;
+        };
     };
     responses: {
         /** @description Successful AIMEAT response */
@@ -24220,6 +24489,306 @@ export interface operations {
             404: components["responses"]["NotFound"];
         };
     };
+    listWorkflows: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The owner's workflow definitions */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            workflows?: components["schemas"]["WorkflowDef"][];
+                            count?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getWorkflow: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Workflow id (lowercase slug) */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Workflow definition */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: components["schemas"]["WorkflowDef"];
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    putWorkflow: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Workflow id (lowercase slug) */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WorkflowDefInput"];
+            };
+        };
+        responses: {
+            /** @description Workflow saved */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: components["schemas"]["WorkflowDef"];
+                    };
+                };
+            };
+            /** @description Validation failed (error.details.errors[] lists the problems) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    deleteWorkflow: {
+        parameters: {
+            query?: {
+                /** @description When true, also drop the workflow's run records. */
+                withRuns?: boolean;
+            };
+            header?: never;
+            path: {
+                /** @description Workflow id (lowercase slug) */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Workflow deleted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    getWorkflowBlueprint: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Blueprint */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: components["schemas"]["WorkflowBlueprint"];
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+            /** @description Workflow no longer resolves against current offers */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+        };
+    };
+    runWorkflow: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @enum {string} */
+                    mode: "signals-only" | "full";
+                    /**
+                     * @description full only: sandbox namespaces every key under wf-test.<runId>. (never clobbers prod); live writes the real keys (default).
+                     * @enum {string}
+                     */
+                    target?: "sandbox" | "live";
+                    /** @description Override declared vars for this run. */
+                    vars?: {
+                        [key: string]: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            /** @description Run started (signals-only completes synchronously; full dispatches) */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            runId?: string;
+                            mode?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Could not start the run (error.details.errors[] lists why) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getWorkflowHealth: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Health trend */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            workflowId?: string;
+                            /** @description Number of runs sampled. */
+                            sample?: number;
+                            lastStatus?: string | null;
+                            /** Format: date-time */
+                            lastRunAt?: string | null;
+                            /** Format: date-time */
+                            lastSuccessAt?: string | null;
+                            meanDurationMs?: number | null;
+                            steps?: {
+                                stepId?: string;
+                                green?: number;
+                                red?: number;
+                                sample?: number;
+                            }[];
+                        };
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
+    listWorkflowRuns: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Runs */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: {
+                            runs?: components["schemas"]["WorkflowRun"][];
+                            count?: number;
+                        };
+                    };
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+        };
+    };
+    getWorkflowRun: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+                runId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Run */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AimeatEnvelope"] & {
+                        data?: components["schemas"]["WorkflowRun"];
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+        };
+    };
     listAgentSchedules: {
         parameters: {
             query?: never;