Integration: Switch to real opencode CLI calls for agent 'think' phase

chrs-agent/src/lib.rs

@@ -11,6 +11,7 @@ use chrs_discovery::{SwarmManager, BusHandle, BusMessage};
 use chrs_election::ElectionManager;
 use chrono::{Utc, DateTime};
 use std::path::Path;
+use std::process::Command;
 use std::time::Duration;
 use tokio::time::sleep;
 use tokio::sync::mpsc;
@@ -122,28 +123,51 @@ impl CHORUSAgent {
             });
             let _ = self.graph.insert_node("api_call_log", log_entry);
 
-            // 3. Perform the actual API call (simulated opencode call for now)
-            // If the command returned an exit code indicating rate limit (e.g. 429)
-            let success = true; 
+            // 3. Perform the actual API call to opencode
+            let output = Command::new("opencode")
+                .args(&[
+                    "run",
+                    "-m", "resetdata/openai/gpt-oss-120b",
+                    &format!("{} \n\n Task: {}", self.system_prompt, message)
+                ])
+                .output();
 
-            if success {
+            match output {
+                Ok(out) if out.status.success() => {
+                    let reasoning = String::from_utf8_lossy(&out.stdout).trim().to_string();
+                    let _ = self.graph.insert_node("api_call_log", serde_json::json!({
+                        "id": Uuid::new_v4().to_string(),
+                        "agent_id": self.id,
+                        "called_at": Utc::now().to_rfc3339(),
+                        "status": "success"
+                    }));
                     let _ = self.graph.commit(&format!("API Call Success: {}", call_id));
-                return format!("Reasoning based on: {}", self.system_prompt);
-            } else {
+                    return reasoning;
+                }
+                _ => {
                     attempts += 1;
+                    let error_msg = if let Ok(out) = output {
+                        String::from_utf8_lossy(&out.stderr).to_string()
+                    } else {
+                        "Failed to execute opencode".to_string()
+                    };
+                    
+                    println!("[AGENT {}] API Call failed (Attempt {}): {}", self.id, attempts, error_msg);
+                    
                     if attempts >= max_attempts {
-                    return "Error: Maximum thinking attempts reached.".into();
+                        return format!("Error: Maximum thinking attempts reached. Last error: {}", error_msg);
                     }
 
                     // 4. Jittered Exponential Backoff
                     let jitter = rand::thread_rng().gen_range(0..1000);
                     let delay = base_delay.mul_f64(2.0_f64.powi(attempts - 1)) + Duration::from_millis(jitter);
                     
-                println!("[AGENT {}] Rate limit hit. Backing off for {:?}...", self.id, delay);
+                    println!("[AGENT {}] Backing off for {:?}...", self.id, delay);
                     sleep(delay).await;
                 }
             }
         }
+    }
 
     /// Main execution loop for the agent.
     pub async fn run_loop(&mut self) {