added example + improved deserialisation + reability

Signed-off-by: Aminu Oluwaseun Joshua <[email protected]>

Author: seun-ja

crates/llm-remote-http/src/lib.rs

@@ -76,11 +76,17 @@ struct InferResponseBody {
 
 #[derive(Deserialize)]
 struct CreateChatCompletionResponse {
+    #[serde(rename = "id")]
     _id: String,
+    #[serde(rename = "object")]
     _object: String,
+    #[serde(rename = "created")]
     _created: u64,
+    #[serde(rename = "model")]
     _model: String,
+    #[serde(rename = "choices")]
     choices: Vec<ChatCompletionChoice>,
+    #[serde(rename = "usage")]
     usage: CompletionUsage,
 }
 

crates/llm-remote-http/src/open_ai.rs

@@ -1,13 +1,13 @@
 use reqwest::{
     header::{HeaderMap, HeaderValue},
-    Body, Client, Url,
+    Client, Url,
 };
 use serde::Serialize;
 use spin_world::v2::llm::{self as wasi_llm};
 
 use crate::{
-    schema::{EmbeddingModels, EncodingFormat, Model, Prompt, Role},
-    CreateChatCompletionResponse, EmbeddingResponseBody,
+    schema::{EmbeddingModels, EncodingFormat, Model, Prompt, ResponseError, Role},
+    CreateChatCompletionResponse, CreateEmbeddingResponse,
 };
 
 pub(crate) struct OpenAIAgentEngine;
@@ -33,7 +33,7 @@ impl OpenAIAgentEngine {
         spin_telemetry::inject_trace_context(&mut headers);
 
         let chat_url = url
-            .join("/chat/completions")
+            .join("/v1/chat/completions")
             .map_err(|_| wasi_llm::Error::RuntimeError("Failed to create URL".to_string()))?;
 
         tracing::info!("Sending remote inference request to {chat_url}");
@@ -51,15 +51,16 @@ impl OpenAIAgentEngine {
         let resp = client
             .request(reqwest::Method::POST, chat_url)
             .headers(headers)
-            .body(body)
+            .json(&body)
             .send()
             .await
             .map_err(|err| {
                 wasi_llm::Error::RuntimeError(format!("POST /infer request error: {err}"))
             })?;
 
-        match resp.json::<CreateChatCompletionResponse>().await {
-            Ok(val) => Ok(val.into()),
+        match resp.json::<CreateChatCompletionResponses>().await {
+            Ok(CreateChatCompletionResponses::Success(val)) => Ok(val.into()),
+            Ok(CreateChatCompletionResponses::Error { error }) => Err(error.into()),
             Err(err) => Err(wasi_llm::Error::RuntimeError(format!(
                 "Failed to deserialize response for \"POST  /index\": {err}"
             ))),
@@ -95,20 +96,21 @@ impl OpenAIAgentEngine {
         let resp = client
             .request(
                 reqwest::Method::POST,
-                url.join("/embeddings").map_err(|_| {
+                url.join("/v1/embeddings").map_err(|_| {
                     wasi_llm::Error::RuntimeError("Failed to create URL".to_string())
                 })?,
             )
             .headers(headers)
-            .body(body)
+            .json(&body)
             .send()
             .await
             .map_err(|err| {
                 wasi_llm::Error::RuntimeError(format!("POST /embed request error: {err}"))
             })?;
 
-        match resp.json::<EmbeddingResponseBody>().await {
-            Ok(val) => Ok(val.into()),
+        match resp.json::<CreateEmbeddingResponses>().await {
+            Ok(CreateEmbeddingResponses::Success(val)) => Ok(val.into()),
+            Ok(CreateEmbeddingResponses::Error { error }) => Err(error.into()),
             Err(err) => Err(wasi_llm::Error::RuntimeError(format!(
                 "Failed to deserialize response  for \"POST  /embed\": {err}"
             ))),
@@ -130,12 +132,6 @@ struct CreateChatCompletionRequest {
     verbosity: Option<String>,
 }
 
-impl From<CreateChatCompletionRequest> for Body {
-    fn from(val: CreateChatCompletionRequest) -> Self {
-        Body::from(serde_json::to_string(&val).unwrap())
-    }
-}
-
 #[derive(Serialize, Debug)]
 pub struct CreateEmbeddingRequest {
     input: Vec<String>,
@@ -148,8 +144,16 @@ pub struct CreateEmbeddingRequest {
     user: Option<String>,
 }
 
-impl From<CreateEmbeddingRequest> for Body {
-    fn from(val: CreateEmbeddingRequest) -> Self {
-        Body::from(serde_json::to_string(&val).unwrap())
-    }
+#[derive(serde::Deserialize)]
+#[serde(untagged)]
+enum CreateChatCompletionResponses {
+    Success(CreateChatCompletionResponse),
+    Error { error: ResponseError },
+}
+
+#[derive(serde::Deserialize)]
+#[serde(untagged)]
+enum CreateEmbeddingResponses {
+    Success(CreateEmbeddingResponse),
+    Error { error: ResponseError },
 }

crates/llm-remote-http/src/schema.rs

@@ -1,24 +1,36 @@
-use std::fmt::Display;
-
 use serde::{Deserialize, Serialize};
 use spin_world::v2::llm as wasi_llm;
 
 /// LLM model
 #[derive(Serialize, Debug)]
 pub enum Model {
+    #[serde(rename = "gpt-5")]
     GPT5,
+    #[serde(rename = "gpt-5-mini")]
     GPT5Mini,
+    #[serde(rename = "gpt-5-nano")]
     GPT5Nano,
+    #[serde(rename = "gpt-5-chat")]
     GPT5Chat,
+    #[serde(rename = "gpt-4.5")]
     GPT45,
+    #[serde(rename = "gpt-4.1")]
     GPT41,
+    #[serde(rename = "gpt-4.1-mini")]
     GPT41Mini,
+    #[serde(rename = "gpt-4.1-nano")]
     GPT41Nano,
+    #[serde(rename = "gpt-4")]
     GPT4,
+    #[serde(rename = "gpt-4o")]
     GPT4o,
+    #[serde(rename = "gpt-4o-mini")]
     GPT4oMini,
+    #[serde(rename = "o4-mini")]
     O4Mini,
+    #[serde(rename = "o3")]
     O3,
+    #[serde(rename = "o1")]
     O1,
 }
 
@@ -48,27 +60,6 @@ impl TryFrom<&str> for Model {
     }
 }
 
-impl Display for Model {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Model::GPT5 => write!(f, "gpt-5"),
-            Model::GPT5Mini => write!(f, "gpt-5-mini"),
-            Model::GPT5Nano => write!(f, "gpt-5-nano"),
-            Model::GPT5Chat => write!(f, "gpt-5-chat"),
-            Model::GPT45 => write!(f, "gpt-4.5"),
-            Model::GPT41 => write!(f, "gpt-4.1"),
-            Model::GPT41Mini => write!(f, "gpt-4.1-mini"),
-            Model::GPT41Nano => write!(f, "gpt-4.1-nano"),
-            Model::GPT4 => write!(f, "gpt-4"),
-            Model::GPT4o => write!(f, "gpt-4o"),
-            Model::GPT4oMini => write!(f, "gpt-4o-mini"),
-            Model::O4Mini => write!(f, "o4-mini"),
-            Model::O3 => write!(f, "o3"),
-            Model::O1 => write!(f, "o1"),
-        }
-    }
-}
-
 #[derive(Serialize, Debug)]
 pub struct Prompt {
     role: Role,
@@ -83,23 +74,16 @@ impl Prompt {
 
 #[derive(Serialize, Debug)]
 pub enum Role {
+    #[serde(rename = "system")]
     System,
+    #[serde(rename = "user")]
     User,
+    #[serde(rename = "assistant")]
     Assistant,
+    #[serde(rename = "tool")]
     Tool,
 }
 
-impl Display for Role {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Role::System => write!(f, "system"),
-            Role::User => write!(f, "user"),
-            Role::Assistant => write!(f, "assistant"),
-            Role::Tool => write!(f, "tool"),
-        }
-    }
-}
-
 impl TryFrom<&str> for Role {
     type Error = wasi_llm::Error;
 
@@ -118,19 +102,12 @@ impl TryFrom<&str> for Role {
 
 #[derive(Serialize, Debug)]
 pub enum EncodingFormat {
+    #[serde(rename = "float")]
     Float,
+    #[serde(rename = "base64")]
     Base64,
 }
 
-impl Display for EncodingFormat {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            EncodingFormat::Float => write!(f, "float"),
-            EncodingFormat::Base64 => write!(f, "base64"),
-        }
-    }
-}
-
 impl TryFrom<&str> for EncodingFormat {
     type Error = wasi_llm::Error;
 
@@ -147,23 +124,15 @@ impl TryFrom<&str> for EncodingFormat {
 
 #[derive(Serialize, Debug)]
 pub enum EmbeddingModels {
+    #[serde(rename = "text-embedding-ada-002")]
     TextEmbeddingAda002,
+    #[serde(rename = "text-embedding-3-small")]
     TextEmbedding3Small,
+    #[serde(rename = "text-embedding-3-large")]
     TextEmbedding3Large,
     Custom(String),
 }
 
-impl Display for EmbeddingModels {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            EmbeddingModels::TextEmbeddingAda002 => write!(f, "text-embedding-ada-002"),
-            EmbeddingModels::TextEmbedding3Small => write!(f, "text-embedding-3-small"),
-            EmbeddingModels::TextEmbedding3Large => write!(f, "text-embedding-3-large"),
-            EmbeddingModels::Custom(model) => write!(f, "{model}"),
-        }
-    }
-}
-
 impl TryFrom<&str> for EmbeddingModels {
     type Error = wasi_llm::Error;
 
@@ -179,23 +148,16 @@ impl TryFrom<&str> for EmbeddingModels {
 
 #[derive(Serialize, Debug)]
 enum ReasoningEffort {
+    #[serde(rename = "minimal")]
     Minimal,
+    #[serde(rename = "low")]
     Low,
+    #[serde(rename = "medium")]
     Medium,
+    #[serde(rename = "high")]
     High,
 }
 
-impl Display for ReasoningEffort {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ReasoningEffort::Minimal => write!(f, "minimal"),
-            ReasoningEffort::Low => write!(f, "low"),
-            ReasoningEffort::Medium => write!(f, "medium"),
-            ReasoningEffort::High => write!(f, "high"),
-        }
-    }
-}
-
 impl TryFrom<&str> for ReasoningEffort {
     type Error = wasi_llm::Error;
 
@@ -236,42 +198,68 @@ impl TryFrom<&str> for Verbosity {
 
 #[derive(Deserialize)]
 pub struct ChatCompletionChoice {
+    #[serde(rename = "index")]
     /// The index of the choice in the list of choices
     _index: u32,
     pub message: ChatCompletionResponseMessage,
     /// The reason the model stopped generating tokens. This will be `stop` if the model hit a
     /// natural stop point or a provided stop sequence,
+    #[serde(rename = "finish_reason")]
     _finish_reason: String,
     /// Log probability information for the choice.
+    #[serde(rename = "logprobs")]
     _logprobs: Option<Logprobs>,
 }
 
 #[derive(Deserialize)]
 /// A chat completion message generated by the model.
 pub struct ChatCompletionResponseMessage {
     /// The role of the author of this message
+    #[serde(rename = "role")]
     _role: String,
     /// The contents of the message
     pub content: String,
     /// The refusal message generated by the model
+    #[serde(rename = "refusal")]
     _refusal: Option<String>,
 }
 
 #[derive(Deserialize)]
 pub struct Logprobs {
     /// A list of message content tokens with log probability information.
+    #[serde(rename = "content")]
     _content: Option<Vec<String>>,
     /// A list of message refusal tokens with log probability information.
+    #[serde(rename = "refusal")]
     _refusal: Option<Vec<String>>,
 }
 
 #[derive(Deserialize)]
 pub struct Embedding {
     /// The index of the embedding in the list of embeddings..
+    #[serde(rename = "index")]
     _index: u32,
     /// The embedding vector, which is a list of floats. The length of vector depends on the model as
     /// listed in the [embedding guide](https://platform.openai.com/docs/guides/embeddings).
     pub embedding: Vec<f32>,
     /// The object type, which is always "embedding"
+    #[serde(rename = "object")]
     _object: String,
 }
+
+#[derive(Deserialize, Default)]
+pub struct ResponseError {
+    pub message: String,
+    #[serde(rename = "type")]
+    _t: String,
+    #[serde(rename = "param")]
+    _param: Option<String>,
+    #[serde(rename = "code")]
+    _code: String,
+}
+
+impl From<ResponseError> for wasi_llm::Error {
+    fn from(value: ResponseError) -> Self {
+        wasi_llm::Error::RuntimeError(value.message)
+    }
+}

examples/open-ai-rust/.gitignore

@@ -0,0 +1,2 @@
+target/
+.spin/