Custom LLM Provider via LanguageModel Protocol

import FoundationModels

// MARK: - Configuration (the cache key)
struct EchoModelConfiguration: LanguageModelConfiguration, Hashable {
    let modelID: String
    let maxTokens: Int
}

// MARK: - Executor (does the real work)
final class EchoModelExecutor: LanguageModelExecutor {
    typealias Configuration = EchoModelConfiguration

    private let configuration: EchoModelConfiguration

    required init(configuration: EchoModelConfiguration) {
        self.configuration = configuration
    }

    func prewarm() async {
        // No-op for this echo model; a real model would load weights here
    }

    func respond(
        to request: LanguageModelRequest,
        model: any LanguageModel,
        channel: LanguageModelResponseChannel
    ) async throws {
        // 1. Send metadata upfront so callers can log request IDs immediately
        await channel.send(.metadataUpdate(
            LanguageModelResponseMetadata(
                modelID: configuration.modelID,
                requestID: UUID().uuidString
            )
        ))

        // 2. Extract the last user prompt from the transcript
        let lastPromptText = request.transcript
            .compactMap { entry -> String? in
                if case .prompt(let content) = entry {
                    return content.text
                }
                return nil
            }
            .last ?? "(no prompt)"

        // 3. Stream a fake "reversed echo" response token-by-token
        let words = lastPromptText.split(separator: " ").map(String.init).reversed()
        for word in words {
            await channel.send(.textDelta(word + " "))
            try await Task.sleep(for: .milliseconds(40))
        }
    }
}

// MARK: - LanguageModel (lightweight descriptor)
struct EchoLanguageModel: LanguageModel {
    typealias Executor = EchoModelExecutor

    var capabilities: LanguageModelCapabilities {
        LanguageModelCapabilities(supportsTools: false, supportsImages: false)
    }

    func makeConfiguration() -> EchoModelConfiguration {
        EchoModelConfiguration(modelID: "echo-v1", maxTokens: 512)
    }
}

// MARK: - Usage
struct ContentView: View {
    @State private var response = "Tap to run"

    var body: some View {
        VStack(spacing: 16) {
            Text(response).padding()
            Button("Ask Echo Model") {
                Task { await runEchoModel() }
            }
        }
    }

    func runEchoModel() async {
        let model = EchoLanguageModel()
        let session = LanguageModelSession(model: model)
        do {
            let result = try await session.respond(to: "Hello from Foundation Models")
            response = result.content
        } catch {
            response = "Error: \(error)"
        }
    }
}