Add OpenAI Responses support and tighten PR comments

Author: haasonsaas

.diffscope.yml.example

@@ -9,6 +9,7 @@ max_tokens: 4000
 # API configuration (optional - can use environment variables)
 # api_key: your-api-key-here
 # base_url: https://api.openai.com/v1
+# openai_use_responses: true  # Use OpenAI Responses API instead of chat completions
 
 # Global exclude patterns
 exclude_patterns:
@@ -85,4 +86,4 @@ paths:
 plugins:
   eslint: true
   semgrep: true
-  duplicate_filter: true
+  duplicate_filter: true

.github/workflows/diffscope.yml

@@ -53,6 +53,7 @@ jobs:
                 body: `**${comment.severity}**: ${comment.content}`,
                 commit_id: headSha,
                 path: comment.file_path,
-                line: comment.line_number
+                line: comment.line_number,
+                side: "RIGHT"
               });
             }

README.md

@@ -182,6 +182,7 @@ model: gpt-4o
 temperature: 0.2
 max_tokens: 4000
 system_prompt: "Focus on security vulnerabilities, performance issues, and best practices"
+openai_use_responses: true  # Use OpenAI Responses API (recommended) instead of chat completions
 
 # Built-in plugins (enabled by default)
 plugins:
@@ -617,4 +618,4 @@ All binaries are automatically built and uploaded with each release.
 
 ## Support
 
