Update chatgpt support

Author: unsecretised

oneAI-backend/src/pricing.rs

@@ -110,16 +110,16 @@ impl Model {
             // ==== OpenAI ====
             Model::Gpt4_1 => "gpt-4.1",
             Model::Gpt4_1Mini => "gpt-4.1-mini",
-            Model::Gpt4_1Nano => "gpt-4.1-nano",
-            Model::GptO3 => "gpt-o3",
-            Model::GptO4Mini => "gpt-o4-mini",
-            Model::GptO3Pro => "gpt-o3-pro",
+            Model::Gpt4_1Nano => "4.1-nano",
+            Model::GptO3 => "o3",
+            Model::GptO4Mini => "o4-mini",
+            Model::GptO3Pro => "o3-pro",
             Model::Gpt4o => "gpt-4o",
             Model::Gpt4oMini => "gpt-4o-mini",
-            Model::GptO1 => "gpt-o1",
-            Model::GptO3DeepResearch => "gpt-o3-DeepResearch",
-            Model::GptO3Mini => "gpt-o3-mini",
-            Model::GptO1Mini => "gpt-o1-mini",
+            Model::GptO1 => "o1",
+            Model::GptO3DeepResearch => "o3-DeepResearch",
+            Model::GptO3Mini => "o3-mini",
+            Model::GptO1Mini => "o1-mini",
 
             // ==== Anthropic ====
             Model::ClaudeOpus4 => "Opus-4",

oneAI-backend/src/requests/parseapi.rs

@@ -109,7 +109,7 @@ impl APIInput {
                     "model": self.model.name(),
                     "messages": self.messages,
                     "temperature": self.temperature,
-                    "max_tokens": maxtoken,
+                    "max_completion_tokens": maxtoken,
                     "top_p": self.top_p,
                     "stop": self.stop_sequences,
                     "stream": self.stream,

oneAI-backend/src/requests/requests.rs

@@ -84,6 +84,7 @@ impl APIInput {
         let total: u32;
         let unified_response: LlmUnifiedResponse = match self.model.provider() {
             AIProvider::OpenAI => {
+                println!("output: {:#?}", output);
                 let openai: OpenAIResponse = from_str(&output?)?;
                 total = openai.usage.total_tokens;
                 openai.into()

oneAI-backend/src/requests/responseparser/openai.rs

@@ -5,36 +5,43 @@ use serde::{Deserialize, Serialize};
 pub struct OpenAIResponse {
     pub id: String,
     pub object: String,
+    #[serde(rename = "created")]
     pub created_at: u64,
-    pub status: String,
-    pub error: Option<serde_json::Value>,
-    pub incomplete_details: Option<serde_json::Value>,
-    pub instructions: Option<serde_json::Value>,
-    pub max_output_tokens: Option<serde_json::Value>,
     pub model: String,
-    pub output: Vec<OpenAIOutput>,
-    pub parallel_tool_calls: bool,
-    pub previous_response_id: Option<String>,
-    pub reasoning: OpenAIReasoning,
-    pub store: bool,
-    pub temperature: f64,
-    pub text: OpenAITextField,
-    pub tool_choice: String,
-    pub tools: Vec<serde_json::Value>,
-    pub top_p: f64,
-    pub truncation: String,
+    pub choices: Vec<OpenAIOutput>,
     pub usage: OpenAIUsage,
-    pub user: Option<serde_json::Value>,
-    pub metadata: OpenAIMetadata,
+    // Optional fields for completeness
+    pub service_tier: Option<String>,
+    pub system_fingerprint: Option<String>,
 }
-
 #[derive(Debug, Serialize, Deserialize)]
 pub struct OpenAIOutput {
-    pub r#type: String,
-    pub id: String,
-    pub status: String,
+    pub index: u32,
+    pub finish_reason: Option<String>,
+    pub message: OpenAIMessage,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct OpenAIUsage {
+    pub prompt_tokens: u32,
+    pub completion_tokens: u32,
+    pub total_tokens: u32,
+    #[serde(default)]
+    pub prompt_tokens_details: OpenAIInputTokensDetails,
+    #[serde(default)]
+    pub completion_tokens_details: OpenAIOutputTokensDetails,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct OpenAIMessage {
     pub role: String,
-    pub content: Vec<OpenAIContent>,
+    pub content: String,
+    pub refusal: Option<serde_json::Value>,
+    pub function_call: Option<serde_json::Value>,
+    pub tool_calls: Option<Vec<serde_json::Value>>,
+    pub parsed: Option<serde_json::Value>,
+    #[serde(default)]
+    pub annotations: Vec<serde_json::Value>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -44,64 +51,63 @@ pub struct OpenAIContent {
     pub annotations: Vec<serde_json::Value>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct OpenAIReasoning {
     pub effort: Option<serde_json::Value>,
     pub summary: Option<serde_json::Value>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct OpenAITextField {
     pub format: OpenAIFormat,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct OpenAIFormat {
+    #[serde(rename = "type")]
     pub r#type: String,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct OpenAIUsage {
-    pub input_tokens: u32,
-    pub input_tokens_details: OpenAIInputTokensDetails,
-    pub output_tokens: u32,
-    pub output_tokens_details: OpenAIOutputTokensDetails,
-    pub total_tokens: u32,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct OpenAIInputTokensDetails {
     pub cached_tokens: u32,
+    pub audio_tokens: Option<u32>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct OpenAIOutputTokensDetails {
     pub reasoning_tokens: u32,
+    pub audio_tokens: Option<u32>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct OpenAIMetadata {} // Empty object
 
 impl From<OpenAIResponse> for LlmUnifiedResponse {
     fn from(res: OpenAIResponse) -> Self {
-        let content = res
-            .output
-            .iter()
-            .flat_map(|out| out.content.iter().map(|c| c.text.clone()))
-            .collect::<Vec<_>>()
-            .join("\n");
+        let first = res.choices.get(0);
+
+        let content = first
+            .map(|c| c.message.content.clone())
+            .unwrap_or_default();
+
+        let role = first
+            .map(|c| c.message.role.clone());
+
+        let finish_reason = first
+            .and_then(|c| c.finish_reason.clone());
 
         LlmUnifiedResponse {
             provider: "OpenAI".into(),
             model: res.model,
-            role: res.output.get(0).map(|o| o.role.clone()),
+            role,
             content,
             usage: Some(LlmUsage {
-                input_tokens: Some(res.usage.input_tokens),
-                output_tokens: Some(res.usage.output_tokens),
+                input_tokens: Some(res.usage.prompt_tokens),
+                output_tokens: Some(res.usage.completion_tokens),
                 total_tokens: Some(res.usage.total_tokens),
             }),
-            finish_reason: Some(res.status), // e.g. "completed"
+            finish_reason,
         }
     }
 }