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

Add an AI client module that integrates with OpenAI-compatible API
providers (OpenAI, Perplexity, and custom providers) to provide
AI-assisted responses within the profanity client.

The implementation includes:

- src/ai/ai_client.c/h: Core AI client with provider management,
  session handling, and async HTTP request handling via libcurl.
  Supports per-provider API keys stored in preferences, reference-
  counted sessions, and conversation history tracking.

- src/ui/window.c/window_list.c: New AI window type (ProfAiWin) for
  displaying AI conversations, with response streaming and error
  display capabilities.

- Command integration: New `/ai` command (cmd_defs.c, cmd_funcs.c)
  for creating sessions, sending prompts, and managing providers.
  Provider autocomplete support in cmd_ac.c.

- Preferences integration: API keys for providers are persisted in
  the preferences system (config/preferences.c).

- Unit tests: 472 lines of comprehensive tests covering provider
  management, session lifecycle, JSON escaping, and autocomplete
  (tests/unittests/test_ai_client.c).

Architecture decisions:
- Asynchronous design: HTTP requests run on a separate thread to
  avoid blocking the main UI loop. Callbacks are invoked on the main
  thread via direct function call (profanity uses ncurses, not GLib
  main loop).
- Reference counting: Both AIProvider and AISession use ref counting
  for safe shared ownership.
- Response size limit: 10MB cap on HTTP responses to prevent OOM.

src/ui/ui.h

@@ -386,6 +386,8 @@ ProfWin* win_create_config(const char* const title, DataForm* form, ProfConfWinC
 ProfWin* win_create_private(const char* const fulljid);
 ProfWin* win_create_plugin(const char* const plugin_name, const char* const tag);
 ProfWin* win_create_vcard(vCard* vcard);
+ProfWin* win_create_ai(AISession* session);
+ProfWin* wins_new_ai(AISession* session);
 void win_update_virtual(ProfWin* window);
 void win_free(ProfWin* window);
 gboolean win_notify_remind(ProfWin* window);

src/ui/win_types.h

@@ -62,6 +62,7 @@
 #define PROFXMLWIN_MEMCHECK     87333463
 #define PROFPLUGINWIN_MEMCHECK  43434777
 #define PROFVCARDWIN_MEMCHECK   68947523
+#define PROFAIWIN_MEMCHECK      91827364
 
 typedef enum {
     FIELD_HIDDEN,
@@ -144,7 +145,8 @@ typedef enum {
     WIN_PRIVATE,
     WIN_XML,
     WIN_PLUGIN,
-    WIN_VCARD
+    WIN_VCARD,
+    WIN_AI
 } win_type_t;
 
 typedef enum {
@@ -258,4 +260,16 @@ typedef struct prof_vcard_win_t
     unsigned long memcheck;
 } ProfVcardWin;
 
+/* Forward declaration */
+typedef struct ai_session_t AISession;
+
+typedef struct prof_ai_win_t
+{
+    ProfWin window;
+    ProfBuff message_buffer;
+    GString* conversation_history;
+    AISession* session;
+    unsigned long memcheck;
+} ProfAiWin;
+
 #endif

src/ui/window.c

@@ -36,6 +36,7 @@
 
 #include "config.h"
 #include "database.h"
+#include "ui/win_types.h"
 #include "ui/window_list.h"
 
 #include <stdlib.h>
@@ -62,6 +63,7 @@
 #include "ui/screen.h"
 #include "xmpp/xmpp.h"
 #include "xmpp/roster_list.h"
+#include "ai/ai_client.h"
 
 static const char* LOADING_MESSAGE = "Loading older messages…";
 static const char* CONS_WIN_TITLE = "CProof. Type /help for help information.";
@@ -329,6 +331,33 @@ win_create_vcard(vCard* vcard)
     return &new_win->window;
 }
 
+ProfWin*
+win_create_ai(AISession* session)
+{
+    ProfAiWin* new_win = g_new0(ProfAiWin, 1);
+    new_win->window.type = WIN_AI;
+    new_win->window.scroll_state = WIN_SCROLL_INNER;
+    new_win->window.layout = _win_create_simple_layout();
+
+    new_win->message_buffer = buffer_create();
+    new_win->conversation_history = g_string_new("");
+    new_win->session = session ? ai_session_ref(session) : NULL;
+    new_win->memcheck = PROFAIWIN_MEMCHECK;
+
+    return &new_win->window;
+}
+
+void
+win_ai_free(ProfAiWin* win)
+{
+    assert(win->memcheck == PROFAIWIN_MEMCHECK);
+    buffer_free(win->message_buffer);
+    g_string_free(win->conversation_history, TRUE);
+    if (win->session) {
+        ai_session_unref(win->session);
+    }
+}
+
 gchar*
 win_get_title(ProfWin* window)
 {
@@ -407,6 +436,13 @@ win_get_title(ProfWin* window)
 
         return g_string_free(title, FALSE);
     }
+    case WIN_AI:
+    {
+        const ProfAiWin* aiwin = (ProfAiWin*)window;
+        assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+
+        return g_strdup_printf("AI Assistant (%s: %s)", aiwin->session->provider_name, aiwin->session->model);
+    }
     }
     assert(FALSE);
 }
