v6.0: Fix Ollama Exec format error + add HF Inference API fallback

- Dockerfile: Fix Ollama binary download (use GitHub releases URL)
- app.py: Dual LLM backend - tries Ollama first, falls back to HF Inference API
- start.sh: Use qwen2.5:1.5b (fits free tier), validate binary before starting
- requirements.txt: Add huggingface_hub for Inference API
- Restore jira_adapter.py (was deleted)

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -0,0 +1,65 @@
+# Moltbot Hybrid Engine - Multi-service Dockerfile
+# Runs: FastAPI (port 7860) + Ollama (optional, background)
+# Build: 2026-02-08 v6.0
+# FIX v6: Dual LLM backend - Ollama (if available) + HF Inference API fallback
+# HF Inference API works on Free tier without GPU/Ollama
+
+FROM python:3.11-slim
+
+# Install packages required for HF Spaces Dev Mode + our needs
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash \
+    curl \
+    wget \
+    procps \
+    git \
+    git-lfs \
+    file \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Ollama AS ROOT - force amd64 (HF Spaces run amd64)
+# Download from GitHub releases (more reliable than ollama.com redirect)
+# Mark as OPTIONAL - app works without it via HF Inference API fallback
+RUN echo "Downloading Ollama (amd64)..." && \
+    curl -fSL --retry 3 --retry-delay 5 \
+        "https://github.com/ollama/ollama/releases/latest/download/ollama-linux-amd64" \
+        -o /usr/local/bin/ollama && \
+    chmod +x /usr/local/bin/ollama && \
+    echo "Ollama binary:" && file /usr/local/bin/ollama && \
+    echo "Size: $(du -h /usr/local/bin/ollama | cut -f1)" \
+    || echo "⚠️ Ollama download failed - will use HF Inference API only"
+
+# Create HF-required user (uid 1000)
+RUN useradd -m -u 1000 user
+
+# Create Ollama model storage directory owned by user
+RUN mkdir -p /home/user/ollama_models && chown -R user:user /home/user/ollama_models
+
+# Switch to user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:/usr/local/bin:$PATH \
+    OLLAMA_MODELS=/home/user/ollama_models \
+    OLLAMA_HOST=0.0.0.0
+
+# Set working directory to /app (required for dev mode)
+WORKDIR /app
+
+# Upgrade pip
+RUN pip install --no-cache-dir --upgrade pip
+
+# Copy all files with correct ownership
+COPY --chown=user . /app
+
+# Install Python dependencies (includes huggingface_hub for Inference API)
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Make start script executable
+RUN chmod +x start.sh
+
+# Expose HF Spaces port
+EXPOSE 7860
+
+# CMD required (not ENTRYPOINT) for dev mode compatibility
+CMD ["./start.sh"]

app.py

@@ -1,18 +1,22 @@
 """
-Moltbot Hybrid Engine - Production v3.0.0
-Multi-service: FastAPI endpoints + Ollama LLM integration
+Moltbot Hybrid Engine - Production v6.0.0
+Multi-service: FastAPI endpoints + Dual LLM backend (Ollama + HF Inference API)
 Runs on Hugging Face Spaces
-Build: 2026-02-06
+Build: 2026-02-08
+
+LLM Strategy:
+  1. Try Ollama (local, if installed and running)
+  2. Fallback to HuggingFace Inference API (always available, no GPU needed)
 
 Endpoints:
   GET  /              - Health check
   GET  /health        - Detailed health status
   GET  /security      - Security posture info
-  POST /api/generate  - LLM text generation via Ollama (called by cloud_llm_adapter.py)
-  POST /api/search    - Fuzzy file matching (called by file resolution)
+  POST /api/generate  - LLM text generation (Ollama → HF Inference API fallback)
+  POST /api/search    - Fuzzy file matching
   POST /api/analyze   - Report analysis (JSON body)
   POST /api/extract_date - Date extraction from filenames
-  POST /tools/analyze_report - Report analysis via file upload (called by trigger_cloud.py)
+  POST /tools/analyze_report - Report analysis via file upload
 """
 import os
 import re
@@ -29,8 +33,8 @@ logger = logging.getLogger("moltbot-engine")
 # Initialize App
 app = FastAPI(
     title="Moltbot Hybrid Engine",
-    description="AI agent for legal document processing - LLM + file matching + analysis",
-    version="3.0.0"
+    description="AI agent for legal document processing - Dual LLM + file matching + analysis",
+    version="6.0.0"
 )
 
 # API Key for authentication
