DeepSeekKit

https://guitaripod.github.io/DeepSeekKit/
Admin
DeepSeekKit is a modern Swift SDK for integrating DeepSeek's powerful AI models into applications...
Tokens:521,737
Snippets:3,641
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### FIM Demonstrator Setup

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

Initializes the FIM demonstrator and sets up the code example and cursor position for demonstrating code completion.

```Swift
import SwiftUI
import DeepSeekKit


// Understanding Fill-in-Middle (FIM) structure
struct FIMStructureView: View {
    @StateObject private var demonstrator = FIMDemonstrator()
    @State private var codeExample = CodeExample.simpleFunction
    @State private var cursorPosition = 50
    
    enum CodeExample: String, CaseIterable {
        case simpleFunction = "Simple Function"
        case classMethod = "Class Method"
        case swiftUIView = "SwiftUI View"
        case completion = "Code Completion"
        
        var code: String {
            switch self {
            case .simpleFunction:
                return """
                func calculateTotal(items: [Item]) -> Double {
                    // TODO: Calculate total
                    return 0.0
                }
                """
            case .classMethod:
                return """
                class ShoppingCart {
                    private var items: [Item] = []

```

--------------------------------

### Initialize and Start Monitoring

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Initializes the queue and storage calculation, then starts a timer to periodically check network connectivity.

```swift
init() {
        loadQueue()
        calculateStorageUsed()
    }
    
    func startMonitoring() {
        // Simulate connection monitoring
        Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { _ in
            // In real app, use Network framework
            self.checkConnection()
        }
    }
```

--------------------------------

### Tool Example

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/tool

An example demonstrating how to create a `Tool` instance for retrieving weather information.

```APIDOC
## Example

```swift
let weatherTool = Tool(
    function: FunctionDefinition(
        name: "get_weather",
        description: "Get current weather for a location",
        parameters: [
            "type": "object",
            "properties": [
                "location": [
                    "type": "string",
                    "description": "City and state, e.g. San Francisco, CA"
                ]
            ],
            "required": ["location"]
        ]
    )
)
```
```

--------------------------------

### SwiftUI View Example with TODO

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

Demonstrates a basic SwiftUI View structure with a placeholder for content.

```swift
struct ContentView: View {
    var body: some View {
        VStack {
            // TODO: Add content
        }
    }
}
```

--------------------------------

### Code Example Structure

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

A simple structure to hold code examples for demonstration purposes.

```swift
struct CodeExample {
    let name: String
    let prefix: String
    let suffix: String
    let description: String
}
```

--------------------------------

### Swift Code Example with TODO

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

Illustrates a Swift code structure with a placeholder comment for item addition.

```swift
func addItem(_ item: Item) {
    // TODO: Add item
}
```

--------------------------------

### Basic Usage Example

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/chatcompletionrequest

A simple example demonstrating how to create a ChatCompletionRequest.

```APIDOC
```swift
let request = ChatCompletionRequest(
    model: .chat,
    messages: [
        .system("You are a helpful assistant"),
        .user("Explain quantum computing")
    ]
)
```
```

--------------------------------

### SwiftUI Code Examples View

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

This view presents a horizontally scrollable list of code example templates. Each example includes a name, prefix, suffix, and description, allowing users to select and use them.

```swift
struct CodeExamplesView: View {
    let onSelect: (CodeExample) -> Void
    
    let examples = [
        CodeExample(
            name: "Array Average",
            prefix: "func calculateAverage(numbers: [Double]) -> Double {\n    ",
            suffix: "\n}",
            description: "Calculate average of array"
        ),
        CodeExample(
            name: "Filter & Map",
            prefix: "let evenSquares = numbers\n    .filter { ",
            suffix: " }\n    .map { $0 * $0 }",
            description: "Filter even numbers and square them"
        ),
        CodeExample(
            name: "SwiftUI Button",
            prefix: "Button(action: {\n    ",
            suffix: "\n}) {\n    Text(\"Submit\")\n}",
            description: "Button action handler"
        ),
        CodeExample(
            name: "Error Handling",
            prefix: "do {\n    let data = try ",
            suffix: "\n} catch {\n    print(\"Error: \(error)\")\n}",
            description: "Try-catch block completion"
        ),
        CodeExample(
            name: "Class Method",
            prefix: "class UserManager {\n    private var users: [User] = []\n    \n    func addUser(_ user: User) {\n        ",
            suffix: "\n    }\n}",
            description: "Implement addUser method"
        )
    ]
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Label("Example Templates", systemImage: "doc.on.doc")
                .font(.headline)
            
            ScrollView(.horizontal, showsIndicators: false) {
                HStack(spacing: 12) {
                    ForEach(examples, id: \.name) {
                        example in
                        ExampleCard(example: example, onSelect: onSelect)
                    }
                }
            }
        }
    }
}
```

--------------------------------

### DeepSeekClient Initialization and Chat Completion Example

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/deepseekclient

Demonstrates how to initialize the DeepSeekClient with an API key and use it to create a chat completion.

```APIDOC
## DeepSeekClient

### Description
The main DeepSeek API client.

### Initializers
`init(apiKey: String, baseURL: URL, session: URLSession)`
Creates a new DeepSeek client.

### Instance Properties
`let apiKey: String`
The API key used for authentication.
`let balance: BalanceServiceProtocol`
Service for user balance queries.
`let baseURL: URL`
The base URL for API requests.
`let chat: ChatServiceProtocol`
Service for chat completion operations.
`let models: ModelServiceProtocol`
Service for model-related operations.

### Example Usage
```swift
let client = DeepSeekClient(apiKey: "your-api-key")


