fix pygmay

pygmyclaw.py

@@ -15,11 +15,8 @@ from huggingface_hub import hf_hub_download, upload_file
 
 # -------------------- Globals --------------------
 SCRIPT_DIR = Path(__file__).parent.resolve()
-import os
-
 DEFAULT_MODEL = os.environ.get("MODEL_NAME", "qwen3.5:0.8b")
-print("pymyclass loaded and default model is ")
-print(DEFAULT_MODEL)
+print("pymyclass loaded and default model is ", DEFAULT_MODEL)
 DEFAULT_ENDPOINT = "http://localhost:11434/api/generate"
 
 HF_TOKEN = os.environ.get("HF_TOKEN")
@@ -49,7 +46,6 @@ def download_hf_files():
                 local_path.write_text("{}")
                 print(f"Created empty {file_name}")
 
-
 # -------------------- PygmyClaw Agent --------------------
 class PygmyClaw:
     def __init__(self):
@@ -176,7 +172,7 @@ class PygmyClaw:
                     exec(prompt, {}, local_vars)
                     result = str(local_vars)
                 else:
-                    result = self.generate_with_ssd_cli(prompt)
+                    result = self.generate_with_ssd(prompt)
                     print("Raw output to upload:")
                     print(result)
 
@@ -202,68 +198,87 @@ class PygmyClaw:
             time.sleep(0.1)
         return self.memory_data[task_id]["response"]
 
-    # -------------------- Model / Ollama call --------------------
-    def generate_with_ssd_cli(self, prompt: str, model: str = DEFAULT_MODEL):
-        """
-        Run the model via Ollama CLI instead of HTTP request.
-        """
-        import subprocess
-
-        try:
-            result = subprocess.run(
-                ["ollama", "run", model, prompt],
-                capture_output=True,
-                text=True,
-                timeout=120
-            )
-            output = result.stdout.strip() if result.stdout else result.stderr.strip()
-            print('Run subprocess command:')
-            print(output)
-            return output
-        except subprocess.TimeoutExpired:
-            return "⏱️ Ollama CLI timed out."
-        except Exception as e:
-            return f"❌ Ollama CLI Error: {str(e)}"
-
+    # -------------------- Unified Model / Ollama call with automatic failover --------------------
     def generate_with_ssd(self, prompt, num_predict=600, timeout=120):
         """
-        Sends a prompt to the model endpoint and retrieves the full response.
-        Stores raw response and extracted Python code.
+        Automatically sends a prompt to the model endpoint or Ollama CLI.
+        - Tries HTTP first; if it fails, falls back to CLI.
+        - Caches which backend worked for future calls.
+        - Stores raw response and extracted Python code in self.memory_data.
+
+        Parameters:
+            prompt (str): Prompt for the model.
+            num_predict (int): Max tokens/predictions (for HTTP).
+            timeout (int): Request timeout in seconds.
+
+        Returns:
+            str: Full model response.
         """
-        payload = {
-            "model": self.model,
-            "prompt": prompt,
-            "stream": False,
-            "enable_thinking": False,
-            "options": {"num_predict": num_predict, "temperature": 0.2},
-        }
-
-        req = urllib.request.Request(
-            self.endpoint,
-            data=json.dumps(payload).encode("utf-8"),
-            headers={"Content-Type": "application/json"},
-            method="POST"
-        )
+        import json, re, textwrap, subprocess, urllib.request
 
-        try:
-            with urllib.request.urlopen(req, timeout=timeout) as resp:
-                resp_data = resp.read().decode("utf-8")
-                self.memory_data["last_raw_response"] = resp_data
+        # Track which backend worked
+        if not hasattr(self, "_ssd_backend"):
+            self._ssd_backend = "http"  # default try HTTP first
+
+        output = ""
+        backends_to_try = ["http", "cli"] if self._ssd_backend == "http" else ["cli", "http"]
 
+        for backend in backends_to_try:
+            if backend == "http":
+                payload = {
+                    "model": self.model,
+                    "prompt": prompt,
+                    "stream": False,
+                    "enable_thinking": False,
+                    "options": {"num_predict": num_predict, "temperature": 0.2},
+                }
+                req = urllib.request.Request(
+                    self.endpoint,
+                    data=json.dumps(payload).encode("utf-8"),
+                    headers={"Content-Type": "application/json"},
+                    method="POST"
+                )
+                try:
+                    with urllib.request.urlopen(req, timeout=timeout) as resp:
+                        output = resp.read().decode("utf-8")
+                    self._ssd_backend = "http"  # mark as working backend
+                    break
+                except Exception as e:
+                    output = f"❌ HTTP request failed: {e}"
+                    continue
+
+            elif backend == "cli":
                 try:
-                    data = json.loads(resp_data)
-                except json.JSONDecodeError:
-                    data = {"response": resp_data}
+                    result = subprocess.run(
+                        ["ollama", "run", self.model, prompt],
+                        capture_output=True,
+                        text=True,
+                        timeout=timeout
+                    )
+                    output = result.stdout.strip() if result.stdout else result.stderr.strip()
+                    self._ssd_backend = "cli"  # mark as working backend
+                    break
+                except subprocess.TimeoutExpired:
+                    output = "⏱️ Ollama CLI timed out."
+                except Exception as e:
+                    output = f"❌ CLI failed: {e}"
+                    continue
+
+        # Store raw response
+        self.memory_data["last_raw_response"] = output
+
+        # Parse JSON if possible
+        try:
+            data = json.loads(output)
+        except json.JSONDecodeError:
+            data = {"response": output}
 
-                full_text = data.get("response", resp_data)
+        full_text = data.get("response", output)
 
-                # Extract Python code
-                import re, textwrap
-                code_blocks = re.findall(r"```(?:python)?\s*(.*?)```", full_text, re.S | re.I)
-                code = "\n\n".join(code_blocks)
-                code = textwrap.dedent(code).replace("\t", "    ").strip()
-                self.memory_data["last_code"] = code
+        # Extract Python code
+        code_blocks = re.findall(r"```(?:python)?\s*(.*?)```", full_text, re.S | re.I)
+        code = "\n\n".join(code_blocks)
+        code = textwrap.dedent(code).replace("\t", "    ").strip()
+        self.memory_data["last_code"] = code
 
-                return full_text
-        except Exception as e:
-            return f"❌ Model request failed: {e}"
+        return full_text