aaif-goose/goose · error

Failed to propagate mode to provider: {}

Error message

Failed to propagate mode to provider: {}

What it means

Thrown at the end of restore_provider_from_session when propagating the session's saved goose_mode to the newly constructed provider via provider.update_mode() fails. The '{}' is the underlying provider error — commonly a transient API/backend failure or a mode the provider does not support (e.g. a planner-dependent mode on a provider without planner support). Provider creation itself succeeded; only the mode sync failed.

Source

Thrown at crates/goose/src/agents/agent.rs:3658

                    .provider_name(&fallback_provider_name)
                    .model_config(fallback_model_config.clone())
                    .apply()
                    .await
                {
                    tracing::warn!("Failed to update session provider: {}", e);
                }

                (fallback_provider, fallback_model_config, true)
            };

        self.update_provider(provider, active_model_config, &session.id)
            .await?;
        // Propagate session mode to the new provider
        if let Some(provider) = self.provider.lock().await.as_ref() {
            provider
                .update_mode(&session.id, session.goose_mode)
                .await
                .map_err(|e| anyhow!("Failed to propagate mode to provider: {}", e))?;
        }
        *self.current_goose_mode.lock().await = session.goose_mode;
        Ok(provider_changed)
    }

    /// Override the system prompt with a custom template
    pub async fn override_system_prompt(&self, template: String) {
        let mut prompt_manager = self.prompt_manager.lock().await;
        prompt_manager.set_system_prompt_override(template);
    }

    pub async fn clear_system_prompt_override(&self) {
        let mut prompt_manager = self.prompt_manager.lock().await;
        prompt_manager.clear_system_prompt_override();
    }

    pub async fn list_extension_prompts(&self, session_id: &str) -> HashMap<String, Vec<Prompt>> {
        self.extension_manager

View on GitHub (pinned to 3810898a74)

Solutions

1. Retry the resume — transient update_mode failures usually clear
2. Switch the mode to the default (unset GOOSE_MODE / 'set_mode default') before resuming
3. Check goose logs for the underlying provider error embedded in '{}'
4. Update goose if the provider's mode handling changed between the session's creation and now

// Rust — retry the resume on transient mode-propagation failures, fail fast otherwise
const MAX: usize = 3;
for attempt in 1..=MAX {
    match agent.restore_provider_from_session(&session).await {
        Ok(changed) => break,
        Err(e) if e.to_string().contains("Failed to propagate mode") && attempt < MAX => {
            tokio::time::sleep(std::time::Duration::from_secs(2u64 * attempt as u64)).await;
        }
        Err(e) => return Err(e),
    }
}

When it happens

Trigger: Resuming a session saved with a non-default GOOSE_MODE where the provider rejects or fails the mode update: transient network error during update_mode, ACP backend error, or mode feature unsupported by the provider build.

Common situations: Resuming sessions across goose versions where mode semantics changed; flaky network at resume time; providers whose mode handling requires extra backend calls that can fail independently.

Related errors

• Provider rejected mode update: {e}
• Could not configure agent: missing provider
• Could not create provider: provider '{}' not found
• Missing env vars for provider '{provider}': {', '.join(missi
• OAuth authentication failed for {}: {}

AI-assisted analysis of aaif-goose/goose@3810898a74 (2026-08-16). Data as JSON: /api/errors/7b6435db4ea4f9da. Report an issue: GitHub.