// Create a chat completion
let response = try await client.chat.createCompletion(
    ChatCompletionRequest(
        model: .chat,
        messages: [
            ChatMessage(role: .user, content: "Hello, how are you?")
        ]
    )
)
print(response.choices.first?.message.content ?? "")
```
```

--------------------------------

### Code Example Selector UI

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

A SwiftUI view for selecting different code examples for demonstration. It uses a horizontal scroll view with buttons for each example.

```swift
struct CodeExampleSelector: View {
    @Binding var selectedExample: FIMStructureView.CodeExample
    let onSelect: (FIMStructureView.CodeExample) -> Void
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("Code Examples")
                .font(.headline)
            
            ScrollView(.horizontal, showsIndicators: false) {
                HStack(spacing: 12) {
                    ForEach(FIMStructureView.CodeExample.allCases, id: \.self) {
 example in
                        Button(action: {
                            selectedExample = example
                            onSelect(example)
                        }) {
                            Text(example.rawValue)
                                .font(.caption)
                                .padding(.horizontal, 16)
                                .padding(.vertical, 8)
                                .background(selectedExample == example ? Color.blue : Color.gray.opacity(0.2))
                                .foregroundColor(selectedExample == example ? .white : .primary)
                                .cornerRadius(20)
                        }
                    }
                }
            }
        }
    }
}
```

--------------------------------

### SwiftUI Example Card

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

This view represents a single code example card within the `CodeExamplesView`. It displays the example's name, description, and a call to action, and triggers the `onSelect` closure when tapped.

```swift
struct ExampleCard: View {
    let example: CodeExample
    let onSelect: (CodeExample) -> Void
    
    var body: some View {
        Button(action: { onSelect(example) }) {
            VStack(alignment: .leading, spacing: 8) {
                Label(example.name, systemImage: "doc.text")
                    .font(.caption)
                    .fontWeight(.medium)
                
                Text(example.description)
                    .font(.caption2)
                    .foregroundColor(.secondary)
                    .multilineTextAlignment(.leading)
                
                Spacer()
                
                Text("Tap to use")
                    .font(.caption2)
                    .foregroundColor(.blue)
            }
            .frame(width: 150, height: 100)
            .padding()
        }
    }
}
```

--------------------------------

### Swift: Example Prompts Data Structure

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/03-understanding-models

Defines an array of example prompts, each with a title, the text content, and an estimated token count. Used for quick testing and demonstration.

```swift
private let examples = [
        (title: "Simple greeting", text: "Hello, how are you today?", tokens: 7),
        (title: "Code snippet", text: "func calculateSum(_ a: Int, _ b: Int) -> Int {\n    return a + b\n}", tokens: 20),
        (title: "Math problem", text: "Solve the quadratic equation: x² + 5x + 6 = 0", tokens: 15),
        (title: "Long prompt", text: "Write a detailed explanation of how machine learning models process natural language, including tokenization, embedding, and attention mechanisms. Provide examples and discuss the implications for AI understanding.", tokens: 45)
    ]
```

--------------------------------

### Rate Limit Handling Example

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Demonstrates how to manage rate limiting by creating a RateLimitManager. This is useful for applications that make frequent API calls.

```swift
import DeepSeekKit


// Dealing with rate limiting
struct RateLimitHandlingView: View {
    @StateObject private var rateLimitManager = RateLimitManager()
    @State private var testPrompt = "Tell me a short joke"
    @State private var requestCount = 5
    
    var body: some View {


```

--------------------------------

### DeepSeekModel Usage Examples

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/deepseekmodel

Demonstrates how to instantiate requests for both the chat and reasoning models using the ChatCompletionRequest. Ensure you import necessary components.

```swift
// Use the chat model for general conversations
let chatRequest = ChatCompletionRequest(
    model: .chat,
    messages: [.user("Tell me a joke")]
)


// Use the reasoning model for complex problems
let reasoningRequest = ChatCompletionRequest(
    model: .reasoner,
    messages: [.user("Prove that the sum of angles in a triangle is 180 degrees")]
)
```

--------------------------------

### Initialize DeepSeekClient

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Initializes the DeepSeekClient with an API key. This is the starting point for interacting with the Deepseek API.

```swift
private let client: DeepSeekClient

init(apiKey: String) {
    self.client = DeepSeekClient(apiKey: apiKey)
}
```

--------------------------------

### Swift Array Mapping Example with TODO

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

Shows a Swift array mapping operation with a placeholder for the doubling logic.

```swift
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { 
    // TODO: Double each number
}
```

--------------------------------

### Animated Streaming View Setup

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/04-streaming-responses

Initializes a view for animated streaming responses using DeepSeekKit. Requires StreamAnimator and AnimationType.

```swift
import DeepSeekKit


// Implementing smooth text animation for streaming
struct AnimatedStreamingView: View {
    @StateObject private var animator = StreamAnimator()
    @State private var prompt = ""
    @State private var selectedAnimation: AnimationType = .typewriter
```

--------------------------------

### Initialize Smart Automation Engine

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Initializes the `SmartAutomationEngine` with an API key and a `SmartHomeManager` instance. This setup is required before using the engine's automation features.

```swift
init(apiKey: String, deviceManager: SmartHomeManager) {
        _engine = StateObject(wrappedValue: SmartAutomationEngine(
            apiKey: apiKey,
            deviceManager: deviceManager
        ))
    }
```

--------------------------------