@@ -454,6 +490,10 @@ win_get_tab_identifier(ProfWin* window)
     {
         return strdup("vcard");
     }
+    case WIN_AI:
+    {
+        return strdup("ai");
+    }
     }
     assert(FALSE);
 }
@@ -536,6 +576,12 @@ win_to_string(ProfWin* window)
         ProfVcardWin* vcardwin = (ProfVcardWin*)window;
         return vcardwin_get_string(vcardwin);
     }
+    case WIN_AI:
+    {
+        ProfAiWin* aiwin = (ProfAiWin*)window;
+        assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+        return aiwin_get_string(aiwin);
+    }
     }
     assert(FALSE);
 }
@@ -662,6 +708,17 @@ win_free(ProfWin* window)
         free(pluginwin->plugin_name);
         break;
     }
+    case WIN_AI:
+    {
+        ProfAiWin* aiwin = (ProfAiWin*)window;
+        assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+        buffer_free(aiwin->message_buffer);
+        g_string_free(aiwin->conversation_history, TRUE);
+        if (aiwin->session) {
+            ai_session_unref(aiwin->session);
+        }
+        break;
+    }
     default:
         break;
     }
@@ -2367,3 +2424,69 @@ get_enc_char(prof_enc_t enc_mode, const char* alt)
     else
         return get_show_char(enc_mode);
 }
+
+// AI Window Functions
+
+char*
+aiwin_get_string(ProfAiWin* win)
+{
+    assert(win->memcheck == PROFAIWIN_MEMCHECK);
+    return g_strdup_printf("AI Chat (%s: %s)", win->session->provider_name, win->session->model);
+}
+
+void
+aiwin_send_message(ProfAiWin* win, const char* message, const char* id)
+{
+    log_debug("[AI-WIN] aiwin_send_message ENTER: win=%p, message='%s'", (void*)win, message);
+    assert(win->memcheck == PROFAIWIN_MEMCHECK);
+
+    if (!win->session) {
+        log_error("[AI-WIN] FAIL: AI session not initialized");
+        return;
+    }
+
+    // Display user message
+    win_print_outgoing(&win->window, ">>", id, NULL, message);
+    log_debug("[AI-WIN] Displayed user message");
+
+    // Send to AI (ai_send_prompt adds message to history internally)
+    log_debug("[AI-WIN] Calling ai_send_prompt...");
+    gboolean result = ai_send_prompt(win->session, message,
+                                     (ai_response_cb)aiwin_display_response,
+                                     (ai_error_cb)aiwin_display_error,
+                                     win);
+    log_debug("[AI-WIN] ai_send_prompt returned: %d", result);
+}
+
+void
+aiwin_display_response(ProfAiWin* win, const char* response)
+{
+    log_debug("[AI-WIN] aiwin_display_response ENTER: win=%p, response='%s'", (void*)win, response);
+    assert(win->memcheck == PROFAIWIN_MEMCHECK);
+
+    if (!response) {
+        log_error("[AI-WIN] FAIL: null response");
+        return;
+    }
+
+    // Display AI response
+    win_println(&win->window, THEME_DEFAULT, "<< LLM:", "%s", response);
+    log_debug("[AI-WIN] Displayed AI response");
+
+    // Add to conversation history
+    ai_session_add_message(win->session, "assistant", response);
+    log_debug("[AI-WIN] Added assistant message to session history");
+}
+
+void
+aiwin_display_error(ProfAiWin* win, const char* error_msg)
+{
+    log_debug("[AI-WIN] aiwin_display_error ENTER: win=%p, error='%s'", (void*)win, error_msg);
+    assert(win->memcheck == PROFAIWIN_MEMCHECK);
+
+    const char* msg = error_msg ? error_msg : "Unknown error";
+    win_println(&win->window, THEME_ERROR, "[ERROR]", "%s", msg);
+
+    // Also show error in console so user sees it regardless of active window
+    cons_show_error("AI Error: %s", msg);
+}

