chore(release): v0.2.9

Author: Bikz

.gitignore

@@ -39,3 +39,6 @@ node_modules/
 npm-debug.log*
 yarn-error.log*
 pnpm-debug.log*
+
+# Local contributor guide
+AGENTS.md

Cargo.lock

@@ -0,0 +1,38 @@
+# Releasing Good Commit
+
+Use this checklist to ship a new version with working Homebrew + npm updates.
+
+## 1) Bump versions
+
+- `crates/core/Cargo.toml`
+- `crates/cli/Cargo.toml`
+- `npm/package.json`
+- `homebrew/goodcommit.rb` (version + URLs; checksums are filled by CI)
+
+## 2) Commit and tag
+
+```bash
+git commit -am "chore(release): vX.Y.Z"
+git tag -a vX.Y.Z -m "vX.Y.Z"
+git push origin main vX.Y.Z
+```
+
+## 3) CI publishes artifacts
+
+- `release` workflow builds binaries and creates the GitHub release.
+- `publish-npm` runs after `release` and publishes `npm/package.json` (must match tag).
+- `publish-brew` runs on the GitHub release and updates the tap with checksums.
+
+If a workflow didn't run, trigger it manually:
+
+- `release`: push the tag again or re-run in GitHub Actions.
+- `publish-npm`: run workflow with the tag.
+- `publish-brew`: run workflow with the tag.
+
+## 4) Verify installs
+
+```bash
+brew upgrade goodcommit
+goodcommit --version
+npm view goodcommit version
+```

RELEASING.md

@@ -1,6 +1,6 @@
 [package]
 name = "goodcommit"
-version = "0.2.7"
+version = "0.2.9"
 edition = "2021"
 license = "MIT"
 description = "Good Commit: fast, reliable AI commit messages"

crates/cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "goodcommit-core"
-version = "0.2.7"
+version = "0.2.9"
 edition = "2021"
 license = "MIT"
 description = "Core library for Good Commit"

crates/core/Cargo.toml