### Device Discovery Start and Stop Logic

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Manages the device discovery process by starting and stopping a simulated scan. Includes timer setup for periodic discovery and a timeout to stop the scan.

```swift
func startDeviceDiscovery() {
    isScanning = true
    discoveredDevices.removeAll()
    
    // Simulate device discovery
    scanTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
        self.simulateDeviceDiscovery()
    }
    
    // Stop after 10 seconds
    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
        self.stopDeviceDiscovery()
    }
}

func stopDeviceDiscovery() {
    isScanning = false
    scanTimer?.invalidate()
    scanTimer = nil
}
```

--------------------------------

### Empty Stream View

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/04-streaming-responses

A placeholder view shown when no streams are active. Use this to guide users on how to start comparing streams.

```swift
struct EmptyStreamView: View {
    var body: some View {
        VStack(spacing: 16) {
            Image(systemName: "rectangle.split.3x1")
                .font(.system(size: 60))
                .foregroundColor(.gray)
            
            Text("No Active Streams")
                .font(.headline)
                .foregroundColor(.secondary)
            
            Text("Select configurations above and enter a prompt to start comparing multiple streams")
                .font(.caption)
                .foregroundColor(.secondary)
                .multilineTextAlignment(.center)
                .padding(.horizontal)
        }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .padding(50)
    }
}

```

--------------------------------

### Initialize Mock Smart Home Scenes

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Loads mock data for predefined scenes, such as 'Good Morning' and 'Good Night'. Each scene consists of a name, icon, and a list of device actions to be performed.

```swift
private func loadMockScenes() {
    scenes = [
        Scene(
            name: "Good Morning",
            icon: "sunrise.fill",
            actions: [
                Scene.DeviceAction(deviceId: "light_001", action: "turn_on", value: 100),
                Scene.DeviceAction(deviceId: "light_002", action: "turn_on", value: 50),
                Scene.DeviceAction(deviceId: "plug_001", action: "turn_on", value: nil),
                Scene.DeviceAction(deviceId: "thermostat_001", action: "set_temperature", value: 72)
            ]
        ),
        Scene(
            name: "Good Night",
            icon: "moon.fill",
            actions: [
                Scene.DeviceAction(deviceId: "light_001", action: "turn_off", value: nil),
                Scene.DeviceAction(deviceId: "light_002", action: "turn_off", value: nil),
                Scene.DeviceAction(deviceId: "lock_001", action: "lock", value: nil),
                Scene.DeviceAction(deviceId: "thermostat_001", action: "set_temperature", value: 68)
            ]
        ),
    ]
}
```

--------------------------------

### Get Recent Chat Sessions

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/03-understanding-models

Retrieves the most recent chat sessions, limited to the latest 5, within a specified time range. Sessions are sorted by start time in descending order.

```swift
func getRecentSessions(for timeRange: UsageTracking.TimeRange) -> [ChatSession] {
        sessions.filter { $0.startTime >= timeRange.startDate }
            .sorted { $0.startTime > $1.startTime }
            .prefix(5)
            .map { $0 }
    }
```

--------------------------------

### Get Action Buttons for DeepSeekError

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Generates a list of suggested actions for specific DeepSeekError types, such as opening settings or retrying the request. This helps guide users toward resolving the error.

```swift
private func getActionButtons(for error: DeepSeekError) -> [ActionButton] {
        switch error {
        case .authenticationError:
            return [
                ActionButton(
                    title: "Open Settings",
                    icon: "gear",
                    action: { print("Open settings") }
                ),
                ActionButton(
                    title: "Get API Key",
                    icon: "key",
                    action: { print("Open DeepSeek dashboard") }
                )
            ]
            
        case .rateLimitExceeded:
            return [
                ActionButton(
                    title: "Set Reminder",
                    icon: "alarm",
                    action: { print("Set 1 minute reminder") }
                )
            ]
            
        case .networkError:
            return [
                ActionButton(
                    title: "Network Settings",
                    icon: "wifi",
                    action: { print("Open network settings") }
                ),
                ActionButton(
                    title: "Retry",
                    icon: "arrow.clockwise",
                    action: { print("Retry request") }
                )
            ]
            
default:
            return [
                ActionButton(
                    title: "Try Again",
                    icon: "arrow.clockwise",
                    action: { print("Retry") }
                )
            ]
        }
    }
```

--------------------------------

### Initialize Logging System

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Initializes the logging system by setting up the logger, generating sample logs, and configuring file logging if enabled.

```swift
init() {
        setupLogger()
        generateSampleLogs()
    }
```

--------------------------------

### Generate Sample Logs for Demonstration

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Creates and logs a predefined set of sample log entries with varying messages, levels, and categories to demonstrate logging functionality.

```swift
private func generateSampleLogs() {
        let sampleLogs: [(String, LogLevel, LogEntry.LogCategory)] = [
            ("Application started", .info, .general),
            ("Connected to DeepSeek API", .info, .network),
            ("Cache initialized with 50 entries", .debug, .cache),
            ("Authentication successful", .info, .authentication),
            ("Rate limit warning: 80% of quota used", .warning, .api),
            ("Network timeout after 30s", .error, .network),
            ("Stream connection established", .info, .stream),
            ("Cache hit for prompt: 'What is SwiftUI?'", .debug, .cache),
            ("API returned 429 Too Many Requests", .error, .api),
            ("Critical: Server returned 503 Service Unavailable", .critical, .api)
        ]
        
        for (message, level, category) in sampleLogs {
            log(message, level: level, category: category)
        }
```

--------------------------------

