refactor: remove direct REST client and direct mode fallback

Author: codeitlikemiley

ARCHITECTURE.md

@@ -56,10 +56,6 @@ The SDK leverages several object-oriented and functional design patterns:
 ### 5. Background Trigger Pattern (`triggers.rs`)
 - **Trigger Trait**: Defines asynchronous background tasks (such as status polling, listener intervals, etc.) that can interact with the connection session concurrently.
 - **TriggerRunner**: Coordinates and spawns registered triggers in separate tasks when the agent session starts.
-
-### 6. Direct Gemini Client (`direct.rs`)
-- **GeminiDirectClient**: A transport-agnostic client that constructs REST request payloads and parses responses directly from the Gemini API. Bypasses the `localharness` and WebSocket loop entirely. It is helpful for environments where TCP/WebSocket or spawning subprocesses is not possible (e.g. lightweight WASI components).
-
 ---
 
 ## Component Details

README.md

@@ -178,9 +178,8 @@ cargo leptos serve
 
 ### Leptos + Spin/WASI (Edge)
 
-For edge/serverless deployments on [Fermyon Spin](https://www.fermyon.com/spin). Since Spin components cannot make outbound TCP/WebSocket connections, two modes are supported:
+For edge/serverless deployments on [Fermyon Spin](https://www.fermyon.com/spin). Since Spin components cannot make outbound TCP/WebSocket connections directly, this target runs in **Sidecar Mode**, where the component communicates via HTTP with a native runner process (`agent_server`):
 
-**Sidecar Mode (Full SDK):**
 ```sh
 # Terminal 1: Start the agent sidecar
 cd examples/agent_server
@@ -192,32 +191,8 @@ spin build --up
 # Open http://localhost:3000
 ```
 
-**Direct Mode (Lightweight, no sidecar):**
-```sh
-cd examples/leptos_ssr_axum
-spin build --up --variable gemini_api_key="your-key"
-```
-
 > See [`examples/README.md`](examples/README.md) for detailed architecture diagrams and configuration options.
 
-### GeminiDirectClient
-
-For environments where TCP/WebSocket is unavailable (e.g. WASI, embedded), the SDK provides a transport-agnostic Gemini API client that builds HTTP request payloads and parses responses — the caller provides the HTTP transport:
-
-```rust
-use antigravity_sdk_rust::direct::{GeminiDirectClient, ChatEntry};
-use antigravity_sdk_rust::types::GeminiConfig;
-
-let client = GeminiDirectClient::new(&GeminiConfig::default())
-    .with_system_instruction("You are a helpful assistant.".to_string());
-
-// Build the request (URL, headers, body) — send via your HTTP client
-let request = client.build_request("your-api-key", "Hello!", &[]).unwrap();
-
-// Parse the response
-let text = GeminiDirectClient::parse_response(&response_bytes).unwrap();
-```
-
 ## Local Development
 
 This project uses [just](https://github.com/casey/just) to manage development tasks.

examples/README.md

@@ -59,11 +59,7 @@ Browser → Axum Server (native)
 
 **Path:** `leptos_ssr_axum/`
 
-A chat application that runs as a [Spin](https://www.fermyon.com/spin) WebAssembly component. Since Spin components cannot make outbound TCP/WebSocket connections (only `wasi:http`), this example supports **two modes**:
-
-#### Mode A: Sidecar Mode (Full SDK — Recommended)
-
-Uses the [`agent_server`](#4-agent-server-sidecar) sidecar to get full SDK features. The Spin component calls the sidecar via HTTP.
+A chat application that runs as a [Spin](https://www.fermyon.com/spin) WebAssembly component. Since Spin components cannot make outbound TCP/WebSocket connections (only `wasi:http`), this example runs in **Sidecar Mode** using the [`agent_server`](#4-agent-server-sidecar) sidecar to get full SDK features (harness, tools, hooks, and policies).
 
 ```sh
 # Terminal 1: Start the sidecar (runs full SDK + localharness)
@@ -87,28 +83,6 @@ Browser → Spin Component (WASI)
                └─ KV Store (chat history)
 ```
 
-#### Mode B: Direct Mode (Lightweight, No Sidecar)
-
-Calls the Gemini API directly using the SDK's `GeminiDirectClient`. No localharness or sidecar needed. Simpler to deploy but without tools, hooks, or policies.
-
-```sh
-cd examples/leptos_ssr_axum
-spin build --up --variable gemini_api_key="your-key"
-```
-
-**Architecture:**
-```
-Browser → Spin Component (WASI)
-               │
-               ├─ GeminiDirectClient::build_request()
-               ├─ wasi::http → Gemini REST API
-               ├─ GeminiDirectClient::parse_response()
-               │
-               └─ KV Store (chat history)
-```
-
-> **How does the mode get selected?** If the `gemini_api_key` Spin variable is set (non-empty), Direct Mode is used. Otherwise, Sidecar Mode is used (calls `agent_server_url`, which defaults to `http://127.0.0.1:8080`).
-
 ---
 
 ### 4. Agent Server (Sidecar)

examples/agent_server/src/main.rs

@@ -27,7 +27,7 @@ use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::routing::{get, post};
 use axum::{Json, Router};
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 use tower_http::cors::{Any, CorsLayer};

examples/leptos_ssr_axum/src/app.rs

@@ -364,20 +364,14 @@ fn send_wasi_http_post(
 
     Ok((status, resp_bytes))
 }
-
 /// Send a message via the antigravity-sdk-rust Agent sidecar server (full SDK)
-/// or fall back to `GeminiDirectClient` (direct Gemini API) if `gemini_api_key` is set.
-///
-/// **Sidecar mode** (default): calls `POST /chat` on the `agent_server` binary which
-/// runs the full SDK with localharness, tools, hooks, and policies.
 ///
-/// **Direct mode** (fallback): if `gemini_api_key` is provided in Spin variables,
-/// calls the Gemini API directly using `GeminiDirectClient`.
+/// Calls `POST /chat` on the `agent_server` binary which runs the full SDK with
+/// localharness, tools, hooks, and policies.
 #[server(prefix = "/api")]
 pub async fn send_message(message: String) -> Result<ChatMessage, ServerFnError<String>> {
     let agent_server_url = spin_sdk::variables::get("agent_server_url")
         .unwrap_or_else(|_| "http://127.0.0.1:8080".to_string());
-    let gemini_api_key = spin_sdk::variables::get("gemini_api_key").unwrap_or_default();
 
     // Load chat history from KV store
     let store = spin_sdk::key_value::Store::open_default().map_err(|e| e.to_string())?;
@@ -386,82 +380,34 @@ pub async fn send_message(message: String) -> Result<ChatMessage, ServerFnError<
         _ => Vec::new(),
     };
 
-    let text = if !gemini_api_key.trim().is_empty() {
-        // ── Direct Mode: GeminiDirectClient (no sidecar needed) ──
-        use antigravity_sdk_rust::direct::{ChatEntry, GeminiDirectClient};
-        use antigravity_sdk_rust::types::GeminiConfig;
-
-        let chat_history: Vec<ChatEntry> = history
-            .iter()
-            .map(|msg| ChatEntry {
-                role: if msg.role == "user" {
-                    "user".to_string()
-                } else {
-                    "model".to_string()
-                },
-                content: msg.content.clone(),
-            })
-            .collect();
-
-        let mut gemini_config = GeminiConfig::default();
-        gemini_config.models.default.name = "gemini-3.5-flash".to_string();
-
-        let client = GeminiDirectClient::new(&gemini_config).with_system_instruction(
-            "You are a helpful AI assistant in a chat interface. \
-             Keep responses concise and conversational. \
-             Use markdown formatting when helpful."
-                .to_string(),
-        );
-
-        let request = client
-            .build_request(gemini_api_key.trim(), &message, &chat_history)
-            .map_err(|e| e.to_string())?;
-
-        let (status, resp_bytes) = send_wasi_http_post(
-            &request.scheme,
-            &request.authority,
-            &request.path,
-            &request.headers,
-            &request.body,
-        )?;
-
-        if status != 200 {
-            return Err(ServerFnError::ServerError(
-                GeminiDirectClient::parse_error(status, &resp_bytes),
-            ));
-        }
-
-        GeminiDirectClient::parse_response(&resp_bytes).map_err(|e| e.to_string())?
-    } else {
-        // ── Sidecar Mode: Full SDK via agent_server ──
-        let body = serde_json::to_vec(&serde_json::json!({ "message": message }))
-            .map_err(|e| e.to_string())?;
+    // ── Sidecar Mode: Full SDK via agent_server ──
+    let body = serde_json::to_vec(&serde_json::json!({ "message": message }))
+        .map_err(|e| e.to_string())?;
 
-        let headers = vec![("content-type".to_string(), b"application/json".to_vec())];
+    let headers = vec![("content-type".to_string(), b"application/json".to_vec())];
 
-        // Parse the sidecar URL to extract scheme/authority
-        let (scheme, authority) = parse_url_parts(&agent_server_url);
+    // Parse the sidecar URL to extract scheme/authority
+    let (scheme, authority) = parse_url_parts(&agent_server_url);
 
-        let (status, resp_bytes) =
-            send_wasi_http_post(&scheme, &authority, "/chat", &headers, &body)?;
+    let (status, resp_bytes) =
+        send_wasi_http_post(&scheme, &authority, "/chat", &headers, &body)?;
 
-        if status != 200 {
-            let err_text = String::from_utf8_lossy(&resp_bytes);
-            return Err(ServerFnError::ServerError(format!(
-                "Agent sidecar error ({}): {}",
-                status, err_text
-            )));
-        }
+    if status != 200 {
+        let err_text = String::from_utf8_lossy(&resp_bytes);
+        return Err(ServerFnError::ServerError(format!(
+            "Agent sidecar error ({}): {}",
+            status, err_text
+        )));
+    }
 
-        // Parse sidecar response: { "text": "...", "conversation_id": "..." }
-        let resp_json: serde_json::Value =
-            serde_json::from_slice(&resp_bytes).map_err(|e| e.to_string())?;
+    // Parse sidecar response: { "text": "...", "conversation_id": "..." }
+    let resp_json: serde_json::Value =
+        serde_json::from_slice(&resp_bytes).map_err(|e| e.to_string())?;
 
-        resp_json["text"]
-            .as_str()
-            .unwrap_or("(No response)")
-            .to_string()
-    };
+    let text = resp_json["text"]
+        .as_str()
+        .unwrap_or("(No response)")
+        .to_string();
 
     let now = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)