v1.0.2

v1.0.2

Author: pancacake

README.md

@@ -35,6 +35,8 @@
 
 ### 📦 Releases
 
+> **[2026.4.11]** [v1.0.2](https://github.com/HKUDS/DeepTutor/releases/tag/v1.0.2) — Search consolidation simplification with SearXNG fallback, provider switch fix, explicit runtime config in test runner, and frontend resource leak fixes.
+
 > **[2026.4.10]** [v1.0.1](https://github.com/HKUDS/DeepTutor/releases/tag/v1.0.1) — New Visualize capability with Chart.js/SVG rendering pipeline, quiz duplicate prevention with generation history, o4-mini model support, and server logging improvements.
 
 > **[2026.4.10]** [v1.0.0-beta.4](https://github.com/HKUDS/DeepTutor/releases/tag/v1.0.0-beta.4) — Embedding progress tracking with HTTP 429 rate limit retry, cross-platform start tour dependency management, and case-insensitive MIME validation fix.

assets/releases/ver1-0-2.md

@@ -0,0 +1,26 @@
+# DeepTutor v1.0.2 Release Notes
+
+**Release Date:** 2026.04.11
+
+## Highlights
+
+### Search Consolidation Simplification & SearXNG Fallback
+Removed the explicit `consolidation_type` parameter — consolidation now runs automatically for any provider that doesn't return its own answer. A new generic fallback formatter handles providers (e.g. SearXNG) that lack a dedicated Jinja2 template, fixing the "no template consolidation available" error. The `CONSOLIDATION_TYPES` constant and related config fields have been removed.
+
+### Provider Switch Fix
+Settings page now always overwrites `base_url` when the user selects a different provider, instead of only filling it when the field was previously empty. This prevents stale base URLs from persisting across provider changes.
+
+### Explicit Runtime Config in Test Runner
+`ConfigTestRunner` now builds LLM, Embedding, and Search configs directly from the resolved runtime catalog instead of relying on the global config cache, ensuring test runs always reflect the current active selection.
+
+### Frontend Resource Leak Fixes
+- Added `AbortController` cleanup across all Playground testers (ToolExecutor, DeepQuestionTester, DeepResearchTester, CapabilityTester) and the SaveToNotebookModal, preventing orphaned fetch requests on unmount or re-execution.
+- Introduced a `MAX_CACHED_SESSIONS = 20` eviction policy in UnifiedChatContext to prevent unbounded session memory growth.
+- WebSocket runners and retry timers are now properly cleaned up on provider unmount.
+- Fixed auto-scroll throttle timer leak by returning a cleanup function from the throttle effect.
+
+## Community Contributions
+
+- **@OlegSob-glitch** — SearXNG auto-fallback for search providers without templates (#286)
+
+**Full Changelog**: https://github.com/HKUDS/DeepTutor/compare/v1.0.1...v1.0.2

deeptutor/services/config/test_runner.py

@@ -13,7 +13,11 @@
 
 from .env_store import get_env_store
 from .model_catalog import get_model_catalog_service
-from .provider_runtime import resolve_search_runtime_config
+from .provider_runtime import (
+    resolve_embedding_runtime_config,
+    resolve_llm_runtime_config,
+    resolve_search_runtime_config,
+)
 
 
 def _redact(value: str) -> str:
@@ -115,11 +119,11 @@ def _run_sync(self, run: TestRun, catalog: dict[str, Any]) -> None:
 
             with temporary_env(env_values):
                 if service == "llm":
-                    asyncio.run(self._test_llm(run))
+                    asyncio.run(self._test_llm(run, catalog))
                 elif service == "embedding":
-                    asyncio.run(self._test_embedding(run, model or {}))
+                    asyncio.run(self._test_embedding(run, model or {}, catalog))
                 elif service == "search":
-                    self._test_search(run)
+                    self._test_search(run, catalog)
                 else:
                     raise ValueError(f"Unsupported service: {service}")
             if not run.cancelled and run.status == "running":
@@ -129,13 +133,26 @@ def _run_sync(self, run: TestRun, catalog: dict[str, Any]) -> None:
             run.status = "failed"
             run.emit("failed", str(exc))
 
-    async def _test_llm(self, run: TestRun) -> None:
+    async def _test_llm(self, run: TestRun, catalog: dict[str, Any]) -> None:
         from deeptutor.services.llm import clear_llm_config_cache, complete as llm_complete
-        from deeptutor.services.llm import get_llm_config, get_token_limit_kwargs
+        from deeptutor.services.llm import get_token_limit_kwargs
+        from deeptutor.services.llm.config import LLMConfig
 
         clear_llm_config_cache()
         run.emit("info", "Loading LLM config from the active catalog selection.")
-        llm_config = get_llm_config()
+        resolved = resolve_llm_runtime_config(catalog=catalog)
+        llm_config = LLMConfig(
+            model=resolved.model,
+            api_key=resolved.api_key,
+            base_url=resolved.base_url,
+            effective_url=resolved.effective_url,
+            binding=resolved.binding,
+            provider_name=resolved.provider_name,
+            provider_mode=resolved.provider_mode,
+            api_version=resolved.api_version,
+            extra_headers=resolved.extra_headers,
+            reasoning_effort=resolved.reasoning_effort,
+        )
         run.emit("info", f"Resolved model `{llm_config.model}` with binding `{llm_config.binding}`.")
         run.emit("info", f"Request target: {llm_config.base_url}")
         token_kwargs = get_token_limit_kwargs(llm_config.model, max_tokens=200)
@@ -155,14 +172,30 @@ async def _test_llm(self, run: TestRun) -> None:
         if not snippet:
             raise ValueError("LLM returned an empty response.")
 
-    async def _test_embedding(self, run: TestRun, model: dict[str, Any]) -> None:
-        from deeptutor.services.embedding import get_embedding_client, get_embedding_config
+    async def _test_embedding(self, run: TestRun, model: dict[str, Any], catalog: dict[str, Any]) -> None:
+        from deeptutor.services.embedding.client import EmbeddingClient
+        from deeptutor.services.embedding.config import EmbeddingConfig
 
         run.emit("info", "Loading embedding config from the active catalog selection.")
-        config = get_embedding_config()
+        resolved = resolve_embedding_runtime_config(catalog=catalog)
+        config = EmbeddingConfig(
+            model=resolved.model,
+            api_key=resolved.api_key,
+            base_url=resolved.base_url,
+            effective_url=resolved.effective_url,
+            binding=resolved.binding,
+            provider_name=resolved.provider_name,
+            provider_mode=resolved.provider_mode,
+            api_version=resolved.api_version,
+            extra_headers=resolved.extra_headers,
+            dim=resolved.dimension,
+            request_timeout=max(1, resolved.request_timeout),
+            batch_size=max(1, resolved.batch_size),
+            batch_delay=max(0.0, resolved.batch_delay),
+        )
         run.emit("info", f"Resolved embedding model `{config.model}` with binding `{config.binding}`.")
         run.emit("info", f"Request target: {config.base_url}")
-        client = get_embedding_client()
+        client = EmbeddingClient(config)
         vectors = await client.embed(["DeepTutor embedding smoke test"])
         if not vectors or not vectors[0]:
             raise ValueError("Embedding service returned an empty vector.")
@@ -179,10 +212,10 @@ async def _test_embedding(self, run: TestRun, model: dict[str, Any]) -> None:
                 f"Embedding dimension mismatch. expected={expected_dimension}, actual={actual_dimension}"
             )
 
-    def _test_search(self, run: TestRun) -> None:
+    def _test_search(self, run: TestRun, catalog: dict[str, Any]) -> None:
         from deeptutor.services.search import web_search
 
-        resolved = resolve_search_runtime_config()
+        resolved = resolve_search_runtime_config(catalog=catalog)
         if not resolved.requested_provider:
             run.status = "completed"
             run.emit("completed", "Search skipped because no active provider is configured.")

deeptutor/services/search/__init__.py

@@ -18,7 +18,7 @@
 )
 
 from .base import SEARCH_API_KEY_ENV, BaseSearchProvider
-from .consolidation import CONSOLIDATION_TYPES, PROVIDER_TEMPLATES, AnswerConsolidator
+from .consolidation import PROVIDER_TEMPLATES, AnswerConsolidator
 from .providers import (
     _DEPRECATED_UNSUPPORTED,
     get_available_providers,
@@ -84,12 +84,16 @@ def web_search(
     output_dir: str | None = None,
     verbose: bool = False,
     provider: str | None = None,
-    consolidation: str | None = None,
     consolidation_custom_template: str | None = None,
     consolidation_llm_model: str | None = None,
     **provider_kwargs: Any,
 ) -> dict[str, Any]:
-    """Execute web search and return DeepTutor structured response shape."""
+    """Execute web search and return DeepTutor structured response shape.
+
+    Consolidation is automatic for providers that return raw SERP results
+    (``supports_answer=False``).  Pass ``consolidation_llm_model`` to
+    upgrade from template formatting to LLM synthesis.
+    """
     config = _get_web_search_config()
     if not config.get("enabled", True):
         _logger.warning("Web search is disabled in config")
@@ -138,19 +142,16 @@ def web_search(
         _logger.error(f"[{search_provider.name}] Search failed: {exc}")
         raise Exception(f"{search_provider.name} search failed: {exc}") from exc
 
-    # Compatibility layer: only apply optional consolidation when requested.
-    if consolidation is None:
-        consolidation = config.get("consolidation")
-    if consolidation_custom_template is None:
-        consolidation_custom_template = config.get("consolidation_template") or None
-    if consolidation and not search_provider.supports_answer:
-        llm_config = {}
-        if consolidation_llm_model:
-            llm_config["model"] = consolidation_llm_model
+    # Auto-consolidate for providers that don't generate their own answers.
+    if not search_provider.supports_answer:
+        if consolidation_custom_template is None:
+            consolidation_custom_template = config.get("consolidation_template") or None
+        use_llm = bool(consolidation_llm_model)
+        llm_config = {"model": consolidation_llm_model} if consolidation_llm_model else None
         consolidator = AnswerConsolidator(
-            consolidation_type=consolidation,
+            use_llm=use_llm,
             custom_template=consolidation_custom_template,
-            llm_config=llm_config if llm_config else None,
+            llm_config=llm_config,
         )
         response = consolidator.consolidate(response)
 
@@ -184,9 +185,7 @@ def get_current_config() -> dict[str, Any]:
         "providers": get_providers_info(),
         "supported_providers": sorted(SUPPORTED_SEARCH_PROVIDERS),
         "deprecated_providers": sorted(DEPRECATED_SEARCH_PROVIDERS),
-        "consolidation": config.get("consolidation"),
         "consolidation_template": config.get("consolidation_template") or None,
-        "consolidation_types": CONSOLIDATION_TYPES,
         "template_providers": list(PROVIDER_TEMPLATES.keys()),
     }
 
@@ -205,7 +204,6 @@ def get_current_config() -> dict[str, Any]:
     "Citation",
     "SearchResult",
     "AnswerConsolidator",
-    "CONSOLIDATION_TYPES",
     "PROVIDER_TEMPLATES",
     "BaseSearchProvider",
     "SearchProvider",