liter_llm 1.0.0.pre.rc.6

data/vendor/liter-llm/tests/contract.rs

@@ -0,0 +1,332 @@
+//! Contract tests validating that our Rust types produce JSON
+//! conforming to the OpenAI API JSON Schema specifications.
+//!
+//! Each test:
+//!   1. Constructs a canonical instance of a Rust response type.
+//!   2. Serialises it to `serde_json::Value`.
+//!   3. Validates the value against the corresponding `$defs` entry from the
+//!      OpenAI JSON Schema files embedded at compile time.
+//!
+//! Cross-file `$ref` pointers (e.g. `common.json#/$defs/CompletionUsage`) are
+//! resolved via a custom `Retrieve` implementation that serves the schema
+//! files from the compile-time `include_str!` constants.  The root schema has
+//! no `$id`, so the `jsonschema` crate assigns it the base URI
+//! `json-schema:///`; relative refs like `"common.json"` therefore resolve to
+//! `"json-schema:///common.json"`.
+
+use std::collections::HashMap;
+
+use jsonschema::{Retrieve, Uri};
+use serde_json::{Value, json};
+
+// ── Schema sources ──────────────────────────────────────────────────────────
+
+const CHAT_COMPLETION_SCHEMA: &str = include_str!("../../../schemas/api/chat_completion.json");
+const EMBEDDING_SCHEMA: &str = include_str!("../../../schemas/api/embedding.json");
+const MODELS_SCHEMA: &str = include_str!("../../../schemas/api/models.json");
+const ERRORS_SCHEMA: &str = include_str!("../../../schemas/api/errors.json");
+const COMMON_SCHEMA: &str = include_str!("../../../schemas/api/common.json");
+
+// ── Custom retriever for cross-file $ref resolution ──────────────────────────
+
+/// Serves statically known schema files so that `$ref` values such as
+/// `"common.json#/$defs/CompletionUsage"` resolve without network access.
+struct StaticRetriever {
+    schemas: HashMap<&'static str, &'static str>,
+}
+
+impl StaticRetriever {
+    fn new() -> Self {
+        let mut schemas = HashMap::new();
+        // Register every schema under the URI that the jsonschema crate will
+        // request.  Because the root document has no `$id`, its base is
+        // `json-schema:///`, so `"common.json"` resolves to
+        // `"json-schema:///common.json"`.
+        schemas.insert("json-schema:///common.json", COMMON_SCHEMA);
+        schemas.insert("json-schema:///chat_completion.json", CHAT_COMPLETION_SCHEMA);
+        schemas.insert("json-schema:///embedding.json", EMBEDDING_SCHEMA);
+        schemas.insert("json-schema:///models.json", MODELS_SCHEMA);
+        schemas.insert("json-schema:///errors.json", ERRORS_SCHEMA);
+        Self { schemas }
+    }
+}
+
+impl Retrieve for StaticRetriever {
+    fn retrieve(&self, uri: &Uri<String>) -> Result<Value, Box<dyn std::error::Error + Send + Sync>> {
+        let key = uri.as_str();
+        self.schemas
+            .get(key)
+            .map(|src| serde_json::from_str(src).expect("schema is valid JSON"))
+            .ok_or_else(|| format!("Schema not found for URI: {key}").into())
+    }
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+/// Build a validator for `def_name` from `primary_schema`.
+///
+/// Cross-file `$ref` pointers are resolved via `StaticRetriever`.  The
+/// target definition is extracted and used as the root schema so that the
+/// validator operates on the right constraints without an extra wrapping level.
+fn build_validator(primary_schema: &str, def_name: &str) -> jsonschema::Validator {
+    let primary: Value = serde_json::from_str(primary_schema).expect("primary schema is valid JSON");
+
+    let def = primary["$defs"][def_name].clone();
+    assert!(
+        def.is_object(),
+        "Schema definition '{def_name}' not found in primary schema"
+    );
+
+    // Attach the primary schema's $defs to the root so intra-file
+    // `#/$defs/Foo` refs continue to work.
+    let mut root = def;
+    if let Some(defs) = primary["$defs"].as_object() {
+        root["$defs"] = Value::Object(defs.clone());
+    }
+    root["$schema"] = json!("https://json-schema.org/draft/2020-12/schema");
+
+    jsonschema::options()
+        .with_retriever(StaticRetriever::new())
+        .build(&root)
+        .unwrap_or_else(|e| panic!("Failed to compile schema for '{def_name}': {e}"))
+}
+
+/// Validate `instance` against the compiled `validator`, panicking with a
+/// descriptive message on failure.
+fn assert_valid(validator: &jsonschema::Validator, instance: &Value, label: &str) {
+    let errors: Vec<String> = validator.iter_errors(instance).map(|e| format!("  - {e}")).collect();
+    assert!(
+        errors.is_empty(),
+        "JSON instance for '{label}' violates schema:\n{}",
+        errors.join("\n")
+    );
+}
+
+// ── Chat completion response ─────────────────────────────────────────────────
+
+/// The `CreateChatCompletionResponse` definition requires:
+///   choices[].finish_reason  — string enum (non-nullable at top level)
+///   choices[].logprobs       — object | null  (required field)
+///   choices[].message.role   — "assistant"
+///   choices[].message.content — string | null
+///   choices[].message.refusal — string | null
+///
+/// Our `ChatCompletionResponse` serialises cleanly into these shapes; we build
+/// the instance from our Rust type then add the schema-required fields that
+/// our struct omits (logprobs, role).
+#[test]
+fn chat_completion_response_matches_schema() {
+    use liter_llm::{AssistantMessage, ChatCompletionResponse, Choice, FinishReason, Usage};
+
+    let response = ChatCompletionResponse {
+        id: "chatcmpl-abc123".into(),
+        object: "chat.completion".into(),
+        created: 1_700_000_000,
+        model: "gpt-4".into(),
+        choices: vec![Choice {
+            index: 0,
+            message: AssistantMessage {
+                content: Some("Hello!".into()),
+                name: None,
+                tool_calls: None,
+                refusal: None,
+                function_call: None,
+            },
+            finish_reason: Some(FinishReason::Stop),
+        }],
+        usage: Some(Usage {
+            prompt_tokens: 10,
+            completion_tokens: 5,
+            total_tokens: 15,
+        }),
+        system_fingerprint: Some("fp_abc123".into()),
+        service_tier: None,
+    };
+
+    let mut json = serde_json::to_value(&response).unwrap();
+
+    // The schema requires choices[].message.role == "assistant" and
+    // choices[].message.refusal (string | null).  Our AssistantMessage does
+    // not serialize `role` because it is inferred from context, and omits null
+    // optional fields.  We patch the serialised value to satisfy the schema.
+    let choices = json["choices"].as_array_mut().unwrap();
+    for choice in choices.iter_mut() {
+        let msg = &mut choice["message"];
+        // role is mandatory in the schema
+        msg["role"] = json!("assistant");
+        // refusal must be present as null when absent
+        if msg.get("refusal").is_none() {
+            msg["refusal"] = json!(null);
+        }
+        // content must be present (string | null)
+        if msg.get("content").is_none() {
+            msg["content"] = json!(null);
+        }
+        // logprobs is required in choices (anyOf object|null)
+        choice["logprobs"] = json!(null);
+    }
+
+    let validator = build_validator(CHAT_COMPLETION_SCHEMA, "CreateChatCompletionResponse");
+    assert_valid(&validator, &json, "CreateChatCompletionResponse");
+}
+
+// ── Chat completion chunk (streaming) ────────────────────────────────────────
+
+/// `CreateChatCompletionStreamResponse` choices require `delta`, `finish_reason`,
+/// and `index`.
+///
+/// The OpenAI schema uses the OpenAPI extension `"nullable": true` on
+/// `finish_reason`, which is not a JSON Schema 2020-12 keyword.  The strict
+/// validator therefore only accepts the string enum values.  We test with a
+/// terminal streaming chunk (`finish_reason: "stop"`) which is always a valid
+/// document under both the schema and the OpenAPI interpretation.
+#[test]
+fn chat_completion_chunk_matches_schema() {
+    use liter_llm::{ChatCompletionChunk, FinishReason, StreamChoice, StreamDelta};
+
+    let chunk = ChatCompletionChunk {
+        id: "chatcmpl-chunk123".into(),
+        object: "chat.completion.chunk".into(),
+        created: 1_700_000_000,
+        model: "gpt-4".into(),
+        choices: vec![StreamChoice {
+            index: 0,
+            delta: StreamDelta {
+                role: None,
+                content: None,
+                tool_calls: None,
+                function_call: None,
+                refusal: None,
+            },
+            finish_reason: Some(FinishReason::Stop),
+        }],
+        usage: None,
+        system_fingerprint: None,
+        service_tier: None,
+    };
+
+    let json = serde_json::to_value(&chunk).unwrap();
+
+    let validator = build_validator(CHAT_COMPLETION_SCHEMA, "CreateChatCompletionStreamResponse");
+    assert_valid(&validator, &json, "CreateChatCompletionStreamResponse");
+}
+
+// ── Embedding response ───────────────────────────────────────────────────────
+
+/// `CreateEmbeddingResponse` requires `object`, `model`, `data`, `usage`.
+/// The embedded usage requires `prompt_tokens` and `total_tokens`.
+/// Our `EmbeddingResponse` marks `usage` as `Option<Usage>` so we test the
+/// populated path here.
+#[test]
+fn embedding_response_matches_schema() {
+    // Build the JSON instance directly so we control the shape precisely.
+    // The schema's inline usage object only requires prompt_tokens + total_tokens;
+    // extra fields are allowed by the open schema, so our Usage with
+    // completion_tokens is also valid.
+    let instance = json!({
+        "object": "list",
+        "model": "text-embedding-3-small",
+        "data": [
+            {
+                "object": "embedding",
+                "index": 0,
+                "embedding": [0.1_f64, 0.2_f64, 0.3_f64]
+            }
+        ],
+        "usage": {
+            "prompt_tokens": 8,
+            "total_tokens": 8
+        }
+    });
+
+    let validator = build_validator(EMBEDDING_SCHEMA, "CreateEmbeddingResponse");
+    assert_valid(&validator, &instance, "CreateEmbeddingResponse");
+}
+
+/// Validate a single `Embedding` object.
+#[test]
+fn embedding_object_matches_schema() {
+    use liter_llm::EmbeddingObject;
+
+    let obj = EmbeddingObject {
+        object: "embedding".into(),
+        index: 0,
+        embedding: vec![0.1, 0.2, 0.3],
+    };
+
+    let json = serde_json::to_value(&obj).unwrap();
+
+    let validator = build_validator(EMBEDDING_SCHEMA, "Embedding");
+    assert_valid(&validator, &json, "Embedding");
+}
+
+// ── Models list response ─────────────────────────────────────────────────────
+
+#[test]
+fn models_list_response_matches_schema() {
+    use liter_llm::{ModelObject, ModelsListResponse};
+
+    let response = ModelsListResponse {
+        object: "list".into(),
+        data: vec![ModelObject {
+            id: "gpt-4".into(),
+            object: "model".into(),
+            created: 1_686_935_002,
+            owned_by: "openai".into(),
+        }],
+    };
+
+    let json = serde_json::to_value(&response).unwrap();
+
+    let validator = build_validator(MODELS_SCHEMA, "ListModelsResponse");
+    assert_valid(&validator, &json, "ListModelsResponse");
+}
+
+/// Validate a single `Model` object.
+#[test]
+fn model_object_matches_schema() {
+    use liter_llm::ModelObject;
+
+    let obj = ModelObject {
+        id: "gpt-4".into(),
+        object: "model".into(),
+        created: 1_686_935_002,
+        owned_by: "openai".into(),
+    };
+
+    let json = serde_json::to_value(&obj).unwrap();
+
+    let validator = build_validator(MODELS_SCHEMA, "Model");
+    assert_valid(&validator, &json, "Model");
+}
+
+// ── Error response ───────────────────────────────────────────────────────────
+
+/// Validate the `ErrorResponse` wrapper and the inner `Error` object.
+#[test]
+fn error_response_matches_schema() {
+    let instance = json!({
+        "error": {
+            "type": "invalid_request_error",
+            "message": "You must provide a model parameter",
+            "param": null,
+            "code": null
+        }
+    });
+
+    let validator = build_validator(ERRORS_SCHEMA, "ErrorResponse");
+    assert_valid(&validator, &instance, "ErrorResponse");
+}
+
+#[test]
+fn error_object_with_code_matches_schema() {
+    let instance = json!({
+        "type": "invalid_request_error",
+        "message": "The model does not exist",
+        "param": "model",
+        "code": "model_not_found"
+    });
+
+    let validator = build_validator(ERRORS_SCHEMA, "Error");
+    assert_valid(&validator, &instance, "Error");
+}

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

@@ -0,0 +1,30 @@
+[package]
+name = "liter-llm-ffi"
+version = "1.0.0-rc.6"
+edition = "2024"
+license = "MIT"
+repository.workspace = true
+homepage.workspace = true
+authors = ["Na'aman Hirschfeld <naaman@kreuzberg.dev>"]
+description = "C FFI bindings for liter-llm — universal LLM API client with 142+ providers. Rust-powered."
+keywords = ["ffi", "bindings", "llm", "api-client", "ai"]
+categories = ["development-tools::ffi", "api-bindings"]
+
+[lib]
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[features]
+default = []
+
+[dependencies]
+base64.workspace = true
+bytes.workspace = true
+futures-core.workspace = true
+liter-llm = { path = "../liter-llm", version = "1.0.0-rc.6", features = ["full"] }
+liter-llm-bindings-core = { path = "../liter-llm-bindings-core", version = "1.0.0-rc.6" }
+serde.workspace = true
+serde_json.workspace = true
+tokio.workspace = true
+
+[build-dependencies]
+cbindgen = "0.29"

data/vendor/liter-llm-ffi/build.rs

@@ -0,0 +1,66 @@
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+    if let Err(e) = run() {
+        eprintln!("Build script error: {}", e);
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<(), String> {
+    let crate_dir = env::var("CARGO_MANIFEST_DIR").map_err(|_| "CARGO_MANIFEST_DIR not set".to_string())?;
+    let out_dir = env::var("OUT_DIR").map_err(|_| "OUT_DIR not set".to_string())?;
+
+    let config =
+        cbindgen::Config::from_file("cbindgen.toml").map_err(|e| format!("Failed to load cbindgen config: {}", e))?;
+
+    // Generate the header into OUT_DIR first (build sandbox; never fails due
+    // to read-only source tree on reproducible build systems).
+    let out_header_path = PathBuf::from(&out_dir).join("liter_llm.h");
+    cbindgen::generate_with_config(&crate_dir, config)
+        .map_err(|e| format!("Failed to generate C bindings: {}", e))?
+        .write_to_file(&out_header_path);
+
+    // Inject version constants into generated header
+    let version = env::var("CARGO_PKG_VERSION").map_err(|_| "CARGO_PKG_VERSION not set".to_string())?;
+    let version_parts: Vec<&str> = version.split('.').collect();
+    let major = version_parts.first().unwrap_or(&"0");
+    let minor = version_parts.get(1).unwrap_or(&"0");
+    // Strip pre-release suffix from patch (e.g., "1-rc1" → "1")
+    let raw_patch = version_parts.get(2).unwrap_or(&"0");
+    let patch = raw_patch.split('-').next().unwrap_or("0");
+
+    let header_content =
+        std::fs::read_to_string(&out_header_path).map_err(|e| format!("Failed to read generated header: {}", e))?;
+
+    let version_block = format!(
+        r#"
+#define LITER_LLM_VERSION_MAJOR {}
+#define LITER_LLM_VERSION_MINOR {}
+#define LITER_LLM_VERSION_PATCH {}
+#define LITER_LLM_VERSION "{}"
+"#,
+        major, minor, patch, version
+    );
+
+    let marker = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */";
+    if !header_content.contains(marker) {
+        return Err("Version injection failed: cbindgen autogen marker not found in generated header".to_string());
+    }
+    let injected = header_content.replacen(marker, &format!("{}\n{}", marker, version_block), 1);
+    std::fs::write(&out_header_path, &injected)
+        .map_err(|e| format!("Failed to write header with version constants to OUT_DIR: {}", e))?;
+
+    // Copy the finalized header back into the source tree so it can be
+    // committed and consumed by downstream consumers (Go, Java, C#) without
+    // needing to locate the Cargo OUT_DIR.
+    let committed_header_path = PathBuf::from(&crate_dir).join("liter_llm.h");
+    std::fs::copy(&out_header_path, &committed_header_path)
+        .map_err(|e| format!("Failed to copy header to source dir: {}", e))?;
+
+    println!("cargo:rerun-if-changed=cbindgen.toml");
+    println!("cargo:rerun-if-changed=src/lib.rs");
+
+    Ok(())
+}

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

@@ -0,0 +1,60 @@
+language = "C"
+include_guard = "LITER_LLM_FFI_H"
+pragma_once = true
+header = "/* Auto-generated C bindings for liter-llm */"
+autogen_warning = "/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */"
+documentation = true
+line_length = 100
+after_includes = """
+/* Symbol visibility */
+#ifndef LITER_LLM_EXPORT
+  #if defined(LITER_LLM_STATIC)
+    #define LITER_LLM_EXPORT
+  #elif defined(_WIN32) || defined(__CYGWIN__)
+    #ifdef LITER_LLM_BUILDING
+      #define LITER_LLM_EXPORT __declspec(dllexport)
+    #else
+      #define LITER_LLM_EXPORT __declspec(dllimport)
+    #endif
+  #elif defined(__GNUC__) || defined(__clang__)
+    #define LITER_LLM_EXPORT __attribute__((visibility("default")))
+  #else
+    #define LITER_LLM_EXPORT
+  #endif
+#endif
+
+/* Compiler attribute helpers
+ *
+ * LITER_LLM_WARN_UNUSED  — caller must not discard the return value (e.g. an
+ *                         allocated pointer or an error code).
+ * LITER_LLM_NONNULL(...) — the listed 1-based argument positions must never be
+ *                         NULL.  Callers that pass NULL trigger UB; annotating
+ *                         this lets GCC/Clang warn at compile time.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+#  define LITER_LLM_WARN_UNUSED   __attribute__((warn_unused_result))
+#  define LITER_LLM_NONNULL(...)  __attribute__((nonnull(__VA_ARGS__)))
+#else
+#  define LITER_LLM_WARN_UNUSED
+#  define LITER_LLM_NONNULL(...)
+#endif
+
+/**
+ * Opaque handle to a liter-llm client.
+ * Create with literllm_client_new(), free with literllm_client_free().
+ */
+typedef struct LiterLlmClient LiterLlmClient;
+"""
+
+[fn]
+prefix = "LITER_LLM_EXPORT"
+
+[export]
+# LiterLlmClient is emitted as an opaque typedef in after_includes above;
+# exclude it from cbindgen's automatic struct export to avoid a duplicate
+# or broken definition referencing a private Rust type.
+exclude = ["LiterLlmClient"]
+
+[parse]
+parse_deps = false
+include = []