@foresthubai/workflow-core 0.3.0 → 0.4.0

package/src/diagnostics/index.ts

@@ -1,11 +1,11 @@
-export type { DiagnosticSeverity, DiagnosticCategory, Diagnostic, CanvasValidationResult, ValidationResult } from "./diagnostics";
-export {
-  computeNodeDiagnostics,
-  computeEdgeDiagnostics,
-  validateChannel,
-  validateMemory,
-  validateModel,
-  validateFunction,
-  validateFunctionOutputs,
-  validateWorkflowState,
-} from "./diagnostics";
+export type { DiagnosticSeverity, DiagnosticCategory, Diagnostic, CanvasValidationResult, ValidationResult } from "./diagnostics";
+export {
+  computeNodeDiagnostics,
+  computeEdgeDiagnostics,
+  validateChannel,
+  validateMemory,
+  validateModel,
+  validateFunction,
+  validateFunctionOutputs,
+  validateWorkflowState,
+} from "./diagnostics";

package/src/edge/Edge.ts

@@ -1,23 +1,23 @@
-import type { Expression } from "../api";
-
-export interface EdgeData extends Record<string, unknown> {
-  prompt?: Expression; // agentTask and agentDelegate
-  description?: string; // agentChoice and agentDelegate
-}
-
-/**
- * Full domain edge entity held on a {@link Canvas}: connectivity topology plus
- * the optional {@link EdgeData} payload. Low-level core fns that read only
- * connectivity accept it directly, and the editor's React Flow `Edge[]` is
- * structurally assignable
- * without an adapter (core stays free of `@xyflow/react`).
- */
-export interface Edge {
-  id: string;
-  type?: string;
-  source: string;
-  sourceHandle?: string | null;
-  target: string;
-  targetHandle?: string | null;
-  data?: EdgeData;
-}
+import type { Expression } from "../api";
+
+export interface EdgeData extends Record<string, unknown> {
+  prompt?: Expression; // agentTask and agentDelegate
+  description?: string; // agentChoice and agentDelegate
+}
+
+/**
+ * Full domain edge entity held on a {@link Canvas}: connectivity topology plus
+ * the optional {@link EdgeData} payload. Low-level core fns that read only
+ * connectivity accept it directly, and the editor's React Flow `Edge[]` is
+ * structurally assignable
+ * without an adapter (core stays free of `@xyflow/react`).
+ */
+export interface Edge {
+  id: string;
+  type?: string;
+  source: string;
+  sourceHandle?: string | null;
+  target: string;
+  targetHandle?: string | null;
+  data?: EdgeData;
+}

package/src/edge/EdgeDefinition.ts

