rig-core 0.47.0

An opinionated library for building LLM powered applications.
Documentation
use super::*;
use crate::completion::CompletionRequest;
use crate::effect::EffectId;
use crate::http_client;
use crate::providers::auth::{DeviceCodeHandler, MemoryTokenStore, TokenStore};
use crate::providers::chatgpt::auth::{AuthSource, Authenticator};
use crate::test_utils::{MockHttpResponse, SequencedHttpClient};
use http::StatusCode;
use std::time::{Duration, SystemTime};

/// A model call whose expired ChatGPT credential the token endpoint refuses
/// to refresh with `reply`.
async fn refreshed_with(reply: MockHttpResponse) -> anyhow::Result<ErrorReport> {
    let store = Arc::new(MemoryTokenStore::default());
    store
        .save(
            chatgpt::PROVIDER_NAME,
            r#"{"refresh_token":"synthetic-refresh","expires_at":0}"#,
        )
        .await
        .map_err(anyhow::Error::from_boxed)?;
    let auth = Authenticator::new(
        AuthSource::OAuth,
        store,
        DeviceCodeHandler::default(),
        false,
    );
    let http = DynHttpClient::new(SequencedHttpClient::new([reply]));
    let spec = Catalog::builtin()
        .resolve("chatgpt/gpt-6.1-sol")?
        .spec
        .clone();
    let model = SignedInModel::new(spec, auth, http)?;
    let kind = EffectKind::Completion {
        request: Arc::new(CompletionRequest::new("hi")),
        stream: false,
    };
    let outcome = model
        .serve(kind, Dispatch::new(EffectId::from_raw(0), false))
        .await
        .into_outcome()
        .await;
    outcome
        .err()
        .ok_or_else(|| anyhow::anyhow!("the call had no credential"))
}

/// A refresh the server could not serve now is retried, waiting as long as
/// it asks; one it refused is final and asks to sign in again.
#[tokio::test]
async fn a_failed_refresh_keeps_the_class_of_its_reply() -> anyhow::Result<()> {
    let mut wait = http::HeaderMap::new();
    wait.insert(http::header::RETRY_AFTER, "7".parse()?);
    let refused = r#"{"error":"invalid_request","error_description":"no"}"#;
    for (reply, retryable, asked) in [
        (
            MockHttpResponse::error_with_headers(StatusCode::TOO_MANY_REQUESTS, "slow down", wait),
            true,
            Some(Duration::from_secs(7)),
        ),
        (
            MockHttpResponse::error(StatusCode::SERVICE_UNAVAILABLE, "down"),
            true,
            None,
        ),
        (
            MockHttpResponse::error(StatusCode::BAD_REQUEST, refused),
            false,
            None,
        ),
    ] {
        let report = refreshed_with(reply).await?;
        let message = &report.message;
        anyhow::ensure!(report.retryable == retryable, "{report:?}");
        anyhow::ensure!(report.kind == ErrorKind::ProviderResponse, "{report:?}");
        anyhow::ensure!(report.http_status.is_some(), "{report:?}");
        anyhow::ensure!(report.retry_after(SystemTime::now()) == asked, "{report:?}");
        anyhow::ensure!(
            message.contains("ChatGPT token refresh failed"),
            "{message}"
        );
        anyhow::ensure!(message.ends_with("sign in again") != retryable, "{message}");
    }
    Ok(())
}

/// A sign-in that failed without a reply keeps its transport's class: a
/// dropped connection is retried, a request the transport refused and a
/// failure of the sign-in itself are final.
#[test]
fn a_failed_sign_in_without_a_reply_keeps_its_class() -> anyhow::Result<()> {
    let reset = || std::io::Error::from(std::io::ErrorKind::ConnectionReset);
    for (error, retryable) in [
        (
            AuthError::Http(http_client::Error::transient(reset())),
            true,
        ),
        (
            AuthError::Http(http_client::Error::permanent(reset())),
            false,
        ),
        (
            AuthError::Message("ChatGPT sign-in required.".into()),
            false,
        ),
    ] {
        let report = failed_sign_in(error);
        anyhow::ensure!(report.retryable == retryable, "{report:?}");
        anyhow::ensure!(
            report.message.ends_with("sign in again") != retryable,
            "{}",
            report.message
        );
    }
    Ok(())
}