sycommon-python-lib 0.2.7a0__py3-none-any.whl → 0.2.7a1__py3-none-any.whl

sycli/acp/__init__.py

@@ -1,38 +1,16 @@
-"""ACP (Agent Communication Protocol) support for sycli.
+"""ACP (Agent Client Protocol — Zed) support for sycli.
 
-Dynamically exposes local CLI tools as ACP agents.
-"""
-
-# Patch uvicorn config type aliases for compatibility with uvicorn>=0.34
-# acp-sdk uses uvicorn.config.LoopSetupType etc. which were removed in uvicorn 0.48+
-import uvicorn.config as _uvicorn_config
-
-_TYPE_ALIASES = (
-    "LoopSetupType",
-    "HTTPProtocolType",
-    "WSProtocolType",
-    "LifespanType",
-    "InterfaceType",
-)
-for _alias in _TYPE_ALIASES:
-    if not hasattr(_uvicorn_config, _alias):
-        setattr(_uvicorn_config, _alias, str)
+把本地 CLI 工具暴露成 Zed ACP agent（stdio JSON-RPC），可被任何 ACP client
+（Zed、或我们 sycommon 的 ACP client）连接调用。
 
-if not hasattr(_uvicorn_config, "LOGGING_CONFIG"):
-    _uvicorn_config.LOGGING_CONFIG = {
-        "version": 1,
-        "disable_existing_loggers": False,
-        "formatters": {},
-        "handlers": {},
-        "loggers": {},
-    }
-
-del _uvicorn_config, _TYPE_ALIASES, _alias
+使用官方 `agent-client-protocol`（import 名 `acp`）的 stdio transport，
+照 examples/echo_agent.py 模板实现 Agent 协议。
+"""
 
 from sycli.acp.config import ACPConfig, ToolArgument, ToolDef
 from sycli.acp.executor import build_cli_command, execute_command, stream_command
 from sycli.acp.registry import CLIToolAgent, build_agents