@@ -38,13 +42,19 @@ API_KEY = os.environ.get("MOLTBOT_API_KEY", "default_insecure_key")
 if API_KEY == "default_insecure_key":
     logger.warning("MOLTBOT_API_KEY not set. Using insecure default.")
 
+# HuggingFace token for Inference API
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+
+# Default HF model for inference API fallback
+HF_MODEL = os.environ.get("HF_MODEL", "Qwen/Qwen2.5-7B-Instruct")
+
 
 # ============================================================
 # DATA MODELS
 # ============================================================
 
 class GenerateRequest(BaseModel):
-    model: str = "qwen2.5:7b"
+    model: str = "qwen2.5:1.5b"
     prompt: str
     stream: bool = False
 
@@ -123,11 +133,83 @@ def check_ollama_status() -> dict:
         return {"running": False, "error": result.stderr.strip()}
     except FileNotFoundError:
         return {"running": False, "error": "ollama binary not found"}
+    except OSError as e:
+        return {"running": False, "error": f"ollama exec error: {e}"}
     except subprocess.TimeoutExpired:
         return {"running": False, "error": "ollama list timed out"}
     except Exception as e:
         return {"running": False, "error": str(e)}
 
+
+def generate_with_ollama(model: str, prompt: str) -> Optional[str]:
+    """Try to generate text with local Ollama. Returns None if unavailable."""
+    try:
+        result = subprocess.run(
+            ["ollama", "run", model, prompt],
+            capture_output=True, text=True, timeout=120
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+        logger.warning(f"[OLLAMA] Non-zero return or empty output: {result.stderr[:200]}")
+        return None
+    except (FileNotFoundError, OSError) as e:
+        logger.warning(f"[OLLAMA] Not available: {e}")
+        return None
+    except subprocess.TimeoutExpired:
+        logger.warning("[OLLAMA] Timeout after 120s")
+        return None
+    except Exception as e:
+        logger.warning(f"[OLLAMA] Error: {e}")
+        return None
+
+
+def generate_with_hf_api(prompt: str, model: str = None) -> Optional[str]:
+    """Generate text using HuggingFace Inference API (free, no GPU needed)."""
+    try:
+        from huggingface_hub import InferenceClient
+
+        hf_model = model or HF_MODEL
+        token = HF_TOKEN if HF_TOKEN else None
+
+        client = InferenceClient(token=token)
+
+        # Use text_generation for instruct models
+        response = client.text_generation(
+            prompt=prompt,
+            model=hf_model,
+            max_new_tokens=1024,
+            temperature=0.7,
+            do_sample=True,
+        )
+
+        if response:
+            return response.strip()
+
+        logger.warning("[HF_API] Empty response")
+        return None
+
+    except ImportError:
+        logger.error("[HF_API] huggingface_hub not installed")
+        return None
+    except Exception as e:
+        logger.warning(f"[HF_API] Error: {e}")
+        # Try chat completion as fallback
+        try:
+            from huggingface_hub import InferenceClient
+            client = InferenceClient(token=HF_TOKEN if HF_TOKEN else None)
+            response = client.chat_completion(
+                model=model or HF_MODEL,
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=1024,
+                temperature=0.7,
+            )
+            if response and response.choices:
+                return response.choices[0].message.content.strip()
+        except Exception as e2:
+            logger.warning(f"[HF_API] Chat completion also failed: {e2}")
+        return None
+
+
 def analyze_report_data(data: dict) -> dict:
     """Analyze a verification report and return findings."""
     suggestions = []
@@ -142,7 +224,6 @@ def analyze_report_data(data: dict) -> dict:
     if blank_pages > 0:
         suggestions.append(f"{blank_pages} blank placeholder pages found - files listed in TOC but not embedded")
 
-    # Check per-bundle issues
     bundles = data.get("bundles", {})
     for bundle_name, bundle_data in bundles.items():
         if isinstance(bundle_data, dict):
@@ -170,20 +251,36 @@ def health_check():
     return {
         "status": "running",
         "service": "Moltbot Hybrid Engine",
-        "version": "3.0.0",
-        "ollama": ollama
+        "version": "6.0.0",
+        "ollama": ollama,
+        "hf_inference_api": {
+            "available": True,
+            "model": HF_MODEL,
+            "token_set": bool(HF_TOKEN)
+        }
     }
 
 @app.get("/health")
 def detailed_health():
-    """Detailed health check with Ollama status."""
+    """Detailed health check with LLM status."""
     ollama = check_ollama_status()
     return {
         "status": "healthy",
         "service": "moltbot-hybrid-engine",
-        "version": "3.0.0",
-        "ollama_running": ollama.get("running", False),
-        "ollama_models": ollama.get("models", []),
+        "version": "6.0.0",
+        "llm_backends": {
+            "ollama": {
+                "running": ollama.get("running", False),
+                "models": ollama.get("models", []),
+                "error": ollama.get("error"),
+            },
+            "hf_inference_api": {
+                "available": True,
+                "model": HF_MODEL,
+                "token_set": bool(HF_TOKEN),
+                "note": "Always available as fallback, no GPU needed"
+            }
+        },
         "endpoints": ["/", "/health", "/api/generate", "/api/search",
                       "/api/analyze", "/api/extract_date", "/tools/analyze_report"]
     }
@@ -200,59 +297,49 @@ def security_info():
     }
 
 
