use openai_client_base::models::{
self, response::Status, FunctionToolCall, InputItem, OutputItem, OutputMessageContent,
ResponseError, ResponseUsage,
};
use serde::{Deserialize, Serialize};
use crate::tool_framework::ToolInvocation;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ResponsesResponse {
inner: models::Response,
#[serde(skip)]
rate_limits: Option<crate::RateLimitSnapshot>,
}
impl PartialEq for ResponsesResponse {
fn eq(&self, other: &Self) -> bool {
self.inner == other.inner
}
}
impl ResponsesResponse {
#[must_use]
pub fn new(inner: models::Response) -> Self {
Self {
inner,
rate_limits: None,
}
}
#[must_use]
pub fn rate_limits(&self) -> Option<crate::RateLimitSnapshot> {
self.rate_limits
}
pub(crate) fn with_rate_limits(
mut self,
rate_limits: Option<crate::RateLimitSnapshot>,
) -> Self {
self.rate_limits = rate_limits;
self
}
#[must_use]
pub fn id(&self) -> &str {
&self.inner.id
}
#[must_use]
pub fn model(&self) -> &str {
&self.inner.model
}
#[must_use]
pub fn status(&self) -> Option<Status> {
self.inner.status
}
#[must_use]
pub fn error(&self) -> Option<&ResponseError> {
self.inner.error.as_ref()
}
#[must_use]
pub fn incomplete_reason(&self) -> Option<String> {
self.inner
.incomplete_details
.as_ref()
.and_then(|details| details.reason)
.map(|reason| reason.to_string())
}
#[must_use]
pub fn output(&self) -> &[OutputItem] {
&self.inner.output
}
#[must_use]
pub fn output_text(&self) -> String {
let mut text = String::new();
for item in &self.inner.output {
if let OutputItem::OutputMessage(message) = item {
for part in &message.content {
if let OutputMessageContent::OutputTextContent(part) = part {
text.push_str(&part.text);
}
}
}
}
text
}
#[must_use]
pub fn refusal(&self) -> Option<&str> {
self.inner.output.iter().find_map(|item| match item {
OutputItem::OutputMessage(message) => {
message.content.iter().find_map(|part| match part {
OutputMessageContent::RefusalContent(refusal) => Some(refusal.refusal.as_str()),
_ => None,
})
}
_ => None,
})
}
#[must_use]
pub fn function_calls(&self) -> Vec<&FunctionToolCall> {
self.inner
.output
.iter()
.filter_map(|item| match item {
OutputItem::FunctionToolCall(call) => Some(call),
_ => None,
})
.collect()
}
#[must_use]
pub fn tool_invocations(&self) -> Vec<ToolInvocation> {
self.inner
.output
.iter()
.filter_map(ToolInvocation::from_output_item)
.collect()
}
#[must_use]
pub fn failure(&self) -> Option<crate::Error> {
(self.inner.status == Some(Status::Failed))
.then(|| super::stream::response_failure(&self.inner))
}
pub fn output_as_input(&self) -> crate::Result<Vec<InputItem>> {
self.inner
.output
.iter()
.map(|item| Ok(serde_json::from_value(serde_json::to_value(item)?)?))
.collect()
}
#[must_use]
pub fn usage(&self) -> Option<&ResponseUsage> {
self.inner.usage.as_ref().and_then(Option::as_ref)
}
#[must_use]
pub fn inner(&self) -> &models::Response {
&self.inner
}
#[must_use]
pub fn into_inner(self) -> models::Response {
self.inner
}
}
impl From<models::Response> for ResponsesResponse {
fn from(inner: models::Response) -> Self {
Self::new(inner)
}
}