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_ac.c

@@ -66,6 +66,8 @@
 #include "omemo/omemo.h"
 #endif
 
+#include "ai/ai_client.h"
+
 static char* _sub_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _notify_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _theme_autocomplete(ProfWin* window, const char* const input, gboolean previous);
@@ -137,6 +139,7 @@ static char* _strophe_autocomplete(ProfWin* window, const char* const input, gbo
 static char* _adhoc_cmd_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _vcard_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _force_encryption_autocomplete(ProfWin* window, const char* const input, gboolean previous);
+static char* _ai_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 
 static char* _script_autocomplete_func(const char* const prefix, gboolean previous, void* context);
 
@@ -280,11 +283,16 @@ static Autocomplete history_switch_ac;
 static Autocomplete color_ac;
 static Autocomplete correction_ac;
 static Autocomplete avatar_ac;
+static Autocomplete ai_subcommands_ac;
+static Autocomplete ai_set_subcommands_ac;
+static Autocomplete ai_set_custom_subcommands_ac;
+static Autocomplete ai_remove_subcommands_ac;
 static Autocomplete url_ac;
 static Autocomplete executable_ac;
 static Autocomplete executable_param_ac;
 static Autocomplete intype_ac;
 static Autocomplete mood_ac;
+static Autocomplete ai_models_ac;
 static Autocomplete mood_type_ac;
 static Autocomplete strophe_ac;
 static Autocomplete strophe_sm_ac;
@@ -456,7 +464,12 @@ static Autocomplete* all_acs[] = {
     &vcard_togglable_param_ac,
     &vcard_address_type_ac,
     &force_encryption_ac,
-    &force_encryption_policy_ac
+    &force_encryption_policy_ac,
+    &ai_subcommands_ac,
+    &ai_set_subcommands_ac,
+    &ai_set_custom_subcommands_ac,
+    &ai_remove_subcommands_ac,
+    &ai_models_ac
 };
 
 static GHashTable* ac_funcs = NULL;
@@ -1169,6 +1182,26 @@ cmd_ac_init(void)
     autocomplete_add(correction_ac, "off");
     autocomplete_add(correction_ac, "char");
 
+    autocomplete_add_unsorted(ai_subcommands_ac, "set", FALSE);
+    autocomplete_add_unsorted(ai_subcommands_ac, "remove", FALSE);
+    autocomplete_add_unsorted(ai_subcommands_ac, "start", FALSE);
+    autocomplete_add_unsorted(ai_subcommands_ac, "clear", FALSE);
+    autocomplete_add_unsorted(ai_subcommands_ac, "providers", FALSE);
+    autocomplete_add_unsorted(ai_subcommands_ac, "switch", FALSE);
+    autocomplete_add_unsorted(ai_subcommands_ac, "models", FALSE);
+
+    autocomplete_add_unsorted(ai_set_subcommands_ac, "provider", FALSE);
+    autocomplete_add_unsorted(ai_set_subcommands_ac, "token", FALSE);
+    autocomplete_add_unsorted(ai_set_subcommands_ac, "default-model", FALSE);
+    autocomplete_add_unsorted(ai_set_subcommands_ac, "custom", FALSE);
+
+    autocomplete_add_unsorted(ai_set_custom_subcommands_ac, "tools", FALSE);
+    autocomplete_add_unsorted(ai_set_custom_subcommands_ac, "search", FALSE);
+    autocomplete_add_unsorted(ai_set_custom_subcommands_ac, "memory", FALSE);
+    autocomplete_add_unsorted(ai_set_custom_subcommands_ac, "plugins", FALSE);
+
+    autocomplete_add_unsorted(ai_remove_subcommands_ac, "provider", FALSE);
+
     autocomplete_add(avatar_ac, "set");
     autocomplete_add(avatar_ac, "disable");
     autocomplete_add(avatar_ac, "get");
@@ -1444,6 +1477,7 @@ cmd_ac_init(void)
     g_hash_table_insert(ac_funcs, "/wins", _wins_autocomplete);
     g_hash_table_insert(ac_funcs, "/wintitle", _wintitle_autocomplete);
     g_hash_table_insert(ac_funcs, "/force-encryption", _force_encryption_autocomplete);
+    g_hash_table_insert(ac_funcs, "/ai", _ai_autocomplete);
 }
 
 void
@@ -1662,6 +1696,7 @@ cmd_ac_reset(ProfWin* window)
     win_reset_search_attempts();
     win_close_reset_search_attempts();
     plugins_reset_autocomplete();
+    ai_providers_reset_ac();
 }
 
 void
