fix: correct OpenAI GPT-5.1 Responses API parsing and provider defaults

Fixed parsing errors for OpenAI GPT-5.1 and OpenAI-compatible providers:

OpenAI GPT-5.1 Response Structure:
- Changed from `type` to `object` field
- Updated output array structure: output[{type: "message", content: [{type: "output_text", text: "..."}]}]
- Fixed usage token field names (input_tokens instead of prompt_tokens)
- Added proper content extraction from nested message/content structure

OpenAI-Compatible Providers:
- Set Ollama to use Chat Completions API (doesn't support Responses API)
- Set LM Studio to use Chat Completions API (doesn't support Responses API)
- Changed default to Chat Completions API for broader compatibility
- Added debug logging to capture raw JSON responses for troubleshooting

Build & Test Improvements:
- Updated Makefile to include all LLM provider features (anthropic, openai-llm, openai-compatible)
- Enhanced test_agentic_mcp.py with traceback printing for better error visibility
- Added LIBRARY_PATH for FAISS linking on macOS

Files changed:
- crates/codegraph-ai/src/openai_llm_provider.rs: Fixed GPT-5.1 response structs and parsing
- crates/codegraph-ai/src/openai_compatible_provider.rs: Set Chat Completions as default, added debug logging
- Makefile: Added all LLM provider features to build command
- test_agentic_mcp.py: Added traceback printing for error details

Author: jruokola

Makefile

@@ -13,7 +13,7 @@ build-release:
 
 # Build MCP server with AutoAgents experimental feature
 build-mcp-autoagents:
-	cargo build --release -p codegraph-mcp --bin codegraph --features "ai-enhanced,autoagents-experimental,faiss,embeddings-ollama"
+	LIBRARY_PATH=/opt/homebrew/lib:$$LIBRARY_PATH cargo build --release -p codegraph-mcp --bin codegraph --features "ai-enhanced,autoagents-experimental,faiss,embeddings-ollama,codegraph-ai/anthropic,codegraph-ai/openai-llm,codegraph-ai/openai-compatible"
 
 # Build MCP HTTP server with experimental HTTP transport
 .PHONY: build-mcp-http

crates/codegraph-ai/src/openai_compatible_provider.rs

@@ -36,7 +36,7 @@ impl Default for OpenAICompatibleConfig {
             max_retries: 3,
             api_key: None,
             provider_name: "openai-compatible".to_string(),
-            use_responses_api: true, // All providers support Responses API
+            use_responses_api: false, // Most providers only support Chat Completions API
         }
     }
 }
@@ -49,7 +49,7 @@ impl OpenAICompatibleConfig {
             model,
             context_window: 256_000,
             provider_name: "lmstudio".to_string(),
-            use_responses_api: true,
+            use_responses_api: false, // LM Studio doesn't support Responses API
             ..Default::default()
         }
     }
@@ -61,7 +61,7 @@ impl OpenAICompatibleConfig {
             model,
             context_window: 256_000,
             provider_name: "ollama".to_string(),
-            use_responses_api: true,
+            use_responses_api: false, // Ollama doesn't support Responses API
             ..Default::default()
         }
     }
@@ -72,7 +72,7 @@ impl OpenAICompatibleConfig {
             base_url,
             model,
             provider_name,
-            use_responses_api: true,
+            use_responses_api: false, // Default to Chat Completions API for compatibility
             ..Default::default()
         }
     }
@@ -214,13 +214,25 @@ impl OpenAICompatibleProvider {
             ));
         }
 
-        response
-            .json::<ResponseAPIResponse>()
-            .await
-            .context(format!(
-                "Failed to parse {} Responses API response",
-                self.config.provider_name
-            ))
+        // Get raw response text for debugging
+        let response_text = response.text().await.context(format!(
+            "Failed to read {} Responses API response body",
+            self.config.provider_name
+        ))?;
+
+        // Log the raw response for debugging
+        tracing::debug!(
+            provider = %self.config.provider_name,
+            response = %response_text,
+            "Raw Responses API response"
+        );
+
+        // Parse the response
+        serde_json::from_str::<ResponseAPIResponse>(&response_text).context(format!(
+            "Failed to parse {} Responses API response. Raw response: {}",
+            self.config.provider_name,
+            response_text
+        ))
     }
 
     /// Try request using Chat Completions API (fallback for older systems)

