ART Swift ADK

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

.target(
    name: "MyApp",
    dependencies: [
        .product(name: "ArtAdk", package: "art-swift-adk"),
        .product(name: "ArtAdkNotifications", package: "art-swift-adk") // optional
    ]
)

func fetchPasscode(for username: String) async throws -> String {
    var request = URLRequest(url: URL(string: "PASSCODE_URL")!)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try JSONSerialization.data(withJSONObject: ["username": username])

    let (data, _) = try await URLSession.shared.data(for: request)
    let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]
    return json?["passcode"] as? String ?? ""
}

import ArtAdk

let passcode = try await fetchPasscode(for: "john_doe")

let adk = Adk(config: AdkConfig(uri: "YOUR_WEBSOCKET_URI", authToken: passcode))

adk.setCredentials(CredentialStore(
    environment: "YOUR_ENV",
    projectKey:  "YOUR_PROJECT_KEY",
    orgTitle:    "YOUR_ORG",
    clientID:    "YOUR_CLIENT_ID",
    accessToken: passcode
))

await adk.connect()

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

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

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

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

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

await adk.connect()

adk.pause()
await adk.resume()

await adk.disconnect()   // close the connection

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

// When you no longer need the channel:
await channel.unsubscribe()

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

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

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

if let subscription = channel as? Subscription {
    let token = subscription.bind(event: "message") { content in
        print(content)
    }

    // Later:
    subscription.remove(event: "message", id: token)
}

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

// Later, to stop receiving updates:
try await stopPresence()

_ = try await adk.generateKeyPair()

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

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

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

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

if let live = channel as? LiveObjSubscription {
    // Edit the document, then send your changes.
    live.state()["document"]["title"].set("My Doc")
    await live.flush()
    // Read a value.
    if let document = await live.query(path: "document").execute() {
        print(document)
    }

    // Watch for changes. The callback also receives the current value.
    let stopWatching = await live.query(path: "document").listen { value in
        print("Updated:", value)
    }

    // Later:
    stopWatching()
}

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

items.push("alpha")                                     // add to the end
items.unshift("zero")                                   // add to the start
items.pop()                                             // remove the last item
items.removeAt(2)                                       // remove the item at an index
items.splice(start: 1, deleteCount: 1, insert: ["x"])   // replace a range

await live.flush()

_ = try await adk.intercept(interceptor: "profanity-filter") { payload, resolve, reject in
    if let text = payload["text"] as? String, text.contains("badword") {
        reject("Message blocked")
        return
    }
    resolve(payload)
}

let agent = adk.agent("YOUR_AGENT_ID")
let thread = agent.thread()   // or agent.thread("THREAD_ID") to continue a conversation

await thread.listen { envelope in
    print("Event:", envelope.event)
}

let run = try 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("The agent couldn't finish:", error.message)
}

let stopUpdates = await thread.listenState { state in
    print(state.phase, state.message)
}

print(thread.getState().phase)   // the latest state
stopUpdates()                    // stop receiving updates

thread.feedbackRequest { request, run in
    print("The agent asks:", request.prompt)

    Task {
        do {
            try await run.sendFeedback("Budget is 50,000, travelling in December")
        } catch {
            print("Couldn't send the answer:", error)
        }
    }
}

let file = try await agent.upload(fileURL: documentURL, options: UploadOptions(
    progress: { fraction in print("Uploaded \(Int(fraction * 100))%") }
))

let run = try await thread.run("Summarize this document", fileMeta: [FileMeta(file)])

let orchestrator = adk.orchestrator("YOUR_ORCHESTRATOR_ID")
let thread = try await orchestrator.thread()

thread.listen { event in
    print(event)
}

thread.listenState { state in
    print(state.phase)
}

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

let ref = try await adk.upload(data: pngData, filename: "chart.png", contentType: "image/png")

let page = try await adk.listFiles(options: ListOptions(configType: .media, page: 1, limit: 20))
let file = try await adk.getFile(fileId: ref.fileId)   // includes a signed URL for reading the file
try await adk.deleteFile(fileId: ref.fileId)           // pass hard: true to delete it permanently

do {
    _ = try await adk.upload(data: pngData)
} catch let error as UploadError where error.step == .signedURL && error.status == 403 {
    print("This user's role doesn't allow uploads")
}

try await adk.updateProfile(UpdateProfileData(firstName: "Ada", email: "ada@example.com"))

let crm = try adk.connector("YOUR_CONNECTOR_ID")

let profile = try await crm.profile()          // the allowed fields and their current values
try await crm.updateProfile(["region": "eu"])  // only allowed fields can be changed

import ArtAdkNotifications

let inbox = adk.use(notifications())

// Receive new notifications as they arrive.
let stopListening = try await inbox.onNew { notification in
    print(notification.title)
}

let unread = try await inbox.list(NotificationListParams(status: .unread))
try await inbox.markRead()   // marks every unread notification as read

// Register the device for push notifications.
try await inbox.registerDevice(RegisterDeviceInput(token: pushToken, platform: .ios))

let result: [String: Any] = try await adk.call(
    endpoint: "/v1/some-endpoint",
    options: CallApiProps(method: "POST", payload: ["key": "value"])
)

ArtLog.handler = { level, message in
    print("[ART][\(level)] \(message)")
}