### Initialize Mock Smart Home Devices

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Loads mock data for various smart home devices, populating an array of `SmartHomeDevices.Device` objects. This includes devices for different rooms like the living room, bedroom, kitchen, and entry.

```swift
private func loadMockDevices() {
    devices = [
        // Living Room
        SmartHomeDevices.Device(
            id: "light_001",
            name: "Living Room Light",
            type: .light,
            room: "Living Room",
            isOnline: true,
            state: .light(on: true, brightness: 80, color: nil),
            capabilities: [.power, .dimming]
        ),
        SmartHomeDevices.Device(
            id: "speaker_001",
            name: "Living Room Speaker",
            type: .speaker,
            room: "Living Room",
            isOnline: true,
            state: .speaker(playing: false, volume: 50),
            capabilities: [.power]
        ),
        
        // Bedroom
        SmartHomeDevices.Device(
            id: "light_002",
            name: "Bedroom Light",
            type: .light,
            room: "Bedroom",
            isOnline: true,
            state: .light(on: false, brightness: 0, color: "#FF0000"),
            capabilities: [.power, .dimming, .colorControl]
        ),
        SmartHomeDevices.Device(
            id: "thermostat_001",
            name: "Bedroom Thermostat",
            type: .thermostat,
            room: "Bedroom",
            isOnline: true,
            state: .thermostat(temperature: 72, mode: .auto),
            capabilities: [.temperature]
        ),
        
        // Kitchen
        SmartHomeDevices.Device(
            id: "plug_001",
            name: "Coffee Maker",
            type: .plug,
            room: "Kitchen",
            isOnline: true,
            state: .plug(on: false, powerUsage: 0),
            capabilities: [.power, .scheduling]
        ),
        
        // Entry
        SmartHomeDevices.Device(
            id: "lock_001",
            name: "Front Door",
            type: .lock,
            room: "Entry",
            isOnline: true,
            state: .lock(locked: true, battery: 85),
            capabilities: [.power]
        ),
        SmartHomeDevices.Device(
            id: "camera_001",
            name: "Front Door Camera",
            type: .camera,
            room: "Entry",
            isOnline: true,
            state: .camera(recording: true, motionDetected: false),
            capabilities: [.recording, .twoWayAudio]
        )
    ]
}
```

--------------------------------

### Advanced Features Example

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/chatcompletionrequest

An example showcasing advanced configuration options for ChatCompletionRequest.

```APIDOC
```swift
let advancedRequest = ChatCompletionRequest(
    model: .chat,
    messages: messages,
    temperature: 0.7,
    maxTokens: 1000,
    stream: true,
    responseFormat: .json,
    tools: [weatherTool, calculatorTool],
    toolChoice: .auto
)
```
```

--------------------------------

### Initialize Weather Assistant with DeepseekClient

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Initializes the weather assistant with a DeepSeekClient and a mock weather service. Sets up the system message and initial assistant welcome message.

```swift
init(apiKey: String) {
    self.client = DeepSeekClient(apiKey: apiKey)
    self.weatherService = MockWeatherService()
    
    setupAssistant()
}
```

--------------------------------

### Load Mock Scenes for Smart Home

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Initializes a collection of predefined scenes, such as 'Good Morning', 'Good Night', and 'Movie Time'. Each scene consists of a name, icon, and a list of actions to be performed on specific devices.

```swift
scenes = [
            Scene(
                name: "Good Morning",
                icon: "sunrise.fill",
                actions: [
                    Scene.DeviceAction(deviceId: "light_001", action: "turn_on", value: 100),
                    Scene.DeviceAction(deviceId: "light_002", action: "turn_on", value: 50),
                    Scene.DeviceAction(deviceId: "plug_001", action: "turn_on", value: nil),
                    Scene.DeviceAction(deviceId: "thermostat_001", action: "set_temperature", value: 72)
                ]
            ),
            Scene(
                name: "Good Night",
                icon: "moon.fill",
                actions: [
                    Scene.DeviceAction(deviceId: "light_001", action: "turn_off", value: nil),
                    Scene.DeviceAction(deviceId: "light_002", action: "turn_off", value: nil),
                    Scene.DeviceAction(deviceId: "lock_001", action: "lock", value: nil),
                    Scene.DeviceAction(deviceId: "thermostat_001", action: "set_temperature", value: 68)
                ]
            ),
            Scene(
                name: "Movie Time",
                icon: "tv.fill",
                actions: [
                    Scene.DeviceAction(deviceId: "light_001", action: "set_brightness", value: 20),
                    Scene.DeviceAction(deviceId: "speaker_001", action: "turn_on", value: nil)
                ]
            )
        ]
```

--------------------------------

### Exponential Backoff Manager Setup

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Initializes the BackoffManager for exponential backoff retries. This is a common setup for handling transient network issues.

```swift
import DeepSeekKit


// Implementing exponential backoff for retries
struct ExponentialBackoffView: View {
    @StateObject private var backoffManager = BackoffManager()
    @State private var selectedStrategy: BackoffStrategy = .exponential
    @State private var simulateFailures = true
    
    var body: some View {


```

--------------------------------

### SwiftUI View for Reasoner Example

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/03-understanding-models

This SwiftUI View demonstrates how to use the DeepSeekClient to solve math problems. It includes input fields, a button to trigger the solution, and a display area for the results. Ensure DeepSeekClient is properly initialized.

