Swarm

let result = try await (fetchAgent --> reasonAgent --> writerAgent)
    .run("Summarize the WWDC session on Swift concurrency.")

print(result.output)

// ❌ Compile error under Swarm's StrictConcurrency — caught before it ships
struct BrokenAgent: AgentRuntime {
    var cache: NSCache<NSString, NSString>
    // error: stored property 'cache' of 'Sendable'-conforming struct
    //        has non-Sendable type 'NSCache<NSString, NSString>'
}

// ✓ Actor isolation makes shared state safe by construction
actor ResponseCache {
    private var store: [String: String] = [:]
    func set(_ value: String, for key: String) { store[key] = value }
    func get(_ key: String) -> String? { store[key] }
}

// Crash-recovery checkpoint store — survives process restarts
let store = FileSystemWorkflowCheckpointStore(
    directory: .applicationSupportDirectory.appending(path: "workflow-checkpoints")
)

// Snapshots are serialised JSON — human-readable, diff-friendly
// { "workflowID": "run-42", "stepIndex": 3, "intermediateOutput": "...", "timestamp": "..." }

// Sequential chain
fetchAgent --> analyzeAgent --> writerAgent

// Type-safe pipeline (compiler enforces Input/Output types at each stage)
let pipeline = Pipeline<String, [String]>  { $0.components(separatedBy: "\n") }
             >>> Pipeline<[String], String> { $0.filter { !$0.isEmpty }.joined(separator: "• ") }

// Dependency DAG — nodes run as soon as their dependencies complete
DAGWorkflow(nodes: [
    DAGNode("fetch",   agent: fetchAgent),
    DAGNode("refs",    agent: refsAgent),
    DAGNode("analyze", agent: analyzeAgent).dependsOn("fetch", "refs"),
    DAGNode("write",   agent: writerAgent).dependsOn("analyze"),
])

// Human-in-the-loop: three-way response
HumanApproval("Approve before publishing?", handler: reviewerUI)
// .approved          → workflow continues with current output
// .rejected(reason)  → workflow throws OrchestrationError.humanApprovalRejected
// .modified(newInput) → corrected value flows forward, replacing the agent's output

import Swarm

// 1. Define a tool
@Tool("Returns the current price of a stock")
struct StockPriceTool {
    @Parameter("Ticker symbol, e.g. AAPL")
    var ticker: String

    func execute() async throws -> String {
        // call your price API here
        return "182.50"
    }
}

// 2. Define an agent blueprint
struct FinanceAgent: AgentBlueprint {
    let analyst = Agent(
        name: "Analyst",
        tools: [StockPriceTool()],
        instructions: "Answer finance questions concisely using real data."
    )

    @OrchestrationBuilder var body: some OrchestrationStep {
        Guard(.input) {
            InputGuard("no_pii") { input in
                input.contains("SSN") ? .tripwire(message: "PII detected") : .passed()
            }
        }
        analyst
    }
}

// 3. Run it
let result = try await FinanceAgent()
    .environment(\.inferenceProvider, .anthropic(key: "YOUR_API_KEY"))
    .run("What is the current price of AAPL?")

print(result.output)

let group = ParallelGroup(
    agents: [
        (name: "primary", agent: primaryAgent),
        (name: "backup",  agent: backupAgent),
        (name: "expert",  agent: expertAgent),
    ],
    mergeStrategy: MergeStrategies.Concatenate(
        separator: "\n\n---\n\n",
        shouldIncludeAgentNames: true
    ),
    maxConcurrency: 3
)

let result = try await group.run("Analyze the Swift concurrency model.")

let memory = VectorMemory(
    embeddingProvider: myEmbedder,
    similarityThreshold: 0.75,
    maxResults: 8
)

await memory.add(.user("The project deadline is March 15."))
await memory.add(.assistant("Noted. I will prioritise accordingly."))

// Semantically retrieves the deadline entry despite different phrasing
let context = await memory.context(for: "When is this due?", tokenLimit: 1_200)

let supervisor = SupervisorAgent(
    agents: [
        (name: "math",    agent: mathAgent,    description: mathDesc),
        (name: "weather", agent: weatherAgent, description: weatherDesc),
        (name: "code",    agent: codeAgent,    description: codeDesc),
    ],
    routingStrategy: LLMRoutingStrategy(inferenceProvider: provider),
    fallbackAgent: Agent(instructions: "I am a general assistant.")
)

let result = try await supervisor.run("What is 15% of $240?")
// Routes to mathAgent

let agent = FinanceAgent()
    .environment(\.inferenceProvider, provider)
    .withRetry(.exponentialBackoff(maxAttempts: 3, baseDelay: .seconds(1)))
    .withCircuitBreaker(threshold: 5, resetTimeout: .seconds(60))
    .withFallback(Agent(instructions: "Service temporarily unavailable."))
    .withTimeout(.seconds(30))

for try await event in (fetchAgent --> writerAgent).stream("Summarise the changelog.") {
    switch event {
    case .outputToken(let token):  print(token, terminator: "")
    case .toolCalling(let call):   print("\n[tool: \(call.toolName)]")
    case .completed(let result):   print("\n\nDone in \(result.duration)")
    case .failed(let error):       print("\nError: \(error)")
    default: break
    }
}

let session = InMemorySession(sessionId: "user-42")

try await agent.run("My portfolio has 100 AAPL shares.", session: session)
let result = try await agent.run("What is my total value?", session: session)
// Agent recalls the earlier context

// Package.swift
dependencies: [
    .package(url: "https://github.com/christopherkarani/Swarm.git", from: "0.3.1")
],
targets: [
    .target(name: "YourApp", dependencies: ["Swarm"])
]