liter_llm 1.1.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87c0ce7287f3e000b825d496b84662586cb3d8899f11a9f7a8bac55587ddc26c
-  data.tar.gz: 5099baea9360fb98d4949324773b9ef5b3dafc870150f1992f3887162b79994e
+  metadata.gz: 7c5ff27da16bef518f0774730ea20b7365795a36ab51504e8e141be7c8ee0702
+  data.tar.gz: 6418ff93511a905374dcdd40767821f50f333a058684ef8379bc21357d17a71c
 SHA512:
-  metadata.gz: 9452263146c7206ebad3b3ca9b0bc163e251ad832b3b4b4b7352132356e59d29779f2741ebe095607a3cdf7a668ff3eb5cf7ae0b2e6593a043e1f92922761897
-  data.tar.gz: 991f0752533062901b10252157ff0c4fa9e6e69bb69ee5e8218e2124ed70d01cc84c51a1a469ef2a167504b6ff369239712116ed80e1873fb0d662da8c9d3bdd
+  metadata.gz: ce2371e26960cb849413bf447cd50ec6e985a370d2d663ae23f1c6aa6f5b7d2a38f69c9268b857513d31cdb88cd1abcc6b766c40845aa4cdea34a434c2a9ab50
+  data.tar.gz: 556703afe772088cc18963f308c189ccf146e8f789fe154822e3edcbb97c692220529d36a3d37d9d0a4f5604942e2454a1ac5d8ab1faf182ae61091ac08ef5e4

data/README.md

@@ -35,6 +35,9 @@
   <a href="https://github.com/kreuzberg-dev/liter-llm/pkgs/container/liter-llm">
     <img src="https://img.shields.io/badge/Docker-007ec6?logo=docker&logoColor=white" alt="Docker">
   </a>
+  <a href="https://github.com/kreuzberg-dev/homebrew-tap/blob/main/Formula/liter-llm.rb">
+    <img src="https://img.shields.io/badge/Homebrew-007ec6?logo=homebrew&logoColor=white" alt="Homebrew">
+  </a>
   <a href="https://github.com/kreuzberg-dev/liter-llm/tree/main/crates/liter-llm-ffi">
     <img src="https://img.shields.io/badge/C-FFI-007ec6" alt="C FFI">
   </a>
@@ -63,7 +66,7 @@
 </div>
 
 
-Universal LLM API client for Ruby. Access 142+ LLM providers through a single interface with idiomatic Ruby API and native performance.
+Universal LLM API client for Ruby. Access 143+ LLM providers through a single interface with idiomatic Ruby API and native performance.
 
 
 ## Installation
@@ -161,7 +164,7 @@ chunks.each { |chunk| puts chunk }
 
 ## Features
 
-### Supported Providers (142+)
+### Supported Providers (143+)
 
 Route to any provider using the `provider/model` prefix convention:
 
@@ -181,7 +184,8 @@ Route to any provider using the `provider/model` prefix convention:
 
 ### Key Capabilities
 
-- **Provider Routing** -- Single client for 142+ LLM providers via `provider/model` prefix
+- **Provider Routing** -- Single client for 143+ LLM providers via `provider/model` prefix
+- **Local LLMs** — Connect to locally-hosted models via Ollama, LM Studio, vLLM, llama.cpp, and other local inference servers
 - **Unified API** -- Consistent `chat`, `chat_stream`, `embeddings`, `list_models` interface
 
 - **Streaming** -- Real-time token streaming via `chat_stream`
@@ -207,7 +211,7 @@ Built on a compiled Rust core for speed and safety:
 
 ## Provider Routing
 
