fix(prompts,chat,dashboard): validate prompt inputs, fix /model provider stickiness, surface dashboard auth gap

Author: ctrl-gaurav

effgen/cli/_main.py

@@ -1170,10 +1170,17 @@ def serve_api(self, args):
             elif oidc:
                 self.print_success("Auth: OIDC / JWT")
 
+            public_dashboard = dev_mode or os.environ.get(
+                "EFFGEN_PUBLIC_DASHBOARD", "0"
+            ).strip() == "1"
+
             self.print(f"Starting server on {host}:{port}")
             self.print(f"  OpenAI-compatible API : http://{host}:{port}/v1")
             self.print(f"  Interactive docs      : http://{host}:{port}/docs")
-            self.print(f"  Dashboard             : http://{host}:{port}/dashboard")
+            dashboard_line = f"  Dashboard             : http://{host}:{port}/dashboard"
+            if not public_dashboard:
+                dashboard_line += "  (data requires an API key; set EFFGEN_PUBLIC_DASHBOARD=1 for local viewing)"
+            self.print(dashboard_line)
             self.print()
 
             uvicorn.run(
@@ -2666,6 +2673,10 @@ def create_parser():
             "  EFFGEN_OIDC_ISSUER /  enable OIDC/JWT auth instead of a static key.\n"
             "  EFFGEN_OIDC_CLIENT_ID\n"
             "  EFFGEN_PUBLIC_METRICS=1   serve /metrics without auth (default: auth).\n"
+            "  EFFGEN_PUBLIC_DASHBOARD=1 serve /dashboard/data.json + /dashboard/spans\n"
+            "                        without auth, for local viewing (default: auth;\n"
+            "                        the /dashboard page itself always loads, but its\n"
+            "                        data calls 401 without this or an API key).\n"
             "  EFFGEN_MODEL_POOL_SIZE    loaded models kept warm (default 4).\n"
             "  EFFGEN_NO_DOTENV=1    skip the .env filesystem search entirely, so\n"
             "                        only environment variables the orchestrator set\n"
@@ -2997,12 +3008,14 @@ def create_parser():
     prompts_render = prompts_subparsers.add_parser('render', help='Non-interactive: render a prompt to stdout')
     prompts_render.add_argument('prompt_name', metavar='name', help='Prompt name (e.g. research.literature_review.v1)')
     prompts_render.add_argument('--input', dest='input_file', metavar='FILE',
-                                help='JSON file with input variables (merged over fixture defaults)')
+                                help="JSON file with input variables, validated against the prompt's "
+                                     "input_schema (see 'prompts show <name>'); omit to render the fixture")
 
     prompts_run = prompts_subparsers.add_parser('run', help='Non-interactive: render + run through a model')
     prompts_run.add_argument('prompt_name', metavar='name', help='Prompt name')
     prompts_run.add_argument('--input', dest='input_file', metavar='FILE',
-                             help='JSON file with input variables')
+                             help="JSON file with input variables, validated against the prompt's "
+                                  "input_schema (see 'prompts show <name>'); omit to render the fixture")
     prompts_run.add_argument('--model', required=True, help='Model identifier to run against')
 
     # Load test command
@@ -4651,7 +4664,10 @@ def _handle_prompts_command(args, cli: "CLIInterface") -> int:
         if RICH_AVAILABLE and cli.console:
             from rich.table import Table
             t = Table(title="Prompt Library", show_lines=False)
-            t.add_column("Name", style="cyan")
+            # Names must never be clipped — they're the id a user types back
+            # into `prompts show`/`run`/`render`. "fold" wraps onto extra
+            # lines instead of the default ellipsis truncation.
+            t.add_column("Name", style="cyan", overflow="fold")
             t.add_column("Domain")
             t.add_column("Variant")
             t.add_column("Description")
@@ -4674,10 +4690,11 @@ def _handle_prompts_command(args, cli: "CLIInterface") -> int:
     # ---- show ----
     if cmd == 'show':
         name = args.name
+        from effgen.cli.playground import _key_error_message, _resolve_prompt
         try:
-            p = registry.get(name)
-        except KeyError:
-            cli.print_error(f"Prompt '{name}' not found.")
+            p, _resolved_name = _resolve_prompt(name)
+        except KeyError as exc:
+            cli.print_error(_key_error_message(exc, name))
             return 1
 
         cli.print_header(f"Prompt: {p.name}")

