Genflows API

POST /api/convert V1 - VLM JSON

Returns procedures, sections, and steps. Accepts multipart uploads or JSON with base64 file bytes.

curl -X POST https://genflows-api.vercel.app/api/convert \
  -F provider=openai \
  -F api_key="$OPENAI_API_KEY" \
  -F file=@/path/to/document.pdf \
  -o result.json

POST /api/v2/convert V2 - CaptureGraph DAG

Returns a CaptureGraph procedure DAG. Same fields as V1.

curl -X POST https://genflows-api.vercel.app/api/v2/convert \
  -F provider=openai \
  -F api_key="$OPENAI_API_KEY" \
  -F file=@/path/to/document.pdf \
  -o procedure.json

Node Types

Nodes use kind, return_type, optional label, settings, inputs, and substeps.

Kind	Returns	Role
ProcedureSequence	PVoid	Ordered substeps
ShowInstructions	PBool	Instruction text
RequireProcedureCompleted	PVoid	Required wrapped step
UserInputBool	PBool	Yes / No prompt
IfThenElse	PVoid	Boolean branch
SwitchString	PVoid	One branch per selected option
Stopwatch	PNumber	Timer in seconds
PaceKeeper	PVoid	Metronome
UserInputString	PString	Free-text field
UserInputNumber	PNumber	Numeric input
UserInputSelectString	PString	Fixed options
DoNothing	PVoid	No-op
NullProcedure	any	Typed null

Output Shape

capturegraph.root points to the first node. capturegraph.nodes stores the DAG.

{
  "procedure_name": "Adult Cardiac Arrest",
  "format": "capturegraph",
  "api_version": "2",
  "metadata": {
    "node_count": 17,
    "model_used": "OpenAI gpt-4o",
    ...
  },
  "capturegraph": {
    "root": "10",
    "nodes": {
      "00": {"kind": "NullProcedure", "return_type": "PImage"},
      "01": {"kind": "ShowInstructions", "return_type": "PBool",
              "label": "Start CPR",
              "settings": {"text": "Give oxygen. Attach monitor."},
              "inputs": {"image": "00"}},
      "02": {"kind": "RequireProcedureCompleted", "return_type": "PVoid",
              "inputs": {"procedure": "01"}},
      "06": {"kind": "UserInputBool", "return_type": "PBool",
              "label": "Shockable Rhythm?",
              "settings": {"true_text": "Yes", "false_text": "No"}},
      "0F": {"kind": "IfThenElse", "return_type": "PVoid",
              "inputs": {"condition": "06",
                          "true_branch": "0B",
                          "false_branch": "0E"}},
      "10": {"kind": "ProcedureSequence", "return_type": "PVoid",
              "label": "Adult Cardiac Arrest",
              "substeps": ["02", "03", "05", "0F"]}
    }
  }
}

Traversal Rules

Walk from root:

• ProcedureSequence: run substeps in order.
• IfThenElse: evaluate inputs.condition, then follow inputs.true_branch or inputs.false_branch.
• RequireProcedureCompleted: run inputs.procedure.
• ShowInstructions: show settings.text.
• Stopwatch / PaceKeeper / UserInput*: render the matching control and store the result.
• NullProcedure / DoNothing: skip.

Nodes may be reused. The procedure viewer also supports cycles that complete at least one interactive step before re-entering the loop.

Custom Viewer

A viewer only needs capturegraph.root, capturegraph.nodes, and a value map for completed leaf nodes.

• Load root and nodes from the V2 response.
• Find the next active leaf node from root.
• Render that node from its kind, label, and settings.
• On completion, save values[activeId] and recompute the next active node.
• For Back, remove the last saved value and recompute from root.

Open Viewer sends the latest V2 response to /viewer.

function resolve(id, nodes) {
  const n = nodes[id];
  if (!n) return null;
  if (n.kind === "RequireProcedureCompleted")
    return resolve(n.inputs?.procedure, nodes);
  if (n.kind === "NullProcedure" || n.kind === "DoNothing") return null;
  return id;
}

function branchId(node, takeTrue) {
  return takeTrue ? node.inputs?.true_branch : node.inputs?.false_branch;
}

function switchBranchId(node, selectedValue) {
  const index = (node.settings?.options ?? []).indexOf(selectedValue);
  return index >= 0 ? node.substeps?.[index] : null;
}

function nextStep(id, nodes, values) {
  const rid = resolve(id, nodes);
  if (!rid) return null;
  const node = nodes[rid];
  if (node.kind === "ProcedureSequence") {
    for (const child of node.substeps ?? []) {
      const active = nextStep(child, nodes, values);
      if (active) return active;
    }
    return null;
  } else if (node.kind === "IfThenElse") {
    const condition = resolve(node.inputs?.condition, nodes);
    if (values[condition] === undefined) return nextStep(condition, nodes, values);
    return nextStep(branchId(node, values[condition]), nodes, values);
  } else if (node.kind === "SwitchString") {
    const selection = resolve(node.inputs?.selection, nodes);
    if (values[selection] === undefined) return nextStep(selection, nodes, values);
    return nextStep(switchBranchId(node, values[selection]), nodes, values);
  }
  return values[rid] === undefined ? rid : null;
}

function complete(activeId, value, state) {
  state.values[activeId] = value;
  state.history.push(activeId);
  state.activeId = nextStep(state.root, state.nodes, state.values);
}

function back(state) {
  const id = state.history.pop();
  if (id) delete state.values[id];
  state.activeId = nextStep(state.root, state.nodes, state.values);
}

Node UI

Use label for titles. Use settings and completion values by node kind.

Kind	UI element
ProcedureSequence	Section / step list
ShowInstructions	Info card: settings.text; button uses optional settings.button_text (default Next); save true
UserInputBool	Yes / No: true_text, false_text; save boolean
SwitchString	Match the saved selection to settings.options, then follow the same-index substeps branch
UserInputString	Text field; save string
UserInputNumber	Number field: min_value, max_value, step; save number
UserInputSelectString	Select / radio: options[]; save selected string
IfThenElse	Branch from saved condition value
Stopwatch	Timer; save elapsed seconds
PaceKeeper	Metronome at settings.bpm; save true
RequireProcedureCompleted	Resolve and run inputs.procedure
NullProcedure / DoNothing	Skip