```swift
struct ReasonerExample: View {
    @StateObject private var client = DeepSeekClient()
    @State private var problem = ""
    @State private var reasoningSteps: [ReasoningStep] = []
    @State private var finalAnswer = ""
    @State private var isLoading = false
    @State private var showReasoning = true

```

--------------------------------

### Generate Sample Logs

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Creates a list of sample log entries for demonstration purposes, including informational messages about application startup and API connection.

```swift
private func generateSampleLogs() {
        let sampleLogs: [(String, LogLevel, LogEntry.LogCategory)] = [
            ("Application started", .info, .general),
            ("Connected to DeepSeek API", .info, .network),

```

--------------------------------

### Start Network Monitoring

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Initiates network status monitoring and quality checks. This function sets up a handler for path updates and starts a timer for periodic quality monitoring.

```swift
func startMonitoring() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.updateConnectionStatus(path: path)
            }
        }
        monitor.start(queue: queue)
        
        // Start quality monitoring
        startQualityMonitoring()
    }
```

--------------------------------

### Cache Initialization

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Initializes the cache system, setting up the disk cache directory, configuring the memory cache limits, and loading the cache index.

```swift
init() {
    // Setup disk cache directory
    let cacheDir = FileManager.default.urls(
        for: .cachesDirectory,
        in: .userDomainMask
    ).first!
    self.diskCacheURL = cacheDir.appendingPathComponent("FunctionCache")
    
    // Create directory if needed
    try? FileManager.default.createDirectory(
        at: diskCacheURL,
        withIntermediateDirectories: true
    )
    
    // Configure memory cache
    memoryCache.countLimit = 100
    memoryCache.totalCostLimit = maxMemorySize
    
    // Load cache index
    loadCacheIndex()
    
    // Start cleanup timer
    startCleanupTimer()
}
```

--------------------------------

### ResponseFormatType.text Case Example

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/responseformattype/text

Demonstrates the basic usage of ResponseFormatType.text.

```plaintext
case text
```

--------------------------------

### init(type:)

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/responseformat/init%28type%3A%29

Creates a new response format instance with the specified type.

```APIDOC
## init(type:)

### Description
Creates a new response format.

### Method Signature
```swift
init(type: ResponseFormatType)
```

### Parameters
#### Path Parameters
- **type** (ResponseFormatType) - Required - The type of response format to create.
```

--------------------------------

### SwiftUI View for FIM Demonstration

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/09-code-completion

This SwiftUI view orchestrates the Fill-in-Middle demonstration. It allows users to select different code examples, interactively adjust the cursor position, and visualize the FIM components. The view updates the FIM analysis whenever the code example or cursor position changes.

```swift
import SwiftUI
import DeepSeekKit


// Understanding Fill-in-Middle (FIM) structure
struct FIMStructureView: View {
    @StateObject private var demonstrator = FIMDemonstrator()
    @State private var codeExample = CodeExample.simpleFunction
    @State private var cursorPosition = 50
    
    enum CodeExample: String, CaseIterable {
        case simpleFunction = "Simple Function"
        case classMethod = "Class Method"
        case swiftUIView = "SwiftUI View"
        case completion = "Code Completion"
        
        var code: String {
            switch self {
            case .simpleFunction:
                return """
                func calculateTotal(items: [Item]) -> Double {
                    // TODO: Calculate total
                    return 0.0
                }
                """
            case .classMethod:
                return """
                class ShoppingCart {
                    private var items: [Item] = []
                    
                    func addItem(_ item: Item) {
                        // TODO: Add item
                    }
                }
                """
            case .swiftUIView:
                return """
                struct ContentView: View {
                    var body: some View {
                        VStack {
                            // TODO: Add content
                        }
                    }
                }
                """
            case .completion:
                return """
                let numbers = [1, 2, 3, 4, 5]
                let doubled = numbers.map { 
                    // TODO: Double each number
                }
                """
            }
        }
        
        var idealCursorPosition: Int {
            // Position cursor at TODO comment
            if let range = code.range(of: "TODO:") {
                return code.distance(from: code.startIndex, to: range.lowerBound)
            }
            return code.count / 2
        }
    }
    
    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 20) {
                // FIM concept explanation
                ConceptExplanationView()
                
                // Code example selector
                CodeExampleSelector(
                    selectedExample: $codeExample,
                    onSelect: { example in
                        cursorPosition = example.idealCursorPosition
                    }
                )
                
                // Interactive FIM demonstration
                InteractiveFIMView(
                    code: codeExample.code,
                    cursorPosition: $cursorPosition,
                    demonstrator: demonstrator
                )
                
                // FIM components breakdown
                if let components = demonstrator.currentComponents {
                    FIMComponentsView(components: components)
                }
                
                // How FIM works
                HowFIMWorksView()
                
                // Best practices
                FIMBestPracticesView()
            }
            .padding()
        }
        .navigationTitle("FIM Structure")
        .onAppear {
            demonstrator.analyzeCode(codeExample.code, cursorPosition: cursorPosition)
        }
        .onChange(of: codeExample) { _ in
            demonstrator.analyzeCode(codeExample.code, cursorPosition: cursorPosition)
        }
        .onChange(of: cursorPosition) {
            demonstrator.analyzeCode(codeExample.code, cursorPosition: cursorPosition)
        }
    }
}


// MARK: - FIM Demonstrator


class FIMDemonstrator: ObservableObject {
    @Published var currentComponents: FIMComponents?
    
    struct FIMComponents {
        let prefix: String
        let suffix: String
        let expectedCompletion: String
        let context: String
    }
    
    func analyzeCode(_ code: String, cursorPosition: Int) {
        let index = code.index(code.startIndex, offsetBy: min(cursorPosition, code.count))
        
        let prefix = String(code[..<index])
        let suffix = String(code[index...])
        
        // Determine expected completion based on context
        let expectedCompletion = generateExpectedCompletion(prefix: prefix, suffix: suffix)
        let context = extractContext(from: code, at: cursorPosition)
        
        currentComponents = FIMComponents(
            prefix: prefix,
            suffix: suffix,
            expectedCompletion: expectedCompletion,
            context: context
        )
    }
    
    private func generateExpectedCompletion(prefix: String, suffix: String) -> String {
        // Simple heuristic-based completion

```

