Persist provider name and model config in the session (#5419)

crates/goose-server/src/openapi.rs

@@ -4,6 +4,7 @@ use goose::agents::ExtensionConfig;
 use goose::config::permission::PermissionLevel;
 use goose::config::ExtensionEntry;
 use goose::conversation::Conversation;
+use goose::model::ModelConfig;
 use goose::permission::permission_confirmation::PrincipalType;
 use goose::providers::base::{ConfigKey, ModelInfo, ProviderMetadata, ProviderType};
 use goose::session::{Session, SessionInsights, SessionType};
@@ -455,6 +456,7 @@ derive_utoipa!(Icon as IconSchema);
         PermissionLevel,
         PrincipalType,
         ModelInfo,
+        ModelConfig,
         Session,
         SessionInsights,
         SessionType,

crates/goose-server/src/routes/agent.rs

@@ -16,7 +16,7 @@ use goose::agents::ExtensionConfig;
 use goose::config::{Config, GooseMode};
 use goose::model::ModelConfig;
 use goose::prompt_template::render_global_file;
-use goose::providers::{create, create_with_named_model};
+use goose::providers::create;
 use goose::recipe::Recipe;
 use goose::recipe_deeplink;
 use goose::session::session_manager::SessionType;
@@ -192,7 +192,7 @@ async fn resume_agent(
     State(state): State<Arc<AppState>>,
     Json(payload): Json<ResumeAgentRequest>,
 ) -> Result<Json<Session>, ErrorResponse> {
-    let session = SessionManager::get_session(&payload.session_id, true)
+    let session = SessionManager::get_session(&payload.session_id, false)
         .await
         .map_err(|err| {
             error!("Failed to resume session {}: {}", payload.session_id, err);
@@ -204,7 +204,7 @@ async fn resume_agent(
 
     if payload.load_model_and_extensions {
         let agent = state
-            .get_agent_for_route(payload.session_id)
+            .get_agent_for_route(payload.session_id.clone())
             .await
             .map_err(|code| ErrorResponse {
                 message: "Failed to get agent for route".into(),
@@ -214,25 +214,39 @@ async fn resume_agent(
         let config = Config::global();
 
         let provider_result = async {
-            let provider_name: String = config.get_goose_provider().map_err(|_| ErrorResponse {
-                message: "Could not configure agent: missing provider".into(),
-                status: StatusCode::INTERNAL_SERVER_ERROR,
-            })?;
-
-            let model: String = config.get_goose_model().map_err(|_| ErrorResponse {
-                message: "Could not configure agent: missing model".into(),
-                status: StatusCode::INTERNAL_SERVER_ERROR,
-            })?;
-
-            let provider = create_with_named_model(&provider_name, &model)
-                .await
-                .map_err(|_| ErrorResponse {
-                    message: "Could not configure agent: missing model".into(),
+            let provider_name = session
+                .provider_name
+                .clone()
+                .or_else(|| config.get_goose_provider().ok())
+                .ok_or_else(|| ErrorResponse {
+                    message: "Could not configure agent: missing provider".into(),
                     status: StatusCode::INTERNAL_SERVER_ERROR,
                 })?;
 
+            let model_config = match session.model_config.clone() {
+                Some(saved_config) => saved_config,
+                None => {
+                    let model_name = config.get_goose_model().map_err(|_| ErrorResponse {
+                        message: "Could not configure agent: missing model".into(),
+                        status: StatusCode::INTERNAL_SERVER_ERROR,
+                    })?;
+                    ModelConfig::new(&model_name).map_err(|e| ErrorResponse {
+                        message: format!("Could not configure agent: invalid model {}", e),
+                        status: StatusCode::INTERNAL_SERVER_ERROR,
+                    })?
+                }
+            };
+
+            let provider =
+                create(&provider_name, model_config)
+                    .await
+                    .map_err(|e| ErrorResponse {
+                        message: format!("Could not create provider: {}", e),
+                        status: StatusCode::INTERNAL_SERVER_ERROR,
+                    })?;
+
             agent
-                .update_provider(provider)
+                .update_provider(provider, &payload.session_id)
                 .await
                 .map_err(|e| ErrorResponse {
                     message: format!("Could not configure agent: {}", e),
@@ -428,12 +442,15 @@ async fn update_agent_provider(
         )
     })?;
 
-    agent.update_provider(new_provider).await.map_err(|e| {
-        (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            format!("Failed to update provider: {}", e),
-        )
-    })?;
+    agent
+        .update_provider(new_provider, &payload.session_id)
+        .await
+        .map_err(|e| {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Failed to update provider: {}", e),
+            )
+        })?;
 
     Ok(())
 }