ART Swift ADK

dependencies: [
    .package(url: "https://github.com/aiotrixdev/art-swift-adk.git", from: "1.0.1")
]

let creds = CredentialStore(
    environment:  "YOUR_ENV",
    projectKey:   "YOUR_PROJECT_KEY",
    orgTitle:     "YOUR_ORG",
    clientID:     "CLIENT_ID",
    clientSecret: "CLIENT_SECRET"
)

func fetchPasscode(creds: CredentialStore) async throws -> String {
    let url = URL(string: "YOUR_ORCHESTRATOR_ID")!
    
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    
    request.addValue(creds.clientID, forHTTPHeaderField: "Client-Id")
    request.addValue(creds.clientSecret, forHTTPHeaderField: "Client-Secret")
    request.addValue(creds.orgTitle, forHTTPHeaderField: "X-Org")
    request.addValue(creds.environment, forHTTPHeaderField: "Environment")
    request.addValue(creds.projectKey, forHTTPHeaderField: "ProjectKey")
    request.addValue("application/json", forHTTPHeaderField: "Content-Type")
    
    let body: [String: Any] = [
        "username": "john_doe",
        "first_name": "John",
        "last_name": "Doe"
    ]
    
    request.httpBody = try JSONSerialization.data(withJSONObject: body)
    
    let (data, _) = try await URLSession.shared.data(for: request)
    let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]
    let dataObj = json?["data"] as? [String: Any]
    
    return dataObj?["passcode"] as? String ?? ""
}

import ArtAdk

let passcode = try await fetchPasscode(creds: creds)

let adk = Adk(config: AdkConfig(
    uri: "YOUR_WEBSOCKET_URI",
    authToken: passcode,
    getCredentials: { creds }
))

adk.on("connection") { data in
    if let conn = data as? ConnectionDetail {
        print("Connected → \(conn.connectionId)")
    }
}

adk.on("close") { reason in
    print("Closed:", reason)
}

try await adk.connect()

let sub = try await adk.subscribe(channel: "room-42")

sub.emitter.on("message") { data in
    print("Received:", data)
}

try await sub.push(
    event: "message",
    data: ["text": "Hello ART!"]
)

try await adk.connect()

do {
    try await adk.connect()
} finally {
    await adk.disconnect()
}

adk.getState() // connected | retrying | paused | stopped

let sub = try await adk.subscribe(channel: "room-42")

if let live = sub as? LiveObjSubscription {
    // CRDT channel
}

await sub.unsubscribe()

try await sub.push(
    event: "message",
    data: ["text": "Hello"]
)

try await sub.push(
    event: "message",
    data: ["text": "Hi Bob"],
    options: PushConfig(to: ["bob"])
)

sub.emitter.on("message") { data in
    print("Got:", data)
}

let cancel = try await sub.fetchPresence { users in
    print("Online:", users)
}

// later
await cancel()

try await adk.generateKeyPair()

let secure = try await adk.subscribe(channel: "SECURE_CHANNEL")

try await secure.push(
    event: "message",
    data: ["text": "Private"],
    options: PushConfig(to: ["bob"])
)

secure.emitter.on("message") { data in
    print("Decrypted:", data)
}

let sub = try await adk.subscribe(channel: "CRDT_CHANNEL")

if let live = sub as? LiveObjSubscription {
    
    // Write
    live.state()["document"]["title"].set("My Doc")
    await live.flush()
    
    // Read
    let snapshot = await live.query(path: "document").execute()
    print(snapshot)
    
    // Listen
    let dispose = await live.query(path: "document").listen { data in
        print("Updated:", data)
    }
    
    dispose()
}

let items = live.state()["items"]

items.push("alpha")
items.unshift("zero")
items.pop()
items.removeAt(2)
items.splice(start: 1, deleteCount: 1, insert: ["x"])

await live.flush()

try await adk.intercept(interceptor: "filter") { payload, resolve, reject in
    
    if let text = payload["text"] as? String,
       text.contains("anyword") {
        reject("Blocked")
        return
    }
    
    resolve(payload)
}

adk.on("connection") { data in
    print("Connected")
}

adk.on("close") { _ in
    print("Closed")
}

adk.pause()
await adk.resume()
await adk.disconnect()

let agent = adk.agent("YOUR_AGENT_ID")

let thread = agent.thread()

await thread.listen { envelope in
    print(envelope.event)
}

let run = await thread.run(
    "Plan a 3-day trip to Dubai"
)

do {
    let output = try await run.done()
    print(output.message)
} catch let error as AgentError {
    print(error.message)
}

thread.feedbackRequest { request, run in
    Task {
        try await run.sendFeedback(
            "Budget 50,000 travelling in December"
        )
    }
}

await thread.listenTrace { frame in
    print(frame)
}

let orchestrator = adk.orchestrator(
    "YOUR_ORCHESTRATOR_ID"
)

let thread = try await orchestrator.thread()

thread.listen { event in
    print(event)
}

try await thread.push(
    event: "user_input",
    data: [
        "message": "Plan a 3-day trip to Goa"
    ]
)

thread.listen { event in

    guard
        let content = event["content"] as? [String: Any],
        let reply = content["reply"] as? ([String: Any]) -> Void
    else { return }

    reply([
        "user_input":
            "Budget 50,000 travelling in December"
    ])
}

thread.listenTrace { frame in
    print(frame)
}