Swift

dependencies: [
    .package(url: "https://github.com/tinfoilsh/tinfoil-swift.git", branch: "main")
]

// Before (OpenAI)
- import OpenAI
- let client = OpenAI(apiToken: ProcessInfo.processInfo.environment["OPENAI_API_KEY"] ?? "")

// After (Tinfoil)
+ import TinfoilAI
+ import OpenAI
+ let client = try await TinfoilAI.create(
+     apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? "",
+     githubRepo: "tinfoilsh/confidential-llama3-3-70b-prod-prod",
+     enclaveURL: "llama3-3-70b-p.model.tinfoil.sh"
+ )

import TinfoilAI
import OpenAI

// Create secure client
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? "",
    githubRepo: "tinfoilsh/confidential-llama3-3-70b-prod-prod",
    enclaveURL: "llama3-3-70b-p.model.tinfoil.sh"
)

// Create chat completion
let chatQuery = ChatQuery(
    messages: [
        .system(.init(content: .textContent("You are a helpful assistant."))),
        .user(.init(content: .string("Explain quantum computing in simple terms")))
    ],
    model: "llama3-3-70b"
)

let chatResponse = try await client.chats(query: chatQuery)
print(chatResponse.choices.first?.message.content ?? "No response")

let chatQuery = ChatQuery(
    messages: [
        .user(.init(content: .string("Tell me a story about AI safety")))
    ],
    model: "llama3-3-70b",
    stream: true
)

// Stream the response
for try await result in client.chatsStream(query: chatQuery) {
    if let choice = result.choices.first,
       let delta = choice.delta.content {
        print("Received: \(delta)")
    }
    
    // Check for completion
    if let finishReason = result.choices.first?.finishReason {
        print("Stream finished with reason: \(finishReason)")
        break
    }
}

import Foundation

// Configure for audio model
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? "",
    githubRepo: "tinfoilsh/confidential-audio-processing",
    enclaveURL: "audio-processing.model.tinfoil.sh"
)

// Load audio file
let audioURL = URL(fileURLWithPath: "path/to/audio.mp3")
let audioData = try Data(contentsOf: audioURL)

// Create transcription
let transcriptionQuery = AudioTranscriptionQuery(
    file: audioData,
    fileType: .mp3,
    model: "whisper-large-v3-turbo"
)

let transcription = try await client.audioTranscriptions(query: transcriptionQuery)
print(transcription.text)

// Configure for embedding model
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? "",
    githubRepo: "tinfoilsh/confidential-nomic-embed-text",
    enclaveURL: "nomic-embed-text.model.tinfoil.sh"
)

// Generate embeddings
let embeddingQuery = EmbeddingsQuery(
    input: .string("The quick brown fox jumps over the lazy dog"),
    model: "nomic-embed-text"
)

let response = try await client.embeddings(query: embeddingQuery)
if let embedding = response.data.first?.embedding {
    print("Embedding dimension: \(embedding.count)")
}

// Set up a callback to handle verification results
let verificationCallback: NonblockingVerification = { verificationPassed in
    if verificationPassed {
        print("✅ Enclave verification passed - connection is secure")
    } else {
        print("❌ Enclave verification failed - connection may not be secure")
        // Handle verification failure (log, alert user, etc.)
    }
}

// Create client with non-blocking verification
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? "",
    githubRepo: "tinfoilsh/model-repo",
    enclaveURL: "enclave.example.com",
    nonblockingVerification: verificationCallback
)

// Requests will proceed even if certificate verification fails
let chatQuery = ChatQuery(
    messages: [
        .user(.init(content: .string("Hello, I need a quick response!")))
    ],
    model: "llama3-3-70b"
)

// This request will go through regardless of verification status
let response = try await client.chats(query: chatQuery)
print(response.choices.first?.message.content ?? "No response")

import TinfoilAI

do {
    let client = try await TinfoilAI.create(
        apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? "",
        githubRepo: "tinfoilsh/confidential-llama3-3-70b-prod-prod",
        enclaveURL: "llama3-3-70b-p.model.tinfoil.sh"
    )
    
    let response = try await client.chats(query: chatQuery)
    // Handle response
} catch {
    print("Error creating client or making request: \(error)")
}

// Manual verification with progress callbacks
let verificationCallbacks = VerificationCallbacks(
    onCodeVerificationComplete: { result in
        switch result.status {
        case .success(let digest):
            print("Code verification successful: \(digest)")
        case .failure(let error):
            print("Code verification failed: \(error)")
        default:
            break
        }
    },
    onRuntimeVerificationComplete: { result in
        switch result.status {
        case .success(let digest):
            print("Runtime verification successful: \(digest)")
        case .failure(let error):
            print("Runtime verification failed: \(error)")
        default:
            break
        }
    },
    onSecurityCheckComplete: { result in
        switch result.status {
        case .success:
            print("Security check passed: Code and runtime match")
        case .failure(let error):
            print("Security check failed: \(error)")
        default:
            break
        }
    }
)

let secureClient = SecureClient(
    githubRepo: "tinfoilsh/model-repo",
    enclaveURL: "enclave.example.com",
    callbacks: verificationCallbacks
)

let verificationResult = try await secureClient.verify()
if verificationResult.isMatch {
    print("Verification successful!")
    print("Code digest: \(verificationResult.codeDigest)")
    print("Runtime digest: \(verificationResult.runtimeDigest)")
    print("Key fingerprint: \(verificationResult.publicKeyFP)")
} else {
    print("Verification failed: Code and runtime digests do not match")
}