Merge feat/settings-providers-panel: providers panel, gen-quality fixes, scalable course list

Brings 20 commits to main:
- Settings → LLM Providers admin panel (auth-kind taxonomy, Bedrock bearer,
  Ollama URL, per-provider test) + e2e selector fixes.
- Content-gen fixes: Issue #1 deck write-root/read-root reconciliation
  (resolve_study_dirs + recursive discovery); MiniMax tool_result correction,
  inline-XML tool-call fallback, transient-retry; --max-retries harness knob.
- Autonomous generate+judge+validate+report workflow (3 providers).
- Scalable course list: publisher field, mode-split Flashcards/Quizzes panels,
  collapsible publisher groups, search, compact rows (+37 e2e tests).

Author: NetDevAutomate

packages/studyloop/src/studyloop/cli/_web.py

@@ -39,11 +39,13 @@ def web(port: int, lan: bool, password: str, ttyd_port: int, dev: bool) -> None:
 
     import secrets
 
-    from studyloop.settings import load_raw_config
+    from studyloop.settings import resolve_study_dirs
 
     study_dirs: list[str] = []
     with contextlib.suppress(Exception):
-        study_dirs = load_raw_config().get("review", {}).get("directories", [])
+        # Falls back to content.base_path when review.directories is unset, so
+        # the review panels discover decks the generator just wrote.
+        study_dirs = resolve_study_dirs()
 
     # Resolve credentials: always read username from config; password from CLI > config > auto
     username = "study"

packages/studyloop/src/studyloop/content/generators/_retry.py

