feat(ai): add AI client with multi-provider chat support

Add an AI client module that integrates with OpenAI-compatible API
providers (OpenAI, Perplexity, and custom endpoints) to provide
AI-assisted chat within CProof. Users can start sessions with /ai start,
send prompts, receive responses in a dedicated AI window, switch between
providers and models, and manage API keys — all with tab-completion.

Providers are configured via /ai set commands with per-provider API keys,
endpoints, default models, and custom settings. Two default providers
(openai, perplexity) are seeded on first use. Provider state persists in
[ai/<name>] sections of the preferences keyfile with automatic migration
from the previous flat-key format.

The /ai command integrates into the existing command system with 8
subcommands covering provider management, session lifecycle, model
fetching, and conversation clearing. Autocomplete uses the standard
flat prefix-matching chain for reliable tab-completion at every nesting
level. A new ProfAiWin window type is added to the window system.

Architecture:

Async design: HTTP requests run on a background thread (pthread) to avoid blocking the ncurses UI loop; results are displayed on the main thread via direct function calls
Thread safety: AIProvider and AISession use atomic ref-counting and mutex-protected session state; the request thread snapshots all session data before making the HTTP call
Window validation: wins_ai_exists() prevents use-after-free when the user closes the AI window during an in-flight HTTP request (~60s)
Privacy: store:false is sent with every request to prevent providers from persisting conversations or using them for training
Response size limit: 10MB cap with immediate curl abort via CURL_WRITEFUNC_ERROR to prevent OOM
JSON parsing uses unified helpers for both chat responses and error
envelopes with consistent escape decoding. The response parser tries
Perplexity /v1/responses "text" field first, then falls back to OpenAI
"content". Error parsing extracts provider error.message from the
standard envelope format. Model parsing handles multiple API response
formats (OpenAI list, Perplexity, array) including edge cases.

Tests include 470+ lines of unit tests covering provider management,
session lifecycle, JSON parsing (multiple formats), autocomplete cycling,
and error handling, plus functional tests for /ai command dispatch.
A stub_ai.c module isolates unit tests from UI dependencies.

src/command/cmd_funcs.c

@@ -81,7 +81,6 @@
 #include "tools/bookmark_ignore.h"
 #include "tools/editor.h"
 #include "plugins/plugins.h"
-#include "ui/inputwin.h"
 #include "ui/ui.h"
 #include "ui/window_list.h"
 #include "xmpp/avatar.h"
@@ -117,6 +116,8 @@
 #include "tools/clipboard.h"
 #endif
 
+#include "ai/ai_client.h"
+
 #ifdef HAVE_PYTHON
 #include "plugins/python_plugins.h"
 #endif
@@ -8466,7 +8467,7 @@ _cmd_execute_default(ProfWin* window, const char* inp)
     }
 
     // handle non commands in non chat or plugin windows
-    if (window->type != WIN_CHAT && window->type != WIN_MUC && window->type != WIN_PRIVATE && window->type != WIN_PLUGIN && window->type != WIN_XML) {
+    if (window->type != WIN_CHAT && window->type != WIN_MUC && window->type != WIN_PRIVATE && window->type != WIN_PLUGIN && window->type != WIN_XML && window->type != WIN_AI) {
         cons_show("Unknown command: %s", inp);
         cons_alert(NULL);
         return TRUE;
@@ -8512,6 +8513,12 @@ _cmd_execute_default(ProfWin* window, const char* inp)
         connection_send_stanza(inp);
         break;
     }
+    case WIN_AI:
+    {
+        ProfAiWin* aiwin = (ProfAiWin*)window;
+        cl_ev_send_ai_msg(aiwin, inp, connection_create_stanza_id());
+        break;
+    }
     default:
         break;
     }
@@ -10780,6 +10787,416 @@ cmd_vcard_save(ProfWin* window, const char* const command, gchar** args)
     return TRUE;
 }
 