@@ -98,21 +98,18 @@ impl OpenAiProvider {
         user_prompt: &str,
         request: ProviderRequest,
     ) -> CoreResult<String> {
-        let base = self.responses_base_payload(system_prompt, user_prompt, request.temperature);
+        let base = self.responses_base_payload(system_prompt, user_prompt, Some(request.temperature));
 
         match self
-            .complete_responses_with_param(&base, "max_output_tokens", request.max_output_tokens)
+            .complete_responses_with_fallbacks(&base, request.max_output_tokens)
             .await
         {
             Ok(message) => Ok(message),
             Err(err) => {
-                if is_unsupported_param(&err, "max_output_tokens") {
+                if is_unsupported_param(&err, "temperature") {
+                    let base = self.responses_base_payload(system_prompt, user_prompt, None);
                     return self
-                        .complete_responses_with_param(
-                            &base,
-                            "max_completion_tokens",
-                            request.max_output_tokens,
-                        )
+                        .complete_responses_with_fallbacks(&base, request.max_output_tokens)
                         .await;
                 }
                 Err(err)
@@ -126,33 +123,51 @@ impl OpenAiProvider {
         user_prompt: &str,
         request: ProviderRequest,
     ) -> CoreResult<String> {
-        let body = serde_json::json!({
-            "model": self.model,
-            "messages": [
-                { "role": "system", "content": system_prompt },
-                { "role": "user", "content": user_prompt }
-            ],
-            "max_tokens": request.max_output_tokens,
-            "temperature": request.temperature
-        });
+        let body = self.chat_payload(
+            system_prompt,
+            user_prompt,
+            request.max_output_tokens,
+            Some(request.temperature),
+        );
 
-        let request = self
+        let http_request = self
             .client
             .post(self.chat_url())
             .bearer_auth(&self.api_key)
             .json(&body);
 
-        let json = self.send_with_retries(request).await?;
+        let json = match self.send_with_retries(http_request).await {
+            Ok(json) => json,
+            Err(err) => {
+                if is_unsupported_param(&err, "temperature") {
+                    let body = self.chat_payload(
+                        system_prompt,
+                        user_prompt,
+                        request.max_output_tokens,
+                        None,
+                    );
+                    let http_request = self
+                        .client
+                        .post(self.chat_url())
+                        .bearer_auth(&self.api_key)
+                        .json(&body);
+                    let json = self.send_with_retries(http_request).await?;
+                    return parse_chat_output(&json);
+                }
+                return Err(err);
+            }
+        };
+
         parse_chat_output(&json)
     }
 
     fn responses_base_payload(
         &self,
         system_prompt: &str,
         user_prompt: &str,
-        temperature: f32,
+        temperature: Option<f32>,
     ) -> Value {
-        serde_json::json!({
+        let mut payload = serde_json::json!({
             "model": self.model,
             "input": [
                 {
@@ -163,9 +178,62 @@ impl OpenAiProvider {
                     "role": "user",
                     "content": [{ "type": "input_text", "text": user_prompt }]
                 }
+            ]
+        });
+
+        if let Some(obj) = payload.as_object_mut() {
+            if let Some(value) = temperature {
+                obj.insert("temperature".to_string(), serde_json::json!(value));
+            }
+        }
+
+        payload
+    }
+
+    fn chat_payload(
+        &self,
+        system_prompt: &str,
+        user_prompt: &str,
+        max_tokens: u32,
+        temperature: Option<f32>,
+    ) -> Value {
+        let mut payload = serde_json::json!({
+            "model": self.model,
+            "messages": [
+                { "role": "system", "content": system_prompt },
+                { "role": "user", "content": user_prompt }
             ],
-            "temperature": temperature
-        })
+            "max_tokens": max_tokens
+        });
+
+        if let Some(obj) = payload.as_object_mut() {
+            if let Some(value) = temperature {
+                obj.insert("temperature".to_string(), serde_json::json!(value));
+            }
+        }
+
+        payload
+    }
+
+    async fn complete_responses_with_fallbacks(
+        &self,
+        base: &Value,
+        max_tokens: u32,
+    ) -> CoreResult<String> {
+        match self
+            .complete_responses_with_param(base, "max_output_tokens", max_tokens)
+            .await
+        {
+            Ok(message) => Ok(message),
+            Err(err) => {
+                if is_unsupported_param(&err, "max_output_tokens") {
+                    return self
+                        .complete_responses_with_param(base, "max_completion_tokens", max_tokens)
+                        .await;
+                }
+                Err(err)
+            }
+        }
     }
 
     async fn complete_responses_with_param(
@@ -274,7 +342,7 @@ mod tests {
         )
         .expect("provider");
 
-        let payload = provider.responses_base_payload("system", "user", 0.2);
+        let payload = provider.responses_base_payload("system", "user", Some(0.2));
         let input = payload
             .get("input")
             .and_then(|value| value.as_array())
@@ -306,6 +374,46 @@ mod tests {
             Some("user")
         );
     }
+
+    #[test]
+    fn responses_payload_omits_temperature_when_none() {
+        let provider = OpenAiProvider::new(
+            "gpt-5-nano-2025-08-07".to_string(),
+            "https://api.openai.com/v1".to_string(),
+            OpenAiMode::Responses,
+            5,
+            Some("test-key".to_string()),
+        )
+        .expect("provider");
+
+        let payload = provider.responses_base_payload("system", "user", None);
+        assert!(payload.get("temperature").is_none());
+    }
+
+    #[test]
+    fn chat_payload_omits_temperature_when_none() {
+        let provider = OpenAiProvider::new(
+            "gpt-5-nano-2025-08-07".to_string(),
+            "https://api.openai.com/v1".to_string(),
+            OpenAiMode::Chat,
+            5,
+            Some("test-key".to_string()),
+        )
+        .expect("provider");
+
+        let payload = provider.chat_payload("system", "user", 100, None);
+        assert!(payload.get("temperature").is_none());
+    }
+
+    #[test]
+    fn unsupported_param_matches_openai_message() {
+        let err = CoreError::Provider(
+            "openai error 400 Bad Request: {\"error\": {\"message\": \"Unsupported parameter: 'temperature' is not supported with this model.\", \"type\": \"invalid_request_error\", \"param\": \"temperature\", \"code\": null}}"
+                .to_string(),
+        );
+
+        assert!(is_unsupported_param(&err, "temperature"));
+    }
 }
 
 fn should_retry(status: StatusCode) -> bool {
@@ -315,6 +423,8 @@ fn should_retry(status: StatusCode) -> bool {
 }
 
 fn is_unsupported_param(err: &CoreError, param: &str) -> bool {
-    let message = err.to_string();
-    message.contains("unsupported_parameter") && message.contains(param)
+    let message = err.to_string().to_lowercase();
+    let param = param.to_lowercase();
+    (message.contains("unsupported_parameter") || message.contains("unsupported parameter"))
+        && message.contains(&param)
 }

crates/core/src/providers/openai.rs

@@ -1,14 +1,14 @@
 class Goodcommit < Formula
   desc "Good Commit: fast, reliable AI commit messages"
   homepage "https://github.com/Bikz/goodcommit"
-  version "0.2.6"
+  version "0.2.9"
 
   on_macos do
     if Hardware::CPU.arm?
-      url "https://github.com/Bikz/goodcommit/releases/download/v0.2.6/goodcommit-aarch64-apple-darwin.tar.gz"
+      url "https://github.com/Bikz/goodcommit/releases/download/v0.2.9/goodcommit-aarch64-apple-darwin.tar.gz"
       sha256 "REPLACE_ME"
     else
-      url "https://github.com/Bikz/goodcommit/releases/download/v0.2.6/goodcommit-x86_64-apple-darwin.tar.gz"
+      url "https://github.com/Bikz/goodcommit/releases/download/v0.2.9/goodcommit-x86_64-apple-darwin.tar.gz"
       sha256 "REPLACE_ME"
     end
   end
@@ -18,7 +18,7 @@ class Goodcommit < Formula
       odie "linux arm64 builds are not yet available"
     end
 
-    url "https://github.com/Bikz/goodcommit/releases/download/v0.2.6/goodcommit-x86_64-unknown-linux-gnu.tar.gz"
+    url "https://github.com/Bikz/goodcommit/releases/download/v0.2.9/goodcommit-x86_64-unknown-linux-gnu.tar.gz"
     sha256 "REPLACE_ME"
   end
 

homebrew/goodcommit.rb

@@ -1,6 +1,6 @@
 {
   "name": "goodcommit",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Good Commit: fast, reliable AI commit messages",
   "license": "MIT",
   "repository": {