Skip to content

Agent Zero AI framework

Revert "Add builtin ACP plugin"

Alessandrob52b4220d928
diff --git a/extensions/python/message_loop_prompts_after/_75_include_workdir_extras.py b/extensions/python/message_loop_prompts_after/_75_include_workdir_extras.py
index 1e8d86058..d823b8199 100644
--- a/extensions/python/message_loop_prompts_after/_75_include_workdir_extras.py
+++ b/extensions/python/message_loop_prompts_after/_75_include_workdir_extras.py
@@ -50,7 +50,7 @@ class IncludeWorkdirExtras(Extension):
max_lines = set["workdir_max_lines"]
gitignore_raw = set["workdir_gitignore"]
- folder = self.agent.context.get_data("workdir_path") or set["workdir_path"]
+ folder = set["workdir_path"]
scan_path = files.get_abs_path_development(folder)
files.create_dir(scan_path)
diff --git a/plugins/_acp/README.md b/plugins/_acp/README.md
deleted file mode 100644
index 6f99df8d2..000000000
--- a/plugins/_acp/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-# Agent Client Protocol
-
-This builtin plugin exposes Agent Zero through the Agent Client Protocol (ACP)
-over stdio so ACP-capable editors can create, load, resume, and prompt Agent
-Zero sessions directly from a workspace.
-
-## Usage
-
-From the Agent Zero repository or runtime container:
-
-```bash
-python -m plugins._acp
-```
-
-For the Dockerized Agent Zero runtime, point the editor command at the
-framework interpreter inside the container, for example:
-
-```bash
-docker exec -i agent-zero /opt/venv-a0/bin/python -m plugins._acp
-```
-
-ACP reserves stdout for JSON-RPC, so the adapter writes diagnostics to stderr.
-
-## Checks
-
-```bash
-python -m plugins._acp --check
-python -m plugins._acp --registry
-```
-
-The ACP Python SDK is provided by `agent-client-protocol`.
-Fresh Docker images install it through the root `requirements.txt`; self-updated
-instances lazy-install the same root pin through `plugins/_acp/hooks.py` the
-first time the ACP stdio entrypoint starts.
diff --git a/plugins/_acp/__init__.py b/plugins/_acp/__init__.py
deleted file mode 100644
index d17b30566..000000000
--- a/plugins/_acp/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-PLUGIN_NAME = "_acp"
-PLUGIN_TITLE = "Agent Client Protocol"
-AGENT_ZERO_ACP_VERSION = "1.19"
-PLUGIN_VERSION = AGENT_ZERO_ACP_VERSION
diff --git a/plugins/_acp/__main__.py b/plugins/_acp/__main__.py
deleted file mode 100644
index 56511a45b..000000000
--- a/plugins/_acp/__main__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from .entry import main
-
-
-if __name__ == "__main__":
- main()
diff --git a/plugins/_acp/acp_registry/agent.json b/plugins/_acp/acp_registry/agent.json
deleted file mode 100644
index 006c390bf..000000000
--- a/plugins/_acp/acp_registry/agent.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
- "id": "agent-zero",
- "name": "Agent Zero",
- "version": "1.19",
- "description": "Agent Zero ACP adapter for editor-native agent sessions.",
- "repository": "https://github.com/agent0ai/agent-zero",
- "authors": ["Agent Zero"],
- "license": "MIT",
- "distribution": {
- "stdio": {
- "command": "python",
- "args": ["-m", "plugins._acp"]
- }
- }
-}
diff --git a/plugins/_acp/entry.py b/plugins/_acp/entry.py
deleted file mode 100644
index 15cc13266..000000000
--- a/plugins/_acp/entry.py
+++ /dev/null
@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import asyncio
-import logging
-import sys
-from pathlib import Path
-
-from plugins._acp import PLUGIN_VERSION
-
-
-_BENIGN_PROBE_METHODS = {"ping", "health", "healthcheck"}
-
-
-class _BenignProbeFilter(logging.Filter):
- def filter(self, record: logging.LogRecord) -> bool:
- if record.getMessage() != "Background task failed":
- return True
- exc_info = record.exc_info
- if not exc_info:
- return True
- try:
- from acp.exceptions import RequestError
- except ImportError:
- return True
- exc = exc_info[1]
- if not isinstance(exc, RequestError):
- return True
- if getattr(exc, "code", None) != -32601:
- return True
- data = getattr(exc, "data", None)
- method = data.get("method") if isinstance(data, dict) else None
- return method not in _BENIGN_PROBE_METHODS
-
-
-def main(argv: list[str] | None = None) -> None:
- args = _parse_args(argv)
-
- if args.version:
- print(PLUGIN_VERSION)
- return
-
- if args.registry:
- registry = Path(__file__).resolve().parent / "acp_registry" / "agent.json"
- print(registry.read_text(encoding="utf-8"))
- return
-
- if args.check:
- _run_check()
- return
-
- _setup_logging(debug=args.debug)
- _ensure_project_root()
-
- acp = _import_acp_or_install()
-
- from helpers import persist_chat
- from plugins._acp.helpers.server import AgentZeroACPAgent
-
- persist_chat.load_tmp_chats()
- logger = logging.getLogger(__name__)
- logger.info("Starting Agent Zero ACP adapter")
-
- try:
- asyncio.run(acp.run_agent(AgentZeroACPAgent(), use_unstable_protocol=True))
- except KeyboardInterrupt:
- logger.info("ACP adapter stopped")
- except Exception:
- logger.exception("ACP adapter crashed")
- sys.exit(1)
-
-
-def _parse_args(argv: list[str] | None) -> argparse.Namespace:
- parser = argparse.ArgumentParser(
- prog="agent-zero-acp",
- description="Run Agent Zero as an Agent Client Protocol stdio server.",
- )
- parser.add_argument("--check", action="store_true", help="Verify ACP imports and exit")
- parser.add_argument("--registry", action="store_true", help="Print ACP registry metadata")
- parser.add_argument("--version", action="store_true", help="Print ACP plugin version")
- parser.add_argument("--debug", action="store_true", help="Enable debug logging to stderr")
- return parser.parse_args(argv)
-
-
-def _setup_logging(*, debug: bool = False) -> None:
- handler = logging.StreamHandler(sys.stderr)
- handler.setFormatter(
- logging.Formatter(
- "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
- datefmt="%Y-%m-%d %H:%M:%S",
- )
- )
- handler.addFilter(_BenignProbeFilter())
- root = logging.getLogger()
- root.handlers.clear()
- root.addHandler(handler)
- root.setLevel(logging.DEBUG if debug else logging.INFO)
- logging.getLogger("httpx").setLevel(logging.WARNING)
- logging.getLogger("httpcore").setLevel(logging.WARNING)
- logging.getLogger("openai").setLevel(logging.WARNING)
-
-
-def _ensure_project_root() -> None:
- project_root = str(Path(__file__).resolve().parents[2])
- if project_root not in sys.path:
- sys.path.insert(0, project_root)
-
-
-def _run_check() -> None:
- _ensure_project_root()
- _import_acp_or_install()
- from plugins._acp.helpers.server import AgentZeroACPAgent # noqa: F401
-
- print("Agent Zero ACP check OK")
-
-
-def _import_acp_or_install():
- try:
- import acp
-
- return acp
- except ImportError:
- pass
-
- from plugins._acp import hooks
-
- if hooks.ensure_dependencies(raise_on_error=False):
- try:
- import acp
-
- return acp
- except ImportError:
- pass
-
- _missing_dependency()
-
-
-def _missing_dependency() -> None:
- print(
- "Agent Zero ACP requires agent-client-protocol. "
- "The plugin tried to install the root requirements pin automatically; "
- "manual fallback: pip install agent-client-protocol==0.10.1",
- file=sys.stderr,
- )
- sys.exit(1)
-
-
-if __name__ == "__main__":
- main()
diff --git a/plugins/_acp/extensions/python/reasoning_stream_chunk/_50_acp_stream.py b/plugins/_acp/extensions/python/reasoning_stream_chunk/_50_acp_stream.py
deleted file mode 100644
index 110f28a53..000000000
--- a/plugins/_acp/extensions/python/reasoning_stream_chunk/_50_acp_stream.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from helpers.extension import Extension
-from plugins._acp.helpers import bridge
-
-
-class ACPReasoningStream(Extension):
- async def execute(self, stream_data=None, **kwargs):
- if not self.agent or not stream_data:
- return
- bridge.send_agent_thought_delta(self.agent.context.id, stream_data.get("full", ""))
diff --git a/plugins/_acp/extensions/python/response_stream/_50_acp_response.py b/plugins/_acp/extensions/python/response_stream/_50_acp_response.py
deleted file mode 100644
index aaed2d3af..000000000
--- a/plugins/_acp/extensions/python/response_stream/_50_acp_response.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from helpers.extension import Extension
-from plugins._acp.helpers import bridge
-
-
-class ACPResponseStream(Extension):
- async def execute(self, parsed=None, **kwargs):
- if not self.agent or not isinstance(parsed, dict):
- return
- tool_name = parsed.get("tool_name") or parsed.get("tool")
- if tool_name != "response":
- return
- tool_args = parsed.get("tool_args") if isinstance(parsed.get("tool_args"), dict) else parsed.get("args")
- if not isinstance(tool_args, dict):
- return
- text = tool_args.get("text", tool_args.get("message", ""))
- bridge.send_agent_delta(self.agent.context.id, str(text or ""))
diff --git a/plugins/_acp/extensions/python/tool_execute_after/_50_acp_tool.py b/plugins/_acp/extensions/python/tool_execute_after/_50_acp_tool.py
deleted file mode 100644
index 38550b050..000000000
--- a/plugins/_acp/extensions/python/tool_execute_after/_50_acp_tool.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from helpers.extension import Extension
-from plugins._acp.helpers import bridge
-
-
-class ACPToolFinish(Extension):
- async def execute(self, response=None, tool_name="", **kwargs):
- if not self.agent:
- return
- bridge.finish_tool(self.agent.context.id, str(tool_name or ""), response)
diff --git a/plugins/_acp/extensions/python/tool_execute_before/_50_acp_tool.py b/plugins/_acp/extensions/python/tool_execute_before/_50_acp_tool.py
deleted file mode 100644
index 35acb4118..000000000
--- a/plugins/_acp/extensions/python/tool_execute_before/_50_acp_tool.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from helpers.extension import Extension
-from plugins._acp.helpers import bridge
-
-
-class ACPToolStart(Extension):
- async def execute(self, tool_name="", tool_args=None, **kwargs):
- if not self.agent:
- return
- bridge.start_tool(self.agent.context.id, str(tool_name or ""), tool_args or {})
diff --git a/plugins/_acp/helpers/__init__.py b/plugins/_acp/helpers/__init__.py
deleted file mode 100644
index 8b1378917..000000000
--- a/plugins/_acp/helpers/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/plugins/_acp/helpers/bridge.py b/plugins/_acp/helpers/bridge.py
deleted file mode 100644
index 7d4883121..000000000
--- a/plugins/_acp/helpers/bridge.py
+++ /dev/null
@@ -1,303 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import threading
-import uuid
-from collections import defaultdict, deque
-from dataclasses import dataclass, field
-from typing import Any, Deque
-
-
-logger = logging.getLogger(__name__)
-
-CTX_IS_ACP = "acp_session"
-CTX_CWD = "acp_cwd"
-CTX_ADDITIONAL_DIRECTORIES = "acp_additional_directories"
-CTX_MODE = "acp_mode"
-CTX_CONFIG_OPTIONS = "acp_config_options"
-CTX_MODEL_ID = "acp_model_id"
-CTX_WORKDIR = "workdir_path"
-
-DEFAULT_MODE = "default"
-
-_MAX_RAW_OUTPUT = 12000
-
-
-@dataclass
-class SessionBridge:
- context_id: str
- session_id: str
- conn: Any
- loop: asyncio.AbstractEventLoop
- response_text_sent: str = ""
- thought_text_sent: str = ""
- message_id: str = ""
- tool_queues: dict[str, Deque[str]] = field(default_factory=lambda: defaultdict(deque))
- lock: threading.RLock = field(default_factory=threading.RLock)
-
-
-_bridges_by_context: dict[str, SessionBridge] = {}
-_bridges_by_session: dict[str, SessionBridge] = {}
-_registry_lock = threading.RLock()
-
-
-def register_bridge(
- *,
- context_id: str,
- session_id: str,
- conn: Any,
- loop: asyncio.AbstractEventLoop,
-) -> SessionBridge:
- bridge = SessionBridge(
- context_id=context_id,
- session_id=session_id,
- conn=conn,
- loop=loop,
- )
- with _registry_lock:
- _bridges_by_context[context_id] = bridge
- _bridges_by_session[session_id] = bridge
- return bridge
-
-
-def unregister_bridge(context_id: str | None = None, session_id: str | None = None) -> None:
- with _registry_lock:
- bridge = None
- if context_id:
- bridge = _bridges_by_context.pop(context_id, None)
- if session_id:
- bridge = _bridges_by_session.pop(session_id, None) or bridge
- if bridge:
- _bridges_by_context.pop(bridge.context_id, None)
- _bridges_by_session.pop(bridge.session_id, None)
-
-
-def get_bridge_for_context(context_id: str) -> SessionBridge | None:
- with _registry_lock:
- return _bridges_by_context.get(context_id)
-
-
-def get_bridge_for_session(session_id: str) -> SessionBridge | None:
- with _registry_lock:
- return _bridges_by_session.get(session_id)
-
-
-def reset_turn(context_id: str, message_id: str = "") -> None:
- bridge = get_bridge_for_context(context_id)
- if not bridge:
- return
- with bridge.lock:
- bridge.response_text_sent = ""
- bridge.thought_text_sent = ""
- bridge.message_id = message_id
- bridge.tool_queues.clear()
-
-
-def send_agent_delta(context_id: str, full_text: str) -> bool:
- bridge = get_bridge_for_context(context_id)
- if not bridge:
- return False
- full_text = str(full_text or "")
- with bridge.lock:
- previous = bridge.response_text_sent
- if full_text == previous:
- return False
- if full_text.startswith(previous):
- delta = full_text[len(previous) :]
- else:
- delta = full_text
- bridge.response_text_sent = full_text
- if not delta:
- return False
- return _send_acp_helper_update(bridge, "update_agent_message_text", delta)
-
-
-def send_agent_text(context_id: str, text: str) -> bool:
- bridge = get_bridge_for_context(context_id)
- if not bridge:
- return False
- text = str(text or "")
- if not text:
- return False
- with bridge.lock:
- bridge.response_text_sent += text
- return _send_acp_helper_update(bridge, "update_agent_message_text", text)
-
-
-def send_agent_thought_delta(context_id: str, full_text: str) -> bool:
- bridge = get_bridge_for_context(context_id)
- if not bridge:
- return False
- full_text = str(full_text or "")
- with bridge.lock:
- previous = bridge.thought_text_sent
- if full_text == previous:
- return False
- if full_text.startswith(previous):
- delta = full_text[len(previous) :]
- else:
- delta = full_text
- bridge.thought_text_sent = full_text
- if not delta:
- return False
- return _send_acp_helper_update(bridge, "update_agent_thought_text", delta)
-
-
-def start_tool(context_id: str, tool_name: str, tool_args: dict[str, Any] | None = None) -> str:
- bridge = get_bridge_for_context(context_id)
- if not bridge:
- return ""
-
- normalized_name = str(tool_name or "tool")
- if normalized_name == "response":
- return ""
-
- tool_call_id = f"a0-{uuid.uuid4().hex}"
- title = _tool_title(normalized_name, tool_args or {})
- kind = _tool_kind(normalized_name, tool_args or {})
- raw_input = _json_safe(tool_args or {})
-
- try:
- import acp
-
- update = acp.start_tool_call(
- tool_call_id,
- title,
- kind=kind,
- status="in_progress",
- raw_input=raw_input,
- )
- except Exception:
- logger.debug("Could not build ACP tool start", exc_info=True)
- return ""
-
- with bridge.lock:
- bridge.tool_queues[normalized_name].append(tool_call_id)
- _send_update(bridge, update)
- return tool_call_id
-
-
-def finish_tool(context_id: str, tool_name: str, response: Any) -> bool:
- bridge = get_bridge_for_context(context_id)
- if not bridge:
- return False
- normalized_name = str(tool_name or "tool")
- if normalized_name == "response":
- return False
-
- with bridge.lock:
- queue = bridge.tool_queues.get(normalized_name)
- if not queue:
- return False
- tool_call_id = queue.popleft()
- if not queue:
- bridge.tool_queues.pop(normalized_name, None)
-
- message = getattr(response, "message", response)
- raw_output = _truncate_raw_output(message)
- try:
- import acp
-
- update = acp.update_tool_call(
- tool_call_id,
- status="completed",
- raw_output=raw_output,
- )
- except Exception:
- logger.debug("Could not build ACP tool completion", exc_info=True)
- return False
- _send_update(bridge, update)
- return True
-
-
-async def send_update_async(session_id: str, update: Any) -> bool:
- bridge = get_bridge_for_session(session_id)
- if not bridge:
- return False
- try:
- await bridge.conn.session_update(session_id, update)
- return True
- except Exception:
- logger.debug("Could not send ACP update", exc_info=True)
- return False
-
-
-def _send_acp_helper_update(bridge: SessionBridge, helper_name: str, text: str) -> bool:
- try:
- import acp
-
- helper = getattr(acp, helper_name)
- update = helper(text)
- except Exception:
- logger.debug("Could not build ACP text update", exc_info=True)
- return False
- _send_update(bridge, update)
- return True
-
-
-def _send_update(bridge: SessionBridge, update: Any) -> None:
- if bridge.loop.is_closed():
- return
-
- async def _deliver() -> None:
- await bridge.conn.session_update(bridge.session_id, update)
-
- future = asyncio.run_coroutine_threadsafe(_deliver(), bridge.loop)
-
- def _log_failure(done_future: Any) -> None:
- try:
- done_future.result()
- except Exception:
- logger.debug("Failed to send ACP session update", exc_info=True)
-
- future.add_done_callback(_log_failure)
-
-
-def _tool_title(tool_name: str, tool_args: dict[str, Any]) -> str:
- action = tool_args.get("action") or tool_args.get("method") or ""
- if action:
- return f"{tool_name}: {action}"
- return tool_name.replace("_", " ").strip().title() or "Tool"
-
-
-def _tool_kind(tool_name: str, tool_args: dict[str, Any]) -> str:
- probe = " ".join(
- str(value).lower()
- for value in (tool_name, tool_args.get("action", ""), tool_args.get("method", ""))
- )
- if any(token in probe for token in ("read", "list", "show", "inspect")):
- return "read"
- if any(token in probe for token in ("write", "edit", "patch", "replace", "create")):
- return "edit"
- if any(token in probe for token in ("delete", "remove")):
- return "delete"
- if any(token in probe for token in ("move", "rename")):
- return "move"
- if any(token in probe for token in ("search", "find", "grep")):
- return "search"
- if any(token in probe for token in ("terminal", "shell", "python", "node", "code_execution")):
- return "execute"
- if any(token in probe for token in ("browser", "fetch", "http")):
- return "fetch"
- return "other"
-
-
-def _json_safe(value: Any) -> Any:
- try:
- json.dumps(value)
- return value
- except Exception:
- return str(value)
-
-
-def _truncate_raw_output(value: Any) -> Any:
- if value is None:
- return None
- if isinstance(value, str):
- if len(value) <= _MAX_RAW_OUTPUT:
- return value
- hidden = len(value) - _MAX_RAW_OUTPUT
- return value[:_MAX_RAW_OUTPUT] + f"\n\n[ACP output truncated: {hidden} characters hidden]"
- return _json_safe(value)
diff --git a/plugins/_acp/helpers/content.py b/plugins/_acp/helpers/content.py
deleted file mode 100644
index 7351edba2..000000000
--- a/plugins/_acp/helpers/content.py
+++ /dev/null
@@ -1,370 +0,0 @@
-from __future__ import annotations
-
-import base64
-import json
-import mimetypes
-import os
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-from urllib.parse import unquote, urlparse
-
-from helpers import files
-from helpers.security import safe_filename
-
-
-MAX_INLINE_RESOURCE_BYTES = 512 * 1024
-MAX_ATTACHMENT_BYTES = 16 * 1024 * 1024
-
-_TEXT_MIME_PREFIXES = ("text/",)
-_TEXT_MIME_TYPES = {
- "application/json",
- "application/javascript",
- "application/typescript",
- "application/xml",
- "application/x-yaml",
- "application/yaml",
- "application/toml",
- "application/sql",
-}
-
-
-@dataclass
-class PromptParts:
- text: str = ""
- attachments: list[str] = field(default_factory=list)
-
-
-def normalize_cwd(cwd: str | None) -> str:
- raw = str(cwd or "").strip() or os.getcwd()
- raw = os.path.expanduser(raw)
- translated = translate_windows_drive_path(raw)
- if translated:
- raw = translated
- return os.path.abspath(raw)
-
-
-def normalize_path_for_compare(path: str | None) -> str:
- return os.path.normcase(os.path.normpath(normalize_cwd(path)))
-
-
-def translate_windows_drive_path(path: str) -> str | None:
- match = re.match(r"^/?([A-Za-z]):[\\/](.*)$", str(path or ""))
- if not match:
- return None
- drive = match.group(1).lower()
- tail = match.group(2).replace("\\", "/").lstrip("/")
- return f"/mnt/{drive}/{tail}"
-
-
-def path_from_file_uri(uri: str) -> Path | None:
- raw = str(uri or "").strip()
- if not raw:
- return None
-
- parsed = urlparse(raw)
- if parsed.scheme and parsed.scheme != "file":
- return None
-
- if parsed.scheme == "file":
- if parsed.netloc and parsed.netloc not in {"", "localhost"}:
- return None
- path_text = unquote(parsed.path or "")
- else:
- path_text = unquote(raw)
-
- translated = translate_windows_drive_path(path_text)
- if translated:
- return Path(translated)
- return Path(path_text)
-
-
-def stringify_message_content(content: Any) -> str:
- if isinstance(content, str):
- return content
- if isinstance(content, dict):
- preview = content.get("preview")
- if isinstance(preview, str) and preview.strip():
- return preview
- raw = content.get("raw_content")
- if raw is not None:
- return stringify_message_content(raw)
- if isinstance(content, list):
- parts = [stringify_message_content(item) for item in content]
- return "\n".join(part for part in parts if part)
- try:
- return json.dumps(content, ensure_ascii=False)
- except Exception:
- return str(content)
-
-
-def prompt_blocks_to_user_message(
- prompt: list[Any],
- *,
- context_id: str,
- message_id: str,
-) -> PromptParts:
- text_parts: list[str] = []
- attachments: list[str] = []
-
- for index, block in enumerate(prompt or []):
- block_type = str(getattr(block, "type", "") or "").strip()
- if block_type == "text" or hasattr(block, "text"):
- text = str(getattr(block, "text", "") or "")
- if text:
- text_parts.append(text)
- continue
-
- if block_type == "image":
- _append_media_block(
- block,
- context_id=context_id,
- message_id=message_id,
- index=index,
- kind="image",
- text_parts=text_parts,
- attachments=attachments,
- )
- continue
-
- if block_type == "audio":
- _append_media_block(
- block,
- context_id=context_id,
- message_id=message_id,
- index=index,
- kind="audio",
- text_parts=text_parts,
- attachments=attachments,
- )
- continue
-
- if block_type == "resource_link":
- _append_resource_link(block, text_parts=text_parts, attachments=attachments)
- continue
-
- if block_type == "resource":
- _append_embedded_resource(
- block,
- context_id=context_id,
- message_id=message_id,
- index=index,
- text_parts=text_parts,
- attachments=attachments,
- )
-
- text = "\n\n".join(part for part in text_parts if part).strip()
- if not text and attachments:
- text = "Please inspect the attached file(s)."
- return PromptParts(text=text, attachments=attachments)
-
-
-def _append_media_block(
- block: Any,
- *,
- context_id: str,
- message_id: str,
- index: int,
- kind: str,
- text_parts: list[str],
- attachments: list[str],
-) -> None:
- uri = str(getattr(block, "uri", "") or "").strip()
- mime_type = str(getattr(block, "mime_type", "") or "").strip() or None
- data = str(getattr(block, "data", "") or "").strip()
-
- if uri:
- path = path_from_file_uri(uri)
- if path and path.exists():
- attachments.append(str(path))
- text_parts.append(f"[Attached {kind}: {path}]")
- return
- text_parts.append(f"[Attached {kind} reference: {uri}]")
- return
-
- if not data:
- return
-
- try:
- raw = base64.b64decode(data.split(",", 1)[-1], validate=False)
- except Exception:
- raw = data.encode("utf-8", errors="replace")
-
- saved = _save_attachment_bytes(
- context_id=context_id,
- message_id=message_id,
- index=index,
- label=kind,
- data=raw,
- mime_type=mime_type,
- )
- attachments.append(saved)
- text_parts.append(f"[Attached {kind}: {saved}]")
-
-
-def _append_resource_link(
- block: Any,
- *,
- text_parts: list[str],
- attachments: list[str],
-) -> None:
- uri = str(getattr(block, "uri", "") or "").strip()
- if not uri:
- return
- name = _resource_display_name(block, uri)
- mime_type = str(getattr(block, "mime_type", "") or "").strip() or None
- path = path_from_file_uri(uri)
-
- if path is None:
- text_parts.append(f"[Attached resource: {name}]\nURI: {uri}")
- return
-
- if not path.exists():
- text_parts.append(f"[Attached resource unavailable: {name}]\nURI: {uri}\nPath: {path}")
- return
-
- if _is_probably_text(path, mime_type):
- try:
- size = path.stat().st_size
- data = path.read_bytes()[:MAX_INLINE_RESOURCE_BYTES]
- body = decode_text_bytes(data, mime_type) or ""
- if size > MAX_INLINE_RESOURCE_BYTES:
- body += f"\n\n[Truncated to {MAX_INLINE_RESOURCE_BYTES} of {size} bytes]"
- text_parts.append(f"[Attached file: {name}]\nURI: {uri}\n\n{body}")
- return
- except OSError as exc:
- text_parts.append(f"[Attached file unreadable: {name}]\nURI: {uri}\nError: {exc}")
- return
-
- attachments.append(str(path))
- text_parts.append(f"[Attached file: {path}]")
-
-
-def _append_embedded_resource(
- block: Any,
- *,
- context_id: str,
- message_id: str,
- index: int,
- text_parts: list[str],
- attachments: list[str],
-) -> None:
- resource = getattr(block, "resource", None)
- if resource is None:
- return
-
- uri = str(getattr(resource, "uri", "") or "").strip()
- mime_type = str(getattr(resource, "mime_type", "") or "").strip() or None
- if hasattr(resource, "text"):
- body = str(getattr(resource, "text", "") or "")
- text_parts.append(f"[Attached resource: {uri or 'embedded text'}]\n\n{body}")
- return
-
- blob = str(getattr(resource, "blob", "") or "")
- if not blob:
- return
-
- try:
- data = base64.b64decode(blob, validate=True)
- except Exception:
- data = blob.encode("utf-8", errors="replace")
-
- text = decode_text_bytes(data[:MAX_INLINE_RESOURCE_BYTES], mime_type)
- if text is not None and _is_text_mime(mime_type):
- if len(data) > MAX_INLINE_RESOURCE_BYTES:
- text += f"\n\n[Truncated to {MAX_INLINE_RESOURCE_BYTES} of {len(data)} bytes]"
- text_parts.append(f"[Attached resource: {uri or 'embedded text'}]\n\n{text}")
- return
-
- saved = _save_attachment_bytes(
- context_id=context_id,
- message_id=message_id,
- index=index,
- label="resource",
- data=data,
- mime_type=mime_type,
- )
- attachments.append(saved)
- text_parts.append(f"[Attached resource: {saved}]")
-
-
-def _save_attachment_bytes(
- *,
- context_id: str,
- message_id: str,
- index: int,
- label: str,
- data: bytes,
- mime_type: str | None,
-) -> str:
- if len(data) > MAX_ATTACHMENT_BYTES:
- data = data[:MAX_ATTACHMENT_BYTES]
-
- extension = mimetypes.guess_extension((mime_type or "").split(";", 1)[0]) or ".bin"
- base_name = safe_filename(f"{label}-{message_id}-{index}{extension}") or f"{label}-{index}{extension}"
- from helpers import persist_chat
-
- attach_dir = files.get_abs_path(persist_chat.get_chat_folder_path(context_id), "acp")
- os.makedirs(attach_dir, exist_ok=True)
- path = os.path.join(attach_dir, base_name)
- with open(path, "wb") as handle:
- handle.write(data)
- return files.normalize_a0_path(path)
-
-
-def _resource_display_name(block: Any, uri: str) -> str:
- title = str(getattr(block, "title", "") or "").strip()
- name = str(getattr(block, "name", "") or "").strip()
- if title and name and title != name:
- return f"{title} ({name})"
- if title:
- return title
- if name:
- return name
- parsed = urlparse(uri)
- return Path(unquote(parsed.path or uri)).name or uri or "resource"
-
-
-def _is_text_mime(mime_type: str | None) -> bool:
- mime = (mime_type or "").split(";", 1)[0].strip().lower()
- if not mime:
- return False
- return mime.startswith(_TEXT_MIME_PREFIXES) or mime in _TEXT_MIME_TYPES
-
-
-def _is_probably_text(path: Path, mime_type: str | None) -> bool:
- if _is_text_mime(mime_type):
- return True
- guessed, _encoding = mimetypes.guess_type(str(path))
- if _is_text_mime(guessed):
- return True
- return path.suffix.lower() in {
- ".md",
- ".txt",
- ".py",
- ".js",
- ".ts",
- ".tsx",
- ".jsx",
- ".json",
- ".yaml",
- ".yml",
- ".toml",
- ".xml",
- ".html",
- ".css",
- ".sql",
- ".sh",
- }
-
-
-def decode_text_bytes(data: bytes, mime_type: str | None = None) -> str | None:
- if b"\x00" in data and not _is_text_mime(mime_type):
- return None
- for encoding in ("utf-8-sig", "utf-8", "latin-1"):
- try:
- return data.decode(encoding)
- except UnicodeDecodeError:
- continue
- return data.decode("utf-8", errors="replace")
diff --git a/plugins/_acp/helpers/server.py b/plugins/_acp/helpers/server.py
deleted file mode 100644
index 38945dbea..000000000
--- a/plugins/_acp/helpers/server.py
+++ /dev/null
@@ -1,627 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-import uuid
-from concurrent.futures import CancelledError
-from pathlib import Path
-from typing import Any
-
-import acp
-from acp.schema import (
- AgentCapabilities,
- AvailableCommand,
- AvailableCommandsUpdate,
- ClientCapabilities,
- CloseSessionResponse,
- CurrentModeUpdate,
- ForkSessionResponse,
- Implementation,
- InitializeResponse,
- ListSessionsResponse,
- LoadSessionResponse,
- NewSessionResponse,
- PromptCapabilities,
- PromptResponse,
- ResumeSessionResponse,
- SessionCapabilities,
- SessionForkCapabilities,
- SessionInfo,
- SessionListCapabilities,
- SessionMode,
- SessionModeState,
- SessionResumeCapabilities,
- SetSessionConfigOptionResponse,
- SetSessionModelResponse,
- SetSessionModeResponse,
- UnstructuredCommandInput,
- Usage,
-)
-
-from agent import Agent, AgentContext, AgentContextType, UserMessage
-from helpers import git, message_queue as mq, persist_chat, tokens
-from helpers.localization import Localization
-from initialize import initialize_agent
-from plugins._acp import AGENT_ZERO_ACP_VERSION, PLUGIN_VERSION
-from plugins._acp.helpers import bridge
-from plugins._acp.helpers.content import (
- normalize_cwd,
- normalize_path_for_compare,
- prompt_blocks_to_user_message,
- stringify_message_content,
-)
-
-
-logger = logging.getLogger(__name__)
-
-
-class AgentZeroACPAgent(acp.Agent):
- _ADVERTISED_COMMANDS = (
- {
- "name": "help",
- "description": "List Agent Zero ACP commands",
- },
- {
- "name": "context",
- "description": "Show conversation and context-window status",
- },
- {
- "name": "reset",
- "description": "Clear the current Agent Zero conversation",
- },
- {
- "name": "version",
- "description": "Show Agent Zero and ACP plugin versions",
- },
- )
-
- _MODE_DEFAULT = bridge.DEFAULT_MODE
- _MODE_PLAN = "plan"
- _MODE_ACT = "act"
-
- _MODE_INSTRUCTIONS = {
- _MODE_PLAN: (
- "ACP session mode: plan first. Prefer analysis, architecture, and tradeoffs. "
- "Do not modify files unless the user explicitly asks you to proceed."
- ),
- _MODE_ACT: (
- "ACP session mode: act. Complete the requested work end-to-end with focused "
- "implementation and validation."
- ),
- }
-
- def __init__(self) -> None:
- super().__init__()
- self._conn: acp.Client | None = None
-
- def on_connect(self, conn: acp.Client) -> None:
- self._conn = conn
- logger.info("ACP client connected")
-
- async def initialize(
- self,
- protocol_version: int | None = None,
- client_capabilities: ClientCapabilities | None = None,
- client_info: Implementation | None = None,
- **kwargs: Any,
- ) -> InitializeResponse:
- client_name = client_info.name if client_info else "unknown"
- logger.info("ACP initialize from %s (protocol v%s)", client_name, protocol_version)
- return InitializeResponse(
- protocol_version=acp.PROTOCOL_VERSION,
- agent_info=Implementation(
- name="agent-zero",
- title="Agent Zero",
- version=AGENT_ZERO_ACP_VERSION,
- ),
- agent_capabilities=AgentCapabilities(
- load_session=True,
- prompt_capabilities=PromptCapabilities(
- embedded_context=True,
- image=True,
- audio=True,
- ),
- session_capabilities=SessionCapabilities(
- fork=SessionForkCapabilities(),
- list=SessionListCapabilities(),
- resume=SessionResumeCapabilities(),
- ),
- ),
- auth_methods=[],
- )
-
- async def new_session(
- self,
- cwd: str,
- additional_directories: list[str] | None = None,
- **kwargs: Any,
- ) -> NewSessionResponse:
- context = self._create_context(cwd=cwd, additional_directories=additional_directories)
- self._register(context)
- await self._send_session_start_updates(context)
- persist_chat.save_tmp_chat(context)
- return NewSessionResponse(session_id=context.id, modes=self._session_modes(context))
-
- async def load_session(
- self,
- cwd: str,
- session_id: str,
- additional_directories: list[str] | None = None,
- **kwargs: Any,
- ) -> LoadSessionResponse | None:
- context = self._get_context(session_id)
- if context is None:
- logger.warning("ACP load_session: missing session %s", session_id)
- return None
- self._apply_workspace(context, cwd=cwd, additional_directories=additional_directories)
- self._register(context)
- await self._replay_history(context)
- await self._send_session_start_updates(context)
- persist_chat.save_tmp_chat(context)
- return LoadSessionResponse(modes=self._session_modes(context))
-
- async def resume_session(
- self,
- cwd: str,
- session_id: str,
- additional_directories: list[str] | None = None,
- **kwargs: Any,
- ) -> ResumeSessionResponse:
- context = self._get_context(session_id)
- if context is None:
- context = self._create_context(
- cwd=cwd,
- additional_directories=additional_directories,
- context_id=session_id,
- )
- else:
- self._apply_workspace(context, cwd=cwd, additional_directories=additional_directories)
- self._register(context)
- await self._replay_history(context)
- await self._send_session_start_updates(context)
- persist_chat.save_tmp_chat(context)
- return ResumeSessionResponse(modes=self._session_modes(context))
-
- async def fork_session(
- self,
- cwd: str,
- session_id: str,
- additional_directories: list[str] | None = None,
- **kwargs: Any,
- ) -> ForkSessionResponse:
- original = self._get_context(session_id)
- if original is None:
- return ForkSessionResponse(session_id="")
-
- new_ids = persist_chat.load_json_chats([persist_chat.export_json_chat(original)])
- new_id = new_ids[0] if new_ids else ""
- context = self._get_context(new_id) if new_id else None
- if context is None:
- return ForkSessionResponse(session_id="")
-
- context.name = f"{original.name or 'ACP session'} (fork)"
- self._apply_workspace(context, cwd=cwd, additional_directories=additional_directories)
- self._register(context)
- await self._send_session_start_updates(context)
- persist_chat.save_tmp_chat(context)
- return ForkSessionResponse(session_id=context.id, modes=self._session_modes(context))
-
- async def list_sessions(
- self,
- cursor: str | None = None,
- cwd: str | None = None,
- **kwargs: Any,
- ) -> ListSessionsResponse:
- persist_chat.load_tmp_chats()
- contexts = [ctx for ctx in AgentContext.all() if ctx.get_data(bridge.CTX_IS_ACP)]
- if cwd:
- normalized = normalize_path_for_compare(cwd)
- contexts = [
- ctx
- for ctx in contexts
- if normalize_path_for_compare(ctx.get_data(bridge.CTX_CWD) or ctx.get_data(bridge.CTX_WORKDIR))
- == normalized
- ]
-
- contexts.sort(key=lambda ctx: ctx.last_message or ctx.created_at, reverse=True)
- if cursor:
- for idx, context in enumerate(contexts):
- if context.id == cursor:
- contexts = contexts[idx + 1 :]
- break
- else:
- contexts = []
-
- page = contexts[:50]
- next_cursor = contexts[50].id if len(contexts) > 50 else None
- sessions = [self._session_info(context) for context in page]
- return ListSessionsResponse(sessions=sessions, next_cursor=next_cursor)
-
- async def prompt(
- self,
- prompt: list[Any],
- session_id: str,
- message_id: str | None = None,
- **kwargs: Any,
- ) -> PromptResponse:
- context = self._get_context(session_id)
- if context is None:
- logger.warning("ACP prompt: missing session %s", session_id)
- return PromptResponse(stop_reason="refusal", user_message_id=message_id)
-
- self._register(context)
- msg_id = message_id or str(uuid.uuid4())
- parts = prompt_blocks_to_user_message(
- prompt,
- context_id=context.id,
- message_id=msg_id,
- )
- user_text = parts.text.strip()
- if not user_text and not parts.attachments:
- return PromptResponse(stop_reason="end_turn", user_message_id=msg_id)
-
- context.last_message = Localization.get().now()
-
- text_only = bool(prompt) and all(str(getattr(block, "type", "") or "") == "text" for block in prompt)
- if text_only and not parts.attachments and user_text.startswith("/"):
- response_text = await self._handle_slash_command(user_text, context)
- if response_text is not None:
- await self._send_agent_message(context.id, response_text)
- persist_chat.save_tmp_chat(context)
- return PromptResponse(stop_reason="end_turn", user_message_id=msg_id)
-
- if context.is_running():
- await self._send_agent_message(
- context.id,
- "A turn is already running. Wait for it to finish or send cancel from the ACP client.",
- )
- return PromptResponse(stop_reason="end_turn", user_message_id=msg_id)
-
- mode_instruction = self._mode_instruction(context)
- system_message = [mode_instruction] if mode_instruction else []
- mq.log_user_message(
- context,
- user_text,
- parts.attachments,
- message_id=msg_id,
- source=" (ACP)",
- )
- bridge.reset_turn(context.id, msg_id)
-
- task = context.communicate(
- UserMessage(
- message=user_text,
- attachments=parts.attachments,
- system_message=system_message,
- id=msg_id,
- )
- )
-
- stop_reason = "end_turn"
- final_text = ""
- try:
- result = await task.result()
- final_text = "" if result is None else str(result)
- except (asyncio.CancelledError, CancelledError):
- stop_reason = "cancelled"
- except Exception as exc:
- logger.exception("ACP prompt failed for session %s", session_id)
- final_text = f"Error: {exc}"
- stop_reason = "end_turn"
-
- session_bridge = bridge.get_bridge_for_context(context.id)
- if final_text and session_bridge and not session_bridge.response_text_sent.strip():
- await self._send_agent_message(context.id, final_text)
- elif final_text and session_bridge is None:
- await self._send_agent_message(context.id, final_text)
-
- persist_chat.save_tmp_chat(context)
- return PromptResponse(
- stop_reason=stop_reason,
- usage=self._usage(context, final_text),
- user_message_id=msg_id,
- )
-
- async def cancel(self, session_id: str, **kwargs: Any) -> None:
- context = self._get_context(session_id)
- if context:
- context.kill_process()
- bridge.reset_turn(context.id)
- logger.info("ACP cancelled session %s", session_id)
-
- async def close_session(self, session_id: str, **kwargs: Any) -> CloseSessionResponse | None:
- context = self._get_context(session_id)
- if context:
- context.kill_process()
- AgentContext.remove(context.id)
- persist_chat.remove_chat(context.id)
- bridge.unregister_bridge(session_id=session_id)
- return CloseSessionResponse()
-
- async def set_session_mode(
- self,
- mode_id: str,
- session_id: str,
- **kwargs: Any,
- ) -> SetSessionModeResponse | None:
- context = self._get_context(session_id)
- if context is None:
- return None
- normalized = str(mode_id or self._MODE_DEFAULT).strip()
- if normalized not in {self._MODE_DEFAULT, self._MODE_PLAN, self._MODE_ACT}:
- normalized = self._MODE_DEFAULT
- context.set_data(bridge.CTX_MODE, normalized)
- persist_chat.save_tmp_chat(context)
- await self._send_current_mode(context)
- return SetSessionModeResponse()
-
- async def set_session_model(
- self,
- model_id: str,
- session_id: str,
- **kwargs: Any,
- ) -> SetSessionModelResponse | None:
- context = self._get_context(session_id)
- if context is None:
- return None
- context.set_data(bridge.CTX_MODEL_ID, str(model_id or ""))
- persist_chat.save_tmp_chat(context)
- return SetSessionModelResponse()
-
- async def set_config_option(
- self,
- config_id: str,
- session_id: str,
- value: str | bool,
- **kwargs: Any,
- ) -> SetSessionConfigOptionResponse | None:
- context = self._get_context(session_id)
- if context is None:
- return None
- options = context.get_data(bridge.CTX_CONFIG_OPTIONS) or {}
- if not isinstance(options, dict):
- options = {}
- options[str(config_id)] = value
- context.set_data(bridge.CTX_CONFIG_OPTIONS, options)
- persist_chat.save_tmp_chat(context)
- return SetSessionConfigOptionResponse(config_options=[])
-
- async def ext_method(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
- if method in {"ping", "health", "healthcheck"}:
- return {"ok": True}
- return {}
-
- async def ext_notification(self, method: str, params: dict[str, Any]) -> None:
- return None
-
- def _create_context(
- self,
- *,
- cwd: str,
- additional_directories: list[str] | None = None,
- context_id: str | None = None,
- ) -> AgentContext:
- resolved_cwd = normalize_cwd(cwd)
- context = AgentContext(
- config=initialize_agent(),
- id=context_id or None,
- name=self._title_for_cwd(resolved_cwd),
- type=AgentContextType.USER,
- )
- self._apply_workspace(context, cwd=resolved_cwd, additional_directories=additional_directories)
- return context
-
- def _get_context(self, session_id: str) -> AgentContext | None:
- context = AgentContext.get(session_id)
- if context is not None:
- return context
- persist_chat.load_tmp_chats()
- return AgentContext.get(session_id)
-
- def _apply_workspace(
- self,
- context: AgentContext,
- *,
- cwd: str,
- additional_directories: list[str] | None = None,
- ) -> None:
- resolved_cwd = normalize_cwd(cwd)
- context.set_data(bridge.CTX_IS_ACP, True)
- context.set_data(bridge.CTX_CWD, resolved_cwd)
- context.set_data(bridge.CTX_WORKDIR, resolved_cwd)
- context.set_data(
- bridge.CTX_ADDITIONAL_DIRECTORIES,
- [normalize_cwd(path) for path in (additional_directories or []) if path],
- )
- context.set_data(bridge.CTX_MODE, context.get_data(bridge.CTX_MODE) or self._MODE_DEFAULT)
- if not context.name:
- context.name = self._title_for_cwd(resolved_cwd)
-
- def _register(self, context: AgentContext) -> None:
- if not self._conn:
- return
- bridge.register_bridge(
- context_id=context.id,
- session_id=context.id,
- conn=self._conn,
- loop=asyncio.get_running_loop(),
- )
-
- def _session_modes(self, context: AgentContext) -> SessionModeState:
- current = str(context.get_data(bridge.CTX_MODE) or self._MODE_DEFAULT)
- if current not in {self._MODE_DEFAULT, self._MODE_PLAN, self._MODE_ACT}:
- current = self._MODE_DEFAULT
- return SessionModeState(
- current_mode_id=current,
- available_modes=[
- SessionMode(
- id=self._MODE_DEFAULT,
- name="Default",
- description="Use the normal Agent Zero behavior.",
- ),
- SessionMode(
- id=self._MODE_PLAN,
- name="Plan",
- description="Prefer planning and analysis before changing files.",
- ),
- SessionMode(
- id=self._MODE_ACT,
- name="Act",
- description="Proceed end-to-end when the request is actionable.",
- ),
- ],
- )
-
- def _mode_instruction(self, context: AgentContext) -> str:
- return self._MODE_INSTRUCTIONS.get(str(context.get_data(bridge.CTX_MODE) or ""), "")
-
- async def _send_session_start_updates(self, context: AgentContext) -> None:
- await self._send_available_commands(context)
- await self._send_current_mode(context)
-
- async def _send_available_commands(self, context: AgentContext) -> None:
- if not self._conn:
- return
- try:
- await self._conn.session_update(
- context.id,
- AvailableCommandsUpdate(
- session_update="available_commands_update",
- available_commands=self._available_commands(),
- ),
- )
- except Exception:
- logger.debug("Could not advertise ACP commands", exc_info=True)
-
- async def _send_current_mode(self, context: AgentContext) -> None:
- if not self._conn:
- return
- try:
- update = CurrentModeUpdate(
- session_update="current_mode_update",
- current_mode_id=str(context.get_data(bridge.CTX_MODE) or self._MODE_DEFAULT),
- )
- await self._conn.session_update(context.id, update)
- except Exception:
- logger.debug("Could not send ACP current mode", exc_info=True)
-
- @classmethod
- def _available_commands(cls) -> list[AvailableCommand]:
- commands: list[AvailableCommand] = []
- for spec in cls._ADVERTISED_COMMANDS:
- input_hint = spec.get("input_hint")
- commands.append(
- AvailableCommand(
- name=spec["name"],
- description=spec["description"],
- input=UnstructuredCommandInput(hint=input_hint) if input_hint else None,
- )
- )
- return commands
-
- async def _replay_history(self, context: AgentContext) -> None:
- if not self._conn:
- return
- try:
- outputs = context.agent0.history.output()
- except Exception:
- logger.debug("Could not read Agent Zero history for ACP replay", exc_info=True)
- return
- for item in outputs:
- text = stringify_message_content(item.get("content")).strip()
- if not text:
- continue
- update = (
- acp.update_agent_message_text(text)
- if item.get("ai")
- else acp.update_user_message_text(text)
- )
- try:
- await self._conn.session_update(context.id, update)
- except Exception:
- logger.debug("Could not replay ACP history", exc_info=True)
- return
-
- async def _send_agent_message(self, session_id: str, text: str) -> None:
- if not self._conn or not text:
- return
- try:
- await self._conn.session_update(session_id, acp.update_agent_message_text(text))
- except Exception:
- logger.debug("Could not send ACP agent message", exc_info=True)
-
- async def _handle_slash_command(self, text: str, context: AgentContext) -> str | None:
- command, _, args = text.partition(" ")
- command = command.lstrip("/").lower().strip()
- args = args.strip()
- if command == "help":
- lines = ["Available commands:", ""]
- for spec in self._ADVERTISED_COMMANDS:
- lines.append(f"/{spec['name']}: {spec['description']}")
- return "\n".join(lines)
- if command == "context":
- return self._context_summary(context)
- if command == "reset":
- context.reset()
- self._apply_workspace(
- context,
- cwd=context.get_data(bridge.CTX_CWD) or context.get_data(bridge.CTX_WORKDIR),
- additional_directories=context.get_data(bridge.CTX_ADDITIONAL_DIRECTORIES) or [],
- )
- return "Conversation history cleared."
- if command == "version":
- return f"Agent Zero {git.get_version()}\nACP plugin {PLUGIN_VERSION}\nACP protocol {acp.PROTOCOL_VERSION}"
- return None
-
- def _context_summary(self, context: AgentContext) -> str:
- outputs = context.agent0.history.output()
- user_count = sum(1 for item in outputs if not item.get("ai"))
- assistant_count = sum(1 for item in outputs if item.get("ai"))
- history_tokens = context.agent0.history.get_tokens()
- window = context.agent0.get_data(Agent.DATA_NAME_CTX_WINDOW) or {}
- window_tokens = window.get("tokens", 0) if isinstance(window, dict) else 0
- cwd = context.get_data(bridge.CTX_CWD) or context.get_data(bridge.CTX_WORKDIR) or ""
- lines = [
- f"Session: {context.id}",
- f"Workspace: {cwd}",
- f"Messages: {user_count} user, {assistant_count} assistant",
- f"History tokens: ~{history_tokens:,}",
- ]
- if window_tokens:
- lines.append(f"Last context window: ~{int(window_tokens):,} tokens")
- mode = context.get_data(bridge.CTX_MODE) or self._MODE_DEFAULT
- lines.append(f"Mode: {mode}")
- return "\n".join(lines)
-
- def _usage(self, context: AgentContext, final_text: str) -> Usage | None:
- window = context.agent0.get_data(Agent.DATA_NAME_CTX_WINDOW) or {}
- input_tokens = int(window.get("tokens", 0) or 0) if isinstance(window, dict) else 0
- output_tokens = tokens.approximate_tokens(final_text or "")
- total = input_tokens + output_tokens
- if total <= 0:
- return None
- return Usage(
- input_tokens=max(input_tokens, 0),
- output_tokens=max(output_tokens, 0),
- total_tokens=max(total, 0),
- )
-
- def _session_info(self, context: AgentContext) -> SessionInfo:
- cwd = context.get_data(bridge.CTX_CWD) or context.get_data(bridge.CTX_WORKDIR) or "."
- updated_at = context.last_message or context.created_at or Localization.get().now()
- if hasattr(updated_at, "isoformat"):
- updated_at_str = updated_at.isoformat()
- else:
- updated_at_str = str(updated_at)
- return SessionInfo(
- session_id=context.id,
- cwd=normalize_cwd(cwd),
- title=context.name or self._title_for_cwd(cwd),
- updated_at=updated_at_str,
- additional_directories=context.get_data(bridge.CTX_ADDITIONAL_DIRECTORIES) or None,
- )
-
- @staticmethod
- def _title_for_cwd(cwd: str) -> str:
- name = Path(str(cwd or "")).name
- return f"ACP: {name or 'workspace'}"
diff --git a/plugins/_acp/hooks.py b/plugins/_acp/hooks.py
deleted file mode 100644
index 71bfa1d5f..000000000
--- a/plugins/_acp/hooks.py
+++ /dev/null
@@ -1,103 +0,0 @@
-from __future__ import annotations
-
-import importlib
-import importlib.util
-import re
-import shutil
-import subprocess
-import sys
-import threading
-from pathlib import Path
-
-from helpers.errors import format_error
-from helpers.print_style import PrintStyle
-
-
-PLUGIN_NAME = "_acp"
-IMPORT_NAME = "acp"
-DISTRIBUTION_NAME = "agent-client-protocol"
-FALLBACK_REQUIREMENT = "agent-client-protocol==0.10.1"
-
-_LOCK = threading.Lock()
-_CHECKED = False
-_PLUGIN_DIR = Path(__file__).resolve().parent
-_PROJECT_ROOT = _PLUGIN_DIR.parents[1]
-_ROOT_REQUIREMENTS_FILE = _PROJECT_ROOT / "requirements.txt"
-
-
-def has_acp() -> bool:
- return importlib.util.find_spec(IMPORT_NAME) is not None
-
-
-def get_acp_requirement() -> str:
- if not _ROOT_REQUIREMENTS_FILE.is_file():
- return FALLBACK_REQUIREMENT
-
- pattern = re.compile(rf"^\s*{re.escape(DISTRIBUTION_NAME)}\s*(?:[<>=!~]=?|===).*$")
- for raw_line in _ROOT_REQUIREMENTS_FILE.read_text(encoding="utf-8").splitlines():
- line = raw_line.split("#", 1)[0].strip()
- if line and pattern.match(line):
- return line
- return FALLBACK_REQUIREMENT
-
-
-def ensure_dependencies(raise_on_error: bool = True) -> bool:
- """Install the ACP SDK into the framework runtime when self-updates need it."""
- global _CHECKED
-
- if _CHECKED and has_acp():
- return True
-
- with _LOCK:
- if _CHECKED and has_acp():
- return True
- if has_acp():
- _CHECKED = True
- return True
-
- requirement = get_acp_requirement()
- try:
- _install_requirement(requirement)
- importlib.invalidate_caches()
- if not has_acp():
- raise RuntimeError(
- f"ACP dependency '{requirement}' is still unavailable after installation"
- )
- _CHECKED = True
- return True
- except Exception as exc:
- message = f"Agent Zero ACP: failed to install {requirement}: {format_error(exc)}"
- if raise_on_error:
- raise RuntimeError(message) from exc
- PrintStyle.error(message)
- return False
-
-
-def install() -> bool:
- return ensure_dependencies(raise_on_error=True)
-
-
-def _install_requirement(requirement: str) -> None:
- cmd = _install_command(requirement)
- PrintStyle.info(f"Agent Zero ACP: installing {requirement}")
- subprocess.check_call(cmd, cwd=str(_PROJECT_ROOT))
-
-
-def _install_command(requirement: str) -> list[str]:
- uv = shutil.which("uv")
- if uv:
- return [
- uv,
- "pip",
- "install",
- "--python",
- sys.executable,
- requirement,
- ]
- return [
- sys.executable,
- "-m",
- "pip",
- "install",
- requirement,
- ]
diff --git a/plugins/_acp/plugin.yaml b/plugins/_acp/plugin.yaml
deleted file mode 100644
index 0a46a2cea..000000000
--- a/plugins/_acp/plugin.yaml
+++ /dev/null
@@ -1,9 +0,0 @@
-name: _acp
-title: Agent Client Protocol
-description: Exposes Agent Zero as an ACP stdio agent for editor clients.
-version: "1.19"
-settings_sections:
- - external
-per_project_config: false
-per_agent_config: false
-always_enabled: true
diff --git a/plugins/_acp/webui/config.html b/plugins/_acp/webui/config.html
deleted file mode 100644
index 529b0c884..000000000
--- a/plugins/_acp/webui/config.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<div class="space-y-4">
- <div>
- <h3 class="text-lg font-semibold">Agent Client Protocol</h3>
- <p class="text-sm opacity-70">Expose Agent Zero to ACP-capable editors over stdio.</p>
- </div>
- <pre class="rounded bg-base-300 p-3 text-xs overflow-auto">python -m plugins._acp</pre>
- <pre class="rounded bg-base-300 p-3 text-xs overflow-auto">docker exec -i agent-zero /opt/venv-a0/bin/python -m plugins._acp</pre>
-</div>
diff --git a/plugins/_code_execution/tools/code_execution_tool.py b/plugins/_code_execution/tools/code_execution_tool.py
index f18d075fe..6e06dd461 100644
--- a/plugins/_code_execution/tools/code_execution_tool.py
+++ b/plugins/_code_execution/tools/code_execution_tool.py
@@ -480,10 +480,8 @@ class CodeExecution(Tool):
if project_name:
path = projects.get_project_folder(project_name)
else:
- path = self.agent.context.get_data("workdir_path")
- if not path:
- set = settings.get_settings()
- path = set.get("workdir_path")
+ set = settings.get_settings()
+ path = set.get("workdir_path")
if not path:
return None
diff --git a/requirements.txt b/requirements.txt
index 445bd2f1a..bbb94b2b8 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,5 @@
a2wsgi==1.10.8
ansio==0.0.1
-agent-client-protocol==0.10.1
docker==7.1.0
duckduckgo-search==6.1.12
pyreqwest-impersonate==0.5.3 # freeze nearest wheel-backed release; 0.5.5 is source-only
diff --git a/tests/test_acp_plugin_static.py b/tests/test_acp_plugin_static.py
deleted file mode 100644
index d24019051..000000000
--- a/tests/test_acp_plugin_static.py
+++ /dev/null
@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-import sys
-from types import SimpleNamespace
-
-ROOT = Path(__file__).resolve().parents[1]
-if str(ROOT) not in sys.path:
- sys.path.insert(0, str(ROOT))
-
-from plugins._acp.helpers.content import (
- normalize_cwd,
- path_from_file_uri,
- prompt_blocks_to_user_message,
-)
-from plugins._acp import hooks
-
-
-def test_acp_manifest_declares_builtin_plugin() -> None:
- manifest = (ROOT / "plugins" / "_acp" / "plugin.yaml").read_text(encoding="utf-8")
- assert "name: _acp" in manifest
- assert "always_enabled: true" in manifest
- assert 'version: "1.19"' in manifest
-
-
-def test_acp_registry_metadata_matches_release() -> None:
- registry = (ROOT / "plugins" / "_acp" / "acp_registry" / "agent.json").read_text(
- encoding="utf-8"
- )
- assert '"version": "1.19"' in registry
- assert '"license": "MIT"' in registry
-
-
-def test_acp_dependency_is_pinned() -> None:
- requirements = (ROOT / "requirements.txt").read_text(encoding="utf-8")
- assert "agent-client-protocol==0.10.1" in requirements
-
-
-def test_acp_hook_uses_root_requirement_pin() -> None:
- assert hooks.get_acp_requirement() == "agent-client-protocol==0.10.1"
- assert not (ROOT / "plugins" / "_acp" / "requirements.txt").exists()
-
-
-def test_acp_entrypoint_attempts_lazy_dependency_install() -> None:
- entry = (ROOT / "plugins" / "_acp" / "entry.py").read_text(encoding="utf-8")
- assert "_import_acp_or_install()" in entry
- assert "hooks.ensure_dependencies(raise_on_error=False)" in entry
-
-
-def test_acp_initialize_metadata_uses_release_version_constant() -> None:
- server = (ROOT / "plugins" / "_acp" / "helpers" / "server.py").read_text(
- encoding="utf-8"
- )
- assert "version=AGENT_ZERO_ACP_VERSION" in server
-
-
-def test_context_workdir_override_is_wired() -> None:
- code_execution = (
- ROOT / "plugins" / "_code_execution" / "tools" / "code_execution_tool.py"
- ).read_text(encoding="utf-8")
- workdir_prompt = (
- ROOT / "extensions" / "python" / "message_loop_prompts_after" / "_75_include_workdir_extras.py"
- ).read_text(encoding="utf-8")
- assert 'get_data("workdir_path")' in code_execution
- assert 'get_data("workdir_path")' in workdir_prompt
-
-
-def test_file_uri_path_translation() -> None:
- assert str(path_from_file_uri("file:///tmp/example.py")) == "/tmp/example.py"
- assert str(path_from_file_uri("file:///C:/Users/Ada/work/app.py")) == "/mnt/c/Users/Ada/work/app.py"
- assert path_from_file_uri("https://example.com/app.py") is None
-
-
-def test_prompt_blocks_inline_text_resource(tmp_path: Path) -> None:
- source = tmp_path / "notes.md"
- source.write_text("hello ACP", encoding="utf-8")
- block = SimpleNamespace(
- type="resource_link",
- uri=source.as_uri(),
- name="notes.md",
- mime_type="text/markdown",
- )
-
- parts = prompt_blocks_to_user_message(
- [SimpleNamespace(type="text", text="Read this"), block],
- context_id="static-test",
- message_id="msg",
- )
-
- assert "Read this" in parts.text
- assert "hello ACP" in parts.text
- assert parts.attachments == []
-
-
-def test_normalize_cwd_returns_absolute_path() -> None:
- assert Path(normalize_cwd(".")).is_absolute()