@@ -1,45 +1,45 @@
-import { Parameter } from "../parameter";
-import type { EdgeType } from "./EdgeType";
-
-export interface EdgeDefinition {
-  label: string;
-  description: string;
-  parameters: Parameter[];
-}
-
-export const EDGE_DEFINITIONS: Record<EdgeType, EdgeDefinition> = {
-  agentTask: {
-    label: "Task",
-    description: "Assigns a task to an agent with a prompt",
-    parameters: [{ id: "prompt", label: "Prompt", description: "", type: "expression", expressionType: "string", default: { expression: "", references: [], dataType: "string" } }],
-  },
-  agentChoice: {
-    label: "Choice",
-    description: "A path the agent can choose based on its description",
-    parameters: [
-      { id: "description", label: "Description", description: "", type: "string", default: "When should the agent take this path?" },
-    ],
-  },
-  agentDelegate: {
-    label: "Delegation",
-    description: "Lets an agent hand off control to another agent",
-    parameters: [
-      { id: "description", label: "Description", description: "", type: "string", default: "When should the agent take this path?" },
-      { id: "prompt", label: "Prompt", description: "", type: "expression", expressionType: "string", default: { expression: "", references: [], dataType: "string" } },
-    ],
-  },
-  control: {
-    label: "Control",
-    description: "Sequential control flow between nodes",
-    parameters: [],
-  },
-  tool: {
-    label: "Tool",
-    description: "Tool connection between nodes",
-    parameters: [],
-  },
-};
-
-export function getEdgeDefinition(type: EdgeType): EdgeDefinition {
-  return EDGE_DEFINITIONS[type];
-}
+import { Parameter } from "../parameter";
+import type { EdgeType } from "./EdgeType";
+
+export interface EdgeDefinition {
+  label: string;
+  description: string;
+  parameters: Parameter[];
+}
+
+export const EDGE_DEFINITIONS: Record<EdgeType, EdgeDefinition> = {
+  agentTask: {
+    label: "Task",
+    description: "Assigns a task to an agent with a prompt",
+    parameters: [{ id: "prompt", label: "Prompt", description: "", type: "expression", expressionType: "string", default: { expression: "", references: [], dataType: "string" } }],
+  },
+  agentChoice: {
+    label: "Choice",
+    description: "A path the agent can choose based on its description",
+    parameters: [
+      { id: "description", label: "Description", description: "", type: "string", default: "When should the agent take this path?" },
+    ],
+  },
+  agentDelegate: {
+    label: "Delegation",
+    description: "Lets an agent hand off control to another agent",
+    parameters: [
+      { id: "description", label: "Description", description: "", type: "string", default: "When should the agent take this path?" },
+      { id: "prompt", label: "Prompt", description: "", type: "expression", expressionType: "string", default: { expression: "", references: [], dataType: "string" } },
+    ],
+  },
+  control: {
+    label: "Control",
+    description: "Sequential control flow between nodes",
+    parameters: [],
+  },
+  tool: {
+    label: "Tool",
+    description: "Tool connection between nodes",
+    parameters: [],
+  },
+};
+
+export function getEdgeDefinition(type: EdgeType): EdgeDefinition {
+  return EDGE_DEFINITIONS[type];
+}

package/src/edge/EdgeType.ts

@@ -1,19 +1,19 @@
-// Edge taxonomy: a plain control/tool edge, or one of the three agent-specific
-// control-flow refinements resolved at connection time from source/target context.
-// Node port handles themselves only carry `control` or `tool`. Tool edges have no
-// agent-specific variant — every tool edge points at an agent by construction.
-export type EdgeType = "control" | "tool" | "agentTask" | "agentChoice" | "agentDelegate";
-
-// All types that behave like control flow (horizontal bezier, side ports)
-export type ControlFlowType = "control" | "agentTask" | "agentChoice" | "agentDelegate";
-
-// All types that behave like tool connections (vertical bezier, top/bottom ports)
-export type ToolFlowType = "tool";
-
-export function isControlFlow(type: EdgeType): type is ControlFlowType {
-  return type === "control" || type === "agentTask" || type === "agentChoice" || type === "agentDelegate";
-}
-
-export function isToolFlow(type: EdgeType): type is ToolFlowType {
-  return type === "tool";
-}
+// Edge taxonomy: a plain control/tool edge, or one of the three agent-specific
+// control-flow refinements resolved at connection time from source/target context.
+// Node port handles themselves only carry `control` or `tool`. Tool edges have no
+// agent-specific variant — every tool edge points at an agent by construction.
+export type EdgeType = "control" | "tool" | "agentTask" | "agentChoice" | "agentDelegate";
+
+// All types that behave like control flow (horizontal bezier, side ports)
+export type ControlFlowType = "control" | "agentTask" | "agentChoice" | "agentDelegate";
+
+// All types that behave like tool connections (vertical bezier, top/bottom ports)
+export type ToolFlowType = "tool";
+
+export function isControlFlow(type: EdgeType): type is ControlFlowType {
+  return type === "control" || type === "agentTask" || type === "agentChoice" || type === "agentDelegate";
+}
+
+export function isToolFlow(type: EdgeType): type is ToolFlowType {
+  return type === "tool";
+}

package/src/edge/index.ts

