liter_llm 1.0.0.pre.rc.6

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

@@ -0,0 +1,40 @@
+use serde::{Deserialize, Serialize};
+
+/// Request to create images from a text prompt.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct CreateImageRequest {
+    pub prompt: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub n: Option<u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub quality: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub style: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response_format: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub user: Option<String>,
+}
+
+/// Response containing generated images.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ImagesResponse {
+    pub created: u64,
+    pub data: Vec<Image>,
+}
+
+/// A single generated image, returned as either a URL or base64 data.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Image {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub b64_json: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub revised_prompt: Option<String>,
+}

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

@@ -0,0 +1,27 @@
+pub mod audio;
+pub mod batch;
+pub mod chat;
+pub mod common;
+pub mod embedding;
+pub mod files;
+pub mod image;
+pub mod models;
+pub mod moderation;
+pub mod ocr;
+pub mod rerank;
+pub mod responses;
+pub mod search;
+
+pub use audio::*;
+pub use batch::*;
+pub use chat::*;
+pub use common::*;
+pub use embedding::*;
+pub use files::*;
+pub use image::*;
+pub use models::*;
+pub use moderation::*;
+pub use ocr::*;
+pub use rerank::*;
+pub use responses::*;
+pub use search::*;

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

@@ -0,0 +1,21 @@
+use serde::{Deserialize, Serialize};
+
+// ─── Responses ────────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ModelsListResponse {
+    /// Always `"list"` from OpenAI-compatible APIs.  Stored as a plain
+    /// `String` so non-standard provider values do not break deserialization.
+    pub object: String,
+    pub data: Vec<ModelObject>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ModelObject {
+    pub id: String,
+    /// Always `"model"` from OpenAI-compatible APIs.  Stored as a plain
+    /// `String` so non-standard provider values do not break deserialization.
+    pub object: String,
+    pub created: u64,
+    pub owned_by: String,
+}

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

@@ -0,0 +1,80 @@
+use serde::{Deserialize, Serialize};
+
+/// Request to classify content for policy violations.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct ModerationRequest {
+    pub input: ModerationInput,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub model: Option<String>,
+}
+
+/// Input to the moderation endpoint — a single string or multiple strings.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum ModerationInput {
+    Single(String),
+    Multiple(Vec<String>),
+}
+
+/// Response from the moderation endpoint.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ModerationResponse {
+    pub id: String,
+    pub model: String,
+    pub results: Vec<ModerationResult>,
+}
+
+/// A single moderation classification result.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ModerationResult {
+    pub flagged: bool,
+    pub categories: ModerationCategories,
+    pub category_scores: ModerationCategoryScores,
+}
+
+/// Boolean flags for each moderation category.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ModerationCategories {
+    pub sexual: bool,
+    pub hate: bool,
+    pub harassment: bool,
+    #[serde(rename = "self-harm")]
+    pub self_harm: bool,
+    #[serde(rename = "sexual/minors")]
+    pub sexual_minors: bool,
+    #[serde(rename = "hate/threatening")]
+    pub hate_threatening: bool,
+    #[serde(rename = "violence/graphic")]
+    pub violence_graphic: bool,
+    #[serde(rename = "self-harm/intent")]
+    pub self_harm_intent: bool,
+    #[serde(rename = "self-harm/instructions")]
+    pub self_harm_instructions: bool,
+    #[serde(rename = "harassment/threatening")]
+    pub harassment_threatening: bool,
+    pub violence: bool,
+}
+
+/// Confidence scores for each moderation category.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ModerationCategoryScores {
+    pub sexual: f64,
+    pub hate: f64,
+    pub harassment: f64,
+    #[serde(rename = "self-harm")]
+    pub self_harm: f64,
+    #[serde(rename = "sexual/minors")]
+    pub sexual_minors: f64,
+    #[serde(rename = "hate/threatening")]
+    pub hate_threatening: f64,
+    #[serde(rename = "violence/graphic")]
+    pub violence_graphic: f64,
+    #[serde(rename = "self-harm/intent")]
+    pub self_harm_intent: f64,
+    #[serde(rename = "self-harm/instructions")]
+    pub self_harm_instructions: f64,
+    #[serde(rename = "harassment/threatening")]
+    pub harassment_threatening: f64,
+    pub violence: f64,
+}

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

