Upload folder using huggingface_hub

plugins/README.md

@@ -1,3 +1,100 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5599dcd901336087fc051149679b2c3fb06597e772f5499d5ffa2bb33aeb7cb6
-size 5518
+# Agent Zero - Core Plugins
+
+This directory contains the system-level plugins bundled with Agent Zero.
+
+## Directory Structure
+
+- `plugins/`: Core system plugins. Reserved for framework updates — do not place custom plugins here.
+- `usr/plugins/`: The correct location for all user-developed and custom plugins. This directory is gitignored.
+
+## Documentation
+
+For detailed guides on how to create, extend, or configure plugins, refer to:
+
+- [`docs/agents/AGENTS.plugins.md`](../docs/agents/AGENTS.plugins.md): Full-stack plugin architecture, manifest format, extension points, and Plugin Index submission.
+- [`docs/developer/plugins.md`](../docs/developer/plugins.md): Human-facing developer guide covering the full plugin lifecycle.
+- [`AGENTS.md`](../AGENTS.md): Main framework guide and backend context.
+- [`skills/a0-plugin-router/SKILL.md`](../skills/a0-plugin-router/SKILL.md): Agent-facing entry point that routes plugin tasks to the appropriate specialist skill.
+- [`skills/a0-create-plugin/SKILL.md`](../skills/a0-create-plugin/SKILL.md): Agent-facing authoring workflow (local and community plugins).
+
+## What a Plugin Can Provide
+
+Plugins are automatically discovered based on the presence of a `plugin.yaml` file. Each plugin can contribute:
+
+- **Backend**: API handlers, tools, helpers, named lifecycle extensions, and implicit `@extensible` hooks under `extensions/python/_functions/...`
+- **Frontend**: HTML/JS UI contributions via core extension breakpoints
+- **Settings**: Isolated configuration scoped per-project and per-agent profile
+- **Activation**: Global and scoped ON/OFF rules via `.toggle-1` and `.toggle-0` files, including advanced per-scope switching in the WebUI
+- **Agent profiles**: Plugin-distributed subagent definitions under `agents/<profile>/agent.yaml`
+
+Backend extension layouts:
+- `extensions/python/<point>/` for named lifecycle hooks
+- `extensions/python/_functions/<module>/<qualname>/<start|end>/` for implicit `@extensible` hooks
+
+Do not use the retired flattened `extensions/python/<module>_<qualname>_<start|end>/` form.
+
+## Plugin Manifest
+
+Every plugin requires a `plugin.yaml` at its root:
+
+```yaml
+name: my_plugin              # required for community plugins
+title: My Plugin
+description: What this plugin does.
+version: 1.0.0
+settings_sections:
+  - agent
+per_project_config: false
+per_agent_config: false
+always_enabled: false
+```
+
+## Plugin Script (`execute.py`)
+
+Plugins can include an optional `execute.py` at the plugin root for user-triggered operations such as setup, post-install steps, maintenance, repairs, migrations, or resource refreshes. Users trigger it from the Plugin List UI.
+
+Guidelines:
+- Treat it as a manual plugin script, not as the primary way to use the plugin
+- Prefer making it safe to rerun, or detect state and explain why a rerun is not appropriate
+- Return `0` on success and print progress messages for user feedback
+- Use `hooks.py` instead when the behavior is framework-internal or should happen automatically
+
+## Runtime Hooks (`hooks.py`)
+
+Plugins can also include an optional `hooks.py` at the plugin root. The framework loads it on demand and can call exported hook functions by name through `helpers.plugins.call_plugin_hook(...)`.
+
+- `hooks.py` runs inside the **Agent Zero framework runtime and Python environment**.
+- Use it for framework-internal work such as install hooks, cache preparation, registration, or filesystem setup.
+- If it runs `sys.executable -m pip install ...`, packages are installed into the same Python environment that runs Agent Zero.
+- If you need to install into the separate agent runtime or into the system environment, explicitly target that environment from a subprocess by selecting the correct interpreter, virtualenv, or package manager.
+
+In Docker, `hooks.py` normally affects `/opt/venv-a0`; the agent execution runtime is `/opt/venv`.
+
+## Plugin Index & Community Sharing
+
+The **Plugin Index** at https://github.com/agent0ai/a0-plugins is the community-maintained registry of plugins available to all Agent Zero users.
+
+To share a plugin with the community:
+
+1. Create a standalone GitHub repository with the plugin contents at the repo root. The runtime `plugin.yaml` must include a `name` field matching the intended index folder name. Add a `LICENSE` file at the repo root (required for Plugin Index listings so users have explicit terms of use).
+2. Fork `https://github.com/agent0ai/a0-plugins` and add a folder `plugins/<your_plugin_name>/` containing a separate index manifest named `index.yaml` (not `plugin.yaml`):
+
+```yaml
+title: My Plugin
+description: What this plugin does.
+github: https://github.com/yourname/your-plugin-repo
+tags:
+  - tools
+```
+
+Optional additional fields: `screenshots` (up to 5 image URLs).
+
+3. Open a Pull Request. CI validates the submission; a maintainer reviews and merges.
+
+Note: The index `index.yaml` is a **different file with a different schema** from the runtime `plugin.yaml`. Folder names use `^[a-z0-9_]+$` (underscores, no hyphens) and must match the `name` field in the remote `plugin.yaml` exactly.
+
+## Plugin Hub
+
+Agent Zero now includes a built-in Plugin Hub flow through the always-enabled **Plugin Installer** plugin. From the **Plugins** dialog, users can either open the **Browse** tab or click **Install**, which opens the installer modal on its own **Browse** tab.
+
+The Plugin Hub surfaces Plugin Index entries directly in the UI and lets users search, filter, inspect, and install community plugins without leaving Agent Zero.

plugins/_browser_agent/api/status.py

@@ -1,3 +1,45 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5c4568b75cc9d3c0c68288561ec86449f3f7e6e6a1fbed62e84aecc55091a2c1
-size 1505
+import importlib.metadata
+
+from helpers.api import ApiHandler, Request, Response
+from plugins._browser_agent.helpers.playwright import (
+    get_playwright_binary,
+    get_playwright_cache_dir,
+)
+from plugins._model_config.helpers.model_config import get_chat_model_config
+
+
+class Status(ApiHandler):
+    async def process(self, input: dict, request: Request) -> dict | Response:
+        cfg = get_chat_model_config()
+        binary = get_playwright_binary()
+
+        browser_use_ok = False
+        browser_use_error = ""
+        browser_use_version = ""
+        try:
+            import browser_use  # noqa: F401
+
+            browser_use_ok = True
+            browser_use_version = importlib.metadata.version("browser-use")
+        except Exception as e:
+            browser_use_error = str(e)
+
+        return {
+            "plugin": "_browser_agent",
+            "model_source": "Main Model via _model_config",
+            "model": {
+                "provider": cfg.get("provider", ""),
+                "name": cfg.get("name", ""),
+                "vision": bool(cfg.get("vision", False)),
+            },
+            "playwright": {
+                "cache_dir": get_playwright_cache_dir(),
+                "binary_found": bool(binary),
+                "binary_path": str(binary) if binary else "",
+            },
+            "browser_use": {
+                "import_ok": browser_use_ok,
+                "version": browser_use_version,
+                "error": browser_use_error,
+            },
+        }

plugins/_browser_agent/assets/init_override.js

@@ -1,3 +1,246 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:da9eb5f18422450feecc7c09d9b939a181200f26bdbeaf89c04f1b40354c7e8f
-size 8188
+// open all shadow doms
+(function () {
+  const originalAttachShadow = Element.prototype.attachShadow;
+  Element.prototype.attachShadow = function attachShadow(options) {
+    return originalAttachShadow.call(this, { ...options, mode: "open" });
+  };
+})();
+
+// // Create a global bridge for iframe communication
+// (function() {
+//   let elementCounter = 0;
+//   const ignoredTags = [
+//     "style",
+//     "script",
+//     "meta",
+//     "link",
+//     "svg",
+//     "noscript",
+//     "path",
+//   ];
+
+//   function isElementVisible(element) {
+//     // Return true for non-element nodes
+//     if (element.nodeType !== Node.ELEMENT_NODE) {
+//       return true;
+//     }
+
+//     const computedStyle = window.getComputedStyle(element);
+
+//     // Check if element is hidden via CSS
+//     if (
+//       computedStyle.display === "none" ||
+//       computedStyle.visibility === "hidden" ||
+//       computedStyle.opacity === "0"
+//     ) {
+//       return false;
+//     }
+
+//     // Check for hidden input type
+//     if (element.tagName === "INPUT" && element.type === "hidden") {
+//       return false;
+//     }
+
+//     // Check for hidden attribute
+//     if (
+//       element.hasAttribute("hidden") ||
+//       element.getAttribute("aria-hidden") === "true"
+//     ) {
+//       return false;
+//     }
+
+//     return true;
+//   }
+
+//   function convertAttribute(tag, attr) {
+//     let out = {
+//       name: attr.name,
+//       value: attr.value,
+//     };
+
+//     if (["srcset"].includes(out.name)) return null;
+//     if (out.name.startsWith("data-") && out.name != "data-A0UID" && out.name != "data-a0-frame-id") return null;
+
+//     if (tag === "img" && out.value.startsWith("data:")) out.value = "data...";
+
+//     return out;
+//   }
+
+//   // This function will be available in all frames
+//   window.__A0_extractFrameContent = function() {
+//     // Get the current frame's DOM content
+//     const extractContent = (node) => {
+//       if (!node) return "";
+      
+//       let content = "";
+//       const tagName = node.tagName ? node.tagName.toLowerCase() : "";
+      
+//       // Skip ignored tags
+//       if (tagName && ignoredTags.includes(tagName)) {
+//         return "";
+//       }
+
+//       if (node.nodeType === Node.ELEMENT_NODE) {
+//         // Add unique ID to the actual DOM element
+//         if (tagName) {
+//           const uid = elementCounter++;
+//           node.setAttribute("data-A0UID", uid);
+//         }
+
+//         content += `<${tagName}`;
+
+//         // Add invisible attribute if element is not visible
+//         if (!isElementVisible(node)) {
+//           content += " invisible";
+//         }
+
+//         // Add attributes with conversion
+//         for (let attr of node.attributes) {
+//           const out = convertAttribute(tagName, attr);
+//           if (out) content += ` ${out.name}="${out.value}"`;
+//         }
+
+//         if (tagName) {
+//           content += ` selector="${node.getAttribute("data-A0UID")}"`;
+//         }
+        
+//         content += ">";
+        
+//         // Handle shadow DOM
+//         if (node.shadowRoot) {
+//           content += "<!-- Shadow DOM Start -->";
+//           for (let shadowChild of node.shadowRoot.childNodes) {
+//             content += extractContent(shadowChild);
+//           }
+//           content += "<!-- Shadow DOM End -->";
+//         }
+        
+//         // Handle child nodes
+//         for (let child of node.childNodes) {
+//           content += extractContent(child);
+//         }
+        
+//         content += `</${tagName}>`;
+//       } else if (node.nodeType === Node.TEXT_NODE) {
+//         content += node.textContent;
+//       } else if (node.nodeType === Node.COMMENT_NODE) {
+//         content += `<!--${node.textContent}-->`;
+//       }
+      
+//       return content;
+//     };
+
+//     return extractContent(document.documentElement);
+//   };
+
+//   // Setup message listener in each frame
+//   window.addEventListener('message', function(event) {
+//     if (event.data === 'A0_REQUEST_CONTENT') {
+//       // Extract content and send it back to parent
+//       const content = window.__A0_extractFrameContent();
+//       // Use '*' as targetOrigin since we're in a controlled environment
+//       window.parent.postMessage({
+//         type: 'A0_FRAME_CONTENT',
+//         content: content,
+//         frameId: window.frameElement?.getAttribute('data-a0-frame-id')
+//       }, '*');
+//     }
+//   });
+
+//   // Function to extract content from all frames
+//   window.__A0_extractAllFramesContent = async function(rootNode = document) {
+//     let content = "";
+    
+//     // Extract content from current document
+//     content += window.__A0_extractFrameContent();
+    
+//     // Find all iframes
+//     const iframes = rootNode.getElementsByTagName('iframe');
+    
+//     // Create a map to store frame contents
+//     const frameContents = new Map();
+    
+//     // Setup promise for each iframe
+//     const framePromises = Array.from(iframes).map((iframe) => {
+//       return new Promise((resolve) => {
+//         const frameId = 'frame_' + Math.random().toString(36).substr(2, 9);
+//         iframe.setAttribute('data-a0-frame-id', frameId);
+        
+//         // Setup one-time message listener for this specific frame
+//         const listener = function(event) {
+//           if (event.data?.type === 'A0_FRAME_CONTENT' && 
+//               event.data?.frameId === frameId) {
+//             frameContents.set(frameId, event.data.content);
+//             window.removeEventListener('message', listener);
+//             resolve();
+//           }
+//         };
+//         window.addEventListener('message', listener);
+        
+//         // Request content from frame
+//         iframe.contentWindow.postMessage('A0_REQUEST_CONTENT', '*');
+        
+//         // Timeout after 2 seconds
+//         setTimeout(resolve, 2000);
+//       });
+//     });
+    
+//     // Wait for all frames to respond or timeout
+//     await Promise.all(framePromises);
+    
+//     // Add frame contents in order
+//     for (let iframe of iframes) {
+//       const frameId = iframe.getAttribute('data-a0-frame-id');
+//       const frameContent = frameContents.get(frameId);
+//       if (frameContent) {
+//         content += `<!-- IFrame ${iframe.src || 'unnamed'} Content Start -->`;
+//         content += frameContent;
+//         content += `<!-- IFrame Content End -->`;
+//       }
+//     }
+    
+//     return content;
+//   };
+// })();
+
+// // override iframe creation to inject our script into them
+// (function() {
+//   // Store the original createElement to use for iframe creation
+//   const originalCreateElement = document.createElement;
+
+//   // Override createElement to catch iframe creation
+//   document.createElement = function(tagName, options) {
+//     const element = originalCreateElement.call(document, tagName, options);
+//     if (tagName.toLowerCase() === 'iframe') {
+//       // Override the src setter
+//       const originalSrcSetter = Object.getOwnPropertyDescriptor(HTMLIFrameElement.prototype, 'src').set;
+//       Object.defineProperty(element, 'src', {
+//         set: function(value) {
+//           // Call original setter
+//           originalSrcSetter.call(this, value);
+          
+//           // Wait for load and inject our script
+//           this.addEventListener('load', () => {
+//             try {
+//               // Try to inject our script into the iframe
+//               const iframeDoc = this.contentWindow.document;
+//               const script = iframeDoc.createElement('script');
+//               script.textContent = `
+//                 // Make iframe accessible
+//                 document.domain = document.domain;
+//                 // Disable security policies if possible
+//                 if (window.SecurityPolicyViolationEvent) {
+//                   window.SecurityPolicyViolationEvent = undefined;
+//                 }
+//               `;
+//               iframeDoc.head.appendChild(script);
+//             } catch(e) {
+//               console.warn('Could not inject into iframe:', e);
+//             }
+//           }, { once: true });
+//         }
+//       });
+//     }
+//     return element;
+//   };
+// })();

plugins/_browser_agent/extensions/python/_functions/agent/Agent/get_browser_model/start/_10_browser_agent.py

@@ -1,3 +1,7 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:42a4626301eaca52005cb53e87a23169ca42d5d4f213d81c0a864720d9a0d94d
-size 309
+from helpers.extension import Extension
+from plugins._browser_agent.helpers.browser_llm import build_browser_model_for_agent
+
+class BrowserModelProvider(Extension):
+    def execute(self, data: dict = {}, **kwargs):
+        if self.agent:
+            data["result"] = build_browser_model_for_agent(self.agent)

plugins/_browser_agent/extensions/webui/get_message_handler/browser-agent-handler.js

@@ -1,3 +1,54 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c22405e621a86ed6eb85c5ddbe9d71c22b8924be1a585b0022a40ff06c0cef0e
-size 1405
+import {
+  createActionButton,
+  copyToClipboard,
+} from "/components/messages/action-buttons/simple-action-buttons.js";
+import { store as stepDetailStore } from "/components/modals/process-step-detail/step-detail-store.js";
+import { store as speechStore } from "/components/chat/speech/speech-store.js";
+import {
+  buildDetailPayload,
+  cleanStepTitle,
+  drawProcessStep,
+} from "/js/messages.js";
+
+export default async function registerBrowserAgentHandler(extData) {
+  if (extData?.type === "browser") {
+    extData.handler = drawMessageBrowserAgent;
+  }
+}
+
+function drawMessageBrowserAgent({
+  id,
+  type,
+  heading,
+  content,
+  kvps,
+  timestamp,
+  agentno = 0,
+  ...additional
+}) {
+  const title = cleanStepTitle(heading);
+  const displayKvps = { ...kvps };
+  const answerText = String(kvps?.answer ?? "");
+  const actionButtons = answerText.trim()
+    ? [
+        createActionButton("detail", "", () =>
+          stepDetailStore.showStepDetail(
+            buildDetailPayload(arguments[0], { headerLabels: [] }),
+          ),
+        ),
+        createActionButton("speak", "", () => speechStore.speak(answerText)),
+        createActionButton("copy", "", () => copyToClipboard(answerText)),
+      ].filter(Boolean)
+    : [];
+
+  return drawProcessStep({
+    id,
+    title,
+    code: "WWW",
+    classes: undefined,
+    kvps: displayKvps,
+    content,
+    actionButtons,
+    log: arguments[0],
+  });
+}

plugins/_browser_agent/extensions/webui/get_tool_message_handler/browser-tool-handler.js

@@ -1,3 +1,15 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3bb4dd47a0699cc349b0e34fb359a9778029debacdfcc931cbf37e6c746675b4
-size 426
+import { drawMessageToolSimple } from "/js/messages.js";
+
+/**
+ * Registers the browser_agent tool message handler to set the custom badge.
+ * @param {object} extData 
+ */
+export default async function registerBrowserToolHandler(extData) {
+  if (extData?.tool_name === "browser_agent") {
+    extData.handler = drawBrowserTool;
+  }
+}
+
+function drawBrowserTool(args) {
+  return drawMessageToolSimple({ ...args, code: "WWW" });
+}

plugins/_browser_agent/helpers/__init__.py

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:676264791b96a553a80980172a7f12b7a47be5c9afb2563503ce3cfa00a983fb
-size 34
+# Built-in browser agent helpers.

plugins/_browser_agent/helpers/browser_llm.py