--------------------------------

### SwiftUI Example: Using the Reasoner Model

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/03-understanding-models

This SwiftUI view demonstrates how to integrate the DeepSeekClient to solve problems using the Reasoner model. It displays the problem input, a button to trigger the reasoning process, and sections to show the detailed reasoning steps and the final answer, along with token usage statistics.

```swift
import SwiftUI
import DeepSeekKit


struct ReasonerExample: View {
    @StateObject private var client = DeepSeekClient()
    @State private var problem = "If a train travels 120 miles in 2 hours, and then travels 180 miles in 3 hours, what is its average speed for the entire journey?"
    @State private var response: ChatResponse?
    @State private var isLoading = false
    
    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 20) {
                Text("Reasoner Model Example")
                    .font(.largeTitle)
                    .bold()
                
                // Problem Input
                VStack(alignment: .leading) {
                    Text("Problem:")
                        .font(.headline)
                    
                    TextEditor(text: $problem)
                        .frame(height: 100)
                        .overlay(
                            RoundedRectangle(cornerRadius: 8)
                                .stroke(Color.gray.opacity(0.3), lineWidth: 1)
                        )
                }
                
                Button(action: solveWithReasoning) {
                    Label("Solve with Reasoning", systemImage: "brain")
                        .frame(maxWidth: .infinity)
                }
                .buttonStyle(.borderedProminent)
                .disabled(problem.isEmpty || isLoading)
                
                if isLoading {
                    HStack {
                        ProgressView()
                        Text("Thinking through the problem...")
                    }
                    .padding()
                }
                
                // Response Display
                if let response = response,
                   let choice = response.choices.first {
                    
                    // Reasoning Content
                    if let reasoning = choice.message.reasoningContent {
                        VStack(alignment: .leading, spacing: 10) {
                            HStack {
                                Image(systemName: "brain")
                                    .foregroundColor(.purple)
                                Text("Reasoning Process")
                                    .font(.headline)
                            }
                            
                            Text(reasoning)
                                .padding()
                                .background(Color.purple.opacity(0.1))
                                .cornerRadius(10)
                                .font(.callout)
                        }
                    }
                    
                    // Final Answer
                    if let content = choice.message.content {
                        VStack(alignment: .leading, spacing: 10) {
                            HStack {
                                Image(systemName: "checkmark.circle")
                                    .foregroundColor(.green)
                                Text("Final Answer")
                                    .font(.headline)
                            }
                            
                            Text(content)
                                .padding()
                                .background(Color.green.opacity(0.1))
                                .cornerRadius(10)
                        }
                    }
                    
                    // Usage Statistics
                    if let usage = response.usage {
                        VStack(alignment: .leading, spacing: 5) {
                            Text("Token Usage")
                                .font(.headline)
                            
                            HStack {
                                Label("\(usage.promptTokens) prompt", systemImage: "arrow.up")
                                Spacer()
                                Label("\(usage.completionTokens) completion", systemImage: "arrow.down")
                                Spacer()
                                Label("\(usage.totalTokens) total", systemImage: "sum")
                            }
                            .font(.caption)
                        }
                        .padding()
                        .background(Color.gray.opacity(0.1))
                        .cornerRadius(10)
                    }
                }
            }
            .padding()
        }
    }
    
    private func solveWithReasoning() {
        isLoading = true
        response = nil
        
        Task {
            do {
                // Use the reasoner model to get detailed reasoning
                response = try await client.chat(

```

--------------------------------

### init(apiKey:baseURL:session:)

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/deepseekclient/init%28apikey%3Abaseurl%3Asession%3A%29

Creates a new DeepSeek client instance. You must provide your API key. The base URL and URLSession can be customized if needed, otherwise, defaults are used.

```APIDOC
## init(apiKey:baseURL:session:)

### Description
Creates a new DeepSeek client.

### Method
Initializer

### Parameters
#### Path Parameters
- **apiKey** (String) - Required - Your DeepSeek API key.
- **baseURL** (URL) - Optional - The base URL for API requests (defaults to production).
- **session** (URLSession) - Optional - URLSession to use for networking (defaults to shared).
```

--------------------------------

### Get Suggested Action for Error

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Provides a user-friendly suggested action for different error scenarios.

```swift
private func getSuggestedAction(for scenario: ErrorScenario) -> String {
    switch scenario {
    case .serverError:
        return "Retry with exponential backoff"
    case .badRequest:
        return "Review and fix request parameters"
    case .forbidden:
        return "Check API key permissions"
    case .notFound:
        return "Verify endpoint and resource ID"
    case .conflict:
        return "Resolve state conflict and retry"
    case .tooManyRequests:
        return "Wait for rate limit reset"
    case .serviceUnavailable:
        return "Wait and retry in a few minutes"
    }
}
```

--------------------------------

### SwiftUI: Usage Tips View

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/03-understanding-models

