AI Commands

#[tauri::command]
pub async fn get_ai_settings(
    app: AppHandle,
) -> Result<AISettings, String>

interface AISettings {
  enabled: boolean;        // AI enhancement enabled/disabled
  provider: string;        // "openai", "gemini", or "custom"
  model: string;           // Model ID (e.g., "gpt-5-nano")
  hasApiKey: boolean;      // API key configured
}

const settings = await invoke<AISettings>('get_ai_settings');

if (settings.enabled && settings.hasApiKey) {
  console.log(`AI enabled with ${settings.provider}/${settings.model}`);
} else if (settings.enabled && !settings.hasApiKey) {
  console.warn('AI enabled but no API key configured');
}

#[tauri::command]
pub async fn get_ai_settings_for_provider(
    provider: String,
    app: AppHandle,
) -> Result<AISettings, String>

const geminiSettings = await invoke<AISettings>('get_ai_settings_for_provider', {
  provider: 'gemini'
});

#[tauri::command]
pub async fn update_ai_settings(
    enabled: bool,
    provider: String,
    model: String,
    app: AppHandle,
) -> Result<(), String>

await invoke('update_ai_settings', {
  enabled: true,
  provider: 'openai',
  model: 'gpt-5-nano'
});

#[tauri::command]
pub async fn disable_ai_enhancement(
    app: AppHandle,
) -> Result<(), String>

await invoke('disable_ai_enhancement');

#[tauri::command]
pub async fn cache_ai_api_key(
    _app: AppHandle,
    args: CacheApiKeyArgs,
) -> Result<(), String>

// Frontend stores key in Stronghold, then caches for backend
await invoke('cache_ai_api_key', {
  provider: 'openai',
  apiKey: 'sk-...' // From secure storage
});

#[tauri::command]
pub async fn validate_and_cache_api_key(
    app: AppHandle,
    args: ValidateAndCacheApiKeyArgs,
) -> Result<(), String>

// Validate OpenAI key
try {
  await invoke('validate_and_cache_api_key', {
    provider: 'openai',
    apiKey: 'sk-...',
    model: 'gpt-5-nano'
  });
  console.log('API key validated successfully');
} catch (error) {
  console.error('Invalid API key:', error);
}

// Validate custom OpenAI-compatible endpoint
await invoke('validate_and_cache_api_key', {
  provider: 'custom',
  baseUrl: 'http://localhost:1234/v1',
  model: 'local-model',
  noAuth: true // No API key needed for local LLM
});

#[tauri::command]
pub async fn test_openai_endpoint(
    base_url: String,
    model: String,
    api_key: Option<String>,
    no_auth: Option<bool>,
) -> Result<(), String>

// Test local LLM endpoint
try {
  await invoke('test_openai_endpoint', {
    baseUrl: 'http://localhost:1234/v1',
    model: 'llama-3.1',
    noAuth: true
  });
  console.log('Endpoint is valid');
} catch (error) {
  console.error('Endpoint test failed:', error);
}

#[tauri::command]
pub async fn clear_ai_api_key_cache(
    _app: AppHandle,
    provider: String,
) -> Result<(), String>

await invoke('clear_ai_api_key_cache', { provider: 'openai' });

#[tauri::command]
pub async fn enhance_transcription(
    text: String,
    app: AppHandle,
) -> Result<String, String>

const rawText = "hello world this is a test";
const enhanced = await invoke<string>('enhance_transcription', {
  text: rawText
});

console.log('Enhanced:', enhanced);
// Output: "Hello world, this is a test."

#[tauri::command]
pub async fn get_enhancement_options(
    app: AppHandle,
) -> Result<EnhancementOptions, String>

interface EnhancementOptions {
  preset: 'professional' | 'casual' | 'technical' | 'creative';
  custom_instructions?: string;
}

const options = await invoke<EnhancementOptions>('get_enhancement_options');
console.log('Using preset:', options.preset);

#[tauri::command]
pub async fn update_enhancement_options(
    options: EnhancementOptions,
    app: AppHandle,
) -> Result<(), String>

await invoke('update_enhancement_options', {
  options: {
    preset: 'technical',
    custom_instructions: 'Format code snippets with markdown'
  }
});

#[tauri::command]
pub async fn list_provider_models(
    provider: String,
    _app: AppHandle,
) -> Result<Vec<ProviderModel>, String>

interface ProviderModel {
  id: string;              // Model ID (e.g., "gpt-5-nano")
  name: string;            // Display name (e.g., "GPT-5 Nano")
  recommended: boolean;    // Official recommendation
}

const models = await invoke<ProviderModel[]>('list_provider_models', {
  provider: 'openai'
});

const recommended = models.find(m => m.recommended);
console.log('Recommended:', recommended.name);

#[tauri::command]
pub async fn set_openai_config(
    app: AppHandle,
    args: SetOpenAIConfigArgs,
) -> Result<(), String>

await invoke('set_openai_config', {
  baseUrl: 'http://localhost:1234/v1',
  noAuth: true
});

#[tauri::command]
pub async fn get_openai_config(
    app: AppHandle,
) -> Result<OpenAIConfig, String>

interface OpenAIConfig {
  baseUrl: string;
  noAuth: boolean;
}

const config = await invoke<OpenAIConfig>('get_openai_config');
console.log('Endpoint:', config.baseUrl);