Agents

Agent (Core Entity)
    ├── Identity
    │   ├── ID (OrbitAIID)
    │   ├── Role (String)
    │   └── Purpose (String)
    │
    ├── Intelligence
    │   ├── LLM Provider
    │   ├── Context/Background
    │   └── Temperature
    │
    ├── Capabilities
    │   ├── Tools (Array)
    │   ├── Memory System
    │   └── Knowledge Base
    │
    ├── Execution
    │   ├── OrbitAgentExecutor
    │   ├── Task Queue
    │   └── Output Generation
    │
    └── Monitoring
        ├── Usage Metrics
        ├── Performance Data
        └── Execution History

let memoryConfig = MemoryConfiguration(
    maxMemoryItems: 100,          // Maximum stored items
    persistencePath: "./memory",   // Storage location
    embeddingModel: "text-embedding-ada-002",
    similarityThreshold: 0.75,    // Relevance threshold
    compressionEnabled: true       // Automatic summarization
)

let agent = Agent(
    role: "Knowledge Assistant",
    purpose: "Provide informed responses using memory",
    context: "Assistant with excellent recall",
    memory: true,
    longTermMemory: true,
    memoryConfig: memoryConfig
)

let agent = Agent(
    role: "Long-Context Analyst",
    purpose: "Analyze large documents",
    context: "Expert in processing extensive content",
    respectContextWindow: true,    // Enforce limits
    maxTokens: 4000               // Per-response limit
)

let agent = Agent(
    role: "Problem Solver",
    purpose: "Solve complex analytical problems",
    context: "Expert in systematic problem-solving",
    maxIter: 20,                  // Allow up to 20 reasoning steps
    allowDelegation: true          // Can delegate subtasks
)

let agent = Agent(
    role: "High-Volume Assistant",
    purpose: "Handle multiple concurrent requests",
    context: "Efficient assistant for batch processing",
    maxRPM: 60,                   // 60 requests per minute
    maxExecutionTime: 300         // 5 minute timeout
)

// Manager agent that can delegate
let manager = Agent(
    role: "Project Manager",
    purpose: "Coordinate complex projects across teams",
    context: "Experienced PM with delegation skills",
    allowDelegation: true,
    tools: ["task_delegator", "progress_tracker"]
)

// Worker agents for specialized tasks
let dataAgent = Agent(
    role: "Data Processor",
    purpose: "Process and transform data",
    context: "Data engineering expert"
)

let reportAgent = Agent(
    role: "Report Generator",
    purpose: "Create formatted reports",
    context: "Technical writing specialist"
)

let agent = Agent(
    role: "Monitored Agent",
    purpose: "Execute tasks with detailed tracking",
    context: "Agent with comprehensive monitoring",
    verbose: true,                // Log all steps
    stepCallback: "onAgentStep"   // Custom callback function
)

// Callback implementation
func onAgentStep(step: AgentStep) {
    print("Agent: \(step.agentId)")
    print("Action: \(step.action)")
    print("Thought: \(step.thought)")
    print("Observation: \(step.observation)")
}

let agent = Agent(
    role: "Research Analyst",
    purpose: "Conduct comprehensive market research",
    context: "Expert researcher with analytical capabilities",
    tools: [
        "web_search",          // Search the internet
        "data_analyzer",       // Analyze datasets
        "chart_generator",     // Create visualizations
        "pdf_reader",          // Read PDF documents
        "calculator",          // Perform calculations
        "report_writer"        // Generate reports
    ]
)

// Agent selects tools based on task
let task = ORTask(
    description: """
    Research current AI trends, analyze the data,
    and create a visualization chart.
    """,
    expectedOutput: "Research report with charts"
)

// Agent with multiple tools
let agent = Agent(
    role: "Research Analyst",
    purpose: "Conduct and visualize research",
    context: "Expert researcher with data viz skills",
    tools: [
        "web_search",      // Used for research
        "data_analyzer",   // Used for analysis
        "chart_generator"  // Used for visualization
    ]
)

// Agent automatically selects tools in order:
// 1. web_search for research
// 2. data_analyzer for analysis
// 3. chart_generator for visualization

struct AnalysisReport: Codable, Sendable {
    let title: String
    let executiveSummary: String
    let findings: [Finding]
    let recommendations: [Recommendation]
    let confidence: Double
    let generatedAt: Date

    struct Finding: Codable, Sendable {
        let category: String
        let description: String
        let impact: Impact
        let evidence: [String]
    }

    struct Recommendation: Codable, Sendable {
        let title: String
        let description: String
        let priority: Priority
        let estimatedCost: Double?
    }

    enum Impact: String, Codable {
        case high, medium, low
    }

    enum Priority: String, Codable {
        case critical, high, medium, low
    }
}

// Agent configured for structured output
let agent = Agent(
    role: "Business Analyst",
    purpose: "Generate structured analysis reports",
    context: "Expert analyst with strong reporting skills",
    temperature: 0.3  // Lower for consistent structure
)

// Task with structured output
let task = ORTask.withStructuredOutput(
    description: "Analyze Q4 2024 business performance",
    expectedType: AnalysisReport.self,
    agent: agent.id
)

let reportSchema = JSONSchema(
    type: .object,
    properties: [
        "title": JSONSchema(type: .string),
        "summary": JSONSchema(type: .string),
        "metrics": JSONSchema(
            type: .object,
            properties: [
                "revenue": JSONSchema(type: .number),
                "growth": JSONSchema(type: .number),
                "customers": JSONSchema(type: .integer)
            ]
        ),
        "recommendations": JSONSchema(
            type: .array,
            items: .init(value: JSONSchema(type: .string))
        )
    ],
    required: ["title", "summary", "metrics"]
)

let task = ORTask(
    description: "Generate quarterly business report",
    expectedOutput: "Structured report with metrics and recommendations",
    outputFormat: .structured(reportSchema)
)