Fix provider routing and Telegram memory

Author: sistemabritto

ADWs/runner.py

@@ -214,6 +214,74 @@ def run_claude(prompt: str, log_name: str = "unnamed", timeout: int = 600, agent
         agent_label = f"@{agent}"
     else:
         agent_label = ""
+
+    use_fallback = os.environ.get("ADW_PROVIDER_FALLBACK", "1").lower() not in (
+        "0", "false", "no",
+    )
+    if use_fallback:
+        try:
+            sys.path.insert(0, str(WORKSPACE / "dashboard" / "backend"))
+            from provider_fallback import invoke_with_fallback
+
+            provider_label = "[fallback]"
+            console.print(f"  [step]▶[/step] {log_name} [dim]{agent_label} {provider_label}[/dim]", end="")
+            start_time = datetime.now()
+            result = invoke_with_fallback(
+                prompt=prompt,
+                max_turns=10,
+                timeout_seconds=timeout,
+                agent=agent or "",
+            )
+            duration = (datetime.now() - start_time).total_seconds()
+            stdout = result.get("output", "") or ""
+            stderr = result.get("error", "") or ""
+            success = result.get("status") == "success"
+
+            usage = None
+            if result.get("tokens_in") is not None or result.get("tokens_out") is not None or result.get("cost_usd") is not None:
+                usage = {
+                    "input_tokens": result.get("tokens_in") or 0,
+                    "output_tokens": result.get("tokens_out") or 0,
+                    "cost_usd": result.get("cost_usd") or 0,
+                }
+
+            result_text = stdout
+            try:
+                json_result = json.loads(stdout)
+                usage = usage or _parse_usage(json_result)
+                result_text = json_result.get("result", stdout)
+            except (json.JSONDecodeError, TypeError, AttributeError):
+                pass
+
+            full_prompt = f"[agent:{agent}] {prompt}" if agent else prompt
+            returncode = 0 if success else 1
+            _log_to_file(log_name, full_prompt, result_text, stderr, returncode, duration, usage)
+            _save_metrics(log_name, duration, returncode, agent, result_text, usage)
+
+            model_info = f" | {result.get('provider_id')}:{result.get('model')}" if result.get("provider_id") else ""
+            if success:
+                cost_str = ""
+                if usage:
+                    tokens_total = usage["input_tokens"] + usage["output_tokens"]
+                    cost_str = f" | {tokens_total:,}tok | ${usage['cost_usd']:.2f}"
+                console.print(f"\r  [success]✓[/success] {log_name} [dim]({duration:.0f}s{cost_str}{model_info})[/dim]")
+            else:
+                console.print(f"\r  [error]✗[/error] {log_name} [dim](fallback exhausted, {duration:.0f}s{model_info})[/dim]")
+                if stderr:
+                    for err_line in stderr.strip().splitlines()[:3]:
+                        console.print(f"    [error]{err_line}[/error]")
+
+            return {
+                "success": success,
+                "stdout": result_text,
+                "stderr": stderr,
+                "returncode": returncode,
+                "duration": duration,
+                "usage": usage,
+            }
+        except Exception as e:
+            console.print(f"\r  [warning]⚠[/warning] {log_name} [dim](fallback unavailable: {e}; using active provider)[/dim]")
+
     provider_label = f"[{cli_command}]" if cli_command != "claude" else ""
     console.print(f"  [step]▶[/step] {log_name} [dim]{agent_label} {provider_label}[/dim]", end="")
 

Makefile

@@ -150,20 +150,50 @@ uninstall:          ## 🗑️  Full cleanup — stop services, remove nginx, da
 bling-auth:         ## 🔐 Bling OAuth2 login (one-time: capture access + refresh tokens into .env)
 	@python3 .claude/skills/int-bling/scripts/bling_auth.py
 
-telegram:           ## 📨 Start Telegram bot in background (screen)
+telegram:           ## 📨 Start Telegram bot using active provider in background (screen)
 	@command -v screen >/dev/null 2>&1 || { echo "❌ 'screen' is not installed — run: sudo apt install screen"; exit 1; }
-	@command -v bun >/dev/null 2>&1 || [ -x "$$HOME/.bun/bin/bun" ] || { echo "❌ 'bun' is not installed (required by the telegram plugin MCP) — run: curl -fsSL https://bun.sh/install | bash"; exit 1; }
-	@if screen -list | grep -q '\.telegram'; then \
+	@if screen -list | grep -qE '\.telegram[[:space:]]'; then \
 		echo "⚠ Telegram bot is already running. Use 'make telegram-stop' first or 'make telegram-attach' to connect."; \
 	else \
-		screen -dmS telegram env CLAUDE_CODE_USE_OPENAI=1 OPENAI_MODEL=codexplan claude --channels plugin:telegram@claude-plugins-official --dangerously-skip-permissions; \
-		echo "✅ Telegram bot running on Codex (GPT-5.5) in background (screen: telegram)"; \
+		screen -dmS telegram python3 scripts/telegram_provider_bot.py; \
+		printf "⏳ Waiting for Telegram provider bot"; \
+		for i in $$(seq 1 10); do \
+			pgrep -af '[p]ython3 scripts/telegram_provider_bot.py' >/dev/null && break; \
+			printf "."; sleep 1; \
+		done; \
+		pgrep -af '[p]ython3 scripts/telegram_provider_bot.py' >/dev/null && echo " ✅ ready" || { echo " ❌ Telegram provider bot did not start — check: screen -r telegram"; exit 1; }; \
+		echo "✅ Telegram bot running with active EvoNexus provider (screen: telegram)"; \
 		echo "📺 Ver: screen -r telegram"; \
 		echo "🛑 Parar: make telegram-stop"; \
 	fi
 
-telegram-stop:      ## 🛑 Stop the Telegram bot
-	@screen -S telegram -X quit 2>/dev/null && echo "✅ Telegram bot stopped" || echo "⚠ Was not running"
+telegram-channel:   ## 🧪 Start legacy Claude Code Channels Telegram bot via LiteLLM proxy
+	@command -v screen >/dev/null 2>&1 || { echo "❌ 'screen' is not installed — run: sudo apt install screen"; exit 1; }
+	@command -v bun >/dev/null 2>&1 || [ -x "$$HOME/.bun/bin/bun" ] || { echo "❌ 'bun' is not installed (required by the telegram plugin MCP) — run: curl -fsSL https://bun.sh/install | bash"; exit 1; }
+	@command -v curl >/dev/null 2>&1 || { echo "❌ 'curl' is not installed"; exit 1; }
+	@[ -x .venv/bin/litellm ] || { echo "❌ litellm not installed in .venv — run: uv pip install 'litellm[proxy]'"; exit 1; }
+	@if screen -list | grep -q '\.telegram-proxy'; then \
+		echo "ℹ LiteLLM proxy already running (screen: telegram-proxy)"; \
+	else \
+		screen -dmS telegram-proxy bash scripts/telegram_litellm_proxy.sh; \
+		printf "⏳ Starting LiteLLM proxy (Anthropic→NVIDIA) on :4000"; \
+		for i in $$(seq 1 30); do \
+			curl -s -m2 http://127.0.0.1:4000/health/readiness >/dev/null 2>&1 && break; \
+			printf "."; sleep 1; \
+		done; \
+		curl -s -m2 http://127.0.0.1:4000/health/readiness >/dev/null 2>&1 && echo " ✅ ready" || { echo " ❌ proxy failed to start — check: screen -r telegram-proxy"; exit 1; }; \
+	fi
+	@if screen -list | grep -qE '\.telegram[[:space:]]'; then \
+		echo "⚠ Telegram bot is already running. Use 'make telegram-stop' first or 'make telegram-attach' to connect."; \
+	else \
+		screen -dmS telegram env ANTHROPIC_BASE_URL=http://127.0.0.1:4000 ANTHROPIC_AUTH_TOKEN=sk-evonexus-telegram-local ANTHROPIC_MODEL=telegram-nvidia claude --channels plugin:telegram@claude-plugins-official --dangerously-skip-permissions; \
+		echo "✅ Legacy Telegram channel running (screen: telegram)"; \
+	fi
+
+telegram-stop:      ## 🛑 Stop the Telegram bot (and its LiteLLM proxy)
+	@screen -S telegram -X quit 2>/dev/null && echo "✅ Telegram bot stopped" || echo "⚠ Bot was not running"
+	@screen -S telegram-debug -X quit 2>/dev/null && echo "✅ Telegram debug bot stopped" || true
+	@screen -S telegram-proxy -X quit 2>/dev/null && echo "✅ LiteLLM proxy stopped" || echo "⚠ Proxy was not running"
 
 telegram-attach:    ## 📺 Connect to Telegram terminal (Ctrl+A D to detach)
 	@screen -r telegram

config/litellm-telegram.yaml

@@ -0,0 +1,36 @@
+# LiteLLM proxy — Anthropic /v1/messages → NVIDIA NIM (OpenAI-compatible)
+#
+# Why: the Telegram bot runs via `claude --channels` (real Claude binary), which
+# only speaks the Anthropic Messages API. NVIDIA NIM is OpenAI-compatible. This
+# proxy translates between them so the bot can run on an NVIDIA model instead of
+# Anthropic. Point the bot at it with ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN.
+#
+# Start:  make telegram   (launches this proxy + the channel)
+# Model: z-ai/glm-5.1 on NVIDIA NIM.
+# MiniMax M3 works for direct calls, but can leave Claude Code channels stuck
+# in "Clauding..." through the Anthropic translation path.
+
+model_list:
+  # Named entry used by ANTHROPIC_MODEL.
+  # Use the native nvidia_nim provider (NOT openai/): the Anthropic /v1/messages
+  # endpoint routes openai/ models through the OpenAI Responses API, which NVIDIA
+  # NIM does not implement (→ 404). nvidia_nim/ forces /chat/completions.
+  - model_name: telegram-nvidia
+    litellm_params:
+      model: nvidia_nim/z-ai/glm-5.1
+      api_key: os.environ/NVIDIA_API_KEY
+
+  # Wildcard so Claude Code's background/small-model calls (title generation,
+  # quota probes) also route to NVIDIA instead of failing with an unknown model.
+  - model_name: "*"
+    litellm_params:
+      model: nvidia_nim/z-ai/glm-5.1
+      api_key: os.environ/NVIDIA_API_KEY
+
+litellm_settings:
+  # NVIDIA NIM rejects some OpenAI params Claude Code sends — drop them instead
+  # of returning 400 and breaking the conversation.
+  drop_params: true
+
+general_settings:
+  master_key: sk-evonexus-telegram-local

config/providers.example.json

@@ -1,5 +1,6 @@
 {
   "active_provider": "anthropic",
+  "telegram_provider": "",
   "providers": {
     "anthropic": {
       "name": "Anthropic (Claude nativo)",
@@ -35,7 +36,20 @@
         "OPENAI_MODEL": ""
       },
       "default_base_url": "https://integrate.api.nvidia.com/v1",
-      "default_model": "deepseek-ai/deepseek-v3.1",
+      "default_model": "z-ai/glm-5.1",
+      "fallback_models": [
+        "minimaxai/minimax-m3"
+      ],
+      "model_tiers": {
+        "opus": "z-ai/glm-5.1",
+        "sonnet": "z-ai/glm-5.1",
+        "haiku": "z-ai/glm-5.1"
+      },
+      "fallback_providers": [
+        "openrouter",
+        "codex_auth",
+        "anthropic"
+      ],
       "requires_logout": true
     },
     "omnirouter": {

dashboard/backend/heartbeat_runner.py

@@ -241,7 +241,11 @@ def step7_invoke_claude(
                 prompt=prompt,
                 max_turns=max_turns,
                 timeout_seconds=timeout_seconds,
-                agent=agent,
+                # The heartbeat prompt already embeds the full agent identity
+                # from .claude/agents/{agent}.md. Passing --agent here breaks
+                # OpenClaude-backed providers, which can misparse the expanded
+                # agent markdown as CLI options.
+                agent="",
             )
             # Preserve the step7 contract; provider_fallback already returns
             # status/output/error/duration_ms/tokens_*/cost_usd and adds

dashboard/backend/provider_fallback.py

@@ -116,17 +116,14 @@ def _read_providers_config() -> dict:
 # ── Default fallback chains ───────────────────────────────────────────────────
 
 # NVIDIA: models are independent — quota on one doesn't block others.
-# Order matches the validated fast, tool-calling-capable models (and mirrors
-# providers.json model_tiers / fallback_models). OpenRouter is intentionally
-# NOT in the chain — its stealth models 404 intermittently ("buga mto").
+# Primary is GLM 5.1 on NVIDIA; if quota/rate-limit hits, rotate inside
+# NVIDIA first, then leave the provider only after these core models fail.
 NVIDIA_MODEL_CHAIN = [
-    "z-ai/glm-5.1",                   # Primary (sonnet tier)
-    "moonshotai/kimi-k2.6",          # 2nd (opus tier, deep reasoning)
-    "qwen/qwen3.5-397b-a17b",        # 3rd
-    "stepfun-ai/step-3.7-flash",     # 4th (haiku tier, fastest)
+    "z-ai/glm-5.1",            # Primary — Telegram + agents default
+    "minimaxai/minimax-m3",    # 2nd
 ]
 
-# Provider chain: NVIDIA → Codex (GPT-5.5 OAuth) → Claude nativo
+# Provider chain: NVIDIA → OpenRouter (owl-alpha) → Codex (GPT-5.x OAuth) → Claude nativo
 DEFAULT_PROVIDER_CHAIN = [
     {
         "provider_id": "nvidia",
@@ -138,6 +135,16 @@ def _read_providers_config() -> dict:
         },
         "model_chain": NVIDIA_MODEL_CHAIN,
     },
+    {
+        "provider_id": "openrouter",
+        "cli_command": "openclaude",
+        "base_url": "https://openrouter.ai/api/v1",
+        "env_vars": {
+            "CLAUDE_CODE_USE_OPENAI": "1",
+            "OPENAI_BASE_URL": "https://openrouter.ai/api/v1",
+        },
+        "model_chain": ["openrouter/owl-alpha"],
+    },
     {
         "provider_id": "codex_auth",
         "cli_command": "openclaude",
@@ -178,26 +185,42 @@ def _build_provider_entry(provider_id: str, providers: dict) -> dict:
     prov = providers.get(provider_id, {})
     env_vars = {k: v for k, v in prov.get("env_vars", {}).items()
                 if v and k not in ("OPENAI_API_KEY", "OPENAI_MODEL")}
-    model_chain = prov.get("fallback_models",
-        [prov.get("default_model") or prov.get("env_vars", {}).get("OPENAI_MODEL")])
+
+    primary_model = prov.get("default_model") or prov.get("env_vars", {}).get("OPENAI_MODEL")
+    model_chain = []
+    if primary_model:
+        model_chain.append(primary_model)
+    for fallback_model in prov.get("fallback_models", []):
+        if fallback_model and fallback_model not in model_chain:
+            model_chain.append(fallback_model)
+
+    if not model_chain and prov.get("cli_command") == "claude":
+        model_chain = [None]
 
     return {
         "provider_id": provider_id,
         "cli_command": prov.get("cli_command", "openclaude"),
         "base_url": prov.get("default_base_url") or prov.get("env_vars", {}).get("OPENAI_BASE_URL"),
         "env_vars": env_vars,
-        "model_chain": [m for m in model_chain if m],
+        "model_chain": model_chain,
     }
 
 
 def _get_api_key(provider_id: str, config: dict) -> str:
+    if provider_id in {"codex_auth", "anthropic"}:
+        return ""
+
     prov = config.get("providers", {}).get(provider_id, {})
     env_vars = prov.get("env_vars", {})
     for key_name in ("OPENAI_API_KEY", "NVIDIA_API_KEY", "GEMINI_API_KEY"):
         val = env_vars.get(key_name, "")
         if val and "****" not in val:
             return val
-    return os.environ.get("OPENAI_API_KEY", "")
+
+    if provider_id in {"nvidia", "openrouter", "openai", "gemini"}:
+        return os.environ.get("OPENAI_API_KEY", "")
+
+    return ""
 
 
 # ── Attempt record ─────────────────────────────────────────────────────────────
@@ -211,6 +234,7 @@ class FallbackAttempt:
     prompt: str
     max_turns: int
     timeout_seconds: int
+    agent: str = ""
     env_overrides: dict = field(default_factory=dict)
     _result: dict | None = field(default=None, repr=False)
 
@@ -220,6 +244,7 @@ def run(self) -> dict:
             prompt=self.prompt,
             max_turns=self.max_turns,
             timeout_seconds=self.timeout_seconds,
+            agent=self.agent,
             env_overrides=self.env_overrides,
         )
         return self._result
@@ -254,6 +279,7 @@ def _invoke_cli(
     prompt: str,
     max_turns: int,
     timeout_seconds: int,
+    agent: str = "",
     env_overrides: dict | None = None,
 ) -> dict:
     cli_bin = shutil.which(cli_command)
@@ -267,7 +293,10 @@ def _invoke_cli(
         }
 
     cmd = [cli_bin, "--print", "--max-turns", str(max_turns),
-           "--dangerously-skip-permissions", "--output-format", "json", "--", prompt]
+           "--dangerously-skip-permissions", "--output-format", "json"]
+    if agent:
+        cmd.extend(["--agent", agent])
+    cmd.extend(["--", prompt])
 
     run_env = dict(os.environ)
     if env_overrides:
@@ -404,6 +433,7 @@ def attempts(
                     prompt=prompt,
                     max_turns=max_turns,
                     timeout_seconds=timeout_seconds,
+                    agent=agent,
                     env_overrides=env_overrides,
                 )
                 self._attempts_log.append(attempt)