Displays a list of usage tips to help users manage their model costs effectively. Includes advice on choosing the right model, limiting token usage, and monitoring balance.

```swift
struct UsageTipsView: View {
    var body: some View {
        VStack(alignment: .leading, spacing: 10) {
            HStack {
                Image(systemName: "lightbulb")
                    .foregroundColor(.yellow)
                Text("Usage Tips")
                    .font(.headline)
            }
            
            VStack(alignment: .leading, spacing: 8) {
                TipRow(text: "Use the chat model for general tasks to save costs")
                TipRow(text: "Limit token usage by being concise in prompts")
                TipRow(text: "Monitor your balance regularly to avoid interruptions")
            }
        }
    }
}
```

--------------------------------

### Get baseURL Property

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/deepseekprotocol/baseurl

This property returns the base URL for API requests. It is a required property.

```swift
var baseURL: URL { get }
```

--------------------------------

### SwiftUI View for Reasoner Model Example

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/03-understanding-models

Demonstrates how to use the Reasoner model to solve a problem. Includes input fields for the problem, a button to trigger the analysis, and displays the reasoning process and final answer. Requires `DeepSeekClient` and `ChatResponse` types.

```swift
import SwiftUI
import DeepSeekKit


struct ReasonerExample: View {
    @StateObject private var client = DeepSeekClient()
    @State private var problem = "If a train travels 120 miles in 2 hours, and then travels 180 miles in 3 hours, what is its average speed for the entire journey?"
    @State private var response: ChatResponse? 
    @State private var isLoading = false
    
    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 20) {
                Text("Reasoner Model Example")
                    .font(.largeTitle)
                    .bold()
                
                // Problem Input
                VStack(alignment: .leading) {
                    Text("Problem:")
                        .font(.headline)
                    
                    TextEditor(text: $problem)
                        .frame(height: 100)
                        .overlay(
                            RoundedRectangle(cornerRadius: 8)
                                .stroke(Color.gray.opacity(0.3), lineWidth: 1)
                        )
                }
                
                Button(action: solveWithReasoning) {
                    Label("Solve with Reasoning", systemImage: "brain")
                        .frame(maxWidth: .infinity)
                }
                .buttonStyle(.borderedProminent)
                .disabled(problem.isEmpty || isLoading)
                
                if isLoading {
                    HStack {
                        ProgressView()
                        Text("Thinking through the problem...")
                    }
                    .padding()
                }
                
                // Response Display
                if let response = response,
                   let choice = response.choices.first {
                    
                    // Reasoning Content
                    if let reasoning = choice.message.reasoningContent {
                        VStack(alignment: .leading, spacing: 10) {
                            HStack {
                                Image(systemName: "brain")
                                    .foregroundColor(.purple)
                                Text("Reasoning Process")
                                    .font(.headline)
                            }
                            
                            Text(reasoning)
                                .padding()
                                .background(Color.purple.opacity(0.1))
                                .cornerRadius(10)
                                .font(.callout)
                        }
                    }
                    
                    // Final Answer
                    if let content = choice.message.content {
                        VStack(alignment: .leading, spacing: 10) {
                            HStack {
                                Image(systemName: "checkmark.circle")
                                    .foregroundColor(.green)
                                Text("Final Answer")

```

--------------------------------

### Setup Function Tools for AI

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Define tools, specifically functions, that the AI can utilize. This includes specifying the function's name, a description of its purpose, and its parameters.

```swift
let weatherTool = ChatCompletionRequest.Tool(
                type: .function,
                function: ChatCompletionRequest.Tool.Function(
                    name: "get_weather",
                    description: "Get the current weather in a given location",
                    parameters: [
                        "type": "object",
                        "properties": [
                            "location": [
                                "type": "string",
                                "description": "The city and state, e.g. San Francisco, CA"
                            ]
                        ],
                        "required": ["location"]
                    ]
                )
            )
```

```swift
let weatherTool = ChatCompletionRequest.Tool(
                type: .function,
                function: .init(
                    name: "get_weather",
                    description: "Get current weather",
                    parameters: [
                        "location": ["type": "string"]
                    ]
                )
            )
```

--------------------------------

### SwiftUI ProgressView Example

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/06-message-history

A basic SwiftUI ProgressView implementation, often used for visual feedback during asynchronous operations.

```swift
ProgressView()
    .scaleEffect(0.8)
}
.onReceive(timer) { _ in
    dots = (dots + 1) % 4
}
}
```

--------------------------------

### Initialize DeepSeekClient with API Key

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/01-setting-up-deepseekkit

Create an instance of DeepSeekClient by providing your API key. It's recommended to retrieve the API key from environment variables or secure storage like the Keychain.

```swift
import SwiftUI
import DeepSeekKit


struct ContentView: View {
    let client: DeepSeekClient
    
    init() {
        // Get API key from environment or Keychain
        guard let apiKey = ProcessInfo.processInfo.environment["DEEPSEEK_API_KEY"] else {
            fatalError("Please set DEEPSEEK_API_KEY environment variable")
        }
        
        self.client = DeepSeekClient(apiKey: apiKey)
    }
    
    var body: some View {
        Text("DeepSeek Client Ready!")
            .padding()
    }
}
```

--------------------------------

### init(name:description:parameters:)

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/functiondefinition/init%28name%3Adescription%3Aparameters%3A%29

Creates a new function definition with a given name, description, and parameters.

```APIDOC
## init(name:description:parameters:)

### Description
Creates a new function definition.

### Parameters
#### Path Parameters
* **name** (String) - Required - The function name (e.g., “get_weather”, “search_database”)
* **description** (String) - Required - A clear description of the function’s purpose
* **parameters** (Any) - Required - JSON Schema defining the function’s parameters
```

