@foresthubai/workflow-core 0.4.6 → 0.4.7

package/src/deploy/requirements.ts

@@ -1,159 +1,104 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright (c) 2026 ForestHub.
-
-import type { Workflow } from "../workflow";
-import { NodeRegistry, isNodeUsedAsTool } from "../node";
-import { isParameterActive } from "../parameter";
-
-/**
- * Model ids that nodes reference but the workflow does not declare in `models`.
- * A `modelSelect` accepts exactly two sources — declared custom models and the
- * static catalog — so any referenced id that isn't a declared model is a catalog
- * model: it carries no declared config, yet still needs a provider/credential
- * supplied at deploy.
- *
- * This is the one deploy demand the workflow's resource arrays can't express:
- * channels/memory/declared-models are enumerable directly from
- * `workflow.{channels,memory,models}`, but catalog model ids live only on the
- * nodes that pick them — hence the walk. Spans every canvas (main + function
- * bodies) and honors parameter activation, so a model behind an inactive
- * `modelSelect` (pruned on serialize, never deployed) is not counted.
- */
-export function getReferencedCatalogModelIds(workflow: Workflow): string[] {
-  const declaredModel = new Set(Object.keys(workflow.models));
-  const catalogIds = new Set<string>();
-
-  for (const canvas of Object.values(workflow.canvases)) {
-    for (const node of canvas.nodes) {
-      const def = NodeRegistry.getByType(node.type);
-      if (!def) continue;
-      const args = node.arguments as Record<string, unknown>;
-      const isToolInput = isNodeUsedAsTool(node.id, node, canvas.edges);
-      for (const param of def.parameters) {
-        if (param.type !== "modelSelect") continue;
-        if (!isParameterActive(param, args, isToolInput)) continue;
-        const id = args[param.id];
-        if (typeof id === "string" && id !== "" && !declaredModel.has(id)) {
-          catalogIds.add(id);
-        }
-      }
-    }
-  }
-
-  return [...catalogIds];
-}
-
-// The five hardware-channel families the engine has a driver for. UART is the
-// odd one out: it carries no per-channel sub-address (see `addressable`).
-export type HardwareFamily = "gpio" | "adc" | "dac" | "pwm" | "serial";
-
-// One hardware channel the workflow declares. `family` is derived from the
-// channel type; `addressable` is false only for serial/UART (every
-// gpio/adc/dac/pwm channel needs an `index` sub-address, UART does not).
-export interface HardwareChannel {
-  id: string;
-  label: string;
-  family: HardwareFamily;
-  addressable: boolean;
-}
-
-export interface MqttChannel {
-  id: string;
-  label: string;
-}
-
-// One custom/self-hosted model declared in workflow.models — needs an
-// ExternalResources provider entry (a device sidecar or a network endpoint).
-export interface CustomModel {
-  id: string;
-  label: string;
-}
-
-// What a workflow needs from its environment, derived from its content alone —
-// no operator input. Drives both input collection (which bindings to ask for)
-// and the spec resolver's completeness check. The component-set derivation the
-// migration doc names as must-not-be-duplicated lives here, shared by every
-// producer.
-export interface DeployRequirements {
-  // At least one Agent references a catalog model (not declared in
-  // workflow.models) — that model needs a provider key as engine env.
-  hasProviderModel: boolean;
-  // The workflow has a Retriever node. A standalone engine has no retriever, so
-  // the node cannot resolve — a producer may refuse to deploy.
-  hasRetriever: boolean;
-  // The workflow has a WebSearchTool node — needs a web-search key as engine env.
-  hasWebSearch: boolean;
-  // Every hardware channel, in declaration order; drives the device manifest +
-  // mapping + container device passthrough.
-  hardwareChannels: HardwareChannel[];
-  // Every MQTT channel; each becomes an ExternalResources entry + a mapping.
-  mqttChannels: MqttChannel[];
-  // Every declared custom model; each becomes an ExternalResources provider + a
-  // mapping (and a llama-server sidecar when bound on-device).
-  customModels: CustomModel[];
-}
-
-// Drift sentinel: a new ChannelType widens the switch input and breaks
-// compilation here until the new type is classified above.
-function assertNeverChannel(t: never): never {
-  throw new Error(`unhandled channel type: ${String(t)}`);
-}
-
-// deriveRequirements reads what a workflow demands of its environment. Pure —
-// no I/O, no operator input. Sorts every declared channel into the hardware /
-// MQTT pools the deploy artifacts need and walks nodes (main + function bodies)
-// for the catalog-model / retriever / web-search signals.
-export function deriveRequirements(workflow: Workflow): DeployRequirements {
-  const hardwareChannels: HardwareChannel[] = [];
-  const mqttChannels: MqttChannel[] = [];
-
-  for (const channel of Object.values(workflow.channels)) {
-    switch (channel.type) {
-      case "GPIOIN":
-      case "GPIOOUT":
-        hardwareChannels.push({ id: channel.id, label: channel.label, family: "gpio", addressable: true });
-        break;
-      case "ADC":
-        hardwareChannels.push({ id: channel.id, label: channel.label, family: "adc", addressable: true });
-        break;
-      case "DAC":
-        hardwareChannels.push({ id: channel.id, label: channel.label, family: "dac", addressable: true });
-        break;
-      case "PWM":
-        hardwareChannels.push({ id: channel.id, label: channel.label, family: "pwm", addressable: true });
-        break;
-      case "UART":
-        hardwareChannels.push({ id: channel.id, label: channel.label, family: "serial", addressable: false });
-        break;
-      case "MQTT":
-        mqttChannels.push({ id: channel.id, label: channel.label });
-        break;
-      case "LOG":
-        // Resolves to the ambient engine logger — no platform resource to bind, so
-        // it demands nothing of the deploy environment.
-        break;
-      default:
-        return assertNeverChannel(channel.type);
-    }
-  }
-
-  let hasRetriever = false;
-  let hasWebSearch = false;
-  for (const canvas of Object.values(workflow.canvases)) {
-    for (const node of canvas.nodes) {
-      if (node.type === "Retriever") hasRetriever = true;
-      else if (node.type === "WebSearchTool") hasWebSearch = true;
-    }
-  }
-
-  const customModels: CustomModel[] = Object.values(workflow.models).map((m) => ({ id: m.id, label: m.label }));
-
-  return {
-    hasProviderModel: getReferencedCatalogModelIds(workflow).length > 0,
-    hasRetriever,
-    hasWebSearch,
-    hardwareChannels,
-    mqttChannels,
-    customModels,
-  };
-}
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 ForestHub.
+
+// Stage 0 of the deployment pipeline (docs/deployment-pipeline.md): extract the
+// binding SURFACE a workflow demands — which resource ids must be bound, and of
+// what kind — from the workflow content alone. This is the language-neutral
+// requirement analysis every deploy path (OSS CLI, backend) shares.
+
+import type { Workflow } from "../workflow";
+
+// The binding kind a workflow resource must be bound with — the discriminator of
+// the deployment api's ResourceBindingRequest.
+//
+// CROSS-LANGUAGE SEAM: these string values MUST match the backend's
+// deploy.BindingRequirement constants (fh-backend deploy.WorkflowBindingRequirements),
+// which are themselves the ResourceBindingRequest discriminators
+// ("hardware"/"mqtt"/"declaredModel"/"catalogModel"/"rag"). A value that drifts
+// here silently disagrees with the backend about what a workflow needs bound.
+//
+// Two deliberate asymmetries with the backend today, each a known catch-up:
+//  - "camera" is OSS-ahead: the backend's extractor predates the CAMERA channel
+//    and has no camera binding kind yet. OSS emits it; the backend will add it.
+//  - "rag" is absent: OSS is behind on retrieval — it does not yet extract a
+//    VectorDatabase memory resource as a requirement (the backend emits "rag").
+//    Add it when the OSS engine gains a retrieval backing.
+export type BindingKind = "hardware" | "mqtt" | "camera" | "declaredModel" | "catalogModel";
+
+// Drift sentinel: a new ChannelType breaks compilation here until it is
+// classified in workflowBindingRequirements' switch.
+function assertNeverChannel(t: never): never {
+  throw new Error(`unhandled channel type: ${String(t)}`);
+}
+
+// workflowBindingRequirements returns the resources a deploy must bind, keyed by
+// workflow logical id — the binding surface. The TS twin of the backend's
+// deploy.WorkflowBindingRequirements: both must derive the SAME id->kind map from
+// the same workflow, or an OSS deploy and a backend deploy disagree about what
+// needs binding.
+//
+// The surface is neither the declared set nor a subset of it:
+//  - LOG channels and MemoryFile bind nothing — declared, but out.
+//  - referenced catalog models bind a provider yet are node references, not
+//    declarations — undeclared, but in.
+//
+// Pure — reads workflow content alone: no operator input, no model catalog.
+export function workflowBindingRequirements(workflow: Workflow): Record<string, BindingKind> {
+  const reqs: Record<string, BindingKind> = {};
+
+  for (const channel of Object.values(workflow.channels)) {
+    switch (channel.type) {
+      case "GPIOIN":
+      case "GPIOOUT":
+      case "ADC":
+      case "DAC":
+      case "PWM":
+      case "UART":
+        reqs[channel.id] = "hardware";
+        break;
+      case "MQTT":
+        reqs[channel.id] = "mqtt";
+        break;
+      case "CAMERA":
+        reqs[channel.id] = "camera";
+        break;
+      case "LOG":
+        // Resolves to the ambient engine logger — no platform resource to bind.
+        break;
+      default:
+        return assertNeverChannel(channel.type);
+    }
+  }
+
+  // Every declared model needs a source binding, LLM and ML alike. The surface
+  // does not distinguish the family — that split is a Stage-1 resolver concern.
+  // Mirrors the backend keying every declared model as "declaredModel".
+  for (const model of Object.values(workflow.models)) reqs[model.id] = "declaredModel";
+
+  // Catalog models: referenced by an Agent node but not declared. Keyed by model
+  // id (canonical, matching the backend surface) — not collapsed to providers
+  // here. getReferencedCatalogModelIds already excludes declared ids, so this
+  // never overwrites a declaredModel entry.
+  for (const id of getReferencedCatalogModelIds(workflow)) reqs[id] = "catalogModel";
+
+  return reqs;
+}
+
+/**
+ * Model ids that Agent nodes reference but the workflow does not declare in
+ * `models` - the catalog models a deploy must bind a provider for.
+ */
+export function getReferencedCatalogModelIds(workflow: Workflow): string[] {
+  const declared = new Set(Object.keys(workflow.models));
+  const catalogIds = new Set<string>();
+
+  for (const canvas of Object.values(workflow.canvases)) {
+    for (const node of canvas.nodes) {
+      if (node.type !== "Agent") continue;
+      const id = node.arguments.model;
+      if (id !== "" && !declared.has(id)) catalogIds.add(id);
+    }
+  }
+
+  return [...catalogIds];
+}

