@foresthubai/workflow-core 0.3.0

package/src/function/serialization.ts

@@ -0,0 +1,40 @@
+import type { Expression } from "../api";
+import type { FunctionDeclaration, FunctionInfo } from "./FunctionDeclaration";
+import { toFunctionInfo } from "./FunctionDeclaration";
+
+/**
+ * The two wire pieces a {@link FunctionDeclaration} splits into. The contract keeps
+ * the signature (`functionInfo`) and the return-value expressions (`outputAssignments`)
+ * apart; the domain bundles them on `outputs`. The function *body*
+ * (nodes/edges/declaredVariables) is added separately by the workflow serializer —
+ * this only handles the declaration ⇄ wire mapping.
+ */
+export interface SerializedFunction {
+  functionInfo: FunctionInfo;
+  outputAssignments: Record<string, Expression>;
+}
+
+/** Domain declaration → wire pieces: flatten the signature and lift each output's
+ *  expression into the `outputAssignments` map keyed by output uid. */
+export function serialize(fn: FunctionDeclaration): SerializedFunction {
+  const outputAssignments: Record<string, Expression> = {};
+  for (const o of fn.outputs) outputAssignments[o.uid] = o.expression;
+  return { functionInfo: toFunctionInfo(fn), outputAssignments };
+}
+
+/** Wire pieces → domain declaration: bundle each `return` with its assignment. A
+ *  return with no stored assignment gets an empty expression of the right dataType. */
+export function deserialize(functionInfo: FunctionInfo, outputAssignments: Record<string, Expression>): FunctionDeclaration {
+  return {
+    id: functionInfo.id,
+    version: functionInfo.version,
+    name: functionInfo.name,
+    arguments: functionInfo.arguments,
+    outputs: functionInfo.returns.map((r) => ({
+      uid: r.uid,
+      name: r.name,
+      dataType: r.dataType,
+      expression: outputAssignments[r.uid] ?? { expression: "", references: [], dataType: r.dataType },
+    })),
+  };
+}

package/src/globals.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This package drops the `DOM` lib (see tsconfig.json) to stay headless, so the
+ * Web Crypto `crypto` global is untyped. It exists at runtime everywhere we run
+ * — browsers, Node >= 19, Deno, Bun — so we declare only the one member we use
+ * rather than pulling in `DOM` or `@types/node` and their global scope.
+ */
+declare const crypto: {
+  randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
+};

