style(ai): rename unparseable to unparsable for codespell

- bound _parse_responses scans to the output_text part's object and to
  the content array, so a later sibling item's "text" (e.g. a reasoning
  summary) can never be returned as the assistant reply
- do not retry the other flavour on a curl timeout: the request likely
  reached the server and may still be generating, so a re-POST of the
  conversation could trigger a second billed generation
- remember an unparseable 2xx from the first AUTO attempt and surface
  stashed first-attempt errors in both error paths, instead of showing
  only the final attempt's transport or HTTP error
- recognize Ollama's model-not-found wording in _names_model so a model
  typo is not misread as a missing endpoint
- drop the dead, racy provider-lookup fallback in the generic request
  thread: a missing provider ref is a caller bug and now fails loudly
- fix ai_providers_lists_defaults to expect the header the command
  actually prints ("Configured providers:"); the test was broken since
  its introduction but CI never ran it
- add functional test group 5 (AI command surface) to FUNC_TEST_GROUPS
  so the CI parallel target runs it; proftest.c port ranges already
  account for five groups

Makefile.am

@@ -335,7 +335,7 @@ tests_functionaltests_functionaltests_LDADD = -lcmocka -lstabber @FORKPTY_LIB@
 # Parallel functional tests target (~3x faster than sequential)
 # Usage: make check-functional-parallel
 # To add more groups: increase FUNC_TEST_GROUPS and add group in functionaltests.c
-FUNC_TEST_GROUPS = 1 2 3 4
+FUNC_TEST_GROUPS = 1 2 3 4 5
 
 check-functional-parallel: tests/functionaltests/functionaltests
 	@echo "Running functional tests in parallel ($(words $(FUNC_TEST_GROUPS)) groups)..."

src/ai/ai_client.h

@@ -12,19 +12,38 @@ typedef struct ai_message_t
     gchar* content; /* Message content */
 } AIMessage;
 
+/**
+ * @brief API flavour used to talk to a provider.
+ *
+ * AUTO tries /v1/responses first and falls back to /v1/chat/completions when
+ * the endpoint is missing (404/405/501) or rejects the payload shape
+ * (400/422). The working flavour is cached for the rest of the run as a
+ * first-attempt hint (the other flavour stays available as a fallback). The
+ * other two values pin the flavour explicitly.
+ */
+typedef enum {
+    AI_API_TYPE_AUTO = 0,
+    AI_API_TYPE_RESPONSES,
+    AI_API_TYPE_CHAT_COMPLETIONS,
+} AIApiType;
+
 /**
  * @brief AI provider configuration.
  */
 typedef struct ai_provider_t
 {
-    gchar* name;           /* Provider name (e.g., "openai", "perplexity") */
-    gchar* api_url;        /* API endpoint URL */
-    gchar* project_id;     /* Optional project ID (for some providers) */
-    gchar* default_model;  /* Default model for this provider */
-    GHashTable* settings;  /* Extensible per-provider settings (e.g., tools=enabled, search=disabled) */
-    GList* models;         /* Cached models (gchar*) */
-    gboolean models_fresh; /* Whether models cache is current */
-    gint32 ref_count;      /* Reference count (atomic) */
+    gchar* name;                   /* Provider name (e.g., "openai", "perplexity") */
+    gchar* api_url;                /* API endpoint URL */
+    gchar* project_id;             /* Optional project ID (for some providers) */
+    gchar* default_model;          /* Default model for this provider */
+    gint api_type;                 /* Configured AIApiType (atomic access; persisted) */
+    gint resolved_api_type;        /* AIApiType detected via 404 fallback (atomic access; runtime cache) */
+    gint api_epoch;                /* Bumped on URL change (atomic); a stale epoch discards resolved_api_type stamps */
+    pthread_mutex_t settings_lock; /* Protects settings and api_url (read by request threads) */
+    GHashTable* settings;          /* Extensible per-provider settings (e.g., temperature=0.7) */
+    GList* models;                 /* Cached models (gchar*) */
+    gboolean models_fresh;         /* Whether models cache is current */
+    gint32 ref_count;              /* Reference count (atomic) */
 } AIProvider;
 
 /**
@@ -66,7 +85,7 @@ AIProvider* ai_get_provider(const gchar* name);
  * Add or update a provider configuration.
  * @param name The provider name
  * @param api_url The API endpoint URL
- * @return New AIProvider* (caller must unref when done)
+ * @return Borrowed AIProvider* owned by the provider table (do not unref)
  */
 AIProvider* ai_add_provider(const gchar* name, const gchar* api_url);
 
