1use super::{
28 AgentError, AgentRunner, ParsedResponse, PermissionRules, StreamEvent, json_error_message,
29 json_str,
30};
31use crate::cmd;
32use crate::cmd_cache;
33use crate::parser;
34use crate::parser::AgentResponse;
35
36use std::path::Path;
37use std::sync::atomic::{AtomicBool, Ordering};
38use std::sync::{Mutex, OnceLock};
39
40use tokio::process::Command;
41use tokio::runtime::Handle;
42use tokio::runtime::Runtime;
43use tokio::time;
44
45use std::collections::BTreeMap;
46use std::process::Stdio;
47use std::sync::PoisonError;
48use std::thread;
49use std::time::Duration;
50
51static FREE_MODELS_CACHE: OnceLock<Mutex<(i64, Vec<String>)>> = OnceLock::new();
54static FREE_MODELS_REFRESH_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
55static ALL_MODELS_CACHE: OnceLock<Mutex<(i64, Vec<String>)>> = OnceLock::new();
58static ALL_MODELS_REFRESH_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
59
60#[cfg(test)]
61pub(crate) fn reset_model_caches_for_test() {
62 if let Some(cache) = FREE_MODELS_CACHE.get()
63 && let Ok(mut guard) = cache.lock()
64 {
65 *guard = (0, Vec::new());
66 }
67 if let Some(cache) = ALL_MODELS_CACHE.get()
68 && let Ok(mut guard) = cache.lock()
69 {
70 *guard = (0, Vec::new());
71 }
72 FREE_MODELS_REFRESH_IN_PROGRESS.store(false, Ordering::Release);
73 ALL_MODELS_REFRESH_IN_PROGRESS.store(false, Ordering::Release);
74}
75
76fn skip_live_opencode_discovery() -> bool {
85 cfg!(any(test, debug_assertions))
86}
87
88fn update_discovered_models_cache(
89 cache: &Mutex<(i64, Vec<String>)>,
90 discovered: Vec<String>,
91 cache_name: &'static str,
92 empty_reason: &'static str,
93) {
94 let now = chrono::Utc::now().timestamp();
95 let mut guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
96
97 if discovered.is_empty() && !guard.1.is_empty() {
98 tracing::warn!(
99 cache = cache_name,
100 cached_models = guard.1.len(),
101 reason = empty_reason,
102 "opencode model discovery returned empty; preserving previous cache contents"
103 );
104 guard.0 = now;
108 return;
109 }
110
111 tracing::debug!(
112 cache = cache_name,
113 discovered_models = discovered.len(),
114 "opencode model discovery refreshed cache"
115 );
116 *guard = (now, discovered);
117}
118
119#[derive(Debug)]
121pub struct OpenCodeRunner;
122
123pub(crate) fn extract_ndjson_text(events: &[serde_json::Value]) -> Option<String> {
124 let mut texts = Vec::new();
125
126 for event in events {
127 let event_type = event.get("type").and_then(|v| v.as_str()).unwrap_or("");
128
129 if event_type == "text" || event_type == "message" || event_type == "assistant" {
135 if let Some(part) = event.get("part") {
136 texts.extend(extract_text_from_part(part));
137 }
138
139 if let Some(text) = event.get("text").and_then(|v| v.as_str()) {
141 texts.push(text.to_string());
142 }
143
144 if let Some(message) = event.get("message")
146 && let Some(items) = message.get("content").and_then(|v| v.as_array())
147 {
148 for item in items {
149 let item_type = item.get("type").and_then(|v| v.as_str()).unwrap_or("");
150 if item_type == "text"
151 && let Some(text) = item.get("text").and_then(|v| v.as_str())
152 {
153 texts.push(text.to_string());
154 }
155 }
156 }
157
158 continue;
159 }
160
161 if let Some(part) = event.get("part") {
163 let part_type = part.get("type").and_then(|v| v.as_str()).unwrap_or("");
164 if part_type == "text" || part_type == "output_text" || part_type == "message" {
165 texts.extend(extract_text_from_part(part));
166 }
167 }
168 }
169
170 if texts.is_empty() {
173 for event in events.iter().rev() {
174 if let Some(event_type) = event.get("type").and_then(|v| v.as_str()) {
175 if event_type == "system" {
177 continue;
178 }
179 }
180
181 if let Some(result) = event.get("result") {
182 if let Some(s) = result.as_str() {
184 return Some(s.to_string());
185 }
186 if result.is_object() || result.is_array() {
187 return Some(result.to_string());
188 }
189 }
190
191 if let Some(text) = event.get("text").and_then(|v| v.as_str())
193 && !text.trim().is_empty()
194 {
195 return Some(text.to_string());
196 }
197 }
198
199 return None;
200 }
201
202 let full = texts.join("");
203 if let Some(json) = extract_json_object(&full) {
204 if parser::parse(&json).is_ok() {
206 return Some(json);
207 }
208
209 if let Ok(val) = serde_json::from_str::<serde_json::Value>(&json)
212 && let Some(obj) = val.as_object()
213 && (obj.contains_key("executor")
214 || obj.contains_key("status")
215 || obj.contains_key("complexity")
216 || obj.contains_key("decision"))
217 {
218 return Some(json);
219 }
220 }
222
223 for text in texts.iter().rev() {
224 let trimmed = text.trim();
225 if let Some(json) = extract_json_object(trimmed) {
226 if parser::parse(&json).is_ok() {
230 return Some(json);
231 }
232
233 if let Ok(val) = serde_json::from_str::<serde_json::Value>(&json)
236 && let Some(obj) = val.as_object()
237 && (obj.contains_key("executor") || obj.contains_key("status"))
238 {
239 return Some(json);
240 }
241 }
242 if trimmed.contains('{') {
246 if parser::parse(trimmed).is_ok() {
251 return Some(trimmed.to_string());
252 }
253
254 if let Ok(val) = serde_json::from_str::<serde_json::Value>(trimmed)
255 && let Some(obj) = val.as_object()
256 && (obj.contains_key("executor")
257 || obj.contains_key("status")
258 || obj.contains_key("complexity"))
259 {
260 return Some(trimmed.to_string());
261 }
262 }
263 }
264
265 Some(full)
266}
267
268fn extract_text_from_part(part: &serde_json::Value) -> Vec<String> {
269 let mut out = Vec::new();
270
271 if let Some(text) = part.get("text").and_then(|v| v.as_str()) {
272 out.push(text.to_string());
273 }
274
275 if let Some(items) = part.get("content").and_then(|v| v.as_array()) {
277 for item in items {
278 let item_type = item.get("type").and_then(|v| v.as_str()).unwrap_or("");
279 if item_type == "text"
280 && let Some(text) = item.get("text").and_then(|v| v.as_str())
281 {
282 out.push(text.to_string());
283 }
284 }
285 }
286
287 out
288}
289
290fn extract_json_object(text: &str) -> Option<String> {
291 let trimmed = text.trim();
292 if serde_json::from_str::<serde_json::Value>(trimmed).is_ok() {
293 return Some(trimmed.to_string());
294 }
295
296 let start = trimmed.find('{')?;
297 let end = trimmed.rfind('}')?;
298 if end <= start {
299 return None;
300 }
301
302 let candidate = trimmed[start..=end].trim();
303 serde_json::from_str::<serde_json::Value>(candidate)
304 .ok()
305 .map(|_| candidate.to_string())
306}
307
308pub(crate) fn extract_router_text(raw: &str) -> Option<String> {
309 let events = super::parse_ndjson(raw.trim());
310 if events.is_empty() {
311 return None;
312 }
313 extract_ndjson_text(&events)
314}
315
316#[cfg(test)]
317mod router_text_tests {
318 use super::*;
319
320 #[test]
321 fn extract_router_text_supports_message_with_content_array() {
322 let raw = r#"{"type":"step_start","timestamp":1}
324{"type":"message","timestamp":2,"part":{"type":"message","content":[{"type":"text","text":"```json\n{\"executor\":\"opencode\",\"complexity\":\"medium\",\"reason\":\"ok\"}\n```"}]}}
325{"type":"step_finish","timestamp":3,"part":{"type":"step-finish","reason":"stop"}}"#;
326 let text = extract_router_text(raw).expect("should extract text");
327 assert!(
328 text.contains("executor"),
329 "extracted text should include JSON"
330 );
331 }
332
333 #[test]
334 fn extract_router_text_ignores_leading_system_init() {
335 let raw = r#"{"type":"system","subtype":"init","cwd":"/"}
339{"type":"text","timestamp":2,"text":"{\"executor\":\"opencode\",\"complexity\":\"medium\",\"reason\":\"ndjson\"}"}
340{"type":"step_finish","timestamp":3}"#;
341
342 let text = extract_router_text(raw).expect("should extract text even with leading init");
343 let parsed: serde_json::Value =
344 serde_json::from_str(&text).expect("extracted text must be JSON");
345 assert_eq!(parsed["executor"], "opencode");
346 assert_eq!(parsed["complexity"], "medium");
347 }
348}
349
350const NO_SNAPSHOT_CONFIG: &str = r#"{"snapshot":false}"#;
353
354impl OpenCodeRunner {
355 pub fn new() -> Self {
356 Self
357 }
358
359 pub(crate) fn split_model_variant(s: &str) -> (&str, Option<&str>) {
366 if let Some(pos) = s.rfind('@') {
367 let base = &s[..pos];
368 let variant = &s[pos + 1..];
369 (base, Some(variant))
370 } else {
371 (s, None)
372 }
373 }
374
375 fn extract_text_from_events(events: &[serde_json::Value]) -> Option<String> {
386 extract_ndjson_text(events)
387 }
388
389 fn extract_tokens(events: &[serde_json::Value]) -> (Option<u64>, Option<u64>) {
391 for event in events.iter().rev() {
392 let event_type = event.get("type").and_then(|v| v.as_str()).unwrap_or("");
393
394 if event_type == "step_finish"
395 && let Some(part) = event.get("part")
396 && let Some(tokens) = part.get("tokens").and_then(|v| v.as_object())
397 {
398 let input = tokens.get("input").and_then(serde_json::Value::as_u64);
399 let output = tokens.get("output").and_then(serde_json::Value::as_u64);
400 return (input, output);
401 }
402 }
403
404 (None, None)
405 }
406
407 fn detect_error(events: &[serde_json::Value]) -> Option<AgentError> {
409 super::patterns::detect_ndjson_error(
410 events,
411 |event| {
412 let event_type = event.get("type").and_then(|v| v.as_str()).unwrap_or("");
413 match event_type {
414 "error" => Some(opencode_error_text(event)),
415 "step_finish" => {
416 let part = event.get("part")?;
417 let reason = part.get("reason").and_then(|v| v.as_str()).unwrap_or("");
418 if reason == "error" || reason == "failed" {
419 Some(
420 part.get("error")
421 .map_or_else(|| "step failed".to_string(), error_value_text),
422 )
423 } else {
424 None
425 }
426 }
427 _ => None,
428 }
429 },
430 classify_opencode_message,
431 )
432 }
433}
434
435fn error_value_text(v: &serde_json::Value) -> String {
437 if let Some(s) = v.as_str() {
438 return s.to_string();
439 }
440 v.get("data")
441 .and_then(|d| d.get("message").or(Some(d)))
442 .and_then(|m| m.as_str())
443 .or_else(|| v.get("message").and_then(|m| m.as_str()))
444 .or_else(|| v.get("name").and_then(|n| n.as_str()))
445 .map_or_else(|| v.to_string(), str::to_string)
446}
447
448fn opencode_error_text(event: &serde_json::Value) -> String {
450 if let Some(s) = event.get("message").and_then(|v| v.as_str()) {
451 return s.to_string();
452 }
453 if let Some(e) = event.get("error") {
454 let text = error_value_text(e);
455 if e.is_object() && text == *e {
456 tracing::warn!(event = %event, "unrecognized opencode error event shape");
457 }
458 text
459 } else {
460 tracing::warn!(event = %event, "unrecognized opencode error event shape");
461 event.to_string()
462 }
463}
464
465impl AgentRunner for OpenCodeRunner {
466 #[cfg(test)]
467 fn name(&self) -> &'static str {
468 "opencode"
469 }
470
471 fn stream_events(&self, event: &serde_json::Value) -> Vec<StreamEvent> {
472 stream_events(event)
473 }
474
475 fn router_transcript(&self) -> super::RouterTranscript {
476 super::RouterTranscript::OpenCode
477 }
478
479 fn extract_text(&self, raw: &str) -> Result<String, AgentError> {
480 let trimmed = raw.trim();
481 if trimmed.is_empty() {
482 return Ok(String::new());
483 }
484
485 let events = super::parse_ndjson(trimmed);
486 if events.is_empty() {
487 return Ok(trimmed.to_string());
488 }
489
490 if let Some(err) = Self::detect_error(&events) {
492 return Err(err);
493 }
494
495 Ok(extract_ndjson_text(&events).unwrap_or_else(|| trimmed.to_string()))
497 }
498
499 fn build_command(
500 &self,
501 model: Option<&str>,
502 timeout_cmd: &str,
503 sys_file: &str,
504 msg_file: &str,
505 permissions: &PermissionRules,
506 ) -> String {
507 let (model_flag, variant_flag) = if let Some(m) = model {
510 let (base, variant) = Self::split_model_variant(m);
511 let mf = format!("--model {}", super::shell_single_quote(base));
512 let vf = variant.map(|v| format!("--variant {}", super::shell_single_quote(v)));
513 (mf, vf)
514 } else {
515 (String::new(), None)
516 };
517
518 let skip_perms = if permissions.autonomous {
531 "--dangerously-skip-permissions "
532 } else {
533 ""
534 };
535
536 let variant_part = variant_flag.unwrap_or_default();
538 format!(
543 r#"OPENCODE_CONFIG_CONTENT={config} {timeout_cmd} opencode run {model_flag} {variant_part} {skip_perms}\
544 --format json - < <(cat "{sys_file}" "{msg_file}")"#,
545 config = super::shell_single_quote(NO_SNAPSHOT_CONFIG),
546 sys_file = sys_file,
547 msg_file = msg_file,
548 timeout_cmd = timeout_cmd,
549 model_flag = model_flag,
550 variant_part = variant_part,
551 skip_perms = skip_perms,
552 )
553 }
554
555 fn parse_response(&self, raw: &str) -> Result<ParsedResponse, AgentError> {
556 let trimmed = raw.trim();
557 if trimmed.is_empty() {
561 return Err(AgentError::Unknown {
562 exit_code: 0,
563 message: "empty-output-exit0: opencode returned exit 0 with empty stdout"
564 .to_string(),
565 });
566 }
567
568 let events = super::parse_ndjson(trimmed);
569
570 if events.is_empty() {
571 if let Ok(resp) = parser::parse(trimmed) {
573 return Ok(ParsedResponse {
574 response: resp,
575 input_tokens: None,
576 output_tokens: None,
577 cost_usd: None,
578 duration_ms: None,
579 });
580 }
581 return Err(AgentError::InvalidResponse {
582 raw: trimmed.to_string(),
583 });
584 }
585
586 if let Some(err) = Self::detect_error(&events) {
588 return Err(err);
589 }
590
591 let (input_tokens, output_tokens) = Self::extract_tokens(&events);
593
594 let Some(text) = Self::extract_text_from_events(&events) else {
601 let response = synthesize_response_from_events(&events);
602 return Ok(ParsedResponse {
603 response,
604 input_tokens,
605 output_tokens,
606 cost_usd: extract_cost(&events),
607 duration_ms: None,
608 });
609 };
610
611 let response = match parser::parse(&text) {
613 Ok(r) => r,
614 Err(_) => {
615 super::synthesize_response_from_text(&text)
618 .ok_or_else(|| AgentError::InvalidResponse { raw: text.clone() })?
619 }
620 };
621
622 Ok(ParsedResponse {
623 response,
624 input_tokens,
625 output_tokens,
626 cost_usd: extract_cost(&events),
627 duration_ms: None,
628 })
629 }
630
631 fn classify_error(&self, exit_code: i32, stdout: &str, stderr: &str) -> AgentError {
632 let events = super::parse_ndjson(stdout);
634 if let Some(err) = Self::detect_error(&events) {
635 return err;
636 }
637
638 let combined = format!("{stdout}\n{stderr}");
639 super::patterns::classify_from_text(exit_code, &combined)
640 }
641
642 fn free_models(&self) -> Vec<String> {
643 discover_free_opencode_models()
644 }
645
646 fn available_models(&self) -> Vec<String> {
647 vec![
649 "anthropic/claude-sonnet-4-20250514".to_string(),
650 "openai/gpt-4.1".to_string(),
651 ]
652 }
653
654 fn router_command(&self, prompt: &str, model: Option<&str>) -> anyhow::Result<Command> {
655 let mut cmd = Command::new("opencode");
661 cmd.env("OPENCODE_CONFIG_CONTENT", NO_SNAPSHOT_CONFIG)
662 .arg("run")
663 .arg("--format")
664 .arg("json")
665 .arg("--dangerously-skip-permissions");
666 if let Some(m) = model {
667 let (base, variant) = Self::split_model_variant(m);
668 cmd.arg("--model").arg(base);
669 if let Some(v) = variant {
670 cmd.arg("--variant").arg(v);
672 }
673 }
674 cmd.arg(prompt);
675 Ok(cmd)
676 }
677}
678
679fn classify_opencode_message(message: &str) -> AgentError {
681 let lower = message.to_lowercase();
682
683 if let Some(e) = super::patterns::detect_rate_limit(message) {
685 return e;
686 }
687
688 if let Some(e) = super::patterns::detect_context_overflow(message) {
690 return e;
691 }
692
693 if let Some(e) = super::patterns::detect_auth_error(message) {
695 return e;
696 }
697
698 if let Some(e) = super::patterns::detect_permission_denied(message) {
700 return e;
701 }
702
703 let is_model_unavailable = (lower.contains("model")
714 && (lower.contains("not found")
715 || lower.contains("not supported")
716 || lower.contains("deprecated")
717 || lower.contains("unavailable for free")
718 || lower.contains("not available in your country")
719 || lower.contains("not available in your region")))
720 || lower.contains("no endpoints found");
721
722 if is_model_unavailable {
723 let model = if lower.contains("no endpoints found") {
726 message
728 .split(" for ")
729 .nth(1)
730 .map(|s| s.trim_end_matches('.').to_string())
731 .unwrap_or_default()
732 } else {
733 let from_colon = message
735 .split(": ")
736 .nth(1)
737 .map(|s| {
738 s.split(". Did you mean")
740 .next()
741 .unwrap_or(s)
742 .trim_end_matches('.')
743 .to_string()
744 })
745 .filter(|s| !s.is_empty());
746
747 let from_transition = if lower.contains("deprecated") {
750 message
751 .split("Transition to ")
752 .nth(1)
753 .and_then(|s| s.split(" for ").next())
754 .map(|s| s.trim_end_matches('.').to_string())
755 .filter(|s| !s.is_empty())
756 } else {
757 None
758 };
759
760 let from_slug_suggestion = if lower.contains("unavailable for free") {
763 message
764 .split("use this slug instead: ")
765 .nth(1)
766 .map(|s| s.trim_end_matches('.').trim().to_string())
767 .filter(|s| !s.is_empty())
768 } else {
769 None
770 };
771
772 from_transition
776 .or(from_slug_suggestion)
777 .or(from_colon)
778 .unwrap_or_default()
779 };
780 return AgentError::ModelUnavailable {
781 message: message.to_string(),
782 model,
783 };
784 }
785
786 if lower.contains("provider returned error") {
791 return AgentError::RateLimit {
792 message: message.to_string(),
793 };
794 }
795
796 if let Some(e) = super::patterns::detect_network_error(message) {
798 return e;
799 }
800
801 AgentError::AgentFailed {
802 message: message.to_string(),
803 }
804}
805
806pub fn discover_free_opencode_models() -> Vec<String> {
815 if skip_live_opencode_discovery() {
816 return Vec::new();
817 }
818 let cache = FREE_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
819
820 let now = chrono::Utc::now().timestamp();
821 {
823 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
824 let (ts, models) = &*guard;
825 if *ts != 0 && now.saturating_sub(*ts) < 3600 {
826 return models.clone();
827 }
828 }
829
830 if !FREE_MODELS_REFRESH_IN_PROGRESS.swap(true, Ordering::AcqRel) {
833 let refresh = async {
834 let _guard = scopeguard::guard((), |()| {
835 FREE_MODELS_REFRESH_IN_PROGRESS.store(false, Ordering::Release);
836 });
837 let (models, empty_reason) = run_opencode_models_discovery_async().await;
838 let raw_count = models.len();
839 let discovered = models
840 .into_iter()
841 .filter(|m| m.to_lowercase().contains("free"))
842 .collect::<Vec<_>>();
843 let empty_reason = if discovered.is_empty() && raw_count > 0 {
844 "no_free_models_in_catalog"
845 } else {
846 empty_reason
847 };
848 let cache = FREE_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
849 update_discovered_models_cache(cache, discovered, "free", empty_reason);
850 };
851 match Handle::try_current() {
852 Ok(handle) => {
853 handle.spawn(refresh);
856 }
857 _ => {
858 thread::spawn(move || {
861 if let Ok(rt) = Runtime::new() {
862 rt.block_on(refresh);
863 }
864 });
865 }
866 }
867 }
868
869 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
871 guard.1.clone()
872}
873
874pub fn discover_opencode_models() -> Vec<String> {
879 if skip_live_opencode_discovery() {
880 return Vec::new();
881 }
882 let cache = ALL_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
883 let now = chrono::Utc::now().timestamp();
884
885 {
886 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
887 let (ts, models) = &*guard;
888 if *ts != 0 && now.saturating_sub(*ts) < 3600 {
889 return models.clone();
890 }
891 }
892
893 if !ALL_MODELS_REFRESH_IN_PROGRESS.swap(true, Ordering::AcqRel) {
894 let refresh = async {
895 let _guard = scopeguard::guard((), |()| {
896 ALL_MODELS_REFRESH_IN_PROGRESS.store(false, Ordering::Release);
897 });
898 let (discovered, empty_reason) = run_opencode_models_discovery_async().await;
899 let cache = ALL_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
900 update_discovered_models_cache(cache, discovered, "all", empty_reason);
901 };
902 match Handle::try_current() {
903 Ok(handle) => {
904 handle.spawn(refresh);
905 }
906 _ => {
907 thread::spawn(move || {
908 if let Ok(rt) = Runtime::new() {
909 rt.block_on(refresh);
910 }
911 });
912 }
913 }
914 }
915
916 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
917 guard.1.clone()
918}
919
920pub fn prime_free_model_cache() {
928 if skip_live_opencode_discovery() {
929 return;
930 }
931 let discovered_all = thread::spawn(|| match Runtime::new() {
932 Ok(rt) => rt.block_on(run_opencode_models_discovery_async()).0,
933 _ => {
934 vec![]
935 }
936 })
937 .join()
938 .unwrap_or_default();
939 let cache = FREE_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
940 let now = chrono::Utc::now().timestamp();
941 if let Ok(mut guard) = cache.lock() {
942 *guard = (
943 now,
944 discovered_all
945 .iter()
946 .filter(|m| m.to_lowercase().contains("free"))
947 .cloned()
948 .collect(),
949 );
950 }
951 let all_cache = ALL_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
952 if let Ok(mut guard) = all_cache.lock() {
953 *guard = (now, discovered_all);
954 }
955}
956
957async fn run_opencode_models_discovery_async() -> (Vec<String>, &'static str) {
966 run_opencode_models_cli(Duration::from_secs(30)).await
967}
968
969pub(crate) async fn run_opencode_models_cli(timeout: Duration) -> (Vec<String>, &'static str) {
971 run_opencode_models_cli_inner("opencode", timeout).await
972}
973
974fn opencode_program_available(program: &str) -> bool {
975 let path = Path::new(program);
976 if path.is_absolute() || program.contains('/') {
977 path.is_file()
978 } else {
979 cmd_cache::command_exists(program)
980 }
981}
982
983async fn run_opencode_models_cli_inner(
984 program: &str,
985 timeout: Duration,
986) -> (Vec<String>, &'static str) {
987 if !opencode_program_available(program) {
988 tracing::warn!("opencode not in PATH, skipping model discovery");
989 return (vec![], "command_not_found");
990 }
991
992 let mut cmd = Command::new(program);
993 cmd.args(["models"])
994 .stdout(Stdio::piped())
995 .stderr(Stdio::piped())
996 .kill_on_drop(true);
997 #[cfg(unix)]
998 cmd.process_group(0);
999
1000 let child = match cmd.spawn() {
1001 Ok(c) => c,
1002 Err(e) => {
1003 tracing::warn!(error = %e, "failed to spawn opencode models");
1004 return (vec![], "spawn_failed");
1005 }
1006 };
1007 let pgid = child.id();
1008 let wait = time::timeout(timeout, child.wait_with_output()).await;
1009
1010 #[cfg(unix)]
1011 if let Some(pid) = pgid {
1012 cmd::kill_process_group(pid);
1013 }
1014
1015 match wait {
1016 Ok(Ok(output)) if output.status.success() => {
1017 let models: Vec<String> = String::from_utf8_lossy(&output.stdout)
1018 .lines()
1019 .map(|l| l.trim().to_string())
1020 .filter(|l| !l.is_empty())
1021 .collect();
1022 let reason = if models.is_empty() {
1023 "empty_output"
1024 } else {
1025 "ok"
1026 };
1027 (models, reason)
1028 }
1029 Ok(Ok(output)) => {
1030 let stderr = String::from_utf8_lossy(&output.stderr);
1031 let stderr = stderr.trim();
1032 let stderr_display = if stderr.len() > 500 {
1033 format!("{}...", &stderr[..stderr.floor_char_boundary(500)])
1034 } else {
1035 stderr.to_string()
1036 };
1037 tracing::warn!(
1038 status = ?output.status,
1039 stderr = %stderr_display,
1040 "opencode models command failed"
1041 );
1042 (vec![], "exit_status_failure")
1043 }
1044 Ok(Err(e)) => {
1045 tracing::warn!(error = %e, "failed to wait on opencode models");
1046 (vec![], "wait_failed")
1047 }
1048 Err(_) => {
1049 tracing::warn!(
1050 secs = timeout.as_secs(),
1051 "opencode models timed out, killing process group"
1052 );
1053 (vec![], "timeout")
1054 }
1055 }
1056}
1057
1058fn synthesize_response_from_events(events: &[serde_json::Value]) -> AgentResponse {
1071 let mut counts: BTreeMap<String, u32> = BTreeMap::new();
1072 let mut tool_names: Vec<String> = Vec::new();
1073 let mut step_finish_reason: Option<String> = None;
1074
1075 for event in events {
1076 let event_type = event
1077 .get("type")
1078 .and_then(|v| v.as_str())
1079 .unwrap_or("unknown");
1080 *counts.entry(event_type.to_string()).or_insert(0) += 1;
1081
1082 if event_type == "step_finish"
1083 && let Some(reason) = event
1084 .get("part")
1085 .and_then(|p| p.get("reason"))
1086 .and_then(|r| r.as_str())
1087 {
1088 step_finish_reason = Some(reason.to_string());
1089 }
1090
1091 if event_type == "tool_use"
1093 && let Some(name) = event
1094 .get("name")
1095 .and_then(|v| v.as_str())
1096 .or_else(|| event.get("tool").and_then(|v| v.as_str()))
1097 .or_else(|| {
1098 event
1099 .get("part")
1100 .and_then(|p| p.get("name"))
1101 .and_then(|v| v.as_str())
1102 })
1103 .or_else(|| {
1104 event
1105 .get("tool")
1106 .and_then(|t| t.get("name"))
1107 .and_then(|v| v.as_str())
1108 })
1109 {
1110 tool_names.push(name.to_string());
1111 }
1112 }
1113
1114 let total_events = events.len();
1115 let reason = step_finish_reason.as_deref().unwrap_or("unknown");
1116
1117 let tool_summary = if tool_names.is_empty() {
1118 String::new()
1119 } else {
1120 let mut tool_counts: BTreeMap<String, u32> = BTreeMap::new();
1121 for n in &tool_names {
1122 *tool_counts.entry(n.clone()).or_insert(0) += 1;
1123 }
1124 let parts: Vec<String> = tool_counts
1125 .iter()
1126 .map(|(k, v)| {
1127 if *v > 1 {
1128 format!("{k}×{v}")
1129 } else {
1130 k.clone()
1131 }
1132 })
1133 .collect();
1134 format!(" (tools: {})", parts.join(", "))
1135 };
1136
1137 let summary = format!(
1138 "opencode emitted {total_events} event(s) with no text output{tool_summary}; \
1139 step_finish reason: {reason}"
1140 );
1141
1142 AgentResponse {
1143 status: "needs_review".to_string(),
1144 summary,
1145 error: Some("agent emitted no text response — only tool/step events".to_string()),
1146 ..Default::default()
1147 }
1148}
1149
1150fn extract_cost(events: &[serde_json::Value]) -> Option<f64> {
1152 events.iter().rev().find_map(|event| {
1153 if event.get("type").and_then(|v| v.as_str()) == Some("step_finish") {
1154 event
1155 .get("part")
1156 .and_then(|p| p.get("cost"))
1157 .and_then(serde_json::Value::as_f64)
1158 .filter(|&c| c > 0.0)
1159 } else {
1160 None
1161 }
1162 })
1163}
1164
1165pub fn find_opencode_result(ndjson: &str) -> Option<super::AgentResult> {
1173 let events = super::parse_ndjson(ndjson.trim());
1174 if events.is_empty() {
1175 return None;
1176 }
1177
1178 let is_error;
1180 let error_text;
1181 if let Some(err) = OpenCodeRunner::detect_error(&events) {
1182 is_error = true;
1183 error_text = Some(err.to_string());
1184 } else {
1185 is_error = false;
1186 error_text = None;
1187 }
1188
1189 let result_text = if is_error {
1191 error_text.unwrap_or_default()
1192 } else {
1193 extract_ndjson_text(&events).unwrap_or_default()
1194 };
1195
1196 let (input_tokens, output_tokens) = OpenCodeRunner::extract_tokens(&events);
1198
1199 let last_step_finish_reason = events
1208 .iter()
1209 .rev()
1210 .find(|event| event.get("type").and_then(|v| v.as_str()) == Some("step_finish"))
1211 .and_then(|event| {
1212 event
1213 .get("part")?
1214 .get("reason")?
1215 .as_str()
1216 .map(str::to_string)
1217 });
1218 let truncated_by_length = match last_step_finish_reason.as_deref() {
1219 Some("length") => true,
1220 Some("unknown") => output_tokens == Some(0),
1221 _ => false,
1222 };
1223
1224 if result_text.is_empty() && !is_error && !truncated_by_length {
1225 return None;
1226 }
1227
1228 let cost_usd = extract_cost(&events);
1229
1230 Some(super::AgentResult {
1231 is_error,
1232 result_text,
1233 input_tokens,
1234 output_tokens,
1235 cost_usd,
1236 duration_ms: None,
1237 truncated_by_length,
1238 })
1239}
1240
1241#[cfg(test)]
1242mod tests {
1243 #[cfg(unix)]
1244 use std::fs;
1245 #[cfg(unix)]
1246 use std::fs::Permissions;
1247 #[cfg(unix)]
1248 use std::os::unix::fs::PermissionsExt;
1249 #[cfg(unix)]
1250 use std::time::Instant;
1251
1252 use super::*;
1253 use crate::engine::runner::agents::fixture;
1254
1255 fn runner() -> OpenCodeRunner {
1256 OpenCodeRunner::new()
1257 }
1258
1259 #[test]
1260 fn parse_opencode_ndjson_success() {
1261 let raw = r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start","snapshot":"..."}}
1262{"type":"text","timestamp":1001,"part":{"type":"text","text":"{\"status\":\"done\",\"summary\":\"hello\",\"accomplished\":[],\"remaining\":[],\"files\":[]}"}}
1263{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"stop","cost":0,"tokens":{"total":17512,"input":17509,"output":3}}}"#;
1264
1265 let parsed = runner().parse_response(raw).unwrap();
1266 assert_eq!(parsed.response.status, "done");
1267 assert_eq!(parsed.response.summary, "hello");
1268 assert_eq!(parsed.input_tokens, Some(17509));
1269 assert_eq!(parsed.output_tokens, Some(3));
1270 }
1271
1272 #[test]
1275 fn parse_opencode_ndjson_direct_text_format() {
1276 let raw = r#"{"type":"step_start","timestamp":1000,"sessionID":"ses_abc"}
1277{"type":"text","timestamp":1001,"sessionID":"ses_abc","text":"{\"status\":\"done\",\"summary\":\"fixed\",\"accomplished\":[],\"remaining\":[],\"files\":[]}"}
1278{"type":"step_finish","timestamp":1002,"sessionID":"ses_abc","part":{"type":"step-finish","reason":"stop","tokens":{"input":200,"output":10}}}"#;
1279
1280 let parsed = runner().parse_response(raw).unwrap();
1281 assert_eq!(parsed.response.status, "done");
1282 assert_eq!(parsed.response.summary, "fixed");
1283 assert_eq!(parsed.input_tokens, Some(200));
1284 assert_eq!(parsed.output_tokens, Some(10));
1285 }
1286
1287 #[test]
1288 fn parse_opencode_concatenated_text() {
1289 let raw = r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}
1290{"type":"text","timestamp":1001,"part":{"type":"text","text":"Working on "}}
1291{"type":"text","timestamp":1002,"part":{"type":"text","text":"the task. "}}
1292{"type":"text","timestamp":1003,"part":{"type":"text","text":"{\"status\":\"done\",\"summary\":\"finished\",\"accomplished\":[],\"remaining\":[],\"files\":[]}"}}
1293{"type":"step_finish","timestamp":1004,"part":{"type":"step-finish","reason":"stop","tokens":{"input":100,"output":50}}}"#;
1294
1295 let parsed = runner().parse_response(raw).unwrap();
1296 assert_eq!(parsed.response.status, "done");
1297 assert_eq!(parsed.input_tokens, Some(100));
1298 assert_eq!(parsed.output_tokens, Some(50));
1299 }
1300
1301 #[test]
1302 fn extract_router_text_prefers_json_payload() {
1303 let raw = r#"{"type":"text","timestamp":1001,"part":{"type":"text","text":"Thinking..."}}
1304{"type":"text","timestamp":1002,"part":{"type":"text","text":"{\"executor\":\"claude\",\"complexity\":\"medium\",\"reason\":\"fit\"}"}}"#;
1305
1306 let text = extract_router_text(raw).unwrap();
1307 let parsed: serde_json::Value = serde_json::from_str(&text).unwrap();
1308 assert_eq!(parsed["executor"], "claude");
1309 }
1310
1311 #[test]
1312 fn parse_opencode_embedded_json_fragment_without_executor_is_ignored() {
1313 let raw = r#"{"type":"step_start","timestamp":1}
1318{"type":"text","timestamp":2,"part":{"type":"text","text":"Here is a debug trace: {\"trace\":{\"duration\":123,\"id\":\"abc\"}}"}}
1319{"type":"step_finish","timestamp":3,"part":{"type":"step-finish","reason":"stop"}}"#;
1320
1321 let err = runner().parse_response(raw).unwrap_err();
1322 match err {
1323 AgentError::InvalidResponse { raw: _ } => {
1324 }
1326 other => panic!("expected InvalidResponse, got: {other:?}"),
1327 }
1328 }
1329
1330 #[test]
1331 fn parse_opencode_error_event() {
1332 let raw = r#"{"type":"error","message":"rate limit exceeded for this model"}"#;
1333
1334 let err = runner().parse_response(raw).unwrap_err();
1335 assert!(matches!(err, AgentError::RateLimit { .. }));
1336 }
1337
1338 #[test]
1344 fn parse_opencode_tool_only_stream_synthesizes_needs_review() {
1345 let raw = r#"{"type":"step_start","timestamp":1,"part":{"type":"step-start"}}
1346{"type":"tool_use","timestamp":2,"name":"bash","input":{"cmd":"ls"}}
1347{"type":"tool_use","timestamp":3,"name":"read","input":{"path":"src/main.rs"}}
1348{"type":"tool_use","timestamp":4,"name":"bash","input":{"cmd":"cargo check"}}
1349{"type":"step_finish","timestamp":5,"part":{"type":"step-finish","reason":"stop","tokens":{"input":500,"output":0}}}"#;
1350
1351 let parsed = runner()
1352 .parse_response(raw)
1353 .expect("tool-only NDJSON must synthesize a response, not error");
1354 assert_eq!(parsed.response.status, "needs_review");
1355 assert!(
1356 !parsed.response.summary.contains("\"type\":\"step_start\""),
1357 "summary must not contain raw NDJSON; got: {}",
1358 parsed.response.summary
1359 );
1360 assert!(
1361 parsed.response.summary.contains("bash") && parsed.response.summary.contains("read"),
1362 "summary should mention tools used; got: {}",
1363 parsed.response.summary
1364 );
1365 assert!(
1366 parsed.response.summary.contains("stop"),
1367 "summary should mention step_finish reason; got: {}",
1368 parsed.response.summary
1369 );
1370 assert_eq!(parsed.input_tokens, Some(500));
1372 assert_eq!(parsed.output_tokens, Some(0));
1373 }
1374
1375 #[test]
1380 fn parse_opencode_plain_prose_completion_synthesizes_response() {
1381 let raw = r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}
1382{"type":"text","timestamp":1001,"part":{"type":"text","text":"Fixed the typo and corrected the deadline reference in the review."}}
1383{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"stop","tokens":{"input":300,"output":40}}}"#;
1384
1385 let parsed = runner()
1386 .parse_response(raw)
1387 .expect("plain-prose completion text must synthesize successfully");
1388 assert_eq!(parsed.response.status, "done");
1389 assert_eq!(parsed.input_tokens, Some(300));
1390 assert_eq!(parsed.output_tokens, Some(40));
1391 }
1392
1393 #[test]
1394 fn parse_opencode_step_finish_error() {
1395 let raw = r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}
1396{"type":"step_finish","timestamp":1001,"part":{"type":"step-finish","reason":"error","error":"context length exceeded"}}"#;
1397
1398 let err = runner().parse_response(raw).unwrap_err();
1399 assert!(matches!(err, AgentError::ContextOverflow { .. }));
1400 }
1401
1402 #[test]
1403 fn parse_opencode_empty_returns_silent_failure() {
1404 let err = runner().parse_response("").unwrap_err();
1405 assert!(matches!(err, AgentError::Unknown { exit_code: 0, .. }));
1408 }
1409
1410 #[test]
1411 fn extract_tokens_from_step_finish() {
1412 let events: Vec<serde_json::Value> = vec![
1413 serde_json::json!({"type":"step_finish","part":{"type":"step-finish","tokens":{"input":1000,"output":500,"total":1500}}}),
1414 ];
1415 let (input, output) = OpenCodeRunner::extract_tokens(&events);
1416 assert_eq!(input, Some(1000));
1417 assert_eq!(output, Some(500));
1418 }
1419
1420 #[test]
1421 fn classify_opencode_rate_limit() {
1422 let err = classify_opencode_message("429 Too Many Requests");
1423 assert!(matches!(err, AgentError::RateLimit { .. }));
1424 }
1425
1426 #[test]
1427 fn classify_opencode_model_not_found() {
1428 let err = classify_opencode_message("model not found: gpt-5");
1429 assert!(matches!(err, AgentError::ModelUnavailable { .. }));
1430 }
1431
1432 #[test]
1433 fn classify_opencode_model_not_found_with_suggestion() {
1434 let err = classify_opencode_message(
1437 "Model not found: github-copilot/gemini-3.1-pro. Did you mean: gemini-3.1-pro-preview?",
1438 );
1439 match err {
1440 AgentError::ModelUnavailable { model, message } => {
1441 assert_eq!(model, "github-copilot/gemini-3.1-pro");
1442 assert!(message.contains("Did you mean"));
1443 }
1444 other => panic!("expected ModelUnavailable, got: {other:?}"),
1445 }
1446 }
1447
1448 #[test]
1449 fn classify_opencode_model_deprecated() {
1450 let err = classify_opencode_message(
1453 "The free model has been deprecated. Transition to qwen/qwen3.6-plus for continued paid access.",
1454 );
1455 match err {
1456 AgentError::ModelUnavailable { model, .. } => {
1457 assert_eq!(
1458 model, "qwen/qwen3.6-plus",
1459 "expected model extracted from 'Transition to X', got: {model:?}"
1460 );
1461 }
1462 other => panic!("expected ModelUnavailable, got: {other:?}"),
1463 }
1464 }
1465
1466 #[test]
1467 fn classify_opencode_model_unavailable_for_free() {
1468 let err = classify_opencode_message(
1472 "network error: Error from provider (Console): Upstream request failed: [404] This model is unavailable for free. The paid version is available now - use this slug instead: inclusionai/ling-3.0-flash",
1473 );
1474 match err {
1475 AgentError::ModelUnavailable { model, .. } => {
1476 assert_eq!(
1477 model, "inclusionai/ling-3.0-flash",
1478 "expected model extracted from 'use this slug instead: X', got: {model:?}"
1479 );
1480 }
1481 other => panic!("expected ModelUnavailable, got: {other:?}"),
1482 }
1483 }
1484
1485 #[test]
1486 fn classify_opencode_model_not_available_in_country() {
1487 let err =
1492 classify_opencode_message("agent failed: This model is not available in your country.");
1493 match err {
1494 AgentError::ModelUnavailable { .. } => {}
1495 other => panic!("expected ModelUnavailable, got: {other:?}"),
1496 }
1497 }
1498
1499 #[test]
1500 fn classify_opencode_no_endpoints_found() {
1501 let err = classify_opencode_message("No endpoints found for qwen/qwen3.6-plus:free.");
1503 match err {
1504 AgentError::ModelUnavailable { model, .. } => {
1505 assert_eq!(model, "qwen/qwen3.6-plus:free");
1506 }
1507 other => panic!("expected ModelUnavailable, got: {other:?}"),
1508 }
1509 }
1510
1511 #[test]
1512 fn build_command_opencode() {
1513 let r = runner();
1514 let perms = PermissionRules::default();
1515 let cmd = r.build_command(
1516 Some("anthropic/claude-sonnet-4-20250514"),
1517 "timeout 1800",
1518 "/tmp/sys.txt",
1519 "/tmp/msg.txt",
1520 &perms,
1521 );
1522 assert!(cmd.contains("opencode run"));
1523 assert!(cmd.contains("--model 'anthropic/claude-sonnet-4-20250514'"));
1524 assert!(cmd.contains("--format json"));
1525 assert!(
1526 cmd.starts_with(
1527 r#"OPENCODE_CONFIG_CONTENT='{"snapshot":false}' timeout 1800 opencode run"#
1528 ),
1529 "snapshots must be off for orch runs, got: {cmd}"
1530 );
1531 assert!(
1534 cmd.contains("--dangerously-skip-permissions"),
1535 "expected --dangerously-skip-permissions, got: {cmd}"
1536 );
1537 assert!(
1538 !cmd.contains("opencode.json"),
1539 "should not write a config file, got: {cmd}"
1540 );
1541 assert!(
1542 !cmd.contains("XDG_CONFIG_HOME"),
1543 "should not override XDG_CONFIG_HOME, got: {cmd}"
1544 );
1545 assert!(
1546 !cmd.contains(".orch-opencode"),
1547 "should not reference .orch-opencode, got: {cmd}"
1548 );
1549 assert!(
1556 !cmd.trim_start().starts_with("cat "),
1557 "opencode command must not start with a `cat |` pipe stage, got: {cmd}"
1558 );
1559 assert!(
1560 cmd.contains("< <(cat \"/tmp/sys.txt\" \"/tmp/msg.txt\")"),
1561 "sys/msg files must be fed via process substitution, got: {cmd}"
1562 );
1563 }
1564
1565 #[test]
1566 fn build_command_opencode_supervised_no_skip_flag() {
1567 let r = runner();
1568 let perms = PermissionRules {
1569 autonomous: false,
1570 ..PermissionRules::default()
1571 };
1572 let cmd = r.build_command(
1573 Some("anthropic/claude-sonnet-4-20250514"),
1574 "timeout 1800",
1575 "/tmp/sys.txt",
1576 "/tmp/msg.txt",
1577 &perms,
1578 );
1579 assert!(
1580 !cmd.contains("--dangerously-skip-permissions"),
1581 "supervised mode must not pass --dangerously-skip-permissions, got: {cmd}"
1582 );
1583 }
1584
1585 #[test]
1586 fn split_model_variant_no_at() {
1587 let (base, variant) = OpenCodeRunner::split_model_variant("openai/gpt-5.5");
1588 assert_eq!(base, "openai/gpt-5.5");
1589 assert!(variant.is_none());
1590 }
1591
1592 #[test]
1593 fn split_model_variant_with_variant() {
1594 let (base, variant) = OpenCodeRunner::split_model_variant("openai/gpt-5.5@xhigh");
1595 assert_eq!(base, "openai/gpt-5.5");
1596 assert_eq!(variant, Some("xhigh"));
1597 }
1598
1599 #[test]
1600 fn split_model_variant_trailing_at_empty() {
1601 let (base, variant) = OpenCodeRunner::split_model_variant("openai/gpt-5.5@");
1602 assert_eq!(base, "openai/gpt-5.5");
1603 assert_eq!(variant, Some(""));
1604 }
1605
1606 #[test]
1607 fn split_model_variant_multiple_ats_last_wins() {
1608 let (base, variant) = OpenCodeRunner::split_model_variant("a@b@c@v");
1609 assert_eq!(base, "a@b@c");
1610 assert_eq!(variant, Some("v"));
1611 }
1612
1613 #[test]
1614 fn build_command_opencode_with_variant() {
1615 let r = runner();
1616 let perms = PermissionRules::default();
1617 let cmd = r.build_command(
1618 Some("openai/gpt-5.5@high"),
1619 "timeout 1800",
1620 "/tmp/sys.txt",
1621 "/tmp/msg.txt",
1622 &perms,
1623 );
1624 assert!(cmd.contains("--model 'openai/gpt-5.5'"));
1625 assert!(cmd.contains("--variant 'high'"));
1626 }
1627
1628 #[test]
1629 fn classify_opencode_permission_denied() {
1630 let err = classify_opencode_message("user rejected permission for tool bash: cargo test");
1631 assert!(
1632 matches!(err, AgentError::PermissionDenied { .. }),
1633 "expected PermissionDenied, got: {err:?}"
1634 );
1635 }
1636
1637 #[test]
1638 fn classify_opencode_provider_returned_error() {
1639 let err = classify_opencode_message("Provider returned error");
1643 assert!(
1644 matches!(err, AgentError::RateLimit { .. }),
1645 "expected RateLimit, got: {err:?}"
1646 );
1647 let err_with_detail =
1648 classify_opencode_message("Provider returned error: upstream connection timed out");
1649 assert!(
1650 matches!(err_with_detail, AgentError::RateLimit { .. }),
1651 "expected RateLimit, got: {err_with_detail:?}"
1652 );
1653 }
1654
1655 #[test]
1656 fn classify_opencode_upstream_idle_timeout() {
1657 let err = classify_opencode_message("Upstream idle timeout exceeded");
1660 assert!(
1661 matches!(err, AgentError::NetworkError { .. }),
1662 "expected NetworkError, got: {err:?}"
1663 );
1664 }
1665
1666 #[test]
1667 fn free_models_discovery_returns_vec() {
1668 let models = discover_free_opencode_models();
1670 assert!(models.is_empty(), "{models:?}");
1671 }
1672
1673 #[test]
1674 fn live_opencode_discovery_is_skipped_in_test_builds() {
1675 assert!(skip_live_opencode_discovery());
1676 let models = discover_opencode_models();
1677 assert!(models.is_empty(), "{models:?}");
1678 let models = discover_free_opencode_models();
1679 assert!(models.is_empty(), "{models:?}");
1680 prime_free_model_cache();
1681 let models = discover_opencode_models();
1682 assert!(models.is_empty(), "{models:?}");
1683 }
1684
1685 #[cfg(unix)]
1688 #[tokio::test]
1689 async fn models_cli_reaps_orphaned_process_group() {
1690 let dir = tempfile::tempdir().unwrap();
1691 let sleeper_pid_path = dir.path().join("sleeper.pid");
1692 let script = dir.path().join("opencode");
1693 fs::write(
1694 &script,
1695 format!(
1696 "#!/bin/sh\n/bin/sleep 60 </dev/null >/dev/null 2>&1 &\necho $! > '{}'\necho test-model-free\n",
1697 sleeper_pid_path.display()
1698 ),
1699 )
1700 .unwrap();
1701 fs::set_permissions(&script, Permissions::from_mode(0o755)).unwrap();
1702
1703 let (models, reason) =
1706 run_opencode_models_cli_inner(script.to_str().unwrap(), Duration::from_secs(30)).await;
1707 assert_eq!(reason, "ok");
1708 assert_eq!(models, vec!["test-model-free".to_string()]);
1709
1710 let sleeper: u32 = fs::read_to_string(&sleeper_pid_path)
1711 .unwrap()
1712 .trim()
1713 .parse()
1714 .expect("sleeper pid");
1715 let deadline = Instant::now() + Duration::from_secs(10);
1716 while pid_is_alive(sleeper) && Instant::now() < deadline {
1717 time::sleep(Duration::from_millis(20)).await;
1718 }
1719 assert!(
1720 !pid_is_alive(sleeper),
1721 "sleeper {sleeper} must die with the process group when opencode models returns"
1722 );
1723 }
1724
1725 #[cfg(unix)]
1726 fn pid_is_alive(pid: u32) -> bool {
1727 i32::try_from(pid).is_ok_and(|pid| cmd::raw_kill(pid, 0) == 0)
1729 }
1730
1731 #[test]
1732 fn empty_free_discovery_preserves_existing_cache_contents() {
1733 reset_model_caches_for_test();
1734 let cache = FREE_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
1735 {
1736 let mut guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
1737 *guard = (123, vec!["opencode/model-free".to_string()]);
1738 }
1739
1740 update_discovered_models_cache(cache, Vec::new(), "free", "empty_output");
1741
1742 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
1743 assert!(guard.0 > 123);
1746 assert_eq!(guard.1, vec!["opencode/model-free".to_string()]);
1747 }
1748
1749 #[test]
1750 fn empty_all_models_discovery_preserves_existing_cache_contents() {
1751 reset_model_caches_for_test();
1752 let cache = ALL_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
1753 {
1754 let mut guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
1755 *guard = (
1756 456,
1757 vec![
1758 "opencode/model-free".to_string(),
1759 "opencode/model-paid".to_string(),
1760 ],
1761 );
1762 }
1763
1764 update_discovered_models_cache(cache, Vec::new(), "all", "exit_status_failure");
1765
1766 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
1767 assert!(guard.0 > 456);
1768 assert_eq!(
1769 guard.1,
1770 vec![
1771 "opencode/model-free".to_string(),
1772 "opencode/model-paid".to_string(),
1773 ]
1774 );
1775 }
1776
1777 #[test]
1778 fn empty_discovery_populates_empty_cache() {
1779 reset_model_caches_for_test();
1780 let cache = FREE_MODELS_CACHE.get_or_init(|| Mutex::new((0, Vec::new())));
1781
1782 update_discovered_models_cache(cache, Vec::new(), "free", "command_not_found");
1783
1784 let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
1785 assert!(guard.0 > 0);
1786 assert!(guard.1.is_empty(), "{:?}", guard.1);
1787 }
1788
1789 #[test]
1795 fn fixture_opencode_permission_denied() {
1796 let raw = fixture::load(include_str!(
1797 "../../../../tests/fixtures/opencode_permission_denied.jsonl"
1798 ));
1799 let err = runner().parse_response(&raw.stdout).unwrap_err();
1800 assert!(
1801 matches!(err, AgentError::PermissionDenied { .. }),
1802 "expected PermissionDenied, got: {err:?}"
1803 );
1804 }
1805
1806 #[test]
1810 fn fixture_opencode_model_not_found() {
1811 let raw = fixture::load(include_str!(
1812 "../../../../tests/fixtures/opencode_model_not_found.jsonl"
1813 ));
1814 let err = runner().parse_response(&raw.stdout).unwrap_err();
1815 assert!(
1816 matches!(err, AgentError::ModelUnavailable { .. }),
1817 "expected ModelUnavailable, got: {err:?}"
1818 );
1819 if let AgentError::ModelUnavailable { model, .. } = &err {
1820 assert_eq!(model, "anthropic/claude-sonnet-4-6");
1821 }
1822 }
1823
1824 #[test]
1827 fn fixture_opencode_provider_returned_error() {
1828 let raw = fixture::load(include_str!(
1829 "../../../../tests/fixtures/opencode_provider_returned_error.jsonl"
1830 ));
1831 let err = runner().parse_response(&raw.stdout).unwrap_err();
1832 assert!(
1833 matches!(err, AgentError::RateLimit { .. }),
1834 "expected RateLimit, got: {err:?}"
1835 );
1836 }
1837
1838 #[test]
1842 fn extract_text_returns_text_events() {
1843 let raw = concat!(
1844 r#"{"type":"step_start","timestamp":1000,"sessionID":"ses_abc"}"#,
1845 "\n",
1846 r#"{"type":"text","timestamp":1001,"part":{"type":"text","text":"{\"decision\":\"approve\",\"notes\":\"LGTM\",\"test_results\":\"pass\",\"issues\":[]}"}}"#,
1847 "\n",
1848 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"stop","cost":0,"tokens":{"total":100,"input":90,"output":10}}}"#,
1849 );
1850 let text = runner().extract_text(raw).unwrap();
1851 assert_eq!(
1852 text,
1853 r#"{"decision":"approve","notes":"LGTM","test_results":"pass","issues":[]}"#
1854 );
1855 }
1856
1857 #[test]
1859 fn extract_text_direct_text_event_format() {
1860 let raw = concat!(
1861 r#"{"type":"step_start","timestamp":1000,"sessionID":"ses_abc"}"#,
1862 "\n",
1863 r#"{"type":"text","timestamp":1001,"sessionID":"ses_abc","text":"Here is my review:\n\n```json\n{\"decision\":\"request_changes\",\"notes\":\"Fix the bug\",\"test_results\":\"fail\",\"issues\":[]}\n```\n"}"#,
1864 "\n",
1865 r#"{"type":"step_finish","timestamp":1002,"sessionID":"ses_abc"}"#,
1866 );
1867 let text = runner().extract_text(raw).unwrap();
1868 assert!(
1869 text.contains("request_changes"),
1870 "expected review JSON, got: {text}"
1871 );
1872 }
1873
1874 #[test]
1876 fn extract_text_rate_limit_propagates() {
1877 let raw = concat!(
1878 r#"{"type":"step_start","timestamp":1000}"#,
1879 "\n",
1880 r#"{"type":"error","message":"rate limit exceeded: 429 Too Many Requests"}"#,
1881 );
1882 let err = runner().extract_text(raw).unwrap_err();
1883 assert!(
1884 matches!(err, AgentError::RateLimit { .. }),
1885 "expected RateLimit, got: {err:?}"
1886 );
1887 }
1888
1889 #[test]
1891 fn extract_text_auth_error_propagates() {
1892 let raw = concat!(
1893 r#"{"type":"step_start","timestamp":1000}"#,
1894 "\n",
1895 r#"{"type":"error","message":"401 Unauthorized: invalid api key"}"#,
1896 );
1897 let err = runner().extract_text(raw).unwrap_err();
1898 assert!(
1899 matches!(err, AgentError::Auth { .. }),
1900 "expected Auth, got: {err:?}"
1901 );
1902 }
1903
1904 #[test]
1906 fn extract_text_empty_input_returns_empty_ok() {
1907 let text = runner().extract_text("").unwrap();
1908 assert_eq!(text, "");
1909 }
1910
1911 #[test]
1914 fn find_opencode_result_success_with_tokens() {
1915 let ndjson = concat!(
1916 r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}"#,
1917 "\n",
1918 r#"{"type":"text","timestamp":1001,"part":{"type":"text","text":"{\"decision\":\"approve\",\"notes\":\"LGTM\"}"}}"#,
1919 "\n",
1920 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"stop","cost":0.05,"tokens":{"input":5000,"output":200}}}"#,
1921 );
1922 let result = find_opencode_result(ndjson).expect("should find result");
1923 assert!(!result.is_error);
1924 assert!(result.result_text.contains("approve"));
1925 assert_eq!(result.input_tokens, Some(5000));
1926 assert_eq!(result.output_tokens, Some(200));
1927 assert_eq!(result.cost_usd, Some(0.05));
1928 assert!(!result.truncated_by_length);
1929 }
1930
1931 #[test]
1932 fn find_opencode_result_error_event() {
1933 let ndjson = r#"{"type":"error","message":"rate limit exceeded: 429"}"#;
1934 let result = find_opencode_result(ndjson).expect("should find error result");
1935 assert!(result.is_error);
1936 assert!(result.result_text.contains("rate limit"));
1937 assert!(!result.truncated_by_length);
1938 }
1939
1940 #[test]
1944 fn find_opencode_result_length_truncation() {
1945 let ndjson = concat!(
1946 r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}"#,
1947 "\n",
1948 r#"{"type":"text","timestamp":1001,"part":{"type":"text","text":"{\"decision\":"}}"#,
1949 "\n",
1950 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"length","tokens":{"input":5485,"output":759,"reasoning":31241}}}"#,
1951 );
1952 let result = find_opencode_result(ndjson).expect("should find result");
1953 assert!(result.truncated_by_length);
1954 assert!(!result.is_error, "length truncation is not a hard error");
1955 }
1956
1957 #[test]
1963 fn find_opencode_result_zero_output_length_truncation() {
1964 let ndjson = concat!(
1965 r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}"#,
1966 "\n",
1967 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"length","tokens":{"total":71482,"input":39482,"output":0,"reasoning":40000}}}"#,
1968 );
1969 let result = find_opencode_result(ndjson).expect("should find result, not None");
1970 assert!(result.truncated_by_length);
1971 assert!(!result.is_error);
1972 assert_eq!(result.result_text, "");
1973 }
1974
1975 #[test]
1978 fn find_opencode_result_zero_output_unknown_reason_truncation() {
1979 let ndjson = concat!(
1980 r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}"#,
1981 "\n",
1982 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"unknown","tokens":{"input":0,"output":0,"reasoning":0}}}"#,
1983 );
1984 let result = find_opencode_result(ndjson).expect("should find result, not None");
1985 assert!(result.truncated_by_length);
1986 assert!(!result.is_error);
1987 assert_eq!(result.result_text, "");
1988 }
1989
1990 #[test]
1994 fn find_opencode_result_unknown_reason_with_output_not_truncated() {
1995 let ndjson = concat!(
1996 r#"{"type":"step_start","timestamp":1000,"part":{"type":"step-start"}}"#,
1997 "\n",
1998 r#"{"type":"text","timestamp":1001,"part":{"type":"text","text":"partial answer"}}"#,
1999 "\n",
2000 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"unknown","tokens":{"input":100,"output":50,"reasoning":0}}}"#,
2001 );
2002 let result = find_opencode_result(ndjson).expect("should find result");
2003 assert!(!result.truncated_by_length);
2004 assert!(!result.is_error);
2005 }
2006
2007 #[test]
2008 fn find_opencode_result_empty_returns_none() {
2009 assert!(find_opencode_result("").is_none());
2010 assert!(find_opencode_result(" ").is_none());
2011 }
2012
2013 #[test]
2014 fn find_opencode_result_direct_text_format() {
2015 let ndjson = concat!(
2016 r#"{"type":"step_start","timestamp":1000}"#,
2017 "\n",
2018 r#"{"type":"text","timestamp":1001,"text":"Review complete. All tests passed."}"#,
2019 "\n",
2020 r#"{"type":"step_finish","timestamp":1002,"part":{"type":"step-finish","reason":"stop","tokens":{"input":100,"output":10}}}"#,
2021 );
2022 let result = find_opencode_result(ndjson).expect("should find result");
2023 assert!(!result.is_error);
2024 assert!(result.result_text.contains("All tests passed"));
2025 }
2026
2027 #[test]
2028 fn find_opencode_result_plain_text_returns_none() {
2029 assert!(find_opencode_result("just some plain text").is_none());
2030 }
2031}
2032
2033#[cfg(test)]
2034mod error_text_tests {
2035 use super::*;
2036 use serde_json::json;
2037
2038 #[test]
2039 fn unrecognized_error_shape_keeps_raw_json() {
2040 let e = json!({"type":"error","error":{"code":429,"detail":"slow down"}});
2041 assert!(opencode_error_text(&e).contains("slow down"));
2042 let e = json!({"type":"error"});
2043 assert!(opencode_error_text(&e).contains("\"type\""));
2044 }
2045
2046 #[test]
2047 fn known_shapes_still_extract() {
2048 assert_eq!(opencode_error_text(&json!({"message":"a"})), "a");
2049 assert_eq!(opencode_error_text(&json!({"error":"b"})), "b");
2050 assert_eq!(opencode_error_text(&json!({"error":{"message":"c"}})), "c");
2051 assert_eq!(
2052 opencode_error_text(&json!({"error":{"name":"N","data":{"message":"d"}}})),
2053 "d"
2054 );
2055 }
2056}
2057
2058fn stream_events(v: &serde_json::Value) -> Vec<StreamEvent> {
2060 let text = || {
2061 v.pointer("/part/text")
2062 .or_else(|| v.get("text"))
2063 .and_then(serde_json::Value::as_str)
2064 .unwrap_or("")
2065 .to_string()
2066 };
2067 match json_str(v, "/type") {
2068 "text" => vec![StreamEvent::Text(text())],
2069 "reasoning" => vec![StreamEvent::Thinking(text())],
2070 "tool_use" => {
2071 let part = &v["part"];
2072 let state = &part["state"];
2073 let id = json_str(part, "/callID").to_string();
2074 let name = json_str(part, "/tool").to_string();
2075 let mut out = vec![StreamEvent::ToolCall {
2076 id: id.clone(),
2077 name: name.clone(),
2078 input: state["input"].clone(),
2079 }];
2080 let result = match json_str(state, "/status") {
2081 "completed" => Some((json_str(state, "/output").to_string(), false)),
2082 "error" => Some((json_error_message(state), true)),
2083 _ => None,
2084 };
2085 if let Some((output, is_error)) = result {
2086 out.push(StreamEvent::ToolResult {
2087 id,
2088 name,
2089 output,
2090 is_error,
2091 });
2092 }
2093
2094 out
2095 }
2096 "step_finish" if json_str(v, "/part/reason") == "stop" => {
2097 vec![StreamEvent::Done(String::new())]
2098 }
2099 "error" => vec![StreamEvent::Error(json_error_message(v))],
2100 _ => vec![],
2101 }
2102}
2103
2104#[cfg(test)]
2105mod stream_tests {
2106 use super::*;
2107 use serde_json::json;
2108
2109 fn events(line: &str) -> Vec<StreamEvent> {
2110 OpenCodeRunner::new().stream_events(&serde_json::from_str(line).unwrap())
2111 }
2112
2113 #[test]
2114 fn text_in_part_or_top_level() {
2115 assert_eq!(
2116 events(r#"{"type":"text","part":{"type":"text","text":"Reviewing."}}"#),
2117 vec![StreamEvent::Text("Reviewing.".into())]
2118 );
2119 assert_eq!(
2120 events(r#"{"type":"text","text":"Plain."}"#),
2121 vec![StreamEvent::Text("Plain.".into())]
2122 );
2123 }
2124
2125 #[test]
2126 fn completed_tool_has_call_and_result() {
2127 let line = r#"{"type":"tool_use","part":{"type":"tool","tool":"read","callID":"c1","state":{"status":"completed","input":{"filePath":"src/lib.rs"},"output":"a\nb"}}}"#;
2128 assert_eq!(
2129 events(line),
2130 vec![
2131 StreamEvent::ToolCall {
2132 id: "c1".into(),
2133 name: "read".into(),
2134 input: json!({"filePath": "src/lib.rs"}),
2135 },
2136 StreamEvent::ToolResult {
2137 id: "c1".into(),
2138 name: "read".into(),
2139 output: "a\nb".into(),
2140 is_error: false,
2141 },
2142 ]
2143 );
2144 }
2145
2146 #[test]
2147 fn failed_tool_result_is_error() {
2148 let line = r#"{"type":"tool_use","part":{"tool":"bash","callID":"c2","state":{"status":"error","input":{"command":"x"},"error":"not found"}}}"#;
2149 assert_eq!(
2150 events(line)[1],
2151 StreamEvent::ToolResult {
2152 id: "c2".into(),
2153 name: "bash".into(),
2154 output: "not found".into(),
2155 is_error: true,
2156 }
2157 );
2158 }
2159
2160 #[test]
2161 fn only_final_step_is_done() {
2162 let dropped = events(r#"{"type":"step_finish","part":{"reason":"tool-calls"}}"#);
2163 assert!(dropped.is_empty(), "{dropped:?}");
2164 assert_eq!(
2165 events(r#"{"type":"step_finish","part":{"reason":"stop"}}"#),
2166 vec![StreamEvent::Done(String::new())]
2167 );
2168 let dropped = events(r#"{"type":"step_start"}"#);
2169 assert!(dropped.is_empty(), "{dropped:?}");
2170 }
2171
2172 #[test]
2173 fn error_event() {
2174 let line = r#"{"type":"error","error":{"name":"UnknownError","data":{"message":"Provider returned error"}}}"#;
2175 assert_eq!(
2176 events(line),
2177 vec![StreamEvent::Error("Provider returned error".into())]
2178 );
2179 }
2180}