feat: add Ollama native API support to inference proxy

Add pattern detection, provider profile, and validation probe for
Ollama's native /api/chat, /api/tags, and /api/show endpoints.

Proxy changes (l7/inference.rs):
- POST /api/chat -> ollama_chat protocol
- GET /api/tags -> ollama_model_discovery protocol
- POST /api/show -> ollama_model_discovery protocol

Provider profile (openshell-core/inference.rs):
- New 'ollama' provider type with default endpoint
  http://host.openshell.internal:11434
- Supports ollama_chat, ollama_model_discovery, and OpenAI-compatible
  protocols (openai_chat_completions, openai_completions, model_discovery)
- Credential lookup via OLLAMA_API_KEY, base URL via OLLAMA_BASE_URL

Validation (backend.rs):
- Ollama validation probe sends minimal /api/chat request with stream:false

Tests: 4 new tests for pattern detection (ollama chat, tags, show,
and GET /api/chat rejection).

Signed-off-by: Lyle Hopkins <lyle@cosmicnetworks.com>

Author: cosmicnet

crates/openshell-core/src/inference.rs

@@ -56,6 +56,14 @@ const OPENAI_PROTOCOLS: &[&str] = &[
 
 const ANTHROPIC_PROTOCOLS: &[&str] = &["anthropic_messages", "model_discovery"];
 
+const OLLAMA_PROTOCOLS: &[&str] = &[
+    "ollama_chat",
+    "ollama_model_discovery",
+    "openai_chat_completions",
+    "openai_completions",
+    "model_discovery",
+];
+
 static OPENAI_PROFILE: InferenceProviderProfile = InferenceProviderProfile {
     provider_type: "openai",
     default_base_url: "https://api.openai.com/v1",
@@ -86,6 +94,16 @@ static NVIDIA_PROFILE: InferenceProviderProfile = InferenceProviderProfile {
     default_headers: &[],
 };
 
+static OLLAMA_PROFILE: InferenceProviderProfile = InferenceProviderProfile {
+    provider_type: "ollama",
+    default_base_url: "http://host.openshell.internal:11434",
+    protocols: OLLAMA_PROTOCOLS,
+    credential_key_names: &["OLLAMA_API_KEY"],
+    base_url_config_keys: &["OLLAMA_BASE_URL", "OLLAMA_HOST"],
+    auth: AuthHeader::Bearer,
+    default_headers: &[],
+};
+
 /// Look up the inference provider profile for a given provider type.
 ///
 /// Returns `None` for provider types that don't support inference routing
@@ -95,6 +113,7 @@ pub fn profile_for(provider_type: &str) -> Option<&'static InferenceProviderProf
         "openai" => Some(&OPENAI_PROFILE),
         "anthropic" => Some(&ANTHROPIC_PROFILE),
         "nvidia" => Some(&NVIDIA_PROFILE),
+        "ollama" => Some(&OLLAMA_PROFILE),
         _ => None,
     }
 }

crates/openshell-router/src/backend.rs

@@ -223,6 +223,20 @@ fn validation_probe(route: &ResolvedRoute) -> Result<ValidationProbe, Validation
         });
     }
 
+    if route
+        .protocols
+        .iter()
+        .any(|protocol| protocol == "ollama_chat")
+    {
+        return Ok(ValidationProbe {
+            path: "/api/chat",
+            protocol: "ollama_chat",
+            body: bytes::Bytes::from_static(
+                br#"{"model":"test","messages":[{"role":"user","content":"ping"}],"stream":false}"#,
+            ),
+        });
+    }
+
     Err(ValidationFailure {
         kind: ValidationFailureKind::RequestShape,
         details: format!(

crates/openshell-sandbox/src/l7/inference.rs

@@ -43,6 +43,24 @@ pub fn default_patterns() -> Vec<InferenceApiPattern> {
             protocol: "anthropic_messages".to_string(),
             kind: "messages".to_string(),
         },
+        InferenceApiPattern {
+            method: "POST".to_string(),
+            path_glob: "/api/chat".to_string(),
+            protocol: "ollama_chat".to_string(),
+            kind: "ollama_chat".to_string(),
+        },
+        InferenceApiPattern {
+            method: "GET".to_string(),
+            path_glob: "/api/tags".to_string(),
+            protocol: "ollama_model_discovery".to_string(),
+            kind: "ollama_tags".to_string(),
+        },
+        InferenceApiPattern {
+            method: "POST".to_string(),
+            path_glob: "/api/show".to_string(),
+            protocol: "ollama_model_discovery".to_string(),
+            kind: "ollama_show".to_string(),
+        },
         InferenceApiPattern {
             method: "GET".to_string(),
             path_glob: "/v1/models".to_string(),
@@ -372,6 +390,37 @@ mod tests {
         assert!(result.is_none());
     }
 
+    #[test]
+    fn detect_ollama_chat() {
+        let patterns = default_patterns();
+        let result = detect_inference_pattern("POST", "/api/chat", &patterns);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().protocol, "ollama_chat");
+    }
+
+    #[test]
+    fn detect_ollama_tags() {
+        let patterns = default_patterns();
+        let result = detect_inference_pattern("GET", "/api/tags", &patterns);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().protocol, "ollama_model_discovery");
+    }
+
+    #[test]
+    fn detect_ollama_show() {
+        let patterns = default_patterns();
+        let result = detect_inference_pattern("POST", "/api/show", &patterns);
+        assert!(result.is_some());
+        assert_eq!(result.unwrap().protocol, "ollama_model_discovery");
+    }
+
+    #[test]
+    fn no_match_ollama_chat_get() {
+        let patterns = default_patterns();
+        let result = detect_inference_pattern("GET", "/api/chat", &patterns);
+        assert!(result.is_none());
+    }
+
     #[test]
     fn detect_get_models() {
         let patterns = default_patterns();