package/src/id/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Centralized UID creation for every entity in a workflow — nodes, edges,
+ * channels, memory, models, declared variables, function arguments, and
+ * function canvases. IDs are opaque.
+ */
+export function generateId(): string {
+  return crypto.randomUUID();
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+import { deserialize } from "./workflow/serialization";
+import { validateWorkflowState, type ValidationResult } from "./diagnostics/diagnostics";
+import type { ApiWorkflow } from "./workflow/Workflow";
+
+// Api-layer types consumers use directly (no domain twin). Sourced from `api`
+// so they're available at the package root rather than via a domain subpath.
+// (`FunctionInfo` is the exception — it's the flat twin of the domain
+// `FunctionDeclaration`, so it lives on the `function` subpath, not here.)
+export type { DataType, Reference, Expression } from "./api";
+
+// Format versioning: load persisted documents through `migrate` before
+// deserializing.
+export { migrate, CURRENT_SCHEMA_VERSION } from "./migration";
+
+/**
+ * Validate a workflow against the headless validator.
+ * Pure: no I/O, no Zustand, no React, no DOM. Runnable in Node, a CLI, or
+ * a Claude Code skill.
+ */
+export function validateWorkflow(workflow: ApiWorkflow): ValidationResult {
+  return validateWorkflowState(deserialize(workflow));
+}

package/src/memory/Memory.ts

@@ -0,0 +1,15 @@
+import type { Schemas } from "../api";
+
+export type MemoryType = "MemoryFile" | "VectorDatabase";
+
+export const ALL_MEMORY_TYPES: MemoryType[] = ["MemoryFile", "VectorDatabase"];
+
+export interface Memory {
+  id: string;
+  label: string;
+  type: MemoryType;
+  arguments: Record<string, unknown>;
+}
+
+/** Reference from an agent node to a declared MemoryFile, with access mode. Round-trips 1:1 with the API. */
+export type MemoryRef = Schemas["MemoryRef"];

package/src/memory/MemoryDefinition.ts

@@ -0,0 +1,16 @@
+import type { Parameter } from "../parameter";
+import type { MemoryType } from "./Memory";
+
+/**
+ * Static, per-type metadata for a memory variant. Mirrors NodeDefinition:
+ * one definition object per MemoryType, registered in MemoryRegistry — unlike
+ * channels, which use a single union definition gated by activation rules.
+ * `label` is a top-level instance field (edited like a channel label), so it is
+ * never a parameter here.
+ */
+export interface MemoryDefinition {
+  type: MemoryType;
+  label: string;
+  description: string;
+  parameters: Parameter[];
+}

package/src/memory/MemoryFileDefinition.ts

@@ -0,0 +1,37 @@
+import type { MemoryDefinition } from "./MemoryDefinition";
+
+/**
+ * Agent-scoped durable text storage. The instance `label` (edited like a channel
+ * label) is the identifier the LLM sees in tool calls, so it is not a parameter.
+ * The config panel renders these parameters via ParameterEditor, same as channels.
+ */
+export const MemoryFileDefinition: MemoryDefinition = {
+  type: "MemoryFile",
+  label: "Memory File",
+  description: "Durable text storage an agent can read and write",
+  parameters: [
+    {
+      id: "description",
+      label: "Description",
+      description: "What this memory file is for (shown to the LLM as tool description)",
+      type: "string",
+      multiline: true,
+      optional: true,
+    },
+    {
+      id: "content",
+      label: "Initial Content",
+      description: "Seed content written on fresh deploy; existing rows keep their content on redeploy",
+      type: "string",
+      multiline: true,
+      optional: true,
+    },
+    {
+      id: "maxSizeBytes",
+      label: "Max Size (bytes)",
+      description: "Byte cap on writes; leave empty for unlimited",
+      type: "int",
+      optional: true,
+    },
+  ],
+};

package/src/memory/MemoryRegistry.ts

@@ -0,0 +1,35 @@
+import type { MemoryType } from "./Memory";
+import type { MemoryDefinition } from "./MemoryDefinition";
+import { MemoryFileDefinition } from "./MemoryFileDefinition";
+import { VectorDatabaseDefinition } from "./VectorDatabaseDefinition";
+
+/**
+ * Central registry for memory variant definitions (one per MemoryType).
+ * Mirrors NodeRegistry.
+ */
+class MemoryDefinitionRegistry {
+  private memories: Map<MemoryType, MemoryDefinition> = new Map();
+  private initialized = false;
+
+  initialize() {
+    if (this.initialized) return;
+    this.register(MemoryFileDefinition);
+    this.register(VectorDatabaseDefinition);
+    this.initialized = true;
+  }
+
+  private register(definition: MemoryDefinition) {
+    this.memories.set(definition.type, definition);
+  }
+
+  getAll(): MemoryDefinition[] {
+    return Array.from(this.memories.values());
+  }
+
+  getByType(type: MemoryType): MemoryDefinition | undefined {
+    return this.memories.get(type);
+  }
+}
+
+export const MemoryRegistry = new MemoryDefinitionRegistry();
+MemoryRegistry.initialize();

package/src/memory/VectorDatabaseDefinition.ts

@@ -0,0 +1,21 @@
+import type { MemoryDefinition } from "./MemoryDefinition";
+
+/**
+ * RAG knowledge base referenced from Retriever nodes. Only descriptive config
+ * lives here; the backend collection it binds to is supplied at deploy time.
+ */
+export const VectorDatabaseDefinition: MemoryDefinition = {
+  type: "VectorDatabase",
+  label: "Vector Database",
+  description: "RAG knowledge base that Retriever nodes can query",
+  parameters: [
+    {
+      id: "description",
+      label: "Description",
+      description: "What this knowledge base contains",
+      type: "string",
+      multiline: true,
+      optional: true,
+    },
+  ],
+};

package/src/memory/index.ts

@@ -0,0 +1,8 @@
+export type { MemoryType, Memory, MemoryRef } from "./Memory";
+export { ALL_MEMORY_TYPES } from "./Memory";
+export type { MemoryDefinition } from "./MemoryDefinition";
+export { MemoryFileDefinition } from "./MemoryFileDefinition";
+export { VectorDatabaseDefinition } from "./VectorDatabaseDefinition";
+export { MemoryRegistry } from "./MemoryRegistry";
+export { serialize, deserialize } from "./serialization";
+export type { ApiMemory } from "./serialization";

package/src/memory/serialization.ts

@@ -0,0 +1,47 @@
+import type { Schemas } from "../api";
+import type { Memory } from "./Memory";
+
+export type ApiMemory = Schemas["Memory"];
+
+/**
+ * Serialize a domain Memory to the API discriminated-union shape.
+ * MemoryFile drops `maxSizeBytes` when unset (absent and null both mean "unlimited").
+ */
+export function serialize(mem: Memory): ApiMemory {
+  const { id, label, type, arguments: args } = mem;
+  switch (type) {
+    case "MemoryFile":
+      return {
+        type,
+        id,
+        label,
+        description: (args.description as string) ?? "",
+        content: (args.content as string) ?? "",
+        ...(args.maxSizeBytes != null ? { maxSizeBytes: args.maxSizeBytes as number } : {}),
+      };
+    case "VectorDatabase":
+      return {
+        type,
+        id,
+        label,
+        ...(args.description != null ? { description: args.description as string } : {}),
+      };
+  }
+}
+
+/** Convert an API Memory into a domain Memory. */
+export function deserialize(api: ApiMemory): Memory {
+  const { id, label, type } = api;
+  const args: Record<string, unknown> = {};
+  switch (type) {
+    case "MemoryFile":
+      args.description = api.description ?? "";
+      args.content = api.content ?? "";
+      if (api.maxSizeBytes != null) args.maxSizeBytes = api.maxSizeBytes;
+      break;
+    case "VectorDatabase":
+      if (api.description != null) args.description = api.description;
+      break;
+  }
+  return { id, label, type, arguments: args };
+}

package/src/migration/index.ts

@@ -0,0 +1,4 @@
+export { CURRENT_SCHEMA_VERSION, BASELINE_SCHEMA_VERSION } from "./version";
+export { migrate, readSchemaVersion } from "./migrate";
+export { MIGRATIONS } from "./migrations";
+export type { Migration } from "./migrations";

package/src/migration/migrate.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { migrate, readSchemaVersion } from "./migrate";
+import { CURRENT_SCHEMA_VERSION } from "./version";
+
+describe("readSchemaVersion", () => {
+  it("reads an explicit integer version", () => {
+    expect(readSchemaVersion({ schemaVersion: 3 })).toBe(3);
+  });
+
+  it("defaults missing, non-integer, or out-of-range to the baseline", () => {
+    expect(readSchemaVersion({})).toBe(1);
+    expect(readSchemaVersion({ schemaVersion: 1.5 })).toBe(1);
+    expect(readSchemaVersion({ schemaVersion: 0 })).toBe(1);
+    expect(readSchemaVersion({ schemaVersion: "2" })).toBe(1);
+  });
+});
+
+describe("migrate", () => {
+  it("stamps the current version on a baseline document", () => {
+    const out = migrate({ nodes: [], edges: [] });
+    expect(out.schemaVersion).toBe(CURRENT_SCHEMA_VERSION);
+  });
+
+  it("passes through a document already at the current version", () => {
+    const doc = { schemaVersion: CURRENT_SCHEMA_VERSION, nodes: [] };
+    expect(migrate(doc).schemaVersion).toBe(CURRENT_SCHEMA_VERSION);
+  });
+
+  it("does not mutate its input", () => {
+    const doc: Record<string, unknown> = { nodes: [] };
+    migrate(doc);
+    expect("schemaVersion" in doc).toBe(false);
+  });
+
+  it("rejects a document newer than this build supports", () => {
+    expect(() => migrate({ schemaVersion: CURRENT_SCHEMA_VERSION + 1 })).toThrow(/newer than this build/);
+  });
+
+  it("rejects a non-object document", () => {
+    expect(() => migrate(null)).toThrow(/must be a JSON object/);
+    expect(() => migrate([])).toThrow(/must be a JSON object/);
+    expect(() => migrate(42)).toThrow(/must be a JSON object/);
+  });
+});

package/src/migration/migrate.ts

@@ -0,0 +1,58 @@
+import type { ApiWorkflow } from "../workflow/Workflow";
+import { MIGRATIONS, type Migration } from "./migrations";
+import { BASELINE_SCHEMA_VERSION, CURRENT_SCHEMA_VERSION } from "./version";
+
+/**
+ * Index the registry by `from` and assert it forms a contiguous chain over
+ * [BASELINE_SCHEMA_VERSION, CURRENT_SCHEMA_VERSION). A gap or duplicate is a
+ * programming error, so it throws at module load rather than on first use.
+ */
+function buildChain(migrations: readonly Migration[]): ReadonlyMap<number, Migration> {
+  const byFrom = new Map<number, Migration>();
+  for (const m of migrations) {
+    if (!Number.isInteger(m.from) || m.from < BASELINE_SCHEMA_VERSION || m.from >= CURRENT_SCHEMA_VERSION) {
+      throw new Error(`[migration] from must be an integer in [${BASELINE_SCHEMA_VERSION}, ${CURRENT_SCHEMA_VERSION}), got ${m.from}`);
+    }
+    if (byFrom.has(m.from)) {
+      throw new Error(`[migration] duplicate migration from ${m.from}`);
+    }
+    byFrom.set(m.from, m);
+  }
+  for (let v = BASELINE_SCHEMA_VERSION; v < CURRENT_SCHEMA_VERSION; v++) {
+    if (!byFrom.has(v)) throw new Error(`[migration] missing migration from ${v} -> ${v + 1}`);
+  }
+  return byFrom;
+}
+
+const CHAIN = buildChain(MIGRATIONS);
+
+/** Read the schema version, defaulting absent/invalid to the baseline. */
+export function readSchemaVersion(doc: Record<string, unknown>): number {
+  const v = doc.schemaVersion;
+  return typeof v === "number" && Number.isInteger(v) && v >= BASELINE_SCHEMA_VERSION ? v : BASELINE_SCHEMA_VERSION;
+}
+
+/**
+ * Upgrade a raw, parsed workflow document to CURRENT_SCHEMA_VERSION and return
+ * it as the current {@link ApiWorkflow}, ready for `deserialize`. Runs on
+ * untyped JSON so each migration stays pinned to the shape it was written for.
+ * Throws on a non-object, or a version newer than this build supports.
+ */
+export function migrate(raw: unknown): ApiWorkflow {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("[migration] workflow document must be a JSON object");
+  }
+  let doc: Record<string, unknown> = { ...(raw as Record<string, unknown>) };
+
+  const version = readSchemaVersion(doc);
+  if (version > CURRENT_SCHEMA_VERSION) {
+    throw new Error(`[migration] schemaVersion ${version} is newer than this build supports (${CURRENT_SCHEMA_VERSION})`);
+  }
+
+  for (let v = version; v < CURRENT_SCHEMA_VERSION; v++) {
+    doc = CHAIN.get(v)!.migrate(doc); // non-null: buildChain covers every v in range
+  }
+
+  doc.schemaVersion = CURRENT_SCHEMA_VERSION;
+  return doc as ApiWorkflow;
+}

