use abstracttui::prelude::*;
use abstracttui::widgets::{Block, Button, Table};
use crate::schema;
use crate::store::{Loadable, RouteRow, RoutesData};
use crate::worker::{next_form_id, Cmd};
use crate::writes;
use super::forms::{confirm_danger, install_write_done, message_slot, open_form_guarded};
use super::util::{field, line, loadable_view, or_dash, span, span_bold};
use super::widths;
use super::Ctx;
pub fn view(cx: Scope, ctx: &Ctx, theme: Signal<&'static abstracttui::theme::Theme>) -> View {
let store = ctx.store;
let ui = ctx.ui;
let ctx_edit = ctx.clone();
let ctx_clear = ctx.clone();
let banner = dyn_view(LayoutStyle::line(1).shrink(0.0), move || {
let t = theme.get().tokens;
match store.routes.get() {
Loadable::Ready(d) => {
let mut spans = if d.writable {
vec![span(" writable", t.ok)]
} else {
vec![span_bold(" read-only (config file refused?)", t.warn)]
};
spans.push(span(
format!(
" · {} of {} configured",
d.configured_count(),
d.rows.len()
),
t.text,
));
spans.push(span(
" · a applies the recommended routes".to_string(),
t.text_faint,
));
if !d.errors.is_empty() {
spans.push(span_bold(
format!(" · errors: {}", d.errors.join(" | ")),
t.error,
));
}
line(spans)
}
_ => line(vec![span(String::new(), t.text)]),
}
});
let viewport = abstracttui::app::use_viewport(cx);
let weights_banner = dyn_view(LayoutStyle::line(1).shrink(0.0), move || {
let t = theme.get().tokens;
let avail = viewport.get().w;
match store.availability.get() {
Loadable::Ready(a) if !a.missing.is_empty() => {
let head = format!(
" {} route{} with no model yet",
a.missing.len(),
if a.missing.len() == 1 { "" } else { "s" }
);
let routes = a
.missing
.iter()
.map(|(route, _, _)| route.as_str())
.filter(|route| !route.is_empty())
.collect::<Vec<_>>()
.join(", ");
let routes = if routes.is_empty() {
String::new()
} else {
format!(" · {routes}")
};
let mut spans = vec![
span_bold(head.clone(), t.warn),
span(routes.clone(), t.text),
];
const LABEL: &str = " · recommended: ";
const VERB: &str = " · w downloads the selected route's weights";
let list = a
.missing
.iter()
.map(|(_, p, art)| format!("{p} {art}"))
.collect::<Vec<_>>()
.join(", ");
let budget = widths::elastic_budget(&[&head, &routes, LABEL, VERB], avail);
if budget >= 8 {
spans.push(span(
format!("{LABEL}{}", widths::middle_fit(&list, budget)),
t.warn,
));
}
spans.push(span(VERB.to_string(), t.text_faint));
line(spans)
}
Loadable::Failed(e) => line(vec![span(
format!(" model availability unavailable: {e}"),
t.text_muted,
)]),
_ => line(vec![span(String::new(), t.text)]),
}
});
let ctx_table = ctx.clone();
let table = dyn_view_scoped(LayoutStyle::default().grow(1.0), move |gcx| {
let t = theme.get().tokens;
let data = store.routes.get();
loadable_view(
&t,
&data,
|d: &RoutesData| d.rows.is_empty(),
"the CLI reported no routes",
|d| routes_table(gcx, cx, &ctx_table, &t, d, ui.route_sel),
)
});
let detail = dyn_view(LayoutStyle::line(1).shrink(0.0), move || {
let t = theme.get().tokens;
let row: Option<RouteRow> = store.routes.with(|d| {
d.ready()
.and_then(|d| d.rows.get(ui.route_sel.get()).cloned())
});
match row {
Some(r) => {
let mut spans = vec![span_bold(format!(" {} ", r.key), t.accent)];
if r.is_task_parent() {
spans.push(span(
format!("serves any {} task with no row of its own ", r.modality),
t.text_muted,
));
if r.covered_by_tasks {
spans.push(span(
format!(
"· all {} task rows below are set, so nothing reads it ",
r.task_keys.len()
),
t.text_faint,
));
}
} else if let Some(parent) = &r.broad_key {
spans.push(span(
if r.inherits_broad {
format!("no value of its own — {parent} answers it ")
} else {
format!("overrides {parent} ")
},
t.text_muted,
));
}
if let Some(u) = r.route_unavailable.as_ref().filter(|_| r.configured) {
spans.push(span(
format!(
"configured but cannot run on this computer: {} — Enter edits it, \
x clears it ",
u.reason
),
t.error,
));
} else if let Some(m) = r
.engine_missing
.as_ref()
.filter(|m| r.configured && m.is_unknown_engine())
{
spans.push(span(format!("{} — Enter edits it ", m.reason), t.error));
} else if let Some(m) = r.engine_missing.as_ref().filter(|_| r.configured) {
let via = match &m.engine_row {
Some(row) => format!(" (Engines: {row}, i installs it)"),
None => String::new(),
};
spans.push(span(
format!("engine not installed: {}{via} ", m.reason),
t.warn,
));
} else if let Some(u) = r
.recommendation_unavailable
.as_ref()
.filter(|_| !r.configured)
{
let what = u.pair_text();
spans.push(span(
if what.is_empty() {
format!("nothing recommended runs on this computer: {} ", u.reason)
} else {
format!(
"the recommended {what} cannot run on this computer: {} ",
u.reason
)
},
t.warn,
));
}
if let Some(u) = &r.base_url {
spans.push(span(format!("base_url {u} "), t.text_muted));
}
if let Some(o) = &r.options {
spans.push(span(format!("options {} ", mask_options(o)), t.text_muted));
}
if !r.configured {
if let Some(h) = &r.package_hint {
spans.push(span(format!("needs: {h}"), t.text_faint));
}
}
if let Some(wr) = store
.availability
.with(|d| d.ready().and_then(|a| a.by_route.get(&r.key).cloned()))
{
let tone = match wr.status.as_str() {
"installed" => t.ok,
"absent" => t.warn,
_ => t.text_muted,
};
spans.push(span(format!(" weights {} ", wr.label()), tone));
if let Some(engine) = &wr.route_provider {
spans.push(span(
format!(
"· run by {engine}, fetched from {} {} ",
wr.provider, wr.artifact
),
t.text_faint,
));
}
if wr.status == "absent" && !wr.artifact.is_empty() {
spans.push(span(
format!("· w downloads {} ", wr.artifact),
t.text_faint,
));
} else if !wr.detail.is_empty() {
spans.push(span(format!("· {} ", wr.detail), t.text_faint));
}
}
line(spans)
}
None => line(vec![span(String::new(), t.text)]),
}
});
Element::new()
.style(LayoutStyle::column().grow(1.0))
.shortcut(KeyChord::plain(Key::Char('e')), move |_| {
edit_selected(cx, &ctx_edit);
})
.shortcut(KeyChord::plain(Key::Char('x')), move |_| {
clear_selected(cx, &ctx_clear);
})
.shortcut(KeyChord::plain(Key::Char('t')), {
let ctx_test = ctx.clone();
move |_| test_selected(&ctx_test)
})
.shortcut(KeyChord::plain(Key::Char('w')), {
let ctx_dl = ctx.clone();
move |_| download_selected(cx, &ctx_dl)
})
.shortcut(KeyChord::plain(Key::Char('a')), {
let ctx_apply = ctx.clone();
move |_| apply_recommended(cx, &ctx_apply)
})
.child(banner)
.child(weights_banner)
.child(table)
.child(detail)
.build()
}
fn download_selected(cx: Scope, ctx: &Ctx) {
let Some(row) = selected_route(ctx) else {
ctx.store
.notice
.set(Some("no route selected — nothing to download".into()));
return;
};
let weights = ctx
.store
.availability
.with_untracked(|d| d.ready().and_then(|a| a.by_route.get(&row.key).cloned()));
let Some(weights) = weights else {
ctx.store.notice.set(Some(format!(
"{}: no weight information yet (r reloads) — nothing to download",
row.key
)));
return;
};
match weights.status.as_str() {
"installed" => {
ctx.store.notice.set(Some(format!(
"{} is already installed{}",
weights.artifact,
if weights.detail.is_empty() {
String::new()
} else {
format!(" ({})", weights.detail)
}
)));
return;
}
"not_applicable" => {
ctx.store.notice.set(Some(format!(
"{} serves models remotely — there is nothing to download",
weights.provider
)));
return;
}
"unknown" => {
let hint = if weights.instruction.is_empty() {
"the provider's tool could not be consulted".to_string()
} else {
weights.instruction.clone()
};
ctx.store.notice.set(Some(format!(
"{}: availability is unknown — {hint}",
row.key
)));
return;
}
_ => {}
}
if !weights.downloadable {
ctx.store
.notice
.set(Some(if weights.instruction.is_empty() {
format!("{} has no download tool on this machine", weights.provider)
} else {
weights.instruction.clone()
}));
return;
}
let ctx2 = ctx.clone();
let provider = weights.provider.clone();
let artifact = weights.artifact.clone();
super::forms::confirm_danger(
cx,
ctx.ui,
format!(
"Download {artifact} with {provider}? This runs the provider's own tool and \
may fetch several gigabytes."
),
"Download",
"Not now",
move || {
ctx2.send(Cmd::DownloadModel {
provider: provider.clone(),
artifact: artifact.clone(),
});
ctx2.send(Cmd::LoadAvailability);
},
);
}
fn test_selected(ctx: &Ctx) {
let Some(row) = selected_route(ctx) else {
ctx.store
.notice
.set(Some("no route selected — nothing to test".into()));
return;
};
let (Some(provider), Some(model)) = (row.provider.clone(), row.model.clone()) else {
ctx.store.notice.set(Some(format!(
"{} resolves to no provider/model — nothing to test (e edits a route)",
row.key
)));
return;
};
let base_url = row.base_url.clone().or_else(|| {
provider.strip_prefix("endpoint:").and_then(|id| {
ctx.store.profiles.with_untracked(|d| {
d.ready()
.and_then(|d| d.profiles.iter().find(|p| p.id == id))
.map(|p| p.base_url.clone())
})
})
});
let spec = crate::probes::route_check(&row.key, &provider, &model, base_url.as_deref());
ctx.send_probe(spec);
}
fn selected_route(ctx: &Ctx) -> Option<RouteRow> {
let idx = ctx.ui.route_sel.get_untracked();
ctx.store
.routes
.with_untracked(|d| d.ready().and_then(|d| d.rows.get(idx).cloned()))
}
fn not_editable_reason(row: &RouteRow) -> String {
if let Some(d) = &row.derived_from {
format!("{} derives from {} — edit that route instead", row.key, d)
} else if row.covered_by.is_some() {
format!("{} is covered and not overrideable", row.key)
} else {
format!("{} is read-only", row.key)
}
}
fn edit_selected(cx: Scope, ctx: &Ctx) {
let Some(row) = selected_route(ctx) else {
ctx.store
.notice
.set(Some("no route selected — nothing to edit".into()));
return;
};
if !row.editable() {
ctx.store.notice.set(Some(not_editable_reason(&row)));
return;
}
if !ctx.writable_now() {
return;
}
open_route_editor(cx, ctx, row);
}
fn clear_selected(cx: Scope, ctx: &Ctx) {
let Some(row) = selected_route(ctx) else {
ctx.store
.notice
.set(Some("no route selected — nothing to clear".into()));
return;
};
if !row.editable() {
ctx.store.notice.set(Some(not_editable_reason(&row)));
return;
}
if !row.configured || row.covered_by.is_some() {
ctx.store.notice.set(Some(format!(
"{} has no explicit override to clear",
row.key
)));
return;
}
if !ctx.writable_now() {
return;
}
confirm_clear(cx, ctx, row);
}
fn apply_recommended(cx: Scope, ctx: &Ctx) {
if !ctx.writable_now() {
return;
}
let ctx_keep = ctx.clone();
let ctx_force = ctx.clone();
let prompt = abstracttui::app::ChoicePrompt::new(
"Apply the framework's recommended routes for this computer? The report names each one."
.to_string(),
)
.option("keep", "Apply — keep routes I configured")
.option_with(
abstracttui::app::ChoiceOption::new("force", "Apply — replace mine too").danger(true),
)
.option("cancel", "Cancel")
.initial("keep");
super::forms::open_prompt(cx, ctx.ui, prompt, move |outcome| {
if let abstracttui::app::ChoiceOutcome::Answered(a) = outcome {
let choice = a.selected.first().cloned().unwrap_or_default();
let (ctx2, force) = match choice.as_str() {
"keep" => (ctx_keep, false),
"force" => (ctx_force, true),
_ => return,
};
let spec = writes::apply_recommended(force, ctx2.write_base(), None);
ctx2.send(Cmd::Write(Box::new(spec)));
}
});
}
fn confirm_clear(cx: Scope, ctx: &Ctx, row: RouteRow) {
let ctx2 = ctx.clone();
let key = row.key.clone();
confirm_danger(
cx,
ctx.ui,
format!(
"Clear the override on {} ({})? The engine default takes over.",
row.key,
row.pair_text()
),
"Clear the route",
"Keep the override",
move || {
let spec = writes::clear_route(&key, ctx2.write_base(), None);
ctx2.send(Cmd::Write(Box::new(spec)));
},
);
}
fn applies_now(t: &TokenSet, row: &RouteRow) -> View {
let mut spans = vec![span_bold("Applies now: ".to_string(), t.text)];
if row.configured {
spans.push(span(row.pair_text(), t.ok));
if let Some(r) = &row.reasoning {
spans.push(span(format!(" · reasoning {r}"), t.ok));
}
if let Some(by) = &row.covered_by {
spans.push(span(format!(" (covered by {by})"), t.info));
} else {
spans.push(span(format!(" (source: {})", row.source), t.text_muted));
}
} else {
spans.push(span(
"nothing configured — engine decides".to_string(),
t.text_muted,
));
if let Some(hint) = &row.package_hint {
spans.push(span(format!(" (needs {hint})"), t.text_faint));
}
}
line(spans)
}
fn open_route_editor(cx: Scope, ctx: &Ctx, row: RouteRow) {
let theme = use_theme(cx);
let ctx2 = ctx.clone();
let screen_cx = cx;
let mut providers: Vec<String> = schema::STATIC_PROVIDERS
.iter()
.map(|s| s.to_string())
.collect();
if let Loadable::Ready(p) = ctx.store.profiles.get_untracked() {
for prof in &p.profiles {
if prof.enabled {
providers.push(prof.virtual_provider());
}
}
}
let base = ctx.write_base();
let providers = std::rc::Rc::new(providers);
if let Some(p) = row.provider.as_deref() {
if providers.iter().any(|q| q == p) {
super::model_field::kick_discovery(ctx, p);
}
}
open_form_guarded(ctx, cx, Size::new(84, 24), move |mcx, close, guard| {
let t = theme.get().tokens;
let mut popts = vec![SelectOption::new("— engine decides —")];
let mut pinitial = 0usize;
for (i, p) in providers.iter().enumerate() {
popts.push(SelectOption::new(p.clone()));
if Some(p.as_str()) == row.provider.as_deref() {
pinitial = i + 1;
}
}
let provider_sel = mcx.signal(pinitial);
let model = mcx.signal(row.model.clone().unwrap_or_default());
let base_url = mcx.signal(row.base_url.clone().unwrap_or_default());
let is_text = row.is_text_generation();
let reasoning_init_ix = crate::store::reasoning_index(row.reasoning.as_deref());
let reasoning_sel = mcx.signal(reasoning_init_ix);
let mtp_init_ix = mtp_policy_index(row.options.as_ref());
let mtp_sel = mcx.signal(mtp_init_ix);
let options = mcx.signal(
row.options
.as_ref()
.and_then(|o| o.as_object())
.map(render_options)
.unwrap_or_default(),
);
let form_error: Signal<Option<String>> = mcx.signal(None);
let in_flight = mcx.signal(false);
let esc_armed = mcx.signal(false);
let p0 = pinitial;
let model_init = model.get_untracked();
let url_init = base_url.get_untracked();
let options_init = options.get_untracked();
{
let model_init = model_init.clone();
let url_init = url_init.clone();
let options_init = options_init.clone();
super::forms::install_dirty_guard_with(
mcx,
&guard,
move || {
provider_sel.get_untracked() != p0
|| model.with_untracked(|v| v != &model_init)
|| base_url.with_untracked(|v| v != &url_init)
|| reasoning_sel.get_untracked() != reasoning_init_ix
|| mtp_sel.get_untracked() != mtp_init_ix
|| options.with_untracked(|v| v != &options_init)
},
move || {
let _ = provider_sel.get();
let _ = model.get();
let _ = base_url.get();
let _ = reasoning_sel.get();
let _ = mtp_sel.get();
let _ = options.get();
},
esc_armed,
form_error,
);
}
let form_id = next_form_id();
install_write_done(mcx, &ctx2, form_id, in_flight, form_error, close.clone());
let providers2 = providers.clone();
let ctx_models = ctx2.clone();
let on_provider = move |i: usize| {
if i > 0 {
super::model_field::kick_discovery(&ctx_models, &providers2[i - 1]);
}
};
let key = row.key.clone();
let providers3 = providers.clone();
let ctx3 = ctx2.clone();
let submit = move || {
if in_flight.get_untracked() {
return;
}
form_error.set(None);
let i = provider_sel.get_untracked();
let m = model.get_untracked().trim().to_string();
let u = base_url.get_untracked().trim().to_string();
let r_ix = reasoning_sel.get_untracked();
let mut opts = match parse_options(&options.get_untracked()) {
Ok(o) => o,
Err(e) => {
form_error.set(Some(e));
return;
}
};
let mtp_changed = is_text && mtp_sel.get_untracked() != mtp_init_ix;
if mtp_changed {
set_mtp_policy_option(&mut opts, mtp_sel.get_untracked());
}
let edit = writes::RouteEdit {
provider: (i != p0).then(|| {
if i > 0 {
providers3[i - 1].clone()
} else {
String::new()
}
}),
model: (m != model_init.trim()).then(|| m.clone()),
base_url: (u != url_init.trim()).then(|| u.clone()),
reasoning: (is_text && r_ix != reasoning_init_ix).then(|| {
crate::store::REASONING_LEVELS
.get(r_ix.wrapping_sub(1))
.map(|s| (*s).to_string())
.unwrap_or_default()
}),
options: (options.get_untracked() != options_init || mtp_changed).then_some(opts),
};
if edit.is_empty() {
form_error.set(Some(
"nothing changed — edit a field, or Clear override drops the route".into(),
));
return;
}
let spec = writes::set_route(&key, &edit, base, Some(form_id));
in_flight.set(true);
ctx3.send(Cmd::Write(Box::new(spec)));
};
let submit_btn = submit.clone();
let mf = super::model_field::model_field(
mcx,
theme,
super::model_field::ModelFieldSpec {
store: ctx2.store,
providers: providers.clone(),
provider_sel,
model_text: model,
class: crate::models::class_for_route(&row.kind, &row.modality),
submit: None,
},
);
let mf_handle = mf.handle.clone();
let mf_custom = mf.custom;
let hint = row
.option_examples
.as_ref()
.map(|e| format!("option examples: {e}"))
.unwrap_or_default();
let reasoning_opts: Vec<SelectOption> = std::iter::once(SelectOption::new("not set"))
.chain(
crate::store::REASONING_LEVELS
.iter()
.map(|l| SelectOption::new(*l)),
)
.collect();
let row_for_clear = row.clone();
let ctx_clear = ctx2.clone();
let close_after_clear = close.clone();
let clear_enabled = row.configured && row.covered_by.is_none();
Block::new()
.title(format!("Route — {} ({})", row.label, row.key))
.layout(LayoutStyle::column().grow(1.0))
.child(
Element::new()
.style(LayoutStyle::column().gap(0))
.shortcut(KeyChord::plain(Key::Char('m')), {
let ctx_m = ctx2.clone();
move |_| {
if !mf_handle.open() {
ctx_m.store.notice.set(Some(
"no picker to open — pick a provider first (or Ctrl+P \
leaves custom typing)"
.into(),
));
}
}
})
.shortcut(KeyChord::plain(Key::Char('c')), move |_| {
mf_custom.set(Some(true));
})
.shortcut(KeyChord::new(Mods::CTRL, Key::Char('p')), move |_| {
mf_custom.set(Some(false));
})
.child(applies_now(&t, &row))
.child(field(
&t,
"provider",
Select::new(popts)
.value(provider_sel)
.on_change(on_provider)
.view(mcx),
))
.child(mf.view)
.child(field(
&t,
"base URL",
TextInput::new()
.layout(LayoutStyle::default().grow(1.0).h(1))
.value(base_url)
.placeholder("optional — http(s)://…")
.view(mcx),
))
.child(if is_text {
field(
&t,
"reasoning",
Select::new(reasoning_opts).value(reasoning_sel).view(mcx),
)
} else {
Element::new().style(LayoutStyle::default().h(0)).build()
})
.child(field(
&t,
"options",
TextInput::new()
.layout(LayoutStyle::default().grow(1.0).h(1))
.value(options)
.placeholder("k=v pairs, space-separated (voice=M2, k=\"a b\")")
.view(mcx),
))
.child(if is_text {
field(&t, "MTP policy", Select::new(
["inherit / not set", "Off", "Depth 2", "Depth 3", "Depth 4", "Depth 5", "custom (keep options)"]
.iter().map(|s| SelectOption::new(*s)).collect::<Vec<_>>()
).value(mtp_sel).view(mcx))
} else { Element::new().style(LayoutStyle::default().h(0)).build() })
.child(if is_text {
line(vec![span(" MTP: compatible models only; missing heads require provisioning/reload.", t.text_faint)])
} else { Element::new().style(LayoutStyle::default().h(0)).build() })
.child(line(vec![span(format!(" {hint}"), t.text_faint)]))
.child(message_slot(theme, form_error, in_flight))
.child(
Element::new()
.style(LayoutStyle::row().gap(2).shrink(0.0))
.child(Button::new("Save").on_click(submit_btn).view(mcx))
.child(
Button::new("Clear override")
.disabled(!clear_enabled)
.on_click(move || {
close_after_clear();
confirm_clear(screen_cx, &ctx_clear, row_for_clear.clone());
})
.view(mcx),
)
.child(
Button::new("Cancel (Esc)")
.on_click({
let close = close.clone();
move || close()
})
.view(mcx),
)
.build(),
)
.build(),
)
.element(&t)
.build()
});
}
fn mtp_policy_index(options: Option<&serde_json::Value>) -> usize {
use serde_json::Value;
match options.and_then(|o| o.get("speculation")) {
None | Some(Value::Null) => 0,
Some(Value::Bool(false)) => 1,
Some(v) if v.get("mode").and_then(Value::as_str) == Some("off") => 1,
Some(v) => match v.get("num_draft_tokens").and_then(Value::as_u64) {
Some(n @ 2..=5) => n as usize,
_ => 6,
},
}
}
fn set_mtp_policy_option(options: &mut Vec<(String, String)>, index: usize) {
if index > 5 {
return;
}
options.retain(|(key, _)| key != "speculation");
if index == 1 {
options.push(("speculation".into(), "false".into()));
} else if index >= 2 {
options.push((
"speculation".into(),
serde_json::json!({
"mode": "native_mtp", "num_draft_tokens": index, "require_acceleration": false,
})
.to_string(),
));
}
}
fn render_options(o: &serde_json::Map<String, serde_json::Value>) -> String {
o.iter()
.map(|(k, v)| {
let vs = match v {
serde_json::Value::String(s) => {
let ambiguous = serde_json::from_str::<serde_json::Value>(s)
.map(|p| !p.is_string())
.unwrap_or(false);
if s.contains(char::is_whitespace) || ambiguous {
format!("\"{s}\"")
} else {
s.clone()
}
}
other => other.to_string(),
};
format!("{k}={vs}")
})
.collect::<Vec<_>>()
.join(" ")
}
pub fn parse_options(raw: &str) -> Result<Vec<(String, String)>, String> {
let mut out = Vec::new();
let mut tokens: Vec<String> = Vec::new();
let mut cur = String::new();
let mut in_quotes = false;
for ch in raw.chars() {
match ch {
'"' => {
in_quotes = !in_quotes;
cur.push(ch);
}
c if c.is_whitespace() && !in_quotes => {
if !cur.is_empty() {
tokens.push(std::mem::take(&mut cur));
}
}
c => cur.push(c),
}
}
if in_quotes {
return Err("unterminated quote in options".into());
}
if !cur.is_empty() {
tokens.push(cur);
}
for tok in tokens {
match tok.split_once('=') {
Some((k, v)) if !k.is_empty() => out.push((k.to_string(), v.to_string())),
_ => {
return Err(format!(
"options are space-separated k=v pairs (quote spaced values: k=\"a b\") — \
\"{tok}\" is not"
))
}
}
}
Ok(out)
}
fn mask_options(options: &serde_json::Value) -> String {
let Some(obj) = options.as_object() else {
return options.to_string();
};
let parts: Vec<String> = obj
.iter()
.map(|(k, v)| {
let kl = k.to_ascii_lowercase();
if kl.contains("key") || kl.contains("token") || kl.contains("secret") {
format!("{k}=«redacted»")
} else {
format!("{k}={v}")
}
})
.collect();
format!("{{{}}}", parts.join(", "))
}
fn routes_table(
gcx: Scope,
page_cx: Scope,
ctx: &Ctx,
t: &TokenSet,
data: &RoutesData,
sel: Signal<usize>,
) -> View {
let w = abstracttui::app::use_viewport(gcx).get().w;
let weights = ctx
.store
.availability
.with(|d| d.ready().map(|a| a.by_route.clone()).unwrap_or_default());
let mut rows: Vec<Vec<String>> = data
.rows
.iter()
.map(|r| {
let state = r.state_label();
let lock = if !r.editable() { " ⊘" } else { "" };
let mut row = vec![format!("{}{}", r.display_key(), lock), state];
if w >= 96 {
row.push(or_dash(&r.provider));
}
row.push(or_dash(&r.model));
row.push(
weights
.get(&r.key)
.map(|w| w.label().to_string())
.unwrap_or_default(),
);
if w >= 112 {
row.push(r.source.clone());
}
row
})
.collect();
let mut rules = vec![
widths::ColRule::tail("route", 18),
widths::ColRule::head("state", 21),
];
if w >= 96 {
rules.push(widths::ColRule::tail("provider", 10));
}
rules.push(widths::ColRule::tail("model", 22));
rules.push(widths::ColRule::head("weights", 14));
if w >= 112 {
rules.push(widths::ColRule::tail("source", 12));
}
let cols = widths::columns(&rules, &mut rows, w);
let ctx_act = ctx.clone();
Table::new(cols)
.rows(rows)
.selection(sel)
.on_activate(move |_| edit_selected(page_cx, &ctx_act))
.layout(LayoutStyle::default().grow(1.0))
.element(gcx, t)
.autofocus()
.build()
}
#[cfg(test)]
mod tests {
use super::{mtp_policy_index, parse_options, render_options, set_mtp_policy_option};
use serde_json::json;
#[test]
fn mtp_policy_preserves_options_off_and_inherit() {
let mut pairs = vec![("other".into(), "4".into())];
set_mtp_policy_option(&mut pairs, 2);
assert_eq!(pairs[0], ("other".into(), "4".into()));
let value: serde_json::Value = serde_json::from_str(&pairs[1].1).unwrap();
assert_eq!(value["num_draft_tokens"], 2);
assert_eq!(value["require_acceleration"], false);
assert_eq!(mtp_policy_index(Some(&json!({"speculation":value}))), 2);
set_mtp_policy_option(&mut pairs, 1);
assert_eq!(pairs[1], ("speculation".into(), "false".into()));
assert_eq!(mtp_policy_index(Some(&json!({"speculation":false}))), 1);
set_mtp_policy_option(&mut pairs, 0);
assert_eq!(pairs, vec![("other".into(), "4".into())]);
}
#[test]
fn custom_policy_survives_round_trip() {
let value = json!({"speculation":{"num_draft_tokens":7}, "other":true});
assert_eq!(mtp_policy_index(Some(&value)), 6);
let mut pairs = parse_options(&render_options(value.as_object().unwrap())).unwrap();
let before = pairs.clone();
set_mtp_policy_option(&mut pairs, 6);
assert_eq!(pairs, before);
}
#[test]
fn options_round_trip_spaces_and_types() {
let stored = json!({
"voice": "M2",
"prompt": "hello world",
"flag": true,
"stringy": "true",
"n": 42
});
let rendered = render_options(stored.as_object().unwrap());
assert!(rendered.contains("voice=M2"), "{rendered}");
assert!(rendered.contains("prompt=\"hello world\""), "{rendered}");
assert!(rendered.contains("flag=true"), "{rendered}");
assert!(
rendered.contains("stringy=\"true\""),
"string-typed 'true' quotes so a re-save keeps it a string: {rendered}"
);
let parsed = parse_options(&rendered).unwrap();
assert!(parsed
.iter()
.any(|(k, v)| k == "prompt" && v == "\"hello world\""));
assert!(parsed
.iter()
.any(|(k, v)| k == "stringy" && v == "\"true\""));
assert!(parse_options("k=\"unterminated").is_err());
let err = parse_options("novalue").unwrap_err();
assert!(err.contains("k=v"), "{err}");
assert!(parse_options("").unwrap().is_empty());
}
}