Workflow

from fibonacci import Workflow

wf = Workflow(
    name="customer-support-bot",
    description="Routes and responds to customer support tickets",
    version=1
)

wf = Workflow.from_yaml(path: str) -> Workflow

wf = Workflow.from_yaml("workflows/analyzer.yaml")

wf.add_node(node: Node) -> Workflow

wf.add_node(node_a).add_node(node_b).add_node(node_c)

wf.add_nodes(nodes: list[Node]) -> Workflow

wf.add_nodes([classifier, router, handler_a, handler_b])

wf.get_node(node_id: str) -> Node | None

wf.remove_node(node_id: str) -> Workflow

wf.validate() -> bool

if wf.validate():
    wf.deploy()

wf.deploy(
    api_key: str | None = None,
    validate: bool = True
) -> str

workflow_id = wf.deploy(api_key="fib_live_abc123")
print(f"Deployed: {workflow_id}")

workflow_id = await wf.deploy_async(api_key="fib_live_abc123")

wf.run(
    input_data: dict,
    workflow_id: str | None = None,
    wait: bool = True,
    timeout: float = 300.0,
    secrets: dict | None = None
) -> WorkflowRunStatus

result = wf.run(
    input_data={"text": "Hello world"},
    secrets={"GOOGLE_TOKEN": "my-token"}
)
print(result.output_data["analyzer"])

import asyncio

async def main():
    result = await wf.run_async(
        input_data={"text": "Hello world"}
    )
    print(result.output_data)

asyncio.run(main())

wf.get_status(run_id: str | None = None) -> WorkflowRunStatus

wf.update(
    name: str | None = None,
    description: str | None = None,
    is_active: bool | None = None
) -> WorkflowResponse

wf.delete() -> bool

wf.activate()    # -> WorkflowResponse
wf.deactivate()  # -> WorkflowResponse

wf.get_stats() -> WorkflowStats

yaml_str = wf.to_yaml()            # return string
wf.to_yaml("exported.yaml")        # write to file

yaml_str = wf.to_yaml_string()

data = wf.to_dict()

print(wf.workflow_id)   # e.g. "wf_abc123"

for node in wf.nodes:
    print(node.id)

print(wf.node_count)   # e.g. 4

wf = Workflow.from_yaml("workflow.yaml")
wf.deploy()
result = wf.run(input_data={"text": "Hello!"})

wf.to_yaml("exported.yaml")

from fibonacci import Workflow, LLMNode, ToolNode, ConditionalNode, Config

# Optional: explicit config
config = Config(api_key="fib_live_abc123")

wf = Workflow(
    name="feedback-pipeline",
    description="Classifies and routes customer feedback",
    version=1,
    config=config
)

# Classify
classify = LLMNode(
    id="classify",
    name="Classify Feedback",
    instruction="Classify as positive, negative, or neutral. One word only.\n\n{{input.feedback}}"
)

# Route
router = ConditionalNode(
    id="router",
    name="Route by Sentiment",
    left_value="{{classify}}",
    operator="contains",
    right_value="negative",
    true_branch=["escalate"],
    false_branch=["log_ok"],
    dependencies=["classify"]
)

# Escalate negative
escalate = ToolNode(
    id="escalate",
    name="Alert Support Team",
    tool="slack_send_message",
    params={
        "channel": "#support",
        "message": "Negative feedback: {{input.feedback}}"
    },
    dependencies=["router"]
)

# Log positive/neutral
log_ok = ToolNode(
    id="log_ok",
    name="Log Feedback",
    tool="google_sheets_append",
    params={
        "spreadsheet_id": "{{input.log_sheet}}",
        "range": "Log!A:C",
        "values": [["{{input.feedback}}", "{{classify}}"]]
    },
    dependencies=["router"]
)

wf.add_nodes([classify, router, escalate, log_ok])

# Validate before deploying
wf.validate()

# Deploy
workflow_id = wf.deploy()
print(f"Deployed: {workflow_id}")

# Run
result = wf.run(
    input_data={"feedback": "Great product!", "log_sheet": "abc123"}
)
print(result.output_data)
print(f"Cost: ${result.total_cost:.4f}")

# Lifecycle management
stats = wf.get_stats()
print(f"Total runs: {stats.total_runs}, success rate: {stats.success_rate:.0%}")

# Deactivate when not needed
wf.deactivate()