liter_llm 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b6cf155e1ca65bf3dc5166f8f59178a8580cdd9cd6f9f4a1f3dde0ecc5385be
-  data.tar.gz: 07b5f2e4f5ecb3bf1e3bff6dda1cd9c261cb4a6198b727a2ecfe0ac9d97ab55c
+  metadata.gz: 7c5ff27da16bef518f0774730ea20b7365795a36ab51504e8e141be7c8ee0702
+  data.tar.gz: 6418ff93511a905374dcdd40767821f50f333a058684ef8379bc21357d17a71c
 SHA512:
-  metadata.gz: 8b82f5e04d2eaee3b096c61c199dd9b17463989c1ce11665d65a2258e34fbc92ac545b22d6632d5426275137c33b32c9253382b0025e3a427d82755eea1cf43e
-  data.tar.gz: d530111003fbd0f490264f52e76a2e34ca76072508cd30446b617f58797a2d76b345e029b6ed57301d9c4e475b910ff4cbf3c993f6075ed2cef95b451a84bfbf
+  metadata.gz: ce2371e26960cb849413bf447cd50ec6e985a370d2d663ae23f1c6aa6f5b7d2a38f69c9268b857513d31cdb88cd1abcc6b766c40845aa4cdea34a434c2a9ab50
+  data.tar.gz: 556703afe772088cc18963f308c189ccf146e8f789fe154822e3edcbb97c692220529d36a3d37d9d0a4f5604942e2454a1ac5d8ab1faf182ae61091ac08ef5e4

data/ext/liter_llm_rb/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "liter-llm-rb"
-version = "1.2.0"
+version = "1.2.1"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
 license = "MIT"

data/vendor/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["liter-llm", "liter-llm-ffi"]
 
 [workspace.package]
-version = "1.2.0"
+version = "1.2.1"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
 license = "MIT"
@@ -19,7 +19,7 @@ clap = { version = "4", features = ["derive", "env"] }
 dashmap = "6"
 futures-core = "0.3"
 futures-util = "0.3"
-jsonschema = "0.45"
+jsonschema = "0.46"
 jsonwebtoken = { version = "10", features = ["use_pem"], default-features = false }
 magnus = "0.8"
 memchr = "2"
@@ -34,7 +34,7 @@ pyo3-async-runtimes = { version = "0.28", features = ["tokio-runtime"] }
 rayon = "1"
 rb-sys = "0.9"
 reqwest = { version = "0.13", features = ["json", "stream", "rustls", "multipart", "form"], default-features = false }
-rmcp = { version = "1.3", features = ["server", "macros", "transport-io", "transport-streamable-http-server", "server-side-http"] }
+rmcp = { version = "1.5", features = ["server", "macros", "transport-io", "transport-streamable-http-server", "server-side-http"] }
 rustler = "0.37"
 schemars = "1"
 secrecy = { version = "0.10", features = ["serde"] }

data/vendor/liter-llm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "liter-llm"
-version = "1.2.0"
+version = "1.2.1"
 edition = "2024"
 license = "MIT"
 repository.workspace = true
@@ -89,6 +89,6 @@ tracing-opentelemetry = { version = "0.32", optional = true }
 
 [dev-dependencies]
 futures-util = "0.3"
-jsonschema = "0.45"
+jsonschema = "0.46"
 serial_test = "3"
 tokio = { version = "1", features = ["test-util", "macros"] }

data/vendor/liter-llm/src/client/mod.rs

