API Reference

{
  "type": "complete",
  "output": {
    "status": "completed",
    "result": "Security analysis complete: 2 critical vulnerabilities detected",
    "timestamp": "2024-01-15T10:30:05.700Z"
  },
  "executionTime": 5542,
  "nodesExecuted": 5
}

curl -X POST https://your-domain.vercel.app/api/execute-workflow \
  -H "Content-Type: application/json" \
  -d '{
    "nodes": [
      {
        "id": "start",
        "type": "start",
        "data": { "input": "Analyze threat intelligence" }
      },
      {
        "id": "httpRequest1",
        "type": "httpRequest",
        "data": {
          "method": "GET",
          "url": "https://api.example.com/threats"
        }
      },
      {
        "id": "textModel1",
        "type": "textModel",
        "data": {
          "model": "gpt-4",
          "prompt": "Summarize: $input1",
          "temperature": 0.3
        }
      },
      {
        "id": "end",
        "type": "end",
        "data": {}
      }
    ],
    "edges": [
      { "source": "start", "target": "httpRequest1" },
      { "source": "httpRequest1", "target": "textModel1" },
      { "source": "textModel1", "target": "end" }
    ],
    "apiKeys": {
      "openai": "sk-..."
    }
  }'

async function executeWorkflow(workflowData) {
  const response = await fetch("/api/execute-workflow", {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify(workflowData)
  })

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`)
  }

  // Read streaming response
  const reader = response.body?.getReader()
  const decoder = new TextDecoder()

  if (!reader) throw new Error("No response body")

  while (true) {
    const { done, value } = await reader.read()
    if (done) break

    // Decode chunk and parse each line as JSON
    const chunk = decoder.decode(value)
    const lines = chunk.split("\n").filter(line => line.trim())

    for (const line of lines) {
      const event = JSON.parse(line)

      switch (event.type) {
        case "node_start":
          console.log(`Node started: ${event.nodeId}`)
          break
        case "node_complete":
          console.log(`Node completed: ${event.nodeId}`, event.output)
          break
        case "node_error":
          console.error(`Node failed: ${event.nodeId}`, event.error)
          break
        case "complete":
          console.log("Workflow completed!", event.output)
          return event.output
        case "error":
          throw new Error(`Workflow failed: ${event.error}`)
      }
    }
  }
}

// Usage
const workflow = {
  nodes: [ /* ... */ ],
  edges: [ /* ... */ ],
  apiKeys: {
    openai: process.env.OPENAI_API_KEY
  }
}

try {
  const result = await executeWorkflow(workflow)
  console.log("Final result:", result)
} catch (error) {
  console.error("Execution failed:", error)
}

import requests
import json
import os

def execute_workflow(workflow_data):
    """Execute a TopFlow workflow via API."""
    url = "https://your-domain.vercel.app/api/execute-workflow"
    headers = {"Content-Type": "application/json"}

    response = requests.post(
        url,
        headers=headers,
        json=workflow_data,
        stream=True  # Enable streaming
    )

    if response.status_code == 429:
        reset_time = response.headers.get("X-RateLimit-Reset")
        print(f"Rate limited. Retry after {reset_time}")
        return None

    if not response.ok:
        raise Exception(f"HTTP {response.status_code}: {response.text}")

    # Process streaming response
    for line in response.iter_lines():
        if not line:
            continue

        event = json.loads(line.decode("utf-8"))

        if event["type"] == "node_start":
            print(f"Node started: {event['nodeId']}")
        elif event["type"] == "node_complete":
            print(f"Node completed: {event['nodeId']}")
        elif event["type"] == "node_error":
            print(f"Node failed: {event['nodeId']} - {event['error']}")
        elif event["type"] == "complete":
            print("Workflow completed!")
            return event["output"]
        elif event["type"] == "error":
            raise Exception(f"Workflow failed: {event['error']}")

    return None

# Usage
workflow = {
    "nodes": [
        {
            "id": "start",
            "type": "start",
            "data": {"input": "Analyze security data"}
        },
        {
            "id": "textModel1",
            "type": "textModel",
            "data": {
                "model": "gpt-4",
                "prompt": "Analyze: $input1",
                "temperature": 0.7
            }
        },
        {
            "id": "end",
            "type": "end",
            "data": {}
        }
    ],
    "edges": [
        {"source": "start", "target": "textModel1"},
        {"source": "textModel1", "target": "end"}
    ],
    "apiKeys": {
        "openai": os.environ["OPENAI_API_KEY"]
    }
}

try:
    result = execute_workflow(workflow)
    print(f"Final result: {result}")
except Exception as error:
    print(f"Execution failed: {error}")