+gboolean
+cmd_ai(ProfWin* window, const char* const command, gchar** args)
+{
+    if (args[0] == NULL) {
+        // Display current AI settings
+        cons_show("AI Chat - OpenAI-compatible API client");
+        cons_show("");
+
+        // List configured providers with full details
+        GList* providers = ai_list_providers();
+        cons_show("Configured providers:");
+        for (GList* curr = providers; curr; curr = g_list_next(curr)) {
+            AIProvider* provider = curr->data;
+            auto_gchar gchar* key = ai_get_provider_key(provider->name);
+            const gchar* default_model = ai_get_provider_default_model(provider->name);
+            cons_show("  %s", provider->name);
+            cons_show("    URL: %s", provider->api_url);
+            cons_show("    Key: %s", key ? "configured" : "NOT configured");
+            if (default_model) {
+                cons_show("    Default model: %s", default_model);
+            }
+            if (provider->models && g_list_length(provider->models) > 0) {
+                cons_show("    Cached models: %d", g_list_length(provider->models));
+            }
+            cons_show("");
+        }
+        g_list_free(providers);
+
+        cons_show("Use '/ai start' to begin a chat (uses default provider/model).");
+        cons_show("Use '/ai models <provider>' to fetch available models.");
+        return TRUE;
+    }
+
+    cons_bad_cmd_usage(command);
+    return TRUE;
+}
+
+gboolean
+cmd_ai_set(ProfWin* window, const char* const command, gchar** args)
+{
+    if (args[1] == NULL) {
+        cons_bad_cmd_usage(command);
+        return TRUE;
+    }
+
+    if (g_strcmp0(args[1], "provider") == 0) {
+        // /ai set provider <name> <url>
+        if (g_strv_length(args) < 4) {
+            cons_bad_cmd_usage(command);
+            return TRUE;
+        }
+        if (ai_add_provider(args[2], args[3])) {
+            cons_show("Provider '%s' configured with URL: %s", args[2], args[3]);
+        } else {
+            cons_show_error("Failed to configure provider '%s'.", args[2]);
+        }
+        cons_show("");
+        return TRUE;
+    } else if (g_strcmp0(args[1], "token") == 0) {
+        // /ai set token <provider> <token>
+        if (g_strv_length(args) < 4) {
+            cons_bad_cmd_usage(command);
+            return TRUE;
+        }
+        ai_set_provider_key(args[2], args[3]);
+        cons_show("API token set for provider: %s", args[2]);
+        cons_show("");
+        return TRUE;
+    } else if (g_strcmp0(args[1], "default-model") == 0) {
+        // /ai set default-model <provider> <model>
+        if (g_strv_length(args) < 4) {
+            cons_bad_cmd_usage(command);
+            return TRUE;
+        }
+        ai_set_provider_default_model(args[2], args[3]);
+        cons_show("Default model for provider '%s' set to: %s", args[2], args[3]);
+        cons_show("");
+        return TRUE;
+    } else if (g_strcmp0(args[1], "custom") == 0) {
+        // /ai set custom <provider> <setting> <value>
+        if (g_strv_length(args) < 5) {
+            cons_bad_cmd_usage(command);
+            return TRUE;
+        }
+        ai_set_provider_setting(args[2], args[3], args[4]);
+        cons_show("Setting '%s' for provider '%s' set to: %s", args[3], args[2], args[4]);
+        cons_show("");
+        return TRUE;
+    }
+
+    cons_bad_cmd_usage(command);
+    return TRUE;
+}
+
+gboolean
+cmd_ai_remove(ProfWin* window, const char* const command, gchar** args)
+{
+    // /ai remove provider <name>
+    if (g_strcmp0(args[1], "provider") != 0) {
+        cons_bad_cmd_usage(command);
+        return TRUE;
+    }
+
+    if (g_strv_length(args) < 3) {
+        cons_bad_cmd_usage(command);
+        return TRUE;
+    }
+
+    if (ai_remove_provider(args[2])) {
+        cons_show("Provider '%s' removed.", args[2]);
+    } else {
+        cons_show("Provider '%s' not found.", args[2]);
+    }
+    cons_show("");
+    return TRUE;
+}
+
+gboolean
+cmd_ai_start(ProfWin* window, const char* const command, gchar** args)
+{
+    // /ai start [<provider>] [<model>]
+    // Space-separated, no slash syntax
+    const gchar* provider_name = NULL;
+    const gchar* model = NULL;
+
+    if (g_strv_length(args) >= 2) {
+        provider_name = args[1];
+    }
+    if (g_strv_length(args) >= 3) {
+        model = args[2];
+    }
+
+    // Resolve defaults
+    auto_gchar gchar* owned_provider_name = NULL;
+    if (!provider_name) {
+        // Use default provider from preferences
+        auto_gchar gchar* default_provider = prefs_get_string(PREF_AI_PROVIDER);
+        if (default_provider && strlen(default_provider) > 0) {
+            provider_name = default_provider;
+        }
+    }
+    if (!provider_name) {
+        provider_name = "openai"; // Fallback
+    }
+
+    AIProvider* provider = ai_get_provider(provider_name);
+    if (!provider) {
+        cons_show_error("Provider '%s' not found. Use '/ai set provider %s <url>' to add it.",
+                        provider_name, provider_name);
+        return TRUE;
+    }
+
+    // Get model: explicit > provider default > hardcoded fallback
+    if (!model) {
+        model = ai_get_provider_default_model(provider_name);
+    }
+
+    if (!model) {
+        cons_show_error("No model specified and no default model set for provider '%s'.", provider_name);
+        cons_show("Use '/ai set default-model %s <model>'.", provider_name);
+        return TRUE;
+    }
+
+    // Check for API key
+    gchar* api_key = ai_get_provider_key(provider_name);
+    if (!api_key || strlen(api_key) == 0) {
+        cons_show_error("No API key set for provider '%s'. Use '/ai set token %s <key>' first.",
+                        provider_name, provider_name);
+        g_free(api_key);
+        return TRUE;
+    }
+    g_free(api_key);
+
+    // Create new AI session
+    AISession* session = ai_session_create(provider_name, model);
+    if (!session) {
+        log_error("[AI-CMD] Failed to create AI session");
+        cons_show_error("Failed to create AI session for %s/%s.", provider_name, model);
+        return TRUE;
+    }
+    log_debug("[AI-CMD] AI session created successfully");
+
+    // Create AI chat window
+    log_debug("[AI-CMD] Calling wins_new_ai()...");
+    ProfWin* ai_win = wins_new_ai(session);
+    if (!ai_win) {
+        log_error("[AI-CMD] wins_new_ai() returned NULL");
+        cons_show_error("Failed to create AI chat window.");
+        ai_session_unref(session);
+        return TRUE;
+    }
+    log_debug("[AI-CMD] wins_new_ai() returned successfully, window type: %d", ai_win->type);
+
+    // Add welcome message to the AI window
+    log_debug("[AI-CMD] Adding welcome messages...");
+    win_println(ai_win, THEME_DEFAULT, "-", "AI Chat: %s/%s", provider_name, model);
+    win_println(ai_win, THEME_DEFAULT, "-", "Type your message and press Enter to start a conversation.");
+    log_debug("[AI-CMD] Welcome messages added");
+
+    // Focus the new window
+    log_debug("[AI-CMD] Calling ui_focus_win()...");
+    ui_focus_win(ai_win);
+    log_debug("[AI-CMD] ui_focus_win() returned");
+
+    cons_show("Started AI chat: %s/%s", provider_name, model);
+    cons_show("");
+    log_debug("[AI-CMD] AI start command completed");
+
+    return TRUE;
+}
+
+gboolean
+cmd_ai_model(ProfWin* window, const char* const command, gchar** args)
+{
+    // /ai model <model>
+    if (args[1] == NULL) {
+        cons_bad_cmd_usage(command);
+        return TRUE;
+    }
+
+    const gchar* model = args[1];
+
+    // Must be in an AI window to use this command
+    if (!window || window->type != WIN_AI) {
+        cons_show_error("Must be in an AI chat window to use this command.");
+        return TRUE;
+    }
+    ProfAiWin* aiwin = (ProfAiWin*)window;
+
+    assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+
+    if (!aiwin->session) {
+        cons_show("No active session in this chat window.");
+        return TRUE;
+    }
+
+    ai_session_set_model(aiwin->session, model);
+    cons_show("Session model changed to: %s", model);
+    cons_show("");
+    return TRUE;
+}
+
+gboolean
+cmd_ai_switch(ProfWin* window, const char* const command, gchar** args)
+{
+    // /ai switch <provider> [<model>] - Change provider and optionally model
+    // /ai switch <model> - Change model only (keeps current provider)
+    // Modifies the existing session's provider and model instead of recreating it
+    if (g_strv_length(args) < 2) {
+        cons_bad_cmd_usage(command);
+        return TRUE;
+    }
+
+    // Must be in an AI window to use this command
+    if (!window || window->type != WIN_AI) {
+        cons_show_error("Must be in an AI chat window to use this command.");
+        return TRUE;
+    }
+    ProfAiWin* aiwin = (ProfAiWin*)window;
+
+    assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+
+    if (!aiwin->session) {
+        cons_show("No active session in this chat window.");
+        return TRUE;
+    }
+
+    const gchar* arg1 = args[1];
+    const gchar* arg2 = (g_strv_length(args) >= 3) ? args[2] : NULL;
+
+    const gchar* provider_name;
+    const gchar* model;
+
+    // Check if arg1 is a known provider
+    AIProvider* provider = ai_get_provider(arg1);
+    if (provider) {
+        // arg1 is a provider name
+        provider_name = arg1;
+
+        // Get model: arg2 > provider default > error
+        if (arg2) {
+            model = arg2;
+        } else {
+            model = ai_get_provider_default_model(provider_name);
+        }
+        if (!model) {
+            cons_show_error("No model specified and no default model set for provider '%s'.", provider_name);
+            cons_show("Use '/ai set default-model %s <model>' or '/ai switch %s <model>'.", provider_name, provider_name);
+            return TRUE;
+        }
+    } else {
+        // arg1 is a model name, keep current provider
+        provider_name = aiwin->session->provider_name;
+        if (!provider_name) {
+            cons_show_error("Session has no provider name.");
+            return TRUE;
+        }
+        model = arg1;
+    }
+
+    // Check for API key
+    auto_gchar gchar* api_key = ai_get_provider_key(provider_name);
+    if (!api_key || strlen(api_key) == 0) {
+        cons_show_error("No API key set for provider '%s'. Use '/ai set token %s <key>' first.",
+                        provider_name, provider_name);
+        return TRUE;
+    }
+
+    // Atomically switch session provider, model, and API key (thread-safe)
+    ai_session_switch(aiwin->session, provider_name, model, g_steal_pointer(&api_key));
+
+    // Update window title
+    win_println((ProfWin*)aiwin, THEME_DEFAULT, "-", "AI Chat: %s/%s", provider_name, model);
+
+    cons_show("Switched to %s/%s", provider_name, model);
+    cons_show("");
+
+    return TRUE;
+}
+
+gboolean
+cmd_ai_models(ProfWin* window, const char* const command, gchar** args)
+{
+    // /ai models <provider> [--cached]
+    // Default: fetch fresh models from API
+    // --cached: display cached models (if available)
+    if (args[1] == NULL) {
+        cons_bad_cmd_usage(command);
+        return TRUE;
+    }
+
+    const gchar* provider_name = args[1];
+    gboolean use_cached = (g_strv_length(args) >= 3) && (g_strcmp0(args[2], "--cached") == 0);
+
+    AIProvider* provider = ai_get_provider(provider_name);
+    if (!provider) {
+        cons_show_error("Provider '%s' not found.", provider_name);
+        return TRUE;
+    }
+
+    if (use_cached) {
+        // Display cached models (if available)
+        if (!provider->models) {
+            cons_show("No cached models for provider '%s'. Use '/ai models %s' to fetch from API.", provider_name, provider_name);
+            return TRUE;
+        }
+        cons_show("Cached models for provider '%s':", provider_name);
+        GList* curr = provider->models;
+        while (curr) {
+            cons_show("  %s", (gchar*)curr->data);
+            curr = g_list_next(curr);
+        }
+        cons_show("");
+        cons_show("Use '/ai models %s' to fetch fresh models from the API.", provider_name);
+    } else {
+        // Default: fetch fresh models from API
+        ai_fetch_models(provider_name, window);
+    }
+
+    return TRUE;
+}
+
+gboolean
+cmd_ai_clear(ProfWin* window, const char* const command, gchar** args)
+{
+    // /ai clear
+    // Must be in an AI window to use this command
+    if (!window || window->type != WIN_AI) {
+        cons_show_error("Must be in an AI chat window to use this command.");
+        return TRUE;
+    }
+    ProfAiWin* aiwin = (ProfAiWin*)window;
+
+    assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+    if (aiwin->session) {
+        ai_session_clear_history(aiwin->session);
+    }
+
+    win_clear(window);
+    cons_show("AI Chat history cleared.");
+    return TRUE;
+}
+
+gboolean
+cmd_ai_providers(ProfWin* window, const char* const command, gchar** args)
+{
+    cons_show("Configured providers:");
+    cons_show("");
+
+    GList* providers = ai_list_providers();
+    if (!providers) {
+        cons_show("  (none configured)");
+        cons_show("");
+        cons_show("Add a provider with: /ai set provider <name> <url>");
+        return TRUE;
+    }
+
+    for (GList* curr = providers; curr; curr = g_list_next(curr)) {
+        AIProvider* provider = curr->data;
+        auto_gchar gchar* key = ai_get_provider_key(provider->name);
+        cons_show("  %s", provider->name);
+        cons_show("    URL: %s", provider->api_url);
+        cons_show("    Key: %s", key ? "configured" : "NOT configured");
+        cons_show("");
+    }
+    g_list_free(providers);
+
+    return TRUE;
+}
+
 gboolean
 cmd_force_encryption(ProfWin* window, const char* const command, gchar** args)
 {