@@ -4450,4 +4485,163 @@ _force_encryption_autocomplete(ProfWin* window, const char* const input, gboolea
 
     result = autocomplete_param_with_ac(input, "/force-encryption", force_encryption_ac, TRUE, previous);
     return result;
-}
+}
+
+/* Forward declaration */
+static char* _ai_provider_and_model_autocomplete(ProfWin* window, const char* const input,
+                                                 gboolean previous, const char* cmd);
+
+static char*
+_ai_autocomplete(ProfWin* window, const char* const input, gboolean previous)
+{
+    char* result = NULL;
+
+    /* Parse once for reuse - /ai <subcommand> [<arg1>] [<arg2>] */
+    gboolean parse_result = FALSE;
+    auto_gcharv gchar** args = parse_args(input, 1, 4, &parse_result);
+    int num_args = g_strv_length(args);
+
+    /* Top-level /ai <subcommand> autocomplete (e.g., /ai s<tab> -> /ai set) */
+    result = autocomplete_param_with_func(input, "/ai set provider", ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    // /ai set token <provider> <token> - autocomplete provider names
+    result = autocomplete_param_with_func(input, "/ai set token", ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    // /ai set default-model <provider> <model> - autocomplete provider names
+    result = autocomplete_param_with_func(input, "/ai set default-model", ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    // /ai set custom <provider> <setting> <value> - autocomplete provider names
+    result = autocomplete_param_with_func(input, "/ai set custom", ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    // /ai set custom <provider> <setting> - autocomplete settings
+    /* args[0]="set", args[1]="custom", args[2]=provider (if typed), args[3]=setting (if typed) */
+    if (num_args == 3 && g_strcmp0(args[1], "custom") == 0) {
+        /* /ai set custom <provider> - check if provider is valid */
+        if (ai_get_provider(args[2])) {
+            /* Valid provider, try settings autocomplete */
+            result = autocomplete_param_with_ac(input, "/ai set custom ", ai_set_custom_subcommands_ac, TRUE, previous);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    // /ai set <subcommand> - autocomplete subcommands
+    result = autocomplete_param_with_ac(input, "/ai set", ai_set_subcommands_ac, TRUE, previous);
+    if (result) {
+        return result;
+    }
+
+    // /ai remove provider <name> - autocomplete provider names
+    result = autocomplete_param_with_func(input, "/ai remove provider", ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    result = autocomplete_param_with_ac(input, "/ai remove", ai_remove_subcommands_ac, TRUE, previous);
+    if (result) {
+        return result;
+    }
+
+    // /ai start <provider> <model> - autocomplete provider names and model names
+    result = _ai_provider_and_model_autocomplete(window, input, previous, "/ai start");
+    if (result) {
+        return result;
+    }
+
+    // /ai switch <provider> <model> - autocomplete provider names and model names
+    result = _ai_provider_and_model_autocomplete(window, input, previous, "/ai switch");
+    if (result) {
+        return result;
+    }
+
+    // /ai set default-model <provider> <model> - autocomplete provider names and model names
+    result = _ai_provider_and_model_autocomplete(window, input, previous, "/ai set default-model");
+    if (result) {
+        return result;
+    }
+
+    // /ai models <provider> - autocomplete provider names
+    result = autocomplete_param_with_func(input, "/ai models", ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    // /ai clear - no autocomplete
+    // /ai providers - no autocomplete
+
+    result = autocomplete_param_with_ac(input, "/ai", ai_subcommands_ac, FALSE, previous);
+
+    return result;
+}
+
+/**
+ * Autocomplete provider names and model names for /ai <cmd> <provider> <model> patterns.
+ * First tries to autocomplete provider names, then model names if provider is valid.
+ * Uses static ai_models_ac to preserve cycling state (last_found) across calls.
+ * The cmd_prefix should NOT include trailing space (e.g., "/ai start" not "/ai start ").
+ */
+static char*
+_ai_provider_and_model_autocomplete(ProfWin* window, const char* const input, gboolean previous, const char* cmd)
+{
+    char* result;
+
+    /* First, try provider name autocomplete */
+    result = autocomplete_param_with_func(input, cmd, ai_providers_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    /* Provider was specified, try model name autocomplete */
+    /* Build the full command prefix with space */
+    auto_gchar gchar* cmd_prefix = g_strdup_printf("%s ", cmd);
+
+    if (!g_str_has_prefix(input, cmd_prefix)) {
+        return NULL;
+    }
+
+    /* Extract provider name from input (after cmd_prefix) */
+    auto_gchar gchar* rest = g_strdup(input + strlen(cmd_prefix));
+    char* space = strchr(rest, ' ');
+    if (space) {
+        *space = '\0';
+    }
+
+    /* Look up the provider by name and get its models */
+    AIProvider* prov = ai_get_provider(rest);
+    if (!prov || !prov->models) {
+        return NULL;
+    }
+
+    if (!ai_models_ac) {
+        ai_models_ac = autocomplete_new();
+    }
+    /* Convert GList* to char** for autocomplete_update */
+    int model_count = g_list_length(prov->models);
+    char** model_array = g_new0(char*, model_count + 1);
+    GList* curr = prov->models;
+    int i = 0;
+    while (curr) {
+        model_array[i++] = curr->data;
+        curr = g_list_next(curr);
+    }
+
+    autocomplete_update(ai_models_ac, model_array);
+    g_free(model_array);
+
+    auto_gchar gchar* full_prefix = g_strdup_printf("%s%s", cmd_prefix, rest);
+
+    result = autocomplete_param_with_ac(input, full_prefix, ai_models_ac, TRUE, previous);
+    return result;
+}

src/command/cmd_defs.c

@@ -2787,6 +2787,67 @@ static const struct cmd_t command_defs[] = {
               "/force-encryption policy block")
     },
 
+    { CMD_PREAMBLE("/ai",
+                   parse_args, 0, 5, NULL)
+      CMD_SUBFUNCS(
+              { "set", cmd_ai_set },
+              { "remove", cmd_ai_remove },
+              { "start", cmd_ai_start },
+              { "clear", cmd_ai_clear },
+              { "providers", cmd_ai_providers },
+              { "switch", cmd_ai_switch },
+              { "models", cmd_ai_models })
+      CMD_MAINFUNC(cmd_ai)
+      CMD_TAGS(
+              CMD_TAG_CHAT)
+      CMD_SYN(
+              "/ai",
+              "/ai set provider <name> <url>",
+              "/ai set token <provider> <token>",
+              "/ai set default-model <provider> <model>",
+              "/ai set custom <provider> <setting> <value>",
+              "/ai remove provider <name>",
+              "/ai providers",
+              "/ai start [<provider>] [<model>]",
+              "/ai switch <provider> [<model>]",
+              "/ai switch <model>",
+              "/ai models <provider>",
+              "/ai clear")
+      CMD_DESC(
+              "Interact with AI models via OpenAI-compatible APIs. "
+              "Supports multiple providers (openai, perplexity, custom). "
+              "Each provider has its own API key, endpoint, default model, and settings. "
+              "Chat history is maintained per session and not persisted locally.")
+      CMD_ARGS(
+              { "", "Display current AI settings and configured providers" },
+              { "set provider <name> <url>", "Add or update a provider with custom API endpoint" },
+              { "set token <provider> <token>", "Set API token for a provider (e.g., openai, perplexity)" },
+              { "set default-model <provider> <model>", "Set default model for a provider" },
+              { "set custom <provider> <setting> <value>", "Set provider-level setting (e.g., tools, search)" },
+              { "remove provider <name>", "Remove a custom provider" },
+              { "providers", "List configured providers with full details" },
+              { "start <provider> [<model>]", "Start new AI chat (space-separated, uses defaults if omitted)" },
+              { "switch <provider> [<model>]", "Switch to different provider (and optionally model)" },
+              { "models <provider>", "Fetch and display available models for provider" },
+              { "clear", "Clear current chat history" })
+      CMD_EXAMPLES(
+              "/ai",
+              "/ai set token openai sk-xxx",
+              "/ai set token perplexity pplx-xxx",
+              "/ai set provider custom https://my-api.com/v1/chat/completions",
+              "/ai set default-model perplexity sonar",
+              "/ai set custom perplexity tools enabled",
+              "/ai remove provider custom",
+              "/ai start",
+              "/ai start perplexity",
+              "/ai start perplexity sonar",
+              "/ai start openai gpt-4o",
+              "/ai switch gpt-4o",
+              "/ai switch openai gpt-5.4-nano",
+              "/ai models perplexity",
+              "/ai clear")
+    },
+
     // NEXT-COMMAND (search helper)
 };
 

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)
 {

src/command/cmd_funcs.h

@@ -166,6 +166,14 @@ gboolean cmd_console(ProfWin* window, const char* const command, gchar** args);
 gboolean cmd_command_list(ProfWin* window, const char* const command, gchar** args);
 gboolean cmd_command_exec(ProfWin* window, const char* const command, gchar** args);
 gboolean cmd_change_password(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_set(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_remove(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_start(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_clear(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_providers(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_switch(ProfWin* window, const char* const command, gchar** args);
+gboolean cmd_ai_models(ProfWin* window, const char* const command, gchar** args);
 
 gboolean cmd_plugins(ProfWin* window, const char* const command, gchar** args);
 gboolean cmd_plugins_sourcepath(ProfWin* window, const char* const command, gchar** args);