crates/codegraph-ai/src/openai_llm_provider.rs

@@ -179,10 +179,24 @@ impl OpenAIProvider {
             return Err(anyhow!("OpenAI API error ({}): {}", status, error_text));
         }
 
-        response
-            .json::<OpenAIResponse>()
+        // Get raw response text for debugging
+        let response_text = response
+            .text()
             .await
-            .context("Failed to parse OpenAI Responses API response")
+            .context("Failed to read OpenAI Responses API response body")?;
+
+        // Log the raw response for debugging
+        tracing::debug!(
+            model = %self.config.model,
+            response = %response_text,
+            "Raw OpenAI Responses API response"
+        );
+
+        // Parse the response
+        serde_json::from_str::<OpenAIResponse>(&response_text).context(format!(
+            "Failed to parse OpenAI Responses API response. Raw response: {}",
+            response_text
+        ))
     }
 }
 
@@ -196,22 +210,22 @@ impl LLMProvider for OpenAIProvider {
         let start = Instant::now();
         let response = self.send_request(messages, config).await?;
 
-        // Handle both old output_text field and new output array format
-        let content = if !response.output_text.is_empty() {
-            response.output_text
-        } else if !response.output.is_empty() {
-            response.output.iter()
-                .map(|o| o.content.as_str())
-                .collect::<Vec<_>>()
-                .join("\n")
-        } else {
-            String::new()
-        };
+        // Extract text from output array
+        // OpenAI GPT-5 returns: output[{type: "message", content: [{type: "output_text", text: "..."}]}]
+        let content = response
+            .output
+            .iter()
+            .filter(|item| item.output_type == "message")
+            .flat_map(|item| &item.content)
+            .filter(|c| c.content_type == "output_text")
+            .map(|c| c.text.as_str())
+            .collect::<Vec<_>>()
+            .join("\n");
 
         Ok(LLMResponse {
             content,
             total_tokens: response.usage.as_ref().map(|u| u.total_tokens),
-            prompt_tokens: response.usage.as_ref().map(|u| u.prompt_tokens),
+            prompt_tokens: response.usage.as_ref().map(|u| u.input_tokens),
             completion_tokens: response.usage.as_ref().map(|u| u.output_tokens),
             finish_reason: response.status.clone(),
             model: self.config.model.clone(),
@@ -356,34 +370,36 @@ struct OpenAIRequest {
 #[derive(Debug, Deserialize)]
 struct OpenAIResponse {
     id: String,
-    #[serde(rename = "type")]
-    response_type: String,
+    object: String,
     #[serde(default)]
     status: Option<String>,
     #[serde(default)]
-    output_text: String,
-    #[serde(default)]
-    output: Vec<ResponseOutput>,
+    output: Vec<OutputItem>,
     #[serde(default)]
-    usage: Option<Usage>,
+    usage: Option<OpenAIUsage>,
 }
 
 #[derive(Debug, Deserialize)]
-struct ResponseOutput {
+struct OutputItem {
     #[serde(rename = "type")]
     output_type: String,
     #[serde(default)]
-    content: String,
+    content: Vec<OutputContent>,
 }
 
 #[derive(Debug, Deserialize)]
-struct Usage {
-    prompt_tokens: usize,
-    #[serde(alias = "completion_tokens")]
+struct OutputContent {
+    #[serde(rename = "type")]
+    content_type: String,
+    #[serde(default)]
+    text: String,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpenAIUsage {
+    input_tokens: usize,
     output_tokens: usize,
     total_tokens: usize,
-    #[serde(default)]
-    reasoning_tokens: Option<usize>,
 }
 
 #[cfg(test)]

test_agentic_mcp.py

@@ -282,6 +282,9 @@ async def run_stdio_tests():
                     except Exception as e:
                         duration = asyncio.get_event_loop().time() - start_time
                         print(f"  ❌ ERROR: {e}")
+                        print(f"\n  📋 Full error details:")
+                        import traceback
+                        traceback.print_exc()
                         results.append({
                             "test": tool_name,
                             "success": False,
@@ -413,6 +416,9 @@ async def run_http_tests():
                     except Exception as e:
                         duration = asyncio.get_event_loop().time() - start_time
                         print(f"  ❌ ERROR: {e}")
+                        print(f"\n  📋 Full error details:")
+                        import traceback
+                        traceback.print_exc()
                         results.append({
                             "test": tool_name,
                             "success": False,