JSON Workflow Runtime

import { parseAndRunWorkflow, AgentHarness, type Tool } from '@noetic-tools/core';

declare const webSearchTool: Tool;

const workflow = {
  version: 1,
  root: {
    kind: 'sequence',
    id: 'research-pipeline',
    steps: [
      {
        kind: 'llm',
        id: 'gather',
        model: 'openai/gpt-4o',
        instructions: 'Search for recent AI news',
        tools: ['webSearch'],
      },
      {
        kind: 'llm',
        id: 'summarize',
        instructions: 'Summarize the findings above',
      },
    ],
  },
};

const harness = new AgentHarness({ name: 'runner', params: {} });
const ctx = harness.createContext();
const result = await parseAndRunWorkflow({
  json: workflow,
  harness,
  ctx,
  tools: [webSearchTool],
});

{
  "version": 1,
  "root": { "...": "WorkflowNode" }
}

{
  "kind": "llm",
  "id": "summarize",
  "model": "openai/gpt-4o",
  "instructions": "Summarize the input text in three bullet points",
  "tools": ["webSearch"],
  "params": { "temperature": 0.3, "maxTokens": 1024 }
}

{
  "kind": "tool",
  "id": "calc-step",
  "toolName": "calculator",
  "args": { "expression": "2 + 2" }
}

{
  "kind": "sequence",
  "id": "pipeline",
  "steps": [
    { "kind": "llm", "id": "step-1", "instructions": "Extract key facts" },
    { "kind": "llm", "id": "step-2", "instructions": "Write a summary from the facts above" }
  ]
}

{
  "kind": "fork",
  "id": "parallel-search",
  "mode": "all",
  "paths": [
    { "kind": "llm", "id": "search-a", "instructions": "Search topic A" },
    { "kind": "llm", "id": "search-b", "instructions": "Search topic B" }
  ],
  "merge": "concat",
  "concurrency": 3
}

{
  "kind": "branch",
  "id": "router",
  "routes": [
    { "match": "code", "target": { "kind": "llm", "id": "code-path", "instructions": "Write code" } },
    { "match": "explain", "target": { "kind": "llm", "id": "explain-path", "instructions": "Explain the concept" } }
  ],
  "default": { "kind": "llm", "id": "fallback", "instructions": "Handle the request" }
}

{
  "kind": "loop",
  "id": "refine",
  "body": { "kind": "llm", "id": "refine-step", "instructions": "Improve the draft" },
  "until": { "kind": "maxSteps", "n": 5 },
  "maxIterations": 10
}

{
  "kind": "spawn",
  "id": "background-task",
  "child": { "kind": "llm", "id": "worker", "instructions": "Process in background" },
  "timeout": 30000
}

{
  "kind": "provide",
  "id": "with-memory",
  "child": { "kind": "llm", "id": "agent", "instructions": "..." },
  "layers": ["conversation-summary"]
}

{
  "kind": "every",
  "id": "heartbeat",
  "step": { "kind": "llm", "id": "check", "instructions": "Check system status" },
  "ms": 60000,
  "onError": "continue"
}

{
  "kind": "any",
  "predicates": [
    { "kind": "maxSteps", "n": 10 },
    { "kind": "outputContains", "marker": "DONE" }
  ]
}

{
  "kind": "all",
  "predicates": [
    { "kind": "maxSteps", "n": 3 },
    { "kind": "noToolCalls" }
  ]
}

import { dynamicWorkflow, AgentHarness, type Tool } from '@noetic-tools/core';

declare const searchTool: Tool;
declare const calcTool: Tool;

const agent = dynamicWorkflow({
  model: 'openai/gpt-4o',
  tools: [searchTool, calcTool],
  instructions: 'Plan the most efficient workflow',
  maxDepth: 5,
});

const harness = new AgentHarness({
  name: 'planner',
  initialStep: agent,
  params: {},
});

await harness.execute('Research and summarize quantum computing advances');
const response = await harness.getAgentResponse();

import { parseAndRunWorkflow, AgentHarness, type Tool } from '@noetic-tools/core';

declare const workflowDocument: unknown;
declare const searchTool: Tool;
declare const calcTool: Tool;

const harness = new AgentHarness({ name: 'runner', params: {} });
const ctx = harness.createContext();

const result = await parseAndRunWorkflow({
  json: workflowDocument,
  harness,
  ctx,
  tools: [searchTool, calcTool],
  maxDepth: 5,
});

import { hydrateWorkflow, hydrateNode } from '@noetic-tools/core';
import type { HydrationContext } from '@noetic-tools/core';

const hydrationCtx: HydrationContext = {
  tools: new Map(myTools.map((t) => [t.name, t])),
  executeStep: harness.run.bind(harness),
};

// Hydrate an entire document
const rootStep = hydrateWorkflow(workflowDoc, hydrationCtx);

// Or hydrate a single node
const singleStep = hydrateNode(someNode, hydrationCtx);

// Then execute manually
const result = await harness.run(rootStep, 'input text', ctx);