@@ -17,6 +17,7 @@ use crate::types::files::{CreateFileRequest, DeleteResponse, FileListQuery, File
 use crate::types::image::{CreateImageRequest, ImagesResponse};
 use crate::types::moderation::{ModerationRequest, ModerationResponse};
 use crate::types::ocr::{OcrRequest, OcrResponse};
+use crate::types::raw::{RawExchange, RawStreamExchange};
 use crate::types::rerank::{RerankRequest, RerankResponse};
 use crate::types::responses::{CreateResponseRequest, ResponseObject};
 use crate::types::search::{SearchRequest, SearchResponse};
@@ -112,6 +113,53 @@ pub trait LlmClient: Send + Sync {
     fn ocr(&self, req: OcrRequest) -> BoxFuture<'_, OcrResponse>;
 }
 
+/// Extension of [`LlmClient`] that returns raw request/response data
+/// alongside the typed response.
+///
+/// Every `_raw` method mirrors its counterpart on [`LlmClient`] but wraps the
+/// result in a [`RawExchange`] that exposes the final request body (after
+/// `transform_request`) and the raw provider response (before
+/// `transform_response`). This is useful for debugging provider-specific
+/// transformations, capturing wire-level data, or implementing custom parsing.
+pub trait LlmClientRaw: LlmClient {
+    /// Send a chat completion request and return the raw exchange.
+    ///
+    /// The `raw_request` field contains the final JSON body sent to the
+    /// provider; `raw_response` contains the provider JSON before
+    /// normalization.
+    fn chat_raw(&self, req: ChatCompletionRequest) -> BoxFuture<'_, RawExchange<ChatCompletionResponse>>;
+
+    /// Send a streaming chat completion request and return the raw exchange.
+    ///
+    /// Only `raw_request` is available upfront — the stream itself is
+    /// returned in `stream` and consumed incrementally.
+    fn chat_stream_raw(
+        &self,
+        req: ChatCompletionRequest,
+    ) -> BoxFuture<'_, RawStreamExchange<BoxStream<'_, ChatCompletionChunk>>>;
+
+    /// Send an embedding request and return the raw exchange.
+    fn embed_raw(&self, req: EmbeddingRequest) -> BoxFuture<'_, RawExchange<EmbeddingResponse>>;
+
+    /// Generate an image and return the raw exchange.
+    fn image_generate_raw(&self, req: CreateImageRequest) -> BoxFuture<'_, RawExchange<ImagesResponse>>;
+
+    /// Transcribe audio to text and return the raw exchange.
+    fn transcribe_raw(&self, req: CreateTranscriptionRequest) -> BoxFuture<'_, RawExchange<TranscriptionResponse>>;
+
+    /// Check content against moderation policies and return the raw exchange.
+    fn moderate_raw(&self, req: ModerationRequest) -> BoxFuture<'_, RawExchange<ModerationResponse>>;
+
+    /// Rerank documents by relevance to a query and return the raw exchange.
+    fn rerank_raw(&self, req: RerankRequest) -> BoxFuture<'_, RawExchange<RerankResponse>>;
+
+    /// Perform a web/document search and return the raw exchange.
+    fn search_raw(&self, req: SearchRequest) -> BoxFuture<'_, RawExchange<SearchResponse>>;
+
+    /// Extract text from a document via OCR and return the raw exchange.
+    fn ocr_raw(&self, req: OcrRequest) -> BoxFuture<'_, RawExchange<OcrResponse>>;
+}
+
 /// File management operations (upload, list, retrieve, delete).
 pub trait FileClient: Send + Sync {
     /// Upload a file.
@@ -788,6 +836,390 @@ impl LlmClient for DefaultClient {
     }
 }
 
+#[cfg(feature = "native-http")]
+impl LlmClientRaw for DefaultClient {
+    fn chat_raw(&self, req: ChatCompletionRequest) -> BoxFuture<'_, RawExchange<ChatCompletionResponse>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.chat_completions_path(), &req.model, Some(false))?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<ChatCompletionResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn chat_stream_raw(
+        &self,
+        req: ChatCompletionRequest,
+    ) -> BoxFuture<'_, RawStreamExchange<BoxStream<'_, ChatCompletionChunk>>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.chat_completions_path(), &req.model, Some(true))?;
+            let raw_request = prepared.body_json.clone();
+
+            let bare_model = prepared.provider.strip_model_prefix(&req.model);
+            let url = prepared
+                .provider
+                .build_stream_url(prepared.provider.chat_completions_path(), bare_model);
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+            let auth = auth_header.as_ref().map(str_pair);
+
+            let stream = match prepared.provider.stream_format() {
+                provider::StreamFormat::Sse => {
+                    let provider = Arc::clone(&prepared.provider);
+                    let parse_event = move |data: &str| provider.parse_stream_event(data);
+                    http::streaming::post_stream(
+                        &self.http,
+                        &url,
+                        auth,
+                        &extra,
+                        prepared.body_bytes,
+                        self.config.max_retries,
+                        parse_event,
+                    )
+                    .await?
+                }
+                provider::StreamFormat::AwsEventStream => {
+                    http::eventstream::post_eventstream(
+                        &self.http,
+                        &url,
+                        auth,
+                        &extra,
+                        prepared.body_bytes,
+                        self.config.max_retries,
+                        provider::bedrock::parse_bedrock_stream_event,
+                    )
+                    .await?
+                }
+            };
+
+            Ok(RawStreamExchange { stream, raw_request })
+        })
+    }
+
+    fn embed_raw(&self, req: EmbeddingRequest) -> BoxFuture<'_, RawExchange<EmbeddingResponse>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.embeddings_path(), &req.model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<EmbeddingResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn image_generate_raw(&self, req: CreateImageRequest) -> BoxFuture<'_, RawExchange<ImagesResponse>> {
+        Box::pin(async move {
+            let model = req.model.as_deref().unwrap_or_default();
+            let prepared = self.prepare_request(&req, |p| p.image_generations_path(), model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<ImagesResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn transcribe_raw(&self, req: CreateTranscriptionRequest) -> BoxFuture<'_, RawExchange<TranscriptionResponse>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.audio_transcriptions_path(), &req.model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<TranscriptionResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn moderate_raw(&self, req: ModerationRequest) -> BoxFuture<'_, RawExchange<ModerationResponse>> {
+        Box::pin(async move {
+            let model = req.model.as_deref().unwrap_or_default();
+            let prepared = self.prepare_request(&req, |p| p.moderations_path(), model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<ModerationResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn rerank_raw(&self, req: RerankRequest) -> BoxFuture<'_, RawExchange<RerankResponse>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.rerank_path(), &req.model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<RerankResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn search_raw(&self, req: SearchRequest) -> BoxFuture<'_, RawExchange<SearchResponse>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.search_path(), &req.model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<SearchResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+
+    fn ocr_raw(&self, req: OcrRequest) -> BoxFuture<'_, RawExchange<OcrResponse>> {
+        Box::pin(async move {
+            let prepared = self.prepare_request(&req, |p| p.ocr_path(), &req.model, None)?;
+            let raw_request = prepared.body_json.clone();
+
+            let auth_header = self
+                .resolve_auth_header_for_provider(prepared.provider.as_ref())
+                .await?;
+            let all_headers = self.all_headers_for_provider(
+                prepared.provider.as_ref(),
+                "POST",
+                &prepared.url,
+                &prepared.body_json,
+                &prepared.body_bytes,
+            );
+            let extra: Vec<(&str, &str)> = all_headers.iter().map(|(n, v)| (n.as_str(), v.as_str())).collect();
+
+            let auth = auth_header.as_ref().map(str_pair);
+            let mut raw = http::request::post_json_raw(
+                &self.http,
+                &prepared.url,
+                auth,
+                &extra,
+                prepared.body_bytes,
+                self.config.max_retries,
+            )
+            .await?;
+
+            let raw_response = Some(raw.clone());
+            prepared.provider.transform_response(&mut raw)?;
+            let data = serde_json::from_value::<OcrResponse>(raw).map_err(LiterLlmError::from)?;
+
+            Ok(RawExchange {
+                data,
+                raw_request,
+                raw_response,
+            })
+        })
+    }
+}
+
 #[cfg(feature = "native-http")]
 impl FileClient for DefaultClient {
     fn create_file(&self, req: CreateFileRequest) -> BoxFuture<'_, FileObject> {

data/vendor/liter-llm/src/lib.rs

@@ -20,7 +20,7 @@ pub mod types;
 // Re-export key types at crate root.
 pub use client::{
     BatchClient, BoxFuture, BoxStream, ClientConfig, ClientConfigBuilder, FileClient, FileConfig, LlmClient,
-    ResponseClient,
+    LlmClientRaw, ResponseClient,
 };
 // DefaultClient requires the native HTTP stack (reqwest + tokio).
 #[cfg(feature = "native-http")]

data/vendor/liter-llm/src/provider/bedrock.rs

@@ -917,7 +917,10 @@ mod tests {
     // ── build_url ─────────────────────────────────────────────────────────────
 
     #[test]
+    #[serial]
     fn build_url_chat_completions() {
+        // SAFETY: env vars are process-global; `#[serial]` ensures no parallel mutation.
+        unsafe { std::env::remove_var("BEDROCK_CROSS_REGION") };
         let p = provider();
         let url = p.build_url("/chat/completions", "anthropic.claude-3-sonnet-20240229-v1:0");
         // Colon must be uppercase-encoded per RFC 3986 §2.1.
@@ -928,7 +931,10 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn build_url_embeddings() {
+        // SAFETY: env vars are process-global; `#[serial]` ensures no parallel mutation.
+        unsafe { std::env::remove_var("BEDROCK_CROSS_REGION") };
         let p = provider();
         let url = p.build_url("/embeddings", "amazon.titan-embed-text-v1");
         assert_eq!(
@@ -938,7 +944,10 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn build_url_other_path() {
+        // SAFETY: env vars are process-global; `#[serial]` ensures no parallel mutation.
+        unsafe { std::env::remove_var("BEDROCK_CROSS_REGION") };
         let p = provider();
         let url = p.build_url("/models", "any-model");
         assert_eq!(url, "https://bedrock-runtime.us-east-1.amazonaws.com/models");

data/vendor/liter-llm/src/types/mod.rs

@@ -8,6 +8,7 @@ pub mod image;
 pub mod models;
 pub mod moderation;
 pub mod ocr;
+pub mod raw;
 pub mod rerank;
 pub mod responses;
 pub mod search;
@@ -22,6 +23,7 @@ pub use image::*;
 pub use models::*;
 pub use moderation::*;
 pub use ocr::*;
+pub use raw::*;
 pub use rerank::*;
 pub use responses::*;
 pub use search::*;

data/vendor/liter-llm/src/types/raw.rs

@@ -0,0 +1,29 @@
+/// The raw request and response JSON exchanged with the provider,
+/// paired with the typed (normalized) response.
+///
+/// Returned by every `_raw` method on [`crate::LlmClientRaw`]. Useful for
+/// debugging provider-specific transformations or implementing custom parsing.
+#[derive(Debug, Clone)]
+pub struct RawExchange<T> {
+    /// The typed, normalized response.
+    pub data: T,
+    /// The final request body sent to the provider (after `transform_request`).
+    pub raw_request: serde_json::Value,
+    /// The raw response body from the provider, before `transform_response`.
+    /// `None` for binary endpoints (speech) or when not applicable.
+    pub raw_response: Option<serde_json::Value>,
+}
+
+/// Raw exchange data for streaming responses.
+///
+/// Returned by [`crate::LlmClientRaw::chat_stream_raw`]. The stream itself is
+/// not captured in its entirety — only the request body is available upfront.
+/// `RawStreamExchange` intentionally does not implement `Clone` because streams
+/// cannot be duplicated.
+#[derive(Debug)]
+pub struct RawStreamExchange<S> {
+    /// The chunk stream, unchanged.
+    pub stream: S,
+    /// The final request body sent to the provider.
+    pub raw_request: serde_json::Value,
+}

data/vendor/liter-llm-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "liter-llm-ffi"
-version = "1.2.0"
+version = "1.2.1"
 edition = "2024"
 license = "MIT"
 repository.workspace = true
@@ -20,8 +20,8 @@ default = []
 base64.workspace = true
 bytes.workspace = true
 futures-core.workspace = true
-liter-llm = { path = "../liter-llm", version = "1.2.0", features = ["full"] }
-liter-llm-bindings-core = { path = "../liter-llm-bindings-core", version = "1.2.0" }
+liter-llm = { path = "../liter-llm", version = "1.2.1", features = ["full"] }
+liter-llm-bindings-core = { path = "../liter-llm-bindings-core", version = "1.2.1" }
 serde.workspace = true
 serde_json.workspace = true
 tokio.workspace = true

data/vendor/liter-llm-ffi/liter_llm.h

@@ -9,8 +9,8 @@
 
 #define LITER_LLM_VERSION_MAJOR 1
 #define LITER_LLM_VERSION_MINOR 2
-#define LITER_LLM_VERSION_PATCH 0
-#define LITER_LLM_VERSION "1.2.0"
+#define LITER_LLM_VERSION_PATCH 1
+#define LITER_LLM_VERSION "1.2.1"
 
 
 #include <stdarg.h>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: liter_llm
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -248,6 +248,7 @@ files:
 - vendor/liter-llm/src/types/models.rs
 - vendor/liter-llm/src/types/moderation.rs
 - vendor/liter-llm/src/types/ocr.rs
+- vendor/liter-llm/src/types/raw.rs
 - vendor/liter-llm/src/types/rerank.rs
 - vendor/liter-llm/src/types/responses.rs
 - vendor/liter-llm/src/types/search.rs