mirror of
https://github.com/openai/codex.git
synced 2026-05-25 05:24:37 +00:00
a803790a10
## Summary - Add `codex-model-provider` as the runtime home for model-provider behavior that does not belong in `codex-core`, `codex-login`, or `codex-api`. - The new crate wraps configured `ModelProviderInfo` in a `ModelProvider` trait object that can resolve the API provider config, provider-scoped auth manager, and request auth provider for each call. - This centralizes provider auth behavior in one place today, and gives us an extension point for future provider-specific auth, model listing, request setup, and related runtime behavior. ## Tests Ran tests manually to make sure that provider auth under different configs still work as expected. --------- Co-authored-by: pakrym-oai <pakrym@openai.com>
94 lines
2.6 KiB
Rust
94 lines
2.6 KiB
Rust
use crate::auth::SharedAuthProvider;
|
|
use crate::common::CompactionInput;
|
|
use crate::endpoint::session::EndpointSession;
|
|
use crate::error::ApiError;
|
|
use crate::provider::Provider;
|
|
use codex_client::HttpTransport;
|
|
use codex_client::RequestTelemetry;
|
|
use codex_protocol::models::ResponseItem;
|
|
use http::HeaderMap;
|
|
use http::Method;
|
|
use serde::Deserialize;
|
|
use serde_json::to_value;
|
|
use std::sync::Arc;
|
|
|
|
pub struct CompactClient<T: HttpTransport> {
|
|
session: EndpointSession<T>,
|
|
}
|
|
|
|
impl<T: HttpTransport> CompactClient<T> {
|
|
pub fn new(transport: T, provider: Provider, auth: SharedAuthProvider) -> Self {
|
|
Self {
|
|
session: EndpointSession::new(transport, provider, auth),
|
|
}
|
|
}
|
|
|
|
pub fn with_telemetry(self, request: Option<Arc<dyn RequestTelemetry>>) -> Self {
|
|
Self {
|
|
session: self.session.with_request_telemetry(request),
|
|
}
|
|
}
|
|
|
|
fn path() -> &'static str {
|
|
"responses/compact"
|
|
}
|
|
|
|
pub async fn compact(
|
|
&self,
|
|
body: serde_json::Value,
|
|
extra_headers: HeaderMap,
|
|
) -> Result<Vec<ResponseItem>, ApiError> {
|
|
let resp = self
|
|
.session
|
|
.execute(Method::POST, Self::path(), extra_headers, Some(body))
|
|
.await?;
|
|
let parsed: CompactHistoryResponse =
|
|
serde_json::from_slice(&resp.body).map_err(|e| ApiError::Stream(e.to_string()))?;
|
|
Ok(parsed.output)
|
|
}
|
|
|
|
pub async fn compact_input(
|
|
&self,
|
|
input: &CompactionInput<'_>,
|
|
extra_headers: HeaderMap,
|
|
) -> Result<Vec<ResponseItem>, ApiError> {
|
|
let body = to_value(input)
|
|
.map_err(|e| ApiError::Stream(format!("failed to encode compaction input: {e}")))?;
|
|
self.compact(body, extra_headers).await
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct CompactHistoryResponse {
|
|
output: Vec<ResponseItem>,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use async_trait::async_trait;
|
|
use codex_client::Request;
|
|
use codex_client::Response;
|
|
use codex_client::StreamResponse;
|
|
use codex_client::TransportError;
|
|
|
|
#[derive(Clone, Default)]
|
|
struct DummyTransport;
|
|
|
|
#[async_trait]
|
|
impl HttpTransport for DummyTransport {
|
|
async fn execute(&self, _req: Request) -> Result<Response, TransportError> {
|
|
Err(TransportError::Build("execute should not run".to_string()))
|
|
}
|
|
|
|
async fn stream(&self, _req: Request) -> Result<StreamResponse, TransportError> {
|
|
Err(TransportError::Build("stream should not run".to_string()))
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn path_is_responses_compact() {
|
|
assert_eq!(CompactClient::<DummyTransport>::path(), "responses/compact");
|
|
}
|
|
}
|