@@ -141,12 +160,44 @@ void ai_set_provider_default_model(const gchar* provider_name, const gchar* mode
 const gchar* ai_get_provider_default_model(const gchar* provider_name);
 
 /**
- * Set a custom setting for a provider.
+ * Set the API type for a provider.
  * @param provider_name The provider name
- * @param setting The setting key (e.g., "tools", "search")
- * @param value The setting value
+ * @param api_type "responses", "chat-completions", or "auto" (detect by probing)
+ * @return TRUE on success, FALSE on unknown provider or invalid type string
  */
-void ai_set_provider_setting(const gchar* provider_name, const gchar* setting, const gchar* value);
+gboolean ai_set_provider_api_type(const gchar* provider_name, const gchar* api_type);
+
+/**
+ * Get the configured API type for a provider.
+ * @param provider_name The provider name
+ * @return The configured AIApiType (AI_API_TYPE_AUTO for unknown providers)
+ */
+AIApiType ai_get_provider_api_type(const gchar* provider_name);
+
+/**
+ * Parse an API type string ("auto", "responses", "chat-completions").
+ * @param str The string to parse
+ * @param type Output for the parsed value (untouched on failure)
+ * @return TRUE if str is a valid API type
+ */
+gboolean ai_api_type_from_string(const gchar* str, AIApiType* type);
+
+/**
+ * String form of an AIApiType, e.g. for display.
+ * @param type The API type
+ * @return Static string, never NULL
+ */
+const gchar* ai_api_type_to_string(AIApiType type);
+
+/**
+ * Set a custom setting for a provider.
+ * Reserved payload keys (model, messages, input, stream) are rejected.
+ * @param provider_name The provider name
+ * @param setting The setting key (e.g., "temperature")
+ * @param value The setting value, or NULL to remove
+ * @return TRUE on success, FALSE on unknown provider or reserved key
+ */
+gboolean ai_set_provider_setting(const gchar* provider_name, const gchar* setting, const gchar* value);
 
 /**
  * Get a custom setting for a provider.
@@ -156,6 +207,14 @@ void ai_set_provider_setting(const gchar* provider_name, const gchar* setting, c
  */
 gchar* ai_get_provider_setting(const gchar* provider_name, const gchar* setting);
 
+/**
+ * List the custom setting keys currently set on a provider.
+ * @param provider_name The provider name
+ * @return GList of gchar* (free with g_list_free_full(keys, g_free)),
+ *         or NULL if the provider is unknown or has no settings
+ */
+GList* ai_get_provider_setting_keys(const gchar* provider_name);
+
 /**
  * Fetch available models from a provider's API.
  * @param provider_name The provider name
@@ -184,14 +243,25 @@ gboolean ai_models_are_fresh(const gchar* provider_name);
 void ai_parse_models_from_json(AIProvider* provider, const gchar* json);
 
 /**
- * Extract assistant content from an LLM response body. Tries Perplexity
- * /v1/responses "text" first, falls back to OpenAI "content". Decodes
- * the \" and \n escape sequences only.
+ * Extract assistant content from a provider response body. Detects the
+ * flavour from the envelope: chat completions
+ * ({"choices":[{"message":{"content":"..."}}]}) or responses
+ * ({"output":[{"content":[{"type":"output_text","text":"..."}]}]}).
  * @param response_json The JSON body from the provider
  * @return Newly allocated content string, or NULL if not found (caller frees)
  */
 gchar* ai_parse_response(const gchar* response_json);
 
+/**
+ * Extract assistant content trying the known request flavour's extractor
+ * first, then the other flavour, then a bare top-level "content" string.
+ * ai_parse_response is equivalent to passing AI_API_TYPE_AUTO.
+ * @param api_type The API flavour the response was requested with
+ * @param response_json The JSON body from the provider
+ * @return Newly allocated content string, or NULL if not found (caller frees)
+ */
+gchar* ai_parse_response_typed(AIApiType api_type, const gchar* response_json);
+
 /**
  * Extract human-readable error message from an API error envelope.
  * Expected format: {"error":{"message":"...","type":"...","code":...}}

src/command/cmd_ac.c

@@ -47,6 +47,7 @@ static char* _notify_autocomplete(ProfWin* window, const char* const input, gboo
 static char* _theme_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _spellcheck_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _autoaway_autocomplete(ProfWin* window, const char* const input, gboolean previous);
+static char* _autoping_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _autoconnect_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _account_autocomplete(ProfWin* window, const char* const input, gboolean previous);
 static char* _who_autocomplete(ProfWin* window, const char* const input, gboolean previous);
@@ -263,6 +264,7 @@ 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_api_types_ac;
 static Autocomplete ai_remove_subcommands_ac;
 static Autocomplete url_ac;
 static Autocomplete executable_ac;
@@ -452,6 +454,7 @@ static Autocomplete* all_acs[] = {
     &ai_subcommands_ac,
     &ai_set_subcommands_ac,
     &ai_set_custom_subcommands_ac,
+    &ai_api_types_ac,
     &ai_remove_subcommands_ac,
     &ai_models_ac
 };
@@ -1056,6 +1059,7 @@ cmd_ac_init(void)
 
     autocomplete_add(autoping_ac, "set");
     autocomplete_add(autoping_ac, "timeout");
+    autocomplete_add(autoping_ac, "warning");
 
     autocomplete_add(plugins_ac, "install");
     autocomplete_add(plugins_ac, "update");
@@ -1181,12 +1185,12 @@ cmd_ac_init(void)
     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, "api-type", 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_api_types_ac, "chat-completions", FALSE);
+    autocomplete_add_unsorted(ai_api_types_ac, "responses", FALSE);
+    autocomplete_add_unsorted(ai_api_types_ac, "auto", FALSE);
 
     autocomplete_add_unsorted(ai_remove_subcommands_ac, "provider", FALSE);
 
@@ -1407,6 +1411,7 @@ cmd_ac_init(void)
     g_hash_table_insert(ac_funcs, "/alias", _alias_autocomplete);
     g_hash_table_insert(ac_funcs, "/autoaway", _autoaway_autocomplete);
     g_hash_table_insert(ac_funcs, "/autoconnect", _autoconnect_autocomplete);
+    g_hash_table_insert(ac_funcs, "/autoping", _autoping_autocomplete);
     g_hash_table_insert(ac_funcs, "/avatar", _avatar_autocomplete);
     g_hash_table_insert(ac_funcs, "/ban", _ban_autocomplete);
     g_hash_table_insert(ac_funcs, "/blocked", _blocked_autocomplete);
@@ -1934,7 +1939,6 @@ _cmd_ac_complete_params(ProfWin* window, const char* const input, gboolean previ
         { "/prefs", prefs_ac },
         { "/disco", disco_ac },
         { "/room", room_ac },
-        { "/autoping", autoping_ac },
         { "/mainwin", winpos_ac },
         { "/inputwin", winpos_ac },
     };
@@ -4264,6 +4268,20 @@ _executable_autocomplete(ProfWin* window, const char* const input, gboolean prev
     return result;
 }
 
+static char*
+_autoping_autocomplete(ProfWin* window, const char* const input, gboolean previous)
+{
+    char* result = NULL;
+
+    result = autocomplete_param_with_ac(input, "/autoping", autoping_ac, TRUE, previous);
+    if (result) {
+        return result;
+    }
+
+    result = autocomplete_param_with_func(input, "/autoping warning", prefs_autocomplete_boolean_choice, previous, NULL);
+    return result;
+}
+
 static char*
 _lastactivity_autocomplete(ProfWin* window, const char* const input, gboolean previous)
 {
@@ -4516,17 +4534,67 @@ _force_encryption_autocomplete(ProfWin* window, const char* const input, gboolea
 static char* _ai_provider_and_model_autocomplete(ProfWin* window, const char* const input,
                                                  gboolean previous, const char* cmd);
 
+static char*
+_ai_api_type_find(const char* const search_str, gboolean previous, void* context)
+{
+    return autocomplete_complete(ai_api_types_ac, search_str, FALSE, previous);
+}
+
+static char*
+_ai_custom_setting_find(const char* const search_str, gboolean previous, void* context)
+{
+    return autocomplete_complete(ai_set_custom_subcommands_ac, search_str, FALSE, previous);
+}
+
+/**
+ * Autocomplete the setting name for /ai set custom <provider> <setting>.
+ * Offers a few common payload parameters merged with the keys already set
+ * on the provider, so existing settings can be retyped or overridden.
+ */
+static char*
+_ai_custom_setting_autocomplete(const char* const input, gboolean previous)
+{
+    if (!g_str_has_prefix(input, "/ai set custom ")) {
+        return NULL;
+    }
+
+    /* Quote-aware parse: args[2] is the provider, args[3] the setting being
+     * typed; skip the rebuild when the caret is not at the setting position */
+    gboolean parse_result = FALSE;
+    auto_gcharv gchar** args = parse_args(input, 1, 5, &parse_result);
+    if (!parse_result) {
+        return NULL;
+    }
+    guint num_args = g_strv_length(args);
+    if (num_args < 3 || num_args > 4 || !ai_get_provider(args[2])) {
+        return NULL;
+    }
+
+    /* Rebuild the completion list: common parameters + the provider's keys */
+    gchar* suggestions[] = { "temperature", "max_tokens", "top_p" };
+    GList* keys = ai_get_provider_setting_keys(args[2]);
+    char** items = g_new0(char*, ARRAY_SIZE(suggestions) + g_list_length(keys) + 1);
+    guint i = 0;
+    for (; i < ARRAY_SIZE(suggestions); i++) {
+        items[i] = suggestions[i];
+    }
+    for (GList* curr = keys; curr; curr = g_list_next(curr)) {
+        items[i++] = curr->data;
+    }
+    autocomplete_update(ai_set_custom_subcommands_ac, items);
+    g_free(items);
+    g_list_free_full(keys, g_free);
+
+    /* /ai(1) set(2) custom(3) <provider>(4) <setting>(5) */
+    return autocomplete_param_no_with_func(input, "/ai set custom", 5, _ai_custom_setting_find, previous, NULL);
+}
+
 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) */
+    // /ai set provider <name> <url> - autocomplete provider names (for updating)
     result = autocomplete_param_with_func(input, "/ai set provider", ai_providers_find, previous, NULL);
     if (result) {
         return result;
@@ -4544,24 +4612,30 @@ _ai_autocomplete(ProfWin* window, const char* const input, gboolean previous)
         return result;
     }
 