package/src/migration/migrations.ts

@@ -0,0 +1,24 @@
+/**
+ * A single-step upgrade of the persisted workflow format, from `from` to
+ * `from + 1`. Operates on the raw parsed document, never the domain types.
+ * Forward-only: there is no down-path.
+ *
+ * A shipped migration is immutable — saved files depend on its exact behaviour.
+ * Express the next change as a new migration, never an edit to an old one.
+ */
+export interface Migration {
+  /** Schema version this migration expects as input. Produces `from + 1`. */
+  readonly from: number;
+  /** Pure transform on the raw document; must not mutate its input. */
+  migrate(doc: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * Ordered registry of single-step format migrations. To change the format:
+ * bump CURRENT_SCHEMA_VERSION, append one migration with `from` set to the
+ * previous value, and reconcile serialize/deserialize. {@link migrate} asserts
+ * at load that the chain is contiguous over [BASELINE, CURRENT).
+ */
+export const MIGRATIONS: readonly Migration[] = [
+  // First entry will be `{ from: 1, migrate: (doc) => ... }`.
+];

package/src/migration/version.ts

@@ -0,0 +1,9 @@
+/**
+ * Persisted-format version this build reads and writes. A plain monotonic
+ * integer, decoupled from the contract/package semver. Bump only when the
+ * serialized {@link ApiWorkflow} shape changes, adding a matching migration.
+ */
+export const CURRENT_SCHEMA_VERSION = 1;
+
+/** Version assumed for documents that carry no `schemaVersion`. */
+export const BASELINE_SCHEMA_VERSION = 1;

package/src/model/LLMModelDefinition.ts

@@ -0,0 +1,12 @@
+import type { ModelDefinition } from "./ModelDefinition";
+
+/**
+ * A declared custom/self-hosted LLM model.
+ * Capabilities default to ["chat"] on serialize; a capability editor can be added later.
+ */
+export const LLMModelDefinition: ModelDefinition = {
+  type: "LLMModel",
+  label: "Custom LLM Model",
+  description: "A self-hosted or custom LLM the llmproxy doesn't ship by default",
+  parameters: [],
+};

package/src/model/Model.ts

@@ -0,0 +1,39 @@
+// Domain Model — covers two distinct things that share a picker:
+//   1. The STATIC catalog (ModelInfo[]): the set of models the llmproxy already
+//      supports. Supplied to the editor as data (props), not declared per-workflow.
+//      A node simply stores the chosen catalog ModelID directly.
+//   2. DECLARED custom models (Model): self-hosted / custom models the
+//      llmproxy doesn't ship. These are channel-like — declared in the workflow,
+//      referenced by id from nodes, and mapped to an llmproxy provider at deploy.
+//
+// A node's `model` field is always just a ModelID string either way; static ids
+// resolve via the catalog (no mapping), custom ids via a declared Model.
+//
+// `type` is the api discriminator; new model families (e.g. future YOLO/ONNX
+// variants) register their own definition in ModelRegistry, mirroring nodes.
+
+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 const ALL_MODEL_TYPES: ModelType[] = ["LLMModel"];
+
+export interface Model {
+  id: string;
+  label: string;
+  type: ModelType;
+  arguments: Record<string, unknown>;
+}
+
+/**
+ * One entry in the static model catalog handed to the builder via props. The
+ * embedder maps the llmproxy's richer ModelInfo down to this minimal shape.
+ */
+export interface ModelInfo {
+  id: string;
+  label: string;
+  capabilities: ModelCapability[];
+}

package/src/model/ModelDefinition.ts

@@ -0,0 +1,15 @@
+import type { Parameter } from "../parameter";
+import type { ModelType } from "./Model";
+
+/**
+ * Static, per-type metadata for a declared (custom) model variant. Mirrors
+ * MemoryDefinition / NodeDefinition: one definition object per ModelType,
+ * registered in ModelRegistry. `label` is a top-level instance field (edited
+ * like a channel label), so it is never a parameter here.
+ */
+export interface ModelDefinition {
+  type: ModelType;
+  label: string;
+  description: string;
+  parameters: Parameter[];
+}

package/src/model/ModelRegistry.ts

@@ -0,0 +1,33 @@
+import type { ModelType } from "./Model";
+import type { ModelDefinition } from "./ModelDefinition";
+import { LLMModelDefinition } from "./LLMModelDefinition";
+
+/**
+ * Central registry for declared (custom) model variant definitions (one per
+ * ModelType). Mirrors MemoryRegistry / NodeRegistry.
+ */
+class ModelDefinitionRegistry {
+  private models: Map<ModelType, ModelDefinition> = new Map();
+  private initialized = false;
+
+  initialize() {
+    if (this.initialized) return;
+    this.register(LLMModelDefinition);
+    this.initialized = true;
+  }
+
+  private register(definition: ModelDefinition) {
+    this.models.set(definition.type, definition);
+  }
+
+  getAll(): ModelDefinition[] {
+    return Array.from(this.models.values());
+  }
+
+  getByType(type: ModelType): ModelDefinition | undefined {
+    return this.models.get(type);
+  }
+}
+
+export const ModelRegistry = new ModelDefinitionRegistry();
+ModelRegistry.initialize();

package/src/model/index.ts

@@ -0,0 +1,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 { ModelRegistry } from "./ModelRegistry";
+export { serialize, deserialize } from "./serialization";
+export type { ApiModel } from "./serialization";

package/src/model/serialization.ts

@@ -0,0 +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 };
+}

package/src/node/AgentNode.ts

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