@@ -1,3 +1,161 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:393f441aa6440c49ab3921b30da6e292d66f9f9aed6e8a2f32c67136c6621cc0
-size 5784
+from typing import Any, List, Optional
+import litellm
+from litellm import acompletion
+from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+from langchain_core.messages import BaseMessage
+
+import models
+from browser_use.llm import ChatGoogle, ChatOpenRouter
+
+from plugins._browser_agent.helpers import browser_use_monkeypatch
+from plugins._browser_agent.helpers import browser_use_openrouter_compat
+from plugins._browser_agent.helpers import browser_use_output_sanitize
+
+
+_BROWSER_USE_PATCHED = False
+
+
+def apply_browser_use_patches() -> None:
+    global _BROWSER_USE_PATCHED
+    if _BROWSER_USE_PATCHED:
+        return
+
+    browser_use_monkeypatch.apply()
+    litellm.modify_params = True
+    _BROWSER_USE_PATCHED = True
+
+
+class AsyncAIChatReplacement:
+    class _Completions:
+        def __init__(self, wrapper):
+            self._wrapper = wrapper
+
+        async def create(self, *args, **kwargs):
+            return await self._wrapper._acall(*args, **kwargs)
+
+    class _Chat:
+        def __init__(self, wrapper):
+            self.completions = AsyncAIChatReplacement._Completions(wrapper)
+
+    def __init__(self, wrapper, *args, **kwargs):
+        self._wrapper = wrapper
+        self.chat = AsyncAIChatReplacement._Chat(wrapper)
+
+
+class BrowserCompatibleChatWrapper(ChatOpenRouter):
+    """
+    A wrapper for browser agent that can filter/sanitize messages
+    before sending them to the LLM.
+    """
+
+    def __init__(self, *args, **kwargs):
+        apply_browser_use_patches()
+        models.turn_off_logging()
+        self._wrapper = models.LiteLLMChatWrapper(*args, **kwargs)
+        self.model = self._wrapper.model_name
+        self.kwargs = self._wrapper.kwargs
+
+    @property
+    def model_name(self) -> str:
+        return self._wrapper.model_name
+
+    @property
+    def provider(self) -> str:
+        return self._wrapper.provider
+
+    def get_client(self, *args, **kwargs):  # type: ignore
+        return AsyncAIChatReplacement(self, *args, **kwargs)
+
+    async def _acall(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ):
+        models.apply_rate_limiter_sync(self._wrapper.a0_model_conf, str(messages))
+
+        try:
+            model = kwargs.pop("model", None)
+            effective_model = model or self._wrapper.model_name
+            kwrgs = {**self._wrapper.kwargs, **kwargs}
+            request_messages = messages
+
+            # hack from browser-use to fix json schema for gemini (additionalProperties, $defs, $ref)
+            if "response_format" in kwrgs and "json_schema" in kwrgs["response_format"] and effective_model and effective_model.startswith("gemini/"):
+                kwrgs["response_format"]["json_schema"] = ChatGoogle("")._fix_gemini_schema(kwrgs["response_format"]["json_schema"])
+
+            if browser_use_openrouter_compat.should_use_openrouter_prompt_schema_fallback(
+                    provider=self.provider,
+                    model_name=effective_model,
+                    kwargs=kwrgs,
+                ):
+                fallback_request = browser_use_openrouter_compat.build_json_object_fallback_request(
+                    messages=messages,
+                    kwargs=kwrgs,
+                )
+                if fallback_request is not None:
+                    request_messages, kwrgs = fallback_request
+
+            resp = await acompletion(
+                model=self._wrapper.model_name,
+                messages=request_messages,
+                stop=stop,
+                **kwrgs,
+            )
+
+            # Gemini: strip triple backticks and conform schema
+            try:
+                msg = resp.choices[0].message # type: ignore
+                if self.provider == "gemini" and isinstance(getattr(msg, "content", None), str):
+                    cleaned = browser_use_monkeypatch.gemini_clean_and_conform(msg.content) # type: ignore
+                    if cleaned:
+                        msg.content = cleaned
+            except Exception:
+                pass
+
+        except Exception as e:
+            raise e
+
+        # Structured output: normalize keys/models reject (e.g. "" on action dicts) and repair partial JSON
+        try:
+            rf = kwrgs.get("response_format") or {}
+            if "json_schema" in rf or "json_object" in rf:
+                msg_obj = resp.choices[0].message
+                raw_content = getattr(msg_obj, "content", None)
+                fixed = browser_use_output_sanitize.sanitize_llm_message_content_for_browser_use(raw_content)  # type: ignore[arg-type]
+                if fixed is not None:
+                    msg_obj.content = fixed
+        except Exception:
+            pass
+
+        return resp
+
+
+def build_browser_model_from_config(
+    model_config: models.ModelConfig,
+) -> BrowserCompatibleChatWrapper:
+    apply_browser_use_patches()
+    original_provider = model_config.provider.lower()
+    provider_name, kwargs = models._merge_provider_defaults(  # type: ignore[attr-defined]
+        "chat", original_provider, model_config.build_kwargs()
+    )
+    return models._get_litellm_chat(  # type: ignore[attr-defined]
+        BrowserCompatibleChatWrapper,
+        model_config.name,
+        provider_name,
+        model_config,
+        **kwargs,
+    )
+
+def build_browser_model_for_agent(agent=None) -> BrowserCompatibleChatWrapper:
+    """Build and return the browser-use adapter using chat model config."""
+    from plugins._model_config.helpers.model_config import (
+        get_chat_model_config,
+        build_model_config,
+    )
+    import models
+    
+    cfg = get_chat_model_config(agent)
+    mc = build_model_config(cfg, models.ModelType.CHAT)
+    return build_browser_model_from_config(mc)

plugins/_browser_agent/helpers/browser_use.py

@@ -1,3 +1,4 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cc02396489ff037c197c5c1e41ce5d20ff2d4fbb6cd3de0f610a9da0ad33423b
-size 129
+from helpers import dotenv
+dotenv.save_dotenv_value("ANONYMIZED_TELEMETRY", "false")
+import browser_use
+import browser_use.utils

plugins/_browser_agent/helpers/browser_use_monkeypatch.py