-Route to 142+ providers using the `provider/model` prefix convention:
+Route to 143+ providers using the `provider/model` prefix convention:
 
 ```text
 openai/gpt-4o
@@ -235,7 +239,7 @@ See the [proxy server documentation](https://docs.liter-llm.kreuzberg.dev/server
 
 - **[Documentation](https://docs.liter-llm.kreuzberg.dev)** -- Full docs and API reference
 - **[GitHub Repository](https://github.com/kreuzberg-dev/liter-llm)** -- Source, issues, and discussions
-- **[Provider Registry](https://github.com/kreuzberg-dev/liter-llm/blob/main/schemas/providers.json)** -- 142 supported providers
+- **[Provider Registry](https://github.com/kreuzberg-dev/liter-llm/blob/main/schemas/providers.json)** -- 143 supported providers
 
 Part of [kreuzberg.dev](https://kreuzberg.dev).
 

data/ext/liter_llm_rb/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "liter-llm-rb"
-version = "1.1.1"
+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.1.1"
+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.1.1"
+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/README.md

@@ -35,6 +35,9 @@
   <a href="https://github.com/kreuzberg-dev/liter-llm/pkgs/container/liter-llm">
     <img src="https://img.shields.io/badge/Docker-007ec6?logo=docker&logoColor=white" alt="Docker">
   </a>
+  <a href="https://github.com/kreuzberg-dev/homebrew-tap/blob/main/Formula/liter-llm.rb">
+    <img src="https://img.shields.io/badge/Homebrew-007ec6?logo=homebrew&logoColor=white" alt="Homebrew">
+  </a>
   <a href="https://github.com/kreuzberg-dev/liter-llm/tree/main/crates/liter-llm-ffi">
     <img src="https://img.shields.io/badge/C-FFI-007ec6" alt="C FFI">
   </a>
@@ -63,7 +66,7 @@
 </div>
 
 
-Universal LLM API client for Rust. Access 142+ LLM providers — OpenAI, Anthropic, Groq, Mistral, and more — through a single unified interface. Async/await with Tokio, streaming via BoxStream, composable Tower middleware stack, and compile-time type safety.
+Universal LLM API client for Rust. Access 143+ LLM providers — OpenAI, Anthropic, Groq, Mistral, and more — through a single unified interface. Async/await with Tokio, streaming via BoxStream, composable Tower middleware stack, and compile-time type safety.
 
 
 ## Installation
@@ -174,7 +177,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 ## Features
 
-### Supported Providers (142+)
+### Supported Providers (143+)
 
 Route to any provider using the `provider/model` prefix convention:
 
@@ -194,7 +197,8 @@ Route to any provider using the `provider/model` prefix convention:
 
 ### Key Capabilities
 
-- **Provider Routing** -- Single client for 142+ LLM providers via `provider/model` prefix
+- **Provider Routing** -- Single client for 143+ LLM providers via `provider/model` prefix
+- **Local LLMs** — Connect to locally-hosted models via Ollama, LM Studio, vLLM, llama.cpp, and other local inference servers
 - **Unified API** -- Consistent `chat`, `chat_stream`, `embeddings`, `list_models` interface
 
 - **Streaming** -- Real-time token streaming via `chat_stream`
@@ -220,7 +224,7 @@ Built on a compiled Rust core for speed and safety:
 
 ## Provider Routing
 
-Route to 142+ providers using the `provider/model` prefix convention:
+Route to 143+ providers using the `provider/model` prefix convention:
 
 ```text
 openai/gpt-4o
