feat: add better file support and helper macros

Author: josh-tracey

CONTRIBUTING.md

@@ -39,21 +39,25 @@ We focus on being a **precision thin layer**—prioritizing raw API fidelity, re
 
 This library is part of the `rain` ecosystem. To maintain consistency across clients (e.g., `ollama-client-rs`), we adhere to a shared set of interface patterns:
 
-1. **Builder Pattern**: Clients should always implement `new`, `with_client`, and `with_api_url`.
-2. **Pinned Streams**: All streaming methods must return `Pin<Box<dyn Stream>>` to simplify caller integration.
-3. **Standardized Telemetry**: Use the internal `telemetry_*!` macros. Never use raw `tracing` calls directly in the client logic.
-4. **Error Mapping**: Maintain a flat, descriptive `GeminiError` enum using `thiserror`.
+1. **Macro-First DX**: Prioritize declarative request building via procedural macros (`gemini_chat!`, `gemini_parts!`).
+2. **Standardized Schema Generation**: All structured outputs should use the `GeminiSchema` derive macro.
+3. **Builder Pattern**: Clients should always implement `new`, `with_client`, and `with_api_url`.
+4. **Pinned Streams**: All streaming methods must return `Pin<Box<dyn Stream>>` to simplify caller integration.
+5. **Standardized Telemetry**: Use the internal `telemetry_*!` macros.
+6. **Error Mapping**: Maintain a flat, descriptive `GeminiError` enum using `thiserror`.
 
 ---
 
 ## 🛠️ Architectural Philosophy
 
 When contributing to the core client, adhere to these principles:
 
-1. **Thin Layer Philosophy**: The client is a transport and mapping layer. Avoid adding complex state machines, orchestration logic, or "agentic" capabilities. These belong in higher-level crates (like `rain`).
-2. **Transparent Proxy**: Preserving byte-for-byte fidelity and API structure is a priority. Avoid abstractions that hide underlying API features.
-3. **Rust Type Safety**: Leverage Rust's type system to make API constraints (like `TaskType` or `FinishReason`) explicit and compile-time safe.
-4. **Zero-Overhead Abstractions**: Ensure the mapping from request structs to JSON is efficient and follows the public API documentation precisely.
+1. **Thin Layer Foundation**: The core client is a transport and mapping layer. Avoid adding complex state machines or orchestration logic.
+2. **Ergonomic Macro Overlay**: Provide a best-in-class developer experience via macros that simplify common tasks (e.g., chat construction, tool declaration).
+3. **Transparent Proxy**: Preserving byte-for-byte fidelity and API structure in the core types is a priority.
+4. **Rust Type Safety**: Leverage Rust's type system to make API constraints explicit and compile-time safe.
+5. **Zero-Overhead Abstractions**: Ensure the mapping from macros to request structs is efficient.
+
 
 ---
 

Cargo.lock

@@ -1,37 +1,12 @@
-[package]
-name = "gemini_client_rs"
-version = "0.9.0"
-edition = "2021"
-description = "A Rust SDK for the Google Gemini API"
-license = "MIT"
-repository = "https://github.com/Adriftdev/gemini-client"
+[workspace]
+members = [
+    "crates/gemini-client",
+    "crates/gemini-client-macros",
+]
+resolver = "2"
 
-[features]
-default = []
-tracing = ["dep:tracing"]
-
-[dependencies]
-async-stream = { version = "0.3", default-features = false }
-async-trait = { version = "0.1", default-features = false }
-futures-util = { version = "0.3", default-features = false }
-reqwest = { version = "0.12", default-features = false, features = [
-  "json",
-  "stream",
-  "rustls-tls"
-] }
-reqwest-eventsource = { version = "0.6", default-features = false }
-serde = { version = "1", default-features = false, features = ["derive"] }
-serde_json = { version = "1", default-features = false }
-thiserror = { version = "2", default-features = false }
-tokio = { version = "1", default-features = false, features = [
-  "macros",
-  "rt-multi-thread",
-] }
-tracing = { version = "0.1", default-features = false, optional = true }
-
-[dev-dependencies]
-dotenvy = "0.15"
-tracing-subscriber = { version = "0.3", default-features = false, features = [
-  "fmt",
-  "registry",
-] }
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+strip = true

Cargo.toml

@@ -15,32 +15,27 @@ This crate does not own orchestration, planning, retrieval, or tool-loop executi
 ## Basic usage
 
 ```rust
-use gemini_client_rs::{
-    types::{Content, ContentPart, GenerateContentRequest},
-    GeminiClient,
-};
+use gemini_client_rs::{gemini_chat, GeminiClient};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let client = GeminiClient::default();
+    
+    // Use the declarative gemini_chat! macro for elegant request building
+    let req = gemini_chat!(
+        user("Summarize this project in two sentences.")
+    );
+
     let response = client
-        .generate_content(
-            "gemini-2.5-flash",
-            &GenerateContentRequest {
-                contents: vec![Content {
-                    role: None,
-                    parts: vec![ContentPart::new_text("Summarize this project in two sentences.", false)],
-                }],
-                ..Default::default()
-            },
-        )
+        .generate_content("gemini-2.0-flash", &req)
         .await?;
 
     println!("{response:#?}");
     Ok(())
 }
 ```
 
+
 ## Position in the stack
 
 - Use `gemini_client_rs` when you want a low-level SDK for Gemini.

README.md

@@ -0,0 +1,15 @@
+[package]
+name = "gemini_client_macros"
+version = "0.1.0"
+edition = "2021"
+description = "Procedural macros for the gemini-client-rs crate"
+license = "MIT"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+darling = "0.20" # Helper for parsing proc-macro attributes