-# --- LLM Generation (called by cloud_llm_adapter.py) ---
+# --- LLM Generation (Dual Backend: Ollama → HF Inference API) ---
 
 @app.post("/api/generate")
 async def generate(request: GenerateRequest, x_api_key: str = Header(None)):
-    """Generate text using Ollama. Called by cloud_llm_adapter.py."""
+    """Generate text using LLM. Tries Ollama first, falls back to HF Inference API."""
     if not x_api_key or x_api_key != API_KEY:
         raise HTTPException(status_code=401, detail="Invalid or missing API Key")
 
     logger.info(f"[GENERATE] model={request.model}, prompt_len={len(request.prompt)}")
 
-    # Check Ollama availability first
-    ollama_status = check_ollama_status()
-    if not ollama_status.get("running"):
+    backend_used = None
+    response_text = None
+
+    # Backend 1: Try Ollama (local)
+    response_text = generate_with_ollama(request.model, request.prompt)
+    if response_text:
+        backend_used = "ollama"
+        logger.info(f"[GENERATE] Ollama success, response_len={len(response_text)}")
+
+    # Backend 2: Fallback to HF Inference API
+    if not response_text:
+        logger.info("[GENERATE] Ollama unavailable, trying HF Inference API...")
+        response_text = generate_with_hf_api(request.prompt)
+        if response_text:
+            backend_used = "hf_inference_api"
+            logger.info(f"[GENERATE] HF API success, response_len={len(response_text)}")
+
+    # Both failed
+    if not response_text:
         raise HTTPException(
             status_code=503,
-            detail=f"Ollama not available: {ollama_status.get('error', 'unknown')}"
+            detail="Both LLM backends unavailable. Ollama not running + HF Inference API failed. Check HF_TOKEN."
         )
 
-    try:
-        result = subprocess.run(
-            ["ollama", "run", request.model, request.prompt],
-            capture_output=True,
-            text=True,
-            timeout=120
-        )
-
-        if result.returncode != 0:
-            logger.error(f"[GENERATE] Ollama error: {result.stderr}")
-            raise HTTPException(
-                status_code=500,
-                detail=f"Ollama error: {result.stderr.strip()}"
-            )
-
-        response_text = result.stdout.strip()
-        logger.info(f"[GENERATE] Success, response_len={len(response_text)}")
-
-        return {
-            "model": request.model,
-            "response": response_text,
-            "done": True
-        }
-
-    except subprocess.TimeoutExpired:
-        logger.error("[GENERATE] Ollama timeout after 120s")
-        raise HTTPException(status_code=504, detail="Ollama request timed out after 120s")
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"[GENERATE] Unexpected error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    return {
+        "model": request.model,
+        "response": response_text,
+        "backend": backend_used,
+        "done": True
+    }
 
 
-# --- File Search (called by file resolution) ---
+# --- File Search ---
 
 @app.post("/api/search", response_model=FileSearchResponse)
 async def search_file(request: FileSearchRequest, x_api_key: str = Header(None)):
@@ -287,7 +374,7 @@ async def search_file(request: FileSearchRequest, x_api_key: str = Header(None))
 
 @app.post("/api/analyze", response_model=AnalysisResponse)
 async def analyze_report_json(request: AnalysisRequest, x_api_key: str = Header(None)):