@@ -248,7 +252,7 @@ See the [proxy server documentation](https://docs.liter-llm.kreuzberg.dev/server
 
 - **[Documentation](https://docs.liter-llm.kreuzberg.dev)** -- Full docs and API reference
 - **[GitHub Repository](https://github.com/kreuzberg-dev/liter-llm)** -- Source, issues, and discussions
-- **[Provider Registry](https://github.com/kreuzberg-dev/liter-llm/blob/main/schemas/providers.json)** -- 142 supported providers
+- **[Provider Registry](https://github.com/kreuzberg-dev/liter-llm/blob/main/schemas/providers.json)** -- 143 supported providers
 
 Part of [kreuzberg.dev](https://kreuzberg.dev).
 

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/tests/local_llm.rs

@@ -0,0 +1,134 @@
+//! Integration tests against local LLM providers (Ollama).
+//!
+//! These tests require a running Ollama instance with models pulled.
+//! Start with: `task local:up`
+//! Run with: `cargo test -p liter-llm --test local_llm -- --ignored`
+
+use futures_util::StreamExt;
+use liter_llm::{
+    ChatCompletionRequest, ClientConfigBuilder, DefaultClient, EmbeddingInput, EmbeddingRequest, LlmClient,
+};
+
+const OLLAMA_CHAT_MODEL: &str = "ollama/qwen2:0.5b";
+const OLLAMA_EMBED_MODEL: &str = "ollama/all-minilm";
+
+/// Check whether an Ollama instance is reachable.
+async fn is_ollama_available() -> bool {
+    let base = std::env::var("OLLAMA_BASE_URL").unwrap_or_else(|_| "http://localhost:11434".into());
+    reqwest::get(format!("{base}/v1/models")).await.is_ok()
+}
+
+fn ollama_client(model_hint: &str) -> DefaultClient {
+    let config = ClientConfigBuilder::new("").max_retries(2).build();
+    DefaultClient::new(config, Some(model_hint)).expect("failed to build Ollama client")
+}
+
+fn simple_chat_request(model: &str) -> ChatCompletionRequest {
+    serde_json::from_value(serde_json::json!({
+        "model": model,
+        "messages": [{"role": "user", "content": "Say hello in one word."}],
+        "max_tokens": 16,
+    }))
+    .expect("failed to build chat request from JSON")
+}
+
+fn simple_embed_request(model: &str) -> EmbeddingRequest {
+    EmbeddingRequest {
+        model: model.into(),
+        input: EmbeddingInput::Single("hello world".into()),
+        encoding_format: None,
+        dimensions: None,
+        user: None,
+    }
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_chat_ollama() {
+    if !is_ollama_available().await {
+        eprintln!("SKIP: Ollama not available, skipping");
+        return;
+    }
+
+    let client = ollama_client(OLLAMA_CHAT_MODEL);
+    let resp = client.chat(simple_chat_request(OLLAMA_CHAT_MODEL)).await.unwrap();
+
+    assert!(!resp.choices.is_empty(), "should have at least one choice");
+    let choice = &resp.choices[0];
+    assert!(
+        choice.message.content.as_ref().is_some_and(|c| !c.is_empty()),
+        "first choice content should be non-empty"
+    );
+    assert!(choice.finish_reason.is_some(), "finish_reason should be present");
+    assert!(!resp.model.is_empty(), "model field should be non-empty");
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_stream_ollama() {
+    if !is_ollama_available().await {
+        eprintln!("SKIP: Ollama not available, skipping");
+        return;
+    }
+
+    let client = ollama_client(OLLAMA_CHAT_MODEL);
+    let mut stream = client
+        .chat_stream(simple_chat_request(OLLAMA_CHAT_MODEL))
+        .await
+        .unwrap();
+
+    let mut content = String::new();
+    let mut chunk_count = 0u32;
+    let mut saw_finish = false;
+
+    while let Some(result) = stream.next().await {
+        let chunk = result.unwrap();
+        chunk_count += 1;
+        if let Some(choice) = chunk.choices.first() {
+            if let Some(text) = &choice.delta.content {
+                content.push_str(text);
+            }
+            if choice.finish_reason.is_some() {
+                saw_finish = true;
+            }
+        }
+        if chunk_count > 200 {
+            break;
+        }
+    }
+
+    assert!(chunk_count >= 1, "should receive at least 1 chunk");
+    assert!(!content.is_empty(), "concatenated content should be non-empty");
+    assert!(saw_finish, "should see a finish_reason in the stream");
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_embed_ollama() {
+    if !is_ollama_available().await {
+        eprintln!("SKIP: Ollama not available, skipping");
+        return;
+    }
+
+    let client = ollama_client(OLLAMA_EMBED_MODEL);
+    let resp = client.embed(simple_embed_request(OLLAMA_EMBED_MODEL)).await.unwrap();
+
+    assert!(!resp.data.is_empty(), "should have embedding data");
+    assert!(!resp.data[0].embedding.is_empty(), "embedding should have dimensions");
+    assert!(!resp.model.is_empty(), "model field should be non-empty");
+}
+
+#[tokio::test]
+#[ignore]
+async fn local_list_models_ollama() {
+    if !is_ollama_available().await {
+        eprintln!("SKIP: Ollama not available, skipping");
+        return;
+    }
+
+    let client = ollama_client(OLLAMA_CHAT_MODEL);
+    let resp = client.list_models().await.unwrap();
+
+    assert!(!resp.data.is_empty(), "should list at least one model");
+    assert!(!resp.data[0].id.is_empty(), "first model id should be non-empty");
+}

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

@@ -1,6 +1,6 @@
 [package]
 name = "liter-llm-ffi"
-version = "1.1.1"
+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.1.1", features = ["full"] }
-liter-llm-bindings-core = { path = "../liter-llm-bindings-core", version = "1.1.1" }
+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

@@ -8,9 +8,9 @@
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 
 #define LITER_LLM_VERSION_MAJOR 1
-#define LITER_LLM_VERSION_MINOR 1
+#define LITER_LLM_VERSION_MINOR 2
 #define LITER_LLM_VERSION_PATCH 1
-#define LITER_LLM_VERSION "1.1.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.1.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-29 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
@@ -274,6 +275,7 @@ files:
 - vendor/liter-llm/tests/live_providers/mistral.rs
 - vendor/liter-llm/tests/live_providers/openai.rs
 - vendor/liter-llm/tests/live_providers/vertex_ai.rs
+- vendor/liter-llm/tests/local_llm.rs
 - vendor/liter-llm/tests/middleware_integration.rs
 - vendor/liter-llm/tests/operations_integration.rs
 - vendor/liter-llm/tests/routing_integration.rs