Skip to content

Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.

Rust
3.5 KB
Raw Blame
// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

//! Test-only algorithm that returns a hard-coded response without calling a backend.

use std::sync::Arc;

use switchyard_protocol::{
    AggLlmResponse, ContentBlock, LlmResponse, ModelId, Request, Response, ResponseOutput, Role,
    StopReason,
};

use crate::core::algorithm::{Algorithm, Driver};
use crate::{Result, RoutingOutcome};

/// Test helper that returns a hard-coded response without routing or model I/O.
pub struct Noop {}

#[async_trait::async_trait]
impl Algorithm for Noop {
    fn name(&self) -> &str {
        "noop"
    }

    async fn route(self: Arc<Self>, _driver: Driver, request: Request) -> Result<RoutingOutcome> {
        let streaming = request.llm_request.stream;
        let model_id = request
            .model_id()
            .unwrap_or_else(|| ModelId::from("switchyard/noop"));
        tracing::info!(target = %model_id, "noop returned its synthetic response");
        let aggregate = AggLlmResponse {
            id: Some("switchyard-noop".to_string()),
            model: Some(model_id.to_string()),
            outputs: vec![ResponseOutput {
                url_citations: Vec::new(),
                role: Role::Assistant,
                content: vec![ContentBlock::Text {
                    text: "OK".to_string(),
                }],
                stop_reason: Some(StopReason::EndTurn),
            }],
            ..Default::default()
        };
        let llm_response = if streaming {
            LlmResponse::Stream(aggregate.into_stream())
        } else {
            LlmResponse::Agg(aggregate)
        };
        let response = Response {
            llm_response,
            metadata: request.metadata.clone(),
            upstream_headers: http::HeaderMap::new(),
        };
        Ok(RoutingOutcome::answered(model_id, request, response))
    }
}

#[cfg(test)]
mod tests {
    use switchyard_protocol::{LlmRequest, Message, Role};

    use super::*;
    use crate::core::testing::{echo, test_drive};

    #[tokio::test]
    async fn test_noop_algo() -> Result<()> {
        const TEST_MODEL: &str = "test_noop_algo";
        let request = Request {
            llm_request: LlmRequest {
                model: Some(TEST_MODEL.to_string()),
                messages: vec![Message::text(Role::User, "hi")],
                ..LlmRequest::default()
            },
            raw_request: None,
            metadata: None,
        };

        // `Noop` synthesizes its own response and never offloads a call, so `echo` is
        // never reached.
        let a: Arc<dyn Algorithm> = Arc::new(Noop {});
        let (selected_model, response) = test_drive(a, request, echo()).await?;
        assert_eq!(selected_model, TEST_MODEL);
        assert_eq!(response.selected_model(), Some(TEST_MODEL));
        Ok(())
    }

    #[tokio::test]
    async fn test_noop_algo_streams_when_requested() -> Result<()> {
        let request = Request {
            llm_request: LlmRequest {
                model: Some("streaming-noop".to_string()),
                messages: vec![Message::text(Role::User, "hi")],
                stream: true,
                ..LlmRequest::default()
            },
            raw_request: None,
            metadata: None,
        };

        let algorithm: Arc<dyn Algorithm> = Arc::new(Noop {});
        let (_, response) = test_drive(algorithm, request, echo()).await?;

        assert!(matches!(response.llm_response, LlmResponse::Stream(_)));
        Ok(())
    }
}