Upload folder using huggingface_hub

rlm_haiku/repl.py

@@ -27,12 +27,13 @@ TERSE_SYSTEM = (
 class Sub_RLM(RLM):
     """Depth-1 LM callee for the REPL environment."""
 
-    def __init__(self, model: str = "haiku", usage=None, terse: bool = False):
-        from rlm_haiku.utils.llm import ClaudeCodeClient
+    def __init__(self, model: str = "haiku", usage=None, terse: bool = False,
+                 backend: str = "claude"):
+        from rlm_haiku.utils.llm import make_client
 
         self.model = model
         self.terse = terse
-        self.client = ClaudeCodeClient(model=model, usage=usage)
+        self.client = make_client(model, usage=usage, backend=backend)
 
     def completion(self, prompt) -> str:
         """Single sub-LM call. Errors are returned as text so REPL code can react."""
@@ -83,6 +84,7 @@ class REPLEnv:
         usage=None,
         max_workers: int = 8,
         terse: bool = False,
+        backend: str = "claude",
     ):
         self.max_workers = max_workers
         # Store the original working directory
@@ -93,7 +95,7 @@ class REPLEnv:
 
 
         # Initialize minimal RLM / LM client. Change this to support more depths.
-        self.sub_rlm: RLM = Sub_RLM(model=recursive_model, usage=usage, terse=terse)
+        self.sub_rlm: RLM = Sub_RLM(model=recursive_model, usage=usage, terse=terse, backend=backend)
         
         # Create safe globals with only string-safe built-ins
         self.globals = {

rlm_haiku/rlm_repl.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional, Any
 
 from rlm_haiku import RLM
 from rlm_haiku.repl import REPLEnv
-from rlm_haiku.utils.llm import ClaudeCodeClient, Usage
+from rlm_haiku.utils.llm import Usage, make_client
 from rlm_haiku.utils.prompts import DEFAULT_QUERY, next_action_prompt, build_system_prompt
 import rlm_haiku.utils.utils as utils
 
@@ -30,7 +30,9 @@ class RLM_REPL(RLM):
                  max_workers: int = 8,
                  terse: bool = False,
                  require_repl: bool = False,
+                 backend: str = "claude",
                  ):
+        self.backend = backend
         self.terse = terse
         self.require_repl = require_repl
         self.api_key = api_key
@@ -38,7 +40,7 @@ class RLM_REPL(RLM):
         self.recursive_model = recursive_model
         self.usage = usage if usage is not None else Usage()
         self.max_workers = max_workers
-        self.llm = ClaudeCodeClient(model=model, usage=self.usage)
+        self.llm = make_client(model, usage=self.usage, backend=backend)
 
         # Track recursive call depth to prevent infinite loops
         self.repl_env = None
@@ -80,6 +82,7 @@ class RLM_REPL(RLM):
             usage=self.usage,
             max_workers=self.max_workers,
             terse=self.terse,
+            backend=self.backend,
         )
         
         return self.messages

rlm_haiku/utils/llm.py

@@ -192,3 +192,95 @@ if __name__ == "__main__":
     assert "391" in out, out
     assert usage.calls == 1 and usage.cost_usd > 0, usage.as_dict()
     print("ok:", out.strip(), usage.as_dict())
+
+
+class OllamaClient:
+    """Same interface as ClaudeCodeClient, backed by a local Ollama model.
+
+    Lets the RLM loop run on local weights instead of the Claude Code CLI. Uses
+    Ollama's Anthropic-compatible /v1/messages so message handling matches the
+    CLI backend exactly.
+    """
+
+    def __init__(
+        self,
+        model: str = "gemma4:e4b",
+        usage: Optional[Usage] = None,
+        base_url: str = "http://127.0.0.1:11434",
+        timeout: int = 900,
+        max_retries: int = 3,
+        max_prompt_chars: int | None = None,
+        max_tokens: int = 4096,
+    ):
+        self.model = model
+        self.usage = usage if usage is not None else Usage()
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        # Local models have far smaller windows than the hosted ones, and Ollama
+        # silently truncates past num_ctx rather than erroring.
+        self.max_prompt_chars = max_prompt_chars or 60_000
+        self.max_tokens = max_tokens
+
+    def completion(self, messages, **_) -> str:
+        import json as _json
+        import urllib.error
+        import urllib.request
+
+        system_prompt, prompt = ClaudeCodeClient._split(messages)
+        if len(prompt) > self.max_prompt_chars:
+            dropped = len(prompt) - self.max_prompt_chars
+            prompt = prompt[: self.max_prompt_chars] + (
+                f"\n\n[TRUNCATED: {dropped} characters dropped, over the "
+                f"{self.max_prompt_chars}-character limit. Use smaller chunks.]"
+            )
+
+        body: dict = {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "messages": [{"role": "user", "content": prompt}],
+        }
+        if system_prompt:
+            body["system"] = system_prompt
+
+        last_error = ""
+        for attempt in range(self.max_retries):
+            start = time.time()
+            try:
+                req = urllib.request.Request(
+                    f"{self.base_url}/v1/messages",
+                    data=_json.dumps(body).encode(),
+                    headers={"content-type": "application/json"},
+                )
+                with urllib.request.urlopen(req, timeout=self.timeout) as r:
+                    payload = _json.loads(r.read())
+                if "error" in payload:
+                    raise RuntimeError(str(payload["error"])[:300])
+                text = "".join(
+                    b.get("text", "") for b in payload.get("content", [])
+                    if b.get("type") == "text"
+                )
+                u = payload.get("usage", {}) or {}
+                self.usage.add(
+                    {"usage": {"input_tokens": u.get("input_tokens", 0),
+                               "output_tokens": u.get("output_tokens", 0)},
+                     "total_cost_usd": 0.0},  # local weights: no marginal cost
+                    time.time() - start,
+                )
+                return text
+            except Exception as e:  # noqa: BLE001
+                last_error = f"{type(e).__name__}: {e}"
+                if attempt < self.max_retries - 1:
+                    time.sleep(2 ** attempt * 2)
+
+        self.usage.add_error()
+        raise RuntimeError(f"ollama failed after {self.max_retries} attempts: {last_error}")
+
+
+def make_client(model: str, usage=None, backend: str = "claude", **kw):
+    """Pick an LM backend. `claude` = Claude Code CLI, `ollama` = local weights."""
+    if backend == "ollama":
+        return OllamaClient(model=model, usage=usage, **kw)
+    if backend == "claude":
+        return ClaudeCodeClient(model=model, usage=usage, **kw)
+    raise ValueError(f"unknown backend {backend!r}")