nucel_agent_opencode/

lib.rs

//! OpenCode provider — HTTP client to an `opencode serve` instance.
//!
//! OpenCode runs as a server (`opencode serve` on `:4096` by default). This
//! provider talks to it via HTTP REST. The client is stateless — sessions
//! live on the server.
//!
//! Supports:
//! - Session creation and prompting
//! - Multi-turn conversations
//! - Session resume (native — returns the same OpenCode session id)
//! - Basic-auth credentials (`api_key` → HTTP basic password)
//!
//! # Minimal example
//!
//! Start a local server in another shell:
//!
//! ```bash
//! opencode serve --port 4096
//! ```
//!
//! Then:
//!
//! ```rust,no_run
//! use nucel_agent_opencode::OpencodeExecutor;
//! use nucel_agent_core::{AgentExecutor, SpawnConfig};
//! use std::path::Path;
//!
//! # async fn run() -> nucel_agent_core::Result<()> {
//! let executor = OpencodeExecutor::with_base_url("http://127.0.0.1:4096");
//! let session = executor.spawn(
//!     Path::new("/my/repo"),
//!     "Read the README and summarize this project.",
//!     &SpawnConfig::default(),
//! ).await?;
//!
//! println!("{}", session.query("Any TODOs?").await?.content);
//! session.close().await?;
//! # Ok(()) }
//! ```
//!
//! See also: [workspace README](https://github.com/nucel-dev/agent-sdk#readme)
//! and the runnable example `crates/unified/examples/opencode_http.rs`.

#![cfg_attr(docsrs, feature(doc_cfg))]

mod client;
mod protocol;

use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};

use async_trait::async_trait;

use nucel_agent_core::{
    AgentCapabilities, AgentCost, AgentError, AgentExecutor, AgentResponse, AgentSession,
    AvailabilityStatus, EventStream, ExecutorType, Result, SessionImpl, SpawnConfig,
};

use client::OpencodeClient;

/// OpenCode executor — connects to OpenCode HTTP server.
pub struct OpencodeExecutor {
    base_url: String,
    api_key: Option<String>,
}

impl OpencodeExecutor {
    pub fn new() -> Self {
        Self {
            base_url: "http://127.0.0.1:4096".to_string(),
            api_key: None,
        }
    }

    pub fn with_base_url(base_url: impl Into<String>) -> Self {
        Self {
            base_url: base_url.into().trim_end_matches('/').to_string(),
            api_key: None,
        }
    }

    pub fn with_api_key(mut self, api_key: impl Into<String>) -> Self {
        self.api_key = Some(api_key.into());
        self
    }

    /// Build a client scoped to a given working dir. The underlying
    /// `reqwest::Client` will pool HTTP keep-alive connections per executor
    /// invocation (`spawn`, `resume`, and within a session's `query` loop —
    /// see `OpenCodeSessionImpl::client`).
    fn make_client(&self, working_dir: &Path) -> OpencodeClient {
        OpencodeClient::new(
            &self.base_url,
            self.api_key.as_deref(),
            working_dir.to_str(),
        )
    }
}

impl Default for OpencodeExecutor {
    fn default() -> Self {
        Self::new()
    }
}

/// Internal session implementation for OpenCode.
struct OpenCodeSessionImpl {
    cost: Arc<Mutex<AgentCost>>,
    budget: f64,
    /// One client per session — preserves HTTP keep-alive across queries.
    client: OpencodeClient,
    opencode_session_id: String,
    config: SpawnConfig,
}

#[async_trait]
impl SessionImpl for OpenCodeSessionImpl {
    async fn query(&self, prompt: &str) -> Result<AgentResponse> {
        {
            let c = self.cost.lock().unwrap();
            if c.total_usd >= self.budget {
                return Err(AgentError::BudgetExceeded {
                    limit: self.budget,
                    spent: c.total_usd,
                });
            }
        }

        let resp = self
            .client
            .prompt(&self.opencode_session_id, prompt, &self.config, self.budget)
            .await?;

        {
            let mut c = self.cost.lock().unwrap();
            c.input_tokens += resp.cost.input_tokens;
            c.output_tokens += resp.cost.output_tokens;
            c.total_usd += resp.cost.total_usd;
        }

        Ok(resp)
    }

    async fn query_stream(&self, prompt: &str) -> Result<EventStream> {
        {
            let c = self.cost.lock().unwrap();
            if c.total_usd >= self.budget {
                return Err(AgentError::BudgetExceeded {
                    limit: self.budget,
                    spent: c.total_usd,
                });
            }
        }
        self.client
            .stream_events(
                self.opencode_session_id.clone(),
                prompt.to_string(),
                self.config.clone(),
                self.budget,
            )
            .await
    }

