use std::collections::BTreeMap;
use std::io::{BufRead, Write};
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use arabica_model::{ContentBlock, RuntimeItem, RuntimeRole};
use arabica_protocol::{
Command, CommandEnvelope, CommandId, Event, EventEnvelope, SessionId, SessionStatus,
ToolPermissionOutcome, ToolPermissionScope, ToolPermissionSource,
};
use arabica_provider::{
ApiModelProvider, ApiProviderConfig, BlendProvider, ModelProgress, ModelProgressSink,
};
use arabica_runner::LocalTool;
use arabica_runtime::BlendRoutingPolicy;
use arabica_runtime::{
PermissionDecision, PermissionRequest, RunCancellation, RunControl, ToolPermissionGate,
ToolPermissionPolicy, ToolPermissionRule,
};
use arabica_session::{
DispatchControl, EventVisibility, FanOutObserver, SessionEventObserver, SessionManager,
};
use arabica_session::{NewSession, SessionStore, SessionWriter};
use crate::config::{SOE_POLICY_ID, save_workspace_settings, set_thinking, soe_policy};
use crate::host::{
HostModel, HostRuntime, LocalRunnerPolicy, ScriptedModel, UuidIds,
build_host_runtime_with_blend_and_runner, workspace_id_for,
};
use crate::print::{self, Resume};
pub struct InteractiveOptions {
pub allow_shell: bool,
pub read_only: bool,
pub resume: Resume,
pub remote_runner: Option<String>,
}
struct TerminalObserver {
state: Mutex<TerminalState>,
}
#[derive(Default)]
struct TerminalState {
step_message: String,
step_reasoning: String,
displayed: String,
line_open: bool,
thinking_open: bool,
}
impl TerminalObserver {
fn new() -> Arc<Self> {
Arc::new(Self {
state: Mutex::new(TerminalState::default()),
})
}
fn sink(self: &Arc<Self>) -> ModelProgressSink {
let observer = Arc::clone(self);
ModelProgressSink::new(move |progress| {
let mut state = observer.state.lock().expect("terminal state lock poisoned");
match progress {
ModelProgress::Start => {
state.step_message.clear();
state.step_reasoning.clear();
}
ModelProgress::Message(text) => {
if state.thinking_open {
eprintln!();
state.thinking_open = false;
}
print!("{text}");
let _ = std::io::stdout().flush();
state.step_message.push_str(&text);
state.displayed.push_str(&text);
state.line_open = true;
}
ModelProgress::Reasoning(text) => {
if !state.thinking_open {
eprint!("[thinking] ");
state.thinking_open = true;
}
eprint!("{text}");
let _ = std::io::stderr().flush();
state.step_reasoning.push_str(&text);
}
}
})
}
fn break_line(&self) {
let mut state = self.state.lock().expect("terminal state lock poisoned");
if state.thinking_open {
eprintln!();
state.thinking_open = false;
}
if state.line_open {
println!();
state.line_open = false;
}
}
fn finish(&self, output: Option<&str>) {
self.break_line();
let state = self.state.lock().expect("terminal state lock poisoned");
if let Some(output) = output.filter(|output| !output.is_empty())
&& !state.displayed.ends_with(output)
{
println!("{output}");
}
}
}
impl SessionEventObserver for TerminalObserver {
fn observe(&self, envelope: &EventEnvelope, _visibility: EventVisibility) {
match &envelope.event {
Event::ModelResponseItem {
item: RuntimeItem::Message(message),
..
} if message.role == RuntimeRole::Assistant => {
let full = message
.content
.iter()
.filter_map(|block| match block {
ContentBlock::Text { text } => Some(text.as_str()),
_ => None,
})
.collect::<String>();
let mut state = self.state.lock().expect("terminal state lock poisoned");
let extra = full
.strip_prefix(&state.step_message)
.unwrap_or(&full)
.to_owned();
if !extra.is_empty() {
if state.thinking_open {
eprintln!();
state.thinking_open = false;
}
print!("{extra}");
let _ = std::io::stdout().flush();
state.displayed.push_str(&extra);
state.line_open = true;
}
}
Event::ModelResponseItem {
item: RuntimeItem::Reasoning(reasoning),
..
} => {
let full = reasoning.summary.join("\n\n");
let mut state = self.state.lock().expect("terminal state lock poisoned");
let extra = full.strip_prefix(&state.step_reasoning).unwrap_or(&full);
if !extra.is_empty() {
if state.thinking_open {
eprintln!("{extra}");
} else {
eprintln!("[thinking] {extra}");
}
state.thinking_open = false;
}
}
Event::ToolCallRequested { name, .. } => {
self.break_line();
eprintln!("→ {name}");
}
Event::ToolCallCompleted { name, is_error, .. } if *is_error => {
eprintln!("✗ {name} failed")
}
_ => {}
}
}
}
pub(crate) fn policy() -> ToolPermissionPolicy {
let mut by_tool = BTreeMap::new();
for name in [
"read_file",
"list_dir",
"grep",
"find_files",
"memory_search",
"memory_read",
] {
by_tool.insert(name.to_owned(), ToolPermissionRule::Allow);
}
ToolPermissionPolicy {
default: ToolPermissionRule::Ask,
by_tool,
argument_rules: Vec::new(),
}
}
fn input_lines() -> tokio::sync::mpsc::UnboundedReceiver<std::io::Result<String>> {
let (sender, receiver) = tokio::sync::mpsc::unbounded_channel();
tokio::task::spawn_blocking(move || {
let stdin = std::io::stdin();
let mut input = stdin.lock();
loop {
let mut line = String::new();
match input.read_line(&mut line) {
Ok(0) => break,
Ok(_) => {
if sender.send(Ok(line)).is_err() {
break;
}
}
Err(error) => {
let _ = sender.send(Err(error));
break;
}
}
}
});
receiver
}
fn prompt(label: &str) {
print!("{label}");
let _ = std::io::stdout().flush();
}
pub(crate) fn set_progress(model: &mut HostModel, sink: ModelProgressSink) {
match model {
HostModel::Api(_) => {
let old = std::mem::replace(model, HostModel::Scripted(ScriptedModel::default()));
if let HostModel::Api(provider) = old {
*model = HostModel::StreamingApi(provider, sink);
}
}
HostModel::StreamingApi(_, progress) => *progress = sink,
HostModel::Blend(_) => {}
HostModel::Scripted(_) => {}
}
}
pub(crate) struct InteractiveSession {
pub(crate) manager: SessionManager<HostRuntime>,
pub(crate) session_id: SessionId,
pub(crate) store: Arc<dyn SessionWriter>,
pub(crate) session_store: Arc<dyn SessionStore>,
pub(crate) config: ApiProviderConfig,
pub(crate) model_configs: BTreeMap<String, ApiProviderConfig>,
blend_policy: Option<BlendRoutingPolicy>,
has_named_soe_policy: bool,
pub(crate) blend_policies: BTreeMap<String, BlendRoutingPolicy>,
pub(crate) arabica_home: PathBuf,
pub(crate) runner_root: PathBuf,
pub(crate) read_only: bool,
pub(crate) allow_shell: bool,
pub(crate) remote_runner: Option<String>,
}
impl InteractiveSession {
pub(crate) async fn open_with_model_configs(
config: ApiProviderConfig,
model: HostModel,
blend_policy: Option<BlendRoutingPolicy>,
model_configs: BTreeMap<String, ApiProviderConfig>,
options: InteractiveOptions,
) -> Result<Self, Box<dyn std::error::Error>> {
let arabica_home = arabica_adapters::default_arabica_home()?;
let session_store = crate::host::session_store(&arabica_home);
Self::open_with_store(
config,
model,
blend_policy,
model_configs,
options,
arabica_home,
session_store,
)
.await
}
pub(crate) async fn open_with_store(
config: ApiProviderConfig,
model: HostModel,
blend_policy: Option<BlendRoutingPolicy>,
model_configs: BTreeMap<String, ApiProviderConfig>,
options: InteractiveOptions,
arabica_home: PathBuf,
session_store: Arc<dyn SessionStore>,
) -> Result<Self, Box<dyn std::error::Error>> {
let session_blend_policy = blend_policy.clone();
let runner_root = std::env::current_dir()?;
let mut blend_policies =
crate::config::user_config_blend_policies(&arabica_home, &runner_root)
.unwrap_or_default();
let has_named_soe_policy = blend_policies.contains_key(SOE_POLICY_ID);
if let Some(policy) = &blend_policy
&& !blend_policies.values().any(|candidate| {
candidate.policy_id == policy.policy_id && candidate.version == policy.version
})
{
blend_policies.insert(policy.policy_id.clone(), policy.clone());
}
if !has_named_soe_policy && let Some(policy) = &blend_policy {
blend_policies
.entry(SOE_POLICY_ID.to_owned())
.or_insert_with(|| soe_policy(policy.default_model.clone()));
}
let workspace_id = workspace_id_for(&runner_root);
let resumed =
print::resolve_resume(&options.resume, session_store.as_ref(), &workspace_id)?;
let mut tool_policy = if options.read_only {
LocalRunnerPolicy::read_only()
} else {
LocalRunnerPolicy::coding()
};
if options.allow_shell {
tool_policy = tool_policy.with_tool(LocalTool::Shell);
}
let (mcp, mcp_diagnostics) = crate::mcp::connect_configured(&runner_root, &arabica_home)
.await
.map_err(|error| format!("mcp configuration: {error}"))?;
for diagnostic in mcp_diagnostics {
eprintln!("arabica: {diagnostic}");
}
let remote = match &options.remote_runner {
Some(name) => {
let remote =
crate::runner::connect_configured(&arabica_home, name, &tool_policy).await?;
eprintln!(
"structure: tools run on remote runner {} ({})",
remote.runner_id(),
name
);
Some(remote)
}
None => None,
};
let mut manager = SessionManager::with_ids(
build_host_runtime_with_blend_and_runner(
model,
&runner_root,
tool_policy,
&arabica_home,
mcp,
remote,
blend_policy,
)?,
Box::new(UuidIds),
);
let instructions_sha256 =
crate::instructions::sha256(manager.runtime().system_instructions());
let (session_id, store) = match resumed {
Some(stored) => {
let session_id = stored.header.id.clone();
let store = session_store.open(&workspace_id, &session_id)?;
manager.restore_session(
stored.into_snapshot(),
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(store.as_ref()),
)?;
if manager
.session(&session_id)
.is_some_and(|session| session.status == SessionStatus::Suspended)
{
manager
.dispatch(
CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(session_id.clone()),
Command::SessionResume,
),
DispatchControl {
run: RunControl::default(),
observer: Some(Arc::clone(&store) as Arc<dyn SessionEventObserver>),
},
)
.await?;
}
(session_id, store)
}
None => {
let created = manager
.dispatch(
CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
None,
Command::SessionCreate {
workspace_id: workspace_id.clone(),
},
),
DispatchControl::default(),
)
.await?;
let event = created.first().expect("session.create emits an event");
let session_id = event.session_id.clone();
let store = session_store.create(NewSession {
session_id: &session_id,
workspace_id: &workspace_id,
cwd: &runner_root,
profile: None,
instructions_sha256: Some(&instructions_sha256),
})?;
store.observe(event, EventVisibility::Client);
(session_id, store)
}
};
Ok(Self {
manager,
session_id,
store,
session_store,
config,
model_configs,
blend_policy: session_blend_policy,
has_named_soe_policy,
blend_policies,
arabica_home,
runner_root,
read_only: options.read_only,
allow_shell: options.allow_shell,
remote_runner: options.remote_runner,
})
}
pub(crate) async fn suspend(&mut self) -> Result<(), Box<dyn std::error::Error>> {
let envelope = CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(self.session_id.clone()),
Command::SessionSuspend,
);
self.manager
.dispatch(
envelope,
DispatchControl {
observer: Some(Arc::clone(&self.store) as Arc<dyn SessionEventObserver>),
..DispatchControl::default()
},
)
.await?;
Ok(())
}
pub(crate) fn session_list(&self) -> Result<Vec<String>, Box<dyn std::error::Error>> {
Ok(self
.session_list_entries()?
.into_iter()
.map(|entry| entry.line)
.collect())
}
pub(crate) fn session_list_entries(
&self,
) -> Result<Vec<crate::sessions::SessionEntry>, Box<dyn std::error::Error>> {
crate::sessions::listing_entries(
self.session_store.as_ref(),
Some(&workspace_id_for(&self.runner_root)),
)
}
pub(crate) async fn switch_to(
&mut self,
id: &str,
) -> Result<InteractiveSession, Box<dyn std::error::Error>> {
let config = self.config.clone();
let model = crate::host::HostModelCatalog {
provider: config.clone(),
models: self
.model_configs
.iter()
.map(|(alias, config)| (alias.clone(), config.model.clone()))
.collect(),
blend_policy: self.blend_policy.clone(),
model_configs: self.model_configs.clone(),
}
.build_model()?;
let mut next = InteractiveSession::open_with_store(
config,
model,
self.blend_policy.clone(),
self.model_configs.clone(),
InteractiveOptions {
allow_shell: self.allow_shell,
read_only: self.read_only,
resume: Resume::Id(id.to_owned()),
remote_runner: self.remote_runner.clone(),
},
self.arabica_home.clone(),
Arc::clone(&self.session_store),
)
.await?;
next.blend_policies = self.blend_policies.clone();
self.suspend().await?;
Ok(next)
}
pub(crate) fn refresh_instructions(&mut self) {
self.manager
.runtime_mut()
.set_system_instructions(crate::host::system_instructions(&self.runner_root));
}
pub(crate) fn write_report(&self) -> String {
self.manager
.runtime()
.runner()
.write_journal()
.lock()
.expect("write journal lock poisoned")
.report(&self.runner_root)
}
pub(crate) fn undo_last_write(&self) -> String {
let journal = self.manager.runtime().runner().write_journal();
let mut journal = journal.lock().expect("write journal lock poisoned");
match journal.undo_last(&self.runner_root) {
crate::checkpoint::UndoOutcome::NothingToDo => {
"No agent file changes to undo.".to_owned()
}
crate::checkpoint::UndoOutcome::Reverted { tool, paths } => {
format!("Reverted {tool}: {}", paths.join(", "))
}
crate::checkpoint::UndoOutcome::Conflict { path } => format!(
"{path} changed on disk since the agent last wrote it; nothing was \
overwritten. Put the file back to the agent's content, then /undo \
again."
),
crate::checkpoint::UndoOutcome::Failed(message) => {
format!("could not revert: {message}")
}
}
}
fn ensure_builtin_soe(&self) -> Result<(), Box<dyn std::error::Error>> {
if self.has_named_soe_policy {
return Err("soe is reserved for the single-model policy; rename the configured policy before changing model or thinking interactively".into());
}
Ok(())
}
fn soe_model_configs(
&self,
) -> Result<BTreeMap<String, ApiProviderConfig>, Box<dyn std::error::Error>> {
let mut configs = self.model_configs.clone();
let preferences =
crate::config::read_workspace_settings(&self.arabica_home, &self.runner_root)?;
for (alias, thinking) in preferences.model_thinking {
if let Some(config) = configs.get_mut(&alias) {
set_thinking(config, &thinking)?;
}
}
Ok(configs)
}
pub(crate) fn change_model(&mut self, model: &str) -> Result<(), Box<dyn std::error::Error>> {
self.ensure_builtin_soe()?;
if !self.model_configs.is_empty() {
let configs = self.soe_model_configs()?;
let next = configs
.get(model)
.cloned()
.ok_or_else(|| format!("unknown Blend model alias {model:?}"))?;
let policy = soe_policy(model.to_owned());
let provider = BlendProvider::from_configs(model, configs.clone())?;
save_workspace_settings(&self.arabica_home, &self.runner_root, |settings| {
settings.blend_policy = Some(SOE_POLICY_ID.to_owned());
settings.model = None;
settings.model_alias = Some(model.to_owned());
settings.thinking = None;
})?;
self.manager
.runtime_mut()
.set_blend_policy(Some(policy.clone()))?;
*self.manager.runtime_mut().model_mut() = HostModel::Blend(provider);
self.config = next;
self.model_configs = configs;
self.blend_policy = Some(policy);
return Ok(());
}
let mut next = self.config.clone();
next.model = model.to_owned();
let provider = ApiModelProvider::new(next.clone())?;
save_workspace_settings(&self.arabica_home, &self.runner_root, |settings| {
settings.blend_policy = Some(SOE_POLICY_ID.to_owned());
settings.model = Some(model.to_owned());
})?;
self.config = next;
*self.manager.runtime_mut().model_mut() = HostModel::Api(provider);
Ok(())
}
pub(crate) fn change_thinking(
&mut self,
value: &str,
) -> Result<(), Box<dyn std::error::Error>> {
self.ensure_builtin_soe()?;
if !self.model_configs.is_empty() {
let alias = self
.blend_policy
.as_ref()
.ok_or("Blend model aliases require a routing policy")?
.default_model
.clone();
let mut configs = self.soe_model_configs()?;
let mut next = self.config.clone();
set_thinking(&mut next, value)?;
configs.insert(alias.clone(), next.clone());
let policy = soe_policy(alias.clone());
let provider = BlendProvider::from_configs(alias.clone(), configs.clone())?;
save_workspace_settings(&self.arabica_home, &self.runner_root, |settings| {
settings.blend_policy = Some(SOE_POLICY_ID.to_owned());
settings.model = None;
settings.model_alias = Some(alias.clone());
settings.thinking = None;
settings
.model_thinking
.insert(alias.clone(), value.to_owned());
})?;
self.manager
.runtime_mut()
.set_blend_policy(Some(policy.clone()))?;
*self.manager.runtime_mut().model_mut() = HostModel::Blend(provider);
self.config = next;
self.model_configs = configs;
self.blend_policy = Some(policy);
return Ok(());
}
let mut next = self.config.clone();
set_thinking(&mut next, value)?;
let provider = ApiModelProvider::new(next.clone())?;
save_workspace_settings(&self.arabica_home, &self.runner_root, |settings| {
settings.blend_policy = Some(SOE_POLICY_ID.to_owned());
settings.model = Some(next.model.clone());
settings.thinking = Some(value.to_owned());
})?;
self.config = next;
*self.manager.runtime_mut().model_mut() = HostModel::Api(provider);
Ok(())
}
pub(crate) fn change_policy(&mut self, id: &str) -> Result<(), Box<dyn std::error::Error>> {
if id == SOE_POLICY_ID && !self.has_named_soe_policy && self.model_configs.is_empty() {
save_workspace_settings(&self.arabica_home, &self.runner_root, |settings| {
settings.blend_policy = Some(SOE_POLICY_ID.to_owned());
})?;
return Ok(());
}
let (policy, configs) = if id == SOE_POLICY_ID && !self.has_named_soe_policy {
let preferences =
crate::config::read_workspace_settings(&self.arabica_home, &self.runner_root)?;
let alias = preferences
.model_alias
.or_else(|| {
self.blend_policy
.as_ref()
.map(|policy| policy.default_model.clone())
})
.ok_or("SOE model is unavailable")?;
(soe_policy(alias), self.soe_model_configs()?)
} else {
let policy = self
.blend_policies
.get(id)
.cloned()
.ok_or_else(|| format!("unknown Blend policy {id:?}"))?;
let mut configs = self.model_configs.clone();
crate::config::reset_configured_model_thinking(&self.arabica_home, &mut configs)?;
(policy, configs)
};
let config = configs
.get(&policy.default_model)
.cloned()
.ok_or("policy default model is unavailable")?;
let provider = BlendProvider::from_configs(&policy.default_model, configs.clone())?;
save_workspace_settings(&self.arabica_home, &self.runner_root, |settings| {
settings.blend_policy = Some(id.to_owned());
})?;
self.manager
.runtime_mut()
.set_blend_policy(Some(policy.clone()))?;
*self.manager.runtime_mut().model_mut() = HostModel::Blend(provider);
self.blend_policy = Some(policy);
self.model_configs = configs;
self.config = config;
Ok(())
}
pub(crate) fn selection_report(&self) -> String {
format!(
"model: {}\npolicy: {}\nthinking: {}\navailable models: {}\navailable policies: {}\nsupported thinking: {}",
self.config.model,
self.blend_policy.as_ref().map_or(
"none",
|policy| crate::config::policy_selection_key(&self.blend_policies, policy)
),
crate::config::thinking_level(&self.config),
self.model_configs
.iter()
.map(|(alias, config)| format!("{alias} ({})", config.model))
.collect::<Vec<_>>()
.join(", "),
self.blend_policies
.keys()
.cloned()
.collect::<Vec<_>>()
.join(", "),
crate::config::thinking_levels(self.config.api_type).join(" | ")
)
}
async fn turn(
&mut self,
text: String,
lines: &mut tokio::sync::mpsc::UnboundedReceiver<std::io::Result<String>>,
) -> Result<(), Box<dyn std::error::Error>> {
let terminal = TerminalObserver::new();
self.refresh_instructions();
if crate::host::sync_remote_tools(self.manager.runtime_mut()) {
eprintln!("structure: the remote runner changed its tools");
}
set_progress(self.manager.runtime_mut().model_mut(), terminal.sink());
let mut observers: Vec<Arc<dyn SessionEventObserver>> = vec![
Arc::clone(&self.store) as Arc<dyn SessionEventObserver>,
Arc::clone(&terminal) as Arc<dyn SessionEventObserver>,
];
crate::evaluation::attach(&mut observers, &self.arabica_home);
let observer: Arc<dyn SessionEventObserver> = Arc::new(FanOutObserver::new(observers));
let cancellation = RunCancellation::new();
let ctrl_c = tokio::spawn({
let cancellation = cancellation.clone();
async move {
loop {
if tokio::signal::ctrl_c().await.is_err() {
break;
}
if cancellation.is_cancelled() {
std::process::exit(130);
}
eprintln!("arabica: cancelling the current run...");
cancellation.cancel();
}
}
});
let (permission_tx, mut permission_rx) =
tokio::sync::mpsc::unbounded_channel::<PermissionRequest>();
let control = DispatchControl {
run: RunControl {
cancellation: Some(cancellation.clone()),
permissions: Some(ToolPermissionGate {
policy: policy(),
approver: Some(permission_tx),
}),
},
observer: Some(observer),
};
let envelope = CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(self.session_id.clone()),
Command::MessageSend {
images: Vec::new(),
content: text,
},
);
let dispatch = self.manager.dispatch(envelope, control);
tokio::pin!(dispatch);
let events = loop {
tokio::select! {
result = &mut dispatch => break result?,
request = permission_rx.recv() => {
let Some(request) = request else { continue; };
terminal.break_line();
let summary = if crate::tui::summarizes_tool(&request.call.name) {
crate::tui::tool_summary(&request.call.name, &request.call.arguments)
} else {
request.call.arguments.to_string()
};
let target = if summary.is_empty() { String::new() } else { format!(" ({summary})") };
eprintln!("Allow {}{target}? [y]es / [a]lways / [n]o / ne[v]er", request.call.name);
prompt("permission> ");
let answer = tokio::select! {
line = lines.recv() => line,
() = cancellation.cancelled() => None,
};
let decision = match answer {
Some(Ok(line)) => match line.trim().to_ascii_lowercase().as_str() {
"y" | "yes" => PermissionDecision::allow_once(),
"a" | "always" => PermissionDecision::allow_for_session(),
"v" | "never" => PermissionDecision { outcome: ToolPermissionOutcome::Denied, scope: ToolPermissionScope::Session, source: ToolPermissionSource::User },
_ => PermissionDecision::deny_once(),
},
_ => PermissionDecision::deny_once(),
};
let _ = request.reply.send(decision);
}
}
};
ctrl_c.abort();
let mut output = None;
for event in &events {
match &event.event {
Event::RunCompleted { output: answer } => output = answer.as_deref(),
Event::RunFailed { message } => eprintln!("error: {message}"),
Event::RunCancelled => eprintln!("arabica: cancelled"),
_ => {}
}
}
terminal.finish(output);
Ok(())
}
}
pub async fn run(config: ApiProviderConfig, options: InteractiveOptions) -> i32 {
let model = match ApiModelProvider::new(config.clone()) {
Ok(model) => HostModel::Api(model),
Err(error) => {
eprintln!("error: {error}");
return 2;
}
};
run_with_model(config, model, None, options).await
}
pub async fn run_with_model(
config: ApiProviderConfig,
model: HostModel,
blend_policy: Option<BlendRoutingPolicy>,
options: InteractiveOptions,
) -> i32 {
run_with_model_configs(config, model, blend_policy, BTreeMap::new(), options).await
}
pub async fn run_with_model_configs(
config: ApiProviderConfig,
model: HostModel,
blend_policy: Option<BlendRoutingPolicy>,
model_configs: BTreeMap<String, ApiProviderConfig>,
options: InteractiveOptions,
) -> i32 {
if options.allow_shell && options.read_only {
eprintln!("error: --allow-shell and --read-only are mutually exclusive");
return 2;
}
let mut session = match InteractiveSession::open_with_model_configs(
config,
model,
blend_policy,
model_configs,
options,
)
.await
{
Ok(session) => session,
Err(error) => {
eprintln!("error: {error}");
return 2;
}
};
eprintln!(
"Arabica session {}. Type /help for commands.",
session.session_id
);
let mut lines = input_lines();
loop {
prompt("arabica> ");
let received = tokio::select! {
line = lines.recv() => line,
interrupt = tokio::signal::ctrl_c() => {
if interrupt.is_ok() { println!(); return 130; }
eprintln!("error: interrupt handler failed");
return 1;
}
};
let line = match received {
Some(Ok(line)) => line,
Some(Err(error)) => {
eprintln!("error: reading input: {error}");
return 1;
}
None => {
println!();
return 0;
}
};
let text = line.trim();
if text.is_empty() {
continue;
}
if matches!(text, "/exit" | "/quit") {
return 0;
}
if text == "/help" {
println!(
"/help /exit /session /sessions /resume <id> /diff /undo /model [alias] /policy [name] /thinking [level]"
);
continue;
}
if text == "/session" {
println!(
"session: {}\nmodel: {}\nprovider: {}\nread only: {}\nshell: {}",
session.session_id,
session.config.model,
session.config.api_type,
session.read_only,
session.allow_shell
);
continue;
}
if text == "/diff" {
print!("{}", session.write_report());
continue;
}
if text == "/undo" {
println!("{}", session.undo_last_write());
continue;
}
if text == "/sessions" {
match session.session_list() {
Ok(lines) if lines.is_empty() => println!("no sessions found"),
Ok(lines) => {
for line in &lines {
println!("{line}");
}
}
Err(error) => eprintln!("error: {error}"),
}
continue;
}
if text == "/resume" || text.starts_with("/resume ") {
let id = text["/resume".len()..].trim();
let id =
if id.is_empty() {
let entries = match session.session_list_entries() {
Ok(entries) => entries,
Err(error) => {
eprintln!("error: {error}");
continue;
}
};
if entries.is_empty() {
println!("no sessions found");
continue;
}
for (index, entry) in entries.iter().enumerate() {
println!("{:>3}. {}", index + 1, entry.line);
}
prompt("resume: number or id (Enter cancels)> ");
let answer = match lines.recv().await {
Some(Ok(line)) => line.trim().to_owned(),
_ => String::new(),
};
if answer.is_empty() {
continue;
}
match answer.parse::<usize>().ok().and_then(|number| {
number.checked_sub(1).and_then(|index| entries.get(index))
}) {
Some(entry) => entry.id.clone(),
None => {
let mut matches = entries
.iter()
.filter(|entry| entry.id.starts_with(&answer))
.collect::<Vec<_>>();
if matches.len() > 1 {
eprintln!("'{}' matches more than one session", answer);
continue;
}
match matches.pop() {
Some(entry) => entry.id.clone(),
None => {
eprintln!("no session matches '{}'", answer);
continue;
}
}
}
}
} else {
id.to_owned()
};
match session.switch_to(&id).await {
Ok(next) => {
session = next;
println!("session: {}", session.session_id);
}
Err(error) => eprintln!("error: {error}"),
}
continue;
}
if matches!(text, "/model" | "/policy" | "/thinking") {
println!("{}", session.selection_report());
continue;
}
if let Some(policy) = text.strip_prefix("/policy ") {
match session.change_policy(policy.trim()) {
Ok(()) => println!("{}", session.selection_report()),
Err(error) => eprintln!("error: {error}"),
}
continue;
}
if let Some(model) = text.strip_prefix("/model ") {
if model.trim().is_empty() {
eprintln!("usage: /model <name>");
} else if let Err(error) = session.change_model(model.trim()) {
eprintln!("error: {error}");
} else {
println!("model: {}", session.config.model);
}
continue;
}
if let Some(level) = text.strip_prefix("/thinking ") {
if let Err(error) = session.change_thinking(level.trim()) {
eprintln!("error: {error}");
} else {
println!("thinking: {level}");
}
continue;
}
if text.starts_with('/') {
eprintln!("unknown command: {text}");
continue;
}
if let Err(error) = session.turn(text.to_owned(), &mut lines).await {
eprintln!("error: {error}");
return 1;
}
}
}