metadata:
  id: workflow_id
  name: Workflow Name
  description: What this workflow does
  version: "1.0.0"

config:
  max_parallel: 10
  default_timeout_ms: 60000

agents:
  agent_name:
    model: gpt-4
    system_prompt: "System instructions"
    temperature: 0.7

nodes:
  - type: start
    id: start
  
  - type: llm_agent
    id: process
    name: Process Input
    agent:
      agent_id: agent_name
  
  - type: end
    id: end

edges:
  - from: start
    to: process
  - from: process
    to: end

edges:
  - from: start
    to: process
  - from: process
    to: end

edges:
  - from: classify
    to: handle_billing
    condition: "category == 'billing'"
    label: billing
  
  - from: classify
    to: handle_technical
    condition: "category == 'technical'"
    label: technical

edges:
  # Fork to parallel branches
  - from: fork
    to: task_a
  - from: fork
    to: task_b
  - from: fork
    to: task_c
  
  # Branches to merge
  - from: task_a
    to: merge
  - from: task_b
    to: merge
  - from: task_c
    to: merge

metadata:
  id: ${WORKFLOW_ID}
  name: ${WORKFLOW_NAME}

agents:
  gpt_agent:
    model: ${MODEL_NAME}
    temperature: ${TEMPERATURE}

nodes:
  - type: llm_agent
    id: process
    name: Process
    agent:
      agent_id: gpt_agent
    prompt_template: "${PROMPT_PREFIX} {{ input }}"

metadata:
  id: customer_support
  name: Customer Support Workflow
  description: Routes customer queries to appropriate handlers
  version: "1.0.0"

agents:
  classifier:
    model: gpt-4
    system_prompt: "Classify queries into: billing, technical, general"
    temperature: 0.3
    max_tokens: 50
  
  billing_handler:
    model: gpt-4
    system_prompt: "Help customers with billing inquiries"
    temperature: 0.7
  
  technical_handler:
    model: gpt-4
    system_prompt: "Help customers with technical issues"
    temperature: 0.7

nodes:
  - type: start
    id: start
  
  - type: llm_agent
    id: classify
    name: Classify Query
    agent:
      agent_id: classifier
    config:
      timeout_ms: 30000
  
  - type: llm_agent
    id: handle_billing
    name: Handle Billing
    agent:
      agent_id: billing_handler
    prompt_template: "Customer query: {{ input }}"
  
  - type: llm_agent
    id: handle_technical
    name: Handle Technical
    agent:
      agent_id: technical_handler
    prompt_template: "Customer query: {{ input }}"
  
  - type: end
    id: end

edges:
  - from: start
    to: classify
  
  - from: classify
    to: handle_billing
    condition: "category == 'billing'"
  
  - from: classify
    to: handle_technical
    condition: "category == 'technical'"
  
  - from: handle_billing
    to: end
  
  - from: handle_technical
    to: end

metadata:
  id: parallel_analysis
  name: Parallel Analysis Workflow
  description: Analyzes content using multiple agents in parallel

agents:
  sentiment_analyzer:
    model: gpt-4
    system_prompt: "Analyze sentiment: positive, negative, or neutral"
    temperature: 0.3
  
  keyword_extractor:
    model: gpt-4
    system_prompt: "Extract top 5 keywords"
    temperature: 0.3
  
  summary_generator:
    model: gpt-4
    system_prompt: "Generate a brief summary"
    temperature: 0.5

nodes:
  - type: start
    id: start
  
  - type: parallel
    id: fork
    name: Fork Analysis
  
  - type: llm_agent
    id: sentiment
    name: Sentiment Analysis
    agent:
      agent_id: sentiment_analyzer
  
  - type: llm_agent
    id: keywords
    name: Keyword Extraction
    agent:
      agent_id: keyword_extractor
  
  - type: llm_agent
    id: summary
    name: Summary Generation
    agent:
      agent_id: summary_generator
  
  - type: join
    id: merge
    name: Merge Results
    wait_for:
      - sentiment
      - keywords
      - summary
  
  - type: transform
    id: format
    name: Format Output
    transform_type: template
    template: |
      Analysis Results:
      - Sentiment: {{ sentiment }}
      - Keywords: {{ keywords }}
      - Summary: {{ summary }}
  
  - type: end
    id: end

edges:
  - from: start
    to: fork
  
  - from: fork
    to: sentiment
  - from: fork
    to: keywords
  - from: fork
    to: summary
  
  - from: sentiment
    to: merge
  - from: keywords
    to: merge
  - from: summary
    to: merge
  
  - from: merge
    to: format
  
  - from: format
    to: end

use mofa_sdk::workflow::{WorkflowDslParser, WorkflowExecutor, ExecutorConfig, WorkflowValue};
use mofa_sdk::llm::{LLMAgent, LLMAgentBuilder, openai_from_env};
use std::collections::HashMap;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse workflow from file
    let definition = WorkflowDslParser::from_file("customer_support.yaml")?;
    
    // Build agent registry
    let mut agent_registry = HashMap::new();
    let provider = Arc::new(openai_from_env()?);
    
    for (agent_id, config) in &definition.agents {
        let agent = Arc::new(
            LLMAgentBuilder::new()
                .with_id(agent_id)
                .with_provider(provider.clone())
                .with_model(&config.model)
                .with_system_prompt(
                    config.system_prompt.as_deref().unwrap_or("")
                )
                .with_temperature(config.temperature.unwrap_or(0.7))
                .build()
        );
        agent_registry.insert(agent_id.clone(), agent);
    }
    
    // Build workflow
    let workflow = WorkflowDslParser::build_with_agents(
        definition,
        &agent_registry
    ).await?;
    
    // Execute workflow
    let executor = WorkflowExecutor::new(ExecutorConfig::default());
    let input = WorkflowValue::String(
        "I was charged twice for my subscription".to_string()
    );
    
    let result = executor.execute(&workflow, input).await?;
    println!("Result: {:?}", result);
    
    Ok(())
}