--------------------------------

### Get Device Model

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/05-error-handling

Determines and returns the current device model, providing platform-specific implementations for iOS and other platforms.

```swift
private func getDeviceModel() -> String {
        #if os(iOS)
        return UIDevice.current.model
        #else
        return "Mac"
        #endif
    }
```

--------------------------------

### Function Calling Workflow View

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

A SwiftUI view that visually guides the user through the function calling workflow steps.

```swift
struct FunctionCallingWorkflow: View {
    @State private var currentStep = 0
    let steps = [
        "Define Tools",
        "Include Tools in Request",
        "Receive Tool Calls",
        "Execute Local Function",
        "Send Function Results",
        "Receive Final Response"
    ]
    
    var body: some View {
        VStack {
            ProgressIndicator(currentStep: currentStep, totalSteps: steps.count)
            
            ExplanationView(step: currentStep)
            
            Spacer()
            
            HStack {
                Button(action: previousStep) {
                    Label("Previous", systemImage: "arrow.left.circle")
                }
                .disabled(currentStep == 0)
                
                Spacer()
                
                Button(action: nextStep) {
                    Label("Next", systemImage: "arrow.right.circle")
                }
                .disabled(currentStep == steps.count - 1)
            }
        }
        .padding()
        .navigationTitle("Function Calling Workflow")
        .navigationBarTitleDisplayMode(.inline)
    }
    
    private func nextStep() {
        withAnimation {
            currentStep = min(currentStep + 1, steps.count - 1)
        }
    }
    
    private func previousStep() {
        withAnimation {
            currentStep = max(currentStep - 1, 0)
        }
    }
}
```

--------------------------------

### MessageRole.tool Case Example

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/messagerole/tool

Demonstrates the basic case usage for MessageRole.tool. Ensure JavaScript is enabled for full page functionality.

```case
case tool
```

--------------------------------

### Live Validation Example with Parameter Schema

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/07-function-calling

Demonstrates live validation of user input against a defined ParameterSchema. Use this to provide immediate feedback on form inputs.

```swift
import SwiftUI
import DeepSeekKit

// Parameter validation for function calls
struct ParameterValidator {
    
    // MARK: - Validation Rules

// MARK: - Live Validation Example


struct LiveValidationExample: View {
    @State private var location = ""
    @State private var units = "fahrenheit"
    @State private var validationMessage = ""
    @State private var isValid = false
    
    let weatherSchema = ParameterSchema(
        name: "location",
        type: .string,
        description: "City and state/country",
        rules: [
            ParameterValidator.required(),
            ParameterValidator.minLength(3),
            ParameterValidator.pattern("^[A-Za-z\\s,]+$")
        ],
        defaultValue: nil
    )
    
    var body: some View {
        VStack(alignment: .leading, spacing: 16) {
            Text("Live Validation Example")
                .font(.headline)
            
            VStack(alignment: .leading, spacing: 8) {
                Text("Location")
                    .font(.subheadline)
                
                TextField("Enter city, state/country", text: $location)
                    .textFieldStyle(RoundedBorderTextFieldStyle())
                    .onChange(of: location) { _ in
                        validateLocation()
                    }
                
                HStack {
                    Image(systemName: isValid ? "checkmark.circle.fill" : "xmark.circle.fill")
                        .foregroundColor(isValid ? .green : .red)
                    
                    Text(validationMessage)
                        .font(.caption)
                        .foregroundColor(isValid ? .green : .red)
                }
            }
            
            Picker("Units", selection: $units) {
                Text("Fahrenheit").tag("fahrenheit")
                Text("Celsius").tag("celsius")
                Text("Kelvin").tag("kelvin")
            }
            .pickerStyle(SegmentedPickerStyle())
            
            Button("Submit") {
                // Process valid input
            }
            .buttonStyle(.borderedProminent)
            .disabled(!isValid)
        }
        .padding()
        .background(Color(.systemGray6))
        .cornerRadius(12)
        .onAppear {
            validateLocation()
        }
    }
    
    private func validateLocation() {
        let result = weatherSchema.validate(location.isEmpty ? nil : location)
        
        switch result {
        case .valid:
            isValid = true
            validationMessage = "Valid location"
        case .invalid(let reason):
            isValid = false
            validationMessage = reason
        case .warning(let message):
            isValid = true
            validationMessage = message
        }
    }
}

```

--------------------------------

### Get Cancellation Reason String

Source: https://guitaripod.github.io/DeepSeekKit/tutorials/deepseekkit/04-streaming-responses

Returns a human-readable string describing the reason for cancellation based on the current cancellation type.

```swift
private func getCancellationReason() -> String {
    switch cancellationType {
    case .immediate:
        return "Stopped immediately"
    case .afterSentence:
        return "Stopped at sentence end"
    case .afterParagraph:
        return "Stopped at paragraph end"
    case .afterWord:
        return "Stopped at word boundary"
    case .graceful:
        return "Stopped gracefully"
    }
}
```

--------------------------------

### init(function:)

Source: https://guitaripod.github.io/DeepSeekKit/documentation/deepseekkit/tool/init%28function%3A%29

Creates a new tool with the specified function definition.

```APIDOC
## init(function:)

### Description
Creates a new tool with the specified function definition.

### Method
(Not specified, likely SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### `function`
- **FunctionDefinition** - Required - The function definition for this tool.
```
Tokens:
Raw