-    """Analyze a verification report (JSON body). Called by API clients."""
+    """Analyze a verification report (JSON body)."""
     if not x_api_key or x_api_key != API_KEY:
         raise HTTPException(status_code=401, detail="Invalid or missing API Key")
 
@@ -299,16 +386,14 @@ async def analyze_report_json(request: AnalysisRequest, x_api_key: str = Header(
     )
 
 
-# --- Report Analysis via file upload (called by trigger_cloud.py) ---
+# --- Report Analysis via file upload ---
 
 @app.post("/tools/analyze_report")
 async def analyze_report_upload(
     report_file: UploadFile = File(...),
     x_api_key: str = Header(None)
 ):
-    """Analyze a verification report uploaded as a file.
-    Called by trigger_cloud.py and generate_bundles_final_corrected.py cloud reporting.
-    """
+    """Analyze a verification report uploaded as a file."""
     if not x_api_key or x_api_key != API_KEY:
         raise HTTPException(status_code=401, detail="Invalid or missing API Key")
 
@@ -324,7 +409,6 @@ async def analyze_report_upload(
 
     result = analyze_report_data(data)
     logger.info(f"[ANALYZE_REPORT] Found {result['critical_issues']} critical issues")
-
     return result
 
 

requirements.txt

@@ -3,3 +3,5 @@ fastapi>=0.104.0
 uvicorn>=0.24.0
 pydantic>=2.0.0
 python-multipart>=0.0.6
+huggingface_hub>=0.20.0
+requests>=2.31.0

shared/jira_adapter.py

@@ -0,0 +1,295 @@
+"""
+JIRA & CONFLUENCE ADAPTER
+=========================
+Zero-risk adapter for Jira and Confluence integration.
+Loads credentials from environment variables or config files.
+
+Usage:
+    from shared import JiraAdapter, ConfluenceAdapter
+    
+    jira = JiraAdapter()
+    jira.add_comment("COURT-123", "Bundle generated successfully")
+    
+    confluence = ConfluenceAdapter()
+    confluence.update_page("123456", "New content")
+
+Created: 2026-02-04
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# Try to import jira library
+try:
+    from jira import JIRA
+    JIRA_AVAILABLE = True
+except ImportError:
+    JIRA = None
+    JIRA_AVAILABLE = False
+
+# Try to import atlassian library for Confluence
+try:
+    from atlassian import Confluence
+    CONFLUENCE_AVAILABLE = True
+except ImportError:
+    Confluence = None
+    CONFLUENCE_AVAILABLE = False
+
+
+def _load_config_from_files() -> Dict[str, str]:
+    """
+    Load configuration from ~/.bashrc or ~/.secure/api_keys.
+    Returns dict with JIRA_URL, JIRA_EMAIL, JIRA_TOKEN, CONFLUENCE_URL.
+    """
+    config = {}
+    
+    # Files to search for credentials
+    config_files = [
+        Path.home() / ".bashrc",
+        Path.home() / ".secure" / "api_keys",
+        Path.home() / ".env",
+    ]
+    
+    patterns = {
+        'JIRA_URL': r'export\s+JIRA_URL\s*=\s*["\']?([^"\';\n]+)',
+        'JIRA_EMAIL': r'export\s+JIRA_EMAIL\s*=\s*["\']?([^"\';\n]+)',
+        'JIRA_TOKEN': r'export\s+JIRA_TOKEN\s*=\s*["\']?([^"\';\n]+)',
+        'CONFLUENCE_URL': r'export\s+CONFLUENCE_URL\s*=\s*["\']?([^"\';\n]+)',
+    }
+    
+    for config_file in config_files:
+        if config_file.exists():
+            try:
+                content = config_file.read_text()
+                for key, pattern in patterns.items():
+                    if key not in config or not config[key]:
+                        match = re.search(pattern, content)
+                        if match:
+                            config[key] = match.group(1).strip()
+            except Exception:
+                continue
+    
+    return config
+
+
+class JiraAdapter:
+    """
+    Robust Jira adapter with automatic credential loading.
+    """
+    
+    def __init__(self, url: str = None, email: str = None, token: str = None):
+        """
+        Initialize Jira connection.
+        Credentials loaded from: args > env vars > config files
+        """
+        # Load from config files first as fallback
+        file_config = _load_config_from_files()
+        
+        # Priority: args > env vars > config files
+        self.url = url or os.environ.get('JIRA_URL') or file_config.get('JIRA_URL')
+        self.email = email or os.environ.get('JIRA_EMAIL') or file_config.get('JIRA_EMAIL')
+        self.token = token or os.environ.get('JIRA_TOKEN') or file_config.get('JIRA_TOKEN')
+        
+        self.client = None
+        self.connected = False
+        self.error_message = None
+        
+        # Attempt connection
+        if self.url and self.email and self.token and JIRA_AVAILABLE:
+            try:
+                self.client = JIRA(
+                    server=self.url,
+                    basic_auth=(self.email, self.token)
+                )
+                self.connected = True
+                print(f"✅ [JiraAdapter] Connected to {self.url}")
+            except Exception as e:
+                self.error_message = str(e)
+                print(f"⚠️ [JiraAdapter] Connection failed: {e}")
+        else:
+            missing = []
+            if not self.url:
+                missing.append('JIRA_URL')
+            if not self.email:
+                missing.append('JIRA_EMAIL')
+            if not self.token:
+                missing.append('JIRA_TOKEN')
+            if not JIRA_AVAILABLE:
+                missing.append('jira library')
+            self.error_message = f"Missing: {', '.join(missing)}"
+            print(f"⚠️ [JiraAdapter] Not configured: {self.error_message}")
+    
+    def add_comment(self, issue_key: str, comment: str) -> bool:
+        """Add a comment to a Jira issue."""
+        if not self.connected:
+            print(f"⚠️ [JiraAdapter] Cannot add comment - not connected")
+            return False
+        
+        try:
+            self.client.add_comment(issue_key, comment)
+            print(f"✅ [JiraAdapter] Comment added to {issue_key}")
+            return True
+        except Exception as e:
+            print(f"❌ [JiraAdapter] Failed to add comment to {issue_key}: {e}")
+            return False
+    
+    def update_status(self, issue_key: str, status: str) -> bool:
+        """Update the status of a Jira issue."""
+        if not self.connected:
+            return False
+        
+        try:
+            transitions = self.client.transitions(issue_key)
+            for t in transitions:
+                if t['name'].lower() == status.lower():
+                    self.client.transition_issue(issue_key, t['id'])
+                    print(f"✅ [JiraAdapter] Status updated to '{status}' for {issue_key}")
+                    return True
+            print(f"⚠️ [JiraAdapter] Status '{status}' not found for {issue_key}")
+            return False
+        except Exception as e:
+            print(f"❌ [JiraAdapter] Failed to update status: {e}")
+            return False
+    
+    def create_issue(self, project: str, summary: str, description: str = "", 
+                     issue_type: str = "Task") -> Optional[str]:
+        """Create a new Jira issue. Returns issue key or None."""
+        if not self.connected:
+            return None
+        
+        try:
+            issue = self.client.create_issue(
+                project=project,
+                summary=summary,
+                description=description,
+                issuetype={'name': issue_type}
+            )
+            print(f"✅ [JiraAdapter] Created issue {issue.key}")
+            return issue.key
+        except Exception as e:
+            print(f"❌ [JiraAdapter] Failed to create issue: {e}")
+            return None
+    
+
+    def is_connected(self) -> bool:
+        """Check if JIRA connection is active (Added by Auto-Fix)."""
+        return self.connected and self.client is not None
+
+    def get_issue(self, issue_key: str) -> Optional[Dict[str, Any]]:
+        """Get issue details."""
+        if not self.connected:
+            return None
+        
+        try:
+            issue = self.client.issue(issue_key)
+            return {
+                'key': issue.key,
+                'summary': issue.fields.summary,
+                'status': issue.fields.status.name,
+                'description': issue.fields.description
+            }
+        except Exception as e:
+            print(f"❌ [JiraAdapter] Failed to get issue {issue_key}: {e}")
+            return None
+
+
+class ConfluenceAdapter:
+    """
+    Robust Confluence adapter with automatic credential loading.
+    """
+    
+    def __init__(self, url: str = None, email: str = None, token: str = None):
+        """
+        Initialize Confluence connection.
+        """
+        file_config = _load_config_from_files()
+        
+        self.url = url or os.environ.get('CONFLUENCE_URL') or file_config.get('CONFLUENCE_URL')
+        self.email = email or os.environ.get('JIRA_EMAIL') or file_config.get('JIRA_EMAIL')
+        self.token = token or os.environ.get('JIRA_TOKEN') or file_config.get('JIRA_TOKEN')
+        
+        self.client = None
+        self.connected = False
+        
+        if self.url and self.email and self.token and CONFLUENCE_AVAILABLE:
+            try:
+                self.client = Confluence(
+                    url=self.url,
+                    username=self.email,
+                    password=self.token,
+                    cloud=True
+                )
+                self.connected = True
+                print(f"✅ [ConfluenceAdapter] Connected to {self.url}")
+            except Exception as e:
+                print(f"⚠️ [ConfluenceAdapter] Connection failed: {e}")
+        else:
+            print(f"⚠️ [ConfluenceAdapter] Not configured")
+    
+    def is_connected(self) -> bool:
+        """Check if Confluence connection is active."""
+        return self.connected and self.client is not None
+
+    def update_page(self, page_id: str, content: str, title: str = None) -> bool:
+        """Update a Confluence page."""
+        if not self.connected:
+            return False
+        
+        try:
+            page = self.client.get_page_by_id(page_id)
+            current_title = title or page['title']
+            
+            self.client.update_page(
+                page_id=page_id,
+                title=current_title,
+                body=content
+            )
+            print(f"✅ [ConfluenceAdapter] Updated page {page_id}")
+            return True
+        except Exception as e:
+            print(f"❌ [ConfluenceAdapter] Failed to update page: {e}")
+            return False
+    
+    def get_page_content(self, page_id: str) -> Optional[str]:
+        """Get Confluence page content."""
+        if not self.connected:
+            return None
+        
+        try:
+            page = self.client.get_page_by_id(page_id, expand='body.storage')
+            return page['body']['storage']['value']
+        except Exception as e:
+            print(f"❌ [ConfluenceAdapter] Failed to get page: {e}")
+            return None
+
+
+def diagnose():
+    """Run diagnostic check on Jira/Confluence connectivity."""
+    print("=" * 60)
+    print("JIRA/CONFLUENCE ADAPTER DIAGNOSTIC")
+    print("=" * 60)
+    
+    config = _load_config_from_files()
+    print(f"\nConfig from files:")
+    for k, v in config.items():
+        masked = v[:10] + "..." if v and len(v) > 10 else v
+        print(f"  {k}: {masked}")
+    
+    print(f"\nJira library available: {JIRA_AVAILABLE}")
+    print(f"Confluence library available: {CONFLUENCE_AVAILABLE}")
+    
+    print("\nTesting Jira connection...")
+    jira = JiraAdapter()
+    print(f"  Connected: {jira.connected}")
+    
+    print("\nTesting Confluence connection...")
+    confluence = ConfluenceAdapter()
+    print(f"  Connected: {confluence.connected}")
+    
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    diagnose()

start.sh

@@ -1,12 +1,11 @@
 #!/bin/bash
 # Moltbot Hybrid Engine - Multi-service Startup
-# Starts: Ollama (background) + FastAPI/uvicorn (foreground on port 7860)
-# Build: 2026-02-06 v4.0
-# Ollama is pre-installed in Dockerfile (as root)
-# This script just starts it and pulls the model
+# Starts: Ollama (background, optional) + FastAPI/uvicorn (foreground on port 7860)
+# Build: 2026-02-08 v6.0
+# v6: Ollama is optional - HF Inference API provides fallback
 
 echo "============================================================"
-echo "  Moltbot Hybrid Engine v4.0.0 - Starting..."
+echo "  Moltbot Hybrid Engine v6.0.0 - Starting..."
 echo "============================================================"
 echo "  Timestamp: $(date '+%Y-%m-%d %H:%M:%S')"
 echo "  User: $(whoami) | Home: $HOME"
@@ -16,53 +15,71 @@ echo ""
 export OMP_NUM_THREADS=2
 export MKL_NUM_THREADS=2
 
-# 1. Verify Ollama is installed (was installed in Dockerfile)
+# 1. Check if Ollama binary exists and is valid
 echo "[1/4] Checking Ollama installation..."
+OLLAMA_OK=false
 if command -v ollama &> /dev/null; then
-    echo "  ✅ Ollama installed: $(ollama --version 2>/dev/null || echo 'present')"
+    # Verify binary is executable (not wrong architecture)
+    if file "$(which ollama)" 2>/dev/null | grep -q "ELF.*x86-64"; then
+        echo "  ✅ Ollama binary verified (x86-64 ELF)"
+        OLLAMA_OK=true
+    else
+        echo "  ⚠️  Ollama binary exists but may be wrong architecture"
+        echo "  Binary type: $(file "$(which ollama)" 2>/dev/null)"
+        echo "  → Will use HF Inference API fallback"
+    fi
 else
-    echo "  ❌ Ollama binary not found - this should not happen"
-    echo "  Attempting emergency install..."
-    curl -fsSL https://ollama.com/install.sh | sh 2>&1 | tail -3
+    echo "  ⚠️  Ollama binary not found"
+    echo "  → Will use HF Inference API fallback"
 fi
 
-# 2. Start Ollama server in background
-echo "[2/4] Starting Ollama server..."
-ollama serve &
-OLLAMA_PID=$!
-echo "  Ollama PID: $OLLAMA_PID"
+# 2. Start Ollama server in background (if binary is OK)
+if [ "$OLLAMA_OK" = true ]; then
+    echo "[2/4] Starting Ollama server..."
+    ollama serve &
+    OLLAMA_PID=$!
+    echo "  Ollama PID: $OLLAMA_PID"
 
-# 3. Wait for Ollama to be ready (up to 30 seconds)
-echo "[3/4] Waiting for Ollama to be ready..."
-MAX_WAIT=30
-WAITED=0
-while [ $WAITED -lt $MAX_WAIT ]; do
-    if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then
-        echo "  ✅ Ollama ready after ${WAITED}s"
-        break
-    fi
-    sleep 1
-    WAITED=$((WAITED + 1))
-done
+    # 3. Wait for Ollama to be ready (up to 20 seconds)
+    echo "[3/4] Waiting for Ollama to be ready..."
+    MAX_WAIT=20
+    WAITED=0
+    while [ $WAITED -lt $MAX_WAIT ]; do
+        if curl -s http://localhost:11434/api/tags > /dev/null 2>&1; then
+            echo "  ✅ Ollama ready after ${WAITED}s"
+            break
+        fi
+        sleep 1
+        WAITED=$((WAITED + 1))
+    done
 
-if [ $WAITED -ge $MAX_WAIT ]; then
-    echo "  ⚠️  Ollama not ready after ${MAX_WAIT}s"
-    echo "  LLM endpoints will return 503 until Ollama is available"
-else
-    # Pull model in background so FastAPI starts immediately
-    echo "  Checking for qwen2.5:7b model..."
-    if ! ollama list 2>/dev/null | grep -q "qwen2.5"; then
-        echo "  ⏳ Model not found, pulling qwen2.5:7b in background..."
-        echo "  (This takes 3-5 minutes on first run, model will be cached after)"
-        nohup ollama pull qwen2.5:7b > /tmp/ollama_pull.log 2>&1 &
-        PULL_PID=$!
-        echo "  Pull PID: $PULL_PID (check /tmp/ollama_pull.log for progress)"
+    if [ $WAITED -ge $MAX_WAIT ]; then
+        echo "  ⚠️  Ollama not ready after ${MAX_WAIT}s"
+        echo "  → LLM will use HF Inference API fallback"
     else
-        echo "  ✅ Model already available"
+        # Pull small model in background (1.5b for free tier)
+        echo "  Checking for qwen2.5:1.5b model..."
+        if ! ollama list 2>/dev/null | grep -q "qwen2.5"; then
+            echo "  ⏳ Model not found, pulling qwen2.5:1.5b in background..."
+            echo "  (Takes 1-2 minutes, model cached after first pull)"
+            nohup ollama pull qwen2.5:1.5b > /tmp/ollama_pull.log 2>&1 &
+            PULL_PID=$!
+            echo "  Pull PID: $PULL_PID"
+        else
+            echo "  ✅ Model already available"
+        fi
     fi
+else
+    echo "[2/4] Skipping Ollama (not available)"
+    echo "[3/4] Skipping Ollama model pull"
 fi
 
-# 4. Start FastAPI (foreground - this keeps the container alive)
+echo ""
+echo "  💡 HF Inference API fallback is always available"
+echo "     (Uses Qwen/Qwen2.5-7B-Instruct hosted by HuggingFace)"
+echo ""
+
+# 4. Start FastAPI (foreground - keeps container alive)
 echo "[4/4] Starting FastAPI on port 7860..."
 echo "============================================================"
 echo ""