Swift

Swift SDK

Swift SDK for Tinfoil’s secure AI inference API
GitHub: tinfoil-swift

Overview

The Tinfoil Swift SDK is a wrapper around the MacPaw OpenAI SDK that provides secure communication with Tinfoil enclaves. It has the same API as the OpenAI SDK with additional security features including automatic verification that the endpoint is running in a secure Tinfoil enclave, TLS certificate pinning, and attestation validation.

Installation

Swift Package Manager

Add to your Package.swift:

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

Xcode

Go to File → Add Package Dependencies
Enter the repository URL: https://github.com/tinfoilsh/tinfoil-swift.git
Select the version you want to use
Click “Add Package”

Note: Tinfoil Swift requires the MacPaw OpenAI SDK as a dependency. When you add Tinfoil Swift through Swift Package Manager, the OpenAI SDK will be automatically included.

Requirements

iOS 17.0+ / macOS 12.0+
Swift 5.9+
Xcode 15.0+

Migration from OpenAI

Migrating from OpenAI to Tinfoil is straightforward. The client is designed to be compatible with the MacPaw OpenAI Swift client:

// 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"] ?? ""
+ )

All method signatures remain the same since TinfoilAI.create() returns a standard OpenAI client with built-in security features.

Model Examples

Below are specific examples for each supported model. Click on any model to see its configuration and usage example.

Chat Models

DeepSeek R1 - deepseek-r1-0528

import TinfoilAI
import OpenAI

// Configure client for DeepSeek R1
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Complex reasoning task
let chatQuery = ChatQuery(
    messages: [
        .system(.init(content: .textContent("You are an expert at solving complex mathematical problems step by step."))),
        .user(.init(content: .string("Solve this step by step: If a train travels 120 miles in 2 hours, and then increases its speed by 25% for the next 3 hours, how far does it travel in total?")))
    ],
    model: "deepseek-r1-0528",
    temperature: 0.1
)

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

Mistral Small 3.1 24B - mistral-small-3-1-24b

import TinfoilAI
import OpenAI

// Configure client for Mistral Small 3.1 24B
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Multilingual conversation
let chatQuery = ChatQuery(
    messages: [
        .user(.init(content: .string("Explain the concept of machine learning in both English and French.")))
    ],
    model: "mistral-small-3-1-24b",
    temperature: 0.7
)

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

Llama 3.3 70B - llama3-3-70b

import TinfoilAI
import OpenAI

// Configure client for Llama 3.3 70B
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Conversational AI
let chatQuery = ChatQuery(
    messages: [
        .system(.init(content: .textContent("You are a helpful assistant that provides detailed explanations."))),
        .user(.init(content: .string("What are the key differences between renewable and non-renewable energy sources?")))
    ],
    model: "llama3-3-70b",
    temperature: 0.8
)

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

Qwen 2.5 72B - qwen2-5-72b

import TinfoilAI
import OpenAI

// Configure client for Qwen 2.5 72B
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Code generation and analysis
let chatQuery = ChatQuery(
    messages: [
        .user(.init(content: .string("Write a Swift function to calculate the Fibonacci sequence up to n terms, then explain how it works.")))
    ],
    model: "qwen2-5-72b",
    temperature: 0.3
)

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

Audio Models

Whisper Large V3 Turbo - whisper-large-v3-turbo

import TinfoilAI
import OpenAI
import Foundation

// Configure client for Whisper Large V3 Turbo
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Audio transcription
let audioURL = URL(fileURLWithPath: "meeting_recording.mp3")
let audioData = try Data(contentsOf: audioURL)

let transcriptionQuery = AudioTranscriptionQuery(
    file: audioData,
    fileType: .mp3,
    model: "whisper-large-v3-turbo",
    language: "en", // Optional: specify language for better accuracy
    prompt: "This is a business meeting discussing quarterly results" // Optional: provide context
)

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

Kokoro - kokoro

import TinfoilAI
import OpenAI
import Foundation

// Note: Kokoro TTS is not yet supported in the Swift SDK
// This is a placeholder showing how it would work when implemented

// Configure client for Kokoro TTS (when available)
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Text-to-speech (when supported)
let textToSpeak = "Welcome to Tinfoil's secure AI platform. Your data remains private and protected."