src/ui/window.h

@@ -101,4 +101,13 @@ char* win_quote_autocomplete(ProfWin* window, const char* const input, gboolean
 char* get_show_char(prof_enc_t encryption_mode);
 char* get_enc_char(prof_enc_t enc_mode, const char* alt);
 
+#include "ai/ai_client.h"
+
+// AI window functions
+void win_ai_free(ProfAiWin* win);
+char* aiwin_get_string(ProfAiWin* win);
+void aiwin_send_message(ProfAiWin* win, const char* message, const char* id);
+void aiwin_display_response(ProfAiWin* win, const char* response);
+void aiwin_display_error(ProfAiWin* win, const char* error_msg);
+
 #endif

src/ui/window_list.c

@@ -44,9 +44,11 @@
 
 #include "common.h"
 #include "config/preferences.h"
+#include "log.h"
 #include "config/theme.h"
 #include "plugins/plugins.h"
 #include "ui/ui.h"
+#include "ui/window.h"
 #include "ui/window_list.h"
 #include "xmpp/xmpp.h"
 #include "xmpp/roster_list.h"
@@ -374,6 +376,8 @@ wins_set_current_by_num(int i)
                 status_bar_active(1, conswin->type, "console");
             }
         }
+    } else {
+        log_error("Window not found for index %d", i);
     }
 }
 
@@ -714,6 +718,20 @@ wins_new_vcard(vCard* vcard)
     return newwin;
 }
 
+ProfWin*
+wins_new_ai(AISession* session)
+{
+    int result = _wins_get_next_available_num(keys);
+    ProfWin* newwin = win_create_ai(session);
+    if (!newwin) {
+        return NULL;
+    }
+    _wins_htable_insert(windows, GINT_TO_POINTER(result), newwin);
+    autocomplete_add(wins_ac, "ai");
+    autocomplete_add(wins_close_ac, "ai");
+    return newwin;
+}
+
 gboolean
 wins_do_notify_remind(void)
 {
@@ -841,7 +859,7 @@ wins_get_prune_wins(void)
 
     while (curr) {
         ProfWin* window = curr->data;
-        if (win_unread(window) == 0 && window->type != WIN_MUC && window->type != WIN_CONFIG && window->type != WIN_XML && window->type != WIN_CONSOLE) {
+        if (win_unread(window) == 0 && window->type != WIN_MUC && window->type != WIN_CONFIG && window->type != WIN_XML && window->type != WIN_CONSOLE && window->type != WIN_AI) {
             result = g_slist_append(result, window);
         }
         curr = g_list_next(curr);
@@ -849,6 +867,24 @@ wins_get_prune_wins(void)
     return result;
 }
 
+ProfAiWin*
+wins_get_ai(void)
+{
+    GList* curr = values;
+
+    while (curr) {
+        ProfWin* window = curr->data;
+        if (window->type == WIN_AI) {
+            ProfAiWin* aiwin = (ProfAiWin*)window;
+            assert(aiwin->memcheck == PROFAIWIN_MEMCHECK);
+            return aiwin;
+        }
+        curr = g_list_next(curr);
+    }
+
+    return NULL;
+}
+
 void
 wins_lost_connection(void)
 {

src/ui/window_list.h

@@ -63,6 +63,7 @@ ProfPrivateWin* wins_get_private(const char* const fulljid);
 ProfPluginWin* wins_get_plugin(const char* const tag);
 ProfXMLWin* wins_get_xmlconsole(void);
 ProfVcardWin* wins_get_vcard(void);
+ProfAiWin* wins_get_ai(void);
 
 void wins_close_plugin(char* tag);