1484 lines
58 KiB
Swift
1484 lines
58 KiB
Swift
//
|
|
// ChatViewModel.swift
|
|
// oAI
|
|
//
|
|
// Main chat view model
|
|
//
|
|
|
|
import Foundation
|
|
import os
|
|
import SwiftUI
|
|
|
|
@Observable
|
|
@MainActor
|
|
class ChatViewModel {
|
|
// MARK: - Observable State
|
|
|
|
var messages: [Message] = []
|
|
var inputText: String = ""
|
|
var isGenerating: Bool = false
|
|
var sessionStats = SessionStats()
|
|
var selectedModel: ModelInfo?
|
|
var currentProvider: Settings.Provider = .openrouter
|
|
var onlineMode: Bool = false
|
|
var memoryEnabled: Bool = true
|
|
var mcpEnabled: Bool = false
|
|
var mcpStatus: String? = nil
|
|
var availableModels: [ModelInfo] = []
|
|
var isLoadingModels: Bool = false
|
|
var showConversations: Bool = false
|
|
var showModelSelector: Bool = false
|
|
var showSettings: Bool = false
|
|
var showStats: Bool = false
|
|
var showHelp: Bool = false
|
|
var showCredits: Bool = false
|
|
var showHistory: Bool = false
|
|
var modelInfoTarget: ModelInfo? = nil
|
|
var commandHistory: [String] = []
|
|
var historyIndex: Int = 0
|
|
var isAutoContinuing: Bool = false
|
|
var autoContinueCountdown: Int = 0
|
|
|
|
// MARK: - Auto-Save Tracking
|
|
|
|
private var conversationStartTime: Date?
|
|
private var lastMessageTime: Date?
|
|
private var idleCheckTimer: Timer?
|
|
|
|
// MARK: - Private State
|
|
|
|
private var streamingTask: Task<Void, Never>?
|
|
private var autoContinueTask: Task<Void, Never>?
|
|
private let settings = SettingsService.shared
|
|
private let providerRegistry = ProviderRegistry.shared
|
|
|
|
// Default system prompt - generic for all models
|
|
private let defaultSystemPrompt = """
|
|
You are a helpful AI assistant. Follow these core principles:
|
|
|
|
## CORE BEHAVIOR
|
|
|
|
- **Accuracy First**: Never invent information. If unsure, say so clearly.
|
|
- **Ask for Clarification**: When ambiguous, ask questions before proceeding.
|
|
- **Be Direct**: Provide concise, relevant answers. No unnecessary preambles.
|
|
- **Show Your Work**: If you use capabilities (tools, web search, etc.), demonstrate what you did.
|
|
- **Complete Tasks Properly**: If you start something, finish it correctly.
|
|
|
|
## FORMATTING
|
|
|
|
Always use Markdown formatting:
|
|
- **Bold** for emphasis
|
|
- Code blocks with language tags: ```python
|
|
- Headings (##, ###) for structure
|
|
- Lists for organization
|
|
|
|
## HONESTY
|
|
|
|
It's better to admit "I need more information" or "I cannot do that" than to fake completion or invent answers.
|
|
"""
|
|
|
|
// Tool-specific instructions (added when tools are available)
|
|
private let toolUsageGuidelines = """
|
|
|
|
## TOOL USAGE (You have access to tools)
|
|
|
|
**CRITICAL: Never claim to have done something without actually using the tools.**
|
|
|
|
**BAD Examples (NEVER do this):**
|
|
❌ "I've fixed the issue" → No tool calls shown
|
|
❌ "The file has been updated" → Didn't actually use the tool
|
|
❌ "Done!" → Claimed completion without evidence
|
|
|
|
**GOOD Examples (ALWAYS do this):**
|
|
✅ [Uses tool silently] → Then explain what you did
|
|
✅ Shows actual work through tool calls
|
|
✅ If you can't complete: "I found the issue, but need clarification..."
|
|
|
|
**ENFORCEMENT:**
|
|
- If a task requires using a tool → YOU MUST actually use it
|
|
- Don't just describe what you would do - DO IT
|
|
- The user can see your tool calls - they are proof you did the work
|
|
- NEVER say "fixed" or "done" without showing tool usage
|
|
|
|
**EFFICIENCY:**
|
|
- Some models have tool call limits (~25-30 per request)
|
|
- Make comprehensive changes in fewer tool calls when possible
|
|
- If approaching limits, tell the user you need to continue in phases
|
|
- Don't use tools to "verify" your work unless asked - trust your edits
|
|
|
|
**METHODOLOGY:**
|
|
1. Use the tool to gather information (if needed)
|
|
2. Use the tool to make changes (if needed)
|
|
3. Explain what you did and why
|
|
|
|
Don't narrate future actions ("Let me...") - just use the tools.
|
|
"""
|
|
|
|
/// Builds the complete system prompt by combining default + conditional sections + custom
|
|
private var effectiveSystemPrompt: String {
|
|
// Check if user wants to replace the default prompt entirely (BYOP mode)
|
|
if settings.customPromptMode == .replace,
|
|
let customPrompt = settings.systemPrompt,
|
|
!customPrompt.isEmpty {
|
|
// BYOP: Use ONLY the custom prompt
|
|
return customPrompt
|
|
}
|
|
|
|
// Otherwise, build the prompt: default + conditional sections + custom (if append mode)
|
|
var prompt = defaultSystemPrompt
|
|
|
|
// Add tool-specific guidelines if MCP is enabled (tools are available)
|
|
if mcpEnabled {
|
|
prompt += toolUsageGuidelines
|
|
}
|
|
|
|
// Append custom prompt if in append mode and custom prompt exists
|
|
if settings.customPromptMode == .append,
|
|
let customPrompt = settings.systemPrompt,
|
|
!customPrompt.isEmpty {
|
|
prompt += "\n\n---\n\nAdditional Instructions:\n" + customPrompt
|
|
}
|
|
|
|
return prompt
|
|
}
|
|
|
|
// MARK: - Initialization
|
|
|
|
init() {
|
|
// Load settings
|
|
self.currentProvider = settings.defaultProvider
|
|
self.onlineMode = settings.onlineMode
|
|
self.memoryEnabled = settings.memoryEnabled
|
|
self.mcpEnabled = settings.mcpEnabled
|
|
|
|
// Load command history from database
|
|
if let history = try? DatabaseService.shared.loadCommandHistory() {
|
|
self.commandHistory = history.map { $0.input }
|
|
self.historyIndex = self.commandHistory.count
|
|
}
|
|
|
|
// Load models on startup
|
|
Task {
|
|
await loadAvailableModels()
|
|
}
|
|
}
|
|
|
|
// MARK: - Public Methods
|
|
|
|
/// Switch to a different provider (from header dropdown)
|
|
func changeProvider(_ newProvider: Settings.Provider) {
|
|
guard newProvider != currentProvider else { return }
|
|
Log.ui.info("Switching provider to \(newProvider.rawValue)")
|
|
settings.defaultProvider = newProvider
|
|
currentProvider = newProvider
|
|
selectedModel = nil
|
|
availableModels = []
|
|
Task { await loadAvailableModels() }
|
|
}
|
|
|
|
/// Start a new conversation
|
|
func newConversation() {
|
|
messages = []
|
|
sessionStats = SessionStats()
|
|
inputText = ""
|
|
}
|
|
|
|
/// Re-sync local state from SettingsService (called when Settings sheet dismisses)
|
|
func syncFromSettings() {
|
|
let newProvider = settings.defaultProvider
|
|
let providerChanged = currentProvider != newProvider
|
|
currentProvider = newProvider
|
|
onlineMode = settings.onlineMode
|
|
memoryEnabled = settings.memoryEnabled
|
|
mcpEnabled = settings.mcpEnabled
|
|
mcpStatus = mcpEnabled ? "MCP" : nil
|
|
|
|
if providerChanged {
|
|
selectedModel = nil
|
|
availableModels = []
|
|
Task { await loadAvailableModels() }
|
|
}
|
|
}
|
|
|
|
func loadAvailableModels() async {
|
|
isLoadingModels = true
|
|
|
|
do {
|
|
guard let provider = providerRegistry.getCurrentProvider() else {
|
|
Log.ui.warning("No API key configured for current provider")
|
|
isLoadingModels = false
|
|
showSystemMessage("⚠️ No API key configured. Add your API key in Settings to load models.")
|
|
return
|
|
}
|
|
|
|
let models = try await provider.listModels()
|
|
availableModels = models
|
|
|
|
// Select model priority: saved default > current selection > first available
|
|
if let defaultModelId = settings.defaultModel,
|
|
let defaultModel = models.first(where: { $0.id == defaultModelId }) {
|
|
selectedModel = defaultModel
|
|
} else if selectedModel == nil, let firstModel = models.first {
|
|
selectedModel = firstModel
|
|
}
|
|
isLoadingModels = false
|
|
|
|
} catch {
|
|
Log.api.error("Failed to load models: \(error.localizedDescription)")
|
|
isLoadingModels = false
|
|
showSystemMessage("⚠️ Could not load models: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
|
|
func sendMessage() {
|
|
guard !inputText.trimmingCharacters(in: .whitespaces).isEmpty else { return }
|
|
|
|
let trimmedInput = inputText.trimmingCharacters(in: .whitespaces)
|
|
|
|
// Handle slash escape: "//" becomes "/"
|
|
var effectiveInput = trimmedInput
|
|
if effectiveInput.hasPrefix("//") {
|
|
effectiveInput = String(effectiveInput.dropFirst())
|
|
} else if effectiveInput.hasPrefix("/") {
|
|
// Check if it's a slash command
|
|
handleCommand(effectiveInput)
|
|
inputText = ""
|
|
return
|
|
}
|
|
|
|
// Parse file attachments
|
|
let (cleanText, filePaths) = effectiveInput.parseFileAttachments()
|
|
|
|
// Read file attachments from disk
|
|
let attachments: [FileAttachment]? = filePaths.isEmpty ? nil : readFileAttachments(filePaths)
|
|
|
|
// Create user message
|
|
let userMessage = Message(
|
|
role: .user,
|
|
content: cleanText,
|
|
tokens: cleanText.estimateTokens(),
|
|
cost: nil,
|
|
timestamp: Date(),
|
|
attachments: attachments,
|
|
modelId: selectedModel?.id
|
|
)
|
|
|
|
messages.append(userMessage)
|
|
sessionStats.addMessage(inputTokens: userMessage.tokens, outputTokens: nil, cost: nil)
|
|
|
|
// Add to command history (in-memory and database)
|
|
commandHistory.append(trimmedInput)
|
|
historyIndex = commandHistory.count
|
|
DatabaseService.shared.saveCommandHistory(input: trimmedInput)
|
|
|
|
// Clear input
|
|
inputText = ""
|
|
|
|
// Check auto-save triggers in background
|
|
Task {
|
|
await checkAutoSaveTriggersAfterMessage(cleanText)
|
|
}
|
|
|
|
// Generate real AI response
|
|
generateAIResponse(to: cleanText, attachments: userMessage.attachments)
|
|
}
|
|
|
|
func cancelGeneration() {
|
|
streamingTask?.cancel()
|
|
streamingTask = nil
|
|
isGenerating = false
|
|
cancelAutoContinue() // Also cancel any pending auto-continue
|
|
}
|
|
|
|
func startAutoContinue() {
|
|
isAutoContinuing = true
|
|
autoContinueCountdown = 5
|
|
|
|
autoContinueTask = Task { @MainActor in
|
|
// Countdown from 5 to 1
|
|
for i in (1...5).reversed() {
|
|
if Task.isCancelled {
|
|
isAutoContinuing = false
|
|
return
|
|
}
|
|
autoContinueCountdown = i
|
|
try? await Task.sleep(for: .seconds(1))
|
|
}
|
|
|
|
// Continue the task
|
|
isAutoContinuing = false
|
|
autoContinueCountdown = 0
|
|
|
|
let continuePrompt = "Please continue from where you left off."
|
|
|
|
// Add user message
|
|
let userMessage = Message(
|
|
role: .user,
|
|
content: continuePrompt,
|
|
tokens: nil,
|
|
cost: nil,
|
|
timestamp: Date(),
|
|
attachments: nil,
|
|
responseTime: nil,
|
|
wasInterrupted: false,
|
|
modelId: selectedModel?.id
|
|
)
|
|
messages.append(userMessage)
|
|
|
|
// Continue generation
|
|
generateAIResponse(to: continuePrompt, attachments: nil)
|
|
}
|
|
}
|
|
|
|
func cancelAutoContinue() {
|
|
autoContinueTask?.cancel()
|
|
autoContinueTask = nil
|
|
isAutoContinuing = false
|
|
autoContinueCountdown = 0
|
|
}
|
|
|
|
func clearChat() {
|
|
messages.removeAll()
|
|
sessionStats.reset()
|
|
showSystemMessage("Chat cleared")
|
|
}
|
|
|
|
func loadConversation(_ conversation: Conversation) {
|
|
do {
|
|
guard let (_, loadedMessages) = try DatabaseService.shared.loadConversation(id: conversation.id) else {
|
|
showSystemMessage("Could not load conversation '\(conversation.name)'")
|
|
return
|
|
}
|
|
|
|
messages.removeAll()
|
|
sessionStats.reset()
|
|
messages = loadedMessages
|
|
|
|
// Rebuild session stats from loaded messages
|
|
for msg in loadedMessages {
|
|
sessionStats.addMessage(
|
|
inputTokens: msg.role == .user ? msg.tokens : nil,
|
|
outputTokens: msg.role == .assistant ? msg.tokens : nil,
|
|
cost: msg.cost
|
|
)
|
|
}
|
|
|
|
showSystemMessage("Loaded conversation '\(conversation.name)'")
|
|
} catch {
|
|
showSystemMessage("Failed to load: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
|
|
func retryLastMessage() {
|
|
guard let lastUserMessage = messages.last(where: { $0.role == .user }) else {
|
|
showSystemMessage("No previous message to retry")
|
|
return
|
|
}
|
|
|
|
// Remove last assistant response if exists
|
|
if let lastMessage = messages.last, lastMessage.role == .assistant {
|
|
messages.removeLast()
|
|
}
|
|
|
|
generateAIResponse(to: lastUserMessage.content, attachments: lastUserMessage.attachments)
|
|
}
|
|
|
|
// MARK: - Command Handling
|
|
|
|
private func handleCommand(_ command: String) {
|
|
guard let (cmd, args) = command.parseCommand() else {
|
|
showSystemMessage("Invalid command")
|
|
return
|
|
}
|
|
|
|
switch cmd.lowercased() {
|
|
case "/help":
|
|
showHelp = true
|
|
|
|
case "/history":
|
|
showHistory = true
|
|
|
|
case "/model":
|
|
showModelSelector = true
|
|
|
|
case "/clear":
|
|
clearChat()
|
|
|
|
case "/retry":
|
|
retryLastMessage()
|
|
|
|
case "/memory":
|
|
if let arg = args.first?.lowercased() {
|
|
memoryEnabled = arg == "on"
|
|
showSystemMessage("Memory \(memoryEnabled ? "enabled" : "disabled")")
|
|
} else {
|
|
showSystemMessage("Usage: /memory on|off")
|
|
}
|
|
|
|
case "/online":
|
|
if let arg = args.first?.lowercased() {
|
|
onlineMode = arg == "on"
|
|
showSystemMessage("Online mode \(onlineMode ? "enabled" : "disabled")")
|
|
} else {
|
|
showSystemMessage("Usage: /online on|off")
|
|
}
|
|
|
|
case "/stats":
|
|
showStats = true
|
|
|
|
case "/config", "/settings":
|
|
showSettings = true
|
|
|
|
case "/provider":
|
|
if let providerName = args.first?.lowercased() {
|
|
if let provider = Settings.Provider.allCases.first(where: { $0.rawValue == providerName }) {
|
|
currentProvider = provider
|
|
showSystemMessage("Switched to \(provider.displayName) provider")
|
|
} else {
|
|
showSystemMessage("Unknown provider: \(providerName)")
|
|
}
|
|
} else {
|
|
showSystemMessage("Current provider: \(currentProvider.displayName)")
|
|
}
|
|
|
|
case "/save":
|
|
if let name = args.first {
|
|
let chatMessages = messages.filter { $0.role != .system }
|
|
guard !chatMessages.isEmpty else {
|
|
showSystemMessage("Nothing to save — no messages in this conversation")
|
|
return
|
|
}
|
|
do {
|
|
let _ = try DatabaseService.shared.saveConversation(name: name, messages: chatMessages)
|
|
showSystemMessage("Conversation saved as '\(name)'")
|
|
} catch {
|
|
showSystemMessage("Failed to save: \(error.localizedDescription)")
|
|
}
|
|
} else {
|
|
showSystemMessage("Usage: /save <name>")
|
|
}
|
|
|
|
case "/load", "/list":
|
|
showConversations = true
|
|
|
|
case "/delete":
|
|
if let name = args.first {
|
|
do {
|
|
let deleted = try DatabaseService.shared.deleteConversation(name: name)
|
|
if deleted {
|
|
showSystemMessage("Deleted conversation '\(name)'")
|
|
} else {
|
|
showSystemMessage("No conversation found with name '\(name)'")
|
|
}
|
|
} catch {
|
|
showSystemMessage("Failed to delete: \(error.localizedDescription)")
|
|
}
|
|
} else {
|
|
showSystemMessage("Usage: /delete <name>")
|
|
}
|
|
|
|
case "/export":
|
|
if args.count >= 1 {
|
|
let format = args[0].lowercased()
|
|
let filename = args.count >= 2 ? args[1] : "conversation.\(format)"
|
|
exportConversation(format: format, filename: filename)
|
|
} else {
|
|
showSystemMessage("Usage: /export md|json <filename>")
|
|
}
|
|
|
|
case "/info":
|
|
if let modelId = args.first {
|
|
if let model = availableModels.first(where: { $0.id == modelId || $0.name.lowercased() == modelId.lowercased() }) {
|
|
showModelInfo(model)
|
|
} else {
|
|
showSystemMessage("Model not found: \(modelId)")
|
|
}
|
|
} else if let model = selectedModel {
|
|
showModelInfo(model)
|
|
} else {
|
|
showSystemMessage("No model selected")
|
|
}
|
|
|
|
case "/credits":
|
|
showCredits = true
|
|
|
|
case "/mcp":
|
|
handleMCPCommand(args: args)
|
|
|
|
default:
|
|
showSystemMessage("Unknown command: \(cmd)\nType /help for available commands")
|
|
}
|
|
}
|
|
|
|
// MARK: - AI Response Generation
|
|
|
|
private func generateAIResponse(to prompt: String, attachments: [FileAttachment]?) {
|
|
// Get provider
|
|
guard let provider = providerRegistry.getCurrentProvider() else {
|
|
Log.ui.warning("Cannot generate: no API key configured")
|
|
showSystemMessage("❌ No API key configured. Please add your API key in Settings.")
|
|
return
|
|
}
|
|
|
|
guard let modelId = selectedModel?.id else {
|
|
Log.ui.warning("Cannot generate: no model selected")
|
|
showSystemMessage("❌ No model selected. Please select a model first.")
|
|
return
|
|
}
|
|
|
|
Log.ui.info("Sending message: model=\(modelId), messages=\(self.messages.count)")
|
|
|
|
// Dispatch to tool-aware path when MCP is enabled with folders
|
|
// Skip for image generation models — they don't support tool calling
|
|
let mcp = MCPService.shared
|
|
let mcpActive = mcpEnabled || settings.mcpEnabled
|
|
let modelSupportTools = selectedModel?.capabilities.tools ?? false
|
|
if mcpActive && !mcp.allowedFolders.isEmpty && modelSupportTools {
|
|
generateAIResponseWithTools(provider: provider, modelId: modelId)
|
|
return
|
|
}
|
|
|
|
isGenerating = true
|
|
|
|
// Cancel any existing task
|
|
streamingTask?.cancel()
|
|
|
|
// Start streaming
|
|
streamingTask = Task {
|
|
let startTime = Date()
|
|
var messageId: UUID?
|
|
do {
|
|
// Create empty assistant message for streaming
|
|
let assistantMessage = Message(
|
|
role: .assistant,
|
|
content: "",
|
|
tokens: nil,
|
|
cost: nil,
|
|
timestamp: Date(),
|
|
attachments: nil,
|
|
modelId: modelId,
|
|
isStreaming: true
|
|
)
|
|
messageId = assistantMessage.id
|
|
|
|
// Already on MainActor
|
|
messages.append(assistantMessage)
|
|
|
|
// Build chat request AFTER adding the assistant message
|
|
// Only include messages up to (but not including) the streaming assistant message
|
|
var messagesToSend = Array(messages.dropLast()) // Remove the empty assistant message
|
|
|
|
// Web search via our WebSearchService
|
|
// Append results to last user message content (matching Python oAI approach)
|
|
if onlineMode && currentProvider != .openrouter && !messagesToSend.isEmpty {
|
|
if let lastUserIdx = messagesToSend.lastIndex(where: { $0.role == .user }) {
|
|
Log.search.info("Running web search for \(currentProvider.displayName)")
|
|
let results = await WebSearchService.shared.search(query: messagesToSend[lastUserIdx].content)
|
|
if !results.isEmpty {
|
|
let searchContext = "\n\n\(WebSearchService.shared.formatResults(results))\n\nPlease use the above web search results to help answer the user's question."
|
|
messagesToSend[lastUserIdx].content += searchContext
|
|
Log.search.info("Injected \(results.count) search results into user message")
|
|
}
|
|
}
|
|
}
|
|
|
|
let isImageGen = selectedModel?.capabilities.imageGeneration ?? false
|
|
if isImageGen {
|
|
Log.ui.info("Image generation mode for model \(modelId)")
|
|
}
|
|
let chatRequest = ChatRequest(
|
|
messages: Array(memoryEnabled ? messagesToSend : [messagesToSend.last!]),
|
|
model: modelId,
|
|
stream: settings.streamEnabled,
|
|
maxTokens: settings.maxTokens > 0 ? settings.maxTokens : nil,
|
|
temperature: settings.temperature > 0 ? settings.temperature : nil,
|
|
topP: nil,
|
|
systemPrompt: effectiveSystemPrompt,
|
|
tools: nil,
|
|
onlineMode: onlineMode,
|
|
imageGeneration: isImageGen
|
|
)
|
|
|
|
if isImageGen {
|
|
// Image generation: use non-streaming request
|
|
// Image models don't reliably support streaming
|
|
if let index = messages.firstIndex(where: { $0.id == messageId }) {
|
|
messages[index].content = ThinkingVerbs.random()
|
|
}
|
|
|
|
let nonStreamRequest = ChatRequest(
|
|
messages: chatRequest.messages,
|
|
model: chatRequest.model,
|
|
stream: false,
|
|
maxTokens: chatRequest.maxTokens,
|
|
temperature: chatRequest.temperature,
|
|
imageGeneration: true
|
|
)
|
|
let response = try await provider.chat(request: nonStreamRequest)
|
|
let responseTime = Date().timeIntervalSince(startTime)
|
|
|
|
if let index = messages.firstIndex(where: { $0.id == messageId }) {
|
|
messages[index].content = response.content
|
|
messages[index].isStreaming = false
|
|
messages[index].generatedImages = response.generatedImages
|
|
messages[index].responseTime = responseTime
|
|
|
|
if let usage = response.usage {
|
|
messages[index].tokens = usage.completionTokens
|
|
if let model = selectedModel {
|
|
let cost = (Double(usage.promptTokens) * model.pricing.prompt / 1_000_000) +
|
|
(Double(usage.completionTokens) * model.pricing.completion / 1_000_000)
|
|
messages[index].cost = cost
|
|
sessionStats.addMessage(inputTokens: usage.promptTokens, outputTokens: usage.completionTokens, cost: cost)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Regular text: stream response
|
|
var fullContent = ""
|
|
var totalTokens: ChatResponse.Usage? = nil
|
|
var wasCancelled = false
|
|
|
|
for try await chunk in provider.streamChat(request: chatRequest) {
|
|
if Task.isCancelled {
|
|
wasCancelled = true
|
|
break
|
|
}
|
|
|
|
if let content = chunk.deltaContent {
|
|
fullContent += content
|
|
if let index = messages.firstIndex(where: { $0.id == messageId }) {
|
|
messages[index].content = fullContent
|
|
}
|
|
}
|
|
|
|
if let usage = chunk.usage {
|
|
totalTokens = usage
|
|
}
|
|
}
|
|
|
|
// Check for cancellation one more time after loop exits
|
|
// (in case it was cancelled after the last chunk)
|
|
if Task.isCancelled {
|
|
wasCancelled = true
|
|
}
|
|
|
|
let responseTime = Date().timeIntervalSince(startTime)
|
|
|
|
if let index = messages.firstIndex(where: { $0.id == messageId }) {
|
|
messages[index].content = fullContent
|
|
messages[index].isStreaming = false
|
|
messages[index].responseTime = responseTime
|
|
messages[index].wasInterrupted = wasCancelled
|
|
|
|
if let usage = totalTokens {
|
|
messages[index].tokens = usage.completionTokens
|
|
if let model = selectedModel {
|
|
let cost = (Double(usage.promptTokens) * model.pricing.prompt / 1_000_000) +
|
|
(Double(usage.completionTokens) * model.pricing.completion / 1_000_000)
|
|
messages[index].cost = cost
|
|
sessionStats.addMessage(inputTokens: usage.promptTokens, outputTokens: usage.completionTokens, cost: cost)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
isGenerating = false
|
|
streamingTask = nil
|
|
|
|
} catch {
|
|
let responseTime = Date().timeIntervalSince(startTime)
|
|
|
|
// Check if this was a cancellation (either by checking Task state or error type)
|
|
let isCancellation = Task.isCancelled || error is CancellationError
|
|
|
|
if isCancellation, let msgId = messageId {
|
|
// Mark the message as interrupted instead of removing it
|
|
if let index = messages.firstIndex(where: { $0.id == msgId }) {
|
|
messages[index].isStreaming = false
|
|
messages[index].wasInterrupted = true
|
|
messages[index].responseTime = responseTime
|
|
}
|
|
} else if let msgId = messageId {
|
|
// For real errors, remove the empty streaming message
|
|
if let index = messages.firstIndex(where: { $0.id == msgId && $0.content.isEmpty }) {
|
|
messages.remove(at: index)
|
|
}
|
|
Log.api.error("Generation failed: \(error.localizedDescription)")
|
|
showSystemMessage("❌ \(friendlyErrorMessage(from: error))")
|
|
}
|
|
|
|
isGenerating = false
|
|
streamingTask = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - File Attachment Reading
|
|
|
|
private let maxFileSize: Int = 10 * 1024 * 1024 // 10 MB
|
|
private let maxTextSize: Int = 50 * 1024 // 50 KB before truncation
|
|
|
|
private func readFileAttachments(_ paths: [String]) -> [FileAttachment] {
|
|
var attachments: [FileAttachment] = []
|
|
let fm = FileManager.default
|
|
|
|
for rawPath in paths {
|
|
// Expand ~ and resolve path
|
|
let expanded = (rawPath as NSString).expandingTildeInPath
|
|
let resolvedPath = expanded.hasPrefix("/") ? expanded : (fm.currentDirectoryPath as NSString).appendingPathComponent(expanded)
|
|
|
|
// Check file exists
|
|
guard fm.fileExists(atPath: resolvedPath) else {
|
|
showSystemMessage("⚠️ File not found: \(rawPath)")
|
|
continue
|
|
}
|
|
|
|
// Check file size
|
|
guard let attrs = try? fm.attributesOfItem(atPath: resolvedPath),
|
|
let fileSize = attrs[.size] as? Int else {
|
|
showSystemMessage("⚠️ Cannot read file: \(rawPath)")
|
|
continue
|
|
}
|
|
|
|
if fileSize > maxFileSize {
|
|
let sizeMB = String(format: "%.1f", Double(fileSize) / 1_000_000)
|
|
showSystemMessage("⚠️ File too large (\(sizeMB) MB, max 10 MB): \(rawPath)")
|
|
continue
|
|
}
|
|
|
|
let type = FileAttachment.typeFromExtension(resolvedPath)
|
|
|
|
switch type {
|
|
case .image, .pdf:
|
|
// Read as raw data
|
|
guard let data = fm.contents(atPath: resolvedPath) else {
|
|
showSystemMessage("⚠️ Could not read file: \(rawPath)")
|
|
continue
|
|
}
|
|
attachments.append(FileAttachment(path: rawPath, type: type, data: data))
|
|
|
|
case .text:
|
|
// Read as string
|
|
guard let content = try? String(contentsOfFile: resolvedPath, encoding: .utf8) else {
|
|
showSystemMessage("⚠️ Could not read file as text: \(rawPath)")
|
|
continue
|
|
}
|
|
|
|
var finalContent = content
|
|
// Truncate large text files
|
|
if content.utf8.count > maxTextSize {
|
|
let lines = content.components(separatedBy: "\n")
|
|
if lines.count > 600 {
|
|
let head = lines.prefix(500).joined(separator: "\n")
|
|
let tail = lines.suffix(100).joined(separator: "\n")
|
|
let omitted = lines.count - 600
|
|
finalContent = head + "\n\n... [\(omitted) lines omitted] ...\n\n" + tail
|
|
}
|
|
}
|
|
|
|
attachments.append(FileAttachment(path: rawPath, type: .text, data: finalContent.data(using: .utf8)))
|
|
}
|
|
}
|
|
|
|
return attachments
|
|
}
|
|
|
|
// MARK: - MCP Command Handling
|
|
|
|
private func handleMCPCommand(args: [String]) {
|
|
let mcp = MCPService.shared
|
|
guard let sub = args.first?.lowercased() else {
|
|
showSystemMessage("Usage: /mcp on|off|status|add|remove|list")
|
|
return
|
|
}
|
|
|
|
switch sub {
|
|
case "on":
|
|
mcpEnabled = true
|
|
settings.mcpEnabled = true
|
|
mcpStatus = "MCP"
|
|
showSystemMessage("MCP enabled (\(mcp.allowedFolders.count) folder\(mcp.allowedFolders.count == 1 ? "" : "s") registered)")
|
|
|
|
case "off":
|
|
mcpEnabled = false
|
|
settings.mcpEnabled = false
|
|
mcpStatus = nil
|
|
showSystemMessage("MCP disabled")
|
|
|
|
case "add":
|
|
if args.count >= 2 {
|
|
let path = args.dropFirst().joined(separator: " ")
|
|
if let error = mcp.addFolder(path) {
|
|
showSystemMessage("MCP: \(error)")
|
|
} else {
|
|
showSystemMessage("MCP: Added folder — \(mcp.allowedFolders.count) folder\(mcp.allowedFolders.count == 1 ? "" : "s") registered")
|
|
}
|
|
} else {
|
|
showSystemMessage("Usage: /mcp add <path>")
|
|
}
|
|
|
|
case "remove":
|
|
if args.count >= 2 {
|
|
let ref = args.dropFirst().joined(separator: " ")
|
|
if let index = Int(ref) {
|
|
if mcp.removeFolder(at: index) {
|
|
showSystemMessage("MCP: Removed folder at index \(index)")
|
|
} else {
|
|
showSystemMessage("MCP: Invalid index \(index)")
|
|
}
|
|
} else {
|
|
if mcp.removeFolder(path: ref) {
|
|
showSystemMessage("MCP: Removed folder")
|
|
} else {
|
|
showSystemMessage("MCP: Folder not found: \(ref)")
|
|
}
|
|
}
|
|
} else {
|
|
showSystemMessage("Usage: /mcp remove <index|path>")
|
|
}
|
|
|
|
case "list":
|
|
if mcp.allowedFolders.isEmpty {
|
|
showSystemMessage("MCP: No folders registered. Use /mcp add <path>")
|
|
} else {
|
|
let list = mcp.allowedFolders.enumerated().map { "\($0): \($1)" }.joined(separator: "\n")
|
|
showSystemMessage("MCP folders:\n\(list)")
|
|
}
|
|
|
|
case "write":
|
|
guard args.count >= 2 else {
|
|
showSystemMessage("Usage: /mcp write on|off")
|
|
return
|
|
}
|
|
let toggle = args[1].lowercased()
|
|
if toggle == "on" {
|
|
settings.mcpCanWriteFiles = true
|
|
settings.mcpCanDeleteFiles = true
|
|
settings.mcpCanCreateDirectories = true
|
|
settings.mcpCanMoveFiles = true
|
|
showSystemMessage("MCP: All write permissions enabled (write, edit, delete, create dirs, move, copy)")
|
|
} else if toggle == "off" {
|
|
settings.mcpCanWriteFiles = false
|
|
settings.mcpCanDeleteFiles = false
|
|
settings.mcpCanCreateDirectories = false
|
|
settings.mcpCanMoveFiles = false
|
|
showSystemMessage("MCP: All write permissions disabled")
|
|
} else {
|
|
showSystemMessage("Usage: /mcp write on|off")
|
|
}
|
|
|
|
case "status":
|
|
let enabled = mcpEnabled ? "enabled" : "disabled"
|
|
let folders = mcp.allowedFolders.count
|
|
var perms: [String] = []
|
|
if settings.mcpCanWriteFiles { perms.append("write") }
|
|
if settings.mcpCanDeleteFiles { perms.append("delete") }
|
|
if settings.mcpCanCreateDirectories { perms.append("mkdir") }
|
|
if settings.mcpCanMoveFiles { perms.append("move/copy") }
|
|
let permStr = perms.isEmpty ? "read-only" : "read + \(perms.joined(separator: ", "))"
|
|
showSystemMessage("MCP: \(enabled), \(folders) folder\(folders == 1 ? "" : "s"), \(permStr), gitignore: \(settings.mcpRespectGitignore ? "on" : "off")")
|
|
|
|
default:
|
|
showSystemMessage("MCP subcommands: on, off, status, add, remove, list, write")
|
|
}
|
|
}
|
|
|
|
// MARK: - AI Response with Tool Calls
|
|
|
|
private func generateAIResponseWithTools(provider: AIProvider, modelId: String) {
|
|
let mcp = MCPService.shared
|
|
isGenerating = true
|
|
streamingTask?.cancel()
|
|
|
|
streamingTask = Task {
|
|
let startTime = Date()
|
|
var wasCancelled = false
|
|
do {
|
|
let tools = mcp.getToolSchemas()
|
|
|
|
// Apply :online suffix for OpenRouter when online mode is active
|
|
var effectiveModelId = modelId
|
|
if onlineMode && currentProvider == .openrouter && !modelId.hasSuffix(":online") {
|
|
effectiveModelId = modelId + ":online"
|
|
}
|
|
|
|
// Build initial messages as raw dictionaries for the tool loop
|
|
let folderList = mcp.allowedFolders.joined(separator: "\n - ")
|
|
var capabilities = "You can read files, list directories, and search for files."
|
|
var writeCapabilities: [String] = []
|
|
if mcp.canWriteFiles { writeCapabilities.append("write and edit files") }
|
|
if mcp.canDeleteFiles { writeCapabilities.append("delete files") }
|
|
if mcp.canCreateDirectories { writeCapabilities.append("create directories") }
|
|
if mcp.canMoveFiles { writeCapabilities.append("move and copy files") }
|
|
if !writeCapabilities.isEmpty {
|
|
capabilities += " You can also \(writeCapabilities.joined(separator: ", "))."
|
|
}
|
|
var systemContent = "You have access to the user's filesystem through tool calls. \(capabilities) The user has granted you access to these folders:\n - \(folderList)\n\nWhen the user asks about their files, use the tools proactively with the allowed paths. Always use absolute paths."
|
|
|
|
// Append the complete system prompt (default + custom)
|
|
systemContent += "\n\n---\n\n" + effectiveSystemPrompt
|
|
|
|
var messagesToSend: [Message] = memoryEnabled
|
|
? messages.filter { $0.role != .system }
|
|
: [messages.last(where: { $0.role == .user })].compactMap { $0 }
|
|
|
|
// Web search via our WebSearchService
|
|
// Append results to last user message content (matching Python oAI approach)
|
|
if onlineMode && currentProvider != .openrouter {
|
|
if let lastUserIdx = messagesToSend.lastIndex(where: { $0.role == .user }) {
|
|
Log.search.info("Running web search for tool-aware path (\(currentProvider.displayName))")
|
|
let results = await WebSearchService.shared.search(query: messagesToSend[lastUserIdx].content)
|
|
if !results.isEmpty {
|
|
let searchContext = "\n\n\(WebSearchService.shared.formatResults(results))\n\nPlease use the above web search results to help answer the user's question."
|
|
messagesToSend[lastUserIdx].content += searchContext
|
|
Log.search.info("Injected \(results.count) search results into user message")
|
|
}
|
|
}
|
|
}
|
|
|
|
let systemPrompt: [String: Any] = [
|
|
"role": "system",
|
|
"content": systemContent
|
|
]
|
|
|
|
var apiMessages: [[String: Any]] = [systemPrompt] + messagesToSend.map { msg in
|
|
["role": msg.role.rawValue, "content": msg.content]
|
|
}
|
|
|
|
let maxIterations = 10 // Increased from 5 to reduce hitting client-side limit
|
|
var finalContent = ""
|
|
var totalUsage: ChatResponse.Usage?
|
|
var hitIterationLimit = false // Track if we exited due to hitting the limit
|
|
|
|
for iteration in 0..<maxIterations {
|
|
if Task.isCancelled {
|
|
wasCancelled = true
|
|
break
|
|
}
|
|
|
|
let response = try await provider.chatWithToolMessages(
|
|
model: effectiveModelId,
|
|
messages: apiMessages,
|
|
tools: tools,
|
|
maxTokens: settings.maxTokens > 0 ? settings.maxTokens : nil,
|
|
temperature: settings.temperature > 0 ? settings.temperature : nil
|
|
)
|
|
|
|
if let usage = response.usage { totalUsage = usage }
|
|
|
|
// Check if the model wants to call tools
|
|
guard let toolCalls = response.toolCalls, !toolCalls.isEmpty else {
|
|
// No tool calls — this is the final text response
|
|
finalContent = response.content
|
|
break
|
|
}
|
|
|
|
// Show what tools the model is calling
|
|
let toolNames = toolCalls.map { $0.functionName }.joined(separator: ", ")
|
|
showSystemMessage("🔧 Calling: \(toolNames)")
|
|
|
|
// Append assistant message with tool_calls to conversation
|
|
var assistantMsg: [String: Any] = ["role": "assistant"]
|
|
if !response.content.isEmpty {
|
|
assistantMsg["content"] = response.content
|
|
}
|
|
let toolCallDicts: [[String: Any]] = toolCalls.map { tc in
|
|
[
|
|
"id": tc.id,
|
|
"type": tc.type,
|
|
"function": [
|
|
"name": tc.functionName,
|
|
"arguments": tc.arguments
|
|
]
|
|
]
|
|
}
|
|
assistantMsg["tool_calls"] = toolCallDicts
|
|
apiMessages.append(assistantMsg)
|
|
|
|
// Execute each tool and append results
|
|
for tc in toolCalls {
|
|
if Task.isCancelled {
|
|
wasCancelled = true
|
|
break
|
|
}
|
|
|
|
let result = mcp.executeTool(name: tc.functionName, arguments: tc.arguments)
|
|
let resultJSON: String
|
|
if let data = try? JSONSerialization.data(withJSONObject: result),
|
|
let str = String(data: data, encoding: .utf8) {
|
|
resultJSON = str
|
|
} else {
|
|
resultJSON = "{\"error\": \"Failed to serialize result\"}"
|
|
}
|
|
|
|
apiMessages.append([
|
|
"role": "tool",
|
|
"tool_call_id": tc.id,
|
|
"name": tc.functionName,
|
|
"content": resultJSON
|
|
])
|
|
}
|
|
|
|
// If this was the last iteration, note it
|
|
if iteration == maxIterations - 1 {
|
|
hitIterationLimit = true // We're exiting with pending tool calls
|
|
finalContent = response.content.isEmpty
|
|
? "[Tool loop reached maximum iterations]"
|
|
: response.content
|
|
}
|
|
}
|
|
|
|
// Check for cancellation one more time after loop exits
|
|
if Task.isCancelled {
|
|
wasCancelled = true
|
|
}
|
|
|
|
// Display the final response as an assistant message
|
|
let responseTime = Date().timeIntervalSince(startTime)
|
|
let assistantMessage = Message(
|
|
role: .assistant,
|
|
content: finalContent,
|
|
tokens: totalUsage?.completionTokens,
|
|
cost: nil,
|
|
timestamp: Date(),
|
|
attachments: nil,
|
|
responseTime: responseTime,
|
|
wasInterrupted: wasCancelled,
|
|
modelId: modelId
|
|
)
|
|
messages.append(assistantMessage)
|
|
|
|
// Calculate cost
|
|
if let usage = totalUsage, let model = selectedModel {
|
|
let cost = (Double(usage.promptTokens) * model.pricing.prompt / 1_000_000) +
|
|
(Double(usage.completionTokens) * model.pricing.completion / 1_000_000)
|
|
if let index = messages.lastIndex(where: { $0.id == assistantMessage.id }) {
|
|
messages[index].cost = cost
|
|
}
|
|
sessionStats.addMessage(
|
|
inputTokens: usage.promptTokens,
|
|
outputTokens: usage.completionTokens,
|
|
cost: cost
|
|
)
|
|
}
|
|
|
|
isGenerating = false
|
|
streamingTask = nil
|
|
|
|
// If we hit the iteration limit and weren't cancelled, start auto-continue
|
|
if hitIterationLimit && !wasCancelled {
|
|
startAutoContinue()
|
|
}
|
|
|
|
} catch {
|
|
let responseTime = Date().timeIntervalSince(startTime)
|
|
|
|
// Check if this was a cancellation
|
|
let isCancellation = Task.isCancelled || wasCancelled || error is CancellationError
|
|
|
|
if isCancellation {
|
|
// Create an interrupted message
|
|
let assistantMessage = Message(
|
|
role: .assistant,
|
|
content: "",
|
|
timestamp: Date(),
|
|
responseTime: responseTime,
|
|
wasInterrupted: true,
|
|
modelId: modelId
|
|
)
|
|
messages.append(assistantMessage)
|
|
} else {
|
|
Log.api.error("Tool generation failed: \(error.localizedDescription)")
|
|
showSystemMessage("❌ \(friendlyErrorMessage(from: error))")
|
|
}
|
|
|
|
isGenerating = false
|
|
streamingTask = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
private func showSystemMessage(_ text: String) {
|
|
let message = Message(
|
|
role: .system,
|
|
content: text,
|
|
tokens: nil,
|
|
cost: nil,
|
|
timestamp: Date(),
|
|
attachments: nil
|
|
)
|
|
messages.append(message)
|
|
}
|
|
|
|
// MARK: - Error Helpers
|
|
|
|
private func friendlyErrorMessage(from error: Error) -> String {
|
|
let desc = error.localizedDescription
|
|
|
|
// Network connectivity
|
|
if let urlError = error as? URLError {
|
|
switch urlError.code {
|
|
case .notConnectedToInternet, .networkConnectionLost:
|
|
return "Unable to reach the server. Check your internet connection."
|
|
case .timedOut:
|
|
return "Request timed out. Try a shorter message or different model."
|
|
case .cannotFindHost, .cannotConnectToHost:
|
|
return "Cannot connect to the server. Check your network or provider URL."
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// HTTP status codes in error messages
|
|
if desc.contains("401") || desc.contains("403") || desc.lowercased().contains("unauthorized") || desc.lowercased().contains("invalid.*key") {
|
|
return "Invalid API key. Update it in Settings (\u{2318},)."
|
|
}
|
|
if desc.contains("429") || desc.lowercased().contains("rate limit") {
|
|
return "Rate limited. Wait a moment and try again."
|
|
}
|
|
if desc.contains("404") || desc.lowercased().contains("model not found") || desc.lowercased().contains("not available") {
|
|
return "Model not available. Select a different model (\u{2318}M)."
|
|
}
|
|
if desc.contains("500") || desc.contains("502") || desc.contains("503") {
|
|
return "Server error. The provider may be experiencing issues. Try again shortly."
|
|
}
|
|
|
|
// Timeout patterns
|
|
if desc.lowercased().contains("timed out") || desc.lowercased().contains("timeout") {
|
|
return "Request timed out. Try a shorter message or different model."
|
|
}
|
|
|
|
// Fallback
|
|
return desc
|
|
}
|
|
|
|
// MARK: - Helpers
|
|
|
|
private func showModelInfo(_ model: ModelInfo) {
|
|
modelInfoTarget = model
|
|
}
|
|
|
|
private func exportConversation(format: String, filename: String) {
|
|
let chatMessages = messages.filter { $0.role != .system }
|
|
guard !chatMessages.isEmpty else {
|
|
showSystemMessage("Nothing to export — no messages")
|
|
return
|
|
}
|
|
|
|
let content: String
|
|
switch format {
|
|
case "md", "markdown":
|
|
content = chatMessages.map { msg in
|
|
let header = msg.role == .user ? "**User**" : "**Assistant**"
|
|
return "\(header)\n\n\(msg.content)"
|
|
}.joined(separator: "\n\n---\n\n")
|
|
case "json":
|
|
let dicts = chatMessages.map { msg -> [String: String] in
|
|
["role": msg.role.rawValue, "content": msg.content]
|
|
}
|
|
if let data = try? JSONSerialization.data(withJSONObject: dicts, options: .prettyPrinted),
|
|
let json = String(data: data, encoding: .utf8) {
|
|
content = json
|
|
} else {
|
|
showSystemMessage("Failed to encode JSON")
|
|
return
|
|
}
|
|
default:
|
|
showSystemMessage("Unsupported format: \(format). Use md or json.")
|
|
return
|
|
}
|
|
|
|
// Write to Downloads folder
|
|
let downloads = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask).first
|
|
?? FileManager.default.temporaryDirectory
|
|
let fileURL = downloads.appendingPathComponent(filename)
|
|
|
|
do {
|
|
try content.write(to: fileURL, atomically: true, encoding: .utf8)
|
|
showSystemMessage("Exported to \(fileURL.path)")
|
|
} catch {
|
|
showSystemMessage("Export failed: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
|
|
// MARK: - Auto-Save & Background Summarization
|
|
|
|
/// Summarize the current conversation in the background (hidden from user)
|
|
/// Returns a 3-5 word title, or nil on failure
|
|
func summarizeConversationInBackground() async -> String? {
|
|
// Need at least a few messages to summarize
|
|
let chatMessages = messages.filter { $0.role == .user || $0.role == .assistant }
|
|
guard chatMessages.count >= 2 else {
|
|
return nil
|
|
}
|
|
|
|
// Get current provider
|
|
guard let provider = providerRegistry.getCurrentProvider() else {
|
|
Log.ui.warning("Cannot summarize: no provider configured")
|
|
return nil
|
|
}
|
|
|
|
guard let modelId = selectedModel?.id else {
|
|
Log.ui.warning("Cannot summarize: no model selected")
|
|
return nil
|
|
}
|
|
|
|
Log.ui.info("Background summarization: model=\(modelId), messages=\(chatMessages.count)")
|
|
|
|
do {
|
|
// Simplified summarization prompt
|
|
let summaryPrompt = "Create a brief 3-5 word title for this conversation. Just the title, nothing else."
|
|
|
|
// Build chat request with just the last few messages for context
|
|
let recentMessages = Array(chatMessages.suffix(10)) // Last 10 messages for context
|
|
var summaryMessages = recentMessages.map { msg in
|
|
Message(role: msg.role, content: msg.content, tokens: nil, cost: nil, timestamp: Date())
|
|
}
|
|
|
|
// Add the summary request as a user message
|
|
summaryMessages.append(Message(
|
|
role: .user,
|
|
content: summaryPrompt,
|
|
tokens: nil,
|
|
cost: nil,
|
|
timestamp: Date()
|
|
))
|
|
|
|
let chatRequest = ChatRequest(
|
|
messages: summaryMessages,
|
|
model: modelId,
|
|
stream: false, // Non-streaming for background request
|
|
maxTokens: 100, // Increased for better response
|
|
temperature: 0.3, // Lower for more focused response
|
|
topP: nil,
|
|
systemPrompt: "You are a helpful assistant that creates concise conversation titles.",
|
|
tools: nil,
|
|
onlineMode: false,
|
|
imageGeneration: false
|
|
)
|
|
|
|
// Make the request (hidden from user)
|
|
let response = try await provider.chat(request: chatRequest)
|
|
|
|
Log.ui.info("Raw summary response: '\(response.content)'")
|
|
|
|
// Extract and clean the summary
|
|
var summary = response.content
|
|
.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
.replacingOccurrences(of: "\"", with: "")
|
|
.replacingOccurrences(of: "'", with: "")
|
|
.replacingOccurrences(of: "Title:", with: "", options: .caseInsensitive)
|
|
.replacingOccurrences(of: "title:", with: "")
|
|
.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
|
|
// Take only first line if multi-line response
|
|
if let firstLine = summary.components(separatedBy: .newlines).first {
|
|
summary = firstLine.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
|
|
// Limit length
|
|
summary = String(summary.prefix(60))
|
|
|
|
Log.ui.info("Cleaned summary: '\(summary)'")
|
|
|
|
// Return nil if empty
|
|
guard !summary.isEmpty else {
|
|
Log.ui.warning("Summary is empty after cleaning")
|
|
return nil
|
|
}
|
|
|
|
return summary
|
|
|
|
} catch {
|
|
Log.ui.error("Background summarization failed: \(error.localizedDescription)")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
/// Check if conversation should be auto-saved based on criteria
|
|
func shouldAutoSave() -> Bool {
|
|
// Check if auto-save is enabled
|
|
guard settings.syncEnabled && settings.syncAutoSave else {
|
|
return false
|
|
}
|
|
|
|
// Check if sync is configured
|
|
guard settings.syncConfigured else {
|
|
return false
|
|
}
|
|
|
|
// Check if repository is cloned
|
|
guard GitSyncService.shared.syncStatus.isCloned else {
|
|
return false
|
|
}
|
|
|
|
// Check minimum message count
|
|
let chatMessages = messages.filter { $0.role == .user || $0.role == .assistant }
|
|
guard chatMessages.count >= settings.syncAutoSaveMinMessages else {
|
|
return false
|
|
}
|
|
|
|
// Check if already auto-saved this conversation
|
|
// (prevent duplicate saves)
|
|
if let lastSavedId = settings.syncLastAutoSaveConversationId {
|
|
// Create a hash of current conversation to detect if it's the same one
|
|
let currentHash = chatMessages.map { $0.content }.joined()
|
|
if lastSavedId == currentHash {
|
|
return false // Already saved this exact conversation
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
/// Auto-save the current conversation with background summarization
|
|
func autoSaveConversation() async {
|
|
guard shouldAutoSave() else {
|
|
return
|
|
}
|
|
|
|
Log.ui.info("Auto-saving conversation...")
|
|
|
|
// Get summary in background (hidden from user)
|
|
let summary = await summarizeConversationInBackground()
|
|
|
|
// Use summary as name, or fallback to timestamp
|
|
let conversationName: String
|
|
if let summary = summary, !summary.isEmpty {
|
|
conversationName = summary
|
|
} else {
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "yyyy-MM-dd HH:mm"
|
|
conversationName = "Conversation - \(formatter.string(from: Date()))"
|
|
}
|
|
|
|
// Save the conversation
|
|
do {
|
|
let chatMessages = messages.filter { $0.role == .user || $0.role == .assistant }
|
|
let conversation = try DatabaseService.shared.saveConversation(
|
|
name: conversationName,
|
|
messages: chatMessages
|
|
)
|
|
|
|
Log.ui.info("Auto-saved conversation: \(conversationName)")
|
|
|
|
// Mark as saved to prevent duplicate saves
|
|
let conversationHash = chatMessages.map { $0.content }.joined()
|
|
settings.syncLastAutoSaveConversationId = conversationHash
|
|
|
|
// Trigger auto-sync (export + push)
|
|
Task {
|
|
await performAutoSync()
|
|
}
|
|
|
|
} catch {
|
|
Log.ui.error("Auto-save failed: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
|
|
/// Perform auto-sync: export + push to git (debounced)
|
|
private func performAutoSync() async {
|
|
await GitSyncService.shared.autoSync()
|
|
}
|
|
|
|
// MARK: - Smart Triggers
|
|
|
|
/// Update conversation tracking times
|
|
func updateConversationTracking() {
|
|
let now = Date()
|
|
|
|
if conversationStartTime == nil {
|
|
conversationStartTime = now
|
|
}
|
|
|
|
lastMessageTime = now
|
|
|
|
// Restart idle timer if enabled
|
|
if settings.syncAutoSaveOnIdle {
|
|
startIdleTimer()
|
|
}
|
|
}
|
|
|
|
/// Start or restart the idle timer
|
|
private func startIdleTimer() {
|
|
// Cancel existing timer
|
|
idleCheckTimer?.invalidate()
|
|
|
|
let idleMinutes = settings.syncAutoSaveIdleMinutes
|
|
let idleSeconds = TimeInterval(idleMinutes * 60)
|
|
|
|
// Schedule new timer
|
|
idleCheckTimer = Timer.scheduledTimer(withTimeInterval: idleSeconds, repeats: false) { [weak self] _ in
|
|
Task { @MainActor [weak self] in
|
|
await self?.onIdleTimeout()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Called when idle timeout is reached
|
|
private func onIdleTimeout() async {
|
|
guard settings.syncAutoSaveOnIdle else { return }
|
|
|
|
Log.ui.info("Idle timeout reached - triggering auto-save")
|
|
await autoSaveConversation()
|
|
}
|
|
|
|
/// Detect goodbye phrases in user message
|
|
func detectGoodbyePhrase(in text: String) -> Bool {
|
|
let lowercased = text.lowercased()
|
|
let goodbyePhrases = [
|
|
"bye", "goodbye", "bye bye",
|
|
"thanks", "thank you", "thx", "ty",
|
|
"that's all", "thats all", "that'll be all",
|
|
"done", "i'm done", "we're done",
|
|
"see you", "see ya", "catch you later",
|
|
"have a good", "have a nice"
|
|
]
|
|
|
|
return goodbyePhrases.contains { phrase in
|
|
// Check for whole word match (not substring)
|
|
let pattern = "\\b\(NSRegularExpression.escapedPattern(for: phrase))\\b"
|
|
return lowercased.range(of: pattern, options: .regularExpression) != nil
|
|
}
|
|
}
|
|
|
|
/// Trigger auto-save when user switches models
|
|
func onModelSwitch(from oldModel: ModelInfo?, to newModel: ModelInfo?) async {
|
|
guard settings.syncAutoSaveOnModelSwitch else { return }
|
|
guard oldModel != nil else { return } // Don't save on first model selection
|
|
|
|
Log.ui.info("Model switch detected - triggering auto-save")
|
|
await autoSaveConversation()
|
|
}
|
|
|
|
/// Trigger auto-save on app quit
|
|
func onAppWillTerminate() async {
|
|
guard settings.syncAutoSaveOnAppQuit else { return }
|
|
|
|
Log.ui.info("App quit detected - triggering auto-save")
|
|
await autoSaveConversation()
|
|
}
|
|
|
|
/// Check and trigger auto-save after user message
|
|
func checkAutoSaveTriggersAfterMessage(_ text: String) async {
|
|
// Update tracking
|
|
updateConversationTracking()
|
|
|
|
// Check for goodbye phrase
|
|
if detectGoodbyePhrase(in: text) {
|
|
Log.ui.info("Goodbye phrase detected - triggering auto-save")
|
|
// Wait a bit to see if user continues
|
|
try? await Task.sleep(for: .seconds(30))
|
|
|
|
// Check if they sent another message in the meantime
|
|
if let lastTime = lastMessageTime, Date().timeIntervalSince(lastTime) < 25 {
|
|
Log.ui.info("User continued chatting - skipping goodbye auto-save")
|
|
return
|
|
}
|
|
|
|
await autoSaveConversation()
|
|
}
|
|
}
|
|
}
|