fix(lm): implement OpenAI and Ollama LM adapters; support LM_PROVIDER; resolve abstract LM error

Author: haasonsaas

orbit_agent/config.py

@@ -93,6 +93,7 @@ def __post_init__(self):
 def _determine_model_and_key() -> tuple[str, Optional[str]]:
     """Determine which model and API key to use"""
     explicit_model = os.getenv("ORBIT_LM")
+    provider_hint = os.getenv("LM_PROVIDER")  # Optional compatibility env: openai|anthropic|ollama
     openai_key = os.getenv("OPENAI_API_KEY")
     anthropic_key = os.getenv("ANTHROPIC_API_KEY")
 
@@ -111,13 +112,26 @@ def _determine_model_and_key() -> tuple[str, Optional[str]]:
         else:
             return explicit_model, None
 
-    # Auto-detect based on available keys
+    # Auto-detect based on available keys or provider hint
+    if provider_hint:
+        hint = provider_hint.lower()
+        if hint.startswith("ollama"):
+            return DEFAULT_OLLAMA, None
+        if hint.startswith("openai"):
+            if not openai_key:
+                raise ValueError("LM_PROVIDER=openai requires OPENAI_API_KEY")
+            return DEFAULT_OPENAI, openai_key
+        if hint.startswith("anthropic"):
+            if not anthropic_key:
+                raise ValueError("LM_PROVIDER=anthropic requires ANTHROPIC_API_KEY")
+            return DEFAULT_ANTHROPIC, anthropic_key
+
     if openai_key:
         return DEFAULT_OPENAI, openai_key
     elif anthropic_key:
         return DEFAULT_ANTHROPIC, anthropic_key
     else:
-        logger.info("No API keys found, defaulting to Ollama")
+        logger.info("No API keys found and no provider hint, defaulting to Ollama")
         return DEFAULT_OLLAMA, None
 
 
@@ -185,15 +199,33 @@ def configure_lm() -> AppConfig:
     config = get_config()
 
     try:
-        # Use generic LM wrapper; provider inferred from model prefix (openai/, anthropic/, ollama_*)
-        # API keys are read from environment by provider integrations.
-        lm = dspy.LM(
-            model=config.lm.model,
-            temperature=config.lm.temperature,
-            max_tokens=config.lm.max_tokens,
-        )
-        dspy.configure(lm=lm)
-        logger.info(f"Configured LM via dspy.LM: {config.lm.model}")
+        # Use custom lightweight LM adapters compatible with dsp/dspy Predict
+        from .lm_providers import OpenAIChatLM, OllamaLM
+
+        model = config.lm.model
+        lm_impl = None
+        if model.startswith("openai/"):
+            mname = model.replace("openai/", "")
+            lm_impl = OpenAIChatLM(
+                model=mname,
+                api_key=config.lm.api_key or os.getenv("OPENAI_API_KEY"),
+                temperature=config.lm.temperature,
+                max_tokens=config.lm.max_tokens,
+                api_base=os.getenv("OPENAI_BASE_URL"),
+            )
+        elif model.startswith("ollama_chat/") or model.startswith("ollama/"):
+            mname = model.replace("ollama_chat/", "").replace("ollama/", "")
+            lm_impl = OllamaLM(
+                model=mname,
+                base_url=config.lm.api_base or os.getenv("OLLAMA_API_BASE", "http://localhost:11434"),
+                temperature=config.lm.temperature,
+                max_tokens=config.lm.max_tokens,
+            )
+        else:
+            raise ValueError(f"Unsupported model provider for '{model}'. Use openai/ or ollama_chat/.")
+
+        dspy.configure(lm=lm_impl)
+        logger.info(f"Configured LM: {config.lm.model}")
         return config
 
     except Exception as e:

orbit_agent/lm_providers.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import os
+import json
+from typing import List, Dict, Any
+
+import requests
+from dsp.modules.lm import LM
+
+
+class OpenAIChatLM(LM):
+    """Minimal OpenAI Chat Completions adapter for dsp/dspy LM interface.
+
+    Returns a list of completion strings for a given prompt.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None,
+        temperature: float = 0.0,
+        max_tokens: int = 400,
+        api_base: str | None = None,
+    ):
+        super().__init__(model)
+        self.provider = "openai"
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.api_base = api_base or os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+        self.kwargs["temperature"] = temperature
+        self.kwargs["max_tokens"] = max_tokens
+
+    def basic_request(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        if not self.api_key:
+            raise ValueError("OPENAI_API_KEY not set")
+
+        url = f"{self.api_base}/chat/completions"
+        payload = {
+            "model": self.kwargs["model"],
+            "messages": [
+                {"role": "system", "content": "You are a concise, direct startup advisor."},
+                {"role": "user", "content": prompt},
+            ],
+            "temperature": kwargs.get("temperature", self.kwargs.get("temperature", 0.0)),
+            "max_tokens": kwargs.get("max_tokens", self.kwargs.get("max_tokens", 400)),
+            "n": kwargs.get("n", self.kwargs.get("n", 1)),
+        }
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+        resp = requests.post(url, headers=headers, data=json.dumps(payload), timeout=60)
+        resp.raise_for_status()
+        return resp.json()
+
+    def __call__(self, prompt: str, only_completed: bool = True, return_sorted: bool = False, **kwargs) -> List[str]:
+        data = self.basic_request(prompt, **kwargs)
+        choices = data.get("choices", [])
+        out: List[str] = []
+        for ch in choices:
+            msg = ch.get("message", {})
+            content = msg.get("content")
+            if content:
+                out.append(content)
+        if not out and "error" in data:
+            raise RuntimeError(f"OpenAI error: {data['error']}")
+        if not out:
+            # Fallback to an empty string to avoid crashes
+            out = [""]
+        return out
+
+
+class OllamaLM(LM):
+    """Minimal Ollama generate adapter for dsp/dspy LM interface.
+
+    Uses /api/generate (non-streaming) and returns a single completion string.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        base_url: str = "http://localhost:11434",
+        temperature: float = 0.0,
+        max_tokens: int = 400,
+    ):
+        super().__init__(model)
+        self.provider = "ollama"
+        self.base_url = base_url.rstrip("/")
+        self.kwargs["temperature"] = temperature
+        self.kwargs["max_tokens"] = max_tokens
+
+    def basic_request(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        url = f"{self.base_url}/api/generate"
+        payload = {
+            "model": self.kwargs["model"],
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": kwargs.get("temperature", self.kwargs.get("temperature", 0.0)),
+                "num_predict": kwargs.get("max_tokens", self.kwargs.get("max_tokens", 400)),
+            },
+        }
+        resp = requests.post(url, json=payload, timeout=120)
+        resp.raise_for_status()
+        return resp.json()
+
+    def __call__(self, prompt: str, only_completed: bool = True, return_sorted: bool = False, **kwargs) -> List[str]:
+        data = self.basic_request(prompt, **kwargs)
+        text = data.get("response", "")
+        return [text]