package/src/diagnostics/diagnostics.test.ts

@@ -101,7 +101,7 @@ describe("computeNodeDiagnostics — expression validation", () => {
   const exprDef = makeNodeDef({
     category: NodeCategory.Input,
     parameters: [
-      { id: "val", label: "Value", description: "", type: "expression", expressionType: "int" },
+      { id: "val", label: "Value", description: "", type: "expression", expressionType: "int", default: makeExpression("0", "int") },
     ],
   });
 
@@ -114,8 +114,8 @@ describe("computeNodeDiagnostics — expression validation", () => {
     });
     const exprDiags = diagsOfCategory(diags, "invalid-expression");
     expect(exprDiags).toHaveLength(1);
-    expect(exprDiags[0].paramId).toBe("val");
-    expect(exprDiags[0].message).toContain("Invalid expression");
+    expect(exprDiags[0]?.paramId).toBe("val");
+    expect(exprDiags[0]?.message).toContain("Invalid expression");
   });
 
   it("accepts a well-formed expression matching declared type", () => {
@@ -138,7 +138,7 @@ describe("computeNodeDiagnostics — expression validation", () => {
     });
     const exprDiags = diagsOfCategory(diags, "invalid-expression");
     expect(exprDiags).toHaveLength(1);
-    expect(exprDiags[0].message).toMatch(/Type mismatch|expected/i);
+    expect(exprDiags[0]?.message).toMatch(/Type mismatch|expected/i);
   });
 
   it("reactivity: changing a referenced variable's type invalidates a previously-valid expression", () => {
@@ -171,7 +171,24 @@ describe("computeNodeDiagnostics — expression validation", () => {
     expect(diagsOfCategory(before, "invalid-expression")).toHaveLength(0);
     const afterExprDiags = diagsOfCategory(after, "invalid-expression");
     expect(afterExprDiags).toHaveLength(1);
-    expect(afterExprDiags[0].paramId).toBe("val");
+    expect(afterExprDiags[0]?.paramId).toBe("val");
+  });
+
+  it("flags an image variable used in a string expression", () => {
+    // A CameraCapture frame (image) interpolated into a text expression has no
+    // string form; it must be rejected, not silently emptied at runtime.
+    const stringDef = makeNodeDef({
+      category: NodeCategory.Input,
+      parameters: [{ id: "val", label: "Value", description: "", type: "expression", expressionType: "string", default: makeExpression("0", "string") }],
+    });
+    const diags = computeNodeDiagnostics({
+      ...baseOpts({
+        nodeDefinition: stringDef,
+        nodeData: makeNode("OnStartup", { val: makeExpression("frame is ${}", "string", [makeDeclaredRef("v1")]) }),
+      }),
+      availableVariables: makeAvailableVars([makeDeclaredVar({ uid: "v1", dataType: "image" })]),
+    });
+    expect(diagsOfCategory(diags, "invalid-expression")).toHaveLength(1);
   });
 
   it("skips validation on inactive expression parameters", () => {
@@ -185,6 +202,7 @@ describe("computeNodeDiagnostics — expression validation", () => {
           description: "",
           type: "expression",
           expressionType: "int",
+          default: makeExpression("0", "int"),
           activationRules: [{ type: "parameterIn", parameterId: "mode", values: ["on"] }],
         },
       ],
@@ -219,13 +237,13 @@ describe("computeNodeDiagnostics — missing required parameters", () => {
     });
     const missing = diagsOfCategory(diags, "missing-required-param");
     expect(missing).toHaveLength(1);
-    expect(missing[0].paramId).toBe("name");
+    expect(missing[0]?.paramId).toBe("name");
   });
 
   it("flags required expression param that is empty", () => {
     const def = makeNodeDef({
       category: NodeCategory.Input,
-      parameters: [{ id: "expr", label: "Expr", description: "", type: "expression", expressionType: "int" }],
+      parameters: [{ id: "expr", label: "Expr", description: "", type: "expression", expressionType: "int", default: makeExpression("0", "int") }],
     });
     const diags = computeNodeDiagnostics({
       ...baseOpts({
@@ -319,8 +337,8 @@ describe("computeNodeDiagnostics — variableSelect validation", () => {
     });
     const refDiags = diagsOfCategory(diags, "invalid-reference");
     expect(refDiags).toHaveLength(1);
-    expect(refDiags[0].message).toMatch(/deleted variable/);
-    expect(refDiags[0].paramId).toBe("ref");
+    expect(refDiags[0]?.message).toMatch(/deleted variable/);
+    expect(refDiags[0]?.paramId).toBe("ref");
   });
 
   it("accepts a valid variable reference", () => {
@@ -369,7 +387,7 @@ describe("computeNodeDiagnostics — channelSelect validation", () => {
     });
     const refDiags = diagsOfCategory(diags, "invalid-reference");
     expect(refDiags).toHaveLength(1);
-    expect(refDiags[0].message).toMatch(/deleted channel/);
+    expect(refDiags[0]?.message).toMatch(/deleted channel/);
   });
 
   it("flags reference to a channel with incompatible type", () => {
@@ -382,7 +400,7 @@ describe("computeNodeDiagnostics — channelSelect validation", () => {
     });
     const refDiags = diagsOfCategory(diags, "invalid-reference");
     expect(refDiags).toHaveLength(1);
-    expect(refDiags[0].message).toMatch(/not a compatible channel type/);
+    expect(refDiags[0]?.message).toMatch(/not a compatible channel type/);
   });
 
   it("accepts reference to a channel with compatible type", () => {
@@ -432,7 +450,7 @@ describe("computeNodeDiagnostics — memorySelect validation", () => {
     });
     const refDiags = diagsOfCategory(diags, "invalid-reference");
     expect(refDiags).toHaveLength(1);
-    expect(refDiags[0].message).toMatch(/deleted memory/);
+    expect(refDiags[0]?.message).toMatch(/deleted memory/);
   });
 
   it("accepts a memory id present in the store with a compatible type", () => {
@@ -456,7 +474,7 @@ describe("computeNodeDiagnostics — memorySelect validation", () => {
     });
     const refDiags = diagsOfCategory(diags, "invalid-reference");
     expect(refDiags).toHaveLength(1);
-    expect(refDiags[0].message).toMatch(/not a compatible memory type/);
+    expect(refDiags[0]?.message).toMatch(/not a compatible memory type/);
   });
 
   it("does not flag when the memory map is undefined (not provided)", () => {
@@ -500,14 +518,14 @@ describe("computeNodeDiagnostics — scalar output binding validation", () => {
     const diags = computeNodeDiagnostics(retrieverBase({ active: true, mode: "assign", target: { srcId: "", varId: "v1" } }));
     const assignDiags = diagsOfCategory(diags, "assign-type-mismatch");
     expect(assignDiags).toHaveLength(1);
-    expect(assignDiags[0].message).toMatch(/no variable selected/);
+    expect(assignDiags[0]?.message).toMatch(/no variable selected/);
   });
 
   it("flags assign-mode binding targeting a deleted variable", () => {
     const diags = computeNodeDiagnostics(retrieverBase({ active: true, mode: "assign", target: makeDeclaredRef("ghost") }));
     const assignDiags = diagsOfCategory(diags, "assign-type-mismatch");
     expect(assignDiags).toHaveLength(1);
-    expect(assignDiags[0].message).toMatch(/deleted variable/);
+    expect(assignDiags[0]?.message).toMatch(/deleted variable/);
   });
 
   it("flags assign-mode binding with type mismatch", () => {
@@ -519,7 +537,7 @@ describe("computeNodeDiagnostics — scalar output binding validation", () => {
     );
     const assignDiags = diagsOfCategory(diags, "assign-type-mismatch");
     expect(assignDiags).toHaveLength(1);
-    expect(assignDiags[0].message).toMatch(/cannot assign/);
+    expect(assignDiags[0]?.message).toMatch(/cannot assign/);
   });
 
   it("accepts assign-mode binding with matching types", () => {
@@ -579,8 +597,8 @@ describe("computeNodeDiagnostics — list-output entry validation", () => {
     );
     const entry = diagsOfCategory(diags, "assign-type-mismatch");
     expect(entry).toHaveLength(1);
-    expect(entry[0].outputId).toBe("outputDeclarations[0]");
-    expect(entry[0].message).toMatch(/entry #1 has no variable selected/);
+    expect(entry[0]?.outputId).toBe("outputDeclarations[0]");
+    expect(entry[0]?.message).toMatch(/entry #1 has no variable selected/);
   });
 
   it("flags list entry targeting a deleted variable", () => {
@@ -589,7 +607,7 @@ describe("computeNodeDiagnostics — list-output entry validation", () => {
     );
     const entry = diagsOfCategory(diags, "assign-type-mismatch");
     expect(entry).toHaveLength(1);
-    expect(entry[0].message).toMatch(/deleted variable/);
+    expect(entry[0]?.message).toMatch(/deleted variable/);
   });
 
   it("flags list entry with type mismatch", () => {
@@ -601,7 +619,7 @@ describe("computeNodeDiagnostics — list-output entry validation", () => {
     );
     const entry = diagsOfCategory(diags, "assign-type-mismatch");
     expect(entry).toHaveLength(1);
-    expect(entry[0].message).toMatch(/cannot assign/);
+    expect(entry[0]?.message).toMatch(/cannot assign/);
   });
 
   it("accepts a valid list entry", () => {
@@ -628,7 +646,7 @@ describe("computeNodeDiagnostics — list-output entry validation", () => {
     );
     const entry = diagsOfCategory(diags, "assign-type-mismatch");
     expect(entry).toHaveLength(1);
-    expect(entry[0].outputId).toBe("outputDeclarations[1]");
+    expect(entry[0]?.outputId).toBe("outputDeclarations[1]");
   });
 
   it("flags duplicate names across the list (both modes)", () => {
@@ -654,7 +672,7 @@ describe("computeNodeDiagnostics — list-output entry validation", () => {
     );
     const missing = diagsOfCategory(diags, "missing-required-param").filter((d) => d.outputId);
     expect(missing).toHaveLength(1);
-    expect(missing[0].message).toMatch(/has no name/);
+    expect(missing[0]?.message).toMatch(/has no name/);
   });
 });
 

package/src/expression/parser.ts

@@ -187,8 +187,13 @@ function inferBinaryType(node: jsep.BinaryExpression, ctx: TypeContext, errors:
   // If either operand failed to type, propagate null
   if (!leftType || !rightType) return null;
 
-  // String concatenation: string + any → string
+  // String concatenation: string + any → string. An image has no text form,
+  // so it cannot be concatenated even though the other operand is a string.
   if (op === "+" && (leftType === "string" || rightType === "string")) {
+    if (leftType === "image" || rightType === "image") {
+      errors.push("An image value cannot be used in a string expression");
+      return null;
+    }
     return "string";
   }
 
@@ -338,6 +343,9 @@ function isNumeric(type: DataType | null): boolean {
 function isCompatible(from: DataType, to: DataType): boolean {
   if (from === to) return true;
   if (isNumeric(from) && isNumeric(to)) return true;
+  // An image is opaque binary with no text form; it is only compatible with an
+  // image sink (handled by from === to above), never the string catch-all.
+  if (from === "image") return false;
   if (to === "string") return true;
   return false;
 }

package/src/model/MLModelDefinition.ts

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 ForestHub.
+
+import type { ModelDefinition } from "./ModelDefinition";
+
+/**
+ * A declared machine-learning model, served by an inference component, that nodes
+ * can reference. The component selects the model by id and derives its behaviour
+ * from the mounted model bundle, so nothing needs to be configured here.
+ */
+export const MLModelDefinition: ModelDefinition = {
+  type: "MLModel",
+  label: "ML Model",
+  description: "A machine-learning model served by an inference component (e.g. object detection)",
+  parameters: [],
+};

package/src/model/Model.ts

@@ -20,9 +20,9 @@ import type { Schemas } from "../api";
 /** A capability a model supports (chat, embedding, vision, ...). From the api. */
 export type ModelCapability = Schemas["ModelCapability"];
 
-export type ModelType = "LLMModel";
+export type ModelType = "LLMModel" | "MLModel";
 
-export const ALL_MODEL_TYPES: ModelType[] = ["LLMModel"];
+export const ALL_MODEL_TYPES: ModelType[] = ["LLMModel", "MLModel"];
 
 export interface Model {
   id: string;
@@ -39,4 +39,8 @@ export interface ModelInfo {
   id: string;
   label: string;
   capabilities: ModelCapability[];
+  // Catalog provider that serves this model (e.g. "anthropic"). The deploy
+  // resolver reads it to emit one ExternalResources provider entry per distinct
+  // provider a workflow's Agent nodes reference. Mirrors llmproxy ModelInfo.provider.
+  provider: string;
 }

package/src/model/ModelRegistry.ts

@@ -4,6 +4,7 @@
 import type { ModelType } from "./Model";
 import type { ModelDefinition } from "./ModelDefinition";
 import { LLMModelDefinition } from "./LLMModelDefinition";
+import { MLModelDefinition } from "./MLModelDefinition";
 
 /**
  * Central registry for declared (custom) model variant definitions (one per
@@ -16,6 +17,7 @@ class ModelDefinitionRegistry {
   initialize() {
     if (this.initialized) return;
     this.register(LLMModelDefinition);
+    this.register(MLModelDefinition);
     this.initialized = true;
   }
 

package/src/model/index.ts

@@ -5,6 +5,7 @@ export type { ModelType, Model, ModelCapability, ModelInfo } from "./Model";
 export { ALL_MODEL_TYPES } from "./Model";
 export type { ModelDefinition } from "./ModelDefinition";
 export { LLMModelDefinition } from "./LLMModelDefinition";
+export { MLModelDefinition } from "./MLModelDefinition";
 export { ModelRegistry } from "./ModelRegistry";
 export { serialize, deserialize } from "./serialization";
 export type { ApiModel } from "./serialization";

package/src/model/serialization.ts

@@ -17,6 +17,8 @@ export function serialize(model: Model): ApiModel {
         label,
         capabilities: (args.capabilities as ModelCapability[]) ?? ["chat"],
       };
+    case "MLModel":
+      return { type, id, label };
   }
 }
 
@@ -28,6 +30,9 @@ export function deserialize(api: ApiModel): Model {
     case "LLMModel":
       args.capabilities = api.capabilities;
       break;
+    case "MLModel":
+      // No type-specific arguments; the component selects the model by id.
+      break;
   }
   return { id, label, type, arguments: args };
 }

package/src/node/InputNode.ts

@@ -48,8 +48,17 @@ export interface WebFetchNode extends NodeBase {
   };
 }
 
-export type InputNodeType = "ReadPin" | "SerialRead" | "Retriever" | "WebFetch";
-export type InputNode = ReadPinNode | SerialReadNode | RetrieverNode | WebFetchNode;
+// CameraCapture - grabs a single still image from a camera channel
+export interface CameraCaptureNode extends NodeBase {
+  type: "CameraCapture";
+  arguments: {
+    cameraReference: string | undefined;
+    output: OutputBinding;
+  };
+}
+
+export type InputNodeType = "ReadPin" | "SerialRead" | "Retriever" | "WebFetch" | "CameraCapture";
+export type InputNode = ReadPinNode | SerialReadNode | RetrieverNode | WebFetchNode | CameraCaptureNode;
 
 // Node Definitions
 
@@ -186,3 +195,20 @@ export const SerialReadNodeDefinition: NodeDefinition = {
     },
   ],
 };
+
+export const CameraCaptureNodeDefinition: NodeDefinition = {
+  type: "CameraCapture",
+  label: "Camera Capture",
+  category: NodeCategory.Input,
+  description: "Capture a still image from a camera",
+  outputs: [{ id: "output", label: "Image", type: "static", dataType: "image" }],
+  parameters: [
+    {
+      id: "cameraReference",
+      label: "Camera",
+      description: "Camera to capture from",
+      type: "channelSelect",
+      channelType: ["CAMERA"],
+    },
+  ],
+};