@foresthubai/workflow-core 0.4.6 → 0.4.8

package/src/diagnostics/diagnostics.test.ts

@@ -8,7 +8,7 @@ import type { FunctionDeclaration } from "../function";
 import { NodeCategory } from "../node";
 import { SetVariableNodeDefinition } from "../node/DataNode";
 import { RetrieverNodeDefinition } from "../node/InputNode";
-import { AgentNodeDefinition } from "../node/AgentNode";
+import { AgentNodeDefinition } from "../node/AINode";
 import { OnThresholdNodeDefinition } from "../node/TriggerNode";
 import { WebSearchToolNodeDefinition } from "../node/ToolNode";
 import {
@@ -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/{AgentNode.ts → AINode.ts}

@@ -1,85 +1,124 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright (c) 2026 ForestHub.
-
-import { NodeBase } from "./Node";
-import { OutputBinding, OutputDeclaration } from "../parameter";
-import type { Schemas } from "../api";
-import { NodeCategory } from "./constants";
-import { NodeDefinition } from "./NodeDefinition";
-
-export type MemoryRef = Schemas["MemoryRef"];
-
-export interface AgentNode extends NodeBase {
-  type: "Agent";
-  arguments: {
-    name: string;
-    model: string;
-    instructions: string;
-    maxTurns: number | undefined;
-    outputDeclarations: OutputDeclaration[];
-    memoryRefs: MemoryRef[];
-    answer: OutputBinding;
-    toolDescription?: string;
-  };
-}
-
-export type AgentNodeType = "Agent";
-
-export const AgentNodeDefinition: NodeDefinition = {
-  type: "Agent",
-  label: "LLM Agent",
-  category: NodeCategory.AI,
-  description: "AI-powered agent for intelligent processing",
-  canBranch: true, // Control output may fan out to multiple branches (tool output is always multi-target).
-  outputs: [
-    { id: "answer", label: "Answer", type: "static", dataType: "string" },
-    { id: "outputDeclarations", label: "Structured Output", type: "list" },
-  ],
-  parameters: [
-    {
-      id: "name",
-      label: "Name",
-      description: "Name of the agent",
-      optional: true,
-      type: "string",
-    },
-    {
-      id: "model",
-      label: "Model",
-      description: "AI model to use for the agent",
-      type: "modelSelect",
-      modelType: ["LLMModel"],
-      capabilities: ["chat"],
-    },
-    {
-      id: "instructions",
-      label: "Instructions",
-      description: "Instructions for the cloud agent that act as system prompt",
-      type: "string",
-      multiline: true,
-      optional: true,
-    },
-    {
-      id: "maxTurns",
-      label: "Max Turns",
-      description: "Maximum number of agent runner turns",
-      type: "int",
-      optional: true,
-    },
-    {
-      id: "memoryRefs",
-      label: "Memory Files",
-      description: "Project memory files this agent can access, with per-file read or read+write mode",
-      type: "memory-refs",
-      default: [],
-    },
-    {
-      id: "toolDescription",
-      label: "Tool Description",
-      description: "Description shown to the calling agent when this agent is wired as a tool",
-      type: "string",
-      multiline: true,
-      activationRules: [{ type: "isToolInput" }],
-    },
-  ],
-};
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 ForestHub.
+
+import { NodeBase } from "./Node";
+import type { Reference, Schemas } from "../api";
+import { OutputBinding, OutputDeclaration } from "../parameter";
+import { NodeCategory } from "./constants";
+import { NodeDefinition } from "./NodeDefinition";
+
+export type MemoryRef = Schemas["MemoryRef"];
+
+export interface AgentNode extends NodeBase {
+  type: "Agent";
+  arguments: {
+    name: string;
+    model: string;
+    instructions: string;
+    maxTurns: number | undefined;
+    outputDeclarations: OutputDeclaration[];
+    memoryRefs: MemoryRef[];
+    answer: OutputBinding;
+    toolDescription?: string;
+  };
+}
+
+// MLInference — runs a declared ML model on an input and returns its result.
+// The model is selected from the workflow's declared MLModels; the input is a
+// reference to a variable whose value is fed to the model, and the result is
+// emitted as a string.
+export interface MLInferenceNode extends NodeBase {
+  type: "MLInference";
+  arguments: {
+    model: string;
+    input: Reference | undefined;
+    output: OutputBinding;
+  };
+}
+
+export type AINodeType = "Agent" | "MLInference";
+export type AINode = AgentNode | MLInferenceNode;
+
+// Node Definitions
+
+export const AgentNodeDefinition: NodeDefinition = {
+  type: "Agent",
+  label: "LLM Agent",
+  category: NodeCategory.AI,
+  description: "AI-powered agent for intelligent processing",
+  canBranch: true, // Control output may fan out to multiple branches (tool output is always multi-target).
+  outputs: [
+    { id: "answer", label: "Answer", type: "static", dataType: "string" },
+    { id: "outputDeclarations", label: "Structured Output", type: "list" },
+  ],
+  parameters: [
+    {
+      id: "name",
+      label: "Name",
+      description: "Name of the agent",
+      optional: true,
+      type: "string",
+    },
+    {
+      id: "model",
+      label: "Model",
+      description: "AI model to use for the agent",
+      type: "modelSelect",
+      modelType: ["LLMModel"],
+      capabilities: ["chat"],
+    },
+    {
+      id: "instructions",
+      label: "Instructions",
+      description: "Instructions for the cloud agent that act as system prompt",
+      type: "string",
+      multiline: true,
+      optional: true,
+    },
+    {
+      id: "maxTurns",
+      label: "Max Turns",
+      description: "Maximum number of agent runner turns",
+      type: "int",
+      optional: true,
+    },
+    {
+      id: "memoryRefs",
+      label: "Memory Files",
+      description: "Project memory files this agent can access, with per-file read or read+write mode",
+      type: "memory-refs",
+      default: [],
+    },
+    {
+      id: "toolDescription",
+      label: "Tool Description",
+      description: "Description shown to the calling agent when this agent is wired as a tool",
+      type: "string",
+      multiline: true,
+      activationRules: [{ type: "isToolInput" }],
+    },
+  ],
+};
+
+export const MLInferenceNodeDefinition: NodeDefinition = {
+  type: "MLInference",
+  label: "ML Inference",
+  category: NodeCategory.AI,
+  description: "Runs a machine-learning model on an input and returns its result",
+  outputs: [{ id: "output", label: "Result", type: "static", dataType: "string" }],
+  parameters: [
+    {
+      id: "model",
+      label: "Model",
+      description: "ML model to run",
+      type: "modelSelect",
+      modelType: ["MLModel"],
+    },
+    {
+      id: "input",
+      label: "Input",
+      description: "Variable whose value is fed to the model",
+      type: "variableSelect",
+    },
+  ],
+};

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"],
+    },
+  ],
+};