@@ -1,3 +1,166 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:83a19ee087245c183741f66aaeb2707b07668ac908a0392da7d0dfa8c782fd9e
-size 7104
+from typing import Any
+from browser_use.llm import ChatGoogle
+from helpers import dirty_json
+
+from plugins._browser_agent.helpers import browser_use_output_sanitize
+
+
+# ------------------------------------------------------------------------------
+# Gemini Helper for Output Conformance
+# ------------------------------------------------------------------------------
+# This function sanitizes and conforms the JSON output from Gemini to match
+# the specific schema expectations of the browser-use library. It handles
+# markdown fences, aliases actions (like 'complete_task' to 'done'), and
+# intelligently constructs a valid 'data' object for the final action.
+
+def gemini_clean_and_conform(text: str):
+    obj = None
+    try:
+        # dirty_json parser is robust enough to handle markdown fences
+        obj = dirty_json.parse(text)
+    except Exception:
+        return None  # return None if parsing fails
+
+    if not isinstance(obj, dict):
+        return None
+
+    obj = browser_use_output_sanitize.normalize_parsed_browser_use_output(obj)
+
+    # Conform actions to browser-use expectations
+    if isinstance(obj.get("action"), list):
+        normalized_actions = []
+        for item in obj["action"]:
+            if not isinstance(item, dict):
+                continue  # Skip non-dict items
+
+            action_key, action_value = next(iter(item.items()), (None, None))
+            if not action_key:
+                continue
+
+            # Alias 'complete_task' to 'done' to handle inconsistencies
+            if action_key == "complete_task":
+                action_key = "done"
+
+            # Create a mutable copy of the value
+            v = (action_value or {}).copy()
+
+            if action_key in ("scroll_down", "scroll_up", "scroll"):
+                is_down = action_key != "scroll_up"
+                v.setdefault("down", is_down)
+                v.setdefault("num_pages", 1.0)
+                normalized_actions.append({"scroll": v})
+            elif action_key == "go_to_url":
+                v.setdefault("new_tab", False)
+                normalized_actions.append({action_key: v})
+            elif action_key == "done":
+                # If `data` is missing, construct it from other keys
+                if "data" not in v:
+                    # Pop fields from the top-level `done` object
+                    response_text = v.pop("response", None)
+                    summary_text = v.pop("page_summary", None)
+                    title_text = v.pop("title", "Task Completed")
+
+                    final_response = response_text or "Task completed successfully." # browser-use expects string
+                    final_summary = summary_text or "No page summary available." # browser-use expects string
+
+                    v["data"] = {
+                        "title": title_text,
+                        "response": final_response,
+                        "page_summary": final_summary,
+                    }
+
+                v.setdefault("success", True)
+                normalized_actions.append({action_key: v})
+            else:
+                normalized_actions.append(item)
+        obj["action"] = normalized_actions
+
+    return dirty_json.stringify(obj)
+
+# ------------------------------------------------------------------------------
+# Monkey-patch for browser-use Gemini schema issue
+# ------------------------------------------------------------------------------
+# The original _fix_gemini_schema in browser_use.llm.google.chat.ChatGoogle
+# removes the 'title' property but fails to remove it from the 'required' list,
+# causing a validation error with the Gemini API. This patch corrects that behavior.
+
+def _patched_fix_gemini_schema(self, schema: dict[str, Any]) -> dict[str, Any]:
+    """
+    Convert a Pydantic model to a Gemini-compatible schema.
+
+    This function removes unsupported properties like 'additionalProperties' and resolves
+    $ref references that Gemini doesn't support.
+    """
+
+    # Handle $defs and $ref resolution
+    if '$defs' in schema:
+        defs = schema.pop('$defs')
+
+        def resolve_refs(obj: Any) -> Any:
+            if isinstance(obj, dict):
+                if '$ref' in obj:
+                    ref = obj.pop('$ref')
+                    ref_name = ref.split('/')[-1]
+                    if ref_name in defs:
+                        # Replace the reference with the actual definition
+                        resolved = defs[ref_name].copy()
+                        # Merge any additional properties from the reference
+                        for key, value in obj.items():
+                            if key != '$ref':
+                                resolved[key] = value
+                        return resolve_refs(resolved)
+                    return obj
+                else:
+                    # Recursively process all dictionary values
+                    return {k: resolve_refs(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [resolve_refs(item) for item in obj]
+            return obj
+
+        schema = resolve_refs(schema)
+
+    # Remove unsupported properties
+    def clean_schema(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            # Remove unsupported properties
+            cleaned = {}
+            for key, value in obj.items():
+                if key not in ['additionalProperties', 'title', 'default']:
+                    cleaned_value = clean_schema(value)
+                    # Handle empty object properties - Gemini doesn't allow empty OBJECT types
+                    if (
+                        key == 'properties'
+                        and isinstance(cleaned_value, dict)
+                        and len(cleaned_value) == 0
+                        and isinstance(obj.get('type', ''), str)
+                        and obj.get('type', '').upper() == 'OBJECT'
+                    ):
+                        # Convert empty object to have at least one property
+                        cleaned['properties'] = {'_placeholder': {'type': 'string'}}
+                    else:
+                        cleaned[key] = cleaned_value
+
+            # If this is an object type with empty properties, add a placeholder
+            if (
+                isinstance(cleaned.get('type', ''), str)
+                and cleaned.get('type', '').upper() == 'OBJECT'
+                and 'properties' in cleaned
+                and isinstance(cleaned['properties'], dict)
+                and len(cleaned['properties']) == 0
+            ):
+                cleaned['properties'] = {'_placeholder': {'type': 'string'}}
+
+            # PATCH: Also remove 'title' from the required list if it exists
+            if 'required' in cleaned and isinstance(cleaned.get('required'), list):
+                cleaned['required'] = [p for p in cleaned['required'] if p != 'title']
+
+            return cleaned
+        elif isinstance(obj, list):
+            return [clean_schema(item) for item in obj]
+        return obj
+
+    return clean_schema(schema)
+
+def apply():
+    """Applies the monkey-patch to ChatGoogle."""
+    ChatGoogle._fix_gemini_schema = _patched_fix_gemini_schema

plugins/_browser_agent/helpers/browser_use_openrouter_compat.py

@@ -1,3 +1,93 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1c65868269ab351da34f84e55950d57646573c41b12cfc6384eb02e215e4cf48
-size 3188
+from __future__ import annotations
+
+import copy
+import json
+from typing import Any
+
+def is_openrouter_request(provider: str | None, model_name: str | None) -> bool:
+    provider_name = (provider or "").lower()
+    model = (model_name or "").lower()
+    return provider_name == "openrouter" or model.startswith("openrouter/")
+
+
+def has_json_schema_response_format(kwargs: dict[str, Any]) -> bool:
+    response_format = kwargs.get("response_format")
+    return isinstance(response_format, dict) and (
+        response_format.get("type") == "json_schema" or "json_schema" in response_format
+    )
+
+
+def should_use_openrouter_prompt_schema_fallback(
+    provider: str | None, model_name: str | None, kwargs: dict[str, Any]
+) -> bool:
+    """
+    OpenRouter sometimes routes browser-use structured output through providers
+    that reject large compiled grammars. Avoid the hard error entirely by
+    downgrading to `json_object` before the first request.
+    """
+    return is_openrouter_request(provider, model_name) and has_json_schema_response_format(kwargs)
+
+
+def relax_strict_tool_schemas(tools: Any) -> Any:
+    """
+    Disable strict tool grammar on fallback while keeping tool definitions intact.
+    """
+    if not isinstance(tools, list):
+        return tools
+
+    relaxed = copy.deepcopy(tools)
+    for tool in relaxed:
+        if not isinstance(tool, dict):
+            continue
+        function_spec = tool.get("function")
+        if isinstance(function_spec, dict) and function_spec.get("strict") is True:
+            function_spec["strict"] = False
+    return relaxed
+
+
+def _schema_hint_text(response_format: dict[str, Any]) -> str | None:
+    schema_payload = response_format.get("json_schema")
+    if not isinstance(schema_payload, dict):
+        return None
+
+    compact_schema = json.dumps(
+        schema_payload,
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+    return (
+        "Return only a single JSON object with no markdown fences, prose, or extra text. "
+        "Follow this schema exactly: "
+        f"{compact_schema}"
+    )
+
+
+def prepend_schema_hint_to_messages(
+    messages: list[Any], response_format: dict[str, Any]
+) -> list[Any]:
+    hint = _schema_hint_text(response_format)
+    if not hint:
+        return list(messages)
+    return [{"role": "system", "content": hint}, *list(messages)]
+
+
+def build_json_object_fallback_request(
+    messages: list[Any],
+    kwargs: dict[str, Any],
+) -> tuple[list[Any], dict[str, Any]] | None:
+    """
+    Replace strict json_schema with json_object and move schema guidance into the prompt.
+
+    This keeps browser-use's local validation path while avoiding provider-side
+    grammar compilation limits on OpenRouter.
+    """
+    response_format = kwargs.get("response_format")
+    if not isinstance(response_format, dict):
+        return None
+
+    updated_kwargs = copy.deepcopy(kwargs)
+    updated_kwargs["response_format"] = {"type": "json_object"}
+    if "tools" in updated_kwargs:
+        updated_kwargs["tools"] = relax_strict_tool_schemas(updated_kwargs["tools"])
+    updated_messages = prepend_schema_hint_to_messages(messages, response_format)
+    return updated_messages, updated_kwargs

plugins/_browser_agent/helpers/browser_use_output_sanitize.py

@@ -1,3 +1,79 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:64fad384c412068a0686b7f3f2edebf22abf50d22c285a449a00ce67a3f5d021
-size 2463
+"""
+Utilities to normalize LLM replies before browser-use parses them into AgentOutput.
+
+Some models (e.g. via OpenRouter) emit extra JSON keys such as "" : "", which
+Pydantic rejects as extra_forbidden on strict action union members.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from helpers import dirty_json
+
+
+def deep_strip_empty_string_keys(obj: Any) -> Any:
+    """
+    Recursively remove dict entries whose key is the empty string.
+
+    Browser-use action objects must be discriminated unions with a single
+    action key; spurious "" keys break validation for every union variant.
+    """
+    if isinstance(obj, dict):
+        return {
+            k: deep_strip_empty_string_keys(v)
+            for k, v in obj.items()
+            if k != ""
+        }
+    if isinstance(obj, list):
+        return [deep_strip_empty_string_keys(item) for item in obj]
+    return obj
+
+
+def normalize_parsed_browser_use_output(obj: dict) -> dict:
+    """Apply all normalizations safe for a parsed AgentOutput-shaped dict."""
+    out = deep_strip_empty_string_keys(obj)
+    if not isinstance(out, dict):
+        return obj
+    return out
+
+
+def parse_and_sanitize_llm_json(text: str) -> str | None:
+    """
+    Parse message content and return JSON text safe for AgentOutput parsing.
+
+    Returns None if the string is not a JSON object.
+    """
+    try:
+        obj = dirty_json.parse(text)
+    except Exception:
+        return None
+    if not isinstance(obj, dict):
+        return None
+    return dirty_json.stringify(normalize_parsed_browser_use_output(obj))
+
+
+def sanitize_llm_message_content_for_browser_use(content: str | None) -> str | None:
+    """
+    Best-effort sanitize assistant message content in place for browser-use.
+
+    - If content parses as a dict: strip bad keys and re-serialize.
+    - If content is non-JSON or trailing garbage: try dirty_json parse; if dict, sanitize.
+    - Otherwise return the original string.
+    """
+    if content is None:
+        return None
+    stripped = content.strip()
+    if not stripped:
+        return content
+    sanitized = parse_and_sanitize_llm_json(stripped)
+    if sanitized is not None:
+        return sanitized
+    if not stripped.startswith("{"):
+        try:
+            obj = dirty_json.parse(stripped)
+        except Exception:
+            return content
+        if isinstance(obj, dict):
+            return dirty_json.stringify(normalize_parsed_browser_use_output(obj))
+    return content

plugins/_browser_agent/helpers/playwright.py

@@ -1,3 +1,38 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9033100aa4946beeaa7639a0c748e4112111e7f76fbad9b82422f9a6100e2093
-size 1114
+import os
+import sys
+from pathlib import Path
+import subprocess
+from helpers import files
+
+
+# this helper ensures that playwright is installed in /lib/playwright
+# should work for both docker and local installation
+
+def get_playwright_binary():
+    pw_cache = Path(get_playwright_cache_dir())
+    for pattern in (
+        "chromium_headless_shell-*/chrome-*/headless_shell",
+        "chromium_headless_shell-*/chrome-*/headless_shell.exe",
+    ):
+        binary = next(pw_cache.glob(pattern), None)
+        if binary:
+            return binary
+    return None
+
+def get_playwright_cache_dir():
+    return files.get_abs_path("tmp/playwright")
+
+def ensure_playwright_binary():
+    bin = get_playwright_binary()
+    if not bin:
+        cache = get_playwright_cache_dir()
+        env = os.environ.copy()
+        env["PLAYWRIGHT_BROWSERS_PATH"] = cache
+        subprocess.check_call(
+            ["playwright", "install", "chromium", "--only-shell"],
+            env=env
+        )
+    bin = get_playwright_binary()
+    if not bin:
+        raise Exception("Playwright binary not found after installation")
+    return bin

plugins/_browser_agent/prompts/agent.system.tool.browser.md

@@ -1,3 +1,36 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8ff07181170e42a9b3000d1e7c1db59541c63e3fefceece2345a5772033720da
-size 960
+### browser_agent:
+
+subordinate agent controls playwright browser
+message argument talks to agent give clear instructions credentials task based
+reset argument spawns new agent
+do not reset if iterating
+be precise descriptive like: open google login and end task, log in using ... and end task
+when following up start: considering open pages
+dont use phrase wait for instructions use end task
+downloads default in /a0/tmp/downloads
+pass secrets and variables in message when needed
+
+usage:
+```json
+{
+  "thoughts": ["I need to log in to..."],
+  "headline": "Opening new browser session for login",
+  "tool_name": "browser_agent",
+  "tool_args": {
+    "message": "Open and log me into...",
+    "reset": "true"
+  }
+}
+```
+
+```json
+{
+  "thoughts": ["I need to log in to..."],
+  "headline": "Continuing with existing browser session",
+  "tool_name": "browser_agent",
+  "tool_args": {
+    "message": "Considering open pages, click...",
+    "reset": "false"
+  }
+}
+```

plugins/_browser_agent/prompts/browser_agent.system.md

@@ -1,3 +1,22 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c2c7c6cca53369be2c55c044d56e95d4368f28e8cb14656076c0115324e4d05b
-size 1368
+# Operation instruction
+Keep your tasks solution as simple and straight forward as possible
+Follow instructions as closely as possible
+When told go to website, open the website. If no other instructions: stop there
+Do not interact with the website unless told to
+Always accept all cookies if prompted on the website, NEVER go to browser cookie settings
+If asked specific questions about a website, be as precise and close to the actual page content as possible
+If you are waiting for instructions: you should end the task and mark as done
+
+## Task Completion
+When you have completed the assigned task OR are waiting for further instructions:
+1. Use the "Complete task" action to mark the task as complete
+2. Provide the required parameters: title, response, and page_summary
+3. Do NOT continue taking actions after calling "Complete task"
+
+## Important Notes
+- Always call "Complete task" when your objective is achieved
+- In page_summary respond with one paragraph of main content plus an overview of page elements
+- Response field is used to answer to user's task or ask additional questions
+- If you navigate to a website and no further actions are requested, call "Complete task" immediately
+- If you complete any requested interaction (clicking, typing, etc.), call "Complete task"
+- Never leave a task running indefinitely - always conclude with "Complete task"

plugins/_browser_agent/tools/browser_agent.py

@@ -1,3 +1,440 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:39588c30a192976b3d109d24a658c6d3f02274f730cbbd156e9ef874cec31881
-size 17422
+import asyncio
+import time
+from typing import Optional, cast
+from agent import Agent, InterventionException
+from pathlib import Path
+
+from helpers.tool import Tool, Response
+from helpers import files, defer, persist_chat, strings
+from plugins._browser_agent.helpers.browser_use import browser_use  # type: ignore[attr-defined]
+from helpers.print_style import PrintStyle
+from plugins._browser_agent.helpers.playwright import ensure_playwright_binary
+from helpers.secrets import get_secrets_manager
+from extensions.python.message_loop_start._10_iteration_no import get_iter_no
+from pydantic import BaseModel
+import uuid
+from helpers.dirty_json import DirtyJson
+
+
+PLUGIN_DIR = Path(__file__).resolve().parents[1]
+
+
+class State:
+    @staticmethod
+    async def create(agent: Agent):
+        state = State(agent)
+        return state
+
+    def __init__(self, agent: Agent):
+        self.agent = agent
+        self.browser_session: Optional[browser_use.BrowserSession] = None
+        self.task: Optional[defer.DeferredTask] = None
+        self.use_agent: Optional[browser_use.Agent] = None
+        self.secrets_dict: Optional[dict[str, str]] = None
+        self.iter_no = 0
+
+    def __del__(self):
+        self.kill_task()
+        files.delete_dir(self.get_user_data_dir()) # cleanup user data dir
+
+    def get_user_data_dir(self):
+        return str(
+            Path.home()
+            / ".config"
+            / "browseruse"
+            / "profiles"
+            / f"agent_{self.agent.context.id}"
+        )
+
+    def _get_browser_http_headers(self):
+        # ignored for now
+        return {}
+
+    def _get_browser_vision(self):
+        from plugins._model_config.helpers.model_config import get_chat_model_config
+        cfg = get_chat_model_config(self.agent)
+        return cfg.get("vision", False)
+
+    async def _initialize(self):
+        if self.browser_session:
+            return
+
+        # for some reason we need to provide exact path to headless shell, otherwise it looks for headed browser
+        pw_binary = ensure_playwright_binary()
+                
+        self.browser_session = browser_use.BrowserSession(
+            browser_profile=browser_use.BrowserProfile(
+                headless=True,
+                disable_security=True,
+                chromium_sandbox=False,
+                accept_downloads=True,
+                downloads_path=files.get_abs_path("usr/downloads"),
+                allowed_domains=["*", "http://*", "https://*"],
+                executable_path=pw_binary,
+                keep_alive=True,
+                minimum_wait_page_load_time=1.0,
+                wait_for_network_idle_page_load_time=2.0,
+                maximum_wait_page_load_time=10.0,
+                window_size={"width": 1024, "height": 2048},
+                screen={"width": 1024, "height": 2048},
+                viewport={"width": 1024, "height": 2048},
+                no_viewport=False,
+                args=["--headless=new", "--no-sandbox"],
+                # Use a unique user data directory to avoid conflicts
+                user_data_dir=self.get_user_data_dir(),
+                extra_http_headers=self._get_browser_http_headers(),
+                )
+        )
+
+        await self.browser_session.start() if self.browser_session else None
+        # self.override_hooks()
+
+        # --------------------------------------------------------------------------
+        # Patch to enforce vertical viewport size
+        # --------------------------------------------------------------------------
+        # Browser-use auto-configuration overrides viewport settings, causing wrong
+        # aspect ratio. We fix this by directly setting viewport size after startup.
+        # --------------------------------------------------------------------------
+
+        if self.browser_session:
+            try:
+                page = await self.browser_session.get_current_page()
+                if page:
+                    await page.set_viewport_size({"width": 1024, "height": 2048})
+            except Exception as e:
+                PrintStyle().warning(f"Could not force set viewport size: {e}")
+
+        # --------------------------------------------------------------------------    
+        
+        # Add init script to the browser session
+        if self.browser_session and self.browser_session.browser_context:
+            js_override = str(PLUGIN_DIR / "assets" / "init_override.js")
+            await self.browser_session.browser_context.add_init_script(path=js_override) if self.browser_session else None
+
+    def start_task(self, task: str):
+        if self.task and self.task.is_alive():
+            self.kill_task()
+
+        self.task = defer.DeferredTask(
+            thread_name="BrowserAgent" + self.agent.context.id
+        )
+        if self.agent.context.task:
+            self.agent.context.task.add_child_task(self.task, terminate_thread=True)
+        self.task.start_task(self._run_task, task) if self.task else None
+        return self.task
+
+    def kill_task(self):
+        if self.task:
+            self.task.kill(terminate_thread=True)
+            self.task = None
+        if self.browser_session:
+            try:
+                import asyncio
+
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                loop.run_until_complete(self.browser_session.close()) if self.browser_session else None
+                loop.close()
+            except Exception as e:
+                PrintStyle().error(f"Error closing browser session: {e}")
+            finally:
+                self.browser_session = None
+        self.use_agent = None
+        self.iter_no = 0
+
+    async def _run_task(self, task: str):
+        await self._initialize()
+
+        class DoneResult(BaseModel):
+            title: str
+            response: str
+            page_summary: str
+
+        # Initialize controller
+        controller = browser_use.Controller(output_model=DoneResult)
+
+        # Register custom completion action with proper ActionResult fields
+        @controller.registry.action("Complete task", param_model=DoneResult)
+        async def complete_task(params: DoneResult):
+            result = browser_use.ActionResult(
+                is_done=True, success=True, extracted_content=params.model_dump_json()
+            )
+            return result
+
+        model = self.agent.get_browser_model()
+
+        try:
+
+            secrets_manager = get_secrets_manager(self.agent.context)
+            secrets_dict = secrets_manager.load_secrets()
+
+            self.use_agent = browser_use.Agent(
+                task=task,
+                browser_session=self.browser_session,
+                llm=model,
+                use_vision=self._get_browser_vision(),
+                extend_system_message=self.agent.read_prompt(
+                    "prompts/browser_agent.system.md"
+                ),
+                controller=controller,
+                enable_memory=False,  # Disable memory to avoid state conflicts
+                llm_timeout=3000, # TODO rem
+                sensitive_data=cast(dict[str, str | dict[str, str]] | None, secrets_dict or {}),  # Pass secrets
+            )
+        except Exception as e:
+            raise Exception(
+                f"Browser agent initialization failed. This might be due to model compatibility issues. Error: {e}"
+            ) from e
+
+        self.iter_no = get_iter_no(self.agent)
+
+        async def hook(agent: browser_use.Agent):
+            await self.agent.wait_if_paused()
+            if self.iter_no != get_iter_no(self.agent):
+                raise InterventionException("Task cancelled")
+
+        # try:
+        result = None
+        if self.use_agent:
+            result = await self.use_agent.run(
+                max_steps=50, on_step_start=hook, on_step_end=hook
+            )
+        return result
+
+    async def get_page(self):
+        if self.use_agent and self.browser_session:
+            try:
+                return await self.use_agent.browser_session.get_current_page() if self.use_agent.browser_session else None
+            except Exception:
+                # Browser session might be closed or invalid
+                return None
+        return None
+
+    async def get_selector_map(self):
+        """Get the selector map for the current page state."""
+        if self.use_agent:
+            await self.use_agent.browser_session.get_state_summary(cache_clickable_elements_hashes=True) if self.use_agent.browser_session else None
+            return await self.use_agent.browser_session.get_selector_map() if self.use_agent.browser_session else None
+            await self.use_agent.browser_session.get_state_summary(
+                cache_clickable_elements_hashes=True
+            )
+            return await self.use_agent.browser_session.get_selector_map()
+        return {}
+
+
+class BrowserAgent(Tool):
+
+    async def execute(self, message="", reset="", **kwargs):
+        self.guid = self.agent.context.generate_id() # short random id
+        reset = str(reset).lower().strip() == "true"
+        await self.prepare_state(reset=reset)
+        message = get_secrets_manager(self.agent.context).mask_values(message, placeholder="<secret>{key}</secret>") # mask any potential passwords passed from A0 to browser-use to browser-use format
+        task = self.state.start_task(message) if self.state else None
+
+        # wait for browser agent to finish and update progress with timeout
+        timeout_seconds = 300  # 5 minute timeout
+        start_time = time.time()
+
+        fail_counter = 0
+        while not task.is_ready() if task else False:
+            # Check for timeout to prevent infinite waiting
+            if time.time() - start_time > timeout_seconds:
+                PrintStyle().warning(
+                    self._mask(f"Browser agent task timeout after {timeout_seconds} seconds, forcing completion")
+                )
+                break
+
+            await self.agent.handle_intervention()
+            await asyncio.sleep(1)
+            try:
+                if task and task.is_ready():  # otherwise get_update hangs
+                    break
+                try:
+                    update = await asyncio.wait_for(self.get_update(), timeout=10)
+                    fail_counter = 0  # reset on success
+                except asyncio.TimeoutError:
+                    fail_counter += 1
+                    PrintStyle().warning(
+                        self._mask(f"browser_agent.get_update timed out ({fail_counter}/3)")
+                    )
+                    if fail_counter >= 3:
+                        PrintStyle().warning(
+                            self._mask("3 consecutive browser_agent.get_update timeouts, breaking loop")
+                        )
+                        break
+                    continue
+                update_log = update.get("log", get_use_agent_log(None))
+                self.update_progress("\n".join(update_log))
+                screenshot = update.get("screenshot", None)
+                if screenshot:
+                    self.log.update(screenshot=screenshot)
+            except Exception as e:
+                PrintStyle().error(self._mask(f"Error getting update: {str(e)}"))
+
+        if task and not task.is_ready():
+            PrintStyle().warning(self._mask("browser_agent.get_update timed out, killing the task"))
+            self.state.kill_task() if self.state else None
+            return Response(
+                message=self._mask("Browser agent task timed out, not output provided."),
+                break_loop=False,
+            )
+
+        # final progress update
+        if self.state and self.state.use_agent:
+            log_final = get_use_agent_log(self.state.use_agent)
+            self.update_progress("\n".join(log_final))
+
+        # collect result with error handling
+        try:
+            result = await task.result() if task else None
+        except Exception as e:
+            PrintStyle().error(self._mask(f"Error getting browser agent task result: {str(e)}"))
+            # Return a timeout response if task.result() fails
+            answer_text = self._mask(f"Browser agent task failed to return result: {str(e)}")
+            self.log.update(answer=answer_text)
+            return Response(message=answer_text, break_loop=False)
+        # finally:
+        #     # Stop any further browser access after task completion
+        #     # self.state.kill_task()
+        #     pass
+
+        # Check if task completed successfully
+        if result and result.is_done():
+            answer = result.final_result()
+            try:
+                if answer and isinstance(answer, str) and answer.strip():
+                    answer_data = DirtyJson.parse_string(answer)
+                    answer_text = strings.dict_to_text(answer_data)  # type: ignore
+                else:
+                    answer_text = (
+                        str(answer) if answer else "Task completed successfully"
+                    )
+            except Exception as e:
+                answer_text = (
+                    str(answer)
+                    if answer
+                    else f"Task completed with parse error: {str(e)}"
+                )
+        else:
+            # Task hit max_steps without calling done()
+            urls = result.urls() if result else []
+            current_url = urls[-1] if urls else "unknown"
+            answer_text = (
+                f"Task reached step limit without completion. Last page: {current_url}. "
+                f"The browser agent may need clearer instructions on when to finish."
+            )
+
+        # Mask answer for logs and response
+        answer_text = self._mask(answer_text)
+
+        # update the log (without screenshot path here, user can click)
+        self.log.update(answer=answer_text)
+
+        # add screenshot to the answer if we have it
+        if (
+            self.log.kvps
+            and "screenshot" in self.log.kvps
+            and self.log.kvps["screenshot"]
+        ):
+            path = self.log.kvps["screenshot"].split("//", 1)[-1].split("&", 1)[0]
+            answer_text += f"\n\nScreenshot: {path}"
+
+        # respond (with screenshot path)
+        return Response(message=answer_text, break_loop=False)
+
+    def get_log_object(self):
+        return self.agent.context.log.log(
+            type="browser",
+            heading=f"icon://captive_portal {self.agent.agent_name}: Calling Browser Agent",
+            content="",
+            kvps=self.args,
+        )
+
+    async def get_update(self):
+        await self.prepare_state()
+
+        result = {}
+        agent = self.agent
+        ua = self.state.use_agent if self.state else None
+        page = await self.state.get_page() if self.state else None
+
+        if ua and page:
+            try:
+
+                async def _get_update():
+
+                    # await agent.wait_if_paused() # no need here
+
+                    # Build short activity log
+                    result["log"] = get_use_agent_log(ua)
+
+                    path = files.get_abs_path(
+                        persist_chat.get_chat_folder_path(agent.context.id),
+                        "browser",
+                        "screenshots",
+                        f"{self.guid}.png",
+                    )
+                    files.make_dirs(path)
+                    await page.screenshot(path=path, full_page=False, timeout=3000)
+                    result["screenshot"] = f"img://{path}&t={str(time.time())}"
+
+                if self.state and self.state.task and not self.state.task.is_ready():
+                    await self.state.task.execute_inside(_get_update)
+
+            except Exception:
+                pass
+
+        return result
+
+    async def prepare_state(self, reset=False):
+        self.state = self.agent.get_data("_browser_agent_state")
+        if reset and self.state:
+            self.state.kill_task()
+        if not self.state or reset:
+            self.state = await State.create(self.agent)
+        self.agent.set_data("_browser_agent_state", self.state)
+
+    def update_progress(self, text):
+        text = self._mask(text)
+        short = text.split("\n")[-1]
+        if len(short) > 50:
+            short = short[:50] + "..."
+        progress = f"Browser: {short}"
+
+        self.log.update(progress=text)
+        self.agent.context.log.set_progress(progress)
+
+    def _mask(self, text: str) -> str:
+        try:
+            return get_secrets_manager(self.agent.context).mask_values(text or "")
+        except Exception as e:
+            return text or ""
+
+    # def __del__(self):
+    #     if self.state:
+    #         self.state.kill_task()
+
+
+def get_use_agent_log(use_agent: browser_use.Agent | None):
+    result = ["🚦 Starting task"]
+    if use_agent:
+        action_results = use_agent.history.action_results() or []
+        short_log = []
+        for item in action_results:
+            # final results
+            if item.is_done:
+                if item.success:
+                    short_log.append("✅ Done")
+                else:
+                    short_log.append(
+                        f"❌ Error: {item.error or item.extracted_content or 'Unknown error'}"
+                    )
+
+            # progress messages
+            else:
+                text = item.extracted_content
+                if text:
+                    first_line = text.split("\n", 1)[0][:200]
+                    short_log.append(first_line)
+        result.extend(short_log)
+    return result

plugins/_browser_agent/webui/main.html

@@ -1,3 +1,204 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bb93c8c7a5f6da7d4e6f6e3d8905b17fe819381ec1cb0049b318d1575724a61a
-size 6527
+<html>
+<head>
+  <title>Browser Agent</title>
+  <script type="module">
+    import { callJsonApi } from "/js/api.js";
+    import "/components/plugins/list/pluginListStore.js";
+
+    globalThis.browserAgentStatusApi = { callJsonApi };
+  </script>
+</head>
+<body>
+  <div
+    x-data="{
+      loading: true,
+      error: '',
+      status: null,
+      async init() {
+        try {
+          this.status = await browserAgentStatusApi.callJsonApi('/plugins/_browser_agent/status', {});
+        } catch (error) {
+          this.error = error instanceof Error ? error.message : String(error);
+        } finally {
+          this.loading = false;
+        }
+      }
+    }"
+    x-init="init()"
+    class="browser-agent-page"
+  >
+    <div class="section-title">Browser Agent</div>
+    <div class="section-description">
+      Built-in browser automation plugin backed by `browser-use` and Playwright.
+      Model selection stays in `_model_config`; the browser agent follows the effective Main Model.
+    </div>
+
+    <div class="browser-agent-card" x-show="loading">
+      <div class="status-row">
+        <span class="material-symbols-outlined spinning">progress_activity</span>
+        <span>Loading browser status...</span>
+      </div>
+    </div>
+
+    <div class="browser-agent-card error" x-show="!loading && error">
+      <div class="field-title">Status check failed</div>
+      <div class="field-description" x-text="error"></div>
+    </div>
+
+    <template x-if="!loading && status">
+      <div class="browser-agent-grid">
+        <div class="browser-agent-card">
+          <div class="field-title">Model Source</div>
+          <div class="field-description" x-text="status.model_source"></div>
+        </div>
+
+        <div class="browser-agent-card">
+          <div class="field-title">Resolved Main Model</div>
+          <div class="status-row">
+            <span class="status-key">Provider</span>
+            <span class="status-value" x-text="status.model.provider || 'Not configured'"></span>
+          </div>
+          <div class="status-row">
+            <span class="status-key">Model</span>
+            <span class="status-value" x-text="status.model.name || 'Not configured'"></span>
+          </div>
+          <div class="status-row">
+            <span class="status-key">Vision</span>
+            <span class="status-badge" :class="status.model.vision ? 'ok' : 'warn'" x-text="status.model.vision ? 'Enabled' : 'Disabled'"></span>
+          </div>
+        </div>
+
+        <div class="browser-agent-card">
+          <div class="field-title">Playwright Runtime</div>
+          <div class="status-row">
+            <span class="status-key">Binary</span>
+            <span class="status-badge" :class="status.playwright.binary_found ? 'ok' : 'fail'" x-text="status.playwright.binary_found ? 'Found' : 'Missing'"></span>
+          </div>
+          <div class="status-row">
+            <span class="status-key">Cache</span>
+            <span class="status-value mono" x-text="status.playwright.cache_dir"></span>
+          </div>
+          <div class="status-row" x-show="status.playwright.binary_path">
+            <span class="status-key">Path</span>
+            <span class="status-value mono" x-text="status.playwright.binary_path"></span>
+          </div>
+          <div class="field-description" x-show="!status.playwright.binary_found">
+            Docker images ship the Playwright Chromium shell preinstalled. In local development, the first run installs it on demand via <span class="mono">ensure_playwright_binary()</span> if missing.
+          </div>
+        </div>
+
+        <div class="browser-agent-card">
+          <div class="field-title">browser-use</div>
+          <div class="status-row">
+            <span class="status-key">Import</span>
+            <span class="status-badge" :class="status.browser_use.import_ok ? 'ok' : 'fail'" x-text="status.browser_use.import_ok ? 'Ready' : 'Error'"></span>
+          </div>
+          <div class="status-row" x-show="status.browser_use.version">
+            <span class="status-key">Version</span>
+            <span class="status-value" x-text="status.browser_use.version"></span>
+          </div>
+          <div class="field-description mono" x-show="status.browser_use.error" x-text="status.browser_use.error"></div>
+        </div>
+      </div>
+    </template>
+
+    <div class="browser-agent-actions">
+      <button
+        class="btn btn-field"
+        @click="$store.pluginListStore.openPluginConfig({ name: '_model_config', has_config_screen: true })"
+      >
+        Open Model Settings
+      </button>
+      <button class="btn btn-field" @click="openModal('/plugins/_model_config/webui/main.html')">
+        Open Presets
+      </button>
+      <button class="btn btn-field" @click="openModal('/plugins/_model_config/webui/api-keys.html')">
+        Open API Keys
+      </button>
+    </div>
+  </div>
+
+  <style>
+    .browser-agent-page {
+      display: flex;
+      flex-direction: column;
+      gap: 14px;
+    }
+
+    .browser-agent-grid {
+      display: grid;
+      gap: 12px;
+      grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+    }
+
+    .browser-agent-card {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      padding: 14px;
+      background: var(--color-input);
+      border: 1px solid var(--color-border);
+      border-radius: 10px;
+    }
+
+    .browser-agent-card.error {
+      border-color: rgba(214, 40, 40, 0.35);
+    }
+
+    .browser-agent-actions {
+      display: flex;
+      gap: 8px;
+      flex-wrap: wrap;
+    }
+
+    .status-row {
+      display: flex;
+      align-items: flex-start;
+      justify-content: space-between;
+      gap: 12px;
+      font-size: 0.84rem;
+    }
+
+    .status-key {
+      opacity: 0.7;
+      min-width: 64px;
+    }
+
+    .status-value {
+      text-align: right;
+      word-break: break-word;
+    }
+
+    .status-badge {
+      padding: 2px 8px;
+      border-radius: 999px;
+      font-size: 0.76rem;
+      font-weight: 600;
+      border: 1px solid transparent;
+    }
+
+    .status-badge.ok {
+      color: #1b5e20;
+      background: rgba(46, 125, 50, 0.14);
+      border-color: rgba(46, 125, 50, 0.24);
+    }
+
+    .status-badge.warn {
+      color: #8a6100;
+      background: rgba(191, 144, 0, 0.14);
+      border-color: rgba(191, 144, 0, 0.24);
+    }
+
+    .status-badge.fail {
+      color: #9f1239;
+      background: rgba(190, 24, 93, 0.12);
+      border-color: rgba(190, 24, 93, 0.24);
+    }
+
+    .mono {
+      font-family: var(--font-mono);
+      font-size: 0.78rem;
+    }
+  </style>
+</body>
+</html>

plugins/_chat_branching/README.md

@@ -1,3 +1,34 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:286f79718ec1ef677d03637b30b0026bd6259c3750ff33b53cd49b1243eeda36
-size 1339
+# Chat Branching
+
+Create a new chat from any existing point in a conversation.
+
+## What It Does
+
+Adds a **Branch** button to every chat message. Clicking it clones the current chat up to that message, creating a new conversation you can continue independently.
+
+## How It Works
+
+1. **ID-based log ↔ history linking**
+   Every `LogItem` and `history.Message` share a UUID generated at creation time. The branch button is only shown on messages that carry this ID.
+
+2. **Clone & trim**
+   - Serializes the source context → deserializes into a new context with a fresh ID.
+   - Walks log entries: keeps everything up to the selected `log_no`, discards the rest.
+   - Collects the IDs of kept entries and uses them to trim `history.messages` so log and history stay consistent.
+
+3. **Persist & refresh**
+   - Saves the branched chat immediately.
+   - Marks UI state dirty so all connected tabs see the new branch.
+
+## Entry Points
+
+| Path | Purpose |
+|---|---|
+| `api/branch_chat.py` | API endpoint — clone, trim, persist |
+| `extensions/webui/set_messages_after_loop/inject-branch-buttons.js` | Injects the Branch button into each message DOM element |
+
+## Plugin Metadata
+
+- **Name**: `_chat_branching`
+- **Title**: `Chat Branching`
+- **Description**: Branch a chat from any message, creating a new chat with history up to that point.

plugins/_chat_branching/api/branch_chat.py

@@ -1,3 +1,147 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:13e2e7056e13a6ece481ec03977d6f49dc6ce99213bc7523a62255fb92096773
-size 4949
+import json
+from datetime import datetime
+
+from helpers.api import ApiHandler, Input, Output, Request, Response
+from helpers.persist_chat import (
+    _serialize_context,
+    _deserialize_context,
+    save_tmp_chat,
+)
+from agent import AgentContext
+
+
+def _trim_history_json(history_json: str, kept_ids: set[str], after_cut_ids: set[str]) -> str:
+    """Trim a serialized history JSON to keep only messages that appear
+    before the branch cut point.
+
+    *kept_ids*: IDs of log items up to and including the cut point.
+    *after_cut_ids*: IDs of log items after the cut point.
+
+    Walk messages in order.  A message is kept while the running state
+    is "keep".  The state flips to "drop" the first time we encounter
+    a message whose id is in *after_cut_ids*.  Messages whose id does
+    not appear in any log set (unpaired) inherit the current state.
+    Summarized topics/bulks are always preserved.
+    """
+    if not history_json:
+        return history_json
+
+    hist = json.loads(history_json)
+    keep = True  # running state
+
+    def filter_messages(messages: list[dict]) -> list[dict]:
+        nonlocal keep
+        result = []
+        for msg in messages:
+            mid = msg.get("id", "")
+            if mid and mid in after_cut_ids:
+                keep = False
+            elif mid and mid in kept_ids:
+                keep = True
+            # else: unpaired – inherit current state
+            if keep:
+                result.append(msg)
+        return result
+
+    # Bulks are already summarized old history – always keep
+    # Topics: keep summarized ones; filter unsummarized
+    trimmed_topics = []
+    for topic in hist.get("topics", []):
+        if topic.get("summary"):
+            trimmed_topics.append(topic)
+            continue
+        msgs = filter_messages(topic.get("messages", []))
+        if msgs:
+            topic["messages"] = msgs
+            trimmed_topics.append(topic)
+        if not keep:
+            break
+    hist["topics"] = trimmed_topics
+
+    # Current topic
+    current = hist.get("current", {})
+    if not current.get("summary") and keep:
+        current["messages"] = filter_messages(current.get("messages", []))
+    elif not keep:
+        current["messages"] = []
+    hist["current"] = current
+
+    # Recount
+    total = sum(
+        len(t.get("messages", [])) for t in hist["topics"] if not t.get("summary")
+    ) + len(hist.get("current", {}).get("messages", []))
+    hist["counter"] = total
+
+    return json.dumps(hist, ensure_ascii=False)
+
+
+class BranchChat(ApiHandler):
+    """Create a new chat branched from an existing chat at a specific log message."""
+
+    async def process(self, input: Input, request: Request) -> Output:
+        ctxid = input.get("context", "")
+        log_no = input.get("log_no")  # LogItem.no from frontend
+
+        if not ctxid:
+            return Response("Missing context id", 400)
+        if log_no is None:
+            return Response("Missing log_no", 400)
+
+        context = AgentContext.get(ctxid)
+        if not context:
+            return Response("Context not found", 404)
+
+        # Serialize the source context
+        data = _serialize_context(context)
+
+        # Remove id so _deserialize_context generates a new one
+        del data["id"]
+
+        # Trim log entries: keep only items up to and including log_no.
+        src_logs = data["log"]["logs"]
+        cut_idx = None
+        for i, item in enumerate(src_logs):
+            if item["no"] == log_no:
+                cut_idx = i
+                break
+
+        if cut_idx is None:
+            if 0 <= log_no < len(src_logs):
+                cut_idx = log_no
+            else:
+                return Response("log_no not found in chat log", 400)
+
+        kept_logs = src_logs[: cut_idx + 1]
+        after_logs = src_logs[cut_idx + 1 :]
+        data["log"]["logs"] = kept_logs
+
+        # Build ID sets for history trimming
+        kept_ids = {item["id"] for item in kept_logs if item.get("id")}
+        after_cut_ids = {item["id"] for item in after_logs if item.get("id")}
+
+        # Trim each agent's history using ID matching
+        for ag in data.get("agents", []):
+            ag["history"] = _trim_history_json(
+                ag.get("history", ""), kept_ids, after_cut_ids
+            )
+
+        # Give the branch a distinguishable name
+        src_name = data.get("name") or "Chat"
+        data["name"] = f"{src_name} (branch)"
+        data["created_at"] = datetime.now().isoformat()
+
+        # Deserialize into a brand-new context (new id, fresh agent config)
+        new_context = _deserialize_context(data)
+
+        # Persist immediately
+        save_tmp_chat(new_context)
+
+        # Notify all tabs
+        from helpers.state_monitor_integration import mark_dirty_all
+        mark_dirty_all(reason="plugins.chat_branching.BranchChat")
+
+        return {
+            "ok": True,
+            "ctxid": new_context.id,
+            "message": "Chat branched successfully.",
+        }

plugins/_chat_branching/extensions/webui/set_messages_after_loop/inject-branch-buttons.js

@@ -1,3 +1,32 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fddb9e71e3fd42ddd846a0e58eb89c50fdffc55b5179dc1a8af4371497672e07
-size 1310
+// Chat Branching Plugin — injects a "branch" button into every message's action bar.
+// Uses the unified handler output: context.results[] = { args: { no, … }, result: { element, … } }
+
+import { createActionButton } from "/components/messages/action-buttons/simple-action-buttons.js";
+import { callJsonApi } from "/js/api.js";
+import { store as chatsStore } from "/components/sidebar/chats/chats-store.js";
+
+export default async function injectBranchButtons(context) {
+  if (!context?.results?.length) return;
+
+  for (const { args, result } of context.results) {
+    if (!result?.element || args.no == null || !args.id) continue;
+
+    const logNo = args.no;
+    for (const bar of result.element.querySelectorAll(".step-action-buttons")) {
+      if (bar.querySelector(".action-fork_right")) continue;
+      bar.appendChild(
+        createActionButton("fork_right", "Branch chat", async () => {
+          const ctxid = globalThis.getContext?.();
+          if (!ctxid) throw new Error("No active chat");
+
+          const res = await callJsonApi("/plugins/_chat_branching/branch_chat", {
+            context: ctxid,
+            log_no: logNo,
+          });
+          if (!res?.ok) throw new Error(res?.message || "Branch failed");
+          chatsStore.selectChat(res.ctxid);
+        }),
+      );
+    }
+  }
+}

plugins/_chat_compaction/api/compact_chat.py

@@ -1,3 +1,68 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c574e9d5b24c884a6c70e3dd85aa9410e91d2fba3233abde7717b3df4eb88d44
-size 2372
+"""API handler for chat compaction."""
+from helpers.api import ApiHandler, Input, Output, Request, Response
+from agent import AgentContext
+from plugins._chat_compaction.helpers.compactor import (
+    MIN_COMPACTION_TOKENS,
+    get_compaction_stats,
+    run_compaction,
+)
+
+
+class CompactChat(ApiHandler):
+    """Compact the current chat history into a summarized message."""
+
+    async def process(self, input: Input, request: Request) -> Output:
+        ctxid = input.get("context", "")
+        action = input.get("action", "compact")
+
+        if not ctxid:
+            return Response("Missing context id", 400)
+
+        context = AgentContext.get(ctxid)
+        if not context:
+            return Response("Context not found", 404)
+
+        if context.is_running():
+            return Response("Cannot compact while agent is running", 409)
+
+        visible_count = len(context.log.logs)
+        if visible_count <= 1:
+            return Response("Not enough messages to compact", 400)
+
+        # Gate both stats and compact — no point opening the modal for tiny chats
+        stats = await get_compaction_stats(context)
+        if stats["token_count"] < MIN_COMPACTION_TOKENS:
+            return {
+                "ok": False,
+                "message": f"Not enough content to compact (minimum {MIN_COMPACTION_TOKENS:,} tokens)",
+            }
+
+        if action == "stats":
+            return {"ok": True, "stats": stats}
+
+        elif action == "compact":
+            use_chat_model = input.get("use_chat_model", True)
+            preset_name = input.get("preset_name") or None
+
+            context.run_task(
+                _run_compaction_task, context, use_chat_model, preset_name
+            )
+
+            return {"ok": True, "message": "Compaction started"}
+
+        else:
+            return Response(f"Unknown action: {action}", 400)
+
+
+async def _run_compaction_task(context, use_chat_model: bool, preset_name: str | None):
+    """Wrapper to run compaction and handle errors."""
+    try:
+        await run_compaction(context, use_chat_model, preset_name)
+    except Exception as e:
+        context.log.log(
+            type="error",
+            heading="Compaction Failed",
+            content=str(e),
+        )
+        from helpers.state_monitor_integration import mark_dirty_all
+        mark_dirty_all(reason="plugins._chat_compaction.compact_chat_error")

plugins/_chat_compaction/extensions/webui/chat-input-bottom-actions-start/compact-button.html

@@ -1,3 +1,373 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2fb0c6475f412d4c090fb67d91310daa55661cf9416fa181a487a190a2c06ac4
-size 10762
+<html>
+<head>
+  <title>Compact Button Extension</title>
+  <script type="module" src="/plugins/_chat_compaction/webui/compact-store.js"></script>
+</head>
+<body>
+  <div x-data="{ 
+    get disabled() { 
+      return !$store.chats?.selected || $store.compactStore?.compacting || $store.chatInput?.running;
+    },
+    get disabledReason() {
+      if (!$store.chats?.selected) return 'No active chat selected';
+      if ($store.compactStore?.compacting) return 'Compaction in progress';
+      if ($store.chatInput?.running) return 'Cannot compact while agent is running';
+      return 'Compact chat history into a single summary';
+    }
+  }">
+    <template x-if="$store.compactStore">
+      <button 
+        class="text-button" 
+        @click="$store.compactStore.fetchStats()"
+        :disabled="disabled"
+        :title="disabledReason"
+      >
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" width="14" height="14" aria-hidden="true">
+          <polyline points="4 14 10 14 10 20"/><line x1="3" y1="21" x2="10" y2="14"/>
+          <polyline points="20 10 14 10 14 4"/><line x1="21" y1="3" x2="14" y2="10"/>
+        </svg>
+        <p>Compact</p>
+      </button>
+    </template>
+  </div>
+
+  <!-- Modal with unique class names to avoid global CSS collision -->
+  <div x-data x-show="$store.compactStore?.showModal" style="display: none;">
+    <div class="cmpct-overlay" @click="$store.compactStore?.closeModal()">
+      <div class="cmpct-dialog" @click.stop>
+        <div class="cmpct-header">
+          <h3>Compact Chat History</h3>
+          <button class="cmpct-close" @click="$store.compactStore?.closeModal()">
+            <span class="material-symbols-outlined">close</span>
+          </button>
+        </div>
+        
+        <div class="cmpct-body">
+          <template x-if="$store.compactStore?.stats">
+            <div>
+              <p class="cmpct-desc">
+                This will summarize your entire conversation into a single optimized message.
+              </p>
+              
+              <div class="cmpct-stats">
+                <div class="cmpct-stat">
+                  <span class="cmpct-stat-label">Messages</span>
+                  <span class="cmpct-stat-value" x-text="$store.compactStore?.stats?.message_count"></span>
+                </div>
+                <div class="cmpct-stat">
+                  <span class="cmpct-stat-label">Tokens</span>
+                  <span class="cmpct-stat-value" x-text="$store.compactStore?.stats?.token_count?.toLocaleString()"></span>
+                </div>
+              </div>
+
+              <!-- Model selection -->
+              <div class="cmpct-model-section">
+                <div class="cmpct-model-label">Model</div>
+
+                <div class="cmpct-model-controls">
+                  <select class="cmpct-select"
+                          x-model="$store.compactStore.selectedPresetName">
+                    <option value="">Current</option>
+                    <template x-for="preset in $store.compactStore.presets" :key="preset.name">
+                      <option :value="preset.name" x-text="preset.name"></option>
+                    </template>
+                  </select>
+
+                  <div class="cmpct-toggle">
+                    <button :class="{ active: $store.compactStore.useChatModel }"
+                            @click="$store.compactStore.useChatModel = true">Chat</button>
+                    <button :class="{ active: !$store.compactStore.useChatModel }"
+                            @click="$store.compactStore.useChatModel = false">Utility</button>
+                  </div>
+                </div>
+
+                <div class="cmpct-model-name" x-text="$store.compactStore.selectedModelDisplay"></div>
+              </div>
+              
+              <div class="cmpct-info">
+                <span class="material-symbols-outlined">check_circle</span>
+                <span>The context will be replaced with a compacted summary. The original conversation will be backed up.</span>
+              </div>
+            </div>
+          </template>
+          
+          <template x-if="!$store.compactStore?.stats">
+            <div class="cmpct-loading">
+              <span class="cmpct-spinner"></span>
+              <span>Loading statistics...</span>
+            </div>
+          </template>
+        </div>
+        
+        <div class="cmpct-footer">
+          <button class="cmpct-btn cmpct-btn-cancel" @click="$store.compactStore?.closeModal()">
+            Cancel
+          </button>
+          <button 
+            class="cmpct-btn cmpct-btn-danger" 
+            @click="$store.compactStore?.compact()"
+            :disabled="$store.compactStore?.compacting || !$store.compactStore?.stats"
+          >
+            <template x-if="$store.compactStore?.compacting">
+              <span class="cmpct-spinner"></span>
+            </template>
+            <span>Compact</span>
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <style>
+    /* All classes prefixed with cmpct- to avoid global CSS collision */
+    .cmpct-overlay {
+      position: fixed;
+      top: 0; left: 0; right: 0; bottom: 0;
+      background: rgba(0, 0, 0, 0.5);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 2002;
+    }
+    
+    .cmpct-dialog {
+      background: var(--color-panel, #1a1a1a);
+      border-radius: 12px;
+      box-shadow: 0 4px 23px rgba(0, 0, 0, 0.3);
+      width: 90%;
+      max-width: 560px;
+      overflow: hidden;
+    }
+    
+    .cmpct-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 16px 20px;
+      border-bottom: 1px solid var(--color-border, #333);
+    }
+    
+    .cmpct-header h3 {
+      margin: 0;
+      font-size: 1.1rem;
+      font-weight: 600;
+      color: var(--color-text, #e5e5e5);
+    }
+    
+    .cmpct-close {
+      background: transparent;
+      border: none;
+      cursor: pointer;
+      padding: 4px;
+      border-radius: 4px;
+      color: var(--color-text-secondary, #999);
+      transition: color 0.2s;
+    }
+    
+    .cmpct-close:hover {
+      color: var(--color-text, #e5e5e5);
+    }
+    
+    .cmpct-body {
+      padding: 20px;
+    }
+    
+    .cmpct-desc {
+      margin: 0 0 16px 0;
+      color: var(--color-text-secondary, #999);
+      font-size: 0.9rem;
+    }
+    
+    .cmpct-stats {
+      display: grid;
+      grid-template-columns: repeat(2, 1fr);
+      gap: 12px;
+      margin-bottom: 16px;
+    }
+    
+    .cmpct-stat {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: 12px 8px;
+      background: var(--color-background-muted, #252525);
+      border-radius: 8px;
+    }
+    
+    .cmpct-stat-label {
+      font-size: 0.7rem;
+      color: var(--color-text-secondary, #999);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: 4px;
+    }
+    
+    .cmpct-stat-value {
+      font-size: 1.1rem;
+      font-weight: 600;
+      color: var(--color-text, #e5e5e5);
+    }
+    
+    /* Model selection section */
+    .cmpct-model-section {
+      margin-bottom: 16px;
+    }
+
+    .cmpct-model-label {
+      font-size: 0.7rem;
+      color: var(--color-text-secondary, #999);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: 8px;
+    }
+
+    .cmpct-model-controls {
+      display: flex;
+      gap: 8px;
+      margin-bottom: 6px;
+    }
+
+    .cmpct-select {
+      flex: 1;
+      min-width: 0;
+      padding: 6px 10px;
+      border-radius: 6px;
+      border: 1px solid var(--color-border, #333);
+      background: var(--color-background-muted, #252525);
+      color: var(--color-text, #e5e5e5);
+      font-size: 0.85rem;
+      cursor: pointer;
+    }
+
+    .cmpct-select:focus {
+      outline: none;
+      border-color: var(--color-primary, #3b82f6);
+    }
+
+    .cmpct-toggle {
+      display: flex;
+      border-radius: 6px;
+      border: 1px solid var(--color-border, #333);
+      overflow: hidden;
+      flex-shrink: 0;
+    }
+
+    .cmpct-toggle button {
+      padding: 6px 14px;
+      border: none;
+      background: var(--color-background-muted, #252525);
+      color: var(--color-text-secondary, #999);
+      font-size: 0.8rem;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+
+    .cmpct-toggle button:first-child {
+      border-right: 1px solid var(--color-border, #333);
+    }
+
+    .cmpct-toggle button.active {
+      background: var(--color-primary, #3b82f6);
+      color: white;
+    }
+
+    .cmpct-toggle button:hover:not(.active) {
+      background: var(--color-background-hover, #444);
+    }
+
+    .cmpct-model-name {
+      font-size: 0.85rem;
+      color: var(--color-text, #e5e5e5);
+      opacity: 0.7;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .cmpct-info {
+      display: flex;
+      align-items: flex-start;
+      gap: 8px;
+      padding: 10px 12px;
+      background: rgba(34, 197, 94, 0.1);
+      border: 1px solid rgba(34, 197, 94, 0.25);
+      border-radius: 8px;
+      color: #4ade80;
+      font-size: 0.8rem;
+    }
+    
+    .cmpct-info .material-symbols-outlined {
+      font-size: 1.1rem;
+      flex-shrink: 0;
+    }
+    
+    .cmpct-loading {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+      padding: 30px;
+      color: var(--color-text-secondary, #999);
+    }
+    
+    .cmpct-footer {
+      display: flex;
+      justify-content: flex-end;
+      gap: 8px;
+      padding: 12px 20px;
+      border-top: 1px solid var(--color-border, #333);
+    }
+    
+    .cmpct-btn {
+      padding: 8px 16px;
+      border-radius: 6px;
+      font-size: 0.9rem;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.2s;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      border: none;
+    }
+    
+    .cmpct-btn:disabled {
+      opacity: 0.6;
+      cursor: not-allowed;
+    }
+    
+    .cmpct-btn-cancel {
+      background: var(--color-background-muted, #333);
+      color: var(--color-text, #e5e5e5);
+    }
+    
+    .cmpct-btn-cancel:hover:not(:disabled) {
+      background: var(--color-background-hover, #444);
+    }
+    
+    .cmpct-btn-danger {
+      background: #dc2626;
+      color: white;
+    }
+    
+    .cmpct-btn-danger:hover:not(:disabled) {
+      background: #b91c1c;
+    }
+    
+    .cmpct-spinner {
+      width: 16px;
+      height: 16px;
+      border: 2px solid currentColor;
+      border-top-color: transparent;
+      border-radius: 50%;
+      animation: cmpct-spin 0.8s linear infinite;
+      display: inline-block;
+    }
+    
+    @keyframes cmpct-spin {
+      to { transform: rotate(360deg); }
+    }
+  </style>
+</body>
+</html>

plugins/_chat_compaction/helpers/compactor.py

@@ -1,3 +1,279 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:728fed13fe891abdba7993dfa3d9ed4ba9fc3bf0011aba5ce6ed401cbc33c030
-size 10002
+"""Core compaction logic for the compaction plugin."""
+import os
+from datetime import datetime
+
+import models as models_module
+from agent import Agent
+from helpers import tokens
+from helpers.history import History, output_text
+from helpers.persist_chat import (
+    export_json_chat,
+    get_chat_folder_path,
+    save_tmp_chat,
+    remove_msg_files,
+)
+from helpers.state_monitor_integration import mark_dirty_all
+
+MIN_COMPACTION_TOKENS = 1000
+from plugins._model_config.helpers.model_config import (
+    get_chat_model_config,
+    get_utility_model_config,
+    get_preset_by_name,
+    build_model_config,
+    build_chat_model,
+    build_utility_model,
+)
+
+
+def _save_pre_compaction_backup(context, full_text: str) -> dict[str, str]:
+    """Save the original chat as JSON and plain text before compaction.
+
+    Returns dict with 'json' and 'txt' absolute file paths.
+    """
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    backup_dir = os.path.join(get_chat_folder_path(context.id), "backups")
+    os.makedirs(backup_dir, exist_ok=True)
+
+    json_path = os.path.join(backup_dir, f"pre-compact-{timestamp}.json")
+    txt_path = os.path.join(backup_dir, f"pre-compact-{timestamp}.txt")
+
+    json_content = export_json_chat(context)
+    with open(json_path, "w", encoding="utf-8") as f:
+        f.write(json_content)
+
+    with open(txt_path, "w", encoding="utf-8") as f:
+        f.write(full_text)
+
+    return {"json": json_path, "txt": txt_path}
+
+
+def _build_model(use_chat_model: bool, preset_name: str | None, agent):
+    """Build the LLM model for compaction based on user selection.
+
+    If preset_name is given, builds from that preset's config.
+    Otherwise falls back to the agent's currently configured model.
+    """
+    if preset_name:
+        preset = get_preset_by_name(preset_name)
+        if preset:
+            model_key = "chat" if use_chat_model else "utility"
+            cfg = preset.get(model_key, {})
+            if cfg.get("provider") or cfg.get("name"):
+                mc = build_model_config(cfg, models_module.ModelType.CHAT)
+                return cfg, models_module.get_chat_model(
+                    mc.provider, mc.name, model_config=mc, **mc.build_kwargs()
+                )
+
+    if use_chat_model:
+        cfg = get_chat_model_config(agent)
+        return cfg, build_chat_model(agent)
+    else:
+        cfg = get_utility_model_config(agent)
+        return cfg, build_utility_model(agent)
+
+
+async def run_compaction(
+    context,
+    use_chat_model: bool = True,
+    preset_name: str | None = None,
+) -> None:
+    """
+    Compact the chat history into a single summarized message.
+    
+    This function:
+    1. Extracts the full conversation text
+    2. Estimates token count and checks against model context window
+    3. If needed, splits history and summarizes iteratively
+    4. Calls the LLM to generate a comprehensive summary
+    5. Replaces the history with a single AI message containing the summary
+    6. Resets the log and creates a response log item
+    7. Persists the changes
+    
+    The function streams progress to the frontend via the log system.
+    If any error occurs, the original history is preserved.
+    """
+    agent = context.agent0
+    
+    try:
+        # Step 1: Extract full conversation text
+        history_output = agent.history.output()
+        full_text = output_text(history_output, ai_label="assistant", human_label="user")
+        
+        if not full_text.strip():
+            raise ValueError("No conversation content to compact")
+        
+        # Step 2: Estimate tokens, resolve model, and compute context budget
+        token_count = tokens.approximate_tokens(full_text)
+
+        resolved_cfg, model = _build_model(use_chat_model, preset_name, agent)
+        ctx_length = int(resolved_cfg.get("ctx_length", 128000)) if resolved_cfg else 128000
+        max_input_tokens = int(ctx_length * 0.7)
+        
+        # Step 3: Create progress log item (count user-visible messages only)
+        visible_types = {"user", "response"}
+        visible_count = sum(1 for item in context.log.logs if item.type in visible_types)
+        log_item = context.log.log(
+            type="info",
+            heading="Compacting chat history...",
+            content=f"Analyzing {visible_count} messages (~{token_count} tokens)...",
+        )
+        
+        # Step 4: Handle large histories by chunking if necessary
+        if token_count > max_input_tokens:
+            summary = await _compact_large_history(
+                agent, full_text, token_count, max_input_tokens, log_item, model
+            )
+        else:
+            summary = await _compact_single_pass(
+                agent, full_text, log_item, model
+            )
+        
+        if not summary or not summary.strip():
+            raise ValueError("Compaction produced empty summary")
+        
+        # Step 5: Save pre-compaction backup before destroying history
+        backup_paths = _save_pre_compaction_backup(context, full_text)
+        
+        # Step 6: Replace history with compacted version
+        backup_note = (
+            f"\n\n---\n"
+            f"*Pre-compaction backup of the full original conversation:*\n"
+            f"- `{backup_paths['txt']}`"
+        )
+        compacted_content = f"## Context compacted\n\n{summary}{backup_note}"
+
+        agent.history = History(agent=agent)
+        agent.history.add_message(ai=True, content=compacted_content)
+        
+        # Clear subordinate chain
+        agent.data.pop(Agent.DATA_NAME_SUBORDINATE, None)
+        context.streaming_agent = None
+        
+        # Step 7: Reset log and create response
+        context.log.reset()
+        context.log.log(
+            type="response",
+            heading="Context compacted",
+            content=compacted_content,
+            update_progress="none",
+        )
+        
+        # Step 8: Persist and notify
+        save_tmp_chat(context)
+        remove_msg_files(context.id)
+        
+        # Step 9: Force progress bar to inactive state LAST
+        # This must happen after all log operations and persist
+        context.log.set_progress("Waiting for input", 0, False)
+        mark_dirty_all(reason="plugins.compaction.compact_chat")
+        
+    except Exception as e:
+        # Log error but don't modify history
+        context.log.log(
+            type="error",
+            heading="Compaction Failed",
+            content=str(e),
+        )
+        mark_dirty_all(reason="plugins.compaction.compact_chat_error")
+        raise
+
+
+async def _compact_single_pass(agent, full_text: str, log_item, model) -> str:
+    """Compact history in a single LLM call using the provided model."""
+    system_prompt = agent.read_prompt("compact.sys.md")
+    user_prompt = agent.read_prompt("compact.msg.md", conversation=full_text)
+
+    async def stream_cb(chunk: str, total: str):
+        if chunk:
+            log_item.stream(content=chunk)
+
+    summary, _ = await model.unified_call(
+        system_message=system_prompt,
+        user_message=user_prompt,
+        response_callback=stream_cb,
+    )
+    return summary
+
+
+async def _compact_large_history(
+    agent, full_text: str, token_count: int, max_input_tokens: int, log_item, model
+) -> str:
+    """Handle large histories by splitting into chunks and summarizing iteratively."""
+    log_item.update(
+        content=f"History is large (~{token_count} tokens). Splitting into chunks...",
+    )
+
+    lines = full_text.split('\n')
+    mid = len(lines) // 2
+    chunks = ['\n'.join(lines[:mid]), '\n'.join(lines[mid:])]
+
+    summaries = []
+    for i, chunk in enumerate(chunks, 1):
+        log_item.update(content=f"Summarizing part {i}/{len(chunks)}...")
+
+        system_prompt = agent.read_prompt("compact.sys.md")
+        user_prompt = agent.read_prompt("compact.msg.md", conversation=chunk)
+
+        chunk_summary, _ = await model.unified_call(
+            system_message=system_prompt,
+            user_message=user_prompt,
+        )
+        summaries.append(chunk_summary)
+
+    combined = "\n\n---\n\n".join(summaries)
+    log_item.update(content="Creating final summary from parts...")
+
+    final_prompt = agent.read_prompt("compact.sys.md")
+    final_user = agent.read_prompt(
+        "compact.msg.md",
+        conversation=f"This is a multi-part conversation. Here are summaries of each part:\n\n{combined}",
+    )
+
+    async def stream_cb(chunk: str, total: str):
+        if chunk:
+            log_item.stream(content=chunk)
+
+    final_summary, _ = await model.unified_call(
+        system_message=final_prompt,
+        user_message=final_user,
+        response_callback=stream_cb,
+    )
+    return final_summary
+
+
+async def get_compaction_stats(context) -> dict:
+    """
+    Get statistics about the current chat for the confirmation modal.
+    
+    Returns:
+        dict with message_count, token_count, model_name
+    """
+    agent = context.agent0
+    
+    # Count user-visible conversation turns only
+    # 'user' = user sent a message, 'response' = agent final response
+    # Other types (agent, tool, code_exe, etc.) are intermediate processing steps
+    visible_types = {"user", "response"}
+    message_count = sum(
+        1 for item in context.log.logs
+        if item.type in visible_types
+    )
+    
+    # Estimate tokens
+    history_output = agent.history.output()
+    full_text = output_text(history_output, ai_label="assistant", human_label="user")
+    token_count = tokens.approximate_tokens(full_text) if full_text else 0
+    
+    # Get model names for both chat and utility
+    chat_cfg = get_chat_model_config(agent)
+    utility_cfg = get_utility_model_config(agent)
+    chat_model_name = chat_cfg.get("name", "Default") if chat_cfg else "Default"
+    utility_model_name = utility_cfg.get("name", "Default") if utility_cfg else "Default"
+    
+    return {
+        "message_count": message_count,
+        "token_count": token_count,
+        "model_name": chat_model_name,
+        "chat_model_name": chat_model_name,
+        "utility_model_name": utility_model_name,
+    }

plugins/_chat_compaction/prompts/compact.msg.md

@@ -1,3 +1,5 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:575fd7aaef3fc532c2fd8fd5d2eae4b2b43bbe759e4ca733ba7d3fbd3b030c1f
-size 98
+Compact this conversation to its essential facts. Be maximally concise.
+
+---
+{{conversation}}
+---

plugins/_chat_compaction/prompts/compact.sys.md

@@ -1,3 +1,17 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:35ae816202ae6f060afd545782baf375eea270260c4695b1bf3b59fa3daa320e
-size 775
+You are a conversation compactor. Produce the most concise summary possible while preserving critical information.
+
+Rules:
+- Extract only: key decisions, final outcomes, actionable facts, unresolved items
+- Discard: intermediate reasoning, failed attempts, redundant exchanges, pleasantries
+- Use terse bullet points, not prose
+- Collapse related items into single lines
+- Keep exact values: file paths, config values, code identifiers, credentials, URLs
+- Omit anything that can be re-derived from context
+- Group by topic, not chronology
+- No meta-commentary about the summarization
+- Target: 10-20% of original length
+
+Output format:
+- Markdown with short section headers
+- Bullet lists, no paragraphs
+- Code/paths in backticks inline, not fenced blocks unless multi-line

plugins/_chat_compaction/webui/compact-modal.html

@@ -1,3 +1,390 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c5eb81d99f422416e3fec848569fbae1ef4ad7544d724a936eb8e3e58f186aa5
-size 11136
+<html>
+<head>
+  <title>Compact Chat</title>
+</head>
+<body>
+  <div x-data x-show="$store.compactStore?.showModal" style="display: none;">
+    <div class="modal-overlay" @click="$store.compactStore?.closeModal()">
+      <div class="modal-container" @click.stop>
+        <div class="modal-header">
+          <h3>Compact Chat History</h3>
+          <button class="modal-close" @click="$store.compactStore?.closeModal()">
+            <span class="material-symbols-outlined">close</span>
+          </button>
+        </div>
+        
+        <div class="modal-content">
+          <template x-if="$store.compactStore?.stats">
+            <div class="stats-container">
+              <p class="stats-description">
+                This will summarize your entire conversation into a single optimized message.
+              </p>
+              
+              <div class="stats-grid">
+                <div class="stat-item">
+                  <span class="stat-label">Messages</span>
+                  <span class="stat-value" x-text="$store.compactStore?.stats?.message_count"></span>
+                </div>
+                <div class="stat-item">
+                  <span class="stat-label">Tokens</span>
+                  <span class="stat-value" x-text="$store.compactStore?.stats?.token_count?.toLocaleString()"></span>
+                </div>
+              </div>
+
+              <!-- Model selection -->
+              <div class="model-section">
+                <div class="model-section-label">Model</div>
+
+                <div class="model-controls">
+                  <!-- Preset dropdown -->
+                  <select class="compact-select"
+                          x-model="$store.compactStore.selectedPresetName">
+                    <option value="">Current</option>
+                    <template x-for="preset in $store.compactStore.presets" :key="preset.name">
+                      <option :value="preset.name" x-text="preset.name"></option>
+                    </template>
+                  </select>
+
+                  <!-- Chat / Utility toggle -->
+                  <div class="model-type-toggle">
+                    <button :class="{ active: $store.compactStore.useChatModel }"
+                            @click="$store.compactStore.useChatModel = true">
+                      Chat
+                    </button>
+                    <button :class="{ active: !$store.compactStore.useChatModel }"
+                            @click="$store.compactStore.useChatModel = false">
+                      Utility
+                    </button>
+                  </div>
+                </div>
+
+                <div class="model-name" x-text="$store.compactStore.selectedModelDisplay"></div>
+              </div>
+              
+              <template x-if="!$store.compactStore?.canCompact">
+                <div class="stats-info">
+                  <span class="material-symbols-outlined">info</span>
+                  <span>Conversation is too short to compact (minimum 1,000 tokens).</span>
+                </div>
+              </template>
+
+              <div class="stats-warning">
+                <span class="material-symbols-outlined">warning</span>
+                <span>This action cannot be undone. The original conversation will be replaced with a summary.</span>
+              </div>
+            </div>
+          </template>
+          
+          <template x-if="!$store.compactStore?.stats">
+            <div class="stats-loading">
+              <span class="loading-spinner"></span>
+              <span>Loading statistics...</span>
+            </div>
+          </template>
+        </div>
+        
+        <div class="modal-footer">
+          <button class="button secondary" @click="$store.compactStore?.closeModal()">
+            Cancel
+          </button>
+          <button 
+            class="button primary danger" 
+            @click="$store.compactStore?.compact()"
+            :disabled="$store.compactStore?.compacting || !$store.compactStore?.canCompact"
+          >
+            <template x-if="$store.compactStore?.compacting">
+              <span class="loading-spinner"></span>
+            </template>
+            <span>Compact</span>
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <style>
+    .modal-overlay {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0, 0, 0, 0.5);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 1000;
+    }
+    
+    .modal-container {
+      background: var(--color-background-elevated);
+      border-radius: var(--border-radius-md);
+      box-shadow: var(--shadow-lg);
+      width: 90%;
+      max-width: 640px;
+      max-height: 90vh;
+      overflow-y: auto;
+    }
+    
+    .modal-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: var(--spacing-md) var(--spacing-lg);
+      border-bottom: 1px solid var(--color-border);
+    }
+    
+    .modal-header h3 {
+      margin: 0;
+      font-size: 1.1rem;
+      font-weight: 600;
+    }
+    
+    .modal-close {
+      background: transparent;
+      border: none;
+      cursor: pointer;
+      padding: var(--spacing-xs);
+      border-radius: var(--border-radius-sm);
+      color: var(--color-text-secondary);
+      transition: color 0.2s;
+    }
+    
+    .modal-close:hover {
+      color: var(--color-text);
+    }
+    
+    .modal-content {
+      padding: var(--spacing-lg);
+    }
+    
+    .stats-description {
+      margin: 0 0 var(--spacing-md) 0;
+      color: var(--color-text-secondary);
+      font-size: 0.9rem;
+    }
+    
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(2, 1fr);
+      gap: var(--spacing-md);
+      margin-bottom: var(--spacing-lg);
+    }
+    
+    .stat-item {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: var(--spacing-md);
+      background: var(--color-background-muted);
+      border-radius: var(--border-radius-md);
+    }
+    
+    .stat-label {
+      font-size: 0.75rem;
+      color: var(--color-text-secondary);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: var(--spacing-xs);
+    }
+    
+    .stat-value {
+      font-size: 1.25rem;
+      font-weight: 600;
+      color: var(--color-text);
+    }
+
+    /* ── Model selection ── */
+    .model-section {
+      margin-bottom: var(--spacing-lg);
+    }
+
+    .model-section-label {
+      font-size: 0.75rem;
+      color: var(--color-text-secondary);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: var(--spacing-sm);
+    }
+
+    .model-controls {
+      display: flex;
+      gap: var(--spacing-sm);
+      margin-bottom: var(--spacing-sm);
+    }
+
+    .compact-select {
+      flex: 1;
+      min-width: 0;
+      padding: 6px 10px;
+      border-radius: var(--border-radius-md);
+      border: 1px solid var(--color-border);
+      background: var(--color-background-muted);
+      color: var(--color-text);
+      font-size: 0.85rem;
+      cursor: pointer;
+      appearance: auto;
+    }
+
+    .compact-select:focus {
+      outline: none;
+      border-color: var(--color-primary, #3b82f6);
+    }
+
+    .model-type-toggle {
+      display: flex;
+      border-radius: var(--border-radius-md);
+      border: 1px solid var(--color-border);
+      overflow: hidden;
+      flex-shrink: 0;
+    }
+
+    .model-type-toggle button {
+      padding: 6px 14px;
+      border: none;
+      background: var(--color-background-muted);
+      color: var(--color-text-secondary);
+      font-size: 0.8rem;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+
+    .model-type-toggle button:not(:last-child) {
+      border-right: 1px solid var(--color-border);
+    }
+
+    .model-type-toggle button.active {
+      background: var(--color-primary, #3b82f6);
+      color: white;
+    }
+
+    .model-type-toggle button:hover:not(.active) {
+      background: var(--color-background-hover);
+    }
+
+    .model-name {
+      font-size: 0.85rem;
+      color: var(--color-text);
+      opacity: 0.7;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+    
+    .stats-info {
+      display: flex;
+      align-items: flex-start;
+      gap: var(--spacing-sm);
+      padding: var(--spacing-md);
+      margin-bottom: var(--spacing-md);
+      background: var(--color-info-bg, rgba(59, 130, 246, 0.1));
+      border: 1px solid var(--color-info-border, rgba(59, 130, 246, 0.3));
+      border-radius: var(--border-radius-md);
+      color: var(--color-info-text, #1e40af);
+      font-size: 0.85rem;
+    }
+
+    .stats-info .material-symbols-outlined {
+      font-size: 1.2rem;
+      flex-shrink: 0;
+    }
+
+    .stats-warning {
+      display: flex;
+      align-items: flex-start;
+      gap: var(--spacing-sm);
+      padding: var(--spacing-md);
+      background: var(--color-warning-bg, rgba(245, 158, 11, 0.1));
+      border: 1px solid var(--color-warning-border, rgba(245, 158, 11, 0.3));
+      border-radius: var(--border-radius-md);
+      color: var(--color-warning-text, #92400e);
+      font-size: 0.85rem;
+    }
+    
+    .stats-warning .material-symbols-outlined {
+      font-size: 1.2rem;
+      flex-shrink: 0;
+    }
+    
+    .stats-loading {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: var(--spacing-sm);
+      padding: var(--spacing-xl);
+      color: var(--color-text-secondary);
+    }
+    
+    .modal-footer {
+      display: flex;
+      justify-content: flex-end;
+      gap: var(--spacing-sm);
+      padding: var(--spacing-md) var(--spacing-lg);
+      border-top: 1px solid var(--color-border);
+    }
+    
+    .button {
+      padding: var(--spacing-sm) var(--spacing-md);
+      border-radius: var(--border-radius-md);
+      font-size: 0.9rem;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.2s;
+      display: flex;
+      align-items: center;
+      gap: var(--spacing-xs);
+    }
+    
+    .button:disabled {
+      opacity: 0.6;
+      cursor: not-allowed;
+    }
+    
+    .button.secondary {
+      background: var(--color-background-muted);
+      border: 1px solid var(--color-border);
+      color: var(--color-text);
+    }
+    
+    .button.secondary:hover:not(:disabled) {
+      background: var(--color-background-hover);
+    }
+    
+    .button.primary {
+      background: var(--color-primary);
+      border: none;
+      color: white;
+    }
+    
+    .button.primary:hover:not(:disabled) {
+      background: var(--color-primary-hover);
+    }
+    
+    .button.danger {
+      background: var(--color-danger, #dc2626);
+    }
+    
+    .button.danger:hover:not(:disabled) {
+      background: var(--color-danger-hover, #b91c1c);
+    }
+    
+    .loading-spinner {
+      width: 16px;
+      height: 16px;
+      border: 2px solid currentColor;
+      border-top-color: transparent;
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+    
+    @keyframes spin {
+      to { transform: rotate(360deg); }
+    }
+  </style>
+
+  <script type="module">
+    import { store } from "/plugins/_chat_compaction/webui/compact-store.js";
+  </script>
+</body>
+</html>

plugins/_chat_compaction/webui/compact-store.js

@@ -1,3 +1,102 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a2031a79da17f12e36a7eaac46d6e37e37b51c12d26fd56bccbb8ec6baaf52a8
-size 2643
+import { createStore } from "/js/AlpineStore.js";
+import { callJsonApi } from "/js/api.js";
+import {
+  toastFrontendSuccess,
+  toastFrontendError,
+} from "/components/notifications/notification-store.js";
+
+export const store = createStore("compactStore", {
+  compacting: false,
+  stats: null,
+  showModal: false,
+  presets: [],
+  selectedPresetName: "",
+  useChatModel: true,
+
+  minTokens: 1000,
+
+  get canCompact() {
+    return this.stats && this.stats.token_count >= this.minTokens;
+  },
+
+  get selectedModelDisplay() {
+    if (this.selectedPresetName) {
+      const preset = this.presets.find(
+        (p) => p.name === this.selectedPresetName
+      );
+      if (preset) {
+        const cfg = this.useChatModel ? preset.chat : preset.utility;
+        if (cfg?.name) return cfg.name;
+      }
+    }
+    return this.useChatModel
+      ? this.stats?.chat_model_name || "Chat Model"
+      : this.stats?.utility_model_name || "Utility Model";
+  },
+
+  async fetchStats() {
+    try {
+      const ctxid = globalThis.getContext?.();
+      if (!ctxid) {
+        toastFrontendError("No active chat", "Compaction");
+        return;
+      }
+
+      const [statsRes, presetsRes] = await Promise.all([
+        callJsonApi("/plugins/_chat_compaction/compact_chat", {
+          context: ctxid,
+          action: "stats",
+        }),
+        callJsonApi("/plugins/_model_config/model_presets", {
+          action: "get",
+        }),
+      ]);
+
+      if (!statsRes?.ok) {
+        throw new Error(statsRes?.message || "Failed to fetch stats");
+      }
+
+      this.stats = statsRes.stats;
+      this.presets = presetsRes?.ok ? presetsRes.presets || [] : [];
+      this.showModal = true;
+    } catch (e) {
+      toastFrontendError(e.message, "Compaction");
+    }
+  },
+
+  async compact() {
+    this.compacting = true;
+    try {
+      const ctxid = globalThis.getContext?.();
+      if (!ctxid) {
+        throw new Error("No active chat");
+      }
+
+      const res = await callJsonApi("/plugins/_chat_compaction/compact_chat", {
+        context: ctxid,
+        action: "compact",
+        use_chat_model: this.useChatModel,
+        preset_name: this.selectedPresetName || null,
+      });
+
+      if (!res?.ok) {
+        throw new Error(res?.message || "Compaction failed");
+      }
+
+      toastFrontendSuccess("Compaction started", "Compaction");
+      this.showModal = false;
+    } catch (e) {
+      toastFrontendError(e.message, "Compaction");
+    } finally {
+      this.compacting = false;
+    }
+  },
+
+  closeModal() {
+    this.showModal = false;
+    this.stats = null;
+    this.presets = [];
+    this.selectedPresetName = "";
+    this.useChatModel = true;
+  },
+});

plugins/_code_execution/README.md

@@ -1,3 +1,52 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:faca9815e268bc1a4c654621462862b684b65af665791767f4cf4a022f54deab
-size 2062
+# Code Execution
+
+Run terminal commands and execute Python or Node.js code through Agent Zero using persistent shell sessions.
+
+## What It Does
+
+This plugin provides the code execution tool used by agents for development tasks. It supports:
+
+- **Terminal commands** in interactive shell sessions
+- **Python execution** through `ipython -c`
+- **Node.js execution** through `node /exe/node_eval.js`
+- **Persistent sessions** keyed by session number
+- **Session reset and output retrieval**
+- **Local or SSH-backed execution** depending on plugin configuration
+
+## Main Behavior
+
+- **Persistent shells**
+  - Maintains per-session shell state in agent data so subsequent calls can reuse the same terminal session.
+- **Multiple runtimes**
+  - Dispatches requests based on `runtime`: `terminal`, `python`, `nodejs`, `output`, or `reset`.
+- **Remote execution support**
+  - Can open SSH interactive sessions instead of local shells when configured.
+- **Streaming output**
+  - Continuously reads shell output, updates the current log item, and detects progress while commands are running.
+- **Safety around running sessions**
+  - Tracks whether a shell is currently busy and can prevent overlapping commands unless explicitly allowed.
+
+## Key Files
+
+- **Tool**
+  - `tools/code_execution_tool.py` contains runtime dispatch, session lifecycle, and streaming output logic.
+- **Helpers**
+  - `helpers/shell_local.py` provides the local interactive shell implementation.
+  - `helpers/shell_ssh.py` provides the SSH-backed interactive shell implementation.
+- **Configuration**
+  - `default_config.yaml` defines execution, prompt, and timeout settings.
+- **Prompts**
+  - `prompts/` contains the response templates shown to the agent.
+
+## Configuration Scope
+
+- **Settings section**: `agent`
+- **Per-project config**: `true`
+- **Per-agent config**: `true`
+- **Always enabled**: `false`
+
+## Plugin Metadata
+
+- **Name**: `_code_execution`
+- **Title**: `Code Execution`
+- **Description**: Code execution tool supporting terminal, Python, and Node.js runtimes via local TTY or SSH.

plugins/_code_execution/extensions/webui/get_message_handler/code-exe-handler.js

@@ -1,3 +1,83 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:13d11b422fac7d6a16b18e9e251197a9414213edaeb70ccacec1b3dc138a0f5a
-size 2071
+import {
+  createActionButton,
+  copyToClipboard,
+} from "/components/messages/action-buttons/simple-action-buttons.js";
+import { store as stepDetailStore } from "/components/modals/process-step-detail/step-detail-store.js";
+import {
+  buildDetailPayload,
+  cleanStepTitle,
+  drawProcessStep,
+} from "/js/messages.js";
+
+export default async function registerCodeExeHandler(extData) {
+  if (extData?.type === "code_exe") {
+    extData.handler = drawMessageCodeExe;
+  }
+}
+
+function drawMessageCodeExe({
+  id,
+  type,
+  heading,
+  test,
+  content,
+  kvps,
+  timestamp,
+  agentno = 0,
+  ...additional
+}) {
+  let title = "Code Execution";
+  // show command at the start and end
+  if (kvps?.code && /done_all|code_execution_tool/.test(heading || "")) {
+    const s = kvps.session;
+    title = `${s != null ? `[${s}] ` : ""}${kvps.runtime || "bash"}> ${kvps.code.trim()}`;
+  } else {
+    // during execution show the original heading (current step)
+    title = cleanStepTitle(heading);
+  }
+
+  const displayKvps = {};
+
+  const headerLabels = [
+    kvps?.runtime && { label: kvps.runtime, class: "tool-name-badge" },
+    kvps?.session != null && {
+      label: `Session ${kvps.session}`,
+      class: "header-label",
+    },
+  ].filter(Boolean);
+
+  const commandText = String(kvps?.code ?? "");
+  const outputText = String(content ?? "");
+
+  const actionButtons = [];
+  actionButtons.push(
+    createActionButton("detail", "", () =>
+      stepDetailStore.showStepDetail(
+        buildDetailPayload(arguments[0], { headerLabels }),
+      ),
+    ),
+  );
+  if (commandText.trim()) {
+    actionButtons.push(
+      createActionButton("copy", "Command", () => copyToClipboard(commandText)),
+    );
+  }
+  if (outputText.trim()) {
+    actionButtons.push(
+      createActionButton("copy", "Output", () => copyToClipboard(outputText)),
+    );
+  }
+  const stepData = drawProcessStep({
+    id,
+    title,
+    code: "EXE",
+    classes: undefined,
+    kvps: displayKvps,
+    content,
+    contentClasses: ["terminal-output"],
+    actionButtons,
+    log: arguments[0],
+  });
+
+  return stepData;
+}

plugins/_code_execution/helpers/shell_local.py

@@ -1,3 +1,50 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7234c968b0ca1e3548b4d475fc9087e28cd5f6b2605ee399680a893c2fa7c65a
-size 1717
+import platform
+import select
+import subprocess
+import time
+import sys
+from typing import Optional, Tuple
+from helpers import runtime
+from plugins._code_execution.helpers import tty_session
+from plugins._code_execution.helpers.shell_ssh import clean_string
+
+class LocalInteractiveSession:
+    def __init__(self, cwd: str|None = None):
+        self.session: tty_session.TTYSession|None = None
+        self.full_output = ''
+        self.cwd = cwd
+
+    async def connect(self):
+        self.session = tty_session.TTYSession(runtime.get_terminal_executable(), cwd=self.cwd)
+        await self.session.start()
+        await self.session.read_full_until_idle(idle_timeout=1, total_timeout=1)
+
+    async def close(self):
+        if self.session:
+            self.session.kill()
+            # self.session.wait()
+
+    async def send_command(self, command: str):
+        if not self.session:
+            raise Exception("Shell not connected")
+        self.full_output = ""
+        await self.session.sendline(command)
+ 
+    async def read_output(self, timeout: float = 0, reset_full_output: bool = False) -> Tuple[str, Optional[str]]:
+        if not self.session:
+            raise Exception("Shell not connected")
+
+        if reset_full_output:
+            self.full_output = ""
+
+        # get output from terminal
+        partial_output = await self.session.read_full_until_idle(idle_timeout=0.01, total_timeout=timeout)
+        self.full_output += partial_output
+
+        # clean output
+        partial_output = clean_string(partial_output)
+        clean_full_output = clean_string(self.full_output)
+
+        if not partial_output:
+            return clean_full_output, None
+        return clean_full_output, partial_output

plugins/_code_execution/helpers/shell_ssh.py

@@ -1,3 +1,245 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0eb7cefe138a50cd6779a47588b9c0850e3547c79b39b4553e9bfa8760219cf7
-size 9253
+import asyncio
+import paramiko
+import time
+import re
+from typing import Tuple
+from helpers.log import Log
+from helpers.print_style import PrintStyle
+# from helpers.strings import calculate_valid_match_lengths
+
+
+class SSHInteractiveSession:
+
+    # end_comment = "# @@==>> SSHInteractiveSession End-of-Command  <<==@@"
+    # ps1_label = "SSHInteractiveSession CLI>"
+
+    def __init__(
+        self, logger: Log, hostname: str, port: int, username: str, password: str, cwd: str|None = None
+    ):
+        self.logger = logger
+        self.hostname = hostname
+        self.port = port
+        self.username = username
+        self.password = password
+        self.client = paramiko.SSHClient()
+        self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        self.shell = None
+        self.full_output = b""
+        self.last_command = b""
+        self.trimmed_command_length = 0  # Initialize trimmed_command_length
+        self.cwd = cwd
+
+    async def connect(self, keepalive_interval: int = 5):
+        """
+        Establish the SSH connection and start an interactive shell.
+
+        Parameters
+        ----------
+        keepalive_interval : int
+            Interval in **seconds** between keep-alive packets sent by Paramiko.
+            A value ≤ 0 disables Paramiko’s keep-alive feature.
+        """
+        errors = 0
+        while True:
+            try:
+                # --- establish TCP/SSH session ---------------------------------
+                self.client.connect(
+                    self.hostname,
+                    self.port,
+                    self.username,
+                    self.password,
+                    allow_agent=False,
+                    look_for_keys=False,
+                )
+
+                # --------- NEW: enable transport-level keep-alives -------------
+                transport = self.client.get_transport()
+                if transport and keepalive_interval > 0:
+                    # sends an SSH_MSG_IGNORE every <keepalive_interval> seconds
+                    transport.set_keepalive(keepalive_interval)
+                # ----------------------------------------------------------------
+
+                # invoke interactive shell
+                self.shell = self.client.invoke_shell(width=100, height=50)
+
+                # disable systemd/OSC prompt metadata and disable local echo
+                initial_command = "unset PROMPT_COMMAND PS0; stty -echo"
+                if self.cwd:
+                    initial_command = f"cd {self.cwd}; {initial_command}"
+                self.shell.send(f"{initial_command}\n".encode())
+
+                # wait for initial prompt/output to settle
+                while True:
+                    full, part = await self.read_output()
+                    if full and not part:
+                        return
+                    time.sleep(0.1)
+
+            except Exception as e:
+                errors += 1
+                if errors < 3:
+                    PrintStyle.standard(f"SSH Connection attempt {errors}...")
+                    self.logger.log(
+                        type="info",
+                        content=f"SSH Connection attempt {errors}...",
+                    )
+                    time.sleep(5)
+                else:
+                    raise e
+
+    async def close(self):
+        if self.shell:
+            self.shell.close()
+        if self.client:
+            self.client.close()
+
+    async def send_command(self, command: str):
+        if not self.shell:
+            raise Exception("Shell not connected")
+        self.full_output = b""
+        # if len(command) > 10: # if command is long, add end_comment to split output
+        #     command = (command + " \\\n" +SSHInteractiveSession.end_comment + "\n")
+        # else:
+        command = command + "\n"
+        self.last_command = command.encode()
+        self.trimmed_command_length = 0
+        self.shell.send(self.last_command)
+        
+    async def read_output(
+        self, timeout: float = 0, reset_full_output: bool = False
+    ) -> Tuple[str, str]:
+        if not self.shell:
+            raise Exception("Shell not connected")
+
+        if reset_full_output:
+            self.full_output = b""
+        partial_output = b""
+        leftover = b""
+        start_time = time.time()
+
+        while self.shell.recv_ready() and (
+            timeout <= 0 or time.time() - start_time < timeout
+        ):
+
+            # data = self.shell.recv(1024)
+            data = self.receive_bytes()
+
+            # # Trim own command from output
+            # if (
+            #     self.last_command
+            #     and len(self.last_command) > self.trimmed_command_length
+            # ):
+            #     command_to_trim = self.last_command[self.trimmed_command_length :]
+            #     data_to_trim = leftover + data
+
+            #     trim_com, trim_out = calculate_valid_match_lengths(
+            #         command_to_trim,
+            #         data_to_trim,
+            #         deviation_threshold=8,
+            #         deviation_reset=2,
+            #         ignore_patterns=[
+            #             rb"\x1b\[\?\d{4}[a-zA-Z](?:> )?",  # ANSI escape sequences
+            #             rb"\r",  # Carriage return
+            #             rb">\s",  # Greater-than symbol
+            #         ],
+            #         debug=False,
+            #     )
+
+            #     leftover = b""
+            #     if trim_com > 0 and trim_out > 0:
+            #         data = data_to_trim[trim_out:]
+            #         leftover = data
+            #         self.trimmed_command_length += trim_com
+
+            partial_output += data
+            self.full_output += data
+            await asyncio.sleep(0.1)  # Prevent busy waiting
+
+        # Decode once at the end
+        decoded_partial_output = partial_output.decode("utf-8", errors="replace")
+        decoded_full_output = self.full_output.decode("utf-8", errors="replace")
+
+        decoded_partial_output = clean_string(decoded_partial_output)
+        decoded_full_output = clean_string(decoded_full_output)
+
+        return decoded_full_output, decoded_partial_output
+
+    def receive_bytes(self, num_bytes=1024):
+        if not self.shell:
+            raise Exception("Shell not connected")
+        # Receive initial chunk of data
+        shell = self.shell
+        data = self.shell.recv(num_bytes)
+
+        # Helper function to ensure that we receive exactly `num_bytes`
+        def recv_all(num_bytes):
+            data = b""
+            while len(data) < num_bytes:
+                chunk = shell.recv(num_bytes - len(data))
+                if not chunk:
+                    break  # Connection might be closed or no more data
+                data += chunk
+            return data
+
+        # Check if the last byte(s) form an incomplete multi-byte UTF-8 sequence
+        if len(data) > 0:
+            last_byte = data[-1]
+
+            # Check if the last byte is part of a multi-byte UTF-8 sequence (continuation byte)
+            if (last_byte & 0b11000000) == 0b10000000:  # It's a continuation byte
+                # Now, find the start of this sequence by checking earlier bytes
+                for i in range(
+                    2, 5
+                ):  # Look back up to 4 bytes (since UTF-8 is up to 4 bytes long)
+                    if len(data) - i < 0:
+                        break
+                    byte = data[-i]
+
+                    # Detect the leading byte of a multi-byte sequence
+                    if (byte & 0b11100000) == 0b11000000:  # 2-byte sequence (110xxxxx)
+                        data += recv_all(1)  # Need 1 more byte to complete
+                        break
+                    elif (
+                        byte & 0b11110000
+                    ) == 0b11100000:  # 3-byte sequence (1110xxxx)
+                        data += recv_all(2)  # Need 2 more bytes to complete
+                        break
+                    elif (
+                        byte & 0b11111000
+                    ) == 0b11110000:  # 4-byte sequence (11110xxx)
+                        data += recv_all(3)  # Need 3 more bytes to complete
+                        break
+
+        return data
+
+def clean_string(input_string):
+    # Remove ANSI escape codes
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+    cleaned = ansi_escape.sub("", input_string)
+
+    # remove null bytes
+    cleaned = cleaned.replace("\x00", "")
+
+    # remove ipython \r\r\n> sequences from the start
+    cleaned = re.sub(r'^[ \r]*(?:\r*\n>[ \r]*)*', '', cleaned)
+    # also remove any amount of '> ' sequences from the start
+    cleaned = re.sub(r'^(>\s*)+', '', cleaned)
+
+    # Replace '\r\n' with '\n'
+    cleaned = cleaned.replace("\r\n", "\n")
+
+    # remove leading \r and spaces
+    cleaned = cleaned.lstrip("\r ")
+
+    # Split the string by newline characters to process each segment separately
+    lines = cleaned.split("\n")
+
+    for i in range(len(lines)):
+        # Handle carriage returns '\r' by splitting and taking the last part
+        parts = [part for part in lines[i].split("\r") if part.strip()]
+        if parts:
+            lines[i] = parts[
+                -1
+            ].rstrip()  # Overwrite with the last part after the last '\r'
+
+    return "\n".join(lines)

plugins/_code_execution/helpers/tty_session.py

@@ -1,3 +1,327 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5a35ea20df84f5bbd39b865887bd82d355b0e2dafdc48d11e8434cf8610f78db
-size 11152
+import asyncio, os, sys, platform, errno
+
+_IS_WIN = platform.system() == "Windows"
+if _IS_WIN:
+    import winpty  # pip install pywinpty # type: ignore
+    import msvcrt
+
+
+#  Make stdin / stdout tolerant to broken UTF-8 so input() never aborts
+sys.stdin.reconfigure(errors="replace")  # type: ignore
+sys.stdout.reconfigure(errors="replace")  # type: ignore
+
+
+# ──────────────────────────── PUBLIC CLASS ────────────────────────────
+
+
+class TTYSession:
+    def __init__(self, cmd, *, cwd=None, env=None, encoding="utf-8", echo=False):
+        self.cmd = cmd if isinstance(cmd, str) else " ".join(cmd)
+        self.cwd = cwd
+        self.env = env or os.environ.copy()
+        self.encoding = encoding
+        self.echo = echo  # ← store preference
+        self._proc = None
+        self._buf: asyncio.Queue = None  # type: ignore
+
+    def __del__(self):
+        # Simple cleanup on object destruction
+        import nest_asyncio
+
+        nest_asyncio.apply()
+        if hasattr(self, "close"):
+            try:
+                asyncio.run(self.close())
+            except Exception:
+                pass
+
+    # ── user-facing coroutines ────────────────────────────────────────
+    async def start(self):
+        self._buf = asyncio.Queue()
+        if _IS_WIN:
+            self._proc = await _spawn_winpty(
+                self.cmd, self.cwd, self.env, self.echo
+            )  # ← pass echo
+        else:
+            self._proc = await _spawn_posix_pty(
+                self.cmd, self.cwd, self.env, self.echo
+            )  # ← pass echo
+        self._pump_task = asyncio.create_task(self._pump_stdout())
+
+    async def close(self):
+        # Cancel the pump task if it exists
+        if hasattr(self, "_pump_task") and self._pump_task:
+            self._pump_task.cancel()
+            try:
+                await self._pump_task
+            except asyncio.CancelledError:
+                pass
+        # Terminate the process if it exists
+        if self._proc:
+            self._proc.terminate()
+            await self._proc.wait()
+        self._proc = None
+        self._pump_task = None
+
+    async def send(self, data: str | bytes):
+        if self._proc is None:
+            raise RuntimeError("TTYSpawn is not started")
+        if isinstance(data, str):
+            data = data.encode(self.encoding)
+        self._proc.stdin.write(data)  # type: ignore
+        await self._proc.stdin.drain()  # type: ignore
+
+    async def sendline(self, line: str):
+        await self.send(line + "\n")
+
+    async def wait(self):
+        if self._proc is None:
+            raise RuntimeError("TTYSpawn is not started")
+        return await self._proc.wait()
+
+    def kill(self):
+        """Force-kill the running child process.
+
+        This is best-effort: if the process has already terminated (which can
+        happen if *close()* was called elsewhere or the child exited by
+        itself) we silently ignore the *ProcessLookupError* raised by
+        *asyncio.subprocess.Process.kill()*. This prevents race conditions
+        where multiple coroutines attempt to close the same session.
+        """
+        if self._proc is None:
+            # Already closed or never started – nothing to do
+            return
+
+        # Only attempt to kill if the process is still running
+        if getattr(self._proc, "returncode", None) is None:
+            try:
+                self._proc.kill()
+            except ProcessLookupError:
+                # Child already gone – treat as successfully killed
+                pass
+
+    async def read(self, timeout=None):
+        # Return any decoded text the child produced, or None on timeout
+        try:
+            return await asyncio.wait_for(self._buf.get(), timeout)
+        except asyncio.TimeoutError:
+            return None
+
+    # backward-compat alias:
+    readline = read
+
+    async def read_full_until_idle(self, idle_timeout, total_timeout):
+        # Collect child output using iter_until_idle to avoid duplicate logic
+        return "".join(
+            [
+                chunk
+                async for chunk in self.read_chunks_until_idle(
+                    idle_timeout, total_timeout
+                )
+            ]
+        )
+
+    async def read_chunks_until_idle(self, idle_timeout, total_timeout):
+        # Yield each chunk as soon as it arrives until idle or total timeout
+        import time
+
+        start = time.monotonic()
+        while True:
+            if time.monotonic() - start > total_timeout:
+                break
+            chunk = await self.read(timeout=idle_timeout)
+            if chunk is None:
+                break
+            yield chunk
+
+    # ��─ internal: stream raw output into the queue ────────────────────
+    async def _pump_stdout(self):
+        if self._proc is None:
+            raise RuntimeError("TTYSpawn is not started")
+        reader = self._proc.stdout
+        while True:
+            chunk = await reader.read(4096)  # grab whatever is ready # type: ignore
+            if not chunk:
+                break
+            self._buf.put_nowait(chunk.decode(self.encoding, "replace"))
+
+
+# ──────────────────────────── POSIX IMPLEMENTATION ────────────────────
+
+
+async def _spawn_posix_pty(cmd, cwd, env, echo):
+    import pty, asyncio, os, termios
+
+    master, slave = pty.openpty()
+
+    # ── Disable ECHO on the slave side if requested ──
+    if not echo:
+        attrs = termios.tcgetattr(slave)
+        attrs[3] &= ~termios.ECHO  # lflag
+        termios.tcsetattr(slave, termios.TCSANOW, attrs)
+
+    proc = await asyncio.create_subprocess_shell(
+        cmd,
+        stdin=slave,
+        stdout=slave,
+        stderr=slave,
+        cwd=cwd,
+        env=env,
+        close_fds=True,
+    )
+    os.close(slave)
+
+    loop = asyncio.get_running_loop()
+    reader = asyncio.StreamReader()
+
+    def _on_data():
+        try:
+            data = os.read(master, 1 << 16)
+        except OSError as e:
+            if e.errno != errno.EIO:  # EIO == EOF on some systems
+                raise
+            data = b""
+        if data:
+            reader.feed_data(data)
+        else:
+            reader.feed_eof()
+            loop.remove_reader(master)
+
+    loop.add_reader(master, _on_data)
+
+    class _Stdin:
+        def write(self, d):
+            os.write(master, d)
+
+        async def drain(self):
+            await asyncio.sleep(0)
+
+    proc.stdin = _Stdin()  # type: ignore
+    proc.stdout = reader
+    return proc
+
+
+# ──────────────────────────── WINDOWS IMPLEMENTATION ──────────────────
+
+
+async def _spawn_winpty(cmd, cwd, env, echo):
+    # Clean PowerShell startup: no logo, no profile, bypass execution policy for deterministic behavior
+    if cmd.strip().lower().startswith("powershell"):
+        if "-nolog" not in cmd.lower():
+            cmd = cmd.replace("powershell.exe", "powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass", 1)
+
+    cols, rows = 80, 25
+    child = winpty.PtyProcess.spawn(cmd, dimensions=(rows, cols), cwd=cwd or os.getcwd(), env=env) # type: ignore
+
+    loop = asyncio.get_running_loop()
+    reader = asyncio.StreamReader()
+
+    async def _on_data():
+        while child.isalive():
+            try:
+                # Run blocking read in executor to not block event loop
+                data = await loop.run_in_executor(None, child.read, 1 << 16)
+                if data:
+                    reader.feed_data(data.encode('utf-8') if isinstance(data, str) else data)
+            except EOFError:
+                break
+            except Exception:
+                await asyncio.sleep(0.01)
+        reader.feed_eof()
+
+    # Start pumping output in background
+    asyncio.create_task(_on_data())
+
+    class _Stdin:
+        def write(self, d):
+            # Use winpty's write method, not os.write
+            if isinstance(d, bytes):
+                d = d.decode('utf-8', errors='replace')
+            # Windows needs \r\n for proper line endings
+            if _IS_WIN:
+              d = d.replace('\n', '\r\n')
+            child.write(d)
+
+        async def drain(self):
+            await asyncio.sleep(0.01)  # Give write time to complete
+
+    class _Proc:
+        def __init__(self):
+            self.stdin = _Stdin()  # type: ignore
+            self.stdout = reader
+            self.pid = child.pid
+            self.returncode = None
+
+        async def wait(self):
+            while child.isalive():
+                await asyncio.sleep(0.2)
+            self.returncode = 0
+            return 0
+
+        def terminate(self):
+            if child.isalive():
+                child.terminate()
+
+        def kill(self):
+            if child.isalive():
+                child.kill()
+
+    return _Proc()
+
+
+# ───────────────────────── INTERACTIVE DRIVER ─────────────────────────
+if __name__ == "__main__":
+
+    async def interactive_shell():
+        shell_cmd, prompt_hint = ("powershell.exe", ">") if _IS_WIN else ("/bin/bash", "$")
+
+        # echo=False → suppress the shell’s own echo of commands
+        term = TTYSession(shell_cmd)
+        await term.start()
+
+        timeout = 1.0
+
+        print(f"Connected to {shell_cmd}.")
+        print("Type commands for the shell.")
+        print("• /t=<seconds>  → change idle timeout")
+        print("• /exit         → quit helper\n")
+
+        await term.sendline(" ")
+        print(await term.read_full_until_idle(timeout, timeout), end="", flush=True)
+
+        while True:
+            try:
+                user = input(f"(timeout={timeout}) {prompt_hint} ")
+            except (EOFError, KeyboardInterrupt):
+                print("\nLeaving…")
+                break
+
+            if user.lower() == "/exit":
+                break
+            if user.startswith("/t="):
+                try:
+                    timeout = float(user.split("=", 1)[1])
+                    print(f"[helper] idle timeout set to {timeout}s")
+                except ValueError:
+                    print("[helper] invalid number")
+                continue
+
+            idle_timeout = timeout
+            total_timeout = 10 * idle_timeout
+            if user == "":
+                # Just read output, do not send empty line
+                async for chunk in term.read_chunks_until_idle(
+                    idle_timeout, total_timeout
+                ):
+                    print(chunk, end="", flush=True)
+            else:
+                await term.sendline(user)
+                async for chunk in term.read_chunks_until_idle(
+                    idle_timeout, total_timeout
+                ):
+                    print(chunk, end="", flush=True)
+
+        await term.sendline("exit")
+        await term.wait()
+
+    asyncio.run(interactive_shell())

plugins/_code_execution/prompts/agent.system.tool.code_exe.md

@@ -1,3 +1,90 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:597f009da6348e27526ea5d3f5b6971ae6586ccb0e32cc71e9bedb46123ecbb0
-size 2353
+### code_execution_tool
+
+execute terminal commands python nodejs code for computation or software tasks
+place code in "code" arg; escape carefully and indent properly
+select "runtime" arg: "terminal" "python" "nodejs" "output"
+select "session" number, 0 default, others for multitasking
+if code runs long, use runtime "output" to wait
+use argument reset true on next call to kill previous process when stuck default false
+use "pip" "npm" "apt-get" in "terminal" to install package
+to output, use print() or console.log()
+if tool outputs error, adjust code before retrying; 
+important: check code for placeholders or demo data; replace with real variables; don't reuse snippets
+don't use with other tools except thoughts; wait for response before using others
+check dependencies before running code
+output may end with [SYSTEM: ...] information comming from framework, not terminal
+usage:
+
+
+1 execute terminal command
+~~~json
+{
+    "thoughts": [
+        "Need to do...",
+        "Need to install...",
+    ],
+    "headline": "Installing zip package via terminal",
+    "tool_name": "code_execution_tool",
+    "tool_args": {
+        "runtime": "terminal",
+        "session": 0,
+        "reset": false,
+        "code": "apt-get install zip",
+    }
+}
+~~~
+
+2 execute python code
+
+~~~json
+{
+    "thoughts": [
+        "Need to do...",
+        "I can use...",
+        "Then I can...",
+    ],
+    "headline": "Executing Python code to check current directory",
+    "tool_name": "code_execution_tool",
+    "tool_args": {
+        "runtime": "python",
+        "session": 0,
+        "reset": false,
+        "code": "import os\nprint(os.getcwd())",
+    }
+}
+~~~
+
+3 execute nodejs code
+
+~~~json
+{
+    "thoughts": [
+        "Need to do...",
+        "I can use...",
+        "Then I can...",
+    ],
+    "headline": "Executing Javascript code to check current directory",
+    "tool_name": "code_execution_tool",
+    "tool_args": {
+        "runtime": "nodejs",
+        "session": 0,
+        "reset": false,
+        "code": "console.log(process.cwd());",
+    }
+}
+~~~
+
+4 wait for output with long-running scripts
+~~~json
+{
+    "thoughts": [
+        "Waiting for program to finish...",
+    ],
+    "headline": "Waiting for long-running program to complete",
+    "tool_name": "code_execution_tool",
+    "tool_args": {
+        "runtime": "output",
+        "session": 0,
+    }
+}
+~~~

plugins/_code_execution/prompts/agent.system.tool.input.md

@@ -1,3 +1,19 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6ed84ad8a01177d24b4cdcaee7d5033a1c4598ee0c159af642de1f0dfa28ed8d
-size 393
+### input:
+use keyboard arg for terminal program input
+use session arg for terminal session number
+answer dialogues enter passwords etc
+not for browser
+usage:
+~~~json
+{
+    "thoughts": [
+        "The program asks for Y/N...",
+    ],
+    "headline": "Responding to terminal program prompt",
+    "tool_name": "input",
+    "tool_args": {
+        "keyboard": "Y",
+        "session": 0
+    }
+}
+~~~

plugins/_code_execution/prompts/fw.code.info.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:86cb4510f6e254650e620035019d818c1683a62ab7be829f478c9719f41f270a
-size 19
+[SYSTEM: {{info}}] 

plugins/_code_execution/prompts/fw.code.max_time.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5edd5cf7c1532bc68375b0af2b8da3d989e7634a3b6505313efed50faaea85b5
-size 197
+Returning control to agent after {{timeout}} seconds of execution. Process might be still running. Check previous outputs and decide whether to reset and continue or wait for more output is needed.

plugins/_code_execution/prompts/fw.code.no_out_time.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:126186f7a0ad8c32b61fd21e3d349f44afc96ee7882c9e3f72e69a5ad73ea367
-size 199
+Returning control to agent after {{timeout}} seconds with no output. Process might be still running. Check previous outputs and decide whether to reset and continue or wait for more output is needed.

plugins/_code_execution/prompts/fw.code.no_output.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f3a7c967352c802ac7ecbdbf7a28e351edf7fc55af9c79a42c6e45058ff50db5
-size 77
+No output returned. Consider resetting the terminal or using another session.

plugins/_code_execution/prompts/fw.code.pause_dialog.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d0ccd1b01ea8a38a6cc6bc13b368be83dce8474c531def8c7838b8448c682239
-size 243
+Potential dialog detected in output. Returning control to agent after {{timeout}} seconds since last output update. Decide whether dialog actually occurred and needs to be addressed, or if it was just a false positive and wait for more output.

plugins/_code_execution/prompts/fw.code.pause_time.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d8897c73603b1e84a815ae0669016c5dfb2b330782f60f904004a98a3b572ed9
-size 209
+Returning control to agent after {{timeout}} seconds since last output update. Process might be still running. Check previous outputs and decide whether to reset and continue or wait for more output is needed.

plugins/_code_execution/prompts/fw.code.reset.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f54cb95ab01cb3b50a13af927ea7875d7add5f0590a3f95ced1430531c435271
-size 32
+Terminal session has been reset.

plugins/_code_execution/prompts/fw.code.running.md

@@ -1,3 +1 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a70c57139bc315622a2b8d86b0a3f9e8316d15bf944e7a5c5c516cd7d6faef45
-size 151
+Terminal session {{session}} might be still running. Check previous outputs and decide whether to reset and continue or wait for more output is needed.

plugins/_code_execution/prompts/fw.code.runtime_wrong.md

@@ -1,3 +1,5 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6342fa28a06e91c09968d0f5ddc28b9ab590d77a40ad61c5ca203c4f0411bfde
-size 150
+~~~json
+{
+    "system_warning": "The runtime '{{runtime}}' is not supported, available options are 'terminal', 'python', 'nodejs' and 'output'."
+}
+~~~

plugins/_code_execution/tools/code_execution_tool.py

@@ -1,3 +1,529 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1f1377b42af094abe31558cb4675f5fa1aae52a8a9efc3c1873b2439fe9c7982
-size 21057
+import asyncio
+from dataclasses import dataclass
+import re
+import shlex
+import time
+
+from helpers.tool import Tool, Response
+from helpers import files, rfc_exchange, projects, runtime, secrets, settings
+from helpers.print_style import PrintStyle
+from helpers.strings import truncate_text as truncate_text_string
+from helpers.messages import truncate_text as truncate_text_agent
+from helpers import plugins
+
+from plugins._code_execution.helpers.shell_local import LocalInteractiveSession
+from plugins._code_execution.helpers.shell_ssh import SSHInteractiveSession
+
+
+@dataclass
+class ShellWrap:
+    id: int
+    session: LocalInteractiveSession | SSHInteractiveSession
+    running: bool
+
+
+@dataclass
+class State:
+    ssh_enabled: bool
+    shells: dict[int, ShellWrap]
+
+
+class CodeExecution(Tool):
+
+    async def execute(self, **kwargs) -> Response:
+
+        await self.agent.handle_intervention()  # wait for intervention and handle it, if paused
+
+        runtime_arg = self.args.get("runtime", "").lower().strip()
+        session = int(self.args.get("session", 0))
+        self.allow_running = bool(self.args.get("allow_running", False))
+        reset = bool(self.args.get("reset", False) or runtime_arg == "reset")
+
+        cfg = _get_config(self.agent)
+
+        if runtime_arg == "python":
+            response = await self.execute_python_code(
+                cfg, code=self.args["code"], session=session, reset=reset
+            )
+        elif runtime_arg == "nodejs":
+            response = await self.execute_nodejs_code(
+                cfg, code=self.args["code"], session=session, reset=reset
+            )
+        elif runtime_arg == "terminal":
+            response = await self.execute_terminal_command(
+                cfg, command=self.args["code"], session=session, reset=reset
+            )
+        elif runtime_arg == "output":
+            response = await self.get_terminal_output(
+                cfg, session=session, timeouts=cfg["output_timeouts"]
+            )
+        elif runtime_arg == "reset":
+            response = await self.reset_terminal(cfg, session=session)
+        else:
+            response = self.agent.read_prompt(
+                "fw.code.runtime_wrong.md", runtime=runtime_arg
+            )
+
+        if not response:
+            response = self.agent.read_prompt(
+                "fw.code.info.md", info=self.agent.read_prompt("fw.code.no_output.md")
+            )
+        return Response(message=response, break_loop=False)
+
+    def get_log_object(self):
+        import uuid
+        return self.agent.context.log.log(
+            type="code_exe",
+            heading=self.get_heading(),
+            content="",
+            kvps=self.args,
+            id=str(uuid.uuid4()),
+        )
+
+    def get_heading(self, text: str = ""):
+        if not text:
+            text = f"{self.name} - {self.args['runtime'] if 'runtime' in self.args else 'unknown'}"
+        session = self.args.get("session", None)
+        session_text = f"[{session}] " if session or session == 0 else ""
+        return f"icon://terminal {session_text}{truncate_text_string(text, 200)}"
+
+    async def after_execution(self, response, **kwargs):
+        self.agent.hist_add_tool_result(self.name, response.message, id=self.log.id if self.log else "", **(response.additional or {}))
+
+    async def prepare_state(self, cfg: dict, reset=False, session: int | None = None):
+        self.state: State | None = self.agent.get_data("_cet_state")
+        ssh_enabled = cfg["ssh_enabled"]
+
+        # always reset state when ssh_enabled changes
+        if not self.state or self.state.ssh_enabled != ssh_enabled:
+            shells: dict[int, ShellWrap] = {}
+        else:
+            shells = self.state.shells.copy()
+
+        # Only reset the specified session if provided
+        if reset and session is not None and session in shells:
+            await shells[session].session.close()
+            del shells[session]
+        elif reset and not session:
+            # Close all sessions if full reset requested
+            for s in list(shells.keys()):
+                await shells[s].session.close()
+            shells = {}
+
+        # initialize local or remote interactive shell interface for session if needed
+        if session is not None and session not in shells:
+            cwd = await self.ensure_cwd()
+            if ssh_enabled:
+                ssh_pass = await _resolve_ssh_pass(cfg["ssh_pass"])
+                shell = SSHInteractiveSession(
+                    self.agent.context.log,
+                    cfg["ssh_addr"],
+                    cfg["ssh_port"],
+                    cfg["ssh_user"],
+                    ssh_pass,
+                    cwd=cwd,
+                )
+            else:
+                shell = LocalInteractiveSession(cwd=cwd)
+
+            shells[session] = ShellWrap(id=session, session=shell, running=False)
+            await shell.connect()
+
+        self.state = State(shells=shells, ssh_enabled=ssh_enabled)
+        self.agent.set_data("_cet_state", self.state)
+        return self.state
+
+    async def execute_python_code(self, cfg: dict, session: int, code: str, reset: bool = False):
+        escaped_code = shlex.quote(code)
+        command = f"ipython -c {escaped_code}"
+        prefix = "python> " + self.format_command_for_output(code) + "\n\n"
+        return await self.terminal_session(cfg, session, command, reset, prefix)
+
+    async def execute_nodejs_code(self, cfg: dict, session: int, code: str, reset: bool = False):
+        escaped_code = shlex.quote(code)
+        command = f"node /exe/node_eval.js {escaped_code}"
+        prefix = "node> " + self.format_command_for_output(code) + "\n\n"
+        return await self.terminal_session(cfg, session, command, reset, prefix)
+
+    async def execute_terminal_command(
+        self, cfg: dict, session: int, command: str, reset: bool = False
+    ):
+        prefix = (
+            ("bash>" if not runtime.is_windows() or cfg["ssh_enabled"] else "PS>")
+            + self.format_command_for_output(command)
+            + "\n\n"
+        )
+        return await self.terminal_session(cfg, session, command, reset, prefix)
+
+    async def terminal_session(
+        self, cfg: dict, session: int, command: str, reset: bool = False, prefix: str = "", timeouts: dict | None = None
+    ):
+        self.state = await self.prepare_state(cfg, reset=reset, session=session)
+
+        await self.agent.handle_intervention()  # wait for intervention and handle it, if paused
+
+        # Check if session is running and handle it
+        if not self.allow_running:
+            if response := await self.handle_running_session(cfg, session):
+                return response
+
+        # try again on lost connection
+        for i in range(2):
+            try:
+                self.state.shells[session].running = True
+                await self.state.shells[session].session.send_command(command)
+
+                locl = (
+                    " (local)"
+                    if isinstance(self.state.shells[session].session, LocalInteractiveSession)
+                    else (
+                        " (remote)"
+                        if isinstance(self.state.shells[session].session, SSHInteractiveSession)
+                        else " (unknown)"
+                    )
+                )
+
+                PrintStyle(
+                    background_color="white", font_color="#1B4F72", bold=True
+                ).print(f"{self.agent.agent_name} code execution output{locl}")
+                return await self.get_terminal_output(
+                    cfg,
+                    session=session,
+                    prefix=prefix,
+                    timeouts=(timeouts or cfg["code_exec_timeouts"]),
+                )
+
+            except Exception as e:
+                if i == 1:
+                    PrintStyle.error(str(e))
+                    await self.prepare_state(cfg, reset=True, session=session)
+                    continue
+                else:
+                    raise e
+
+    def format_command_for_output(self, command: str):
+        short_cmd = command[:250]
+        short_cmd = " ".join(short_cmd.split())
+        short_cmd = secrets.get_secrets_manager(self.agent.context).mask_values(short_cmd)
+        short_cmd = truncate_text_string(short_cmd, 100)
+        return f"{short_cmd}"
+
+    async def get_terminal_output(
+        self,
+        cfg: dict,
+        session=0,
+        reset_full_output=True,
+        first_output_timeout=30,
+        between_output_timeout=15,
+        dialog_timeout=5,
+        max_exec_timeout=180,
+        sleep_time=0.5,
+        prefix="",
+        timeouts: dict | None = None,
+    ):
+        self.state = await self.prepare_state(cfg, session=session)
+
+        # Override timeouts if a dict is provided
+        if timeouts:
+            first_output_timeout = timeouts.get("first_output_timeout", first_output_timeout)
+            between_output_timeout = timeouts.get("between_output_timeout", between_output_timeout)
+            dialog_timeout = timeouts.get("dialog_timeout", dialog_timeout)
+            max_exec_timeout = timeouts.get("max_exec_timeout", max_exec_timeout)
+
+        prompt_patterns = cfg["prompt_patterns"]
+        dialog_patterns = cfg["dialog_patterns"]
+
+        start_time = time.time()
+        last_output_time = start_time
+        full_output = ""
+        truncated_output = ""
+        got_output = False
+
+        # if prefix, log right away
+        if prefix:
+            self.log.update(content=prefix)
+
+        while True:
+            await asyncio.sleep(sleep_time)
+            full_output, partial_output = await self.state.shells[session].session.read_output(
+                timeout=1, reset_full_output=reset_full_output
+            )
+            reset_full_output = False  # only reset once
+
+            await self.agent.handle_intervention()
+
+            now = time.time()
+            if partial_output:
+                PrintStyle(font_color="#85C1E9").stream(partial_output)
+                truncated_output = self.fix_full_output(full_output)
+                self.set_progress(truncated_output)
+                heading = self.get_heading_from_output(truncated_output, 0)
+                self.log.update(content=prefix + truncated_output, heading=heading)
+                last_output_time = now
+                got_output = True
+
+                # Check for shell prompt at the end of output
+                last_lines = (
+                    truncated_output.splitlines()[-3:] if truncated_output else []
+                )
+                last_lines.reverse()
+                for idx, line in enumerate(last_lines):
+                    line = line.strip()
+                    line = line if len(line) <= 500 else line[:250] + line[-250:] # only check start and end on long lines
+                    for pat in prompt_patterns:
+                        if pat.search(line):
+                            PrintStyle.info(
+                                "Detected shell prompt, returning output early."
+                            )
+                            last_lines.reverse()
+                            heading = self.get_heading_from_output(
+                                "\n".join(last_lines), idx + 1, True
+                            )
+                            self.log.update(heading=heading)
+                            self.mark_session_idle(session)
+                            return truncated_output
+
+            # Check for max execution time
+            if now - start_time > max_exec_timeout:
+                sysinfo = self.agent.read_prompt(
+                    "fw.code.max_time.md", timeout=max_exec_timeout
+                )
+                response = self.agent.read_prompt("fw.code.info.md", info=sysinfo)
+                if truncated_output:
+                    response = truncated_output + "\n\n" + response
+                PrintStyle.warning(sysinfo)
+                heading = self.get_heading_from_output(truncated_output, 0)
+                self.log.update(content=prefix + response, heading=heading)
+                return response
+
+            # Waiting for first output
+            if not got_output:
+                if now - start_time > first_output_timeout:
+                    sysinfo = self.agent.read_prompt(
+                        "fw.code.no_out_time.md", timeout=first_output_timeout
+                    )
+                    response = self.agent.read_prompt("fw.code.info.md", info=sysinfo)
+                    PrintStyle.warning(sysinfo)
+                    self.log.update(content=prefix + response)
+                    return response
+            else:
+                # Waiting for more output after first output
+                if now - last_output_time > between_output_timeout:
+                    sysinfo = self.agent.read_prompt(
+                        "fw.code.pause_time.md", timeout=between_output_timeout
+                    )
+                    response = self.agent.read_prompt("fw.code.info.md", info=sysinfo)
+                    if truncated_output:
+                        response = truncated_output + "\n\n" + response
+                    PrintStyle.warning(sysinfo)
+                    heading = self.get_heading_from_output(truncated_output, 0)
+                    self.log.update(content=prefix + response, heading=heading)
+                    return response
+
+                # potential dialog detection
+                if now - last_output_time > dialog_timeout:
+                    last_lines = (
+                        truncated_output.splitlines()[-2:] if truncated_output else []
+                    )
+                    for line in last_lines:
+                        for pat in dialog_patterns:
+                            if pat.search(line.strip()):
+                                PrintStyle.info(
+                                    "Detected dialog prompt, returning output early."
+                                )
+
+                                sysinfo = self.agent.read_prompt(
+                                    "fw.code.pause_dialog.md", timeout=dialog_timeout
+                                )
+                                response = self.agent.read_prompt(
+                                    "fw.code.info.md", info=sysinfo
+                                )
+                                if truncated_output:
+                                    response = truncated_output + "\n\n" + response
+                                PrintStyle.warning(sysinfo)
+                                heading = self.get_heading_from_output(
+                                    truncated_output, 0
+                                )
+                                self.log.update(
+                                    content=prefix + response, heading=heading
+                                )
+                                return response
+
+    async def handle_running_session(
+        self,
+        cfg: dict,
+        session=0,
+        reset_full_output=True,
+        prefix=""
+    ):
+        if not self.state or session not in self.state.shells:
+            return None
+        if not self.state.shells[session].running:
+            return None
+
+        prompt_patterns = cfg["prompt_patterns"]
+        dialog_patterns = cfg["dialog_patterns"]
+
+        full_output, _ = await self.state.shells[session].session.read_output(
+            timeout=1, reset_full_output=reset_full_output
+        )
+        truncated_output = self.fix_full_output(full_output)
+        self.set_progress(truncated_output)
+        heading = self.get_heading_from_output(truncated_output, 0)
+
+        last_lines = (
+            truncated_output.splitlines()[-3:] if truncated_output else []
+        )
+        last_lines.reverse()
+        for line in last_lines:
+            for pat in prompt_patterns:
+                if pat.search(line.strip()):
+                    PrintStyle.info(
+                        "Detected shell prompt, returning output early."
+                    )
+                    self.mark_session_idle(session)
+                    return None
+
+        has_dialog = False
+        for line in last_lines:
+            for pat in dialog_patterns:
+                if pat.search(line.strip()):
+                    has_dialog = True
+                    break
+            if has_dialog:
+                break
+
+        if has_dialog:
+            sys_info = self.agent.read_prompt("fw.code.pause_dialog.md", timeout=1)
+        else:
+            sys_info = self.agent.read_prompt("fw.code.running.md", session=session)
+
+        response = self.agent.read_prompt("fw.code.info.md", info=sys_info)
+        if truncated_output:
+            response = truncated_output + "\n\n" + response
+        PrintStyle(font_color="#FFA500", bold=True).print(response)
+        self.log.update(content=prefix + response, heading=heading)
+        return response
+
+    def mark_session_idle(self, session: int = 0):
+        if self.state and session in self.state.shells:
+            self.state.shells[session].running = False
+
+    async def reset_terminal(self, cfg: dict, session=0, reason: str | None = None):
+        if reason:
+            PrintStyle(font_color="#FFA500", bold=True).print(
+                f"Resetting terminal session {session}... Reason: {reason}"
+            )
+        else:
+            PrintStyle(font_color="#FFA500", bold=True).print(
+                f"Resetting terminal session {session}..."
+            )
+
+        await self.prepare_state(cfg, reset=True, session=session)
+        response = self.agent.read_prompt(
+            "fw.code.info.md", info=self.agent.read_prompt("fw.code.reset.md")
+        )
+        self.log.update(content=response)
+        return response
+
+    def get_heading_from_output(self, output: str, skip_lines=0, done=False):
+        done_icon = " icon://done_all" if done else ""
+
+        if not output:
+            return self.get_heading() + done_icon
+
+        lines = output.splitlines()
+        for i in range(len(lines) - skip_lines - 1, -1, -1):
+            line = lines[i].strip()
+            if not line:
+                continue
+            return self.get_heading(line) + done_icon
+
+        return self.get_heading() + done_icon
+
+    def fix_full_output(self, output: str):
+        output = re.sub(r"(?<!\\)\\x[0-9A-Fa-f]{2}", "", output)
+        output = truncate_text_agent(agent=self.agent, output=output, threshold=1000000)
+        return output
+
+    async def ensure_cwd(self) -> str | None:
+        project_name = projects.get_context_project_name(self.agent.context)
+        if project_name:
+            path = projects.get_project_folder(project_name)
+        else:
+            set = settings.get_settings()
+            path = set.get("workdir_path")
+
+        if not path:
+            return None
+
+        normalized = files.normalize_a0_path(path)
+        await runtime.call_development_function(make_dir, normalized)
+        return normalized
+
+
+# ------------------------------------------------------------------
+# Internal
+# ------------------------------------------------------------------
+
+def _resolve_ssh_enabled(raw_value) -> bool:
+    val = str(raw_value).strip().lower()
+    if val == "auto":
+        return not runtime.is_dockerized()
+    return val in ("true", "1", "yes", "on")
+
+
+def _resolve_ssh_addr(cfg_addr: str) -> str:
+    if cfg_addr:
+        return cfg_addr
+    set = settings.get_settings()
+    host = set.get("rfc_url", "localhost")
+    if "//" in host:
+        host = host.split("//")[1]
+    if ":" in host:
+        host = host.split(":")[0]
+    if host.endswith("/"):
+        host = host.rstrip("/")
+    return host or "localhost"
+
+
+async def _resolve_ssh_pass(cfg_pass: str) -> str:
+    if cfg_pass:
+        return cfg_pass
+    return await rfc_exchange.get_root_password()
+
+
+def _parse_patterns(raw, flags=0) -> list[re.Pattern]:
+    lines = [str(p) for p in raw] if isinstance(raw, list) else str(raw).splitlines()
+    return [re.compile(p.strip(), flags) for p in lines if p.strip()]
+
+
+_TIMEOUT_KEYS = ("first_output_timeout", "between_output_timeout", "max_exec_timeout", "dialog_timeout")
+
+
+def _parse_timeouts(cfg: dict, prefix: str, defaults: tuple[int, ...]) -> dict:
+    return {
+        key: int(cfg.get(f"{prefix}_{key}", default))
+        for key, default in zip(_TIMEOUT_KEYS, defaults)
+    }
+
+
+def _get_config(agent) -> dict:
+    cfg = plugins.get_plugin_config("_code_execution", agent=agent) or {}
+
+    return {
+        "ssh_enabled": _resolve_ssh_enabled(cfg.get("ssh_enabled", "auto")),
+        "ssh_addr": _resolve_ssh_addr(str(cfg.get("ssh_addr", ""))),
+        "ssh_port": int(cfg.get("ssh_port", 55022)),
+        "ssh_user": str(cfg.get("ssh_user", "root")),
+        "ssh_pass": str(cfg.get("ssh_pass", "")),
+        "code_exec_timeouts": _parse_timeouts(cfg, "code_exec", (30, 15, 180, 5)),
+        "output_timeouts": _parse_timeouts(cfg, "output", (90, 45, 300, 5)),
+        "prompt_patterns": _parse_patterns(cfg.get("prompt_patterns", "")),
+        "dialog_patterns": _parse_patterns(cfg.get("dialog_patterns", ""), re.IGNORECASE),
+    }
+
+
+def make_dir(path: str):
+    import os
+    os.makedirs(path, exist_ok=True)

plugins/_code_execution/tools/input.py

@@ -1,3 +1,26 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9df378bf0ab4be63b9561310f7c3d12d39092a602ed069154a96a729fc5fe204
-size 1176
+from helpers.tool import Tool, Response
+from plugins._code_execution.tools.code_execution_tool import CodeExecution
+
+
+class Input(Tool):
+
+    async def execute(self, keyboard="", **kwargs):
+        # normalize keyboard input
+        keyboard = keyboard.rstrip()
+        # keyboard += "\n" # no need to, code_exec does that
+        
+        # terminal session number
+        session = int(self.args.get("session", 0))
+
+        # forward keyboard input to code execution tool
+        args = {"runtime": "terminal", "code": keyboard, "session": session, "allow_running": True}
+        cet = CodeExecution(self.agent, "code_execution_tool", "", args, self.message, self.loop_data)
+        cet.log = self.log
+        return await cet.execute(**args)
+
+    def get_log_object(self):
+        import uuid
+        return self.agent.context.log.log(type="code_exe", heading=f"icon://keyboard {self.agent.agent_name}: Using tool '{self.name}'", content="", kvps=self.args, id=str(uuid.uuid4()))
+
+    async def after_execution(self, response, **kwargs):
+        self.agent.hist_add_tool_result(self.name, response.message, id=self.log.id if self.log else "", **(response.additional or {}))

plugins/_code_execution/webui/config.html

@@ -1,3 +1,204 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f54f4dcc7da0133df7ad98297d492a5ae20a8ee34fa7f7baa2746631bcfd1f88
-size 10012
+<html>
+<head>
+    <title>Code Execution</title>
+</head>
+
+<body>
+    <div x-data>
+        <template x-if="config">
+            <div>
+                <div class="section-title">Code Execution</div>
+                <div class="section-description">
+                    Configuration for the code execution tool. Controls the shell interface, SSH credentials, execution timeouts, and prompt/dialog detection patterns.
+                </div>
+
+                <!-- Shell Interface -->
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Shell Interface</div>
+                        <div class="field-description">
+                            <b>Auto</b>: SSH when running outside Docker, local TTY when dockerized.
+                            <b>SSH</b>: always connect via SSH. <b>Local</b>: always use local PTY.
+                        </div>
+                    </div>
+                    <div class="field-control">
+                        <select x-model="config.ssh_enabled">
+                            <option value="auto">Auto</option>
+                            <option value="true">SSH</option>
+                            <option value="false">Local TTY</option>
+                        </select>
+                    </div>
+                </div>
+
+                <!-- SSH credentials (shown when SSH or Auto) -->
+                <template x-if="config.ssh_enabled !== 'false'">
+                    <div>
+                        <div class="field">
+                            <div class="field-label">
+                                <div class="field-title">SSH Address</div>
+                                <div class="field-description">Hostname or IP of the SSH target. Leave empty to use the RFC URL from settings.</div>
+                            </div>
+                            <div class="field-control">
+                                <input type="text" x-model="config.ssh_addr" placeholder="(from RFC URL)" />
+                            </div>
+                        </div>
+
+                        <div class="field">
+                            <div class="field-label">
+                                <div class="field-title">SSH Port</div>
+                                <div class="field-description">SSH port on the target host (default: 55022 for Docker RFC).</div>
+                            </div>
+                            <div class="field-control">
+                                <input type="number" min="1" max="65535" x-model.number="config.ssh_port" />
+                            </div>
+                        </div>
+
+                        <div class="field">
+                            <div class="field-label">
+                                <div class="field-title">SSH User</div>
+                                <div class="field-description">Username for SSH login.</div>
+                            </div>
+                            <div class="field-control">
+                                <input type="text" x-model="config.ssh_user" placeholder="root" />
+                            </div>
+                        </div>
+
+                        <div class="field">
+                            <div class="field-label">
+                                <div class="field-title">SSH Password</div>
+                                <div class="field-description">Password for SSH login. Leave empty to use the dev root password (via RFC).</div>
+                            </div>
+                            <div class="field-control">
+                                <input type="password" autocomplete="off" x-model="config.ssh_pass" placeholder="(from RFC)" />
+                            </div>
+                        </div>
+                    </div>
+                </template>
+
+                <!-- Execution timeouts -->
+                <div class="section-title">Execution Timeouts</div>
+                <div class="section-description">
+                    Timeouts (in seconds) for python, nodejs, and terminal runtimes.
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">First output timeout</div>
+                        <div class="field-description">Seconds to wait for the first output before returning control to the agent.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.code_exec_first_output_timeout" />
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Between output timeout</div>
+                        <div class="field-description">Seconds to wait between output chunks before returning control.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.code_exec_between_output_timeout" />
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Max execution timeout</div>
+                        <div class="field-description">Hard cap on total execution time in seconds.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.code_exec_max_exec_timeout" />
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Dialog detection timeout</div>
+                        <div class="field-description">Seconds of idle output before checking for dialog prompts.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.code_exec_dialog_timeout" />
+                    </div>
+                </div>
+
+                <!-- Output runtime timeouts -->
+                <div class="section-title">Output Runtime Timeouts</div>
+                <div class="section-description">
+                    Timeouts (in seconds) for the "output" runtime (waiting for long-running processes).
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">First output timeout</div>
+                        <div class="field-description">Seconds to wait for the first output.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.output_first_output_timeout" />
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Between output timeout</div>
+                        <div class="field-description">Seconds to wait between output chunks.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.output_between_output_timeout" />
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Max execution timeout</div>
+                        <div class="field-description">Hard cap on total wait time in seconds.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.output_max_exec_timeout" />
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Dialog detection timeout</div>
+                        <div class="field-description">Seconds of idle output before checking for dialog prompts.</div>
+                    </div>
+                    <div class="field-control">
+                        <input type="number" min="1" x-model.number="config.output_dialog_timeout" />
+                    </div>
+                </div>
+
+                <!-- Patterns -->
+                <div class="section-title">Detection Patterns</div>
+                <div class="section-description">
+                    Regular expressions used to detect shell prompts and interactive dialogs. One pattern per line.
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Prompt patterns</div>
+                        <div class="field-description">
+                            When any pattern matches the last output lines, execution is considered complete and output is returned immediately.
+                        </div>
+                    </div>
+                    <div class="field-control">
+                        <textarea rows="5" x-model="config.prompt_patterns"></textarea>
+                    </div>
+                </div>
+
+                <div class="field">
+                    <div class="field-label">
+                        <div class="field-title">Dialog patterns</div>
+                        <div class="field-description">
+                            When any pattern matches after the dialog timeout, control is returned to the agent to handle the interactive prompt.
+                        </div>
+                    </div>
+                    <div class="field-control">
+                        <textarea rows="4" x-model="config.dialog_patterns"></textarea>
+                    </div>
+                </div>
+            </div>
+        </template>
+    </div>
+</body>
+
+</html>