@@ -0,0 +1,87 @@
+//! Types for document OCR (optical character recognition) requests and responses.
+
+use serde::{Deserialize, Serialize};
+
+use super::common::Usage;
+
+/// An OCR request.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct OcrRequest {
+    /// The model/provider to use (e.g. `"mistral/mistral-ocr-latest"`).
+    pub model: String,
+    /// The document to process.
+    pub document: OcrDocument,
+    /// Specific pages to process (1-indexed). `None` means all pages.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pages: Option<Vec<u32>>,
+    /// Whether to include base64-encoded images of each page.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub include_image_base64: Option<bool>,
+}
+
+/// Document input for OCR — either a URL or inline base64 data.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum OcrDocument {
+    /// A publicly accessible document URL.
+    #[serde(rename = "document_url")]
+    Url {
+        /// The document URL.
+        url: String,
+    },
+    /// Inline base64-encoded document data.
+    #[serde(rename = "base64")]
+    Base64 {
+        /// Base64-encoded document content.
+        data: String,
+        /// MIME type (e.g. `"application/pdf"`, `"image/png"`).
+        media_type: String,
+    },
+}
+
+/// An OCR response.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OcrResponse {
+    /// Extracted pages.
+    pub pages: Vec<OcrPage>,
+    /// The model used.
+    pub model: String,
+    /// Token usage, if reported by the provider.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub usage: Option<Usage>,
+}
+
+/// A single page of OCR output.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OcrPage {
+    /// Page index (0-based).
+    pub index: u32,
+    /// Extracted content as Markdown.
+    pub markdown: String,
+    /// Extracted images, if `include_image_base64` was set.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub images: Option<Vec<OcrImage>>,
+    /// Page dimensions in pixels, if available.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dimensions: Option<PageDimensions>,
+}
+
+/// An image extracted from an OCR page.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct OcrImage {
+    /// Unique image identifier.
+    pub id: String,
+    /// Base64-encoded image data.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub image_base64: Option<String>,
+}
+
+/// Page dimensions in pixels.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PageDimensions {
+    /// Width in pixels.
+    pub width: u32,
+    /// Height in pixels.
+    pub height: u32,
+}

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

@@ -0,0 +1,46 @@
+use serde::{Deserialize, Serialize};
+
+/// Request to rerank documents by relevance to a query.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct RerankRequest {
+    pub model: String,
+    pub query: String,
+    pub documents: Vec<RerankDocument>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub top_n: Option<u32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub return_documents: Option<bool>,
+}
+
+/// A document to be reranked — either a plain string or an object with a text field.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum RerankDocument {
+    Text(String),
+    Object { text: String },
+}
+
+/// Response from the rerank endpoint.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct RerankResponse {
+    pub id: Option<String>,
+    pub results: Vec<RerankResult>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub meta: Option<serde_json::Value>,
+}
+
+/// A single reranked document with its relevance score.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct RerankResult {
+    pub index: u32,
+    pub relevance_score: f64,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub document: Option<RerankResultDocument>,
+}
+
+/// The text content of a reranked document, returned when `return_documents` is true.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct RerankResultDocument {
+    pub text: String,
+}

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

@@ -0,0 +1,55 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct CreateResponseRequest {
+    pub model: String,
+    pub input: serde_json::Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub instructions: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tools: Option<Vec<ResponseTool>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub temperature: Option<f64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_output_tokens: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ResponseTool {
+    #[serde(rename = "type")]
+    pub tool_type: String,
+    #[serde(flatten)]
+    pub config: serde_json::Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ResponseObject {
+    pub id: String,
+    pub object: String,
+    pub created_at: u64,
+    pub model: String,
+    pub status: String,
+    pub output: Vec<ResponseOutputItem>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub usage: Option<ResponseUsage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ResponseOutputItem {
+    #[serde(rename = "type")]
+    pub item_type: String,
+    #[serde(flatten)]
+    pub content: serde_json::Value,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ResponseUsage {
+    pub input_tokens: u64,
+    pub output_tokens: u64,
+    pub total_tokens: u64,
+}

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

@@ -0,0 +1,45 @@
+//! Types for web/document search requests and responses.
+
+use serde::{Deserialize, Serialize};
+
+/// A search request.
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(deny_unknown_fields)]
+pub struct SearchRequest {
+    /// The model/provider to use (e.g. `"brave/web-search"`, `"tavily/search"`).
+    pub model: String,
+    /// The search query.
+    pub query: String,
+    /// Maximum number of results to return.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_results: Option<u32>,
+    /// Domain filter — restrict results to specific domains.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub search_domain_filter: Option<Vec<String>>,
+    /// Country code for localized results (ISO 3166-1 alpha-2).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub country: Option<String>,
+}
+
+/// A search response.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchResponse {
+    /// The search results.
+    pub results: Vec<SearchResult>,
+    /// The model used.
+    pub model: String,
+}
+
+/// An individual search result.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchResult {
+    /// Title of the result.
+    pub title: String,
+    /// URL of the result.
+    pub url: String,
+    /// Text snippet / excerpt.
+    pub snippet: String,
+    /// Publication or last-updated date, if available.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub date: Option<String>,
+}