effgen/cli/chat.py

@@ -590,18 +590,45 @@ def _cmd_help(self) -> None:
             for cmd, desc in _SLASH_COMMANDS.items():
                 print(f"  {cmd:9s} {desc}")
 
+    def _resolve_swap_target(self, new_id: str) -> tuple[str | None, str]:
+        """Resolve a ``/model`` argument the same way a fresh ``chat -m <id>``
+        (no ``--provider``) would.
+
+        A ``provider:model`` prefix pins that provider explicitly, mirroring
+        startup resolution. A bare id clears any provider left over from a
+        prior explicit ``--provider`` flag, so the loader's own auto-detection
+        (catalog lookup / known-prefix matching) picks the right adapter
+        instead of forcing the new id through the *previous* session's
+        provider — which silently keeps the old adapter and fails every turn.
+        """
+        if ":" in new_id:
+            from effgen.models.registry import ProviderRegistry
+
+            prefix, rest = new_id.split(":", 1)
+            try:
+                known = ProviderRegistry.list_providers()
+            except Exception:  # noqa: BLE001
+                known = []
+            if prefix in known and rest:
+                return prefix, rest
+        return None, new_id
+
     def _cmd_model(self, arg: str) -> None:
         if not arg:
             self.cli.print(f"Active model: {self.model_id}")
             self.cli.print("Swap with:  /model <model-id>   (e.g. /model gpt-5-nano)")
             return
         new_id = arg.split()[0]
         old_id = self.model_id
-        self.model_id = new_id
+        old_provider = self.provider
+        new_provider, resolved_id = self._resolve_swap_target(new_id)
+        self.model_id = resolved_id
+        self.provider = new_provider
         try:
             self._rebuild()
         except Exception as e:  # noqa: BLE001
             self.model_id = old_id
+            self.provider = old_provider
             self.cli.print_error(f"Could not switch to '{new_id}': {e}")
             self._teach_model_error(e)
             # Restore the working agent.

effgen/cli/playground.py

@@ -116,8 +116,24 @@ def _resolve_prompt(name: str) -> tuple[LibraryPrompt, str]:
         raise KeyError(f"Prompt '{name}' is ambiguous; use one of: {options}") from exc
 
 
-def _key_error_message(exc: KeyError) -> str:
-    return str(exc.args[0]) if exc.args else str(exc)
+def _suggest_prompt_names(name: str, n: int = 3) -> list[str]:
+    """Closest registered prompt names to *name*, for a not-found error."""
+    import difflib
+
+    try:
+        candidates = [p.name for p in registry.all()]
+    except Exception:  # noqa: BLE001
+        return []
+    return difflib.get_close_matches(name, candidates, n=n, cutoff=0.5)
+
+
+def _key_error_message(exc: KeyError, name: str | None = None) -> str:
+    msg = str(exc.args[0]) if exc.args else str(exc)
+    if name and "not found in registry" in msg:
+        suggestions = _suggest_prompt_names(name)
+        if suggestions:
+            msg += f". Did you mean: {', '.join(suggestions)}?"
+    return msg
 
 
 # ---------------------------------------------------------------------------
@@ -200,12 +216,34 @@ def _run_prompt(rendered: str, model: str) -> str:
 # Non-interactive entry-points
 # ---------------------------------------------------------------------------
 
+def _validate_or_report(p: LibraryPrompt, inputs: dict[str, Any]) -> bool:
+    """Validate a non-empty --input object against the prompt's input_schema.
+
+    Returns True when it's safe to render. An empty *inputs* dict means no
+    --input was supplied (the fixture alone drives the render), so it skips
+    validation. Reports one message per violation and leaves rendering to
+    the caller to skip.
+    """
+    if not inputs:
+        return True
+    errors = p.validate_input(inputs)
+    if not errors:
+        return True
+    _print_err(f"Input for '{p.name}' does not match its input_schema:")
+    for msg in errors:
+        _print_err(f"  {msg}")
+    _print(f"Run 'effgen prompts show {p.name}' to see the schema and a valid fixture example.")
+    return False
+
+
 def cmd_render(name: str, inputs: dict[str, Any]) -> int:
     """Non-interactive render: print rendered prompt to stdout."""
     try:
         p, _resolved_name = _resolve_prompt(name)
     except KeyError as exc:
-        _print_err(_key_error_message(exc))
+        _print_err(_key_error_message(exc, name))
+        return 1
+    if not _validate_or_report(p, inputs):
         return 1
     try:
         merged = {**p.fixture, **inputs}
@@ -222,7 +260,9 @@ def cmd_run(name: str, inputs: dict[str, Any], model: str) -> int:
     try:
         p, _resolved_name = _resolve_prompt(name)
     except KeyError as exc:
-        _print_err(_key_error_message(exc))
+        _print_err(_key_error_message(exc, name))
+        return 1
+    if not _validate_or_report(p, inputs):
         return 1
     try:
         merged = {**p.fixture, **inputs}
@@ -348,7 +388,7 @@ def _cmd_select(self, rest: str) -> None:
         try:
             p, resolved_name = _resolve_prompt(name)
         except KeyError as exc:
-            _print_err(f"{_key_error_message(exc)}. Try 'list' to see available prompts.")
+            _print_err(f"{_key_error_message(exc, name)}. Try 'list' to see available prompts.")
             return
         self.session.prompt_name = resolved_name
         self.session.variables = dict(p.fixture)  # seed with fixture defaults
@@ -486,7 +526,7 @@ def _cmd_show(self, rest: str) -> None:
         try:
             p, _resolved_name = _resolve_prompt(name)
         except KeyError as exc:
-            _print_err(_key_error_message(exc))
+            _print_err(_key_error_message(exc, name))
             return
         _print(f"\nName:        {p.name}")
         _print(f"Domain:      {p.domain}")

effgen/core/agent_generation.py

@@ -21,6 +21,7 @@
     ModelNotFoundError,
     ModelRefusalError,
     classify_provider_error,
+    simplify_embedded_provider_error,
 )
 from ..observability import get_logger as _get_obs_logger
 from ..utils.structured_logging import (
@@ -589,6 +590,10 @@ def _build_error_detail(self, exc: Exception, model: Any) -> dict[str, Any]:
         # the server's error envelope) doesn't get that prefix stacked twice.
         raw = getattr(exc, "message", None) or getattr(exc, "refusal_message", None)
         raw_message = raw if isinstance(raw, str) and raw else str(exc)
+        # An adapter's actionable message can embed a raw SDK error body
+        # ("Error code: 413 - {'error': {...}}") verbatim — collapse that to
+        # its inner text so the response shows prose, not a dumped structure.
+        raw_message = simplify_embedded_provider_error(raw_message)
         try:
             message = get_redactor().scrub(raw_message)
         except Exception:  # redaction must never mask the underlying error

effgen/dashboard/static/app.js

@@ -46,6 +46,20 @@
     if (txt) { txt.textContent = online ? "Connected" : "Offline"; }
   }
 
+  function showAuthBanner() {
+    const el = $("auth-banner");
+    if (!el) return;
+    el.textContent = "Dashboard data requires authentication. Restart the server with "
+      + "EFFGEN_PUBLIC_DASHBOARD=1 for local viewing, or supply an API key "
+      + "(Authorization: Bearer <key> or X-API-Key: <key>).";
+    el.hidden = false;
+  }
+
+  function hideAuthBanner() {
+    const el = $("auth-banner");
+    if (el) el.hidden = true;
+  }
+
   // ------------------------------------------------------------------
   // Chart initialisation
   // ------------------------------------------------------------------