@@ -1,8 +1,8 @@
-// Public surface of the edge module. The base type (EdgeData) lives in
-// ./Edge; this file is a barrel only. Mirrors channel/memory/model.
-
-export type { EdgeData, Edge } from "./Edge";
-export { type EdgeDefinition, getEdgeDefinition, EDGE_DEFINITIONS } from "./EdgeDefinition";
-export { type EdgeType, type ControlFlowType, type ToolFlowType, isControlFlow, isToolFlow } from "./EdgeType";
-export { serialize, deserialize } from "./serialization";
-export type { ApiEdge } from "./serialization";
+// Public surface of the edge module. The base type (EdgeData) lives in
+// ./Edge; this file is a barrel only. Mirrors channel/memory/model.
+
+export type { EdgeData, Edge } from "./Edge";
+export { type EdgeDefinition, getEdgeDefinition, EDGE_DEFINITIONS } from "./EdgeDefinition";
+export { type EdgeType, type ControlFlowType, type ToolFlowType, isControlFlow, isToolFlow } from "./EdgeType";
+export { serialize, deserialize } from "./serialization";
+export type { ApiEdge } from "./serialization";

package/src/edge/serialization.ts

@@ -1,83 +1,83 @@
-import type { Schemas } from "../api";
-import type { Edge, EdgeData } from "./Edge";
-import type { EdgeType } from "./EdgeType";
-
-export type ApiEdge = Schemas["Edge"];
-
-/**
- * Serialize a domain {@link Edge} to the api `Edge`. The `id` is preserved
- * (the api requires it). Edge-type-conditional metadata (`prompt`,
- * `description`) is reattached from the edge's `data` payload.
- */
-export function serialize(edge: Edge): ApiEdge {
-  const sourceHandle = edge.sourceHandle || "";
-  const targetHandle = edge.targetHandle || "";
-  const edgeType = edge.type as EdgeType | undefined;
-  const from = { nodeId: edge.source, port: sourceHandle };
-  const to = { nodeId: edge.target, port: targetHandle };
-
-  switch (edgeType) {
-    case "agentTask":
-      return {
-        id: edge.id,
-        type: "agentTask",
-        from,
-        to,
-        prompt: (edge.data?.prompt as Schemas["Expression"]) ?? { expression: "", references: [], dataType: "string" },
-      };
-    case "agentChoice":
-      return {
-        id: edge.id,
-        type: "agentChoice",
-        from,
-        to,
-        ...(edge.data?.description ? { description: edge.data.description as string } : {}),
-      };
-    case "agentDelegate":
-      return {
-        id: edge.id,
-        type: "agentDelegate",
-        from,
-        to,
-        ...(edge.data?.prompt ? { prompt: edge.data.prompt as Schemas["Expression"] } : {}),
-        ...(edge.data?.description ? { description: edge.data.description as string } : {}),
-      };
-    case "control":
-      return { id: edge.id, type: "control", from, to };
-    case "tool":
-      return { id: edge.id, type: "tool", from, to };
-    default:
-      return {
-        id: edge.id,
-        type: sourceHandle.startsWith("ctrl") || targetHandle.startsWith("ctrl") ? "control" : "tool",
-        from,
-        to,
-      };
-  }
-}
-
-/**
- * Convert an api `Edge` into a domain {@link Edge}. The api's `id` is preserved
- * verbatim (earlier code synthesized `e${index+1}`, breaking roundtrip
- * identity). Edge-type-conditional metadata (`prompt` on agentTask/agentDelegate;
- * `description` on agentChoice/agentDelegate) is folded into `data` as
- * {@link EdgeData}.
- */
-export function deserialize(apiEdge: ApiEdge): Edge {
-  let data: EdgeData | undefined;
-  if ((apiEdge.type === "agentTask" || apiEdge.type === "agentDelegate") && apiEdge.prompt) {
-    data = { ...data, prompt: apiEdge.prompt };
-  }
-  if ((apiEdge.type === "agentChoice" || apiEdge.type === "agentDelegate") && apiEdge.description) {
-    data = { ...data, description: apiEdge.description };
-  }
-  return {
-    id: apiEdge.id,
-    type: apiEdge.type,
-    source: apiEdge.from.nodeId,
-    sourceHandle: apiEdge.from.port,
-    target: apiEdge.to.nodeId,
-    targetHandle: apiEdge.to.port,
-    ...(data ? { data } : {}),
-  };
-}
+import type { Schemas } from "../api";
+import type { Edge, EdgeData } from "./Edge";
+import type { EdgeType } from "./EdgeType";
+
+export type ApiEdge = Schemas["Edge"];
+
+/**
+ * Serialize a domain {@link Edge} to the api `Edge`. The `id` is preserved
+ * (the api requires it). Edge-type-conditional metadata (`prompt`,
+ * `description`) is reattached from the edge's `data` payload.
+ */
+export function serialize(edge: Edge): ApiEdge {
+  const sourceHandle = edge.sourceHandle || "";
+  const targetHandle = edge.targetHandle || "";
+  const edgeType = edge.type as EdgeType | undefined;
+  const from = { nodeId: edge.source, port: sourceHandle };
+  const to = { nodeId: edge.target, port: targetHandle };
+
+  switch (edgeType) {
+    case "agentTask":
+      return {
+        id: edge.id,
+        type: "agentTask",
+        from,
+        to,
+        prompt: (edge.data?.prompt as Schemas["Expression"]) ?? { expression: "", references: [], dataType: "string" },
+      };
+    case "agentChoice":
+      return {
+        id: edge.id,
+        type: "agentChoice",
+        from,
+        to,
+        ...(edge.data?.description ? { description: edge.data.description as string } : {}),
+      };
+    case "agentDelegate":
+      return {
+        id: edge.id,
+        type: "agentDelegate",
+        from,
+        to,
+        ...(edge.data?.prompt ? { prompt: edge.data.prompt as Schemas["Expression"] } : {}),
+        ...(edge.data?.description ? { description: edge.data.description as string } : {}),
+      };
+    case "control":
+      return { id: edge.id, type: "control", from, to };
+    case "tool":
+      return { id: edge.id, type: "tool", from, to };
+    default:
+      return {
+        id: edge.id,
+        type: sourceHandle.startsWith("ctrl") || targetHandle.startsWith("ctrl") ? "control" : "tool",
+        from,
+        to,
+      };
+  }
+}
+
+/**
+ * Convert an api `Edge` into a domain {@link Edge}. The api's `id` is preserved
+ * verbatim (earlier code synthesized `e${index+1}`, breaking roundtrip
+ * identity). Edge-type-conditional metadata (`prompt` on agentTask/agentDelegate;
+ * `description` on agentChoice/agentDelegate) is folded into `data` as
+ * {@link EdgeData}.
+ */
+export function deserialize(apiEdge: ApiEdge): Edge {
+  let data: EdgeData | undefined;
+  if ((apiEdge.type === "agentTask" || apiEdge.type === "agentDelegate") && apiEdge.prompt) {
+    data = { ...data, prompt: apiEdge.prompt };
+  }
+  if ((apiEdge.type === "agentChoice" || apiEdge.type === "agentDelegate") && apiEdge.description) {
+    data = { ...data, description: apiEdge.description };
+  }
+  return {
+    id: apiEdge.id,
+    type: apiEdge.type,
+    source: apiEdge.from.nodeId,
+    sourceHandle: apiEdge.from.port,
+    target: apiEdge.to.nodeId,
+    targetHandle: apiEdge.to.port,
+    ...(data ? { data } : {}),
+  };
+}

package/src/expression/index.ts

@@ -1,4 +1,4 @@
-export type { ParseResult } from "./parser";
-export { parseExpression } from "./parser";
-export type { ResolvedExpr } from "./types";
-export { resolveExpression, isExpression } from "./types";
+export type { ParseResult } from "./parser";
+export { parseExpression } from "./parser";
+export type { ResolvedExpr } from "./types";
+export { resolveExpression, isExpression } from "./types";