+    // /ai set api-type <provider> <type> - autocomplete the type value
+    result = autocomplete_param_no_with_func(input, "/ai set api-type", 5, _ai_api_type_find, previous, NULL);
+    if (result) {
+        return result;
+    }
+
+    // /ai set api-type <provider> - autocomplete provider names
+    result = autocomplete_param_with_func(input, "/ai set api-type", 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 custom <provider> <setting> - autocomplete setting names
+    result = _ai_custom_setting_autocomplete(input, 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) {

src/command/cmd_defs.c

@@ -1964,12 +1964,14 @@ static const struct cmd_t command_defs[] = {
               CMD_TAG_CONNECTION)
       CMD_SYN(
               "/autoping set <seconds>",
-              "/autoping timeout <seconds>")
+              "/autoping timeout <seconds>",
+              "/autoping warning on|off")
       CMD_DESC(
               "Set the interval between sending ping requests to the server to ensure the connection is kept alive.")
       CMD_ARGS(
               { "set <seconds>", "Number of seconds between sending pings, a value of 0 disables autoping." },
-              { "timeout <seconds>", "Seconds to wait for autoping responses, after which the connection is considered broken." })
+              { "timeout <seconds>", "Seconds to wait for autoping responses, after which the connection is considered broken." },
+              { "warning on|off", "Enable or disable autoping availability warning." })
     },
 
     { CMD_PREAMBLE("/ping",
@@ -2813,6 +2815,7 @@ static const struct cmd_t command_defs[] = {
               "/ai set provider <name> <url>",
               "/ai set token <provider> <token>",
               "/ai set default-model <provider> <model>",
+              "/ai set api-type <provider> chat-completions|responses|auto",
               "/ai set custom <provider> <setting> <value>",
               "/ai remove provider <name>",
               "/ai providers",
@@ -2828,10 +2831,11 @@ static const struct cmd_t command_defs[] = {
               "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 provider <name> <url>", "Add or update a provider with a custom API base URL (endpoint paths are appended automatically)" },
               { "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)" },
+              { "set api-type <provider> chat-completions|responses|auto", "Pin the provider API flavour; auto tries responses and falls back to chat completions when the endpoint is missing" },
+              { "set custom <provider> <setting> <value>", "Set provider-level setting (e.g., temperature, max_tokens)" },
               { "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)" },
@@ -2842,9 +2846,10 @@ static const struct cmd_t command_defs[] = {
               "/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 provider custom https://my-api.com/",
               "/ai set default-model perplexity sonar",
-              "/ai set custom perplexity tools enabled",
+              "/ai set api-type perplexity responses",
+              "/ai set custom perplexity temperature 0.7",
               "/ai remove provider custom",
               "/ai start",
               "/ai start perplexity",

src/command/cmd_funcs.c

@@ -6374,6 +6374,8 @@ cmd_autoping(ProfWin* window, const char* const command, gchar** args)
             cons_bad_cmd_usage(command);
         }
 
+    } else if (g_strcmp0(cmd, "warning") == 0) {
+        _cmd_set_boolean_preference(value, "Autoping availability warning", PREF_AUTOPING_WARNING);
     } else {
         cons_bad_cmd_usage(command);
     }
@@ -10701,6 +10703,19 @@ cmd_vcard_save(ProfWin* window, const char* const command, gchar** args)
     return TRUE;
 }
 
+/* Show the provider's API flavour: pinned, or auto with the detected one */
+static void
+_cons_show_ai_api_type(AIProvider* provider)
+{
+    AIApiType api_type = g_atomic_int_get(&provider->api_type);
+    AIApiType resolved = g_atomic_int_get(&provider->resolved_api_type);
+    if (api_type != AI_API_TYPE_AUTO) {
+        cons_show("    API type: %s", ai_api_type_to_string(api_type));
+    } else if (resolved != AI_API_TYPE_AUTO) {
+        cons_show("    API type: auto (detected: %s)", ai_api_type_to_string(resolved));
+    }
+}
+
 gboolean
 cmd_ai(ProfWin* window, const char* const command, gchar** args)
 {
@@ -10722,6 +10737,7 @@ cmd_ai(ProfWin* window, const char* const command, gchar** args)
             if (default_model) {
                 cons_show("    Default model: %s", default_model);
             }
+            _cons_show_ai_api_type(provider);
             if (provider->models && g_list_length(provider->models) > 0) {
                 cons_show("    Cached models: %d", g_list_length(provider->models));
             }
@@ -10779,14 +10795,30 @@ cmd_ai_set(ProfWin* window, const char* const command, gchar** args)
         cons_show("Default model for provider '%s' set to: %s", args[2], args[3]);
         cons_show("");
         return TRUE;
+    } else if (g_strcmp0(args[1], "api-type") == 0) {
+        // /ai set api-type <provider> chat-completions|responses|auto
+        if (g_strv_length(args) < 4) {
+            cons_bad_cmd_usage(command);
+            return TRUE;
+        }
+        if (ai_set_provider_api_type(args[2], args[3])) {
+            cons_show("API type for provider '%s' set to: %s", args[2], args[3]);
+        } else {
+            cons_show_error("Cannot set API type for provider '%s': unknown provider or invalid type (use chat-completions, responses, or auto).", args[2]);
+        }
+        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]);
+        if (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]);
+        } else {
+            cons_show_error("Cannot set '%s' for provider '%s': unknown provider or reserved key (model, messages, input, stream).", args[3], args[2]);
+        }
         cons_show("");
         return TRUE;
     }
@@ -11100,6 +11132,7 @@ cmd_ai_providers(ProfWin* window, const char* const command, gchar** args)
         cons_show("  %s", provider->name);
         cons_show("    URL: %s", provider->api_url);
         cons_show("    Key: %s", key ? "configured" : "NOT configured");
+        _cons_show_ai_api_type(provider);
         cons_show("");
     }
     g_list_free(providers);

src/config/preferences.c

@@ -2002,6 +2002,30 @@ prefs_ai_get_default_model(const char* const provider)
     return _ai_get_string(provider, "default_model");
 }
 
+/* --- API type --- */
+
+gboolean
+prefs_ai_set_api_type(const char* const provider, const char* const api_type)
+{
+    if (!provider || !api_type || !prefs)
+        return FALSE;
+    if (api_type[0] == '\0')
+        return prefs_ai_remove_api_type(provider);
+    return _ai_set_string(provider, "api_type", api_type);
+}
+
+gboolean
+prefs_ai_remove_api_type(const char* const provider)
+{
+    return _ai_remove_string(provider, "api_type");
+}
+
+char*
+prefs_ai_get_api_type(const char* const provider)
+{
+    return _ai_get_string(provider, "api_type");
+}
+
 /* --- Provider URL --- */
 
 gboolean
@@ -2290,6 +2314,7 @@ _get_group(preference_t pref)
     case PREF_TRAY:
     case PREF_TRAY_READ:
     case PREF_ADV_NOTIFY_DISCO_OR_VERSION:
+    case PREF_AUTOPING_WARNING:
         return PREF_GROUP_NOTIFICATIONS;
     case PREF_DBLOG:
     case PREF_CHLOG:
@@ -2646,6 +2671,8 @@ _get_key(preference_t pref)
         return "enabled";
     case PREF_SPELLCHECK_LANG:
         return "lang";
+    case PREF_AUTOPING_WARNING:
+        return "autoping.warning";
     default:
         return NULL;
     }
@@ -2699,6 +2726,7 @@ _get_default_boolean(preference_t pref)
     case PREF_MOOD:
     case PREF_STROPHE_SM_ENABLED:
     case PREF_STROPHE_SM_RESEND:
+    case PREF_AUTOPING_WARNING:
         return TRUE;
     case PREF_SPELLCHECK_ENABLE:
     case PREF_PGP_PUBKEY_AUTOIMPORT:

src/config/preferences.h

@@ -169,6 +169,7 @@ typedef enum {
     PREF_FORCE_ENCRYPTION_MODE,
     PREF_SPELLCHECK_ENABLE,
     PREF_SPELLCHECK_LANG,
+    PREF_AUTOPING_WARNING
 } preference_t;
 
 typedef struct prof_alias_t
@@ -367,6 +368,11 @@ gboolean prefs_ai_set_default_model(const char* const provider, const char* cons
 gboolean prefs_ai_remove_default_model(const char* const provider);
 char* prefs_ai_get_default_model(const char* const provider);
 
+/* AI API type per provider ("responses" or "chat-completions") */
+gboolean prefs_ai_set_api_type(const char* const provider, const char* const api_type);
+gboolean prefs_ai_remove_api_type(const char* const provider);
+char* prefs_ai_get_api_type(const char* const provider);
+
 /* AI per-provider custom settings (e.g. tools, search) — persisted as
  * setting.<name>=<value> inside [ai/<provider>]. Pass NULL value to remove. */
 gboolean prefs_ai_set_setting(const char* const provider, const char* const setting, const char* const value);

src/gitversion.h.in

@@ -1,6 +0,0 @@
-#ifndef PROF_GIT_BRANCH
-#define PROF_GIT_BRANCH @PROF_GIT_BRANCH@
-#endif
-#ifndef PROF_GIT_REVISION
-#define PROF_GIT_REVISION @PROF_GIT_REVISION@
-#endif

src/pgp/gpg.c

@@ -519,13 +519,15 @@ p_gpg_sign(const gchar* const str, const gchar* const fp)
 }
 
 gchar*
