refactor(client): use ModelCallObservation throughout

Signed-off-by: nachiketb <nachiketb@nvidia.com>

Author: nachiketb-nvidia

crates/libsy-llm-client/src/lib.rs

@@ -32,7 +32,7 @@ mod system_one;
 pub use backend::{Backend, DEFAULT_MAX_RETRIES, HttpBackendConfig};
 pub use client::{AuxiliaryOperation, ModelConfig, TranslatingLlmClient};
 pub use error::{LlmClientError, Result};
-pub use observation::{LlmCallObservation, RunObservation, RunObserver};
+pub use observation::{ModelCallObservation, RunObservation, RunObserver};
 pub use raw::RawResponse;
 pub use run::{ClientRouter, decide, run};
 pub use switchyard_translation::RawEventStream;

crates/libsy-llm-client/src/observation.rs

@@ -11,7 +11,7 @@ use switchyard_protocol::{ModelId, Usage};
 
 /// One completed model call observed while serving an algorithm run.
 #[derive(Clone, Debug)]
-pub struct LlmCallObservation {
+pub struct ModelCallObservation {
     /// Model selected for the completed call.
     pub selected_model: ModelId,
     /// Whether the call completed successfully.
@@ -28,11 +28,11 @@ pub enum RunObservation {
     /// Metadata attached to the completed routing outcome.
     Outcome(OutcomeMetadata),
     /// A completed model call requested by the algorithm for routing work.
-    LlmCall(LlmCallObservation),
+    LlmCall(ModelCallObservation),
     /// A completed decision call requested by the algorithm for routing work.
-    DecisionCall(LlmCallObservation),
+    DecisionCall(ModelCallObservation),
     /// A completed terminal model call made from the routing outcome.
-    AnswerCall(LlmCallObservation),
+    AnswerCall(ModelCallObservation),
     /// Routing time recorded by the `switchyard.routing_overhead_ms` metric.
     RoutingOverhead(Duration),
 }

crates/libsy-llm-client/src/run.rs

@@ -37,7 +37,7 @@ use switchyard_protocol::{
 };
 use switchyard_translation::prepare_request_for_target;
 
-use crate::observation::{LlmCallObservation, RunObservation, RunObserver};
+use crate::observation::{ModelCallObservation, RunObservation, RunObserver};
 use crate::{metrics, observability};
 
 /// Run one request to completion, serving every offloaded model call with `client`.
@@ -169,7 +169,7 @@ async fn serve_decision(
     if let Some(observations) = observations {
         observations
             .lock()
-            .push(RunObservation::DecisionCall(LlmCallObservation {
+            .push(RunObservation::DecisionCall(ModelCallObservation {
                 selected_model: call.model.clone(),
                 is_success: result.is_ok(),
                 duration: started.elapsed(),
@@ -249,7 +249,7 @@ async fn call_first_available(
     algorithm: &str,
     request: &Request,
     models: &[ModelId],
-    observe: &(dyn Fn(LlmCallObservation) + Send + Sync),
+    observe: &(dyn Fn(ModelCallObservation) + Send + Sync),
 ) -> Result<Response> {
     for (index, target) in models.iter().enumerate() {
         let request = clients.prepare_completion_request(request.clone(), target);
@@ -326,7 +326,7 @@ async fn call_one(
     model_id: &ModelId,
     request: Request,
     algorithm: &str,
-    observe: &(dyn Fn(LlmCallObservation) + Send + Sync),
+    observe: &(dyn Fn(ModelCallObservation) + Send + Sync),
     // index is for span log
     index: usize,
     // count is for span log
@@ -367,7 +367,7 @@ async fn call_one(
     } else {
         result
     };
-    observe(LlmCallObservation {
+    observe(ModelCallObservation {
         selected_model: model_id.clone(),
         is_success: result.is_ok(),
         duration,
@@ -1386,7 +1386,7 @@ mod tests {
     fn answer_observation_keeps_call_order() {
         let pending = Some(Arc::new(Mutex::new(
             ["answer", "judge"]
-                .map(|model| LlmCallObservation {
+                .map(|model| ModelCallObservation {
                     selected_model: model.into(),
                     is_success: true,
                     duration: std::time::Duration::ZERO,

crates/switchyard-nemo-relay-plugin/src/runtime.rs

@@ -11,7 +11,7 @@ use nemo_relay_plugin::{
     MetricValueType, PluginRuntime,
 };
 use serde_json::{Map, json};
-use switchyard_llm_client::{LlmCallObservation, RunObservation, RunObserver};
+use switchyard_llm_client::{ModelCallObservation, RunObservation, RunObserver};
 use switchyard_protocol::{
     LlmClientError, LlmResponse, LlmResponseChunk, LlmStreamError, Metadata, ProviderExtensions,
     Request, Response, Usage, WireFormat,
@@ -390,7 +390,7 @@ impl SwitchyardRuntime {
     fn routing_call_events(
         &self,
         events: &mut Vec<RoutingEvent>,
-        call: LlmCallObservation,
+        call: ModelCallObservation,
         call_index: usize,
         metadata: &Json,
         mark_name: &str,
@@ -734,7 +734,7 @@ fn routing_overhead_metric(latency_ms: f64, metadata: Json) -> RoutingEvent {
 
 fn token_usage_metrics(
     call_role: &str,
-    call: &LlmCallObservation,
+    call: &ModelCallObservation,
     metadata: &Json,
 ) -> Vec<RoutingEvent> {
     let Some(usage) = call.usage.as_ref() else {
@@ -1316,7 +1316,7 @@ mod tests {
         runtime.emit_observations(
             &mut events,
             vec![
-                RunObservation::LlmCall(LlmCallObservation {
+                RunObservation::LlmCall(ModelCallObservation {
                     selected_model: ModelId::from("routing-model"),
                     is_success: false,
                     duration: std::time::Duration::from_millis(12),
@@ -1407,7 +1407,7 @@ mod tests {
 
     #[test]
     fn token_usage_metrics_distinguish_routing_and_answer_targets() {
-        let call = LlmCallObservation {
+        let call = ModelCallObservation {
             selected_model: ModelId::from("judge-model"),
             is_success: true,
             duration: std::time::Duration::from_millis(1),
@@ -1469,13 +1469,13 @@ mod tests {
         runtime.emit_observations(
             &mut events,
             vec![
-                RunObservation::AnswerCall(LlmCallObservation {
+                RunObservation::AnswerCall(ModelCallObservation {
                     selected_model: ModelId::from("weak-target"),
                     is_success: false,
                     duration: std::time::Duration::from_millis(2),
                     usage: None,
                 }),
-                RunObservation::AnswerCall(LlmCallObservation {
+                RunObservation::AnswerCall(ModelCallObservation {
                     selected_model: ModelId::from("strong-target"),
                     is_success: true,
                     duration: std::time::Duration::from_millis(3),

crates/switchyard-server/src/lib.rs

@@ -1685,7 +1685,7 @@ fn endpoint_listing(has_routing_log: bool) -> String {
 
 #[cfg(test)]
 mod tests {
-    use switchyard_llm_client::LlmCallObservation;
+    use switchyard_llm_client::ModelCallObservation;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
     use tokio::sync::{Notify, oneshot};
 
@@ -1706,7 +1706,7 @@ mod tests {
         let observer = stats_observer(StatsAccumulator::default(), Some((log.clone(), context)));
 
         let call = |model: &str, answer: bool| {
-            let observation = LlmCallObservation {
+            let observation = ModelCallObservation {
                 selected_model: ModelId::from(model),
                 is_success: true,
                 duration: Duration::from_millis(3),