// This functionality will be available in future Swift SDK versions
print("Text-to-speech with Kokoro will be available in future Swift SDK versions")

Embedding Models

Nomic Embed Text - nomic-embed-text

import TinfoilAI
import OpenAI
import Foundation

// Configure client for Nomic Embed Text
let client = try await TinfoilAI.create(
    apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
)

// Example: Generate embeddings for similarity search
let documents = [
    "Artificial intelligence is transforming modern technology.",
    "Machine learning enables computers to learn from data.",
    "The weather today is sunny and warm.",
    "Deep learning uses neural networks with multiple layers."
]

// Generate embeddings for all documents
var embeddings: [[Double]] = []
for document in documents {
    let embeddingQuery = EmbeddingsQuery(
        input: .string(document),
        model: "nomic-embed-text"
    )
    
    let response = try await client.embeddings(query: embeddingQuery)
    if let embedding = response.data.first?.embedding {
        embeddings.append(embedding)
    }
}

// Calculate similarity between first two documents
func dotProduct(_ a: [Double], _ b: [Double]) -> Double {
    return zip(a, b).map(*).reduce(0, +)
}

func magnitude(_ vector: [Double]) -> Double {
    return sqrt(vector.map { $0 * $0 }.reduce(0, +))
}

let similarity = dotProduct(embeddings[0], embeddings[1]) / 
    (magnitude(embeddings[0]) * magnitude(embeddings[1]))

print("Similarity between first two AI-related documents: \(String(format: "%.3f", similarity))")
print("Embedding dimension: \(embeddings[0].count)")

Advanced Features

Non-Blocking Verification

By default, Tinfoil Swift enforces strict security by failing requests when enclave verification or certificate pinning fails. With non-blocking verification, you can allow requests to proceed even if verification fails, while still being notified of the verification status through a callback.

// 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"] ?? "",
    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")

Important Security Warning: When using non-blocking verification, requests will proceed even if enclave verification or certificate pinning fails. Only use this mode when availability is more important than security guarantees.

Error Handling

import TinfoilAI

do {
    let client = try await TinfoilAI.create(
        apiKey: ProcessInfo.processInfo.environment["TINFOIL_API_KEY"] ?? ""
    )
    
    let response = try await client.chats(query: chatQuery)
    // Handle response
} catch {
    print("Error creating client or making request: \(error)")
}

Manual Verification and Certificate Pinning

For advanced use cases, you can perform manual verification and use certificate pinning directly:

// 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/<config-repo>",
    enclaveURL: "<enclave>.model.tinfoil.sh",
    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")
}

API Documentation

This library is a drop-in replacement for the MacPaw OpenAI Swift client that can be used with Tinfoil. All methods and types are identical. See the MacPaw OpenAI documentation for complete API usage and documentation.

Guides

Tool Calling

Learn how to use function calling capabilities with AI models.

Structured Outputs

Use JSON schema validation for reliable data extraction.

Image Processing

Process images with multimodal AI models.

Document Processing

Upload and process documents securely.

Getting Started

Models

SDKs

Guides

Enclave Verification

Tutorials

Resources

Swift SDK

Overview

Installation

Swift Package Manager

Xcode

Requirements

Migration from OpenAI

Model Examples

Chat Models

Audio Models

Embedding Models

Advanced Features

Non-Blocking Verification

Error Handling

Manual Verification and Certificate Pinning

API Documentation

Guides

Tool Calling

Structured Outputs

Image Processing

Document Processing

Getting Started

Models

SDKs

Guides

Enclave Verification

Tutorials

Resources

Swift SDK

​Overview

​Installation

​Swift Package Manager

​Xcode

​Requirements

​Migration from OpenAI

​Model Examples

​Chat Models

​Audio Models

​Embedding Models

​Advanced Features

​Non-Blocking Verification

​Error Handling

​Manual Verification and Certificate Pinning

​API Documentation

​Guides

Tool Calling

Structured Outputs

Image Processing

Document Processing

Overview

Installation

Swift Package Manager

Xcode

Requirements

Migration from OpenAI

Model Examples

Chat Models

Audio Models

Embedding Models

Advanced Features

Non-Blocking Verification

Error Handling

Manual Verification and Certificate Pinning

API Documentation

Guides