calvyn-code 0.14.3 → 0.14.5

package/agent/auxiliary_client.py

@@ -2136,7 +2136,7 @@ def _is_rate_limit_error(exc: Exception) -> bool:
     return False
 
 
-def _is_connection_error(exc: Exception) -> bool:
+def _is_connection_error(exc: Exception) -> bool:
     """Detect connection/network errors that warrant provider fallback.
 
     Returns True for errors indicating the provider endpoint is unreachable
@@ -2170,8 +2170,21 @@ def _is_connection_error(exc: Exception) -> bool:
         "remoteprotocolerror",
         "localprotocolerror",
     )):
-        return True
-    return False
+        return True
+    return False
+
+
+def _is_not_found_error(exc: Exception) -> bool:
+    """Detect provider 404s that should fall back for auto auxiliary tasks."""
+    status = getattr(exc, "status_code", None)
+    if status == 404:
+        return True
+    err_lower = str(exc).lower()
+    return (
+        "http 404" in err_lower
+        or "404 not found" in err_lower
+        or "status code: 404" in err_lower
+    )
 
 
 def _is_auth_error(exc: Exception) -> bool:
@@ -4374,12 +4387,13 @@ def call_llm(
                 # payment / auth chains below using the temperature-stripped
                 # kwargs.  Re-raise only if the retry hit something those
                 # chains won't handle.
-                if not (
-                    _is_payment_error(retry_err)
-                    or _is_connection_error(retry_err)
-                    or _is_auth_error(retry_err)
-                    or "max_tokens" in retry_err_str
-                    or "unsupported_parameter" in retry_err_str
+                if not (
+                    _is_payment_error(retry_err)
+                    or _is_connection_error(retry_err)
+                    or _is_not_found_error(retry_err)
+                    or _is_auth_error(retry_err)
+                    or "max_tokens" in retry_err_str
+                    or "unsupported_parameter" in retry_err_str
                 ):
                     raise
                 first_err = retry_err
@@ -4409,9 +4423,9 @@ def call_llm(
             except Exception as retry_err:
                 # If the max_tokens retry also hits a payment or connection
                 # error, fall through to the fallback chain below.
-                if not (_is_payment_error(retry_err) or _is_connection_error(retry_err) or _is_rate_limit_error(retry_err)):
-                    raise
-                first_err = retry_err
+                if not (_is_payment_error(retry_err) or _is_connection_error(retry_err) or _is_not_found_error(retry_err) or _is_rate_limit_error(retry_err)):
+                    raise
+                first_err = retry_err
 
         # ── Nous auth refresh parity with main agent ──────────────────
         client_is_nous = (
@@ -4515,10 +4529,11 @@ def call_llm(
         # back to an alternative provider instead of exhausting retries
         # against the same rate-limited endpoint.
         should_fallback = (
-            _is_payment_error(first_err)
-            or _is_connection_error(first_err)
-            or _is_rate_limit_error(first_err)
-        )
+            _is_payment_error(first_err)
+            or _is_connection_error(first_err)
+            or _is_not_found_error(first_err)
+            or _is_rate_limit_error(first_err)
+        )
         # Only try alternative providers when the user didn't explicitly
         # configure this task's provider.  Explicit provider = hard constraint;
         # auto (the default) = best-effort fallback chain.  (#7559)
@@ -4533,10 +4548,12 @@ def call_llm(
                 _mark_provider_unhealthy(
                     _recoverable_pool_provider(resolved_provider, client) or resolved_provider
                 )
-            elif _is_rate_limit_error(first_err):
-                reason = "rate limit"
-            else:
-                reason = "connection error"
+            elif _is_rate_limit_error(first_err):
+                reason = "rate limit"
+            elif _is_not_found_error(first_err):
+                reason = "not found"
+            else:
+                reason = "connection error"
             logger.info("Auxiliary %s: %s on %s (%s), trying fallback",
                         task or "call", reason, resolved_provider, first_err)
             fb_client, fb_model, fb_label = _try_payment_fallback(
@@ -4725,12 +4742,13 @@ async def async_call_llm(
                     await client.chat.completions.create(**retry_kwargs), task)
             except Exception as retry_err:
                 retry_err_str = str(retry_err)
-                if not (
-                    _is_payment_error(retry_err)
-                    or _is_connection_error(retry_err)
-                    or _is_auth_error(retry_err)
-                    or "max_tokens" in retry_err_str
-                    or "unsupported_parameter" in retry_err_str
+                if not (
+                    _is_payment_error(retry_err)
+                    or _is_connection_error(retry_err)
+                    or _is_not_found_error(retry_err)
+                    or _is_auth_error(retry_err)
+                    or "max_tokens" in retry_err_str
+                    or "unsupported_parameter" in retry_err_str
                 ):
                     raise
                 first_err = retry_err
@@ -4760,9 +4778,9 @@ async def async_call_llm(
             except Exception as retry_err:
                 # If the max_tokens retry also hits a payment or connection
                 # error, fall through to the fallback chain below.
-                if not (_is_payment_error(retry_err) or _is_connection_error(retry_err) or _is_rate_limit_error(retry_err)):
-                    raise
-                first_err = retry_err
+                if not (_is_payment_error(retry_err) or _is_connection_error(retry_err) or _is_not_found_error(retry_err) or _is_rate_limit_error(retry_err)):
+                    raise
+                first_err = retry_err
 
         # ── Nous auth refresh parity with main agent ──────────────────
         client_is_nous = (
@@ -4847,10 +4865,11 @@ async def async_call_llm(
 
         # ── Payment / connection / rate-limit fallback (mirrors sync call_llm) ──
         should_fallback = (
-            _is_payment_error(first_err)
-            or _is_connection_error(first_err)
-            or _is_rate_limit_error(first_err)
-        )
+            _is_payment_error(first_err)
+            or _is_connection_error(first_err)
+            or _is_not_found_error(first_err)
+            or _is_rate_limit_error(first_err)
+        )
         is_auto = resolved_provider in {"auto", "", None}
         if should_fallback and is_auto:
             if _is_payment_error(first_err):
@@ -4858,10 +4877,12 @@ async def async_call_llm(
                 _mark_provider_unhealthy(
                     _recoverable_pool_provider(resolved_provider, client) or resolved_provider
                 )
-            elif _is_rate_limit_error(first_err):
-                reason = "rate limit"
-            else:
-                reason = "connection error"
+            elif _is_rate_limit_error(first_err):
+                reason = "rate limit"
+            elif _is_not_found_error(first_err):
+                reason = "not found"
+            else:
+                reason = "connection error"
             logger.info("Auxiliary %s (async): %s on %s (%s), trying fallback",
                         task or "call", reason, resolved_provider, first_err)
             fb_client, fb_model, fb_label = _try_payment_fallback(

package/bin/calvyn.js

@@ -18,6 +18,12 @@ function resolveCalvynBinary() {
   return path.join(packageRoot, ".venv", venvName, filename)
 }
 
+function resolveVenvPython() {
+  return isWindows
+    ? path.join(packageRoot, ".venv", "Scripts", "python.exe")
+    : path.join(packageRoot, ".venv", "bin", "python")
+}
+
 function runPostinstallIfNeeded() {
   const calvynBinary = resolveCalvynBinary()
   if (fs.existsSync(calvynBinary)) {
@@ -50,12 +56,15 @@ function runPostinstallIfNeeded() {
 }
 
 const args = process.argv.slice(2)
-const calvynBinary = runPostinstallIfNeeded()
-const result = spawnSync(calvynBinary, args, {
+runPostinstallIfNeeded()
+const venvPython = resolveVenvPython()
+const cliEntry = path.join(packageRoot, "cli.py")
+const result = spawnSync(venvPython, [cliEntry, ...args], {
   stdio: "inherit",
   shell: false,
   env: {
     ...process.env,
+    CALVYN_LAUNCHED_FROM_NPM: "",
     CALVYN_REPO_ROOT: packageRoot,
     CALVYN_HOME: process.env.CALVYN_HOME || path.join(require("os").homedir(), ".calvyn"),
   },

package/cli.py

@@ -6959,7 +6959,13 @@ class HermesCLI:
             try:
                 if ctx is None:
                     raise RuntimeError("inventory context unavailable")
-                providers = build_models_payload(ctx, max_models=50)["providers"]
+                providers = build_models_payload(
+                    ctx,
+                    include_unconfigured=True,
+                    picker_hints=True,
+                    canonical_order=True,
+                    max_models=50,
+                )["providers"]
             except Exception:
                 providers = []
 

package/hermes_cli/inventory.py

@@ -157,27 +157,31 @@ def build_models_payload(
 # ─── Internal: row post-processing ──────────────────────────────────────
 
 
-def _append_unconfigured_rows(rows: list[dict], ctx: ConfigContext) -> list[dict]:
-    """Build skeleton rows for canonical providers missing from ``rows``."""
-    from hermes_cli.models import CANONICAL_PROVIDERS, _PROVIDER_LABELS
+def _append_unconfigured_rows(rows: list[dict], ctx: ConfigContext) -> list[dict]:
+    """Build skeleton rows for canonical providers missing from ``rows``."""
+    from hermes_cli.models import CANONICAL_PROVIDERS, OPENROUTER_MODELS, _PROVIDER_LABELS, _PROVIDER_MODELS
 
     seen = {r["slug"].lower() for r in rows}
     cur = (ctx.current_provider or "").lower()
     extras: list[dict] = []
-    for entry in CANONICAL_PROVIDERS:
-        if entry.slug.lower() in seen:
-            continue
-        extras.append(
-            {
-                "slug": entry.slug,
-                "name": _PROVIDER_LABELS.get(entry.slug, entry.label),
-                "is_current": entry.slug.lower() == cur,
-                "is_user_defined": False,
-                "models": [],
-                "total_models": 0,
-                "source": "canonical",
-            }
-        )
+    for entry in CANONICAL_PROVIDERS:
+        if entry.slug.lower() in seen:
+            continue
+        if entry.slug == "openrouter":
+            models = [mid for mid, _ in OPENROUTER_MODELS]
+        else:
+            models = list(_PROVIDER_MODELS.get(entry.slug, []))
+        extras.append(
+            {
+                "slug": entry.slug,
+                "name": _PROVIDER_LABELS.get(entry.slug, entry.label),
+                "is_current": entry.slug.lower() == cur,
+                "is_user_defined": False,
+                "models": models,
+                "total_models": len(models),
+                "source": "canonical",
+            }
+        )
     return extras
 
 
@@ -196,10 +200,10 @@ def _apply_picker_hints(rows: list[dict]) -> None:
             continue
         # Distinguish authenticated rows (returned by
         # list_authenticated_providers) from skeleton rows (from
-        # _append_unconfigured_rows). The skeleton rows have empty
-        # `models` AND source="canonical"; authenticated rows have
-        # populated `models` OR a non-canonical source.
-        is_skeleton = row.get("source") == "canonical" and not row.get("models")
+        # _append_unconfigured_rows). Skeleton rows come from source="canonical";
+        # they may still carry static fallback models so the picker can show
+        # choices before credentials are configured.
+        is_skeleton = row.get("source") == "canonical"
         row["authenticated"] = not is_skeleton
         if not is_skeleton or row.get("is_user_defined"):
             continue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calvyn-code",
-  "version": "0.14.3",
+  "version": "0.14.5",
   "description": "Calvyn Code — AI агент с инструментами, мессенджерами и локальным CLI",
   "bin": {
     "calvyn": "./bin/calvyn.js",

package/run_agent.py

@@ -3210,12 +3210,32 @@ class AIAgent:
         except Exception:
             pass
 
-    def _emit_auxiliary_failure(self, task: str, exc: BaseException) -> None:
-        """Surface a compact warning for failed auxiliary work."""
-        try:
-            detail = self._summarize_api_error(exc)
-        except Exception:
-            detail = str(exc)
+    def _emit_auxiliary_failure(self, task: str, exc: BaseException) -> None:
+        """Surface a compact warning for failed auxiliary work."""
+        try:
+            from agent.auxiliary_client import (
+                _is_not_found_error,
+                _is_payment_error,
+                _is_rate_limit_error,
+            )
+        except Exception:
+            _is_payment_error = _is_rate_limit_error = _is_not_found_error = None
+
+        if task == "title generation":
+            try:
+                if (
+                    (_is_payment_error and _is_payment_error(exc))
+                    or (_is_rate_limit_error and _is_rate_limit_error(exc))
+                    or (_is_not_found_error and _is_not_found_error(exc))
+                ):
+                    logger.debug("Suppressing auxiliary %s warning: %s", task, exc)
+                    return
+            except Exception:
+                pass
+        try:
+            detail = self._summarize_api_error(exc)
+        except Exception:
+            detail = str(exc)
         detail = (detail or exc.__class__.__name__).strip()
         if len(detail) > 220:
             detail = detail[:217].rstrip() + "..."