Files
codex/codex-rs/tui/src/app/provider_tests.rs
T
alexsong-oai 2497eab251 Add custom gateway selection to TUI sign-in (#60009)
## What changed

- Add the disabled-by-default `gateway_setup_wizard` feature to let users choose a saved custom gateway during eligible local sign-in onboarding.
- Save the selection as `model_provider`, restart the embedded app server with that provider, and complete required primary authentication and gateway OAuth before starting the first chat.
- Show gateway loading and configuration errors, browser sign-in links, and an OAuth retry action. Respect provider policy and launch overrides.

## Testing

Add coverage for onboarding eligibility, saved gateway selection and persistence, and gateway error and OAuth screens. Add a terminal integration test verifying that the selected gateway receives the first chat with authentication.

GitOrigin-RevId: 92bd2da3abd28d6c2274c91b2d7561bf359f0ca0
2026-11-06 23:35:54 +00:00

490 lines
18 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Provider browsing through loading, startup attachment, nested views, and dismissal.
#![cfg(test)]
use super::*;
use crate::app::tests::make_test_app_with_channels;
use crate::app::tests::test_thread_session;
use crate::chatwidget::tests::render_bottom_popup;
use crate::config_panel::ConfigEditor;
use crate::config_panel::ConfigEditorHandoff;
use crate::config_panel::ResumeCurrentAvailability;
use crate::model_catalog::ModelCatalog;
use crate::tui::TuiEvent;
use crate::tui::test_support::make_test_tui;
use codex_app_server_client::TypedRequestError;
use codex_protocol::ThreadId;
use color_eyre::eyre::Result;
use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyModifiers;
use pretty_assertions::assert_eq;
use ratatui::Terminal;
use ratatui::backend::TestBackend;
use tokio::sync::mpsc::UnboundedReceiver;
async fn next_provider_event(rx: &mut UnboundedReceiver<AppEvent>) -> Event {
loop {
if let AppEvent::Provider(event) = rx.recv().await.expect("open event channel") {
return event;
}
}
}
#[tokio::test]
async fn loading_survives_initial_attachment_and_refreshes_under_an_overlay() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut tui = make_test_tui()?;
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
app.chat_widget.open_config_panel();
let handoff = ConfigEditorHandoff::new(
ConfigEditor::ModelProviders,
crate::key_hint::plain(KeyCode::Enter),
);
handoff.mark_activation_inactive();
app.chat_widget
.open_config_editor(handoff, ResumeCurrentAvailability::Available);
assert!(app.chat_widget.thread_id().is_none());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
let loaded = next_provider_event(&mut events).await;
let session = test_thread_session(ThreadId::new(), app.config.cwd.to_path_buf());
app.chat_widget.handle_thread_session_quiet(session);
app.chat_widget.show_selection_view(SelectionViewParams {
view_id: Some("test_overlay"),
items: vec![back()],
..Default::default()
});
handle(&mut app, &mut tui, &server, loaded);
assert!(app.chat_widget.active_view_is("test_overlay"));
app.chat_widget.handle_key_event(KeyCode::Esc.into());
assert!(app.chat_widget.active_view_is(LIST_VIEW));
app.chat_widget.handle_key_event(KeyCode::Enter.into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
assert!(matches!(app.overlay, Some(Overlay::Static(_))));
app.handle_backtrack_overlay_event(
&mut tui,
&mut server,
TuiEvent::Key(KeyCode::Char('q').into()),
)
.await?;
assert!(app.overlay.is_none());
assert!(app.chat_widget.active_view_is(LIST_VIEW));
// A late result cannot replace a new loading popup after Back and reopen.
app.chat_widget.handle_key_event(KeyCode::Esc.into());
let (view, load) = loading();
app.chat_widget.show_selection_view(view);
handle(&mut app, &mut tui, &server, load);
let stale = next_provider_event(&mut events).await;
app.chat_widget.handle_key_event(KeyCode::Enter.into());
let (view, _load) = loading();
app.chat_widget.show_selection_view(view);
handle(&mut app, &mut tui, &server, stale);
assert!(app.chat_widget.active_view_is(LOADING_VIEW));
server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn provider_views_show_reported_endpoints_and_ids_outside_the_catalog() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut tui = make_test_tui()?;
let server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
let provider = ModelProviderSummary {
id: "openai".into(),
name: "OpenAI".into(),
can_edit: false,
base_url: Some(
"https://example.test/organization/deployment/region/service/openai/v1".into(),
),
settings: ProviderSettings::OpenAi,
};
let page = ModelProviderListResponse {
data: vec![provider],
default_provider_id: "lmstudio".into(),
can_change_default: true,
};
app.chat_widget.show_selection_view(list(
Some("ollama"),
Arc::new(Catalog {
backend: server.backend_id(),
page,
}),
/*client_override*/ None,
&app.keymap.list,
/*notice*/ None,
));
insta::assert_snapshot!(
"provider_list",
render_bottom_popup(&app.chat_widget, /*width*/ 80)
);
app.chat_widget.handle_key_event(KeyCode::Enter.into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
let Some(Overlay::Static(pager)) = &mut app.overlay else {
panic!("expected provider details pager");
};
let mut terminal = Terminal::new(TestBackend::new(/*width*/ 48, /*height*/ 9))?;
terminal.draw(|frame| pager.render(frame.area(), frame.buffer_mut()))?;
let first_page = terminal.backend().to_string();
pager.handle_event(&mut tui, TuiEvent::Key(KeyCode::PageDown.into()))?;
terminal.draw(|frame| pager.render(frame.area(), frame.buffer_mut()))?;
insta::assert_snapshot!(
"openai_provider_details",
format!("{first_page}\n{}", terminal.backend())
);
server.shutdown().await?;
Ok(())
}
#[tokio::test(flavor = "current_thread")]
async fn space_saves_once_retries_and_preserves_the_current_chat() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut tui = make_test_tui()?;
std::fs::write(
app.config.codex_home.join("config.toml"),
r#"model_providers.gateway = { name = "Example Gateway", base_url = "http://127.0.0.1:9/v1" }"#,
)?;
let server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
let session = test_thread_session(ThreadId::new(), app.config.cwd.to_path_buf());
let original = session.model_provider_id.clone();
app.chat_widget.handle_thread_session_quiet(session);
let (view, load) = loading();
app.chat_widget.show_selection_view(view);
handle(&mut app, &mut tui, &server, load);
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
// Disconnection after the picker opened must release its write guard for retry.
app.chat_widget.handle_key_event(KeyCode::Home.into());
app.reconnect.offline = true;
app.chat_widget.handle_key_event(KeyCode::Char(' ').into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
app.reconnect.offline = false;
while !app.chat_widget.active_view_is(LIST_VIEW) {
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
}
let retried = render_bottom_popup(&app.chat_widget, /*width*/ 100);
assert!(retried.contains("Could not save provider: Reconnect"));
assert!(!app.model_catalog.provider_may_have_changed());
app.chat_widget.handle_key_event(KeyCode::Home.into());
app.chat_widget.handle_key_event(KeyCode::Char(' ').into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
// The spawned RPC cannot run until this current-thread test yields.
write::Write::Default("openai".into()).start(&mut app, &server);
assert!(std::iter::from_fn(|| events.try_recv().ok()).any(|event| {
matches!(event, AppEvent::InsertHistoryCell(cell) if cell.display_lines(/*width*/ 100)[0]
.to_string().contains("A provider change is already saving."))
}));
// Wait for the RPC without dispatching its completion on the original event channel.
let backend = server.backend_id();
assert!(*app.provider_writes[&backend].lock().await);
let other =
ModelCatalog::new(Vec::new()).for_backend(BackendId::new(), &mut app.provider_writes);
assert!(!other.provider_may_have_changed());
let reconnected = ModelCatalog::new(Vec::new()).for_backend(backend, &mut app.provider_writes);
assert!(reconnected.provider_may_have_changed());
app.chat_widget.show_selection_view(SelectionViewParams {
view_id: Some("test_overlay"),
items: vec![back()],
..Default::default()
});
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
assert!(app.chat_widget.model_picker_unavailable().is_some());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
assert!(app.chat_widget.active_view_is("test_overlay"));
app.chat_widget.handle_key_event(KeyCode::Esc.into());
app.chat_widget.handle_key_event(KeyCode::Home.into());
assert_eq!(app.chat_widget.config_ref().model_provider_id, original);
insta::assert_snapshot!(
"saved_default_provider",
render_bottom_popup(&app.chat_widget, /*width*/ 100)
);
// Switch back, then dismiss the picker before the save result is delivered.
app.chat_widget.handle_key_event(KeyCode::End.into());
app.chat_widget.handle_key_event(KeyCode::Up.into());
app.chat_widget.handle_key_event(KeyCode::Char(' ').into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
app.chat_widget.handle_key_event(KeyCode::Esc.into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
let cell = std::iter::from_fn(|| events.try_recv().ok())
.filter_map(|event| match event {
AppEvent::InsertHistoryCell(cell) => Some(cell),
_ => None,
})
.last()
.expect("restart hint in history");
insta::assert_snapshot!(cell.display_lines(/*width*/ 160)[0].to_string(), @"• /new now uses openai. Restart the app server and TUI to refresh /model.");
server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn only_ambiguous_write_failures_invalidate_the_model_catalog() {
use codex_app_server_client::AppServerClient;
use codex_app_server_client::CloudClient;
use codex_app_server_protocol::JSONRPCErrorError;
let rejected = Ok(Err(JSONRPCErrorError {
code: -32602,
message: "Rejected".into(),
data: None,
}));
let overridden = Ok(Ok(serde_json::json!({
"status": "okOverridden", "version": "1", "filePath": std::env::temp_dir().join("config.toml")
})));
let disconnected = Err(std::io::Error::other("connection lost"));
let unreadable = Ok(Ok(serde_json::Value::Null));
for (reply, stale) in [
(rejected, false),
(overridden, false),
(disconnected, true),
(unreadable, true),
] {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let (client, mut commands, _server_events) = CloudClient::channel(/*capacity*/ 1);
let backend = BackendId::new();
let server = AppServerSession::new(
backend,
AppServerClient::Cloud(client),
crate::app_server_session::ThreadParamsMode::Remote,
);
app.chat_widget.show_selection_view(SelectionViewParams {
view_id: Some(LIST_VIEW),
items: vec![back()],
..Default::default()
});
write::Write::Default("gateway".into()).start(&mut app, &server);
let command = commands.recv().await.expect("config write");
command
.response
.send(reply)
.expect("write is awaiting a response");
assert!(matches!(
next_provider_event(&mut events).await,
Event::Written(_)
));
let reconnected =
ModelCatalog::new(Vec::new()).for_backend(backend, &mut app.provider_writes);
assert_eq!(reconnected.provider_may_have_changed(), stale);
}
}
#[test]
fn unsupported_list_method_explains_server_compatibility() {
for (code, message) in [
(-32601, "Method not found"),
(
-32600,
"Invalid request: unknown variant `modelProvider/list`",
),
] {
let error = TypedRequestError::Server {
method: "modelProvider/list".into(),
source: codex_app_server_protocol::JSONRPCErrorError {
code,
message: message.into(),
data: None,
},
};
assert_eq!(
rpc::request_error(error),
"Update the connected app server to browse model providers."
);
}
}
#[tokio::test]
async fn list_opened_before_first_attachment_shows_the_attached_provider() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut tui = make_test_tui()?;
let server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
let (view, event) = loading();
app.chat_widget.show_selection_view(view);
handle(&mut app, &mut tui, &server, event);
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
assert!(
render_bottom_popup(&app.chat_widget, /*width*/ 100)
.contains("Current chat: No active chat")
);
let mut session = test_thread_session(ThreadId::new(), app.config.cwd.to_path_buf());
session.model_provider_id = "ollama".into();
app.chat_widget.handle_thread_session_quiet(session);
assert!(app.chat_widget.active_view_is(LOADING_VIEW));
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
assert!(render_bottom_popup(&app.chat_widget, /*width*/ 100).contains("Current chat: ollama"));
server.shutdown().await?;
Ok(())
}
#[tokio::test]
async fn adding_a_custom_provider_saves_to_the_server_and_preserves_the_default() -> Result<()> {
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
let mut tui = make_test_tui()?;
std::fs::write(
app.config.codex_home.join("config.toml"),
r#"model_providers.seed = { name = "Existing", env_key = "CATALOG_KEY" }"#,
)?;
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
let (view, load) = loading();
app.chat_widget.show_selection_view(view);
handle(&mut app, &mut tui, &server, load);
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
// Open the existing gateway's scrollable details and enter its editor.
app.chat_widget.handle_key_event(KeyCode::End.into());
app.chat_widget.handle_key_event(KeyCode::Up.into());
app.chat_widget.handle_key_event(KeyCode::Enter.into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
let Some(Overlay::Static(pager)) = &mut app.overlay else {
panic!("expected provider details pager");
};
let mut terminal = Terminal::new(TestBackend::new(/*width*/ 72, /*height*/ 12))?;
terminal.draw(|frame| pager.render(frame.area(), frame.buffer_mut()))?;
insta::assert_snapshot!("editable_provider_details", terminal.backend());
app.handle_backtrack_overlay_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Enter.into()))
.await?;
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
assert!(app.chat_widget.active_view_is(editor::VIEW_ID));
assert!(render_bottom_popup(&app.chat_widget, /*width*/ 72).contains("Existing"));
app.chat_widget.handle_key_event(KeyCode::Esc.into());
app.chat_widget.handle_key_event(KeyCode::End.into());
app.chat_widget.handle_key_event(KeyCode::Enter.into());
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
let chat = &mut app.chat_widget;
insta::assert_snapshot!(render_bottom_popup(chat, /*width*/ 72), @r"
Add custom provider
› Name* Team gateway
Base URL* https://gateway.example/v1
API key variable $TEAM_API_KEY
Save
* Required
Enter the environment variable name on the app server.
tab move · enter next/save · esc back
");
for value in ["Team gateway", "https://gateway.example.test/v1"] {
chat.handle_paste(value.into());
chat.handle_key_event(KeyCode::Enter.into());
}
chat.handle_paste("CAT".into());
chat.handle_key_event(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL));
assert!(render_bottom_popup(chat, /*width*/ 19).contains("$CATALOG_KEY"));
chat.handle_key_event(KeyCode::Tab.into());
chat.handle_key_event(KeyCode::Enter.into());
// Process the write, its completion, and the subsequent catalog reload.
for _ in 0..4 {
handle(
&mut app,
&mut tui,
&server,
next_provider_event(&mut events).await,
);
}
let list = render_bottom_popup(&app.chat_widget, /*width*/ 100);
assert!(list.contains("Team gateway"));
assert!(list.contains("Default for new chats: openai"));
server.shutdown().await?;
Ok(())
}