package/src/node/Node.ts

@@ -12,7 +12,7 @@
 import type { DataType } from "../api";
 import { InputNode, InputNodeType } from "./InputNode";
 import { OutputNode, OutputNodeType } from "./OutputNode";
-import { AgentNode, AgentNodeType } from "./AgentNode";
+import { AINode, AINodeType } from "./AINode";
 import { LogicNode, LogicNodeType } from "./LogicNode";
 import { DataNode, DataNodeType } from "./DataNode";
 import { TriggerNode, TriggerNodeType } from "./TriggerNode";
@@ -24,7 +24,7 @@ export type NodeOutput = { name: string; dataType: DataType };
 export type NodeType =
   | InputNodeType
   | OutputNodeType
-  | AgentNodeType
+  | AINodeType
   | LogicNodeType
   | DataNodeType
   | TriggerNodeType
@@ -37,7 +37,7 @@ export type NodeType =
  * It is a union type of all specific node types, each with their own typed parameters.
  * Use this type when you need strong typing for a specific node.
  */
-export type NodeData = InputNode | OutputNode | AgentNode | LogicNode | DataNode | TriggerNode | ToolNode | FunctionCallNode | MqttNode;
+export type NodeData = InputNode | OutputNode | AINode | LogicNode | DataNode | TriggerNode | ToolNode | FunctionCallNode | MqttNode;
 
 /**
  * Full domain node entity held on a {@link Canvas}: the {@link NodeData}

package/src/node/NodeRegistry.ts

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright (c) 2026 ForestHub.
 
-import { ReadPinNodeDefinition, SerialReadNodeDefinition, RetrieverNodeDefinition, WebFetchNodeDefinition } from "./InputNode";
-import { AgentNodeDefinition } from "./AgentNode";
+import { ReadPinNodeDefinition, SerialReadNodeDefinition, RetrieverNodeDefinition, WebFetchNodeDefinition, CameraCaptureNodeDefinition } from "./InputNode";
+import { AgentNodeDefinition, MLInferenceNodeDefinition } from "./AINode";
 import {
   DelayNodeDefinition,
   TickerNodeDefinition,
@@ -38,6 +38,7 @@ class NodeDefinitionRegistry {
     this.register(WritePinNodeDefinition);
     this.register(SerialWriteNodeDefinition);
     this.register(AgentNodeDefinition);
+    this.register(MLInferenceNodeDefinition);
     this.register(IfNodeDefinition);
     this.register(SetVariableNodeDefinition);
     // Register trigger nodes
@@ -54,6 +55,7 @@ class NodeDefinitionRegistry {
     // Register input tool nodes
     this.register(RetrieverNodeDefinition);
     this.register(WebFetchNodeDefinition);
+    this.register(CameraCaptureNodeDefinition);
     // Register MQTT nodes
     this.register(MqttPublishNodeDefinition);
     this.register(OnMqttMessageNodeDefinition);

package/src/node/methods.ts

@@ -66,6 +66,7 @@ export function getPorts(node: NodeData): PortDefinitions {
     case "WritePin":
     case "SerialWrite":
     case "MqttPublish":
+    case "CameraCapture":
       return {
         input: [{ id: "ctrl", type: "control" }],
         output: [{ id: "ctrl", type: "control" }],
@@ -132,6 +133,11 @@ export function getPorts(node: NodeData): PortDefinitions {
         input: [{ id: "ctrl", type: "control" }],
         output: [{ id: "ctrl", type: "control" }],
       };
+    case "MLInference":
+      return {
+        input: [{ id: "ctrl", type: "control" }],
+        output: [{ id: "ctrl", type: "control" }],
+      };
     case "WebSearchTool":
       return { input: [{ id: "tool", type: "tool", label: "As Tool" }], output: [] };
   }