quick fix for OpenAI

Author: noise64

llm/openai/src/client.rs

@@ -1,6 +1,6 @@
 use golem_llm::error::{error_code_from_status, from_event_source_error, from_reqwest_error};
 use golem_llm::event_source::EventSource;
-use golem_llm::golem::llm::llm::Error;
+use golem_llm::golem::llm::llm::{Error, ErrorCode};
 use log::trace;
 use reqwest::header::HeaderValue;
 use reqwest::{Client, Method, Response};
@@ -97,7 +97,7 @@ pub struct CreateModelResponseResponse {
     pub error: Option<ErrorObject>,
     pub incomplete_details: Option<IncompleteDetailsObject>,
     pub status: Status,
-    pub output: Vec<OutputItem>,
+    pub output: Vec<OpenOutputItem>,
     pub usage: Option<Usage>,
     pub metadata: Option<serde_json::Value>,
 }
@@ -122,6 +122,13 @@ pub enum OutputItem {
     },
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum OpenOutputItem {
+    Known(OutputItem),
+    Other(serde_json::Value),
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type")]
 pub enum OutputMessageContent {
@@ -273,9 +280,15 @@ pub struct ResponseOutputItemDone {
 fn parse_response<T: DeserializeOwned + Debug>(response: Response) -> Result<T, Error> {
     let status = response.status();
     if status.is_success() {
-        let body = response
-            .json::<T>()
-            .map_err(|err| from_reqwest_error("Failed to decode response body", err))?;
+        let body_text = response
+            .text()
+            .map_err(|err| from_reqwest_error("Failed to receive response body", err))?;
+
+        let body = serde_json::from_str::<T>(&body_text).map_err(|err| Error {
+            code: ErrorCode::InvalidRequest,
+            message: format!("Failed to decode response body: {}", err),
+            provider_error_json: Some(body_text),
+        })?;
 
         trace!("Received response from OpenAI API: {body:?}");
 

llm/openai/src/conversions.rs

@@ -1,13 +1,14 @@
 use crate::client::{
     CreateModelResponseRequest, CreateModelResponseResponse, Detail, InnerInput, InnerInputItem,
-    Input, InputItem, OutputItem, OutputMessageContent, Tool,
+    Input, InputItem, OpenOutputItem, OutputItem, OutputMessageContent, Tool,
 };
 use base64::{engine::general_purpose, Engine as _};
 use golem_llm::error::error_code_from_status;
 use golem_llm::golem::llm::llm::{
     Config, ContentPart, Error, ErrorCode, Event, ImageDetail, ImageReference, Message, Response,
     ResponseMetadata, Role, ToolCall, ToolDefinition, ToolResult, Usage,
 };
+use log::trace;
 use reqwest::StatusCode;
 use std::collections::HashMap;
 use std::str::FromStr;
@@ -221,30 +222,35 @@ pub fn process_model_response(response: CreateModelResponseResponse) -> Result<R
 
         for output_item in response.output {
             match output_item {
-                OutputItem::Message { content, .. } => {
-                    for content in content {
-                        match content {
-                            OutputMessageContent::Text { text, .. } => {
-                                contents.push(ContentPart::Text(text));
-                            }
-                            OutputMessageContent::Refusal { refusal, .. } => {
-                                contents.push(ContentPart::Text(format!("Refusal: {refusal}")));
+                OpenOutputItem::Known(output_item) => match output_item {
+                    OutputItem::Message { content, .. } => {
+                        for content in content {
+                            match content {
+                                OutputMessageContent::Text { text, .. } => {
+                                    contents.push(ContentPart::Text(text));
+                                }
+                                OutputMessageContent::Refusal { refusal, .. } => {
+                                    contents.push(ContentPart::Text(format!("Refusal: {refusal}")));
+                                }
                             }
                         }
                     }
-                }
-                OutputItem::ToolCall {
-                    arguments,
-                    call_id,
-                    name,
-                    ..
-                } => {
-                    let tool_call = ToolCall {
-                        id: call_id,
+                    OutputItem::ToolCall {
+                        arguments,
+                        call_id,
                         name,
-                        arguments_json: arguments,
-                    };
-                    tool_calls.push(tool_call);
+                        ..
+                    } => {
+                        let tool_call = ToolCall {
+                            id: call_id,
+                            name,
+                            arguments_json: arguments,
+                        };
+                        tool_calls.push(tool_call);
+                    }
+                },
+                OpenOutputItem::Other(value) => {
+                    trace!("Ignoring unknown output item: {value:?}");
                 }
             }
         }