Skip to main content

orch/engine/runner/agents/
opencode.rs

1//! OpenCode agent runner.
2//!
3//! ## CLI invocation
4//!
5//! ```bash
6//! opencode run --format json -m {model} - < "{msg_file}"
7//! ```
8//!
9//! ## Output format (`run --format json`)
10//!
11//! NDJSON stream:
12//! ```jsonl
13//! {"type":"step_start","timestamp":...,"part":{"type":"step-start","snapshot":"..."}}
14//! {"type":"text","timestamp":...,"part":{"type":"text","text":"hello"}}
15//! {"type":"step_finish","timestamp":...,"part":{"type":"step-finish","reason":"stop","cost":0,"tokens":{"total":17512,"input":17509,"output":3}}}
16//! ```
17//!
18//! ## Token extraction
19//!
20//! Tokens are in the `step_finish` event: `part.tokens.{input,output,total}`
21//!
22//! ## Free models
23//!
24//! Discoverable via: `opencode models | grep free`
25//! Discovered dynamically at startup with 1-hour cache.
26
27use 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
51/// Module-level cache for discovered free opencode models.
52/// Shared across all callers (router, runner, failover).
53static FREE_MODELS_CACHE: OnceLock<Mutex<(i64, Vec<String>)>> = OnceLock::new();
54static FREE_MODELS_REFRESH_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
55/// Module-level cache for all discovered opencode models.
56/// Shared across all callers (router, runner, failover).
57static 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
76/**
77 * Model discovery runs the real `opencode` binary, and opencode 2.2.1 starts an
78 * `opencode serve --service` child that outlives it, so a suite run left one server
79 * behind per test process. It also made the result depend on the machine, and CI has no
80 * opencode at all. A test that needs models passes them in, or uses `Router::new_for_test`.
81 * `cfg(test)` is unset when the integration tests link the library, so debug builds count
82 * too, and the run-time check keeps the live path compiled in every build
83 **/
84fn 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        // Still advance the timestamp so a persistently-failing discovery
105        // backs off for the full TTL window instead of being retried on
106        // every subsequent call.
107        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/// Runner for OpenCode agent.
120#[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        // OpenCode emits several shapes across versions. Also scan assistant
130        // messages coming from Claude-like wrappers which use `type: "assistant"`
131        // with a `message.content` array containing text items.
132        // We intentionally restrict extraction to event/part/message types that
133        // represent assistant text output (not tool I/O).
134        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            // Handle opencode `text` events that put text at top-level
140            if let Some(text) = event.get("text").and_then(|v| v.as_str()) {
141                texts.push(text.to_string());
142            }
143
144            // Handle Claude-like assistant messages: message.content -> [{type:"text", text:...}]
145            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        // Some builds use a generic event type but keep a text-ish part.
162        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 we found no text-like events, try to look for a terminal `result` event
171    // which some opencode builds emit. Prefer the last result event (newest).
172    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                // Ignore system/init envelopes
176                if event_type == "system" {
177                    continue;
178                }
179            }
180
181            if let Some(result) = event.get("result") {
182                // If result is a string, return it; if object/array return its JSON
183                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            // Some events include direct text payloads outside of `part`
192            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        // Prefer a full-json payload that parses as an AgentResponse.
205        if parser::parse(&json).is_ok() {
206            return Some(json);
207        }
208
209        // Also accept JSON that looks like a router decision / agent envelope
210        // even when it's not a full AgentResponse (e.g. {"executor":"opencode"}).
211        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        // Otherwise fall through and try per-event heuristics below
221    }
222
223    for text in texts.iter().rev() {
224        let trimmed = text.trim();
225        if let Some(json) = extract_json_object(trimmed) {
226            // Prefer JSON blobs that parse as AgentResponse. This allows
227            // accepting payloads that don't include routing keys but are
228            // nevertheless valid task responses.
229            if parser::parse(&json).is_ok() {
230                return Some(json);
231            }
232
233            // Also accept routing-style JSON objects that don't match the
234            // AgentResponse schema (router decisions, etc.).
235            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        // As a conservative fallback, if the trimmed chunk contains a '{' and
243        // looks like it mentions routing keys, return it. We keep this branch
244        // minimal to avoid accidental acceptance of unrelated log blobs.
245        if trimmed.contains('{') {
246            // As a last-ditch conservative heuristic, accept the chunk if it
247            // can be interpreted as a valid AgentResponse or if it contains
248            // routing keys. This avoids accepting unrelated log blobs while
249            // remaining tolerant of router-style payloads.
250            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    // Some schemas store text content as: {"content":[{"type":"text","text":"..."}, ...]}
276    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        // Some opencode versions nest assistant text in a message.content array.
323        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        // Early opencode wrappers may emit a system/init envelope before the
336        // actual text/result event. Ensure the extractor skips the init envelope
337        // and returns the real JSON payload from the subsequent text event.
338        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
350// Each worktree gets its own snapshot git repo under opencode's data dir and nothing removes it.
351// Orch commits the work itself, so turn snapshots off for orch runs only
352const NO_SNAPSHOT_CONFIG: &str = r#"{"snapshot":false}"#;
353
354impl OpenCodeRunner {
355    pub fn new() -> Self {
356        Self
357    }
358
359    /// Split an opencode model identifier into base model and optional variant.
360    ///
361    /// The identifier shape is: "provider/model[@variant]". Splitting is
362    /// performed on the LAST `@` so provider/model strings containing `@`
363    /// are handled correctly. Returns (base, Some(variant)) when a trailing
364    /// `@` is present (variant may be empty), or (s, None) when no `@` exists.
365    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    /// Extract text from `text` events.
376    ///
377    /// Concatenates all text events, then tries to find the structured
378    /// JSON response. If the concatenated text doesn't parse as JSON,
379    /// tries each text event individually (newest first) since earlier
380    /// events are often progress messages.
381    ///
382    /// Handles two text event formats emitted by different opencode versions:
383    /// - Format 1 (current): `{"type":"text","part":{"type":"text","text":"..."}}`
384    /// - Format 2 (newer):   `{"type":"text","text":"..."}`
385    fn extract_text_from_events(events: &[serde_json::Value]) -> Option<String> {
386        extract_ndjson_text(events)
387    }
388
389    /// Extract token usage from `step_finish` events.
390    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    /// Check for error events in the stream.
408    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
435/// Render an error value as text: strings as-is, objects by their message/name or raw JSON
436fn 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
448/// Extract the message from an opencode `error` event, keeping the raw JSON when no shape matches
449fn 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        // Propagate terminal errors so the review pipeline records cooldowns.
491        if let Some(err) = Self::detect_error(&events) {
492            return Err(err);
493        }
494
495        // Concatenate all text events; fall back to raw output if none found.
496        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        // Support optional variant suffix on opencode model identifiers:
508        // provider/model[@variant]
509        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        // OpenCode autonomous permission control.
519        //
520        // `--dangerously-skip-permissions` auto-approves any tool that isn't
521        // explicitly denied, which is what orch needs for unattended dispatch.
522        // It avoids the user's global ~/.config/opencode/opencode.json defaults
523        // (e.g. "edit":"ask", "external_directory":"ask") that would otherwise
524        // block agent file edits and git operations on the worktree.
525        //
526        // The previously-used .orch-opencode/opencode/opencode.json +
527        // XDG_CONFIG_HOME override is no longer needed: the only `deny` entries
528        // it set were for opencode's interactive-only features (todowrite,
529        // question, codesearch, list) which never fire under `opencode run`.
530        let skip_perms = if permissions.autonomous {
531            "--dangerously-skip-permissions "
532        } else {
533            ""
534        };
535
536        // Append variant flag when present
537        let variant_part = variant_flag.unwrap_or_default();
538        // Feed both files via process substitution rather than a leading `cat |`
539        // pipe stage — a leading pipe would make `cat`, not opencode, the first
540        // stage in the runner script's pipeline, so PIPESTATUS[0] there would
541        // always report cat's (always-zero) exit code instead of opencode's.
542        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        // Empty output with exit code 0 is a silent failure — return Unknown with
558        // a deterministic message matching what fallback.rs expects so the model
559        // gets a cooldown and free-model retry is attempted.
560        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            // Maybe direct JSON
572            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        // Check for errors first
587        if let Some(err) = Self::detect_error(&events) {
588            return Err(err);
589        }
590
591        // Extract tokens (needed for both the text path and the tool-only fallback)
592        let (input_tokens, output_tokens) = Self::extract_tokens(&events);
593
594        // Extract text — when opencode emits only tool_use/step events with no
595        // text content, synthesize a human-readable summary from the event
596        // stream instead of falling through to InvalidResponse. Otherwise the
597        // upstream `synthesize_response_from_text` heuristic gets handed the
598        // entire raw NDJSON, matches a "completed" substring inside tool state
599        // JSON, and emits 500 bytes of raw NDJSON as the task summary.
600        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        // Parse the text through standard parser
612        let response = match parser::parse(&text) {
613            Ok(r) => r,
614            Err(_) => {
615                // Structured parse failed — try plain-text synthesis before
616                // giving up, same rescue path claude.rs uses (issue #3467).
617                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        // Try parsing NDJSON events from stdout for structured errors
633        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        // Known default models; could be extended with `opencode models` discovery
648        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        // Routing only needs text output — no tools fire.
656        // `--dangerously-skip-permissions` prevents the user's global
657        // ~/.config/opencode/opencode.json interactive defaults (e.g.
658        // "edit":"ask") from producing PermissionError events that the router
659        // would misclassify as model failures.
660        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                // pass variant even if empty (last-token-wins semantics)
671                cmd.arg("--variant").arg(v);
672            }
673        }
674        cmd.arg(prompt);
675        Ok(cmd)
676    }
677}
678
679/// Classify an OpenCode error message.
680fn classify_opencode_message(message: &str) -> AgentError {
681    let lower = message.to_lowercase();
682
683    // Rate limit — delegate to shared helper
684    if let Some(e) = super::patterns::detect_rate_limit(message) {
685        return e;
686    }
687
688    // Context overflow — delegate to shared helper (covers "context overflow", "context length", etc.)
689    if let Some(e) = super::patterns::detect_context_overflow(message) {
690        return e;
691    }
692
693    // Auth errors — delegate to shared helper (includes HTTP 401/403, billing, etc.)
694    if let Some(e) = super::patterns::detect_auth_error(message) {
695        return e;
696    }
697
698    // Permission denied — delegate to shared helper
699    if let Some(e) = super::patterns::detect_permission_denied(message) {
700        return e;
701    }
702
703    // Model not available (opencode-specific extraction pattern)
704    //
705    // Patterns handled:
706    //   "Model not found: anthropic/claude-sonnet-4-6."
707    //   "Model not found: github-copilot/gemini-3.1-pro. Did you mean: gemini-3.1-pro-preview?"
708    //   "model not supported: X"
709    //   "The free model has been deprecated. Transition to qwen/qwen3.6-plus for continued paid access."
710    //   "No endpoints found for qwen/qwen3.6-plus:free."
711    //   "This model is unavailable for free. The paid version is available now - use this slug instead: X"
712    //   "This model is not available in your country."
713    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        // Try to extract model name from patterns like "Model not found: anthropic/claude-sonnet-4-6."
724        // or "No endpoints found for qwen/qwen3.6-plus:free."
725        let model = if lower.contains("no endpoints found") {
726            // "No endpoints found for X." — extract X after "for "
727            message
728                .split(" for ")
729                .nth(1)
730                .map(|s| s.trim_end_matches('.').to_string())
731                .unwrap_or_default()
732        } else {
733            // Try "Model not found: X" or "model not supported: X" patterns
734            let from_colon = message
735                .split(": ")
736                .nth(1)
737                .map(|s| {
738                    // Strip opencode's "Did you mean: X?" suggestion suffix if present
739                    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            // For deprecated messages like "The free model has been deprecated. Transition to X for..."
748            // extract the model from "Transition to X" when colon-based extraction yields nothing.
749            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            // For "unavailable for free" messages like "... use this slug instead: X"
761            // extract the suggested replacement slug.
762            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            // Transition/slug extractions are tied to specific message shapes and take
773            // priority over the generic colon split, which would otherwise grab the
774            // wrong substring (e.g. the "[404] ..." text before the real slug).
775            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    // OpenCode surfaces opaque upstream provider failures as "Provider returned error".
787    // Treat this as a usage-limit class signal so fallback/error tracking records a
788    // rate-limit event (instead of a generic failure), allowing router health/degraded
789    // checks to react faster to unstable provider/model endpoints.
790    if lower.contains("provider returned error") {
791        return AgentError::RateLimit {
792            message: message.to_string(),
793        };
794    }
795
796    // Transient network/transport errors (e.g. "Upstream idle timeout exceeded")
797    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
806/// Discover free opencode models, with 1-hour cache and background refresh.
807///
808/// This is the single source of truth for free model discovery. Called by
809/// the router (pool expansion, model_map), the runner (failover), and
810/// startup priming.
811///
812/// Non-blocking: returns cached data immediately. When the cache is cold
813/// or expired, spawns a background thread to refresh via `opencode models`.
814pub 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    // Fast path: return cached data if still fresh (1-hour TTL).
822    {
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    // Cache is cold or expired. Spawn a background task on the current runtime to refresh.
831    // Only one refresh runs at a time.
832    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                // Use the current tokio runtime's handle to spawn the async discovery task,
854                // avoiding the overhead of a std::thread + new tokio runtime.
855                handle.spawn(refresh);
856            }
857            _ => {
858                // No tokio runtime (e.g. called from a plain unit test). Spawn a thread
859                // with a dedicated runtime — this is the fallback path.
860                thread::spawn(move || {
861                    if let Ok(rt) = Runtime::new() {
862                        rt.block_on(refresh);
863                    }
864                });
865            }
866        }
867    }
868
869    // Return whatever is in cache (may be empty on first call).
870    let guard = cache.lock().unwrap_or_else(PoisonError::into_inner);
871    guard.1.clone()
872}
873
874/// Discover all opencode models, with 1-hour cache and background refresh.
875///
876/// Non-blocking: returns cached data immediately. When the cache is cold
877/// or expired, spawns a background refresh via `opencode models`.
878pub 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
920/// Prime the free-model cache synchronously at startup.
921///
922/// Called from `Router::new()` via `spawn_blocking` so the initial
923/// blocking subprocess doesn't stall the Tokio runtime.
924/// Runs `run_opencode_models_discovery_async()` in a dedicated thread with its
925/// own tokio runtime, avoiding `block_on` restrictions when called from within
926/// an existing runtime (e.g. `#[tokio::test]` or a nested runtime context).
927pub 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
957/// Async version of `run_opencode_models_discovery` that uses `tokio::time::sleep`
958/// instead of blocking `std::thread::sleep`.
959///
960/// Returns the discovered models plus a reason code describing why the list
961/// is empty (`"ok"` when discovery actually succeeded with a non-empty
962/// result). The reason is threaded into `update_discovered_models_cache` so
963/// the "returned empty" warning says which of the failure branches fired,
964/// without requiring `RUST_LOG=debug` in production.
965async fn run_opencode_models_discovery_async() -> (Vec<String>, &'static str) {
966    run_opencode_models_cli(Duration::from_secs(30)).await
967}
968
969/// Run `opencode models` and reap any process-group leftovers when it returns
970pub(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
1058/// Build a synthetic `AgentResponse` summarizing an opencode NDJSON event
1059/// stream when no `text` events are present.
1060///
1061/// Opencode runs that produced tool calls but never emitted a text event
1062/// (model exited mid-tool, stop_reason without a final reply, etc.) would
1063/// otherwise be passed to `synthesize_response_from_text` as raw NDJSON.
1064/// That heuristic matches "completed" substrings inside tool state JSON and
1065/// emits the first 500 bytes of NDJSON as the notification summary — what
1066/// the user sees as garbage in Telegram/Discord/Slack.
1067///
1068/// Status is `needs_review` because there is no text confirming completion;
1069/// the agent did work but never reported on it.
1070fn 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        // Capture tool names from common opencode/claude-style shapes.
1092        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
1150/// The cost opencode reports in the last `step_finish` event, if any.
1151fn 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
1165/// Extract a structured `AgentResult` from OpenCode NDJSON output.
1166///
1167/// Concatenates text from `type:text` events (both `part.text` and direct
1168/// `text` field formats), extracts tokens from the last `step_finish` event,
1169/// and checks for `error` / `step_finish.reason=error` events.
1170///
1171/// Returns `None` only if no parseable NDJSON events are found.
1172pub 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    // Check for errors first
1179    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    // Extract text content
1190    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    // Extract tokens from step_finish
1197    let (input_tokens, output_tokens) = OpenCodeRunner::extract_tokens(&events);
1198
1199    // The model was cut off for exceeding its output/reasoning token budget,
1200    // not because it produced malformed prose. Distinguish this from a
1201    // generic parse failure so callers don't apply the long
1202    // format-incapable-model cooldown for a token-budget fluke. A reasoning
1203    // model that spends its entire budget on hidden reasoning emits zero
1204    // text and a final step_finish of reason="length" (or opencode's
1205    // "unknown" with all-zero tokens) — same failure mode, must be computed
1206    // before the empty-text early return below or it never gets checked.
1207    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    /// Newer opencode versions emit text directly in the event (no "part" wrapper).
1273    /// The extract_text method must handle both formats.
1274    #[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        // NDJSON with a text event that contains a JSON-like fragment which does
1314        // NOT include routing keys (executor/status). This should NOT be
1315        // interpreted as a routing payload; parse_response should fail with
1316        // InvalidResponse rather than accidentally accepting the fragment.
1317        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                // expected
1325            }
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    /// Regression: opencode runs that emit only tool_use / step_start / step_finish
1339    /// events (no `text` events) must synthesize a clean needs_review response from
1340    /// the event stream instead of returning InvalidResponse with the raw NDJSON
1341    /// blob, which would otherwise be passed to synthesize_response_from_text and
1342    /// leak as 500 bytes of raw JSON into the notification summary.
1343    #[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        // Tokens from step_finish must still be propagated.
1371        assert_eq!(parsed.input_tokens, Some(500));
1372        assert_eq!(parsed.output_tokens, Some(0));
1373    }
1374
1375    /// Regression test for issue #3467: when opencode's `text` event contains
1376    /// a plain-prose completion summary (not JSON), parser::parse fails but
1377    /// synthesize_response_from_text must rescue it instead of returning
1378    /// InvalidResponse, mirroring the fallback claude.rs already has.
1379    #[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        // Empty output with exit 0 is treated as silent failure so fallback.rs
1406        // can apply model cooldown and retry with free models
1407        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        // Issue #1934: opencode returns "Model not found: X. Did you mean: Y?"
1435        // The parser must extract "X", not "X. Did you mean"
1436        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        // Issue #2228: "The free model has been deprecated." should be ModelUnavailable
1451        // with the model extracted from "Transition to X" so the cooldown key is non-empty.
1452        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        // Issue #3475: "This model is unavailable for free ... use this slug instead: X"
1469        // must classify as ModelUnavailable, not fall through to the transient
1470        // network-error path via the "Upstream request failed" substring.
1471        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        // Issue #3535: "This model is not available in your country." must classify as
1488        // ModelUnavailable (persistent per-model cooldown), not fall through to the
1489        // generic AgentFailed bucket which applies a weaker cooldown plus an
1490        // unwarranted agent-wide penalty.
1491        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        // Issue #2228: "No endpoints found for X." should be ModelUnavailable with model extracted
1502        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        // Autonomous mode passes --dangerously-skip-permissions instead of
1532        // writing a config file or overriding XDG_CONFIG_HOME.
1533        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        // Regression: the command must not start with a `cat sys msg |` pipe
1550        // stage. `build_runner_script` captures the agent's exit status via
1551        // `PIPESTATUS[0]` of `{agent_cmd} | tee ...` — a leading `cat |` would
1552        // make PIPESTATUS[0] always report cat's (always-zero) exit code
1553        // instead of opencode's real exit code. sys/msg files must be fed via
1554        // input redirection instead.
1555        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        // Issue #2478: "Provider returned error" is an opaque upstream failure from the
1640        // opencode CLI. Classify as RateLimit so fallback records a rate-limit signal
1641        // and applies cooldown behavior tuned for transient provider instability.
1642        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        // Issue #3301: "Upstream idle timeout exceeded" must produce NetworkError so
1658        // fallback.rs applies a model-level cooldown instead of retrying immediately.
1659        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        // discover_free_opencode_models returns empty in test/debug builds
1669        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    /// The stub stands in for opencode 2.2.1, which starts `opencode serve --service`
1686    /// as a child that outlives it
1687    #[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        // The production discovery timeout, so a loaded machine does not turn this into
1704        // a timeout run, which reaps the group too and would assert nothing
1705        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        // Signal 0 is the POSIX existence probe
1728        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        // Timestamp must advance on a failed refresh so the TTL provides a
1744        // real backoff window instead of retrying on every subsequent call.
1745        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    // ── Fixture-based tests ─────────────────────────────────────
1790
1791    /// Real failure: OpenCode rejects a tool permission in non-interactive mode.
1792    /// The error has `{"error":{"name":"PermissionError","data":{"message":"user rejected permission..."}}}`.
1793    /// Parser must extract the nested message and classify as PermissionDenied.
1794    #[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    /// Real failure: OpenCode returns nested error for unknown model.
1807    /// The error object is `{"name":"UnknownError","data":{"message":"Model not found: X"}}`.
1808    /// Parser must extract the nested message and classify as ModelUnavailable.
1809    #[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    /// Real failure: OpenCode returns "Provider returned error" as an opaque upstream
1825    /// provider failure. Classified as RateLimit so degraded/rate-limit tracking applies.
1826    #[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    // ── extract_text ─────────────────────────────────────────────
1839
1840    /// OpenCode: extract_text concatenates text events for review parsing.
1841    #[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    /// OpenCode: extract_text with newer direct-text format.
1858    #[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    /// OpenCode: extract_text propagates RateLimit for terminal errors.
1875    #[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    /// OpenCode: extract_text propagates Auth error.
1890    #[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    /// OpenCode: extract_text on empty input returns empty string (not an error).
1905    #[test]
1906    fn extract_text_empty_input_returns_empty_ok() {
1907        let text = runner().extract_text("").unwrap();
1908        assert_eq!(text, "");
1909    }
1910
1911    // ── find_opencode_result ────────────────────────────────────
1912
1913    #[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    /// step_finish reason=length signals the model was cut off by its
1941    /// output/reasoning token budget, not malformed output — the flag must
1942    /// be set so callers avoid the persistent-format-failure cooldown.
1943    #[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    /// A reasoning model can burn its entire budget on hidden reasoning and
1958    /// emit zero text before step_finish reason=length. The old early return
1959    /// on empty result_text bailed out with None before truncated_by_length
1960    /// was ever computed, so this got misclassified as parse_error and hit
1961    /// the 4h-7d persistent-model cooldown instead of standard backoff.
1962    #[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    /// opencode also emits reason="unknown" with all-zero tokens for the same
1976    /// zero-output failure mode — must be treated as an equivalent signal.
1977    #[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    /// reason="unknown" with nonzero output tokens means the model did
1991    /// produce something and the step just wasn't cleanly terminated — not
1992    /// the same "wrote nothing" signal, so it must not be flagged.
1993    #[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
2058/// OpenCode `--format json`: a `tool_use` event carries both the call and its finished state
2059fn 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}