-from sycli.acp.server import create_acp_server, run_acp_server
+from sycli.acp.server import run_acp_server
 
 __all__ = [
     "ACPConfig",
@@ -41,7 +19,6 @@ __all__ = [
     "ToolDef",
     "build_agents",
     "build_cli_command",
-    "create_acp_server",
     "execute_command",
     "run_acp_server",
     "stream_command",

sycli/acp/registry.py

@@ -1,20 +1,45 @@
-"""Dynamic ACP agent registry.
+"""Zed ACP agent registry.
 
-Creates CLIToolAgent (AgentManifest subclass) instances at runtime,
-one per ToolDef in the configuration. Each agent wraps a CLI tool
-and executes it via the executor module when a run is requested.
+把 .sycli/acp.yaml 里声明的 CLI 工具暴露成一个 Zed ACP Agent（stdio）。
+照官方 examples/echo_agent.py 模板实现 Agent 协议。
+
+设计：一个 agent 进程承载多个 CLI 工具。prompt 到来时：
+  1. 从输入文本解析 `tool=<name>`（或第一段当作工具名），定位 ToolDef
+  2. build_cli_command 拼命令 → stream_command/execute_command 执行
+  3. 通过 session_update 把输出（逐行流式或一次性）推给 client
+  4. 返回 PromptResponse(stop_reason="end_turn")
 """
 
 from __future__ import annotations
 
 import os
 from collections.abc import AsyncGenerator
-from typing import TYPE_CHECKING
-
-from acp_sdk.models import Message, MessagePart, Metadata
-from acp_sdk.server.agent import AgentManifest
-from acp_sdk.server.context import Context
-from acp_sdk.server.types import RunYield, RunYieldResume
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from acp import (
+    Agent,
+    InitializeResponse,
+    NewSessionResponse,
+    PromptResponse,
+    text_block,
+    update_agent_message,
+    update_plan,
+)
+from acp.interfaces import Client
+from acp.schema import (
+    AudioContentBlock,
+    ClientCapabilities,
+    EmbeddedResourceContentBlock,
+    HttpMcpServer,
+    ImageContentBlock,
+    Implementation,
+    McpServerStdio,
+    PlanEntry,
+    ResourceContentBlock,
+    SseMcpServer,
+    TextContentBlock,
+)
 
 from sycli.acp.executor import build_cli_command, execute_command, stream_command
 
@@ -22,134 +47,177 @@ if TYPE_CHECKING:
     from sycli.acp.config import ACPConfig, ToolDef
 
 
-class CLIToolAgent(AgentManifest):
-    """An AgentManifest that wraps a CLI tool.
+class CLIToolAgent(Agent):
+    """一个承载多个 CLI 工具的 Zed ACP agent。
 
-    Each instance is configured with a ToolDef. The run() method
-    is an async generator, enabling both streaming and batch modes
-    via the ACP SDK executor.
+    每次 prompt：解析工具名 → 执行对应 CLI → session_update 推输出。
     """
 
-    def __init__(self, tool_def: ToolDef, project_root: str) -> None:
-        self._tool_def = tool_def
-        self._project_root = project_root
-
-    @property
-    def name(self) -> str:
-        return self._tool_def.name
-
-    @property
-    def description(self) -> str:
-        return self._tool_def.description or f"CLI tool: {self._tool_def.command}"
+    _conn: Client | None = None
 
-    @property
-    def input_content_types(self) -> list[str]:
-        return ["text/plain"]
-
-    @property
-    def output_content_types(self) -> list[str]:
-        return [self._tool_def.output_content_type]
-
-    @property
-    def metadata(self) -> Metadata:
-        return Metadata(
-            tags=["cli-tool", self._tool_def.command],
+    def __init__(self, config: "ACPConfig", project_root: str) -> None:
+        self._config = config
+        self._project_root = project_root
+        # 工具名 → ToolDef 索引，便于路由
+        self._tools_by_name: dict[str, "ToolDef"] = {t.name: t for t in config.tools}
+
+    # ---- Agent 协议回调 ----
+    def on_connect(self, conn: Client) -> None:
+        self._conn = conn
+
+    async def initialize(
+        self,
+        protocol_version: int,
+        client_capabilities: ClientCapabilities | None = None,
+        client_info: Implementation | None = None,
+        **kwargs: Any,
+    ) -> InitializeResponse:
+        return InitializeResponse(protocol_version=protocol_version)
+
+    async def new_session(
+        self,
+        cwd: str,
+        additional_directories: list[str] | None = None,
+        mcp_servers: list[HttpMcpServer | SseMcpServer | McpServerStdio] | None = None,
+        **kwargs: Any,
+    ) -> NewSessionResponse:
+        return NewSessionResponse(session_id=uuid4().hex)
+
+    async def prompt(
+        self,
+        prompt: list[
+            TextContentBlock
+            | ImageContentBlock
+            | AudioContentBlock
+            | ResourceContentBlock
+            | EmbeddedResourceContentBlock
+        ],
+        session_id: str,
+        **kwargs: Any,
+    ) -> PromptResponse:
+        assert self._conn is not None, "Agent 未连接"
+
+        # 1. 提取输入文本
+        input_text = _extract_input_text_from_blocks(prompt)
+
+        # 2. 路由到具体 CLI 工具
+        tool_def, remaining_input = _resolve_tool(input_text, self._tools_by_name)
+
+        if tool_def is None:
+            # 找不到工具，列出可用工具
+            available = ", ".join(self._tools_by_name.keys()) or "(无)"
+            await self._conn.session_update(
+                session_id=session_id,
+                update=update_agent_message(text_block(
+                    f"❌ 未识别的 CLI 工具。可用工具: {available}\n"
+                    f"用法: 第一个词为工具名，或用 tool=<name> 指定。"
+                )),
+            )
+            return PromptResponse(stop_reason="end_turn")
+
+        # 3. 上报计划（让 client 看到要执行什么）
+        await self._conn.session_update(
+            session_id=session_id,
+            update=update_plan([PlanEntry(
+                content=f"执行 CLI 工具: {tool_def.name} ({tool_def.command})",
+                priority="medium",
+                status="in_progress",
+            )]),
         )
 
-    async def run(
-        self, input: list[Message], context: Context
-    ) -> AsyncGenerator[RunYield, RunYieldResume]:
-        """Execute the CLI tool and yield results.
-
-        Async generator enabling:
-        - Stream mode: yields MessagePart per stdout line
-        - Sync/async mode: yields complete Message at the end
-
-        Flow:
-            1. Extract text from input Messages (concatenate text/plain parts)
-            2. Build CLI command via build_cli_command()
-            3. If stream_output=True: stream_command(), yield MessagePart per line
-            4. Otherwise: execute_command(), yield single Message
-        """
-        # Step 1: Extract input text
-        input_text = _extract_input_text(input)
-
-        # Step 2: Build command
-        command = build_cli_command(self._tool_def, input_text)
-
-        # Step 3: Determine working directory
-        cwd = self._tool_def.working_dir or self._project_root
-
-        # Step 4: Build environment
-        env = None
-        if self._tool_def.env:
-            env = {**os.environ, **self._tool_def.env}
-
-        if self._tool_def.stream_output:
-            # Streaming: yield MessagePart per stdout line
+        # 4. 拼命令 + 执行环境
+        command = build_cli_command(tool_def, remaining_input)
+        cwd = tool_def.working_dir or self._project_root
+        env = {**os.environ, **tool_def.env} if tool_def.env else None
+
+        # 5. 执行并推送输出
+        if tool_def.stream_output:
             async for line in stream_command(
-                command,
-                cwd=cwd,
-                timeout=self._tool_def.timeout,
-                env=env,
+                command, cwd=cwd, timeout=tool_def.timeout, env=env,
             ):
-                yield MessagePart(
-                    content=line,
-                    content_type="text/plain",
+                await self._conn.session_update(
+                    session_id=session_id,
+                    update=update_agent_message(text_block(line)),
                 )
         else:
-            # Batch: execute and yield complete output
             result = await execute_command(
                 command,
                 cwd=cwd,
-                timeout=self._tool_def.timeout,
+                timeout=tool_def.timeout,
                 env=env,
-                max_output_bytes=100_000,
-                stdin_input=input_text if self._tool_def.input_mode == "stdin" else None,
+                max_output_bytes=self._config.max_output_bytes,
+                stdin_input=remaining_input if tool_def.input_mode == "stdin" else None,
             )
-
-            if result.timed_out:
-                output = f"Error: Command timed out after {self._tool_def.timeout}s\n{result.stdout}"
-            elif result.exit_code not in self._tool_def.allowed_exit_codes:
-                parts = []
-                if result.stdout:
-                    parts.append(result.stdout)
-                if result.stderr:
-                    parts.append(f"[stderr]\n{result.stderr}")
-                parts.append(f"Exit code: {result.exit_code}")
-                output = "\n".join(parts)
-            else:
-                output = result.stdout or "(no output)"
-
-            yield Message(
-                role="agent",
-                parts=[MessagePart(content=output, content_type="text/plain")],
+            output = _format_execution_result(result, tool_def)
+            await self._conn.session_update(
+                session_id=session_id,
+                update=update_agent_message(text_block(output)),
             )
 
+        return PromptResponse(stop_reason="end_turn")
+
 
-def _extract_input_text(messages: list[Message]) -> str:
-    """Extract and concatenate all text/plain content from input messages."""
+def _extract_input_text_from_blocks(prompt: list[Any]) -> str:
+    """从 prompt 内容块列表里拼接所有 text/plain 文本。"""
     parts: list[str] = []
-    for msg in messages:
-        for part in msg.parts:
-            content_type = getattr(part, "content_type", None) or "text/plain"
-            content = getattr(part, "content", None)
-            if content_type in ("text/plain", None) and content:
-                parts.append(content)
+    for block in prompt:
+        text = block.get("text", "") if isinstance(block, dict) else getattr(block, "text", "")
+        if text:
+            parts.append(text)
     return "\n".join(parts)
 
 
-def build_agents(config: ACPConfig, project_root: str) -> list[AgentManifest]:
-    """Create AgentManifest instances for all tools in config.
+def _resolve_tool(
+    input_text: str, tools_by_name: dict[str, "ToolDef"]
+) -> tuple["ToolDef | None", str]:
+    """从输入文本解析工具名，返回 (ToolDef, 剩余输入)。
+
+    支持两种写法：
+    - `tool=<name> <args...>`（显式指定）
+    - `<name> <args...>`（第一段当工具名）
+    """
+    stripped = input_text.strip()
+    if not stripped:
+        return None, ""
+
+    # tool=xxx 形式
+    if stripped.startswith("tool="):
+        head, _, rest = stripped.partition(" ")
+        name = head[len("tool="):].strip()
+        if name in tools_by_name:
+            return tools_by_name[name], rest.strip()
+        return None, stripped
+
+    # 第一段当工具名
+    first, _, rest = stripped.partition(" ")
+    if first in tools_by_name:
+        return tools_by_name[first], rest.strip()
+    return None, stripped
+
+
+def _format_execution_result(result: Any, tool_def: "ToolDef") -> str:
+    """把 executor.ExecutionResult 格式化成给 client 看的文本。"""
+    if result.timed_out:
+        return f"Error: Command timed out after {tool_def.timeout}s\n{result.stdout}"
+    if result.exit_code not in tool_def.allowed_exit_codes:
+        parts = []
+        if result.stdout:
+            parts.append(result.stdout)
+        if result.stderr:
+            parts.append(f"[stderr]\n{result.stderr}")
+        parts.append(f"Exit code: {result.exit_code}")
+        return "\n".join(parts)
+    return result.stdout or "(no output)"
+
+
+def build_agents(config: "ACPConfig", project_root: str) -> CLIToolAgent:
+    """创建承载所有 CLI 工具的 Zed ACP agent 实例。
 
     Args:
-        config: ACP configuration with tool definitions.
-        project_root: Project root directory for command execution.
+        config: ACP 配置（含 tools 列表）。
+        project_root: CLI 命令执行根目录。
 
     Returns:
-        List of CLIToolAgent instances ready for Server.register().
+        CLIToolAgent 实例，ready for acp.run_agent()。
     """
-    return [
-        CLIToolAgent(tool_def=tool_def, project_root=project_root)
-        for tool_def in config.tools
-    ]
+    return CLIToolAgent(config=config, project_root=project_root)

sycli/acp/server.py

@@ -1,69 +1,33 @@
-"""ACP server bootstrap for sycli.
+"""Zed ACP server bootstrap for sycli.
 
-Creates and starts an ACP server with all CLI tool agents registered.
-Uses the acp_sdk FastAPI app directly with uvicorn to avoid version
-compatibility issues between acp-sdk and uvicorn's positional parameters.
+启动一个 Zed ACP agent（stdio JSON-RPC），把 .sycli/acp.yaml 里声明的 CLI 工具
+作为该 agent 的能力暴露。照官方 examples/echo_agent.py 的 run_agent 模式。
+
+注意：Zed ACP 是 stdio 协议，不像旧 acp-sdk 走 HTTP/FastAPI/uvicorn。
+每个 CLI 工具不是独立的 agent，而是同一个 agent 用「会话内识别指令 → 路由到
+对应工具」的方式承载（一个 agent 进程，多工具）。
 """
 
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from acp_sdk.server.app import create_app
-import uvicorn
-
 from sycli.acp.registry import build_agents
 
 if TYPE_CHECKING:
-    from acp_sdk.server import Server
     from sycli.acp.config import ACPConfig
 
 
-def create_acp_app(config: ACPConfig, project_root: str):
-    """Create a FastAPI app with all registered tool agents.
-
-    Args:
-        config: ACP configuration (loaded from .sycli/acp.yaml).
-        project_root: Project root directory for command execution.
-
-    Returns:
-        FastAPI application instance with ACP routes.
-    """
-    agents = build_agents(config, project_root)
-    app = create_app(*agents)
-    return app
-
-
-def create_acp_server(config: ACPConfig, project_root: str) -> Server:
-    """Create and configure an ACP Server with all registered tool agents.
+def run_acp_server(config: ACPConfig, project_root: str) -> None:
+    """启动 Zed ACP agent（阻塞，直到 client 断开或收到关闭信号）。
 
     Args:
-        config: ACP configuration (loaded from .sycli/acp.yaml).
-        project_root: Project root directory for command execution.
-
-    Returns:
-        Configured Server instance (not yet started).
+        config: ACP 配置（来自 .sycli/acp.yaml），含 tools 列表。
+        project_root: CLI 命令执行的根目录。
     """
-    from acp_sdk.server import Server
-
-    server = Server()
-    agents = build_agents(config, project_root)
-    server.register(*agents)
-    return server
-
+    import asyncio
 
-def run_acp_server(config: ACPConfig, project_root: str) -> None:
-    """Create and start the ACP server (blocking until shutdown).
-
-    This is the main entry point called from acp_cmd.py.
-    Uses uvicorn directly to avoid acp-sdk / uvicorn version mismatches.
-    """
-    app = create_acp_app(config, project_root)
+    from acp import run_agent
 
-    uvicorn.run(
-        app,
-        host=config.host,
-        port=config.port,
-        log_level="info",
-        headers=[("server", "acp")],
-    )
+    agent = build_agents(config, project_root)
+    asyncio.run(run_agent(agent))

sycli/cli.py

@@ -169,10 +169,8 @@ def _create_parser() -> argparse.ArgumentParser:
     cdp_sub.add_parser("interactive", help="Start interactive CDP REPL")
 
     # ── acp ──
-    p_acp = sub.add_parser("acp", help="Start ACP server exposing CLI tools as agents")
+    p_acp = sub.add_parser("acp", help="Start Zed ACP agent exposing CLI tools over stdio")
     p_acp.add_argument("--config", "-c", help="Path to ACP config file (default: .sycli/acp.yaml)")
-    p_acp.add_argument("--host", help="Override server host")
-    p_acp.add_argument("--port", "-p", type=int, help="Override server port")
     p_acp.add_argument("--project-root", "-r", default=".", help="Project root directory")
 
     # ── version ──

sycli/commands/acp_cmd.py

@@ -1,7 +1,8 @@
-"""sycli acp command — start ACP server exposing CLI tools as agents."""
+"""sycli acp command — start a Zed ACP agent exposing CLI tools over stdio."""
 
 from __future__ import annotations
 
+import asyncio
 import signal
 import sys
 from pathlib import Path
@@ -17,10 +18,10 @@ def handle_acp(args) -> int:
         2. Load .sycli/acp.yaml (or --config path)
         3. Validate tool definitions
         4. Print registered agents summary
-        5. Start ACP server (blocking)
+        5. Start Zed ACP agent over stdio (blocking)
 
     Args:
-        args: Parsed argparse namespace with config, host, port, project_root.
+        args: Parsed argparse namespace with config, project_root.
 
     Returns:
         Exit code (0 for success, 1 for error).
@@ -28,22 +29,23 @@ def handle_acp(args) -> int:
     project_root = Path(args.project_root or ".").resolve()
     sycli_dir = project_root / ".sycli"
 
-    if not sycli_dir.exists():
-        error(".sycli/ not found. Run `sycli init` first.")
-        return 1
-
     # Determine config path
-    config_path = Path(args.config) if args.config else sycli_dir / "acp.yaml"
-    if not config_path.exists():
-        config_path = sycli_dir / "acp.json"
+    # 显式 --config 优先（允许指向任意位置，不强制 .sycli/）；
+    # 否则回退到 <project_root>/.sycli/acp.{yaml,json}
+    if args.config:
+        config_path = Path(args.config)
+    else:
+        config_path = sycli_dir / "acp.yaml"
+        if not config_path.exists():
+            config_path = sycli_dir / "acp.json"
 
     if not config_path.exists():
-        error(f"ACP config not found at {sycli_dir / 'acp.yaml'}")
+        if not args.config and not sycli_dir.exists():
+            error(".sycli/ not found. Run `sycli init` first, or 用 --config 指定外部配置。")
+        error(f"ACP config not found at {config_path}")
         error("Create one with your tool definitions. Example:")
         error("""
-  # .sycli/acp.yaml
-  host: "127.0.0.1"
-  port: 8100
+  # acp.yaml
   tools:
     - name: "git-status"
       command: "git"
@@ -62,33 +64,28 @@ def handle_acp(args) -> int:
         error(f"Failed to load ACP config: {e}")
         return 1
 
-    # Override port/host from CLI args
-    if args.host:
-        config.host = args.host
-    if args.port:
-        config.port = args.port
-
     if not config.tools:
         error("No tools defined in ACP config. Add tools to acp.yaml.")
         return 1
 
-    # Print summary
-    header("ACP Server Configuration")
-    info(f"Config:  {config_path}")
-    info(f"Host:    {config.host}")
-    info(f"Port:    {config.port}")
-    info(f"Agents:  {len(config.tools)} registered")
+    # Print summary to stderr（stdout 留给 stdio JSON-RPC）
+    header("Zed ACP Agent Configuration")
+    info(f"Config:   {config_path}")
+    info(f"Transport: stdio (JSON-RPC)")
+    info(f"Agents:   {len(config.tools)} CLI tools exposed")
     print()
     for tool in config.tools:
         desc = tool.description or "(no description)"
         info(f"  {tool.name}: {tool.command} {' '.join(tool.args) if tool.args else ''}")
         info(f"    {desc}")
     print()
+    print("-" * 60, file=sys.stderr)
+    info("Agent ready — waiting for ACP client on stdin/stdout...")
+    print("-" * 60, file=sys.stderr)
 
-    # Start server
+    # Start agent (stdio, blocking)
     from sycli.acp.server import run_acp_server
 
-    # Graceful shutdown on SIGINT
     _shutdown = False
 
     def _signal_handler(sig, frame):
@@ -96,18 +93,17 @@ def handle_acp(args) -> int:
         if _shutdown:
             sys.exit(1)
         _shutdown = True
-        warning("\nShutting down ACP server...")
+        warning("\nShutting down ACP agent...")
 
     signal.signal(signal.SIGINT, _signal_handler)
 
     try:
-        success(f"Starting ACP server on http://{config.host}:{config.port}")
         run_acp_server(config, str(project_root))
     except KeyboardInterrupt:
-        warning("ACP server stopped.")
+        warning("ACP agent stopped.")
         return 0
     except Exception as e:
-        error(f"ACP server failed: {e}")
+        error(f"ACP agent failed: {e}")
         import traceback
 
         traceback.print_exc()