Orbits

let task1 = ORTask(
    description: "Research AI trends",
    expectedOutput: "Research report"
)

let task2 = ORTask(
    description: """
    Write article based on:
    {task_0_output}
    """,
    expectedOutput: "Article",
    context: [task1.id]
)

let task3 = ORTask(
    description: """
    Edit article for publication.
    Original research: {task_0_output}
    Article draft: {task_1_output}
    """,
    expectedOutput: "Final article",
    context: [task1.id, task2.id]
)

let inputs = OrbitInput(Metadata([
    "company": .string("TechCorp"),
    "year": .int(2024),
    "quarter": .string("Q4")
]))

let task = ORTask(
    description: """
    Analyze {company} performance for {year} {quarter}.
    """,
    expectedOutput: "Performance report"
)

let result = try await orbit.start(inputs: inputs)
// "Analyze TechCorp performance for 2024 Q4."

let inputs = OrbitInput(Metadata([
    "mode": .string("detailed"),
    "include_charts": .bool(true)
]))

let task = ORTask(
    description: """
    Generate report in {mode} mode.
    {if include_charts}Include visualizations and charts.{endif}
    {if mode=detailed}Provide comprehensive analysis with examples.{endif}
    """,
    expectedOutput: "Report"
)

// Enable metrics collection
let orbit = try await Orbit.create(
    name: "Tracked Workflow",
    agents: agents,
    tasks: tasks,
    usageMetrics: true  // Default: true
)

let result = try await orbit.start()

// Access aggregated metrics
let metrics = result.usageMetrics

print("Token Usage:")
print("  Prompt: \(metrics.promptTokens)")
print("  Completion: \(metrics.completionTokens)")
print("  Total: \(metrics.totalTokens)")

print("\nAPI Calls:")
print("  Successful: \(metrics.successfulRequests)")
print("  Total: \(metrics.totalRequests)")
print("  Success rate: \((Double(metrics.successfulRequests) / Double(metrics.totalRequests)) * 100)%")

// Calculate costs (example for OpenAI)
let inputCost = Double(metrics.promptTokens) * 0.00001  // $0.01 per 1K
let outputCost = Double(metrics.completionTokens) * 0.00003  // $0.03 per 1K
let totalCost = inputCost + outputCost

print("\nEstimated Cost: $\(String(format: "%.4f", totalCost))")

let result = try await orbit.start()

print("Performance Metrics:")
print("  Total execution: \(result.executionTime)s")

// Per-task timing
for (index, output) in result.taskOutputs.enumerated() {
    if let task = orbit.tasks[safe: index] {
        print("  Task \(index): \(task.executionTime ?? 0)s")
    }
}

// Identify bottlenecks
let sortedTasks = result.taskOutputs.enumerated().sorted {
    guard let time1 = orbit.tasks[safe: $0.offset]?.executionTime,
          let time2 = orbit.tasks[safe: $1.offset]?.executionTime else {
        return false
    }
    return time1 > time2
}

print("\nSlowest tasks:")
for (index, _) in sortedTasks.prefix(3) {
    if let task = orbit.tasks[safe: index] {
        print("  \(task.description): \(task.executionTime ?? 0)s")
    }
}

let result = try await orbit.start()

// Aggregate tool usage across all tasks
var toolStats: [String: (count: Int, totalTime: TimeInterval)] = [:]

for output in result.taskOutputs {
    for toolUsage in output.toolsUsed {
        if var stats = toolStats[toolUsage.toolName] {
            stats.count += 1
            stats.totalTime += toolUsage.executionTime
            toolStats[toolUsage.toolName] = stats
        } else {
            toolStats[toolUsage.toolName] = (1, toolUsage.executionTime)
        }
    }
}

print("Tool Usage Statistics:")
for (tool, stats) in toolStats.sorted(by: { $0.value.count > $1.value.count }) {
    let avgTime = stats.totalTime / Double(stats.count)
    print("  \(tool): \(stats.count) calls, avg \(String(format: "%.2f", avgTime))s")
}

do {
    let orbit = try await Orbit.create(
        name: "Test Orbit",
        agents: agents,
        tasks: tasks
    )
} catch OrbitAIError.configuration(let message) {
    print("Configuration error: \(message)")

    // Check specific issues
    if agents.isEmpty {
        print("Error: No agents provided")
    }
    if tasks.isEmpty {
        print("Error: No tasks provided")
    }

    // Validate agent configs
    for agent in agents {
        if agent.role.isEmpty {
            print("Error: Agent missing role")
        }
    }
}

// Verify agents have necessary tools
for agent in agents {
    let tools = await agent.getToolNames()
    print("\(agent.role) tools: \(tools)")
}

// Verify LLM provider
let llmManager = await orbit.getLLMManager()
let providers = await llmManager.getAvailableProviders()
print("Available providers: \(providers)")

if providers.isEmpty {
    // Configure provider
    let provider = try OpenAIProvider.fromEnvironment(
        model: .gpt4o
    )
    await orbit.configureLLMProvider(provider, asDefault: true)
}

// Enable verbose logging
let orbit = try await Orbit.create(
    name: "Debug Orbit",
    agents: agents,
    tasks: tasks,
    verbose: true  // See what's happening
)

// Ensure context is declared
let task = ORTask(
    description: "Process: {task_0_output}",
    expectedOutput: "Result",
    context: [previousTask.id]  // Required!
)

// Provide orbit inputs
let inputs = OrbitInput(Metadata([
    "variable": .string("value")
]))
let result = try await orbit.start(inputs: inputs)

// Verify variable names match
// Description: "Analyze {industry}"
// Input key must be: "industry"

// Disable unnecessary memory
let orbit = Orbit.create(
    name: "Lightweight Orbit",
    agents: agents,
    tasks: tasks,
    memory: false,           // Disable if not needed
    longTermMemory: false,
    entityMemory: false
)

// Configure memory limits
let memoryConfig = MemoryConfiguration(
    maxMemoryItems: 50,      // Limit storage
    compressionEnabled: true, // Auto-summarize
    pruneOldItems: true      // Remove old entries
)

// Extract only needed data
let summaryTask = ORTask(
    description: "Summarize key points from research",
    expectedOutput: "5 bullet points"  // Compact output
)

// Use flow-based for parallelization
let taskFlow = TaskFlow(
    tasks: independentTasks
)

let engine = TaskExecutionEngine(
    agentExecutor: executor,
    maxConcurrentTasks: 5  // Enable parallelism
)

// Optimize context
let task = ORTask(
    description: "Use summary: {task_1_output}",
    context: [summaryTask.id]  // Reference specific task, not all
)

// Enable context window management
let agent = Agent(
    role: "Agent",
    purpose: "Process efficiently",
    context: "...",
    respectContextWindow: true  // Auto-prune context
)

// Profile execution
let result = try await orbit.start()
for (i, output) in result.taskOutputs.enumerated() {
    if let task = orbit.tasks[safe: i] {
        print("Task \(i): \(task.executionTime ?? 0)s")
    }
}

// Lower temperature for consistency
let agent = Agent(
    role: "Data Processor",
    purpose: "Process data consistently",
    context: "Deterministic processing",
    temperature: 0.0  // Fully deterministic
)

// Use structured outputs
struct ProcessingResult: Codable, Sendable {
    let status: String
    let count: Int
}

let task = ORTask.withStructuredOutput(
    description: "Process data",
    expectedType: ProcessingResult.self,
    agent: agent.id
)

// Disable memory for stateless execution
let orbit = Orbit.create(
    name: "Stateless Orbit",
    agents: [agent],
    tasks: [task],
    memory: false  // No state
)