@foresthubai/workflow-core 0.3.0 → 0.4.0

package/src/model/serialization.ts

@@ -1,30 +1,30 @@
-import type { Schemas } from "../api";
-import type { Model, ModelCapability } from "./Model";
-
-export type ApiModel = Schemas["Model"];
-
-/** Serialize a domain Model to the API discriminated-union shape. */
-export function serialize(model: Model): ApiModel {
-  const { id, label, type, arguments: args } = model;
-  switch (type) {
-    case "LLMModel":
-      return {
-        type,
-        id,
-        label,
-        capabilities: (args.capabilities as ModelCapability[]) ?? ["chat"],
-      };
-  }
-}
-
-/** Convert an API Model into a domain Model. */
-export function deserialize(api: ApiModel): Model {
-  const { id, label, type } = api;
-  const args: Record<string, unknown> = {};
-  switch (type) {
-    case "LLMModel":
-      args.capabilities = api.capabilities;
-      break;
-  }
-  return { id, label, type, arguments: args };
-}
+import type { Schemas } from "../api";
+import type { Model, ModelCapability } from "./Model";
+
+export type ApiModel = Schemas["Model"];
+
+/** Serialize a domain Model to the API discriminated-union shape. */
+export function serialize(model: Model): ApiModel {
+  const { id, label, type, arguments: args } = model;
+  switch (type) {
+    case "LLMModel":
+      return {
+        type,
+        id,
+        label,
+        capabilities: (args.capabilities as ModelCapability[]) ?? ["chat"],
+      };
+  }
+}
+
+/** Convert an API Model into a domain Model. */
+export function deserialize(api: ApiModel): Model {
+  const { id, label, type } = api;
+  const args: Record<string, unknown> = {};
+  switch (type) {
+    case "LLMModel":
+      args.capabilities = api.capabilities;
+      break;
+  }
+  return { id, label, type, arguments: args };
+}

package/src/node/AgentNode.ts

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

package/src/node/DataNode.ts

@@ -1,41 +1,41 @@
-import { NodeBase } from "./Node";
-import type { Expression, Reference } from "../api";
-import { NodeCategory } from "./constants";
-import { NodeDefinition } from "./NodeDefinition";
-
-export interface SetVariableNode extends NodeBase {
-  type: "SetVariable";
-  arguments: {
-    variable: Reference | undefined;
-    value: Expression;
-  };
-}
-
-export type DataNodeType = "SetVariable";
-export type DataNode = SetVariableNode;
-
-// Node Definitions
-
-export const SetVariableNodeDefinition: NodeDefinition = {
-  type: "SetVariable",
-  label: "Set Variable",
-  category: NodeCategory.Data,
-  description: "Assign a new value to an existing variable",
-  parameters: [
-    {
-      id: "variable",
-      label: "Variable",
-      description: "The variable to update",
-      type: "variableSelect",
-    },
-    {
-      id: "value",
-      label: "Value",
-      description: "Expression to assign",
-      type: "expression",
-      expressionType: "int", // fallback; actual type is derived from the target variable (see fromReference)
-      fromReference: "variable",
-      default: { expression: "", references: [], dataType: "int" },
-    },
-  ],
-};
+import { NodeBase } from "./Node";
+import type { Expression, Reference } from "../api";
+import { NodeCategory } from "./constants";
+import { NodeDefinition } from "./NodeDefinition";
+
+export interface SetVariableNode extends NodeBase {
+  type: "SetVariable";
+  arguments: {
+    variable: Reference | undefined;
+    value: Expression;
+  };
+}
+
+export type DataNodeType = "SetVariable";
+export type DataNode = SetVariableNode;
+
+// Node Definitions
+
+export const SetVariableNodeDefinition: NodeDefinition = {
+  type: "SetVariable",
+  label: "Set Variable",
+  category: NodeCategory.Data,
+  description: "Assign a new value to an existing variable",
+  parameters: [
+    {
+      id: "variable",
+      label: "Variable",
+      description: "The variable to update",
+      type: "variableSelect",
+    },
+    {
+      id: "value",
+      label: "Value",
+      description: "Expression to assign",
+      type: "expression",
+      expressionType: "int", // fallback; actual type is derived from the target variable (see fromReference)
+      fromReference: "variable",
+      default: { expression: "", references: [], dataType: "int" },
+    },
+  ],
+};

package/src/node/FunctionNode.ts