-- GitHub Issues: [github.com/Haasonsaas/diffscope/issues](https://github.com/Haasonsaas/diffscope/issues)
+- GitHub Issues: [github.com/Haasonsaas/diffscope/issues](https://github.com/Haasonsaas/diffscope/issues)

src/adapters/llm.rs

@@ -9,6 +9,7 @@ pub struct ModelConfig {
     pub base_url: Option<String>,
     pub temperature: f32,
     pub max_tokens: usize,
+    pub openai_use_responses: Option<bool>,
 }
 
 impl Default for ModelConfig {
@@ -19,6 +20,7 @@ impl Default for ModelConfig {
             base_url: None,
             temperature: 0.2,
             max_tokens: 4000,
+            openai_use_responses: None,
         }
     }
 }

src/adapters/openai.rs

@@ -21,6 +21,15 @@ struct OpenAIRequest {
     max_tokens: usize,
 }
 
+#[derive(Serialize)]
+struct OpenAIResponsesRequest {
+    model: String,
+    input: String,
+    instructions: String,
+    temperature: f32,
+    max_output_tokens: usize,
+}
+
 #[derive(Serialize, Deserialize)]
 struct Message {
     role: String,
@@ -34,6 +43,29 @@ struct OpenAIResponse {
     model: String,
 }
 
+#[derive(Deserialize)]
+struct OpenAIResponsesResponse {
+    output: Vec<OpenAIResponseOutput>,
+    model: String,
+    #[serde(default)]
+    usage: Option<OpenAIResponsesUsage>,
+}
+
+#[derive(Deserialize)]
+struct OpenAIResponseOutput {
+    #[serde(rename = "type")]
+    output_type: String,
+    #[serde(default)]
+    content: Vec<OpenAIResponseContent>,
+}
+
+#[derive(Deserialize)]
+struct OpenAIResponseContent {
+    #[serde(rename = "type")]
+    content_type: String,
+    text: Option<String>,
+}
+
 #[derive(Deserialize)]
 struct Choice {
     message: Message,
@@ -46,6 +78,13 @@ struct OpenAIUsage {
     total_tokens: usize,
 }
 
+#[derive(Deserialize)]
+struct OpenAIResponsesUsage {
+    input_tokens: usize,
+    output_tokens: usize,
+    total_tokens: usize,
+}
+
 impl OpenAIAdapter {
     pub fn new(config: ModelConfig) -> Result<Self> {
         let api_key = config.api_key.clone()
@@ -109,6 +148,32 @@ impl OpenAIAdapter {
 #[async_trait]
 impl LLMAdapter for OpenAIAdapter {
     async fn complete(&self, request: LLMRequest) -> Result<LLMResponse> {
+        if should_use_responses_api(&self.config) {
+            return self.complete_responses(request).await;
+        }
+
+        self.complete_chat_completions(request).await
+    }
+
+    fn _model_name(&self) -> &str {
+        &self.config.model_name
+    }
+}
+
+fn is_retryable_status(status: StatusCode) -> bool {
+    status == StatusCode::TOO_MANY_REQUESTS || status.is_server_error()
+}
+
+fn should_use_responses_api(config: &ModelConfig) -> bool {
+    if let Some(flag) = config.openai_use_responses {
+        return flag;
+    }
+
+    !config.model_name.starts_with("gpt-3.5")
+}
+
+impl OpenAIAdapter {
+    async fn complete_chat_completions(&self, request: LLMRequest) -> Result<LLMResponse> {
         let messages = vec![
             Message {
                 role: "system".to_string(),
@@ -161,11 +226,65 @@ impl LLMAdapter for OpenAIAdapter {
         })
     }
 
-    fn _model_name(&self) -> &str {
-        &self.config.model_name
+    async fn complete_responses(&self, request: LLMRequest) -> Result<LLMResponse> {
+        let openai_request = OpenAIResponsesRequest {
+            model: self.config.model_name.clone(),
+            input: request.user_prompt,
+            instructions: request.system_prompt,
+            temperature: request.temperature.unwrap_or(self.config.temperature),
+            max_output_tokens: request.max_tokens.unwrap_or(self.config.max_tokens),
+        };
+
+        let url = format!("{}/responses", self.base_url);
+        let response = self
+            .send_with_retry(|| {
+                self.client
+                    .post(&url)
+                    .header("Authorization", format!("Bearer {}", self.api_key))
+                    .header("Content-Type", "application/json")
+                    .json(&openai_request)
+            })
+            .await
+            .context("Failed to send request to OpenAI")?;
+
+        let openai_response: OpenAIResponsesResponse = response
+            .json()
+            .await
+            .context("Failed to parse OpenAI response")?;
+
+        let content = extract_response_text(&openai_response);
+        let usage = openai_response.usage.map(|usage| Usage {
+            prompt_tokens: usage.input_tokens,
+            completion_tokens: usage.output_tokens,
+            total_tokens: usage.total_tokens,
+        });
+
+        Ok(LLMResponse {
+            content,
+            model: openai_response.model,
+            usage,
+        })
     }
 }
 
-fn is_retryable_status(status: StatusCode) -> bool {
-    status == StatusCode::TOO_MANY_REQUESTS || status.is_server_error()
+fn extract_response_text(response: &OpenAIResponsesResponse) -> String {
+    let mut combined = String::new();
+
+    for item in &response.output {
+        if item.output_type != "message" {
+            continue;
+        }
+        for content in &item.content {
+            if content.content_type == "output_text" {
+                if let Some(text) = &content.text {
+                    if !combined.is_empty() {
+                        combined.push('\n');
+                    }
+                    combined.push_str(text);
+                }
+            }
+        }
+    }
+
+    combined
 }

src/config.rs

@@ -18,6 +18,9 @@ pub struct Config {
     pub api_key: Option<String>,
     pub base_url: Option<String>,
 
+    #[serde(default)]
+    pub openai_use_responses: Option<bool>,
+
     #[serde(default)]
     pub plugins: PluginConfig,
 
@@ -78,6 +81,7 @@ impl Default for Config {
             system_prompt: None,
             api_key: None,
             base_url: None,
+            openai_use_responses: None,
             plugins: PluginConfig::default(),
             exclude_patterns: Vec::new(),
             paths: HashMap::new(),

src/main.rs

@@ -240,6 +240,7 @@ async fn review_command(
         base_url: config.base_url.clone(),
         temperature: config.temperature,
         max_tokens: config.max_tokens,
+        openai_use_responses: config.openai_use_responses,
     };
 
     let adapter = adapters::llm::create_adapter(&model_config)?;
@@ -498,6 +499,7 @@ async fn pr_command(
             base_url: config.base_url.clone(),
             temperature: config.temperature,
             max_tokens: config.max_tokens,
+            openai_use_responses: config.openai_use_responses,
         };
 
         let adapter = adapters::llm::create_adapter(&model_config)?;
@@ -560,6 +562,7 @@ async fn suggest_commit_message(config: config::Config) -> Result<()> {
         base_url: config.base_url.clone(),
         temperature: config.temperature,
         max_tokens: config.max_tokens,
+        openai_use_responses: config.openai_use_responses,
     };
 
     let adapter = adapters::llm::create_adapter(&model_config)?;
@@ -608,6 +611,7 @@ async fn suggest_pr_title(config: config::Config) -> Result<()> {
         base_url: config.base_url.clone(),
         temperature: config.temperature,
         max_tokens: config.max_tokens,
+        openai_use_responses: config.openai_use_responses,
     };
 
     let adapter = adapters::llm::create_adapter(&model_config)?;
@@ -742,6 +746,7 @@ async fn review_diff_content_raw(
         base_url: config.base_url.clone(),
         temperature: config.temperature,
         max_tokens: config.max_tokens,
+        openai_use_responses: config.openai_use_responses,
     };
 
     let adapter = adapters::llm::create_adapter(&model_config)?;
@@ -1164,6 +1169,7 @@ async fn smart_review_command(
         base_url: config.base_url.clone(),
         temperature: config.temperature,
         max_tokens: config.max_tokens,
+        openai_use_responses: config.openai_use_responses,
     };
 
     let adapter = adapters::llm::create_adapter(&model_config)?;