@uug-ai/models 1.6.1 → 1.6.3

package/dist/types.d.ts

@@ -25431,6 +25431,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/workflowdevice": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WorkflowDevice (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowDevice schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.WorkflowDevice"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/workflowedge": {
         parameters: {
             query?: never;
@@ -25509,6 +25548,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/workflowrun": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WorkflowRun (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowRun schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.WorkflowRun"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/workflowstage": {
         parameters: {
             query?: never;
@@ -25548,6 +25626,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/workflowstorage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WorkflowStorage (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowStorage schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.WorkflowStorage"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/workflowtrigger": {
         parameters: {
             query?: never;
@@ -25587,6 +25704,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/workflowuser": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WorkflowUser (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowUser schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.WorkflowUser"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/media": {
         parameters: {
             query?: never;
@@ -31329,6 +31485,8 @@ export interface components {
             /** @description Add more fields as needed */
             user?: components["schemas"]["models.User"];
         };
+        /** @enum {string} */
+        "models.NeedsMode": "any" | "all";
         "models.NotificationSettings": {
             detections?: components["schemas"]["models.Detections"];
             devices?: components["schemas"]["models.Devices"];
@@ -31698,18 +31856,26 @@ export interface components {
         "models.StageCondition": {
             /** @description see the ConditionOp consts */
             op?: components["schemas"]["models.ConditionOp"];
-            /** @description dot-path into the upstream op's result */
+            /** @description absolute dot-path into the run root (see type doc) */
             path?: string;
             /** @description comparison operand (unused for ConditionOpExists) */
             value?: unknown;
         };
         "models.StageDependency": {
             /**
-             * @description Condition is the predicate evaluated against the upstream's result. Nil
-             *     means the dependency matches as soon as the upstream resolves.
+             * @description Condition is the predicate evaluated against the run root. Nil means the
+             *     need matches as soon as its gate (if any) is satisfied.
              */
             condition?: components["schemas"]["models.StageCondition"];
-            /** @description Operation is the upstream stage this dependency waits on. */
+            /**
+             * @description Operation is the id of the operation whose presence gates this need: it must
+             *     be available on the run — present in Inputs or Results — before the need's
+             *     Condition is evaluated. It is an operation id, not necessarily a deployed
+             *     stage: the most common gate, "classify", is the analysis trigger (it arrives
+             *     in Inputs at open), not a stage. Empty means the need is ungated: a check on
+             *     the run root itself (device/user/identity, or an input present from open),
+             *     evaluated as soon as the run opens with nothing to wait for.
+             */
             operation?: string;
         };
         "models.StageParam": {
@@ -32469,6 +32635,14 @@ export interface components {
             user_id?: string;
             username?: string;
         };
+        "models.WorkflowDevice": {
+            deviceKey?: string;
+            deviceName?: string;
+            /** @description media VideoProvider: where the media is served from */
+            provider?: string;
+            /** @description media StorageSolution: where the media is stored */
+            storageSolution?: string;
+        };
         "models.WorkflowEdge": {
             /**
              * @description Condition is the structured predicate evaluated against the source stage's
@@ -32519,6 +32693,134 @@ export interface components {
             x?: number;
             y?: number;
         };
+        "models.WorkflowRun": {
+            /**
+             * @description Device identifies the recording the run derives from, with the few fields
+             *     vault-override resolution and logging need (device key/name and where the
+             *     media is stored/served from). Copied from the recording at hand-off time.
+             *     Wire-only.
+             */
+            device?: components["schemas"]["models.WorkflowDevice"];
+            /**
+             * @description Inputs is the immutable start context the run opens with, keyed by the
+             *     upstream operation that produced it (e.g. "classify" → the classification
+             *     result). Conditions and stages read upstream context from here; it is set
+             *     once by analysis and never mutated by the run. Persisted at open so a run
+             *     reloaded mid-flight still sees its start context.
+             */
+            inputs?: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Key is the media key the run is about: its natural identity, used to load
+             *     or open the run document. Copied from the recording at hand-off time.
+             */
+            key?: string;
+            /**
+             * @description Operation marks the message's role on the workflows queue (wire-only):
+             *       - "event": a fresh run hand-off from analysis. It opens the run and
+             *         carries the start context in Inputs (e.g. the classification result).
+             *       - any other value (e.g. "anpr"): either the engine dispatching that
+             *         stage to its worker (Storage populated), or the worker routing its
+             *         result back (Payload or Results populated). These never collide because the
+             *         workflows queue only ever carries the "event" open and worker results —
+             *         a dispatch goes to the worker's own queue — so the engine never has to
+             *         disambiguate a dispatch from a result.
+             */
+            operation?: string;
+            /**
+             * @description Payload is the self-describing block envelope a delegated-ingest worker
+             *     hands back for the platform to persist: one or more typed blocks (e.g. a
+             *     "detection" block carrying a PostDetectionsRequest, optionally followed by
+             *     "marker" blocks). It is the channel the shared ingest core reads from,
+             *     distinct from Results:
+             *
+             *       - Results is the multi-operation, decoded routing/state ledger the
+             *         condition matcher reads and the run persists.
+             *       - Payload is one worker's block envelope for a single ingest hop.
+             *
+             *     Lifecycle mirrors Storage and is one-directional (worker → engine):
+             *       - A delegated-ingest worker sets Payload on its result; the engine routes
+             *         it through ingest.IngestBlocks, persisting each block by its own type
+             *         into the platform-owned collection, and mirrors the envelope's blocks
+             *         grouped by type into Results[operation] (one array per block type, e.g.
+             *         results.<op>.detections) so a downstream conditional stage can test what
+             *         the stage produced. The engine targets the run's own recording
+             *         (Key/User/Device), so a payload that also carries its own recording
+             *         reference (e.g. a PostDetectionsRequest mediaKey/analysisId) has that
+             *         reference ignored on the queue path.
+             *       - A self-persisting worker writes its own collection and returns its
+             *         routing values in Results instead; Payload is empty.
+             *
+             *     `bson:"-"` is load-bearing: the raw body is ingested into its own
+             *     collection, never duplicated into the run's persisted state. The engine
+             *     never sets it on an outbound dispatch, so it never travels engine → worker.
+             */
+            payload?: number[];
+            /**
+             * @description RecordingTimestamp is the recording's start time (unix seconds), copied
+             *     from the recording at hand-off time. It is denormalised onto any platform
+             *     artifact the engine ingests (see Payload) so cleanup expires the artifact
+             *     on the recording's retention clock rather than the post time. It is set on
+             *     the analysis hand-off and persisted on the run at open; the engine then
+             *     reads it from the run document when stamping an ingested artifact. It is
+             *     therefore engine-internal — NOT sent on the engine→worker dispatch and not
+             *     something a worker has to echo back, so it is not part of the stage
+             *     contract.
+             */
+            recordingTimestamp?: number;
+            /**
+             * @description Results is the run's accumulated stage outputs, keyed by operation. Each
+             *     stage worker writes its result under its operation on the way back, and
+             *     conditions / downstream stages read upstream outputs from here. It grows
+             *     as the run progresses; the engine records each result into it. Together
+             *     with Inputs it is the durable condition bag (Results wins on any overlap).
+             */
+            results?: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description RunId is the run's identifier on the wire (the hex of the document Id). It
+             *     is empty on the analysis hand-off — the run is keyed by Key until the
+             *     engine opens it — and set on every engine→worker dispatch. The persisted
+             *     identity is Id, so RunId itself is wire-only.
+             */
+            runId?: string;
+            /**
+             * @description Storage carries the credentials a dispatched stage worker needs to fetch
+             *     the media (global Kerberos Storage plus any resolved per-recording vault
+             *     override). It is populated by the engine only on the engine→worker
+             *     dispatch hop and is empty on the analysis hand-off and the worker→engine
+             *     result. `bson:"-"` is load-bearing: credentials never sit in the run's
+             *     persisted state.
+             */
+            storage?: components["schemas"]["models.WorkflowStorage"];
+            /** @description TraceId continues the distributed trace across the workflow tail. */
+            traceId?: string;
+            /**
+             * @description User is the curated, secret-free account context a run needs: the
+             *     organisation that owns the recording (for logging/scoping) and the account
+             *     Storage block used to resolve a per-recording vault override. Copied (and
+             *     scrubbed) from the analysis monitor stage — credential/secret fields and the
+             *     individual user id never cross the boundary. Wire-only; the persisted scope
+             *     is UserId (which holds the organisation id).
+             */
+            user?: components["schemas"]["models.WorkflowUser"];
+            /**
+             * @description WorkflowId is the id of the Workflow definition (models.Workflow) this run
+             *     executes — the authored graph (nodes/edges/trigger) the run is an execution
+             *     of, as opposed to the global stage registry. Forward-looking: it is set once
+             *     the engine executes Workflow graphs; while the engine is driven by the flat
+             *     stage registry it is empty.
+             */
+            workflowId?: string;
+            /**
+             * @description WorkflowName is the human-readable name of that Workflow, carried so a
+             *     dispatch/result is legible in worker context and logs without a lookup.
+             *     Populated alongside WorkflowId.
+             */
+            workflowName?: string;
+        };
         "models.WorkflowStage": {
             /** @description Description explains what the stage does, for the catalog UI. */
             description?: string;
@@ -32549,19 +32851,43 @@ export interface components {
             /** @description Name is a human-friendly catalog name shown in the stage library. */
             name?: string;
             /**
-             * @description Needs lists the upstream dependencies of a conditional stage — its fan-in.
-             *     It is the compiled, runtime-authoritative projection of the workflow's
-             *     incoming edges (one entry per edge), not an independently editable field. At
-             *     least one entry is required when Dispatch is DispatchConditional; ignored
-             *     otherwise. The runtime re-evaluates the stage whenever any listed upstream
-             *     resolves, and the stage fires for the first dependency whose Condition
-             *     matches that upstream's result (a nil Condition matches unconditionally).
+             * @description Needs lists the dependencies of a conditional stage — its fan-in. It is the
+             *     compiled, runtime-authoritative projection of the workflow's incoming edges
+             *     (one entry per edge), not an independently editable field. At least one
+             *     entry is required when Dispatch is DispatchConditional; ignored otherwise.
+             *     The runtime re-evaluates the stage against the run root whenever the run
+             *     progresses; each need's Operation gates when its Condition may be read (an
+             *     empty Operation is ungated, evaluated at open) and the stage fires for the
+             *     first need whose Condition matches (a nil Condition matches unconditionally).
              */
             needs?: components["schemas"]["models.StageDependency"][];
+            /**
+             * @description NeedsMode controls how multiple Needs combine into a dispatch decision:
+             *     NeedsModeAny (the default) fires the stage as soon as one need is satisfied
+             *     (its gate operation available and its condition matching); NeedsModeAll
+             *     fires the stage only once every need is satisfied (a join). It is
+             *     meaningful only when Dispatch is DispatchConditional and there is more than
+             *     one need; with a single need both modes behave identically. Empty defaults
+             *     to NeedsModeAny.
+             */
+            needsMode?: components["schemas"]["models.NeedsMode"];
             /**
              * @description Operation uniquely identifies the stage and binds its queue, dispatch and
-             *     resolution. It is the key that workflow nodes reference. Two stages may
-             *     never share an operation.
+             *     resolution. It is the key workflow nodes reference, and the key under which
+             *     the stage's result is filed in a run's Inputs/Results. Two stages may never
+             *     share an operation.
+             *
+             *     Stage vs. operation — they are not synonyms:
+             *       - a STAGE is this definition: a deployed worker with a queue and a
+             *         dispatch rule.
+             *       - an OPERATION is the id string. It names this stage, and it is also the
+             *         key results are filed under on a run.
+             *     Every deployed stage has an operation, but a run's operation keyspace is
+             *     wider than its stages: it also includes the trigger analysis hands off
+             *     (e.g. "classify"), which seeds Inputs and can gate a need or be read by a
+             *     condition, yet is not itself a deployed stage. That is why routing —
+             *     Needs/gates, conditions, and the run's dispatched/resolved tiers — is keyed
+             *     by operation (the wider id space), while deployment talks in stages.
              */
             operation?: string;
             outputs?: components["schemas"]["models.StagePort"][];
@@ -32587,6 +32913,15 @@ export interface components {
             /** @description Tag is the image tag deployed for the stage. */
             tag?: string;
         };
+        "models.WorkflowStorage": {
+            accessKey?: string;
+            secret?: string;
+            uri?: string;
+            vaultOverrideAccessKey?: string;
+            vaultOverrideProvider?: string;
+            vaultOverrideSecret?: string;
+            vaultOverrideUri?: string;
+        };
         "models.WorkflowTrigger": {
             endAt?: string;
             /** @description Selection is the set of devices/streams the workflow applies to. */
@@ -32596,6 +32931,10 @@ export interface components {
             /** @description Weekdays restricts the workflow to the listed days of week. */
             weekdays?: number[];
         };
+        "models.WorkflowUser": {
+            organisationId?: string;
+            storage?: components["schemas"]["models.Storage"];
+        };
     };
     responses: never;
     parameters: never;
@@ -32854,10 +33193,14 @@ export declare namespace models {
     type Webhook = components['schemas']['models.Webhook'];
     type WeeklySchedule = components['schemas']['models.WeeklySchedule'];
     type Workflow = components['schemas']['models.Workflow'];
+    type WorkflowDevice = components['schemas']['models.WorkflowDevice'];
     type WorkflowEdge = components['schemas']['models.WorkflowEdge'];
     type WorkflowNode = components['schemas']['models.WorkflowNode'];
+    type WorkflowRun = components['schemas']['models.WorkflowRun'];
     type WorkflowStage = components['schemas']['models.WorkflowStage'];
+    type WorkflowStorage = components['schemas']['models.WorkflowStorage'];
     type WorkflowTrigger = components['schemas']['models.WorkflowTrigger'];
+    type WorkflowUser = components['schemas']['models.WorkflowUser'];
 }
 export declare namespace api {
     type AddAccessTokenErrorResponse = components['schemas']['api.AddAccessTokenErrorResponse'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uug-ai/models",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "TypeScript type definitions for Go models",
   "main": "dist/types.js",
   "types": "dist/types.d.ts",