@@ -1,76 +1,76 @@
-import { NodeBase } from "./Node";
-import type { Expression } from "../api";
-import type { FunctionInfo } from "../function";
-import type { DataType } from "../api";
-import { OutputBinding } from "../parameter";
-import { NodeDefinition } from "./NodeDefinition";
-import { NodeCategory } from "./constants";
-import { paramKey } from "../variable";
-
-// Function Call Node - invokes a user-defined function.
-// Arguments are flat — keyed by Variable uid. Input argument uids map to Expression,
-// return uids map to OutputBinding. Same shape as every other node, so the rest of
-// the system (parameter editors, output bindings, merge/update) treats FunctionCall
-// uniformly. Outputs are derived on-the-fly via buildFunctionNodeDef from
-// functionInfo.returns — there is no registered NodeDefinition.
-export interface FunctionCallNode extends NodeBase {
-  type: "FunctionCall";
-  functionInfo: FunctionInfo; // Snapshot at creation; may be stale vs registry
-  // Flat bag keyed by Variable uid (Expression for args, OutputBinding for returns),
-  // plus the reserved `toolDescription` key (string) for the tool-mode parameter.
-  arguments: Record<string, Expression | OutputBinding | string>;
-}
-
-export type FunctionCallNodeType = "FunctionCall";
-
-// FunctionNodeDefinition extends NodeDefinition with function-specific fields
-// Used by NodeLibrary to create new FunctionCall nodes
-export interface FunctionNodeDefinition extends NodeDefinition {
-  type: "FunctionCall";
-  functionInfo: FunctionInfo; // Metadata about the function being called
-}
-
-/**
- * Build a FunctionCall NodeDefinition from FunctionInfo. Pure — takes an
- * optional translator function so the headless validator can call it without
- * an i18n runtime; workflow-builder passes `i18n.t.bind(i18n)` to get
- * translated descriptions. Defaults to identity (returns the key) when no
- * translator is supplied; validation logic ignores description strings.
- */
-export function buildFunctionNodeDef(
-  fn: FunctionInfo,
-  t: (key: string, params?: Record<string, unknown>) => string = (key) => key,
-): FunctionNodeDefinition {
-  return {
-    type: "FunctionCall",
-    functionInfo: fn,
-    label: fn.name,
-    category: NodeCategory.Function,
-    description: t("builder.functionCallDesc", { name: fn.name }),
-    parameters: [
-      ...fn.arguments.map((param) => ({
-        id: paramKey(param),
-        label: param.name,
-        description: t("builder.functionParamDesc", { name: param.name }),
-        type: "expression" as const,
-        expressionType: param.dataType as DataType,
-        default: { expression: "", references: [], dataType: param.dataType as DataType },
-        activationRules: [{ type: "isControlFlow" as const }],
-      })),
-      {
-        id: "toolDescription",
-        label: "Tool Description",
-        description: "Description shown to the agent when this function is wired as a tool",
-        type: "string" as const,
-        multiline: true,
-        activationRules: [{ type: "isToolInput" as const }],
-      },
-    ],
-    outputs: fn.returns.map((ret) => ({
-      id: paramKey(ret),
-      label: ret.name,
-      type: "static" as const,
-      dataType: ret.dataType as DataType,
-    })),
-  };
-}
+import { NodeBase } from "./Node";
+import type { Expression } from "../api";
+import type { FunctionInfo } from "../function";
+import type { DataType } from "../api";
+import { OutputBinding } from "../parameter";
+import { NodeDefinition } from "./NodeDefinition";
+import { NodeCategory } from "./constants";
+import { paramKey } from "../variable";
+
+// Function Call Node - invokes a user-defined function.
+// Arguments are flat — keyed by Variable uid. Input argument uids map to Expression,
+// return uids map to OutputBinding. Same shape as every other node, so the rest of
+// the system (parameter editors, output bindings, merge/update) treats FunctionCall
+// uniformly. Outputs are derived on-the-fly via buildFunctionNodeDef from
+// functionInfo.returns — there is no registered NodeDefinition.
+export interface FunctionCallNode extends NodeBase {
+  type: "FunctionCall";
+  functionInfo: FunctionInfo; // Snapshot at creation; may be stale vs registry
+  // Flat bag keyed by Variable uid (Expression for args, OutputBinding for returns),
+  // plus the reserved `toolDescription` key (string) for the tool-mode parameter.
+  arguments: Record<string, Expression | OutputBinding | string>;
+}
+
+export type FunctionCallNodeType = "FunctionCall";
+
+// FunctionNodeDefinition extends NodeDefinition with function-specific fields
+// Used by NodeLibrary to create new FunctionCall nodes
+export interface FunctionNodeDefinition extends NodeDefinition {
+  type: "FunctionCall";
+  functionInfo: FunctionInfo; // Metadata about the function being called
+}
+
+/**
+ * Build a FunctionCall NodeDefinition from FunctionInfo. Pure — takes an
+ * optional translator function so the headless validator can call it without
+ * an i18n runtime; workflow-builder passes `i18n.t.bind(i18n)` to get
+ * translated descriptions. Defaults to identity (returns the key) when no
+ * translator is supplied; validation logic ignores description strings.
+ */
+export function buildFunctionNodeDef(
+  fn: FunctionInfo,
+  t: (key: string, params?: Record<string, unknown>) => string = (key) => key,
+): FunctionNodeDefinition {
+  return {
+    type: "FunctionCall",
+    functionInfo: fn,
+    label: fn.name,
+    category: NodeCategory.Function,
+    description: t("builder.functionCallDesc", { name: fn.name }),
+    parameters: [
+      ...fn.arguments.map((param) => ({
+        id: paramKey(param),
+        label: param.name,
+        description: t("builder.functionParamDesc", { name: param.name }),
+        type: "expression" as const,
+        expressionType: param.dataType as DataType,
+        default: { expression: "", references: [], dataType: param.dataType as DataType },
+        activationRules: [{ type: "isControlFlow" as const }],
+      })),
+      {
+        id: "toolDescription",
+        label: "Tool Description",
+        description: "Description shown to the agent when this function is wired as a tool",
+        type: "string" as const,
+        multiline: true,
+        activationRules: [{ type: "isToolInput" as const }],
+      },
+    ],
+    outputs: fn.returns.map((ret) => ({
+      id: paramKey(ret),
+      label: ret.name,
+      type: "static" as const,
+      dataType: ret.dataType as DataType,
+    })),
+  };
+}