Configuration

try RunAnywhere.initialize(environment: .development)

try RunAnywhere.initialize(
    apiKey: "<YOUR_API_KEY>",
    baseURL: "https://api.runanywhere.ai",
    environment: .production
)

public enum SDKEnvironment: String, Sendable {
    case development
    case staging
    case production
}

import RunAnywhere
import LlamaCPPRuntime
import ONNXRuntime

@MainActor
func configureSDK() {
    // Register LlamaCPP for LLM capability
    LlamaCPP.register(priority: 100)

    // Register ONNX for STT/TTS/VAD
    ONNX.register(priority: 100)
}

// Custom module with higher priority
MyCustomLLM.register(priority: 200)  // Used first
LlamaCPP.register(priority: 100)     // Fallback

RunAnywhere.registerModel(
    id: String,
    name: String,
    url: URL,
    framework: .llamaCpp | .onnx | .coreml,
    modality: .speechRecognition | .speechSynthesis | .imageGeneration,  // optional
    artifactType: .archive(.tarGz | .zip, structure: .nestedDirectory),  // optional, for archives
    memoryRequirement: Int  // bytes
)

RunAnywhere.registerMultiFileModel(
    id: String,
    name: String,
    files: [ModelFileDescriptor(url: URL, filename: String)],
    framework: .llamaCpp,
    modality: .multimodal,
    memoryRequirement: Int
)

let progressStream = try await RunAnywhere.downloadModel(modelId: String)
for await progress in progressStream {
    progress.overallProgress  // Double (0.0-1.0)
    progress.stage            // includes .completed
}

try await RunAnywhere.loadModel(modelId: String)         // LLM
try await RunAnywhere.loadSTTModel(modelId: String)       // STT
try await RunAnywhere.loadTTSVoice(modelId: String)       // TTS
try await RunAnywhere.loadVLMModel(model: ModelDescriptor) // VLM (requires descriptor)

let models = try await RunAnywhere.availableModels()
// Returns [ModelDescriptor] — each has .id, .name, .isDownloaded, .localPath

await RunAnywhere.isModelLoaded           // Bool — LLM loaded?
await RunAnywhere.isSTTModelLoaded        // Bool — STT loaded?
await RunAnywhere.isTTSVoiceLoaded        // Bool — TTS loaded?
await RunAnywhere.isVLMModelLoaded        // Bool — VLM loaded?
await RunAnywhere.isDiffusionModelLoaded  // Bool — Diffusion loaded?

public struct LLMGenerationOptions: Sendable {
    public let maxTokens: Int               // Maximum tokens to generate
    public let temperature: Float           // Randomness (0.0-2.0)
    public let topP: Float                  // Nucleus sampling (0.0-1.0)
    public let stopSequences: [String]      // Stop generation strings
    public let streamingEnabled: Bool       // Token streaming
    public let preferredFramework: InferenceFramework?
    public let structuredOutput: StructuredOutputConfig?
    public let systemPrompt: String?        // System prompt
}

// Deterministic, factual responses
let factual = LLMGenerationOptions(
    maxTokens: 200,
    temperature: 0.1,
    topP: 0.9
)

// Creative writing
let creative = LLMGenerationOptions(
    maxTokens: 500,
    temperature: 1.2,
    topP: 0.95
)

// JSON output
let json = LLMGenerationOptions(
    maxTokens: 300,
    temperature: 0.2,
    stopSequences: ["}"],
    systemPrompt: "Respond only with valid JSON."
)

public struct STTOptions: Sendable {
    public let language: String             // ISO 639-1 code
    public let sampleRate: Int              // Audio sample rate
    public let enableWordTimestamps: Bool   // Per-word timing
    public let enableVAD: Bool              // Voice activity detection
}

public struct TTSOptions: Sendable {
    public let rate: Float          // Speed (0.5-2.0)
    public let pitch: Float         // Pitch (0.5-2.0)
    public let volume: Float        // Volume (0.0-1.0)
    public let language: String     // Language code
    public let sampleRate: Int      // Output sample rate
    public let audioFormat: AudioFormat
}

public struct VADConfiguration: Sendable {
    public let sampleRate: Int              // Audio sample rate
    public let frameLength: Double          // Frame duration (seconds)
    public let energyThreshold: Double      // Detection sensitivity
}

// Unload models when not needed
try await RunAnywhere.unloadModel()
try await RunAnywhere.unloadSTTModel()
try await RunAnywhere.unloadTTSVoice()

// Check storage
let storage = await RunAnywhere.getStorageInfo()
print("Available: \(storage.availableBytes / 1_000_000_000) GB")

// Clean temporary files
try await RunAnywhere.cleanTempFiles()

// Set log level
RunAnywhere.setLogLevel(.debug)  // .debug | .info | .warning | .error | .fault

// Enable local logging (Pulse integration)
RunAnywhere.configureLocalLogging(enabled: true)

// Enable verbose debug mode
RunAnywhere.setDebugMode(true)

// Flush logs
await RunAnywhere.flushAll()

// Check initialization
let isInitialized = RunAnywhere.isSDKInitialized
let servicesReady = RunAnywhere.areServicesReady
let isActive = RunAnywhere.isActive

// Version info
let version = RunAnywhere.version

// Authentication
let isAuthenticated = RunAnywhere.isAuthenticated
let userId = RunAnywhere.getUserId()
let orgId = RunAnywhere.getOrganizationId()

// Device
let deviceId = RunAnywhere.deviceId
let isRegistered = RunAnywhere.isDeviceRegistered()

func configureForEnvironment() {
    #if DEBUG
    try? RunAnywhere.initialize(
        environment: .development
    )
    RunAnywhere.setLogLevel(.debug)
    RunAnywhere.setDebugMode(true)
    #else
    try? RunAnywhere.initialize(
        apiKey: ProcessInfo.processInfo.environment["RUNANYWHERE_API_KEY"],
        baseURL: "https://api.runanywhere.ai",
        environment: .production
    )
    RunAnywhere.setLogLevel(.warning)
    #endif
}

// Reset SDK state for testing
RunAnywhere.reset()