import CosmoRealtime

let session = try await RealtimeSession.start(
    .init(apiKey: "key", baseURL: URL(string: "https://app.askcosmo.ai")!),
    config: SessionConfig(instructions: "You are a terse assistant.")
)
for try await event in session.events {
    switch event {
    case .ready(let ready): print("live, session:", ready.sessionId)
    case .transcript(let delta): print(delta.text)
    case .sessionEnded(let ended): print("over:", ended.reason ?? "")
    default: break
    }
}

public struct Options: Sendable {
    public var credential: Credential   // .apiKey(String) or .token(String)
    public var baseURL: URL
    public var connectTimeout: TimeInterval
    public var requestTimeout: TimeInterval
    public var verifyTLS: VerifyTLS
    public var clientIdentity: ClientIdentity?

    public init(
        credential: Credential,
        baseURL: URL,
        connectTimeout: TimeInterval = 30,
        requestTimeout: TimeInterval = 45,
        verifyTLS: VerifyTLS = .auto,
        clientIdentity: ClientIdentity? = nil
    )
}

public init(apiKey: String, baseURL: URL, ...)   // Options.Credential.apiKey
public init(token: String, baseURL: URL, ...)    // Options.Credential.token

public struct ClientIdentity: Sendable, Equatable {
    public init(client: String, marketingVersion: String, build: String)
}

public static func start(
    _ options: Options,
    config: SessionConfig = SessionConfig(),
    micMuted: Bool = false,
    rpcHandlers: [String: ClientToolHandler] = [:]
) async throws -> RealtimeSession

public struct SessionConfig: Sendable, Equatable {
    public init(
        agentName: String? = nil,
        agentInputs: [String: String]? = nil,
        model: String? = nil,
        modelOptions: ModelOptions? = nil,
        voice: Voice? = nil,
        audio: Audio? = nil,
        instructions: String? = nil,
        tools: [Tool]? = nil,
        interruptionSensitivity: InterruptionSensitivity? = nil,
        greeting: String? = nil,
        resumeSessionId: String? = nil,
        maxSessionSeconds: Int? = nil,
        storeRecording: Bool? = nil,
        hooks: [Hook]? = nil
    )
}

public struct Voice: Sendable, Equatable {
    public init(name: String? = nil, speakingStyle: String? = nil)
}

public struct Audio: Sendable, Equatable {
    public init(output: Bool? = nil, noiseCancellation: Bool? = nil, ambience: Ambience? = nil)
}

public struct Ambience: Sendable, Equatable {
    public init(track: String? = nil, gainDb: Double? = nil)
}

let config = SessionConfig(
    voice: .init(name: "Puck", speakingStyle: "Warm and unhurried."),
    audio: .init(noiseCancellation: true, ambience: .init(track: "office", gainDb: -30)),
    instructions: "You are a terse voice assistant."
)

public enum ModelOptions: Sendable, Equatable {
    case gemini(temperature: Double? = nil, maxOutputTokens: Int? = nil, thinkingLevel: ThinkingLevel? = nil)
    case openai
    case ultravox(temperature: Double? = nil, turnEndpointDelaySeconds: Double? = nil)
    case personaplex
}

public enum Tool: Sendable, Equatable {
    case client(name: String, description: String,
                parameters: [String: JSONValue], handler: ClientToolHandler? = nil)
    case backgroundClient(name: String, description: String,
                          parameters: [String: JSONValue], handler: BackgroundClientToolHandler)
    case webSearch
    case examineImage
    case detectObjects
    case pointAtObject
}

public typealias ClientToolHandler =
    @Sendable ([String: JSONValue]) async throws -> [String: JSONValue]

public nonisolated let events: AsyncThrowingStream<Event, Error>

public nonisolated let states: AsyncStream<State>

public enum State: Sendable, Equatable {
    case idle
    case connecting
    case connected
    case reconnecting          // transient drop; session survives if recovery succeeds
    case reconnected           // same session, same thread
    case disconnected(reason: EndReason)   // terminal
}

public enum EndReason: Sendable, Equatable {
    case clientEnded                                    // this client called end()
    case clientClosed                                   // close() without the wire end frame
    case handshakeFailed(status: Int?, detail: String?) // server refused the start
    case serverEnded(reason: String?)                   // graceful server teardown
    case transportError(message: String)
}

public func send(text: String) async throws

public func setMuted(_ muted: Bool) async throws

public func ping() async throws

public func send(
    image data: String,
    mimeType: String = "image/jpeg",
    streamId: String = "video.input.default"
) async throws

public func send(bytes data: Data, topic: String) async throws

public func sendActivityEnd() async throws

public func end() async     // graceful: best-effort wire end frame, reason .clientEnded
public func close() async   // abrupt local teardown, reason .clientClosed

public nonisolated var inputLevels: AsyncStream<Float>    // mic RMS, 0…1
public nonisolated var outputLevels: AsyncStream<Float>   // agent audio RMS, 0…1
public nonisolated func setAgentPlaybackVolume(_ volume: Double)

public func startScreenShare() async throws
public nonisolated func pushScreenShareFrame(_ sampleBuffer: CMSampleBuffer)
public func stopScreenShare() async
public nonisolated func setScreenShareFrameProcessor(_ processor: ScreenShareFrameProcessor?)
public nonisolated func onScreenShareFailed(_ handler: @escaping @Sendable (Error) -> Void) -> Cancellable

public func dial(phoneNumber: String, callerNumber: String? = nil) async throws -> String

public static func prewarmConnection(origin: PrewarmOrigin = .other) async
public static func setRecordingAlwaysPrepared(_ enabled: Bool) async throws
public static func prepareSession(_ options: Options) async throws
public static func discardPreparedSession()

public enum RealtimeSessionError: Error, LocalizedError, Equatable {
    case versionMismatch(detail: String)
    case voiceDisabled
    case handshakeFailed(status: Int, code: String?, detail: String?)
    case sessionStartFailed(message: String)
    case alreadyStarted
    case notConnected
    case transportError(message: String)
    case invalidPayload(String)
    case screenShareUnavailable
    case insecureBaseURL(String)
}