Swift SDK

import Skytells

// Option 1: Direct initializer
let client = SkytellsClient(apiKey: "sk-your-api-key")

// Option 2: Factory method
let client = Skytells.createClient(apiKey: "sk-your-api-key")

// Make a prediction
let prediction = try await client.predict(.init(
    model: "vendor/model-name",
    input: ["prompt": "A golden sunset over the Pacific Ocean"]
))

print("Status: \(prediction.status)")  // e.g. .succeeded
print("ID: \(prediction.id)")

// Access the output
if let url = prediction.firstOutputURL {
    print("Output URL: \(url)")
}

let options = ClientOptions(
    baseURL: "https://api.skytells.ai/v1",
    timeout: 90
)
let client = SkytellsClient(apiKey: "sk-...", options: options)

let prediction = try await client.predict(.init(
    model: "vendor/model-name",
    input: ["prompt": "A futuristic cityscape at sunset"]
))

// Array of URL strings (e.g. generated images)
if let urls = prediction.outputURLs {
    for url in urls {
        print("Image: \(url)")
    }
}

// First URL in the output array
if let url = prediction.firstOutputURL {
    print("Primary output: \(url)")
}

// Single string output (e.g. generated text)
if let text = prediction.outputString {
    print("Text: \(text)")
}

// Array of dictionaries
if let objects = prediction.outputObjects {
    for obj in objects {
        print(obj)
    }
}

let prediction = try await client.getPrediction(id: "prediction-id")

switch prediction.status {
case .succeeded:
    print("Output: \(prediction.outputString ?? "N/A")")
case .processing, .pending, .starting, .started:
    print("Still in progress…")
case .failed:
    print("Prediction failed")
case .cancelled:
    print("Prediction was cancelled")
}

let prediction = try await client.streamPrediction(id: "prediction-id")

let cancelled = try await client.cancelPrediction(id: "prediction-id")
print("Cancelled: \(cancelled.status)")  // .cancelled

let deleted = try await client.deletePrediction(id: "prediction-id")

let models = try await client.listModels()

for model in models {
    print("\(model.namespace)/\(model.name) — \(model.description ?? "")")
    print("  Type: \(model.type)")            // .image, .text, .audio, etc.
    print("  Privacy: \(model.privacy)")       // .public or .private
    print("  Status: \(model.status)")
    print("  Capabilities: \(model.capabilities)")

    if let pricing = model.pricing {
        print("  Price: \(pricing.amount) \(pricing.currency)/\(pricing.unit)")
    }
}

import SwiftUI
import Skytells

struct ContentView: View {
    @State private var prompt = ""
    @State private var output = ""
    @State private var isLoading = false
    @State private var errorMessage: String?

    private let client = SkytellsClient(apiKey: "sk-your-api-key")

    var body: some View {
        VStack(spacing: 16) {
            TextField("Enter a prompt…", text: $prompt)
                .textFieldStyle(.roundedBorder)

            Button {
                Task { await generate() }
            } label: {
                if isLoading {
                    ProgressView()
                } else {
                    Text("Generate")
                }
            }
            .disabled(prompt.isEmpty || isLoading)

            if let errorMessage {
                Text(errorMessage)
                    .foregroundStyle(.red)
                    .font(.caption)
            }

            if !output.isEmpty {
                Text(output)
                    .padding()
                    .background(.gray.opacity(0.1), in: .rect(cornerRadius: 8))
            }
        }
        .padding()
    }

    private func generate() async {
        isLoading = true
        errorMessage = nil

        do {
            let prediction = try await client.predict(.init(
                model: "vendor/text-model",
                input: ["prompt": .string(prompt)],
                await: true
            ))
            output = prediction.outputString ?? "No output"
        } catch let error as SkytellsError {
            errorMessage = error.message
        } catch {
            errorMessage = error.localizedDescription
        }

        isLoading = false
    }
}

import UIKit
import Skytells

class PredictionViewController: UIViewController {
    private let client = SkytellsClient(apiKey: "sk-your-api-key")
    private let outputLabel = UILabel()
    private let activityIndicator = UIActivityIndicatorView(style: .large)

    override func viewDidLoad() {
        super.viewDidLoad()

        Task {
            activityIndicator.startAnimating()
            defer { activityIndicator.stopAnimating() }

            do {
                let prediction = try await client.predict(.init(
                    model: "vendor/model",
                    input: ["prompt": "Describe Swift in one sentence"],
                    await: true
                ))
                outputLabel.text = prediction.outputString
            } catch let error as SkytellsError {
                outputLabel.text = "Error: \(error.message)"
            }
        }
    }
}

import Vapor
import Skytells

func routes(_ app: Application) throws {
    let client = SkytellsClient(
        apiKey: Environment.get("SKYTELLS_API_KEY")
    )

    app.post("predict") { req async throws -> Response in
        struct PredictBody: Content {
            let model: String
            let prompt: String
        }
        let body = try req.content.decode(PredictBody.self)

        let prediction = try await client.predict(.init(
            model: body.model,
            input: ["prompt": .string(body.prompt)],
            await: true
        ))

        return try await prediction.encodeResponse(for: req)
    }
}

actor PredictionManager {
    private let client: SkytellsClient

    init(apiKey: String) {
        self.client = SkytellsClient(apiKey: apiKey)
    }

    func runBatch(prompts: [String], model: String) async throws -> [PredictionResponse] {
        try await withThrowingTaskGroup(of: PredictionResponse.self) { group in
            for prompt in prompts {
                group.addTask {
                    try await self.client.predict(.init(
                        model: model,
                        input: ["prompt": .string(prompt)],
                        await: true
                    ))
                }
            }
            var results: [PredictionResponse] = []
            for try await result in group {
                results.append(result)
            }
            return results
        }
    }
}

if let metrics = prediction.metrics {
    print("Predict time: \(metrics.predictTime ?? 0)s")
    print("Total time: \(metrics.totalTime ?? 0)s")
    print("Images generated: \(metrics.imageCount ?? 0)")
}

if let billing = prediction.metadata?.billing {
    print("Credits used: \(billing.creditsUsed ?? 0)")
}

if let files = prediction.metadata?.storage?.files {
    for file in files {
        print("\(file.name) (\(file.type), \(file.size) bytes): \(file.url)")
    }
}

print("Skytells Swift SDK v\(Skytells.version)")  // "1.0.0"
print("API Base URL: \(Skytells.apiBaseURL)")      // "https://api.skytells.ai/v1"

swift package update