Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
//! OpenCode native ACP leaf; the shared executor owns authority, transport and process cleanup.
use super::*;
use std::collections::BTreeSet;
pub(super) const MODE: &str = "hiroute-worker";
/// Final admission runs under the existing initialization permit. In particular,
/// another first Worker may still be creating this native database during rendering.
pub(super) struct StartupAdmission {
native: hiroute_integrations::OpenCodeNativeContext,
config_digest: hiroute_domain::CanonicalDigest,
migrations: &'static [&'static str],
search_path: String,
}
impl StartupAdmission {
pub(super) fn root(&self) -> &Path {
&self.native.database
}
pub(super) fn validate(
&self,
workspace: &Path,
new_session: bool,
) -> Result<(), DelegationErrorV1> {
let unavailable = || DelegationErrorV1::CapabilityUnavailable;
if !new_session
&& !self
.native
.database
.try_exists()
.map_err(|_| unavailable())?
{
return Err(DelegationErrorV1::ResumeUnavailable);
}
validate_database(&self.native.database, self.migrations)?;
let config = self
.native
.read_config(Some((workspace, &self.search_path)))
.map_err(|_| unavailable())?;
if config.digest != self.config_digest {
return Err(unavailable());
}
hiroute_integrations::validate_opencode_composition(
&self.native,
&config,
workspace,
&self.search_path,
)
.map_err(|_| unavailable())
}
}
pub(super) fn render(
input: &ProfileInput<'_>,
search_path: &str,
) -> Result<RenderedHarnessProfile, DelegationErrorV1> {
let unavailable = || DelegationErrorV1::CapabilityUnavailable;
let native = input.native_context.opencode().ok_or_else(unavailable)?;
let ids = hiroute_integrations::opencode_native_format(input.harness_binary)
.map_err(|_| unavailable())?;
let config = native
.read_config(Some((input.workspace, search_path)))
.map_err(|_| unavailable())?;
let task = input
.session_root
.path()
.file_name()
.and_then(|n| n.to_str())
.ok_or_else(unavailable)?;
let provider = format!("hiroute-worker-{task}");
if config.value["provider"].get(&provider).is_some()
|| config.value["agent"].get(MODE).is_some()
{
return Err(unavailable());
}
let model = hiroute_domain::AdditionalAgentModelV1 {
alias: input.alias.into(),
protocol: input.protocol,
context_window_tokens: input.context_window_tokens.ok_or_else(unavailable)?,
max_output_tokens: input.max_output_tokens.ok_or_else(unavailable)?,
};
let declaration = hiroute_integrations::opencode_provider(
&format!("http://{}/v1", input.gateway),
&model,
"{env:HIROUTE_RUN_TOKEN}",
None,
)
.map_err(|_| unavailable())?;
let selector = format!("{provider}/{}", input.alias);
let permission = json!({"*":"deny","read":"allow","edit":"allow","bash":"allow","glob":"allow","grep":"allow","skill":"allow","external_directory":"allow","doom_loop":"allow"});
let mut agents = serde_json::Map::new();
for key in ["build", "plan", "general", "explore"].into_iter().chain(
config.value["agent"]
.as_object()
.into_iter()
.flat_map(|v| v.keys().map(String::as_str)),
) {
agents.insert(key.into(), json!({"disable":true}));
}
for key in ["title", "summary", "compaction"] {
agents.insert(
key.into(),
json!({"model":selector,"disable":false,"permission":{"*":"deny"}}),
);
}
agents.insert(
MODE.into(),
json!({"mode":"primary","model":selector,"permission":permission}),
);
let mcp = config.value["mcp"]
.as_object()
.into_iter()
.flat_map(|v| v.keys())
.map(|k| (k.clone(), json!({"enabled":false})))
.collect::<serde_json::Map<_, _>>();
let overlay = json!({"$schema":"https://opencode.ai/config.json","model":selector,"small_model":selector,"default_agent":MODE,
"enabled_providers":[provider],"provider":{(provider):declaration},"agent":agents,"permission":permission,"mcp":mcp,
"share":"disabled","autoupdate":false,"lsp":false,"formatter":false,"compaction":{"auto":true}});
let mut listener_entropy = [0u8; 32];
getrandom::fill(&mut listener_entropy).map_err(|_| unavailable())?;
let listener_password = Zeroizing::new(
listener_entropy
.iter()
.map(|b| format!("{b:02x}"))
.collect::<String>(),
);
use zeroize::Zeroize;
listener_entropy.zeroize();
let mut rendered = RenderedHarnessProfile {
opencode_startup: Some(StartupAdmission {
native: native.clone(),
config_digest: config.digest.clone(),
migrations: ids,
search_path: search_path.into(),
}),
native_model_id: selector,
native_args: vec![
"acp".into(),
"--cwd".into(),
input.workspace.into(),
"--hostname".into(),
"127.0.0.1".into(),
"--port".into(),
"0".into(),
"--mdns=false".into(),
],
..Default::default()
};
for (key, value) in [
(
"OPENCODE_CONFIG_CONTENT",
serde_json::to_string(&overlay).map_err(|_| unavailable())?,
),
("HIROUTE_RUN_TOKEN", secret_string(&input.token)?),
("OPENCODE_SERVER_PASSWORD", listener_password.to_string()),
("OPENCODE_SERVER_USERNAME", "hiroute-worker".into()),
("OPENCODE_PURE", "true".into()),
("OPENCODE_DISABLE_DEFAULT_PLUGINS", "true".into()),
("OPENCODE_DISABLE_AUTOUPDATE", "true".into()),
("OPENCODE_DISABLE_MODELS_FETCH", "true".into()),
("OPENCODE_DISABLE_LSP_DOWNLOAD", "true".into()),
("OPENCODE_DISABLE_FFF", "true".into()),
(
"OPENCODE_PERMISSION",
serde_json::to_string(&permission).map_err(|_| unavailable())?,
),
("OPENCODE_DB", path_string(&native.database)?),
(
"XDG_CONFIG_HOME",
path_string(native.config_root.parent().ok_or_else(unavailable)?)?,
),
(
"XDG_DATA_HOME",
path_string(native.data_root.parent().ok_or_else(unavailable)?)?,
),
(
"XDG_CACHE_HOME",
path_string(native.cache_root.parent().ok_or_else(unavailable)?)?,
),
(
"XDG_STATE_HOME",
path_string(native.state_root.parent().ok_or_else(unavailable)?)?,
),
] {
rendered.env.insert(key.into(), Zeroizing::new(value));
}
for (key, path) in [
("OPENCODE_CONFIG", native.config_file.as_ref()),
("OPENCODE_CONFIG_DIR", native.extra_config_root.as_ref()),
] {
if let Some(path) = path {
rendered
.env
.insert(key.into(), Zeroizing::new(path_string(path)?));
}
}
Ok(rendered)
}
fn validate_database(path: &Path, expected: &[&str]) -> Result<(), DelegationErrorV1> {
let unavailable = || DelegationErrorV1::CapabilityUnavailable;
match std::fs::symlink_metadata(path) {
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(()),
Ok(meta) if meta.is_file() && !meta.file_type().is_symlink() => {}
_ => return Err(unavailable()),
}
let db = rusqlite::Connection::open_with_flags(
path,
rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY | rusqlite::OpenFlags::SQLITE_OPEN_NO_MUTEX,
)
.map_err(|_| unavailable())?;
db.busy_timeout(std::time::Duration::from_millis(100))
.map_err(|_| unavailable())?;
let kind: String = db
.query_row(
"SELECT type FROM sqlite_schema WHERE name='migration'",
[],
|r| r.get(0),
)
.map_err(|_| unavailable())?;
if kind != "table" {
return Err(unavailable());
}
let mut query = db
.prepare(
"SELECT CASE WHEN length(CAST(id AS BLOB)) <= 256 THEN id END FROM migration LIMIT 129",
)
.map_err(|_| unavailable())?;
let rows = query
.query_map([], |r| r.get::<_, String>(0))
.map_err(|_| unavailable())?
.collect::<Result<Vec<_>, _>>()
.map_err(|_| unavailable())?;
if rows.len() > 128 || rows.iter().any(|x| x.len() > 256) {
return Err(unavailable());
}
let actual = rows.iter().map(String::as_str).collect::<BTreeSet<_>>();
if actual.len() != rows.len() || actual != expected.iter().copied().collect() {
return Err(unavailable());
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn git_workspace(home: &Path) -> String {
let path = worker_path(&home.join("opencode"), None, None).unwrap();
let status = std::process::Command::new("git")
.args(["init", "-q"])
.arg(home)
.env_clear()
.env("HOME", home)
.env("PATH", &path)
.status()
.unwrap();
assert!(status.success());
path
}
#[test]
fn opencode_startup_rejects_rewritable_schema_without_touching_borrowed_files() {
let root = tempfile::tempdir().unwrap();
let home = root.path().canonicalize().unwrap();
let native =
hiroute_integrations::OpenCodeNativeContext::from_lookup(&home, |_| None).unwrap();
std::fs::create_dir_all(&native.config_root).unwrap();
let search_path = git_workspace(&home);
for schema in [
"",
"{env:HIROUTE_UNSET_SCHEMA}",
"{file:schema.txt}",
"https://opencode.ai/config.json",
] {
let bytes = serde_json::to_vec(&json!({"$schema":schema})).unwrap();
std::fs::write(native.model_target(), &bytes).unwrap();
let config = native.read_config(Some((&home, &search_path))).unwrap();
let admission = StartupAdmission {
native: native.clone(),
config_digest: config.digest.clone(),
migrations: &["known"],
search_path: search_path.clone(),
};
assert_eq!(
admission.validate(&home, true).is_ok(),
schema == "https://opencode.ai/config.json",
"{schema}"
);
assert_eq!(std::fs::read(native.model_target()).unwrap(), bytes);
assert!(!native.database.exists());
}
}
#[test]
fn opencode_startup_refuses_incomplete_ancestry_before_native_tool_loading() {
for git in [true, false] {
let root = tempfile::tempdir().unwrap();
let home = root.path().canonicalize().unwrap();
let project = home.join("project");
std::fs::create_dir_all(project.join(".opencode/tools")).unwrap();
if git {
std::fs::create_dir(project.join(".git")).unwrap();
}
let tool = project.join(".opencode/tools/custom.ts");
let content = b"throw new Error('must never be imported')";
std::fs::write(&tool, content).unwrap();
let native =
hiroute_integrations::OpenCodeNativeContext::from_lookup(&home, |_| None).unwrap();
let search_path = git_workspace(&home);
let config = native.read_config(Some((&home, &search_path))).unwrap();
let admission = StartupAdmission {
native: native.clone(),
config_digest: config.digest.clone(),
migrations: &["known"],
search_path: search_path.clone(),
};
let deep = (0..65).fold(project, |path, _| path.join("d"));
std::fs::create_dir_all(&deep).unwrap();
assert_eq!(
admission.validate(&deep, true),
Err(DelegationErrorV1::CapabilityUnavailable)
);
assert_eq!(std::fs::read(tool).unwrap(), content);
assert!(!native.database.exists());
}
}
#[cfg(unix)]
#[test]
fn opencode_startup_refuses_false_git_stops_and_rechecks_late_boundary_changes() {
for kind in [
"empty",
"corrupt",
"broken-worktree",
"missing-git",
"rejected-git",
"late-corruption",
] {
let root = tempfile::tempdir().unwrap();
let base = root.path().canonicalize().unwrap();
let home = base.join("home");
let ancestor = base.join("ancestor");
let project = ancestor.join("project");
std::fs::create_dir(&home).unwrap();
std::fs::create_dir_all(&project).unwrap();
let native =
hiroute_integrations::OpenCodeNativeContext::from_lookup(&home, |_| None).unwrap();
let path = worker_path(&home.join("opencode"), None, None).unwrap();
let marker = project.join(".git");
if matches!(kind, "missing-git" | "rejected-git" | "late-corruption") {
let status = std::process::Command::new("git")
.args(["init", "-q"])
.arg(&project)
.env_clear()
.env("HOME", &home)
.env("PATH", &path)
.status()
.unwrap();
assert!(status.success());
} else if kind == "empty" {
std::fs::create_dir(&marker).unwrap();
} else {
std::fs::write(
&marker,
if kind == "corrupt" {
"not a gitdir"
} else {
"gitdir: missing-worktree\n"
},
)
.unwrap();
}
let config_bytes = br#"{"$schema":""}"#;
let config_path = ancestor.join("opencode.json");
std::fs::write(&config_path, config_bytes).unwrap();
std::fs::create_dir_all(ancestor.join(".opencode/tools")).unwrap();
let tool = ancestor.join(".opencode/tools/custom.ts");
let tool_bytes = b"throw new Error('must never be imported')";
std::fs::write(&tool, tool_bytes).unwrap();
let config = native.read_config(None).unwrap();
let mut admission = StartupAdmission {
native: native.clone(),
config_digest: config.digest.clone(),
migrations: &["known"],
search_path: path.clone(),
};
if kind == "late-corruption" {
assert!(admission.validate(&project, true).is_ok());
std::fs::write(marker.join("config"), b"[invalid git config").unwrap();
}
if kind == "missing-git" {
admission.search_path = home.to_str().unwrap().into();
}
if kind == "rejected-git" {
// A real Git rejection, without changing process-global test environment.
std::fs::write(marker.join("config"), b"[invalid git config").unwrap();
}
assert_eq!(
admission.validate(&project, true),
Err(DelegationErrorV1::CapabilityUnavailable),
"{kind}"
);
assert!(
native
.read_config(Some((&project, &admission.search_path)))
.is_err(),
"{kind}"
);
assert_eq!(std::fs::read(&config_path).unwrap(), config_bytes);
assert_eq!(std::fs::read(&tool).unwrap(), tool_bytes);
assert!(!native.database.exists());
}
}
#[test]
fn opencode_startup_rechecks_configuration_and_missing_continue_history() {
let root = tempfile::tempdir().unwrap();
let home = root.path().canonicalize().unwrap();
let native =
hiroute_integrations::OpenCodeNativeContext::from_lookup(&home, |_| None).unwrap();
let search_path = git_workspace(&home);
let config = native.read_config(Some((&home, &search_path))).unwrap();
let admission = StartupAdmission {
native: native.clone(),
config_digest: config.digest.clone(),
migrations: &["known"],
search_path: search_path.clone(),
};
assert_eq!(admission.root(), native.database);
assert!(admission.validate(&home, true).is_ok());
assert_eq!(
admission.validate(&home, false),
Err(DelegationErrorV1::ResumeUnavailable)
);
assert!(!native.database.exists());
std::fs::create_dir_all(&native.config_root).unwrap();
std::fs::write(
native.model_target(),
br#"{"$schema":"https://opencode.ai/config.json","mcp":{"late":{"enabled":true}}}"#,
)
.unwrap();
assert_eq!(
admission.validate(&home, true),
Err(DelegationErrorV1::CapabilityUnavailable)
);
assert!(!native.database.exists());
}
#[test]
fn opencode_database_admission_refuses_pending_unknown_and_legacy_without_writes() {
let root = tempfile::tempdir().unwrap();
let path = root.path().join("native.db");
assert!(validate_database(&path, &["known"]).is_ok());
assert!(!path.exists());
let db = rusqlite::Connection::open(&path).unwrap();
db.execute_batch("CREATE TABLE migration(id TEXT PRIMARY KEY);CREATE TABLE session(id TEXT PRIMARY KEY,content TEXT);INSERT INTO session VALUES('native-exact','opaque-must-survive')").unwrap();
drop(db);
let before = std::fs::read(&path).unwrap();
assert!(validate_database(&path, &["known"]).is_err());
assert_eq!(std::fs::read(&path).unwrap(), before);
let db = rusqlite::Connection::open(&path).unwrap();
db.execute("INSERT INTO migration VALUES('known')", [])
.unwrap();
drop(db);
let before = std::fs::read(&path).unwrap();
assert!(validate_database(&path, &["known"]).is_ok());
assert_eq!(std::fs::read(&path).unwrap(), before);
let db = rusqlite::Connection::open(&path).unwrap();
db.execute("INSERT INTO migration VALUES('future')", [])
.unwrap();
drop(db);
let before = std::fs::read(&path).unwrap();
assert!(validate_database(&path, &["known"]).is_err());
assert_eq!(std::fs::read(&path).unwrap(), before);
}
}