@@ -237,8 +251,14 @@
   async function fetchData() {
     try {
       const resp = await fetch("/dashboard/data.json", { cache: "no-store" });
+      if (resp.status === 401) {
+        setStatus(false);
+        showAuthBanner();
+        return;
+      }
       if (!resp.ok) throw new Error("HTTP " + resp.status);
       const data = await resp.json();
+      hideAuthBanner();
       setStatus(true);
       renderCards(data);
       renderSLO(data);

effgen/dashboard/static/index.html

@@ -21,6 +21,8 @@
     </div>
   </header>
 
+  <div id="auth-banner" class="auth-banner" role="alert" hidden></div>
+
   <main class="main">
 
     <!-- Row 1: summary cards -->

effgen/dashboard/static/style.css

@@ -69,6 +69,16 @@ body {
 }
 #refresh-btn:hover { color: var(--accent2); }
 
+/* ---- Auth banner ---- */
+.auth-banner {
+  background: rgba(245, 158, 11, 0.12);
+  border-bottom: 1px solid var(--warn);
+  color: var(--text);
+  padding: 0.6rem 1.5rem;
+  font-size: 0.85rem;
+}
+.auth-banner[hidden] { display: none; }
+
 /* ---- Layout ---- */
 .main {
   display: flex;

effgen/models/errors.py

@@ -9,6 +9,8 @@
 
 from __future__ import annotations
 
+import ast
+import re
 from dataclasses import dataclass
 
 # ---------------------------------------------------------------------------
@@ -562,3 +564,69 @@ def classify_provider_error(exc: Exception) -> ErrorClass:
         return _TRANSIENT
 
     return _UNKNOWN
+
+
+_SDK_ERROR_BODY_RE = re.compile(r"Error code: \d+ - \{")
+
+
+def _balanced_brace_end(text: str, open_index: int) -> int | None:
+    """Return the index just past the ``{...}`` starting at *open_index*
+    (which must be ``{``), respecting quoted strings. ``None`` if unbalanced."""
+    depth = 0
+    in_str = False
+    str_char = ""
+    i = open_index
+    while i < len(text):
+        ch = text[i]
+        if in_str:
+            if ch == "\\":
+                i += 2
+                continue
+            if ch == str_char:
+                in_str = False
+        elif ch in ("'", '"'):
+            in_str = True
+            str_char = ch
+        elif ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                return i + 1
+        i += 1
+    return None
+
+
+def simplify_embedded_provider_error(message: str) -> str:
+    """Collapse an embedded raw SDK error body down to its inner message.
+
+    OpenAI-compatible SDKs (openai, groq, together, fireworks, ...) format an
+    HTTP error's ``str()`` as ``Error code: N - {<python-dict-repr of the JSON
+    body>}``. An adapter that embeds that raw text inside its own actionable
+    message (e.g. "request too large for X: <raw body> — reduce the request
+    ...") ends up surfacing a dumped data structure instead of prose. This
+    extracts the body's ``error.message`` field and substitutes it in place of
+    the raw dict, leaving any surrounding text untouched. Returns *message*
+    unchanged if no embedded body is found or it can't be parsed.
+    """
+    match = _SDK_ERROR_BODY_RE.search(message)
+    if not match:
+        return message
+    brace_start = match.end() - 1
+    end = _balanced_brace_end(message, brace_start)
+    if end is None:
+        return message
+    try:
+        parsed = ast.literal_eval(message[brace_start:end])
+    except (ValueError, SyntaxError, RecursionError):
+        return message
+    inner = None
+    if isinstance(parsed, dict):
+        err = parsed.get("error")
+        if isinstance(err, dict) and isinstance(err.get("message"), str):
+            inner = err["message"]
+        elif isinstance(parsed.get("message"), str):
+            inner = parsed["message"]
+    if not inner:
+        return message
+    return message[: match.start()] + inner + message[end:]

effgen/models/groq_adapter.py

@@ -509,7 +509,10 @@ def _do_generate(
 
                 failed_tool_call = _parse_failed_generation_tool_call(msg)
                 if tools and "tool_use_failed" in msg_lower and failed_tool_call is not None:
-                    logger.warning(
+                    # Recovered, not actionable — the call still succeeds via
+                    # failed_generation. INFO (not WARNING) so a successful
+                    # turn emits no WARNING line by default; --verbose shows it.
+                    logger.info(
                         "Groq returned tool_use_failed but included a parseable tool call; "
                         "using failed_generation as structured tool call."
                     )

effgen/models/openai_adapter.py

@@ -149,7 +149,11 @@ def __init__(
         **kwargs,
     ):
         if model_name not in OPENAI_MODELS:
-            logger.warning(
+            # Informational fallback, not an actionable warning — a valid new
+            # or hot-swapped model id just isn't in the bundled catalog yet.
+            # Surfaced at INFO so it shows with --verbose without making a
+            # normal, successful run/chat turn look broken by default.
+            logger.info(
                 f"Model '{model_name}' is not in the OpenAI registry. "
                 f"Using conservative defaults (context=128k, pricing fallback). "
                 f"Call OpenAIAdapter.list_models() for registered ids."