@@ -79,21 +79,42 @@ def call_with_correction(
     """
     history_extension: list[dict[str, Any]] = []
     last_error: str | None = None
+    last_transient: CardGenerationError | None = None
 
     for attempt in range(max_retries + 1):
         ctx = CallContext[T](
             attempt=attempt,
             last_error=last_error,
             history_extension=history_extension,
         )
-        tool_payload, new_history = call_fn(ctx)
+        try:
+            tool_payload, new_history = call_fn(ctx)
+        except CardGenerationError as exc:
+            # Transient call failure (e.g. a flaky provider returned an
+            # unparseable / tool-less response, or a momentary transport blip).
+            # Don't hard-fail the whole generation on a single bad emission —
+            # retry within the same budget. Some providers (MiniMax M2.7) only
+            # emit a valid tool call ~half the time, so one clean retry usually
+            # succeeds. The history is left unchanged (the bad turn is dropped).
+            last_transient = exc
+            last_error = f"Previous attempt failed to produce a usable tool call: {exc}"
+            continue
+
+        last_transient = None
         history_extension = new_history
 
         try:
             return model_cls.model_validate(tool_payload)
         except ValidationError as exc:
             last_error = f"Tool input did not match schema: {exc.errors()!r}"
 
+    # Exhausted the budget. If the last failure was a transient call error,
+    # surface that (it's more actionable than a stale schema error).
+    if last_transient is not None:
+        raise CardGenerationError(
+            f"Generator failed to produce a usable tool call after "
+            f"{max_retries + 1} attempts: {last_transient}"
+        )
     raise CardGenerationError(
         f"Generator returned invalid payload after {max_retries + 1} attempts: {last_error}"
     )

packages/studyloop/src/studyloop/content/generators/anthropic_compat.py

@@ -29,6 +29,7 @@
 from __future__ import annotations
 
 import json
+import re
 from typing import TYPE_CHECKING, Any
 
 import httpx
@@ -76,6 +77,48 @@
 _DEFAULT_MAX_TOKENS = 4096
 
 
+# MiniMax M2.7 sometimes emits the forced tool call as inline XML markup inside
+# a text block rather than a native Anthropic tool_use block, e.g.:
+#   <minimax:tool_call>
+#   <invoke name="emit_quiz_deck">
+#   <parameter name="title">"DT"</parameter>
+#   <parameter name="questions">[ ... JSON ... ]</parameter>
+#   </invoke>
+#   </minimax:tool_call>
+# Each <parameter> value is the JSON encoding of that key's value. We reassemble
+# them into the tool-input dict the schema expects.
+_INVOKE_RE = re.compile(r'<invoke\s+name="(?P<name>[^"]+)"\s*>(?P<body>.*?)</invoke>', re.DOTALL)
+_PARAM_RE = re.compile(
+    r'<parameter\s+name="(?P<key>[^"]+)"\s*>(?P<val>.*?)</parameter>', re.DOTALL
+)
+
+
+def _parse_inline_tool_call(text: str, expected_tool_name: str) -> dict[str, Any] | None:
+    """Parse MiniMax's inline ``<invoke>`` markup into a tool-input dict.
+
+    Returns the assembled tool input, or ``None`` if the text contains no
+    matching ``<invoke name="<expected_tool_name>">`` block (so a genuine
+    text-only refusal still surfaces as an error upstream).
+    """
+    for m in _INVOKE_RE.finditer(text):
+        if m.group("name") != expected_tool_name:
+            continue
+        body = m.group("body")
+        params: dict[str, Any] = {}
+        for pm in _PARAM_RE.finditer(body):
+            key = pm.group("key")
+            raw = pm.group("val").strip()
+            try:
+                params[key] = json.loads(raw)
+            except (ValueError, json.JSONDecodeError):
+                # Fall back to the raw string when a value isn't JSON-encoded
+                # (e.g. a bare title); the schema validator catches real misses.
+                params[key] = raw
+        if params:
+            return params
+    return None
+
+
 class AnthropicCompatGenerator:
     """Card generator backed by any Anthropic Messages-compatible API.
 
@@ -196,17 +239,29 @@ def _generate(
         tool_choice = {"type": "tool", "name": tool_name}
 
         def call(ctx: CallContext) -> tuple[Any, list[dict[str, Any]]]:
-            messages = list(base_messages) + list(ctx.history_extension)
-            if ctx.last_error is not None:
-                messages.append(
-                    {
-                        "role": "user",
-                        "content": (
-                            f"The previous tool call did not validate against the schema: "
-                            f"{ctx.last_error}. Re-emit a corrected payload that conforms."
-                        ),
-                    }
-                )
+            history = list(ctx.history_extension)
+            # On a retry, fill in the real validation error on the tool_result
+            # placeholder that the previous attempt appended. The Anthropic
+            # Messages spec requires the user turn after an assistant tool_use
+            # to be a tool_result for that tool_use id; MiniMax's /anthropic
+            # shim enforces this strictly (a plain-text user turn -> error
+            # 2013). Carrying the correction AS a tool_result keeps the
+            # alternation valid across all providers.
+            if ctx.last_error is not None and history:
+                last = history[-1]
+                if (
+                    last.get("role") == "user"
+                    and isinstance(last.get("content"), list)
+                    and last["content"]
+                    and last["content"][0].get("type") == "tool_result"
+                ):
+                    last["content"][0]["content"] = (
+                        f"The previous tool call did not validate against the "
+                        f"schema: {ctx.last_error}. Re-emit a corrected payload "
+                        f"that conforms exactly."
+                    )
+
+            messages = list(base_messages) + history
 
             payload: dict[str, Any] = {
                 "model": self._model.id,
@@ -224,18 +279,27 @@ def call(ctx: CallContext) -> tuple[Any, list[dict[str, Any]]]:
                 }
 
             resp = self._post_messages(payload)
-            tool_payload, assistant_turn = self._extract_tool_payload(resp, tool_name)
-            new_history = list(ctx.history_extension) + [assistant_turn]
-            if ctx.last_error is not None:
-                new_history.append(
-                    {
-                        "role": "user",
-                        "content": (
-                            f"The previous tool call did not validate against the schema: "
-                            f"{ctx.last_error}. Re-emit a corrected payload that conforms."
-                        ),
-                    }
-                )
+            tool_payload, assistant_turn, tool_use_id = self._extract_tool_payload(
+                resp, tool_name
+            )
+            # Append the assistant's tool_use turn followed immediately by a
+            # placeholder tool_result so the history stays protocol-valid. If
+            # validation fails, the NEXT attempt overwrites the placeholder
+            # content with the actual error (above).
+            new_history = [
+                *history,
+                assistant_turn,
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": tool_use_id,
+                            "content": "Acknowledged.",
+                        }
+                    ],
+                },
+            ]
             return tool_payload, new_history
 
         return call_with_correction(
@@ -266,14 +330,18 @@ def _post_messages(self, payload: dict[str, Any]) -> dict[str, Any]:
 
     def _extract_tool_payload(
         self, resp: dict[str, Any], expected_tool_name: str
-    ) -> tuple[dict[str, Any], dict[str, Any]]:
+    ) -> tuple[dict[str, Any], dict[str, Any], str]:
         """Pull the ``tool_use`` block out of an Anthropic Messages response.
 
         Anthropic returns ``content`` as a list of typed blocks. With
         forced tool_choice, exactly one of those blocks should be a
         ``{type:"tool_use", name, input}`` block. We assemble the
         assistant turn from the full content list so the correction-turn
         history sees what the model actually said.
+
+        Returns ``(tool_input, assistant_turn, tool_use_id)``. The
+        ``tool_use_id`` lets the caller build a protocol-valid
+        ``tool_result`` correction turn that references this exact call.
         """
         content = resp.get("content")
         if not isinstance(content, list) or not content:
@@ -289,11 +357,20 @@ def _extract_tool_payload(
                 break
 
         if tool_use_block is None:
+            # MiniMax M2.7 intermittently narrates the tool call as inline XML
+            # markup inside a text block instead of emitting a native tool_use
+            # block (a reasoning-model quirk). Parse that fallback before giving
+            # up, so generation doesn't fail ~half the time on this provider.
             text_blocks = [b for b in content if b.get("type") == "text"]
-            text = (text_blocks[0].get("text", "") if text_blocks else "")[:200]
+            full_text = "".join(b.get("text", "") for b in text_blocks)
+            inline = _parse_inline_tool_call(full_text, expected_tool_name)
+            if inline is not None:
+                assistant_turn = {"role": "assistant", "content": content}
+                return inline, assistant_turn, "toolu_inline"
+            preview = full_text[:200]
             raise CardGenerationError(
                 f"{self._profile.label} response missing tool_use block "
-                f"(expected {expected_tool_name!r}). Text content was: {text!r}"
+                f"(expected {expected_tool_name!r}). Text content was: {preview!r}"
             )
 
         if tool_use_block.get("name") != expected_tool_name:
@@ -314,7 +391,8 @@ def _extract_tool_payload(
             )
 
         assistant_turn = {"role": "assistant", "content": content}
-        return args, assistant_turn
+        tool_use_id = str(tool_use_block.get("id") or "toolu_correction")
+        return args, assistant_turn, tool_use_id
 
 
 __all__ = ["AnthropicCompatGenerator"]

packages/studyloop/src/studyloop/content/generators/bedrock.py

@@ -158,6 +158,20 @@ def _build_client(self, *, region: str, model: str) -> tuple[Any, str]:
             retries={"max_attempts": 1, "mode": "standard"},
         )
 
+        # Bearer-token fast-path. When AWS_BEARER_TOKEN_BEDROCK is set (a
+        # Bedrock API key, injected from the encrypted store at generation
+        # time), boto3's credential chain uses it directly — no named profile,
+        # and no STS get_caller_identity precheck (a bearer token is scoped to
+        # bedrock:CallWithBearerToken, not STS, so the precheck would wrongly
+        # fail). An invalid token fails fast on the first Converse call.
+        import os
+
+        if os.environ.get("AWS_BEARER_TOKEN_BEDROCK", "").strip():
+            return (
+                boto3.client("bedrock-runtime", region_name=region, config=boto_config),
+                model,
+            )
+
         profiles: list[str] = [self._bedrock.profile]
         if self._bedrock.profile_fallback and self._bedrock.profile_fallback not in profiles:
             profiles.append(self._bedrock.profile_fallback)

packages/studyloop/src/studyloop/content/generators/provider_profiles.py

@@ -70,7 +70,7 @@ class ProviderProfile:
 
     slug: str
     label: str
-    adapter: Literal["openai_compat", "anthropic_compat"]
+    adapter: Literal["openai_compat", "anthropic_compat", "bedrock", "ollama"]
     base_url: str
     auth_env: str
     models: list[ModelEntry] = field(default_factory=list)
@@ -203,6 +203,71 @@ class ProviderProfile:
             ),
         ],
     ),
+    # Bedrock uses boto3 + the Converse API, handled by the separate
+    # BedrockGenerator (not one of the two HTTP adapters). It authenticates
+    # with an AWS profile/SigV4 OR an AWS_BEARER_TOKEN_BEDROCK bearer token —
+    # availability is computed in the providers route, not via auth_env alone.
+    # Model IDs are cross-region inference profiles; verify in the Bedrock
+    # console before relying on them.
+    "bedrock": ProviderProfile(
+        slug="bedrock",
+        label="AWS Bedrock",
+        adapter="bedrock",
+        base_url="",
+        auth_env="AWS_PROFILE",
+        models=[
+            ModelEntry(
+                id="us.anthropic.claude-haiku-4-5-20251001-v1:0",
+                label="Claude Haiku 4.5 (Bedrock)",
+                cost_tier="cheap",
+                notes="Cross-region inference profile",
+            ),
+            ModelEntry(
+                id="us.anthropic.claude-sonnet-4-6-20251101-v1:0",
+                label="Claude Sonnet 4.6 (Bedrock)",
+                cost_tier="balanced",
+                notes="Cross-region inference profile",
+            ),
+        ],
+    ),
+    # Ollama is local and keyless. Handled by OllamaGenerator. The model list
+    # is a modest-footprint recommendation for machines without a large
+    # unified-memory GPU; the endpoint is user-editable (stored as the
+    # ``ollama_base_url`` secret). Per-host-profile model suggestions via the
+    # autoagent harness are a future phase.
+    "ollama": ProviderProfile(
+        slug="ollama",
+        label="Ollama (local)",
+        adapter="ollama",
+        base_url="http://localhost:11434",
+        auth_env="",
+        models=[
+            ModelEntry(
+                id="qwen2.5:7b",
+                label="Qwen 2.5 7B",
+                cost_tier="cheap",
+                notes="Default; good structured output",
+            ),
+            ModelEntry(
+                id="llama3.2:3b",
+                label="Llama 3.2 3B",
+                cost_tier="cheap",
+                notes="Fast, low RAM",
+            ),
+            ModelEntry(
+                id="gemma3:4b",
+                label="Gemma 3 4B",
+                cost_tier="cheap",
+                notes="Google; efficient",
+            ),
+            ModelEntry(
+                id="phi3.5:3.8b",
+                label="Phi-3.5 3.8B",
+                cost_tier="cheap",
+                notes="Microsoft; efficient",
+            ),
+        ],
+    ),
 }