@camstack/types 1.1.56 → 1.1.58

package/dist/types/agent-pipeline-settings.d.ts

@@ -19,10 +19,11 @@
  */
 import type { CameraPipelineConfig } from './camera-pipeline.js';
 /**
- * Per-addon configuration stored under `agent.addonDefaults[addonId]`.
- * Every addon in the catalog gets one entry — whether enabled or not.
- * Operators edit these to pick models, tune settings, flip default
- * enabled state for their hardware.
+ * LEGACY per-addon configuration (the removed per-node model layer,
+ * `agent.addonDefaults[addonId]`). Retained ONLY for the one-shot boot
+ * migration that strips `addonDefaults`, and for UI/library code pending
+ * the per-(node,device) rework. New code carries model/settings per
+ * `(node,device)` via {@link DeviceStepConfig}.
  *
  * modelId present ONLY when the operator explicitly chose a model;
  * absent = use this node's format default (resolved on-the-fly by the
@@ -34,16 +35,25 @@ export interface AgentAddonConfig {
     readonly settings: Readonly<Record<string, unknown>>;
 }
 /**
- * Partial override of a single addon's config for one (device, agent) pair.
- * Every field is optional — the resolver shallow-merges this patch on top
- * of the agent.addonDefaults base, so operators can override one field
- * (e.g. just the model) without redeclaring the whole config. The merge is
- * per-field on the top-level interface keys only: when `settings` is present
- * on the patch, it fully replaces the base `settings` map (no key-level
- * deep merge inside `settings`).
+ * Per-(node,device) BASE provisioning for one step: the model + intrinsic
+ * settings the executing node applies for EVERY camera landing on that
+ * accelerator. Both fields optional — absent = the executor resolves its own
+ * format default at runtime. This is the same shape carried by the
+ * per-camera-device OVERRIDE ({@link CameraStepOverridePatch}); the dispatch
+ * provisioning stage merges override on top of base (`override ?? base`).
+ */
+export interface DeviceStepConfig {
+    readonly modelId?: string;
+    readonly settings?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Per-(camera,node,device,step) override patch over the per-(node,device)
+ * base ({@link DeviceStepConfig}). Both fields optional — unset means
+ * "inherit from the device base". Enablement is NOT carried here: which
+ * steps run is the per-camera `stepToggles` authority. When `settings` is
+ * present it merges over the base `settings` (override keys win).
  */
 export interface CameraStepOverridePatch {
-    readonly enabled?: boolean;
     readonly modelId?: string;
     readonly settings?: Readonly<Record<string, unknown>>;
 }
@@ -57,7 +67,6 @@ export interface CameraStepOverridePatch {
  * on these settings nor carried on the attach payload.
  */
 export interface AgentPipelineSettings {
-    readonly addonDefaults: Readonly<Record<string, AgentAddonConfig>>;
     /**
      * Optional per-node camera capacity cap. When set, the load balancer will
      * not assign more than this many cameras to this agent. `null` = unlimited.
@@ -111,10 +120,21 @@ export interface AgentPipelineSettings {
      * one best accelerator, others opt-in. When TWO+ keys are enabled the
      * dispatcher balances new sessions across them (weighted, by active-session
      * count) so the accelerators run CONCURRENTLY.
+     *
+     * `steps` (per-(node,device) BASE provisioning) — an optional
+     * `stepId → {modelId?, settings?}` map: the default model + intrinsic
+     * settings for EVERY camera landing on that accelerator, overridable
+     * per-camera via `cameraSettings.stepOverridesByDevice`. A stepId ABSENT ⇒
+     * that step uses the device format default. A pinned modelId MUST have a
+     * build for the device's FORMAT, else the executor's `resolveInputSteps`
+     * substitutes it back to the format default (the UI only offers
+     * format-compatible models, so a stored base is always valid).
      */
     readonly inferenceDevices?: Readonly<Record<string, {
         readonly enabled: boolean;
         readonly weight?: number;
+        readonly maxSessions?: number;
+        readonly steps?: Readonly<Record<string, DeviceStepConfig>>;
     }>>;
 }
 /**
@@ -128,15 +148,15 @@ export interface CameraPipelineSettings {
     readonly pinnedAgentNodeId?: string;
     readonly stepToggles?: Readonly<Record<string, boolean>>;
     /**
-     * L2.5 per-agent per-step override. Shallow-merged on top of the L1
-     * agent defaults AFTER the L2 flat stepToggles overlay but BEFORE the
-     * L3 wholesale bypass. `pipelineByAgent[agent]` still takes full
-     * precedence when present — the L2.5 map for that agent is ignored.
-     * When an L2.5 patch has `enabled` set, it supersedes the corresponding
-     * L2 `stepToggles` entry for that (agent, addonId) pair; L2 still
-     * applies when the L2.5 patch leaves `enabled` undefined.
+     * Per-(camera,node,device) model/settings override. Addressed by
+     * `[agentNodeId][deviceKey][addonId]` because the camera is balanced onto
+     * one `(node,deviceKey)` per session and a node's accelerators share no
+     * format. Overrides the per-(node,device) base
+     * (`inferenceDevices[node][deviceKey].steps`) for one camera on one
+     * accelerator; the wholesale `pipelineByAgent[agent]` escape hatch, when
+     * present, still bypasses this. Enablement is orthogonal (`stepToggles`).
      */
-    readonly stepOverridesByAgent?: Readonly<Record<string, Readonly<Record<string, CameraStepOverridePatch>>>>;
+    readonly stepOverridesByDevice?: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, CameraStepOverridePatch>>>>>>;
     /**
      * Per-agent wholesale pipeline override. Engine is NOT stored here —
      * the override runs under the engine selected on that agent via the

package/dist/utils/runtime-mapping.d.ts

@@ -21,6 +21,22 @@ export type PipelineRuntime = 'node' | 'python';
  * Python backends use their native format.
  */
 declare const BACKEND_TO_FORMAT: Readonly<Record<string, ModelFormat>>;
+/**
+ * DEVICE-POOL backend → model format — the SSOT for the multi-device inference
+ * DESCRIPTOR path (Python per-device pools), distinct from {@link BACKEND_TO_FORMAT}
+ * above which is the legacy NODE runtime map (where `coreml → onnx` because
+ * onnxruntime-node's CoreML EP loads `.onnx`). Here a device pool runs the
+ * backend NATIVELY, so `coreml → coreml` and `edgetpu → tflite`. Consumed by
+ * `resolveDeviceEngine` (addon-pipeline) and the orchestrator's
+ * `parseDeviceKey`/`getNodeInferenceDevices` — the previously-duplicated
+ * `BACKEND_FORMAT` maps (R3/node-F2). `cpu`/`cuda` floor to onnx.
+ */
+declare const DEVICE_BACKEND_TO_FORMAT: Readonly<Record<string, ModelFormat>>;
+/**
+ * Resolve a DEVICE-POOL backend to its model format via {@link DEVICE_BACKEND_TO_FORMAT},
+ * flooring unknown backends to `onnx`. The single entry point both addons call.
+ */
+declare function deviceBackendToFormat(backend: string): ModelFormat;
 /**
  * Map DetectionRuntime to ModelFormat.
  * Used when the addon receives an explicit runtime (not 'auto').
@@ -84,4 +100,4 @@ export declare function pythonScriptForBackend(backend: string): string | undefi
  * 'coreml', 'pytorch', 'openvino' need Python; 'onnx' and 'tflite' don't.
  */
 export declare function requiresPython(runtime: DetectionRuntime | string): boolean;
-export { BACKEND_TO_FORMAT, RUNTIME_TO_FORMAT, PYTHON_SCRIPT };
+export { BACKEND_TO_FORMAT, DEVICE_BACKEND_TO_FORMAT, deviceBackendToFormat, RUNTIME_TO_FORMAT, PYTHON_SCRIPT, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.1.56",
+  "version": "1.1.58",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",