    async fn total_cost(&self) -> Result<AgentCost> {
        Ok(self.cost.lock().unwrap().clone())
    }

    async fn close(&self) -> Result<()> {
        // Best-effort abort of any in-flight server-side work.
        self.client.abort(&self.opencode_session_id).await
    }
}

#[async_trait]
impl AgentExecutor for OpencodeExecutor {
    fn executor_type(&self) -> ExecutorType {
        ExecutorType::OpenCode
    }

    async fn spawn(
        &self,
        working_dir: &Path,
        prompt: &str,
        config: &SpawnConfig,
    ) -> Result<AgentSession> {
        let cost = Arc::new(Mutex::new(AgentCost::default()));
        let budget = config.budget_usd.unwrap_or(f64::MAX);

        if budget <= 0.0 {
            return Err(AgentError::BudgetExceeded {
                limit: budget,
                spent: 0.0,
            });
        }

        let client = self.make_client(working_dir);

        // Create session on server.
        let session_data = client.create_session().await?;
        let opencode_session_id = session_data
            .get("id")
            .and_then(|v| v.as_str())
            .ok_or_else(|| AgentError::Provider {
                provider: "opencode".into(),
                message: "session response missing id".into(),
            })?
            .to_string();

        // Send first prompt — reusing the same client (HTTP keep-alive).
        let response = client
            .prompt(&opencode_session_id, prompt, config, budget)
            .await?;

        {
            let mut c = cost.lock().unwrap();
            *c = response.cost.clone();
        }

        let inner = Arc::new(OpenCodeSessionImpl {
            cost: cost.clone(),
            budget,
            client,
            opencode_session_id: opencode_session_id.clone(),
            config: config.clone(),
        });

        Ok(AgentSession::new(
            opencode_session_id,
            ExecutorType::OpenCode,
            working_dir.to_path_buf(),
            config.model.clone(),
            inner,
        ))
    }

    async fn resume(
        &self,
        working_dir: &Path,
        session_id: &str,
        prompt: &str,
        config: &SpawnConfig,
    ) -> Result<AgentSession> {
        // OpenCode supports native session resume — we just keep prompting the
        // existing server session id.
        let cost = Arc::new(Mutex::new(AgentCost::default()));
        let budget = config.budget_usd.unwrap_or(f64::MAX);

        if budget <= 0.0 {
            return Err(AgentError::BudgetExceeded {
                limit: budget,
                spent: 0.0,
            });
        }

        let client = self.make_client(working_dir);

        let response = client
            .prompt(session_id, prompt, config, budget)
            .await?;

        {
            let mut c = cost.lock().unwrap();
            *c = response.cost.clone();
        }

        let inner = Arc::new(OpenCodeSessionImpl {
            cost: cost.clone(),
            budget,
            client,
            opencode_session_id: session_id.to_string(),
            config: config.clone(),
        });

        Ok(AgentSession::new(
            session_id.to_string(),
            ExecutorType::OpenCode,
            working_dir.to_path_buf(),
            config.model.clone(),
            inner,
        ))
    }

    fn capabilities(&self) -> AgentCapabilities {
        AgentCapabilities {
            session_resume: true,
            // True now that we actually parse info.tokens / tokens.
            token_usage: true,
            mcp_support: true,
            autonomous_mode: true,
            structured_output: false,
            streaming: true,
            hooks: false,
            prompt_caching: false,
            extended_thinking: false,
        }
    }

    fn availability(&self) -> AvailabilityStatus {
        AvailabilityStatus {
            available: true,
            reason: Some(format!(
                "Run `opencode serve` to start server at {}",
                self.base_url
            )),
        }
    }
}

// Keep PathBuf used (formerly used directly; now via working_dir.to_path_buf()).
#[allow(dead_code)]
fn _pathbuf_used() -> PathBuf {
    PathBuf::new()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn executor_type_is_opencode() {
        let exec = OpencodeExecutor::new();
        assert_eq!(exec.executor_type(), ExecutorType::OpenCode);
    }

    #[test]
    fn capabilities_declares_session_resume() {
        let caps = OpencodeExecutor::new().capabilities();
        assert!(caps.session_resume);
        assert!(caps.autonomous_mode);
        assert!(caps.mcp_support);
        assert!(caps.token_usage);
    }

    #[test]
    fn default_base_url_is_localhost() {
        let exec = OpencodeExecutor::new();
        assert_eq!(exec.base_url, "http://127.0.0.1:4096");
    }

    #[test]
    fn custom_base_url_strips_trailing_slash() {
        let exec = OpencodeExecutor::with_base_url("http://my-server:8080/");
        assert_eq!(exec.base_url, "http://my-server:8080");
    }
}