bump version to v0.2.0

Author: rookiestar28

api/config.py

@@ -30,6 +30,7 @@
     from ..services.runtime_config import (
         ALLOWED_LLM_KEYS,
         get_admin_token,
+        get_apply_semantics,
         get_effective_config,
         is_loopback_client,
         update_config,
@@ -46,6 +47,7 @@
     from services.runtime_config import ALLOWED_LLM_KEYS  # type: ignore
     from services.runtime_config import (
         get_admin_token,
+        get_apply_semantics,
         get_effective_config,
         is_loopback_client,
         update_config,
@@ -482,11 +484,16 @@ async def config_put_handler(request: web.Request) -> web.Response:
 
     # Return updated config
     effective, sources = get_effective_config()
+
+    # R53: Calculate apply semantics
+    apply_info = get_apply_semantics(list(updates.keys()))
+
     return web.json_response(
         {
             "ok": True,
             "config": effective,
             "sources": sources,
+            "apply": apply_info,
         }
     )
 

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-openclaw"
 description = "Your own personal AIGC Factory. Any picture. Any reel. The Comfy way.©️"
-version = "0.1.9"
+version = "0.2.0"
 license = {text = "MIT"}
 readme = "README.md"
 requires-python = ">=3.10"

services/llm_client.py

@@ -119,31 +119,30 @@ def __init__(
             if info:
                 self.base_url = info.base_url
 
-        self.model = model or eff_config.get("model")
-
-        # R23: Model alias resolution via plugins (using async bridge)
-        if PLUGINS_AVAILABLE and self.model:
-            try:
-                from .plugins.async_bridge import run_async_in_sync_context
+        # R57: Strict Precedence (Arg > Config > Default)
+        # CRITICAL: Only inherit config['model'] if the effective provider matches config['provider'].
+        # If user overrides provider (e.g. "openai") but config has ("anthropic", "claude-3"),
+        # we must NOT use "claude-3" for "openai".
+
+        config_provider = eff_config.get("provider")
+        config_model = eff_config.get("model")
+
+        if model:
+            # 1. Explicit argument override
+            self.model = model
+        elif self.provider == config_provider:
+            # 2. Config usage (provider matches) -> use config model
+            self.model = config_model
+        else:
+            # 3. Provider mismatch (arg override vs config) -> do NOT use config model
+            # Fallback to default for the *new* provider
+            self.model = None
 
-                ctx = RequestContext(
-                    provider=self.provider,
-                    model=self.model,
-                    trace_id="init",
-                )
-                # Fix: Use async bridge even in __init__ just in case it's called from an async context
-                resolved = run_async_in_sync_context(
-                    plugin_manager.execute_first("model.resolve", ctx, self.model)
-                )
-                if resolved and resolved != self.model:
-                    logger.info(f"Model alias resolved: {self.model} -> {resolved}")
-                    self.model = resolved
-            except Exception as e:
-                logger.warning(f"Model resolution plugin failed (non-fatal): {e}")
+        # If we still have no model, try to get a default for the provider
+        if not self.model:
+            from .providers.catalog import DEFAULT_MODEL_BY_PROVIDER
 
-        # Fallback to catalog default if config model seems mismatched or empty?
-        # For now, trust the config (defaults to gpt-4o-mini).
-        # If user switches provider but not model, it might fail, but that's expected config behavior.
+            self.model = DEFAULT_MODEL_BY_PROVIDER.get(self.provider, "default")
 
         self.timeout = (
             timeout if timeout is not None else eff_config.get("timeout_sec", 120)

services/runtime_config.py

@@ -425,6 +425,42 @@ def validate_config_update(updates: Dict[str, Any]) -> Tuple[Dict[str, Any], lis
     return sanitized, errors
 
 
+def get_apply_semantics(updated_keys: list) -> Dict[str, list]:
+    """
+    R53: Determine apply semantics for updated keys.
+    Returns:
+        {
+            "applied_now": [keys applied immediately],
+            "restart_required": [keys requiring restart],
+            "notes": [explanatory notes]
+        }
+    """
+    applied_now = []
+    restart_required = []
+    notes = []
+
+    for key in updated_keys:
+        if key in ALLOWED_LLM_KEYS:
+            # LLM keys are read from file on every request (via get_effective_config),
+            # so they are effectively "applied now".
+            applied_now.append(key)
+        elif key in ALLOWED_SCHEDULER_KEYS:
+            # Scheduler config is env-only (not file-based) in current implementation,
+            # but if it were updateable via API, it might require restart or re-init.
+            # For now, this path is unused by config_put_handler which targets LLM config.
+            restart_required.append(key)
+            notes.append(f"{key} requires service restart to take effect.")
+        else:
+            # Unknown keys? Assume restart needed for safety if they slipped through validation
+            restart_required.append(key)
+
+    return {
+        "applied_now": sorted(applied_now),
+        "restart_required": sorted(restart_required),
+        "notes": notes,
+    }
+
+
 def update_config(updates: Dict[str, Any]) -> Tuple[bool, list]:
     """
     Update LLM config, persisting to file.

tests/repro_r53_apply.py

@@ -0,0 +1,47 @@
+
+import unittest
+import asyncio
+from unittest.mock import patch, MagicMock
+from api.config import config_put_handler
+
+class TestR53ApplyFeedbackRepro(unittest.TestCase):
+    def setUp(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+    def tearDown(self):
+        self.loop.close()
+
+    @patch("api.config.update_config")
+    @patch("api.config.get_effective_config")
+    @patch("api.config.require_admin_token")
+    @patch("api.config.check_rate_limit")
+    @patch("api.config.require_same_origin_if_no_token")
+    def test_put_returns_apply_metadata(self, mock_csrf, mock_rate, mock_auth, mock_get_config, mock_update):
+        # Setup mocks
+        mock_csrf.return_value = None
+        mock_rate.return_value = True
+        mock_auth.return_value = (True, None)
+        
+        # update_config succeeds
+        mock_update.return_value = (True, [])
+        
+        # get_effective_config returns the new state
+        mock_get_config.return_value = ({"provider": "openai"}, {"provider": "file"})
+
+        # Mock Request
+        request = MagicMock()
+        request.json = MagicMock(return_value=asyncio.Future())
+        request.json.return_value.set_result({"llm": {"provider": "openai"}})
+        request.remote = "127.0.0.1"
+
+        # Execute
+        response = self.loop.run_until_complete(config_put_handler(request))
+        body = json.loads(response.body)
+
+        # Assertion: R53 requires an 'apply' field in the PUT /config response.
+        self.assertIn("apply", body, "R53 Failure: Response missing 'apply' metadata")
+
+import json
+if __name__ == "__main__":
+    unittest.main()

tests/repro_r57_precedence.py

@@ -0,0 +1,31 @@
+
+import unittest
+from unittest.mock import patch, MagicMock
+from services.llm_client import LLMClient
+
+class TestR57PrecedenceRepro(unittest.TestCase):
+    @patch("services.runtime_config.get_effective_config")
+    def test_provider_model_contamination(self, mock_get_config):
+        # Scenario: Config has Provider A and Model A
+        mock_get_config.return_value = (
+            {"provider": "anthropic", "model": "claude-3-opus", "base_url": ""},
+            {"provider": "file", "model": "file"}
+        )
+
+        # User requests Provider B explicitly (e.g. via "Test Connection" with overrides)
+        # They do NOT specify a model (failed to select one, or just testing provider default)
+        client = LLMClient(provider="openai")
+
+        # CURRENT BEHAVIOR (Expected Failure): 
+        # The client picks up "claude-3-opus" from config because it's not None.
+        # But "claude-3-opus" is invalid for "openai".
+        
+        print(f"DEBUG: Client Provider={client.provider}, Model={client.model}")
+
+        # Assertion: We want the model to BE CLEAN (None or provider default), not the config's model.
+        # If this fails, it means we reproduced the issue.
+        self.assertNotEqual(client.model, "claude-3-opus", 
+            "R57 Failure: Client inherited incompatible model from config for a different provider")
+
+if __name__ == "__main__":
+    unittest.main()

web/tabs/job_monitor_tab.js

@@ -33,6 +33,7 @@ export function addJob(promptId, traceId = null) {
 export const jobMonitorTab = {
     id: "job-monitor",
     title: "Jobs",
+    icon: "pi pi-briefcase",
     render: async (container) => {
         loadJobs();
         container.innerHTML = "";

web/tabs/settings_tab.js

@@ -8,6 +8,7 @@ import { getAdminErrorMessage } from "../admin_errors.js";
 export const settingsTab = {
     id: "settings",
     title: "Settings",
+    icon: "pi pi-cog",
     render: async (container) => {
         // IMPORTANT (UI layout): `.moltbot-content` has `overflow: hidden`.
         // This tab MUST render its own scroll container (`.moltbot-scroll-area`),
@@ -128,7 +129,14 @@ export const settingsTab = {
         // -- LLM Settings Section --
         const llmSec = createSection("LLM Settings");
         if (configRes.ok) {
-            const { config, sources, providers } = configRes.data;
+            // R54: Null-safe destructuring with defaults
+            const data = configRes.data || {};
+            const config = data.config || {};
+            const sources = data.sources || {};
+            const providers = data.providers || [];
+            // R53: Apply feedback (optional, for debug/toast later)
+            const applyInfo = data.apply || {};
+
 
             // Provider dropdown
             const providerRow = createFormRow("Provider", sources.provider === "env");
@@ -380,9 +388,22 @@ export const settingsTab = {
                 };
 
                 const res = await moltbotApi.putConfig(updates, token);
+                // R53: Hot-Reload Feedback
                 if (res.ok) {
-                    statusDiv.textContent = "✓ Saved! Restart ComfyUI to apply.";
-                    statusDiv.className = "moltbot-status ok";
+                    const apply = res.data?.apply || {};
+                    let msg = "✓ Saved!";
+
+                    if (apply.restart_required?.length > 0) {
+                        msg += " Restart required for: " + apply.restart_required.join(", ");
+                        statusDiv.className = "moltbot-status warning"; // Yellow/Orange
+                    } else if (apply.applied_now?.length > 0) {
+                        msg += " Applied immediately (Hot Reload).";
+                        statusDiv.className = "moltbot-status ok";
+                    } else {
+                        // No changes or unknown
+                        statusDiv.className = "moltbot-status ok";
+                    }
+                    statusDiv.textContent = msg;
                 } else {
                     const errorMsg = getAdminErrorMessage(res.error, res.status);
                     statusDiv.textContent = `✗ ${res.errors?.join(", ") || errorMsg}`;
@@ -396,7 +417,16 @@ export const settingsTab = {
             const testBtn = document.createElement("button");
             testBtn.className = "moltbot-btn moltbot-btn-secondary";
             testBtn.textContent = "Test Connection";
+
+            // R54: Debounced Test Action to prevent spam
+            // We use a separate handler because we need to manage button state (disabled/enabled)
+            // which debounce interferes with if not careful.
+            // Better strategy: Disable button immediately on click, re-enable after completion.
+            // Debounce is less critical here if we disable the button, but good for "auto-test on change" (future).
+            // For now, implementing "Disable while testing" is the better guard than generic debounce for a button click.
             testBtn.onclick = async () => {
+                if (testBtn.disabled) return;
+
                 const token = (tokenInput.value || MoltbotSession.getAdminToken() || "").trim();
                 if (token) MoltbotSession.setAdminToken(token);
 
@@ -408,22 +438,25 @@ export const settingsTab = {
                 // selected in the UI, even if the user hasn't clicked Save yet. Otherwise, the backend
                 // falls back to the effective config (often "openai") and produces confusing errors like:
                 // "API key not configured for provider 'openai'" while the UI is set to Gemini.
-                const res = await moltbotApi.testLLM(token, {
-                    provider: providerSelect.value,
-                    model: modelInput.value,
-                    base_url: baseUrlInput.value,
-                    timeout_sec: parseInt(timeoutInput.value) || 120,
-                    max_retries: parseInt(retriesInput.value) || 3,
-                });
-                if (res.ok) {
-                    statusDiv.textContent = "✓ Success! " + (res.response ? `"${res.response}"` : "");
-                    statusDiv.className = "moltbot-status ok";
-                } else {
-                    const errorMsg = getAdminErrorMessage(res.error, res.status);
-                    statusDiv.textContent = `✗ ${errorMsg}`;
-                    statusDiv.className = "moltbot-status error";
+                try {
+                    const res = await moltbotApi.testLLM(token, {
+                        provider: providerSelect.value,
+                        model: modelInput.value,
+                        base_url: baseUrlInput.value,
+                        timeout_sec: parseInt(timeoutInput.value) || 120,
+                        max_retries: parseInt(retriesInput.value) || 3,
+                    });
+                    if (res.ok) {
+                        statusDiv.textContent = "✓ Success! " + (res.response ? `"${res.response}"` : "");
+                        statusDiv.className = "moltbot-status ok";
+                    } else {
+                        const errorMsg = getAdminErrorMessage(res.error, res.status);
+                        statusDiv.textContent = `✗ ${errorMsg}`;
+                        statusDiv.className = "moltbot-status error";
+                    }
+                } finally {
+                    testBtn.disabled = false;
                 }
-                testBtn.disabled = false;
             };
             btnRow.appendChild(testBtn);
 

web/utils/debounce.js

@@ -0,0 +1,13 @@
+
+/**
+ * Simple debounce utility (R54 UI Guard).
+ * Prevents rapid-fire API calls (e.g. test connection spam).
+ */
+export function debounce(func, wait) {
+    let timeout;
+    return function (...args) {
+        const context = this;
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func.apply(context, args), wait);
+    };
+}