Struct Wizard 

pub struct Wizard {

    pub step: Step,
    pub cursor: usize,
    pub providers: Vec<ProviderRow>,
    pub detail: usize,
    pub defaults: Vec<Field>,
    pub limits: Vec<Field>,
    pub agents: Vec<AgentRow>,
    pub mcp: Vec<McpRow>,
    pub mcp_scan_errors: Vec<String>,
    pub edit: Option<Edit>,
    pub reveal: bool,
    pub show_help: bool,
    pub confirm: Option<PendingConfirm>,
    pub dirty: bool,
    pub claude_code_tos_accepted: bool,
    pub should_quit: bool,
    pub finished: bool,
    pub message: Option<String>,
    pub base: Config,
    pub env_only: HashMap<&'static str, String>,
    pub opener: BrowserOpener,
    pub verify_tx: UnboundedSender<VerifyRequest>,
    pub reply_rx: UnboundedReceiver<VerifyReply>,
    pub ticks: u64,
    /* private fields */
}

The whole wizard.

Fields

step: Step

cursor: usize

Selected row within the current step.

providers: Vec<ProviderRow>

detail: usize

Which selected provider the credential screen is showing.

defaults: Vec<Field>

limits: Vec<Field>

agents: Vec<AgentRow>

mcp: Vec<McpRow>

mcp_scan_errors: Vec<String>

edit: Option<Edit>

reveal: bool

Show credentials in clear text.

show_help: bool

confirm: Option<PendingConfirm>

A confirmation dialog is on screen, and (after Ctrl-C) it is the only thing keys mean until it is answered.

dirty: bool

The user has changed something since the wizard opened, so quitting silently would discard real choices.

claude_code_tos_accepted: bool

The user has acknowledged the Claude Code transport’s terms risk. A hard gate on saving: the transport cannot be written to the config without it, and deselecting the transport withdraws it.

should_quit: bool

finished: bool

Set once the plan has been applied, so the loop knows to stop.

message: Option<String>

A one-line status message.

base: Config

The config as loaded from the file, which is what the plan is diffed against and built on.

env_only: HashMap<&'static str, String>

Credentials present only in the environment. Shown, never written.

opener: BrowserOpener

Opens a provider’s signup page. Injected rather than called directly: lev dash once had a unit test launch a real browser, and this is the same shape of hazard.

verify_tx: UnboundedSender<VerifyRequest>

reply_rx: UnboundedReceiver<VerifyReply>

ticks: u64

Tick counter, for the spinner.

Implementations

impl Wizard

pub fn handle_key(&mut self, key: KeyEvent) -> Action

Handle one key press.

impl Wizard

pub fn new( base: Config, env_lookup: &dyn Fn(&str) -> Option<String>, candidates: Vec<(String, Candidate)>, scan_errors: Vec<String>, agents_dir: &Path, opener: BrowserOpener, ) -> Self

Build the wizard from the config file and the surrounding environment.

base must come from reading the file, not from Config::load(): load folds $ANTHROPIC_API_KEY and friends into the struct, and the old wizard then re-serialized the whole thing - silently writing a key the user had deliberately kept in their environment into ~/.leviath/config.toml. Environment-supplied credentials are tracked separately in env_only and shown as such.

pub fn take_verify_ends( &mut self, ) -> Option<(UnboundedReceiver<VerifyRequest>, UnboundedSender<VerifyReply>)>

Hand the background verifier loop its channel ends. Returns None if already taken.

pub fn selected_providers(&self) -> Vec<usize>

Providers the user picked, in table order.

pub fn detail_row(&self) -> Option<usize>

The provider row the credential screen is currently showing.

pub fn claude_code_selected(&self) -> bool

Whether the Claude Code transport is one of the picked providers.

pub fn needs_tos_confirmation(&self) -> bool

Whether saving must first ask the user to acknowledge Anthropic’s terms. Enabling the transport routes inference through a subscription session, so the risk is confirmed once, explicitly, rather than being buried in a paragraph nobody reads.

pub fn fields(&self) -> &[Field]

The fields the current step edits, if it edits fields.

pub fn row_count(&self) -> usize

How many selectable rows the current step has.

pub fn nav_rows(&self) -> usize

How many cursor positions the current step has: its rows plus the Continue/action button that every step ends with.

pub fn on_continue(&self) -> bool

Whether the cursor sits on the step’s Continue/action button (the virtual row after the last real one).

pub fn continue_label(&self) -> String

The label of the current step’s Continue/action button. It carries state (selection counts, what screen is next) so advancing is never a surprise.

pub fn move_cursor(&mut self, delta: isize)

Move the selection, clamped to the step’s rows plus its button.

pub fn next_step(&mut self)

Advance to the next step, skipping ones with nothing to show. Skipping the credential screen is announced rather than silent: it looks exactly like a bug when a screen the breadcrumb promises never appears.

pub fn prev_step(&mut self)

Go back a step, skipping empty ones. No-op on the first.

pub fn enter(&mut self, step: Step)

Switch to step, resetting per-step state.

pub fn next_detail(&mut self) -> bool

Within the credential screen, move to the next selected provider; returns false when there is no next one.

pub fn prev_detail(&mut self) -> bool

The reverse of Self::next_detail.

pub fn request_verification(&mut self, index: usize)

Ask the background verifier about the provider at index.

A provider with nothing to check is left alone rather than queued: a blank API key would fail with a message about the key rather than saying the obvious, that none was given.

pub fn verify_all(&mut self)

Ask about every selected provider at once.

pub fn drain_verifications(&mut self)

Take whatever the background verifier has answered.

pub fn discovered_models(&self) -> Vec<String>

Every model id any provider reported, deduplicated, for the picker.

pub fn rebuild_defaults(&mut self)

Rebuild the Defaults screen. Called on entry, since both the provider list and the discovered models can change between visits.

pub fn apply_provider_concurrency_default(&mut self)

Set the concurrency default that suits the chosen provider.

A local Ollama serves one model at a time, so eight concurrent inferences against it queue and thrash rather than going faster. Only applied while the field still holds the general default, so a number the user typed is never overwritten.

pub fn open_quit_confirm(&mut self)

q/Ctrl-C with unsaved choices: ask before discarding them.

pub fn open_tos_confirm(&mut self)

Saving with the Claude Code transport selected: the terms risk is confirmed once, explicitly, on a dialog with real buttons.

pub fn open_no_providers_confirm(&mut self)

Leaving the Providers screen with nothing selected: Leviath cannot run an agent without a provider, so this is almost always a slip.

pub fn commit_edit(&mut self)

Commit an edited text buffer into wherever it belongs.

pub fn build_config(&self) -> Config

Fold every choice into the config that will be written.

pub fn build_plan(&self) -> SetupPlan

The plan this wizard describes.

pub fn review_lines(&self) -> Vec<String>

Lines for the review screen.

pub fn selected_inline_secrets(&self) -> Vec<String>

MCP rows carrying a credential copied verbatim out of another tool’s config, which importing would duplicate into ~/.leviath/config.toml.