Trace model settings without request extras

Co-authored-by: anode-agent[bot] <283895490+anode-agent[bot]@users.noreply.github.com>

Author: chai1any

crates/agents-core/src/model_settings.rs

@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
+use serde_json::{Value, json};
 
 /// Provider-agnostic model tuning parameters.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
@@ -41,6 +41,60 @@ pub struct ReasoningSettings {
 }
 
 impl ModelSettings {
+    /// Return the model settings that are safe to attach to trace metadata.
+    ///
+    /// Provider-specific request extras can contain credentials or other request-scoped
+    /// sensitive data, so they are intentionally excluded.
+    pub fn to_traceable_map(&self) -> BTreeMap<String, Value> {
+        let mut traceable = BTreeMap::new();
+        if let Some(value) = self.temperature {
+            traceable.insert("temperature".to_owned(), json!(value));
+        }
+        if let Some(value) = self.top_p {
+            traceable.insert("top_p".to_owned(), json!(value));
+        }
+        if let Some(value) = self.max_output_tokens {
+            traceable.insert("max_output_tokens".to_owned(), json!(value));
+        }
+        if let Some(value) = self.frequency_penalty {
+            traceable.insert("frequency_penalty".to_owned(), json!(value));
+        }
+        if let Some(value) = self.presence_penalty {
+            traceable.insert("presence_penalty".to_owned(), json!(value));
+        }
+        if let Some(value) = &self.tool_choice {
+            traceable.insert("tool_choice".to_owned(), json!(value));
+        }
+        if let Some(value) = self.parallel_tool_calls {
+            traceable.insert("parallel_tool_calls".to_owned(), json!(value));
+        }
+        if let Some(value) = &self.truncation {
+            traceable.insert("truncation".to_owned(), json!(value));
+        }
+        if let Some(value) = self.store {
+            traceable.insert("store".to_owned(), json!(value));
+        }
+        if let Some(value) = self.include_usage {
+            traceable.insert("include_usage".to_owned(), json!(value));
+        }
+        if !self.response_include.is_empty() {
+            traceable.insert("response_include".to_owned(), json!(self.response_include));
+        }
+        if let Some(value) = self.top_logprobs {
+            traceable.insert("top_logprobs".to_owned(), json!(value));
+        }
+        if let Some(value) = &self.reasoning {
+            traceable.insert("reasoning".to_owned(), json!(value));
+        }
+        if let Some(value) = &self.verbosity {
+            traceable.insert("verbosity".to_owned(), json!(value));
+        }
+        if !self.metadata.is_empty() {
+            traceable.insert("metadata".to_owned(), json!(self.metadata));
+        }
+        traceable
+    }
+
     pub fn resolve(&self, override_settings: Option<&Self>) -> Self {
         let Some(override_settings) = override_settings else {
             return self.clone();
@@ -212,4 +266,32 @@ mod tests {
         assert_eq!(resolved.extra_args.get("timeout"), Some(&json!(10)));
         assert_eq!(resolved.extra_args.get("retry"), Some(&json!(2)));
     }
+
+    #[test]
+    fn traceable_model_settings_omit_request_extras() {
+        let settings = ModelSettings {
+            temperature: Some(0.5),
+            metadata: BTreeMap::from([("purpose".to_owned(), json!("trace"))]),
+            extra_query: BTreeMap::from([("api-key".to_owned(), json!("query-secret"))]),
+            extra_body: BTreeMap::from([("secret".to_owned(), json!("body-secret"))]),
+            extra_headers: BTreeMap::from([(
+                "authorization".to_owned(),
+                json!("Bearer header-secret"),
+            )]),
+            extra_args: BTreeMap::from([("api_key".to_owned(), json!("arg-secret"))]),
+            ..Default::default()
+        };
+
+        let traceable = settings.to_traceable_map();
+
+        assert_eq!(traceable.get("temperature"), Some(&json!(0.5)));
+        assert_eq!(
+            traceable.get("metadata"),
+            Some(&json!({"purpose": "trace"}))
+        );
+        assert!(!traceable.contains_key("extra_query"));
+        assert!(!traceable.contains_key("extra_body"));
+        assert!(!traceable.contains_key("extra_headers"));
+        assert!(!traceable.contains_key("extra_args"));
+    }
 }

crates/agents-core/src/run.rs

@@ -1312,6 +1312,12 @@ impl Runner {
         let settings = get_default_model_settings(requested_model.as_deref())
             .resolve(agent.model_settings.as_ref())
             .resolve(self.config.model_settings.as_ref());
+        let traceable_settings = settings.to_traceable_map();
+        if !traceable_settings.is_empty()
+            && let SpanData::Generation(data) = &mut span.data
+        {
+            data.model_config = Some(traceable_settings);
+        }
         let tools = internal_turn_preparation::get_all_tools(agent, context).await?;
 
         if let Some(model_provider) = self
@@ -3555,6 +3561,57 @@ mod tests {
         assert_eq!(exported_span["metadata"]["nested"], json!({"value": 1}));
     }
 
+    #[tokio::test]
+    async fn generation_span_model_config_omits_request_extras() {
+        let _trace_guard = crate::tracing::setup::trace_provider_test_lock()
+            .lock()
+            .await;
+        let previous_provider = crate::tracing::get_trace_provider();
+        let _provider_reset = TraceProviderReset(previous_provider);
+        let provider = Arc::new(crate::tracing::DefaultTraceProvider::default())
+            as Arc<dyn crate::tracing::TraceProvider>;
+        crate::tracing::set_trace_provider(provider);
+        let processor = Arc::new(RecordingTraceProcessor::default());
+        crate::tracing::get_trace_provider().register_processor(processor.clone());
+
+        Runner::new()
+            .with_model_provider(Arc::new(StaticProvider {
+                model: Arc::new(RequestCaptureModel::default()),
+            }))
+            .with_config(RunConfig {
+                model_settings: Some(crate::ModelSettings {
+                    temperature: Some(0.5),
+                    extra_headers: BTreeMap::from([(
+                        "authorization".to_owned(),
+                        json!("Bearer provider-token"),
+                    )]),
+                    extra_query: BTreeMap::from([("api-key".to_owned(), json!("query-token"))]),
+                    extra_body: BTreeMap::from([("secret".to_owned(), json!("body-token"))]),
+                    extra_args: BTreeMap::from([("api_key".to_owned(), json!("arg-token"))]),
+                    ..Default::default()
+                }),
+                ..RunConfig::default()
+            })
+            .run(&Agent::builder("assistant").build(), "hello")
+            .await
+            .expect("run should succeed");
+
+        let model_config = processor
+            .spans()
+            .into_iter()
+            .find_map(|span| match span.data {
+                crate::tracing::SpanData::Generation(data) => data.model_config,
+                _ => None,
+            })
+            .expect("generation span should carry model config");
+
+        assert_eq!(model_config.get("temperature"), Some(&json!(0.5)));
+        assert!(!model_config.contains_key("extra_headers"));
+        assert!(!model_config.contains_key("extra_query"));
+        assert!(!model_config.contains_key("extra_body"));
+        assert!(!model_config.contains_key("extra_args"));
+    }
+
     #[tokio::test]
     async fn multiprovider_forwards_harness_metadata_hooks() {
         struct HarnessMetadataProvider {