fix(goose): only send agent-session-id when a session exists

crates/goose-cli/src/commands/configure.rs

@@ -17,15 +17,13 @@ use goose::config::{
     configure_tetrate, Config, ConfigError, ExperimentManager, ExtensionEntry, GooseMode,
     PermissionManager,
 };
-use goose::conversation::message::Message;
 use goose::model::ModelConfig;
 use goose::posthog::{get_telemetry_choice, TELEMETRY_ENABLED_KEY};
 use goose::providers::provider_test::test_provider_configuration;
 use goose::providers::{create, providers, retry_operation, RetryConfig};
 use goose::session::SessionType;
 use serde_json::Value;
 use std::collections::HashMap;
-use uuid::Uuid;
 
 // useful for light themes where there is no dicernible colour contrast between
 // cursor-selected and cursor-unselected items.
@@ -683,10 +681,8 @@ pub async fn configure_provider_dialog() -> anyhow::Result<bool> {
     let models_res = {
         let temp_model_config = ModelConfig::new(&provider_meta.default_model)?;
         let temp_provider = create(provider_name, temp_model_config).await?;
-        // Provider setup runs before any user session exists; use an ephemeral id.
-        let session_id = Uuid::new_v4().to_string();
         retry_operation(&RetryConfig::default(), || async {
-            temp_provider.fetch_recommended_models(&session_id).await
+            temp_provider.fetch_recommended_models().await
         })
         .await
     };
@@ -1658,11 +1654,11 @@ pub async fn handle_openrouter_auth() -> anyhow::Result<()> {
 
     match create("openrouter", model_config).await {
         Ok(provider) => {
-            // Config verification runs before any user session exists; use an ephemeral id.
-            let session_id = Uuid::new_v4().to_string();
+            let model_config = provider.get_model_config();
             let test_result = provider
-                .complete(
-                    &session_id,
+                .complete_with_model(
+                    None,
+                    &model_config,
                     "You are goose, an AI assistant.",
                     &[Message::user().with_text("Say 'Configuration test successful!'")],
                     &[],
@@ -1738,16 +1734,7 @@ pub async fn handle_tetrate_auth() -> anyhow::Result<()> {
 
     match create("tetrate", model_config).await {
         Ok(provider) => {
-            // Config verification runs before any user session exists; use an ephemeral id.
-            let session_id = Uuid::new_v4().to_string();
-            let test_result = provider
-                .complete(
-                    &session_id,
-                    "You are goose, an AI assistant.",
-                    &[Message::user().with_text("Say 'Configuration test successful!'")],
-                    &[],
-                )
-                .await;
+            let test_result = provider.fetch_supported_models().await;
 
             match test_result {
                 Ok(_) => {

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

@@ -28,7 +28,6 @@ use serde_json::Value;
 use serde_yaml;
 use std::{collections::HashMap, sync::Arc};
 use utoipa::ToSchema;
-use uuid::Uuid;
 
 #[derive(Serialize, ToSchema)]
 pub struct ExtensionResponse {
@@ -409,10 +408,8 @@ pub async fn get_provider_models(
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    // Config endpoints have no user session; use an ephemeral id for the probe.
-    let session_id = Uuid::new_v4().to_string();
     let models_result = retry_operation(&RetryConfig::default(), || async {
-        provider.fetch_recommended_models(&session_id).await
+        provider.fetch_recommended_models().await
     })
     .await;
 
@@ -592,10 +589,8 @@ pub async fn detect_provider(
     Json(detect_request): Json<DetectProviderRequest>,
 ) -> Result<Json<DetectProviderResponse>, StatusCode> {
     let api_key = detect_request.api_key.trim();
-    // Provider detection runs without a user session; use an ephemeral id.
-    let session_id = Uuid::new_v4().to_string();
 
-    match detect_provider_from_api_key(&session_id, api_key).await {
+    match detect_provider_from_api_key(api_key).await {
         Some((provider_name, models)) => Ok(Json(DetectProviderResponse {
             provider_name,
             models,

crates/goose/examples/databricks_oauth.rs

@@ -1,10 +1,8 @@
 use anyhow::Result;
 use dotenvy::dotenv;
 use goose::conversation::message::Message;
+use goose::providers::create_with_named_model;
 use goose::providers::databricks::DATABRICKS_DEFAULT_MODEL;
-use goose::providers::{base::Usage, create_with_named_model};
-use tokio_stream::StreamExt;
-use uuid::Uuid;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -20,25 +18,25 @@ async fn main() -> Result<()> {
     let message = Message::user().with_text("Tell me a short joke about programming.");
 
     // Get a response
-    let session_id = Uuid::new_v4().to_string();
-    let mut stream = provider
-        .stream(&session_id, "You are a helpful assistant.", &[message], &[])
+    let (response, usage) = provider
+        .complete_with_model(
+            None,
+            &provider.get_model_config(),
+            "You are a helpful assistant.",
+            &[message],
+            &[],
+        )
         .await?;
 
     println!("\nResponse from AI:");
     println!("---------------");
-    let mut usage = Usage::default();
-    while let Some(Ok((msg, usage_part))) = stream.next().await {
-        dbg!(msg);
-        if let Some(u) = usage_part {
-            usage += u.usage;
-        }
-    }
+    println!("{:?}", response);
+
     println!("\nToken Usage:");
     println!("------------");
-    println!("Input tokens: {:?}", usage.input_tokens);
-    println!("Output tokens: {:?}", usage.output_tokens);
-    println!("Total tokens: {:?}", usage.total_tokens);
+    println!("Input tokens: {:?}", usage.usage.input_tokens);
+    println!("Output tokens: {:?}", usage.usage.output_tokens);
+    println!("Total tokens: {:?}", usage.usage.total_tokens);
 
     Ok(())
 }

crates/goose/examples/image_tool.rs

@@ -10,7 +10,6 @@ use rmcp::model::{CallToolRequestParams, Content, Tool};
 use rmcp::object;
 use std::fs;
 use std::sync::Arc;
-use uuid::Uuid;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -63,10 +62,10 @@ async fn main() -> Result<()> {
                 },
             }
         });
-        let session_id = Uuid::new_v4().to_string();
         let (response, usage) = provider
-            .complete(
-                &session_id,
+            .complete_with_model(
+                None,
+                &provider.get_model_config(),
                 "You are a helpful assistant. Please describe any text you see in the image.",
                 &messages,
                 &[Tool::new("view_image", "View an image", input_schema)],