-p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gchar* const fp)
+p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gchar* const fp, gchar** err)
 {
     ProfPGPPubKeyId* pubkeyid = g_hash_table_lookup(pubkeys, barejid);
     if (!pubkeyid) {
+        *err = g_strdup("No PGP key found for recipient");
         return NULL;
     }
     if (!pubkeyid->id) {
+        *err = g_strdup("No key ID found for recipient");
         return NULL;
     }
 
@@ -538,6 +540,7 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
     gpgme_ctx_t ctx;
     gpgme_error_t error = gpgme_new(&ctx);
     if (error) {
+        *err = g_strdup_printf("Failed to create GPGME context: %s %s", gpgme_strsource(error), gpgme_strerror(error));
         log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error));
         return NULL;
     }
@@ -545,6 +548,7 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
     gpgme_key_t receiver_key;
     error = gpgme_get_key(ctx, pubkeyid->id, &receiver_key, 0);
     if (error || receiver_key == NULL) {
+        *err = g_strdup_printf("Failed to get receiver key '%s': %s %s", pubkeyid->id, gpgme_strsource(error), gpgme_strerror(error));
         log_error("GPG: Failed to get receiver_key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
         gpgme_release(ctx);
         return NULL;
@@ -554,8 +558,10 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
     gpgme_key_t sender_key = NULL;
     error = gpgme_get_key(ctx, fp, &sender_key, 0);
     if (error || sender_key == NULL) {
+        *err = g_strdup_printf("Failed to get sender key '%s': %s %s", fp, gpgme_strsource(error), gpgme_strerror(error));
         log_error("GPG: Failed to get sender_key. %s %s", gpgme_strsource(error), gpgme_strerror(error));
         gpgme_release(ctx);
+        gpgme_key_unref(receiver_key);
         return NULL;
     }
     keys[1] = sender_key;
@@ -574,7 +580,8 @@ p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gcha
     gpgme_key_unref(sender_key);
 
     if (error) {
-        log_error("GPG: Failed to encrypt message. %s %s", gpgme_strsource(error), gpgme_strerror(error));
+        *err = g_strdup_printf("Encryption failed: (%s) %s", gpgme_strsource(error), gpgme_strerror(error));
+        log_error("GPG: Failed to encrypt message. (%s) %s", gpgme_strsource(error), gpgme_strerror(error));
         return NULL;
     }
 

src/pgp/gpg.h

@@ -42,7 +42,7 @@ gboolean p_gpg_available(const gchar* const barejid);
 const gchar* p_gpg_libver(void);
 gchar* p_gpg_sign(const gchar* const str, const gchar* const fp);
 void p_gpg_verify(const gchar* const barejid, const gchar* const sign);
-gchar* p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gchar* const fp);
+gchar* p_gpg_encrypt(const gchar* const barejid, const gchar* const message, const gchar* const fp, gchar** err);
 gchar* p_gpg_decrypt(const gchar* const cipher);
 void p_gpg_free_decrypted(gchar* decrypted);
 gchar* p_gpg_autocomplete_key(const gchar* const search_str, gboolean previous, void* context);

src/ui/console.c

@@ -1703,6 +1703,11 @@ cons_notify_setting(void)
     else
         cons_show("Subscription requests (/notify sub) : OFF");
 
+    if (prefs_get_boolean(PREF_AUTOPING_WARNING))
+        cons_show("Autoping warning (/autoping warning): ON");
+    else
+        cons_show("Autoping warning (/autoping warning): OFF");
+
     gint remind_period = prefs_get_notify_remind();
     if (remind_period == 0) {
         cons_show("Reminder period (/notify remind)    : OFF");
@@ -2003,21 +2008,26 @@ cons_autoping_setting(void)
 {
     gint autoping_interval = prefs_get_autoping();
     if (autoping_interval == 0) {
-        cons_show("Autoping interval (/autoping)   : OFF");
+        cons_show("Autoping interval (/autoping)       : OFF");
     } else if (autoping_interval == 1) {
-        cons_show("Autoping interval (/autoping)   : 1 second");
+        cons_show("Autoping interval (/autoping)       : 1 second");
     } else {
-        cons_show("Autoping interval (/autoping)   : %d seconds", autoping_interval);
+        cons_show("Autoping interval (/autoping)       : %d seconds", autoping_interval);
     }
 
     gint autoping_timeout = prefs_get_autoping_timeout();
     if (autoping_timeout == 0) {
-        cons_show("Autoping timeout (/autoping)    : OFF");
+        cons_show("Autoping timeout (/autoping)        : OFF");
     } else if (autoping_timeout == 1) {
-        cons_show("Autoping timeout (/autoping)    : 1 second");
+        cons_show("Autoping timeout (/autoping)        : 1 second");
     } else {
-        cons_show("Autoping timeout (/autoping)    : %d seconds", autoping_timeout);
+        cons_show("Autoping timeout (/autoping)        : %d seconds", autoping_timeout);
     }
+
+    if (prefs_get_boolean(PREF_AUTOPING_WARNING))
+        cons_show("Autoping warning (/autoping warning): ON");
+    else
+        cons_show("Autoping warning (/autoping warning): OFF");
 }
 
 void

src/ui/window.c

@@ -43,7 +43,7 @@
 #include "ai/ai_client.h"
 
 static const int PAD_MIN_HEIGHT = 100;
-static const int PAD_THRESHOLD = 12000; // above buffer cap (~9000): reclaims dead pad space, never fires while scrolling
+static const int PAD_DEAD_SPACE_LIMIT = 2000; // reclaim once the pad holds this much dead space (cursor past live buffer); size-independent, so it never fires while scrolling
 static gboolean _in_redraw = FALSE;
 
 static void
@@ -56,9 +56,10 @@ _win_ensure_pad_capacity(ProfWin* window, WINDOW* win, int lines_needed)
     int cur_height = getmaxy(win);
     int cur_width = getmaxx(win);
     if (lines_needed >= cur_height - 1) {
-        // If we are getting too large, trigger a redraw to clean up old lines
-        // but only if we are not already in a redraw process.
-        if (window && cur_height >= PAD_THRESHOLD && !_in_redraw) {
+        // redraw to reclaim dead pad space (cursor far past live buffer, e.g. a long
+        // append-only session); dead space never accrues while scrolling, only here
+        int dead = window ? getcury(win) - window->layout->buffer->lines : 0;
+        if (window && dead > PAD_DEAD_SPACE_LIMIT && !_in_redraw) {
             win_redraw(window);
         } else {
             // resize to required lines + some buffer for next messages

src/xmpp/iq.c

@@ -99,6 +99,7 @@ static void _disco_items_result_handler(xmpp_stanza_t* const stanza);
 static void _last_activity_get_handler(xmpp_stanza_t* const stanza);
 static void _version_get_handler(xmpp_stanza_t* const stanza);
 static void _ping_get_handler(xmpp_stanza_t* const stanza);
+static void _disco_autoping_warning_message(GHashTable* features);
 
 static int _version_result_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
 static int _disco_info_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata);
@@ -2429,6 +2430,12 @@ _disco_info_response_id_handler_onconnect(xmpp_stanza_t* const stanza, void* con
             }
             child = xmpp_stanza_get_next(child);
         }
+
+        // Prevent repetitions by avoiding checks of disco items (from connection_set_disco_items)
+        const char* domain = connection_get_domain();
+        if (from && domain && g_ascii_strcasecmp(from, domain) == 0) {
+            _disco_autoping_warning_message(features);
+        }
     }
 
     connection_features_received(from);
@@ -2436,6 +2443,21 @@ _disco_info_response_id_handler_onconnect(xmpp_stanza_t* const stanza, void* con
     return 0;
 }
 
+static void
+_disco_autoping_warning_message(GHashTable* features)
+{
+    gboolean server_supports_ping = g_hash_table_contains(features, "urn:xmpp:ping");
+    gboolean user_prefers_warning = prefs_get_boolean(PREF_AUTOPING_WARNING);
+    gboolean is_autoping_enabled = prefs_get_autoping() != 0;
+
+    if (!is_autoping_enabled && server_supports_ping && user_prefers_warning) {
+        cons_show("This server supports XEP-0199: XMPP Ping (better keepalive detection),\n"
+                  "but autoping feature is currently disabled in settings.\n"
+                  "Consider enabling it (e.g., `/autoping set 30`) for improved connection stability.\n"
+                  "Use `/autoping warning off` to disable this message.");
+    }
+}
+
 static int
 _http_upload_response_id_handler(xmpp_stanza_t* const stanza, void* const userdata)
 {

src/xmpp/message.c

@@ -467,12 +467,15 @@ message_send_chat_pgp(const char* const barejid, const char* const msg, gboolean
     auto_char char* jid = chat_session_get_jid(barejid);
     char* id = connection_create_stanza_id();
 
+    ProfWin* current = wins_get_current();
+
     xmpp_stanza_t* message = NULL;
 #ifdef HAVE_LIBGPGME
     ProfAccount* account = accounts_get_account(session_get_account_name());
     if (account->pgp_keyid) {
         auto_jid Jid* jidp = jid_create(jid);
-        auto_gchar gchar* encrypted = p_gpg_encrypt(jidp->barejid, msg, account->pgp_keyid);
+        auto_gchar gchar* err = NULL;
+        auto_gchar gchar* encrypted = p_gpg_encrypt(jidp->barejid, msg, account->pgp_keyid, &err);
         if (encrypted) {
             message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
             xmpp_message_set_body(message, "This message is encrypted (XEP-0027).");
@@ -486,18 +489,31 @@ message_send_chat_pgp(const char* const barejid, const char* const msg, gboolean
             xmpp_stanza_add_child(message, x);
             xmpp_stanza_release(x);
         } else {
-            message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
-            xmpp_message_set_body(message, msg);
+            if (current) {
+                win_println(current, THEME_ERROR, "-", "Unable to encrypt message for %s: %s.", jid, err);
+            }
+            log_error("Message not encrypted for %s: %s.", jid, err);
+            account_free(account);
+            free(id);
+            return NULL;
         }
     } else {
-        message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
-        xmpp_message_set_body(message, msg);
+        if (current) {
+            win_println(current, THEME_ERROR, "-", "No PGP key configured for this account.");
+        }
+        log_error("No PGP key configured, message not sent.");
+        account_free(account);
+        free(id);
+        return NULL;
     }
     account_free(account);
 #else
-    // ?
-    message = xmpp_message_new(ctx, STANZA_TYPE_CHAT, jid, id);
-    xmpp_message_set_body(message, msg);
+    if (current) {
+        win_println(current, THEME_ERROR, "-", "LibGPGME not available, message not sent.");
+    }
+    log_error("LibGPGME not available, message not sent.");
+    free(id);
+    return NULL;
 #endif
 
     if (state) {
@@ -546,7 +562,10 @@ message_send_chat_ox(const char* const barejid, const char* const msg, gboolean
     xmpp_stanza_to_text(signcrypt, &c, &s);
     char* signcrypt_e = p_ox_gpg_signcrypt(account->jid, barejid, c);
     if (signcrypt_e == NULL) {
-        cons_show("Unable to send OX message. Check log file and profanity-ox-setup man page for details.");
+        ProfWin* current = wins_get_current();
+        if (current) {
+            win_println(current, THEME_ERROR, "-", "Unable to send OX message. Check log file and profanity-ox-setup man page for details.");
+        }
         log_error("Message not signcrypted.");
         return NULL;
     }

tests/functionaltests/functionaltests.c

@@ -150,6 +150,14 @@ main(int argc, char* argv[])
         PROF_FUNC_TEST(autoping_sends_ping_after_interval),
         PROF_FUNC_TEST(autoping_server_not_supporting_ping),
 
+        /* Autoping availability warning - negative cases wait ~3s */
+        PROF_FUNC_TEST(autoping_warning_shown_when_disabled),
+        PROF_FUNC_TEST(autoping_warning_not_shown_when_server_unsupported),
+        PROF_FUNC_TEST(autoping_warning_not_shown_when_autoping_enabled),
+        PROF_FUNC_TEST(autoping_warning_not_shown_when_user_disabled),
+        PROF_FUNC_TEST(autoping_warning_not_shown_for_user_jid),
+        PROF_FUNC_TEST(autoping_warning_not_shown_for_subdomain_service),
+
         /* Service Discovery - XEP-0030 */
         PROF_FUNC_TEST(disco_info_shows_identity),
         PROF_FUNC_TEST(disco_info_shows_features),

tests/functionaltests/test_ai.c

@@ -55,11 +55,11 @@ ai_no_args_shows_help(void** state)
 void
 ai_providers_lists_defaults(void** state)
 {
-    /* `/ai providers` (no "list") shows the built-in list with URLs. */
+    /* `/ai providers` (no "list") shows the configured list with URLs. */
     prof_input("/ai providers");
 
     prof_timeout(5);
-    assert_true(prof_output_exact("Available AI providers:"));
+    assert_true(prof_output_exact("Configured providers:"));
     /* At least one URL line is rendered — exact name agnostic. */
     assert_true(prof_output_regex("https?://"));
     prof_timeout_reset();

tests/functionaltests/test_autoping.c

@@ -112,3 +112,144 @@ autoping_server_not_supporting_ping(void** state)
     // Should show error about ping not being supported
     assert_true(prof_output_regex("Server ping not supported"));
 }
+
+/*
+ * Autoping availability warning.
+ *
+ * The warning fires from the on-connect disco handler, so the three inputs
+ * (server ping support, autoping interval, warning preference) must all be
+ * set before prof_connect().
+ */
+
+/* Stable substring of the warning text emitted by iq.c. */
+#define AUTOPING_WARNING_MATCH "This server supports XEP-0199"
+
+static void
+_stub_server_disco(gboolean with_ping)
+{
+    if (with_ping) {
+        stbbr_for_query("http://jabber.org/protocol/disco#info",
+            "<iq to='stabber@localhost/profanity' type='result' from='localhost'>"
+                "<query xmlns='http://jabber.org/protocol/disco#info'>"
+                    "<identity category='server' type='im' name='Stabber'/>"
+                    "<feature var='urn:xmpp:ping'/>"
+                "</query>"
+            "</iq>"
+        );
+    } else {
+        stbbr_for_query("http://jabber.org/protocol/disco#info",
+            "<iq to='stabber@localhost/profanity' type='result' from='localhost'>"
+                "<query xmlns='http://jabber.org/protocol/disco#info'>"
+                    "<identity category='server' type='im' name='Stabber'/>"
+                "</query>"
+            "</iq>"
+        );
+    }
+}
+
+void
+autoping_warning_shown_when_disabled(void** state)
+{
+    // All conditions met: server supports ping, autoping off, warning on (default).
+    _stub_server_disco(TRUE);
+
+    prof_input("/autoping set 0");
+    assert_true(prof_output_exact("Autoping disabled."));
+
+    prof_connect();
+
+    assert_true(prof_output_regex(AUTOPING_WARNING_MATCH));
+}
+
+void
+autoping_warning_not_shown_when_server_unsupported(void** state)
+{
+    // Server does not advertise urn:xmpp:ping -> no warning even with autoping off.
+    _stub_server_disco(FALSE);
+
+    prof_input("/autoping set 0");
+    assert_true(prof_output_exact("Autoping disabled."));
+
+    prof_connect();
+
+    prof_timeout(NEGATIVE_ASSERT_TIMEOUT);
+    assert_false(prof_output_regex(AUTOPING_WARNING_MATCH));
+}
+
+void
+autoping_warning_not_shown_when_autoping_enabled(void** state)
+{
+    // Warning is suppressed while autoping is enabled.
+    _stub_server_disco(TRUE);
+
+    prof_input("/autoping set 30");
+    assert_true(prof_output_exact("Autoping interval set to 30 seconds."));
+
+    prof_connect();
+
+    prof_timeout(NEGATIVE_ASSERT_TIMEOUT);
+    assert_false(prof_output_regex(AUTOPING_WARNING_MATCH));
+}
+
+void
+autoping_warning_not_shown_when_user_disabled(void** state)
+{
+    // User opted out -> no warning.
+    _stub_server_disco(TRUE);
+
+    prof_input("/autoping set 0");
+    assert_true(prof_output_exact("Autoping disabled."));
+
+    prof_input("/autoping warning off");
+    assert_true(prof_output_exact("Autoping availability warning disabled."));
+
+    prof_connect();
+
+    prof_timeout(NEGATIVE_ASSERT_TIMEOUT);
+    assert_false(prof_output_regex(AUTOPING_WARNING_MATCH));
+}
+
+void
+autoping_warning_not_shown_for_user_jid(void** state)
+{
+    // disco#info from a user JID (with '@') should not trigger the warning,
+    // only server responses (no '@') should.
+    stbbr_for_query("http://jabber.org/protocol/disco#info",
+        "<iq to='stabber@localhost/profanity' type='result' from='buddy1@localhost'>"
+            "<query xmlns='http://jabber.org/protocol/disco#info'>"
+                "<identity category='person' type='chat' name='Buddy1'/>"
+                "<feature var='urn:xmpp:ping'/>"
+            "</query>"
+        "</iq>"
+    );
+
+    prof_input("/autoping set 0");
+    assert_true(prof_output_exact("Autoping disabled."));
+
+    prof_connect();
+
+    prof_timeout(NEGATIVE_ASSERT_TIMEOUT);
+    assert_false(prof_output_regex(AUTOPING_WARNING_MATCH));
+}
+
+void
+autoping_warning_not_shown_for_subdomain_service(void** state)
+{
+    // disco#info from a subdomain service should not trigger the warning, only the server's own domain should
+    stbbr_for_query("http://jabber.org/protocol/disco#info",
+        "<iq to='stabber@localhost/profanity' type='result' from='conf.localhost'>"
+            "<query xmlns='http://jabber.org/protocol/disco#info'>"
+                "<identity category='conference' type='text' name='Conference Service'/>"
+                "<feature var='urn:xmpp:ping'/>"
+            "</query>"
+        "</iq>"
+    );
+
+    prof_input("/autoping set 0");
+    assert_true(prof_output_exact("Autoping disabled."));
+
+    prof_connect();
+
+    prof_timeout(NEGATIVE_ASSERT_TIMEOUT);
+    assert_false(prof_output_regex(AUTOPING_WARNING_MATCH));
+}

tests/functionaltests/test_autoping.h

@@ -4,3 +4,9 @@ void autoping_timeout_set(void** state);
 void autoping_timeout_zero_disables(void** state);
 void autoping_sends_ping_after_interval(void** state);
 void autoping_server_not_supporting_ping(void** state);
+void autoping_warning_shown_when_disabled(void** state);
+void autoping_warning_not_shown_when_server_unsupported(void** state);
+void autoping_warning_not_shown_when_autoping_enabled(void** state);
+void autoping_warning_not_shown_when_user_disabled(void** state);
+void autoping_warning_not_shown_for_user_jid(void** state);
+void autoping_warning_not_shown_for_subdomain_service(void** state);

tests/unittests/test_ai_client.c

@@ -62,12 +62,10 @@ test_ai_add_provider(void** state)
     assert_string_equal("custom", provider->name);
     assert_string_equal("https://custom.api.com/v1", provider->api_url);
 
-    /* Update existing provider (returns ref; caller owns it) */
+    /* Update existing provider (borrowed pointer, same as the create path) */
     AIProvider* updated = ai_add_provider("custom", "https://new.api.com/v1");
     assert_non_null(updated);
     assert_string_equal("https://new.api.com/v1", updated->api_url);
-
-    ai_provider_unref(updated);
 }
 
 void
@@ -329,11 +327,10 @@ test_ai_add_provider_update_existing(void** state)
     assert_non_null(provider);
     assert_string_equal("https://first.api.com/v1", provider->api_url);
 
-    /* Update the same provider (returns ref) */
+    /* Update the same provider (borrowed pointer) */
     provider = ai_add_provider("custom", "https://second.api.com/v1");
     assert_non_null(provider);
     assert_string_equal("https://second.api.com/v1", provider->api_url);
-    ai_provider_unref(provider);
 }
 
 void
@@ -614,6 +611,112 @@ test_ai_set_provider_setting(void** state)
     assert_null(ai_get_provider_setting("p_set_settings", "nonexistent_setting"));
 }
 
+void
+test_ai_set_provider_setting_reserved_key(void** state)
+{
+    ai_add_provider("p_reserved_keys", "https://example.test/rk/");
+
+    /* Reserved payload keys are rejected (would duplicate fixed fields) */
+    assert_false(ai_set_provider_setting("p_reserved_keys", "model", "x"));
+    assert_false(ai_set_provider_setting("p_reserved_keys", "messages", "[]"));
+    assert_false(ai_set_provider_setting("p_reserved_keys", "input", "[]"));
+    assert_false(ai_set_provider_setting("p_reserved_keys", "stream", "true"));
+    assert_null(ai_get_provider_setting("p_reserved_keys", "model"));
+
+    /* "store" is a legitimate chat-completions parameter and overrides the
+     * responses-flavour "store":false default, so it stays settable */
+    assert_true(ai_set_provider_setting("p_reserved_keys", "store", "true"));
+    auto_gchar gchar* store = ai_get_provider_setting("p_reserved_keys", "store");
+    assert_non_null(store);
+    assert_string_equal("true", store);
+
+    /* Ordinary keys still work */
+    assert_true(ai_set_provider_setting("p_reserved_keys", "temperature", "0.7"));
+    auto_gchar gchar* temp = ai_get_provider_setting("p_reserved_keys", "temperature");
+    assert_non_null(temp);
+    assert_string_equal("0.7", temp);
+}
+
+void
+test_ai_get_provider_setting_keys(void** state)
+{
+    ai_add_provider("p_setting_keys", "https://example.test/skeys/");
+
+    /* No settings yet, unknown provider, NULL — all yield NULL */
+    assert_null(ai_get_provider_setting_keys("p_setting_keys"));
+    assert_null(ai_get_provider_setting_keys("nonexistent"));
+    assert_null(ai_get_provider_setting_keys(NULL));
+
+    ai_set_provider_setting("p_setting_keys", "temperature", "0.7");
+    ai_set_provider_setting("p_setting_keys", "reasoning_effort", "high");
+
+    /* Both keys listed (order is hash-defined, assert membership) */
+    GList* keys = ai_get_provider_setting_keys("p_setting_keys");
+    assert_int_equal(2, g_list_length(keys));
+    assert_non_null(g_list_find_custom(keys, "temperature", (GCompareFunc)g_strcmp0));
+    assert_non_null(g_list_find_custom(keys, "reasoning_effort", (GCompareFunc)g_strcmp0));
+    g_list_free_full(keys, g_free);
+
+    /* Removing a setting removes its key */
+    ai_set_provider_setting("p_setting_keys", "temperature", NULL);
+    keys = ai_get_provider_setting_keys("p_setting_keys");
+    assert_int_equal(1, g_list_length(keys));
+    assert_string_equal("reasoning_effort", keys->data);
+    g_list_free_full(keys, g_free);
+}
+
+void
+test_ai_set_provider_api_type(void** state)
+{
+    ai_add_provider("p_api_type", "https://example.test/at/");
+
+    /* Default is auto */
+    assert_int_equal(AI_API_TYPE_AUTO, ai_get_provider_api_type("p_api_type"));
+
+    /* Pin each flavour explicitly */
+    assert_true(ai_set_provider_api_type("p_api_type", "chat-completions"));
+    assert_int_equal(AI_API_TYPE_CHAT_COMPLETIONS, ai_get_provider_api_type("p_api_type"));
+
+    assert_true(ai_set_provider_api_type("p_api_type", "responses"));
+    assert_int_equal(AI_API_TYPE_RESPONSES, ai_get_provider_api_type("p_api_type"));
+
+    /* auto resets to detection */
+    assert_true(ai_set_provider_api_type("p_api_type", "auto"));
+    assert_int_equal(AI_API_TYPE_AUTO, ai_get_provider_api_type("p_api_type"));
+
+    /* Invalid values and unknown providers are rejected */
+    assert_false(ai_set_provider_api_type("p_api_type", "v2"));
+    assert_false(ai_set_provider_api_type("p_api_type", NULL));
+    assert_false(ai_set_provider_api_type("nonexistent", "responses"));
+    assert_false(ai_set_provider_api_type(NULL, "responses"));
+
+    /* Unknown provider reads as auto */
+    assert_int_equal(AI_API_TYPE_AUTO, ai_get_provider_api_type("nonexistent"));
+    assert_int_equal(AI_API_TYPE_AUTO, ai_get_provider_api_type(NULL));
+}
+
+void
+test_ai_api_type_string_round_trip(void** state)
+{
+    AIApiType type = AI_API_TYPE_AUTO;
+
+    assert_true(ai_api_type_from_string("responses", &type));
+    assert_int_equal(AI_API_TYPE_RESPONSES, type);
+    assert_string_equal("responses", ai_api_type_to_string(type));
+
+    assert_true(ai_api_type_from_string("chat-completions", &type));
+    assert_int_equal(AI_API_TYPE_CHAT_COMPLETIONS, type);
+    assert_string_equal("chat-completions", ai_api_type_to_string(type));
+
+    assert_true(ai_api_type_from_string("auto", &type));
+    assert_int_equal(AI_API_TYPE_AUTO, type);
+    assert_string_equal("auto", ai_api_type_to_string(type));
+
+    assert_false(ai_api_type_from_string("completions", &type));
+    assert_false(ai_api_type_from_string("", &type));
+    assert_false(ai_api_type_from_string(NULL, &type));
+}
+
 void
 test_ai_get_provider_setting(void** state)
 {
@@ -919,8 +1022,10 @@ test_ai_parse_response_openai_content(void** state)
 }
 
 void
-test_ai_parse_response_perplexity_text(void** state)
+test_ai_parse_response_responses_output_text(void** state)
 {
+    /* Responses API: "content" is an array of typed parts; the inner "text"
+     * of the output_text part is the assistant message. */
     const gchar* json = "{\"output\":[{\"content\":[{\"text\":\"Search result\",\"type\":\"output_text\"}]}]}";
     auto_gchar gchar* out = ai_parse_response(json);
     assert_non_null(out);
@@ -928,13 +1033,180 @@ test_ai_parse_response_perplexity_text(void** state)
 }
 
 void
-test_ai_parse_response_text_preferred_over_content(void** state)
+test_ai_parse_response_responses_full_envelope(void** state)
 {
-    /* When both formats are present, "text" wins (Perplexity path tried first). */
+    /* Realistic responses body: a reasoning item precedes the message item;
+     * the parser must still land on the message's output_text. */
+    const gchar* json = "{\"id\":\"resp_1\",\"object\":\"response\",\"status\":\"completed\","
+                        "\"output\":["
+                        "{\"id\":\"rs_1\",\"type\":\"reasoning\",\"summary\":[]},"
+                        "{\"id\":\"msg_1\",\"type\":\"message\",\"status\":\"completed\",\"role\":\"assistant\","
+                        "\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"text\":\"Hello!\"}]}"
+                        "]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("Hello!", out);
+}
+
+void
+test_ai_parse_response_choices_win_over_output(void** state)
+{
+    /* A chat-completions envelope is authoritative even if the content
+     * happens to mention "output". */
+    const gchar* json = "{\"choices\":[{\"message\":{\"content\":\"chat result\"}}],\"output\":[{\"content\":[{\"text\":\"wrong\"}]}]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("chat result", out);
+}
+
+void
+test_ai_parse_response_responses_reasoning_summary_skipped(void** state)
+{
+    /* A reasoning item with a non-empty summary precedes the message item;
+     * the summary's "text" must not be mistaken for the assistant reply. */
+    const gchar* json = "{\"output\":["
+                        "{\"id\":\"rs_1\",\"type\":\"reasoning\",\"summary\":[{\"type\":\"summary_text\",\"text\":\"User asks X\"}]},"
+                        "{\"id\":\"msg_1\",\"type\":\"message\",\"status\":\"completed\",\"role\":\"assistant\","
+                        "\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"text\":\"Actual answer\"}]}"
+                        "]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("Actual answer", out);
+}
+
+void
+test_ai_parse_response_responses_reasoning_only_returns_null(void** state)
+{
+    /* An incomplete/truncated body with only a reasoning item (no message
+     * "content" array at all) must yield a parse failure, not leak the
+     * reasoning summary's "text" as the assistant reply. */
+    const gchar* json = "{\"status\":\"incomplete\",\"output\":["
+                        "{\"type\":\"reasoning\",\"summary\":[{\"type\":\"summary_text\",\"text\":\"secret reasoning\"}]}"
+                        "]}";
+    gchar* out = ai_parse_response(json);
+    assert_null(out);
+}
+
+void
+test_ai_parse_response_responses_reasoning_after_message_skipped(void** state)
+{
+    /* A reasoning item ordered after the message, with the part's "text"
+     * preceding "type":"output_text": the forward scan must stay inside the
+     * part's object and the backscan must find the real answer. */
+    const gchar* json = "{\"output\":["
+                        "{\"type\":\"message\",\"content\":[{\"text\":\"answer\",\"type\":\"output_text\"}]},"
+                        "{\"type\":\"reasoning\",\"summary\":[{\"type\":\"summary_text\",\"text\":\"secret\"}]}"
+                        "]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("answer", out);
+}
+
+void
+test_ai_parse_response_responses_empty_content_not_leaked(void** state)
+{
+    /* An empty content array followed by a reasoning item must yield a parse
+     * failure; the scan must not escape the array and return the summary. */
+    const gchar* json = "{\"output\":["
+                        "{\"type\":\"message\",\"content\":[]},"
+                        "{\"type\":\"reasoning\",\"summary\":[{\"type\":\"summary_text\",\"text\":\"secret\"}]}"
+                        "]}";
+    gchar* out = ai_parse_response(json);
+    assert_null(out);
+}
+
+void
+test_ai_parse_response_responses_text_value_before_later_item(void** state)
+{
+    /* A reply that is exactly "text" plus a reasoning item after the message:
+     * the backscan's own extraction must also stay inside the part's object. */
+    const gchar* json = "{\"output\":["
+                        "{\"type\":\"message\",\"content\":[{\"text\":\"text\",\"type\":\"output_text\"}]},"
+                        "{\"type\":\"reasoning\",\"summary\":[{\"type\":\"summary_text\",\"text\":\"secret\"}]}"
+                        "]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("text", out);
+}
+
+void
+test_ai_parse_response_choices_in_string_value(void** state)
+{
+    /* "choices" occurring as a string value must not hijack a valid
+     * responses envelope. */
+    const gchar* json = "{\"kind\":\"choices\",\"output\":[{\"content\":[{\"type\":\"output_text\",\"text\":\"hi\"}]}]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("hi", out);
+}
+
+void
+test_ai_parse_response_content_before_choices(void** state)
+{
+    /* Nonstandard body: a top-level content string precedes an empty
+     * choices array; the bare-content fallback must still find it. */
+    const gchar* json = "{\"content\":\"hi\",\"choices\":[]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("hi", out);
+}
+
+void
+test_ai_parse_response_content_preferred_over_text(void** state)
+{
+    /* Chat-completions "content" is extracted; a stray "text" field is ignored. */
     const gchar* json = "{\"text\":\"from text field\",\"content\":\"from content field\"}";
     auto_gchar gchar* out = ai_parse_response(json);
     assert_non_null(out);
-    assert_string_equal("from text field", out);
+    assert_string_equal("from content field", out);
+}
+
+void
+test_ai_parse_response_responses_brace_in_text(void** state)
+{
+    /* Responses part with "text" before "type":"output_text" and a '{' inside
+     * the answer: the nearest preceding "text" key must be extracted, not a
+     * brace inside the string value. */
+    const gchar* json = "{\"output\":[{\"content\":[{\"text\":\"use { here\",\"type\":\"output_text\"}]}]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("use { here", out);
+}
+
+void
+test_ai_parse_response_choices_logprobs_before_content(void** state)
+{
+    /* A non-string "content" (logprobs array) ordered before message.content
+     * must not defeat extraction; anchoring on "message" finds the reply. */
+    const gchar* json = "{\"choices\":[{\"logprobs\":{\"content\":[{\"token\":\"hi\"}]},"
+                        "\"message\":{\"role\":\"assistant\",\"content\":\"real answer\"}}]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("real answer", out);
+}
+
+void
+test_ai_parse_response_reasoning_not_leaked_without_text(void** state)
+{
+    /* An output_text part with no "text" at all (truncated body) must yield a
+     * parse failure, not leak the preceding reasoning summary's text. */
+    const gchar* json = "{\"output\":["
+                        "{\"type\":\"reasoning\",\"summary\":[{\"type\":\"summary_text\",\"text\":\"secret\"}]},"
+                        "{\"type\":\"message\",\"content\":[{\"type\":\"output_text\",\"annotations\":[]}]}"
+                        "]}";
+    gchar* out = ai_parse_response(json);
+    assert_null(out);
+}
+
+void
+test_ai_parse_response_responses_text_value_text(void** state)
+{
+    /* A reply that is exactly the string "text" must not confuse the
+     * backscan (the value's own quoted bytes match the key needle). */
+    const gchar* json = "{\"output\":[{\"content\":[{\"text\":\"text\",\"type\":\"output_text\"}]}]}";
+    auto_gchar gchar* out = ai_parse_response(json);
+    assert_non_null(out);
+    assert_string_equal("text", out);
 }
 
 void
@@ -1474,6 +1746,26 @@ test_ai_prefs_round_trip_remove_key(void** state)
     assert_null(after);
 }
 
+void
+test_ai_prefs_round_trip_api_type(void** state)
+{
+    ai_add_provider("p_persist_api_type", "https://example.test/pat/");
+    assert_true(ai_set_provider_api_type("p_persist_api_type", "chat-completions"));
+
+    ai_client_shutdown();
+    ai_client_init();
+
+    assert_int_equal(AI_API_TYPE_CHAT_COMPLETIONS, ai_get_provider_api_type("p_persist_api_type"));
+
+    /* Setting auto removes the persisted value */
+    assert_true(ai_set_provider_api_type("p_persist_api_type", "auto"));
+
+    ai_client_shutdown();
+    ai_client_init();
+
+    assert_int_equal(AI_API_TYPE_AUTO, ai_get_provider_api_type("p_persist_api_type"));
+}
+
 void
 test_ai_prefs_multiple_providers_persist(void** state)
 {

tests/unittests/test_ai_client.h

@@ -43,6 +43,10 @@ void test_ai_providers_find_case_insensitive(void** state);
 void test_ai_set_provider_default_model(void** state);
 void test_ai_get_provider_default_model(void** state);
 void test_ai_set_provider_setting(void** state);
+void test_ai_set_provider_setting_reserved_key(void** state);
+void test_ai_get_provider_setting_keys(void** state);
+void test_ai_set_provider_api_type(void** state);
+void test_ai_api_type_string_round_trip(void** state);
 void test_ai_get_provider_setting(void** state);
 /* Model caching tests */
 void test_ai_models_are_fresh_initial(void** state);
@@ -64,8 +68,21 @@ int ai_client_teardown_with_prefs(void** state);
 
 /* Chat response parser tests (ai_parse_response) */
 void test_ai_parse_response_openai_content(void** state);
-void test_ai_parse_response_perplexity_text(void** state);
-void test_ai_parse_response_text_preferred_over_content(void** state);
+void test_ai_parse_response_responses_output_text(void** state);
+void test_ai_parse_response_responses_full_envelope(void** state);
+void test_ai_parse_response_responses_reasoning_summary_skipped(void** state);
+void test_ai_parse_response_choices_win_over_output(void** state);
+void test_ai_parse_response_choices_in_string_value(void** state);
+void test_ai_parse_response_content_before_choices(void** state);
+void test_ai_parse_response_content_preferred_over_text(void** state);
+void test_ai_parse_response_responses_brace_in_text(void** state);
+void test_ai_parse_response_choices_logprobs_before_content(void** state);
+void test_ai_parse_response_reasoning_not_leaked_without_text(void** state);
+void test_ai_parse_response_responses_reasoning_only_returns_null(void** state);
+void test_ai_parse_response_responses_reasoning_after_message_skipped(void** state);
+void test_ai_parse_response_responses_empty_content_not_leaked(void** state);
+void test_ai_parse_response_responses_text_value_before_later_item(void** state);
+void test_ai_parse_response_responses_text_value_text(void** state);
 void test_ai_parse_response_escaped_quote(void** state);
 void test_ai_parse_response_newline_escape(void** state);
 void test_ai_parse_response_empty_content(void** state);
@@ -128,6 +145,7 @@ void test_ai_parse_models_multiple_models(void** state);
 /* Prefs round-trip tests */
 void test_ai_prefs_round_trip_api_key(void** state);
 void test_ai_prefs_round_trip_remove_key(void** state);
+void test_ai_prefs_round_trip_api_type(void** state);
 void test_ai_prefs_multiple_providers_persist(void** state);
 
 /* Autocomplete deeper coverage */

tests/unittests/unittests.c

@@ -752,6 +752,10 @@ main(int argc, char* argv[])
         cmocka_unit_test_setup_teardown(test_ai_set_provider_default_model, ai_client_setup, ai_client_teardown),
         cmocka_unit_test_setup_teardown(test_ai_get_provider_default_model, ai_client_setup, ai_client_teardown),
         cmocka_unit_test_setup_teardown(test_ai_set_provider_setting, ai_client_setup, ai_client_teardown),
+        cmocka_unit_test_setup_teardown(test_ai_set_provider_setting_reserved_key, ai_client_setup, ai_client_teardown),
+        cmocka_unit_test_setup_teardown(test_ai_get_provider_setting_keys, ai_client_setup, ai_client_teardown),
+        cmocka_unit_test_setup_teardown(test_ai_set_provider_api_type, ai_client_setup, ai_client_teardown),
+        cmocka_unit_test(test_ai_api_type_string_round_trip),
         cmocka_unit_test_setup_teardown(test_ai_get_provider_setting, ai_client_setup, ai_client_teardown),
         /* Model caching tests */
         cmocka_unit_test_setup_teardown(test_ai_models_are_fresh_initial, ai_client_setup, ai_client_teardown),
@@ -774,8 +778,21 @@ main(int argc, char* argv[])
         cmocka_unit_test(test_ai_json_escape_backslash_quote),
         /* Chat response parser */
         cmocka_unit_test(test_ai_parse_response_openai_content),
-        cmocka_unit_test(test_ai_parse_response_perplexity_text),
-        cmocka_unit_test(test_ai_parse_response_text_preferred_over_content),
+        cmocka_unit_test(test_ai_parse_response_responses_output_text),
+        cmocka_unit_test(test_ai_parse_response_responses_full_envelope),
+        cmocka_unit_test(test_ai_parse_response_responses_reasoning_summary_skipped),
+        cmocka_unit_test(test_ai_parse_response_choices_win_over_output),
+        cmocka_unit_test(test_ai_parse_response_choices_in_string_value),
+        cmocka_unit_test(test_ai_parse_response_content_before_choices),
+        cmocka_unit_test(test_ai_parse_response_content_preferred_over_text),
+        cmocka_unit_test(test_ai_parse_response_responses_brace_in_text),
+        cmocka_unit_test(test_ai_parse_response_choices_logprobs_before_content),
+        cmocka_unit_test(test_ai_parse_response_reasoning_not_leaked_without_text),
+        cmocka_unit_test(test_ai_parse_response_responses_reasoning_only_returns_null),
+        cmocka_unit_test(test_ai_parse_response_responses_reasoning_after_message_skipped),
+        cmocka_unit_test(test_ai_parse_response_responses_empty_content_not_leaked),
+        cmocka_unit_test(test_ai_parse_response_responses_text_value_before_later_item),
+        cmocka_unit_test(test_ai_parse_response_responses_text_value_text),
         cmocka_unit_test(test_ai_parse_response_escaped_quote),
         cmocka_unit_test(test_ai_parse_response_newline_escape),
         cmocka_unit_test(test_ai_parse_response_empty_content),
@@ -830,6 +847,7 @@ main(int argc, char* argv[])
         /* Prefs round-trip (uses prefs+ai setup) */
         cmocka_unit_test_setup_teardown(test_ai_prefs_round_trip_api_key, ai_client_setup_with_prefs, ai_client_teardown_with_prefs),
         cmocka_unit_test_setup_teardown(test_ai_prefs_round_trip_remove_key, ai_client_setup_with_prefs, ai_client_teardown_with_prefs),
+        cmocka_unit_test_setup_teardown(test_ai_prefs_round_trip_api_type, ai_client_setup_with_prefs, ai_client_teardown_with_prefs),
         cmocka_unit_test_setup_teardown(test_ai_prefs_multiple_providers_persist, ai_client_setup_with_prefs, ai_client_teardown_with_prefs),
         /* Autocomplete deeper coverage */
         cmocka_unit_test_setup_teardown(test_ai_providers_find_after_remove_skips_removed, ai_client_setup, ai_client_teardown),