peterfriese/system-one-foundation-models/jev-foundation-models

import FoundationModels
 
@Generable
enum SupportDepartment: String, Sendable {
    case billing
    case technicalSupport
    case sales
}
 
@Generable
struct TriageDecision: Sendable {
    @Guide(description: "Is this customer inquiry urgent or blocking critical business?")
    var isUrgent: Bool
 
    @Guide(description: "Which department is best suited to resolve this issue?")
    var department: SupportDepartment
 
    @Guide(description: "Customer frustration rating on a 0 to 3 scale", .range(0...3))
    var frustrationLevel: Int
}

import FoundationModels
import JevFoundationModels
 
// 1. Initialize the model provider
let model = JevLanguageModel(apiKey: apiKey)
let session = LanguageModelSession(model: model)
 
// 2. Evaluate state against the @Generable schema
let customerTicket = """
Ticket #8491: Urgent! I was charged $500 twice for renewal, and our accounts are locked!
"""
 
let response = try await session.respond(to: customerTicket, generating: TriageDecision.self)
 
// 3. Consume strongly typed decision content
let decision: TriageDecision = response.content
print("Department:", decision.department)       // .billing
print("Is Urgent:", decision.isUrgent)           // true
print("Frustration:", decision.frustrationLevel) // 3

let policy = RoutingPolicy(
    escalateBelow: 0.60,
    autoAtOrAbove: 0.85,
    undecidedBand: 0.35...0.65
)
 
// Categorical or Scored Decision (.auto, .confirm, .escalate)
let deptAction = response.decision(for: "department", policy: policy)
switch deptAction {
case .auto:
    routeToDepartment(decision.department)
case .confirm:
    suggestDepartment(decision.department)
case .escalate:
    routeToGeneralQueue()
}
 
// Boolean (Noul) Judgement
let urgencyJudgement = response.judgement(for: "isUrgent", policy: policy)
switch urgencyJudgement.decision {
case .auto:
    if urgencyJudgement.answer == true {
        pageOnCallLead()       // Confident Yes (p >= 0.85)
    } else {
        markStandardPriority() // Confident No (p <= 0.15)
    }
case .confirm:
    promptAgentToConfirm()     // Leaning (0.16...0.34 or 0.65...0.84)
case .escalate:
    assignManualReview()       // Undecided band (0.35...0.65): answer is nil
}

if let score = response.scoreValue(for: "frustrationLevel") {
    print("Continuous Weighted Score:", score.value)      // e.g. 2.75 (leaning toward level 3)
    print("Discrete Rounded Level:", score.rounded)       // 3
    print("Confidence Score:", score.confidence)          // 0.0 ... 1.0
    if let normalized = score.normalized {
        print("Normalized Rubric Position:", normalized)  // 0.0 ... 1.0
    }
}

let retryPolicy = RetryPolicy(
    maxAttempts: 3,                  // Initial attempt + up to 2 retries
    initialDelay: .milliseconds(500), // First retry delay
    multiplier: 2.0,                 // Exponential backoff
    jitter: 0.2,                     // +/- 20% random jitter to avoid thundering herds
    retryableStatuses: [429, 529],   // Retry rate-limits and temporary capacity limits
    maxRetryAfter: .seconds(60)      // Respects RFC 9110 Retry-After headers
)
 
let model = JevLanguageModel(apiKey: apiKey, retryPolicy: retryPolicy)

let task = Task {
    try await session.respond(to: ticket, generating: TriageDecision.self)
}
 
// When user dismisses view or cancels operation:
task.cancel()
 
do {
    let response = try await task.value
} catch is CancellationError {
    print("Decision task cancelled cleanly.")
} catch let error as JevError {
    print("Jev failure: \(error)")
}

import JevFoundationModels
 
// 1. Configure the proxy transport (supports .cached or .singleUse replay-protected tokens)
let transport = FirebaseAppCheckTransport(
    proxyEndpoint: URL(string: "https://your-cloud-function.cloudfunctions.net/triageProxy")!,
    tokenStrategy: .cached // < 1ms cached hardware token lookup
)
 
// 2. Initialize model without apiKey (authentication handled by App Check + backend proxy secret)
let model = JevLanguageModel(
    endpoint: URL(string: "https://your-cloud-function.cloudfunctions.net/triageProxy")!,
    transport: transport
)
let session = LanguageModelSession(model: model)

import Testing
import FoundationModels
@testable import JevFoundationModels
 
@Suite("Triage Decision Tests")
struct TriageWorkflowTests {
 
    @Test("Verifies triage routing and high-probability escalation")
    func testUrgentBillingTriage() async throws {
        let mockTransport = MockJevTransport { request in
            #expect(request.questions.count == 3)
            #expect(request.state.contains("charged $500 twice"))
 
            return JevResponse(
                model: "jev-mock",
                answers: [
                    "isUrgent": JevAnswer(type: "noul", noul: 0.97, confidence: 0.95),
                    "department": JevAnswer(type: "choice", choice: "billing", confidence: 0.98),
                    "frustrationLevel": JevAnswer(type: "score", score: 2.8, confidence: 0.90)
                ],
                usage: JevUsage(inputTokens: 85, outputTokens: 10)
            )
        }
 
        let model = JevLanguageModel(apiKey: "mock-key", transport: mockTransport)
        let session = LanguageModelSession(model: model)
 
        let response = try await session.respond(
            to: "charged $500 twice",
            generating: TriageDecision.self
        )
 
        // Verify strongly typed content
        #expect(response.content.isUrgent == true)
        #expect(response.content.department == .billing)
        #expect(response.content.frustrationLevel == 3) // rounded from 2.8
 
        // Verify routing policy decision
        let judgement = response.judgement(for: "isUrgent")
        #expect(judgement.decision == .auto)
        #expect(judgement.answer == true)
 
        // Verify rubric telemetry
        let frustration = response.scoreValue(for: "frustrationLevel")
        #expect(frustration?.rounded == 3)
        #expect(frustration?.value == 2.8)
    }
}