agno-cursor-agent 0.1.0__tar.gz

agno_cursor_agent-0.1.0/.gitignore

@@ -0,0 +1,17 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.coverage
+coverage.xml
+htmlcov/
+*.egg-info/
+dist/
+build/
+
+.env
+.env.local
+config.yaml
+*.db
+
+.DS_Store

agno_cursor_agent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vaiden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agno_cursor_agent-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.5
+Name: agno-cursor-agent
+Version: 0.1.0
+Summary: Agno Model adapter for persistent Cursor CLI ACP sessions
+Project-URL: Homepage, https://github.com/vaiden/agno-cursor-agent
+Project-URL: Repository, https://github.com/vaiden/agno-cursor-agent
+Author: vaiden
+License: MIT
+License-File: LICENSE
+Keywords: a2a,acp,agent,agno,cursor
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: agno[a2a]>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: fastapi>=0.100.0; extra == 'dev'
+Requires-Dist: httpx>=0.27.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: sqlalchemy>=2.0.0; extra == 'dev'
+Provides-Extra: standard
+Requires-Dist: uvicorn[standard]>=0.27.0; extra == 'standard'
+Description-Content-Type: text/markdown
+
+# agno-cursor-agent
+
+![CI](https://github.com/vaiden/agno-cursor-agent/actions/workflows/ci.yml/badge.svg)
+![codecov](https://codecov.io/gh/vaiden/agno-cursor-agent/graph/badge.svg)
+
+Agno `Model` adapter that talks to the **Cursor CLI** over a persistent **ACP** (JSON-RPC) session.  
+
+## Reasoning
+Cursor unlocks multiple exciting features: multiple model providers, cost router, agentic memory, code indexing, cloud agent provisioning and a powerful harness.
+Now available to power your Agno agents for the best aSDLC pipeline experience.
+
+## Quickstart
+
+Install from PyPI:
+
+```bash
+pip install agno-cursor-agent
+# AgentOS with WebSockets:
+pip install "agno-cursor-agent[standard]"
+```
+
+Import name on PyPI is **`agno-cursor-agent`**; in Python you still `import agno_cursor`.
+
+## Quick usage
+
+```python
+from agno.agent import Agent
+from agno_cursor import CursorACPChat, HarnessSettings
+
+settings = HarnessSettings(acp_trace=False)
+model = CursorACPChat(agent_key="coder", model="composer-2.5", mode="ask", settings=settings)
+
+agent = Agent(id="coder", model=model, instructions=["You write code."])
+# Requires cursor-agent login on the machine running this code.
+```
+
+Harness environment variables use the `AGNO_CURSOR_` prefix (for example `AGNO_CURSOR_ACP_TRACE=true`).
+
+## Demo team
+
+A full **Agno AgentOS + A2A** team lives under [`examples/demo_team`](examples/demo_team/README.md). It uses `CURSOR_TEAM_`* settings and role-based models (leader defaults to `auto`).
+
+```bash
+cd examples/demo_team
+pip install -e "../..[standard]"
+cursor-agent login
+python team_os.py
+```
+
+Connect the Agno UI to **http://localhost:7777** (not `0.0.0.0`).
+
+## Development
+
+- Unit tests mock ACP I/O; CI never calls `cursor-agent`.
+- Integration tests: `pytest -m integration` locally with login and optional `team_os` running.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).

agno_cursor_agent-0.1.0/README.md

@@ -0,0 +1,57 @@
+# agno-cursor-agent
+
+![CI](https://github.com/vaiden/agno-cursor-agent/actions/workflows/ci.yml/badge.svg)
+![codecov](https://codecov.io/gh/vaiden/agno-cursor-agent/graph/badge.svg)
+
+Agno `Model` adapter that talks to the **Cursor CLI** over a persistent **ACP** (JSON-RPC) session.  
+
+## Reasoning
+Cursor unlocks multiple exciting features: multiple model providers, cost router, agentic memory, code indexing, cloud agent provisioning and a powerful harness.
+Now available to power your Agno agents for the best aSDLC pipeline experience.
+
+## Quickstart
+
+Install from PyPI:
+
+```bash
+pip install agno-cursor-agent
+# AgentOS with WebSockets:
+pip install "agno-cursor-agent[standard]"
+```
+
+Import name on PyPI is **`agno-cursor-agent`**; in Python you still `import agno_cursor`.
+
+## Quick usage
+
+```python
+from agno.agent import Agent
+from agno_cursor import CursorACPChat, HarnessSettings
+
+settings = HarnessSettings(acp_trace=False)
+model = CursorACPChat(agent_key="coder", model="composer-2.5", mode="ask", settings=settings)
+
+agent = Agent(id="coder", model=model, instructions=["You write code."])
+# Requires cursor-agent login on the machine running this code.
+```
+
+Harness environment variables use the `AGNO_CURSOR_` prefix (for example `AGNO_CURSOR_ACP_TRACE=true`).
+
+## Demo team
+
+A full **Agno AgentOS + A2A** team lives under [`examples/demo_team`](examples/demo_team/README.md). It uses `CURSOR_TEAM_`* settings and role-based models (leader defaults to `auto`).
+
+```bash
+cd examples/demo_team
+pip install -e "../..[standard]"
+cursor-agent login
+python team_os.py
+```
+
+Connect the Agno UI to **http://localhost:7777** (not `0.0.0.0`).
+
+## Development
+
+- Unit tests mock ACP I/O; CI never calls `cursor-agent`.
+- Integration tests: `pytest -m integration` locally with login and optional `team_os` running.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).

agno_cursor_agent-0.1.0/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agno-cursor-agent"
+version = "0.1.0"
+description = "Agno Model adapter for persistent Cursor CLI ACP sessions"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "vaiden" }]
+keywords = ["agno", "cursor", "acp", "agent", "a2a"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "agno[a2a]>=2.0.0",
+    "pydantic-settings>=2.0.0",
+    "pyyaml>=6.0",
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+standard = ["uvicorn[standard]>=0.27.0"]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "pytest-cov>=4.0.0",
+    "pytest-mock>=3.0.0",
+    "httpx>=0.27.0",
+    "fastapi>=0.100.0",
+    "sqlalchemy>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/vaiden/agno-cursor-agent"
+Repository = "https://github.com/vaiden/agno-cursor-agent"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["agno_cursor"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src/agno_cursor" = "agno_cursor"
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/README.md", "/LICENSE"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests", "examples/demo_team/tests"]
+pythonpath = ["src", "examples/demo_team"]
+addopts = ["-m", "not integration", "--strict-markers"]
+asyncio_mode = "auto"
+markers = [
+    "integration: tests requiring cursor-agent login and live ACP/AgentOS (opt-in with -m integration)",
+]
+
+[tool.coverage.run]
+source = ["agno_cursor"]
+branch = true
+
+[tool.coverage.report]
+fail_under = 85
+show_missing = true

agno_cursor_agent-0.1.0/src/agno_cursor/__init__.py

@@ -0,0 +1,27 @@
+"""Agno + Cursor CLI ACP harness."""
+
+from agno_cursor.acp.registry import ACPSessionRegistry, REGISTRY
+from agno_cursor.acp.session import ACPSession
+from agno_cursor.model.cursor_acp import CursorACPChat
+from agno_cursor.settings import (
+    AcpMode,
+    HarnessSettings,
+    build_spawn_argv,
+    check_cursor_login,
+)
+from agno_cursor.trace import log_agent_block, log_agent_meta
+
+__all__ = [
+    "ACPSession",
+    "ACPSessionRegistry",
+    "AcpMode",
+    "CursorACPChat",
+    "HarnessSettings",
+    "REGISTRY",
+    "build_spawn_argv",
+    "check_cursor_login",
+    "log_agent_block",
+    "log_agent_meta",
+]
+
+__version__ = "0.1.0"

agno_cursor_agent-0.1.0/src/agno_cursor/acp/__init__.py

@@ -0,0 +1,4 @@
+from agno_cursor.acp.registry import ACPSessionRegistry, REGISTRY
+from agno_cursor.acp.session import ACPSession
+
+__all__ = ["ACPSession", "ACPSessionRegistry", "REGISTRY"]

agno_cursor_agent-0.1.0/src/agno_cursor/acp/registry.py

@@ -0,0 +1,53 @@
+"""Shared in-process ACP session registry."""
+
+from __future__ import annotations
+
+import threading
+from typing import Dict, List, Tuple
+
+from agno_cursor.acp.session import ACPSession, PopenFactory
+from agno_cursor.settings import ACPSettings, AcpMode
+
+
+class ACPSessionRegistry:
+    def __init__(self) -> None:
+        self._sessions: Dict[str, ACPSession] = {}
+        self._lock = threading.Lock()
+        self._popen_factory: PopenFactory | None = None
+
+    def set_popen_factory(self, factory: PopenFactory | None) -> None:
+        self._popen_factory = factory
+
+    def get_or_create(
+        self,
+        agent_key: str,
+        model: str,
+        mode: AcpMode,
+        settings: ACPSettings,
+    ) -> ACPSession:
+        with self._lock:
+            session = self._sessions.get(agent_key)
+            if session is None or session._closed:
+                session = ACPSession.from_settings(
+                    agent_key,
+                    model,
+                    mode,
+                    settings,
+                    popen_factory=self._popen_factory,
+                )
+                session.ensure_started()
+                self._sessions[agent_key] = session
+            return session
+
+    def warm(self, keys: List[Tuple[str, str, AcpMode]], settings: ACPSettings) -> None:
+        for agent_key, model, mode in keys:
+            self.get_or_create(agent_key, model, mode, settings)
+
+    def close_all(self) -> None:
+        with self._lock:
+            for session in self._sessions.values():
+                session.close()
+            self._sessions.clear()
+
+
+REGISTRY = ACPSessionRegistry()

agno_cursor_agent-0.1.0/src/agno_cursor/acp/session.py

@@ -0,0 +1,251 @@
+"""Persistent ACP session bridge to cursor-agent acp (JSON-RPC over stdio)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+
+from agno_cursor.settings import ACPSettings, AcpMode, resolve_acp_role
+from agno_cursor.trace import log_agent_block
+
+logger = logging.getLogger(__name__)
+
+_TRACE_PREVIEW = 1500
+
+PopenFactory = Callable[..., subprocess.Popen[str]]
+
+
+def _trace_preview(text: str, limit: int = _TRACE_PREVIEW) -> str:
+    if len(text) <= limit:
+        return text
+    return f"{text[:limit]}… ({len(text)} chars total)"
+
+
+@dataclass
+class ACPSession:
+    agent_key: str
+    model: str
+    mode: AcpMode
+    cwd: str
+    spawn_argv: List[str]
+    trace: bool = False
+    role: str = ""
+    popen_factory: PopenFactory = field(default=subprocess.Popen, repr=False)
+
+    _proc: Optional[subprocess.Popen[str]] = field(default=None, init=False, repr=False)
+    _session_id: Optional[str] = field(default=None, init=False, repr=False)
+    _req_id: int = field(default=0, init=False, repr=False)
+    _pending: Dict[int, Any] = field(default_factory=dict, init=False, repr=False)
+    _lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False)
+    _io_lock: threading.RLock = field(default_factory=threading.RLock, init=False, repr=False)
+    _reader_thread: Optional[threading.Thread] = field(default=None, init=False, repr=False)
+    _stderr_thread: Optional[threading.Thread] = field(default=None, init=False, repr=False)
+    _stderr_tail: List[str] = field(default_factory=list, init=False, repr=False)
+    _active_chunks: List[str] = field(default_factory=list, init=False, repr=False)
+    _initialized: bool = field(default=False, init=False, repr=False)
+    _closed: bool = field(default=False, init=False, repr=False)
+
+    @classmethod
+    def from_settings(
+        cls,
+        agent_key: str,
+        model: str,
+        mode: AcpMode,
+        settings: ACPSettings,
+        *,
+        popen_factory: PopenFactory | None = None,
+    ) -> "ACPSession":
+        return cls(
+            agent_key=agent_key,
+            model=model,
+            mode=mode,
+            cwd=str(settings.project_root),
+            spawn_argv=settings.spawn_argv(model, mode),
+            trace=settings.acp_trace,
+            role=resolve_acp_role(settings, agent_key),
+            popen_factory=popen_factory or subprocess.Popen,
+        )
+
+    @property
+    def argv(self) -> List[str]:
+        return list(self.spawn_argv)
+
+    def ensure_started(self) -> None:
+        with self._lock:
+            if self._closed:
+                raise RuntimeError(f"ACP session {self.agent_key} is closed")
+            if self._proc is None or self._proc.poll() is not None:
+                self._start_process()
+            if not self._initialized:
+                self._initialize_session()
+                self._initialized = True
+
+    def _start_process(self) -> None:
+        logger.info("Starting ACP process for %s: %s", self.agent_key, self.spawn_argv)
+        self._stderr_tail = []
+        self._proc = self.popen_factory(
+            self.spawn_argv,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            cwd=self.cwd,
+        )
+        self._pending.clear()
+        self._reader_thread = threading.Thread(
+            target=self._read_loop, daemon=True, name=f"acp-{self.agent_key}"
+        )
+        self._reader_thread.start()
+        self._stderr_thread = threading.Thread(
+            target=self._stderr_loop, daemon=True, name=f"acp-err-{self.agent_key}"
+        )
+        self._stderr_thread.start()
+
+    def _stderr_loop(self) -> None:
+        assert self._proc and self._proc.stderr
+        for line in self._proc.stderr:
+            line = line.rstrip("\n")
+            if not line:
+                continue
+            self._stderr_tail.append(line)
+            if len(self._stderr_tail) > 20:
+                self._stderr_tail.pop(0)
+
+    def _read_loop(self) -> None:
+        assert self._proc and self._proc.stdout
+        for line in self._proc.stdout:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                logger.debug("ACP non-JSON stdout: %s", line[:200])
+                continue
+            self._handle_message(msg)
+
+    def _handle_message(self, msg: Dict[str, Any]) -> None:
+        if "id" in msg and ("result" in msg or "error" in msg):
+            with self._io_lock:
+                self._pending[msg["id"]] = msg
+            return
+
+        method = msg.get("method")
+        if method == "session/update":
+            update = msg.get("params", {}).get("update", {})
+            if update.get("sessionUpdate") == "agent_message_chunk":
+                text = update.get("content", {}).get("text", "")
+                if text:
+                    self._active_chunks.append(text)
+            return
+
+        if method == "session/request_permission":
+            req_id = msg.get("id")
+            if req_id is not None:
+                self._send_raw(
+                    {
+                        "jsonrpc": "2.0",
+                        "id": req_id,
+                        "result": {"outcome": {"outcome": "selected", "optionId": "allow-once"}},
+                    }
+                )
+            return
+
+        logger.debug("ACP notification %s: %s", method, str(msg)[:200])
+
+    def _send_raw(self, payload: Dict[str, Any]) -> None:
+        assert self._proc and self._proc.stdin
+        with self._io_lock:
+            self._proc.stdin.write(json.dumps(payload) + "\n")
+            self._proc.stdin.flush()
+
+    def _call(self, method: str, params: Dict[str, Any], timeout: float = 120.0) -> Dict[str, Any]:
+        with self._io_lock:
+            self._req_id += 1
+            req_id = self._req_id
+            self._send_raw({"jsonrpc": "2.0", "id": req_id, "method": method, "params": params})
+
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            with self._io_lock:
+                if req_id in self._pending:
+                    msg = self._pending.pop(req_id)
+                    if "error" in msg:
+                        raise RuntimeError(f"ACP {method} error: {msg['error']}")
+                    return msg.get("result", {})
+            if self._proc and self._proc.poll() is not None:
+                exit_code = self._proc.poll()
+                tail = list(self._stderr_tail)
+                detail = tail[-1] if tail else f"exit code {exit_code}"
+                raise RuntimeError(f"ACP process died during {method}: {detail}")
+            time.sleep(0.02)
+        raise TimeoutError(f"ACP call timed out: {method}")
+
+    def _initialize_session(self) -> None:
+        self._call(
+            "initialize",
+            {
+                "protocolVersion": 1,
+                "clientCapabilities": {
+                    "fs": {"readTextFile": False, "writeTextFile": False},
+                    "terminal": False,
+                },
+                "clientInfo": {"name": "agno-cursor-acp", "version": "0.1.0"},
+            },
+        )
+        self._call("authenticate", {"methodId": "cursor_login"})
+        result = self._call("session/new", {"cwd": self.cwd, "mcpServers": []})
+        self._session_id = result["sessionId"]
+        logger.info("ACP session ready for %s: %s", self.agent_key, self._session_id)
+
+    def prompt(self, text: str, timeout: float = 180.0) -> str:
+        with self._lock:
+            self.ensure_started()
+            assert self._session_id
+            if self.trace:
+                log_agent_block(
+                    role=self.role,
+                    model=self.model,
+                    agent_key=self.agent_key,
+                    mode=self.mode,
+                    label=f"ACP → Cursor (session={self._session_id})",
+                    body=_trace_preview(text),
+                )
+            self._active_chunks = []
+            self._call(
+                "session/prompt",
+                {
+                    "sessionId": self._session_id,
+                    "prompt": [{"type": "text", "text": text}],
+                },
+                timeout=timeout,
+            )
+            reply = "".join(self._active_chunks).strip()
+            if self.trace:
+                log_agent_block(
+                    role=self.role,
+                    model=self.model,
+                    agent_key=self.agent_key,
+                    mode=self.mode,
+                    label="ACP ← Cursor",
+                    body=_trace_preview(reply) if reply else "(empty)",
+                )
+            return reply
+
+    def close(self) -> None:
+        with self._lock:
+            self._closed = True
+            if self._proc and self._proc.poll() is None:
+                try:
+                    self._proc.terminate()
+                    self._proc.wait(timeout=5)
+                except Exception:
+                    self._proc.kill()
+            self._proc = None
+            self._initialized = False

agno_cursor_agent-0.1.0/src/agno_cursor/model/__init__.py

@@ -0,0 +1,3 @@
+from agno_cursor.model.cursor_acp import CursorACPChat
+
+__all__ = ["CursorACPChat"]

agno_cursor_agent-0.1.0/src/agno_cursor/model/cursor_acp.py

@@ -0,0 +1,264 @@
+"""Custom Agno Model adapter: Agno model API <-> Cursor ACP."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.models.response import ModelResponse
+from agno.run.agent import RunOutput
+from agno.run.team import TeamRunOutput
+
+from agno_cursor.acp.registry import REGISTRY
+from agno_cursor.acp.session import ACPSession
+from agno_cursor.settings import AcpMode, HarnessSettings
+from agno_cursor.trace import log_agent_meta
+
+TOOL_CALL_INSTRUCTION = """
+When tools are available you MUST respond with ONLY valid JSON (no markdown fences):
+{{"tool_calls":[{{"name":"<tool_name>","arguments":{{...}}}}]}}
+If no tool is needed respond with ONLY:
+{{"content":"<your reply>"}}
+Available tools (name and parameters):
+{tools_json}
+"""
+
+
+@dataclass
+class CursorACPChat(Model):
+    id: str = "composer-2.5"
+    agent_key: str = ""
+    model: str = "composer-2.5"
+    mode: AcpMode = "ask"
+    settings: Any = field(default=None, repr=False)
+    provider: str = "cursor"
+    _first_turn: bool = field(default=True, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self.id = self.model
+        if not self.agent_key:
+            self.agent_key = self.model
+        if self.settings is None:
+            self.settings = HarnessSettings()
+
+    def _session(self) -> ACPSession:
+        return REGISTRY.get_or_create(self.agent_key, self.model, self.mode, self.settings)
+
+    def _tools_prompt_json(self, tools: Optional[List[Any]]) -> str:
+        if not tools:
+            return "[]"
+        simplified = []
+        for t in tools:
+            if hasattr(t, "to_dict") and callable(t.to_dict):
+                fn = t.to_dict()
+                if "name" in fn:
+                    simplified.append(
+                        {
+                            "name": fn.get("name"),
+                            "description": fn.get("description"),
+                            "parameters": fn.get("parameters"),
+                        }
+                    )
+                    continue
+            if isinstance(t, dict):
+                fn = t.get("function", t)
+                simplified.append(
+                    {
+                        "name": fn.get("name"),
+                        "description": fn.get("description"),
+                        "parameters": fn.get("parameters"),
+                    }
+                )
+        return json.dumps(simplified, indent=2)
+
+    def _build_prompt(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> str:
+        parts: List[str] = []
+        if self._first_turn:
+            system_msgs = [
+                m.get_content_string() for m in messages if m.role == "system" and m.get_content_string()
+            ]
+            if system_msgs:
+                parts.append("System instructions:\n" + "\n".join(system_msgs))
+
+        for m in reversed(messages):
+            if m.role == "user" and m.get_content_string():
+                parts.append(m.get_content_string())
+                break
+            if m.role == "tool" and m.get_content_string():
+                parts.append("Tool result:\n" + m.get_content_string())
+                break
+
+        if not parts:
+            parts.append(messages[-1].get_content_string() if messages else "")
+
+        prompt = parts[-1] if len(parts) == 1 and not self._first_turn else "\n\n".join(parts)
+
+        if tools:
+            prompt += "\n\n" + TOOL_CALL_INSTRUCTION.format(tools_json=self._tools_prompt_json(tools))
+
+        self._first_turn = False
+        return prompt
+
+    def _extract_json(self, text: str) -> Optional[Dict[str, Any]]:
+        text = text.strip()
+        if text.startswith("{") and text.endswith("}"):
+            try:
+                return json.loads(text)
+            except json.JSONDecodeError:
+                pass
+        match = re.search(r"\{[\s\S]*\}", text)
+        if match:
+            try:
+                return json.loads(match.group())
+            except json.JSONDecodeError:
+                return None
+        return None
+
+    def _parse_provider_response(self, response: Any, **kwargs) -> ModelResponse:
+        text = response if isinstance(response, str) else str(response)
+        parsed = self._extract_json(text)
+        model_response = ModelResponse(role="assistant")
+
+        if parsed and "tool_calls" in parsed:
+            tool_calls = []
+            for tc in parsed["tool_calls"]:
+                name = tc.get("name")
+                args = tc.get("arguments", {})
+                tool_calls.append(
+                    {
+                        "id": f"call_{uuid.uuid4().hex[:12]}",
+                        "type": "function",
+                        "function": {
+                            "name": name,
+                            "arguments": json.dumps(args) if isinstance(args, dict) else str(args),
+                        },
+                    }
+                )
+            model_response.tool_calls = tool_calls
+            return model_response
+
+        if parsed and "content" in parsed:
+            model_response.content = parsed["content"]
+            return model_response
+
+        model_response.content = text
+        return model_response
+
+    def _parse_provider_response_delta(self, response: Any) -> ModelResponse:
+        return self._parse_provider_response(response)
+
+    def invoke(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[Union[RunOutput, TeamRunOutput]] = None,
+        compress_tool_results: bool = False,
+    ) -> ModelResponse:
+        prompt = self._build_prompt(messages, tools=tools)
+        resolved = self.settings.resolve(self.agent_key, self.agent_key) if hasattr(self.settings, "resolve") else None
+        role = resolved.role if resolved else self.agent_key
+        mode = resolved.mode if resolved else self.mode
+
+        if getattr(self.settings, "acp_trace", False):
+            log_agent_meta(
+                role=role,
+                model=self.model,
+                agent_key=self.agent_key,
+                mode=mode,
+                label="Agno → ACP (invoke)",
+                detail=f"tools={'yes' if tools else 'no'}",
+            )
+        raw = self._session().prompt(prompt)
+        parsed = self._parse_provider_response(raw)
+        if getattr(self.settings, "acp_trace", False):
+            if parsed.tool_calls:
+                names = [tc.get("function", {}).get("name") for tc in parsed.tool_calls]
+                detail = f"tool_calls={names}"
+            else:
+                detail = f"content={(parsed.content or '')[:500]!r}"
+            log_agent_meta(
+                role=role,
+                model=self.model,
+                agent_key=self.agent_key,
+                mode=mode,
+                label="Agno ← ACP (parsed)",
+                detail=detail,
+            )
+        return parsed
+
+    async def ainvoke(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[Union[RunOutput, TeamRunOutput]] = None,
+        compress_tool_results: bool = False,
+    ) -> ModelResponse:
+        return await asyncio.to_thread(
+            self.invoke,
+            messages,
+            assistant_message,
+            response_format,
+            tools,
+            tool_choice,
+            run_response,
+            compress_tool_results,
+        )
+
+    def invoke_stream(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[Union[RunOutput, TeamRunOutput]] = None,
+        compress_tool_results: bool = False,
+    ) -> Iterator[ModelResponse]:
+        yield self.invoke(
+            messages,
+            assistant_message,
+            response_format,
+            tools,
+            tool_choice,
+            run_response,
+            compress_tool_results,
+        )
+
+    async def ainvoke_stream(
+        self,
+        messages: List[Message],
+        assistant_message: Message,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
+        run_response: Optional[Union[RunOutput, TeamRunOutput]] = None,
+        compress_tool_results: bool = False,
+    ) -> AsyncIterator[ModelResponse]:
+        result = await self.ainvoke(
+            messages,
+            assistant_message,
+            response_format,
+            tools,
+            tool_choice,
+            run_response,
+            compress_tool_results,
+        )
+        yield result

agno_cursor_agent-0.1.0/src/agno_cursor/settings.py

@@ -0,0 +1,67 @@
+"""Harness settings and Cursor CLI spawn helpers."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Literal, Protocol, runtime_checkable
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+AcpMode = Literal["ask", "plan", "agent"]
+
+
+def build_spawn_argv(base_spawn_cmd: str, model: str, mode: AcpMode) -> list[str]:
+    cmd = base_spawn_cmd.split()
+    argv = [*cmd, "--model", model]
+    if mode in ("ask", "plan"):
+        argv.extend(["--mode", mode])
+    elif mode == "agent":
+        argv.append("--force")
+    argv.append("acp")
+    return argv
+
+
+class HarnessSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="AGNO_CURSOR_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    base_spawn_cmd: str = "cursor-agent"
+    acp_trace: bool = False
+    project_root: Path = Field(default_factory=Path.cwd)
+
+    def spawn_argv(self, model: str, mode: AcpMode) -> list[str]:
+        return build_spawn_argv(self.base_spawn_cmd, model, mode)
+
+
+@runtime_checkable
+class ACPSettings(Protocol):
+    acp_trace: bool
+    project_root: Path
+
+    def spawn_argv(self, model: str, mode: AcpMode) -> list[str]: ...
+
+
+def resolve_acp_role(settings: ACPSettings, agent_key: str) -> str:
+    resolve = getattr(settings, "resolve", None)
+    if callable(resolve):
+        return resolve(agent_key, agent_key).role
+    return agent_key
+
+
+def check_cursor_login() -> None:
+    cli = shutil.which("cursor-agent") or shutil.which("agent")
+    if not cli:
+        raise RuntimeError("cursor-agent CLI not found on PATH")
+    result = subprocess.run([cli, "status"], capture_output=True, text=True, check=False)
+    if result.returncode != 0 or "Logged in" not in (result.stdout + result.stderr):
+        raise RuntimeError(
+            "Cursor CLI is not logged in. Run: cursor-agent login\n"
+            + (result.stdout or result.stderr)
+        )

agno_cursor_agent-0.1.0/src/agno_cursor/trace.py

@@ -0,0 +1,83 @@
+"""Colored, bounded log blocks for ACP trace (role/model header + <EOF AGENT>)."""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+
+logger = logging.getLogger(__name__)
+
+_TRACE_STYLE = "bold bright_cyan"
+_ANSI_BEGIN = "\033[96m\033[1m"
+_ANSI_END = "\033[0m"
+
+
+def _color_enabled() -> bool:
+    if os.environ.get("NO_COLOR"):
+        return False
+    force = (
+        os.environ.get("AGNO_CURSOR_ACP_TRACE_COLOR")
+        or os.environ.get("CURSOR_TEAM_ACP_TRACE_COLOR")
+        or ""
+    ).lower()
+    if force in ("0", "false", "no"):
+        return False
+    if force in ("1", "true", "yes"):
+        return True
+    return sys.stderr.isatty() or sys.stdout.isatty()
+
+
+def _agent_header(*, role: str, model: str, agent_key: str, mode: str, label: str) -> str:
+    return f"── {label} ──  role={role}  model={model}  agent_key={agent_key}  mode={mode}"
+
+
+def log_agent_block(
+    *,
+    role: str,
+    model: str,
+    agent_key: str,
+    mode: str,
+    label: str,
+    body: str,
+) -> None:
+    """Emit one readable trace block: agent line, body, then <EOF AGENT>."""
+    header = _agent_header(role=role, model=model, agent_key=agent_key, mode=mode, label=label)
+    eof = "<EOF AGENT>"
+    plain = f"{header}\n{body}\n{eof}"
+
+    if _color_enabled():
+        try:
+            from rich.console import Console
+
+            console = Console(stderr=True, highlight=False)
+            console.print(f"[{_TRACE_STYLE}]{header}[/]")
+            console.print(body)
+            console.print(f"[{_TRACE_STYLE}]{eof}[/]")
+            console.print()
+            return
+        except Exception:
+            pass
+        logger.info("%s%s%s", _ANSI_BEGIN, plain, _ANSI_END)
+        return
+
+    logger.info("\n%s", plain)
+
+
+def log_agent_meta(
+    *,
+    role: str,
+    model: str,
+    agent_key: str,
+    mode: str,
+    label: str,
+    detail: str,
+) -> None:
+    log_agent_block(
+        role=role,
+        model=model,
+        agent_key=agent_key,
+        mode=mode,
+        label=label,
+        body=detail,
+    )