sycommon-python-lib 0.2.6a4__tar.gz → 0.2.6a5__tar.gz

{sycommon_python_lib-0.2.6a4 → sycommon_python_lib-0.2.6a5}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.6a4
+Version: 0.2.6a5
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika==9.6.2
-Requires-Dist: aiohttp==3.13.5
+Requires-Dist: aiohttp==3.14.1
 Requires-Dist: aiomysql==0.3.2
 Requires-Dist: anyio==4.13.0
 Requires-Dist: decorator==5.3.1
@@ -13,9 +13,9 @@ Requires-Dist: deepagents==0.6.8
 Requires-Dist: elasticsearch==9.4.1
 Requires-Dist: fastapi==0.136.3
 Requires-Dist: jinja2==3.1.6
-Requires-Dist: kafka-python==2.3.1
-Requires-Dist: langchain==1.3.4
-Requires-Dist: langchain-core==1.4.0
+Requires-Dist: kafka-python==2.3.2
+Requires-Dist: langchain==1.3.7
+Requires-Dist: langchain-core==1.4.6
 Requires-Dist: langchain-openai==1.2.2
 Requires-Dist: langfuse==4.7.1
 Requires-Dist: langgraph==1.2.4
@@ -29,20 +29,21 @@ Requires-Dist: psutil==7.2.2
 Requires-Dist: pyxxl==0.4.7
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: python-dotenv==1.2.2
-Requires-Dist: python-multipart==0.0.30
+Requires-Dist: python-multipart==0.0.32
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: redis==7.4.0
-Requires-Dist: sentry-sdk[fastapi]==2.61.1
+Requires-Dist: sentry-sdk[fastapi]==2.62.0
 Requires-Dist: sqlalchemy[asyncio]==2.0.50
-Requires-Dist: starlette[full]==1.2.1
+Requires-Dist: starlette[full]==1.3.0
 Requires-Dist: tiktoken==0.13.0
-Requires-Dist: uvicorn==0.48.0
+Requires-Dist: uvicorn==0.49.0
 Requires-Dist: wecom-aibot-python-sdk==1.0.2
 Requires-Dist: twine==6.2.0
 Requires-Dist: minio==7.2.20
 Requires-Dist: langchain-mcp-adapters==0.2.2
 Requires-Dist: fastapi-mcp==0.4.0
 Requires-Dist: psycopg[binary,pool]==3.3.4
+Requires-Dist: acp-sdk>=1.0.3
 
 # sycommon-python-lib
 

{sycommon_python_lib-0.2.6a4 → sycommon_python_lib-0.2.6a5}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.6a4"
+version = "0.2.6a5"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "aio-pika==9.6.2",
-    "aiohttp==3.13.5",
+    "aiohttp==3.14.1",
     "aiomysql==0.3.2",
     "anyio==4.13.0",
     "decorator==5.3.1",
@@ -14,9 +14,9 @@ dependencies = [
     "elasticsearch==9.4.1",
     "fastapi==0.136.3",
     "jinja2==3.1.6",
-    "kafka-python==2.3.1",
-    "langchain==1.3.4",
-    "langchain-core==1.4.0",
+    "kafka-python==2.3.2",
+    "langchain==1.3.7",
+    "langchain-core==1.4.6",
     "langchain-openai==1.2.2",
     "langfuse==4.7.1",
     "langgraph==1.2.4",
@@ -30,20 +30,21 @@ dependencies = [
     "pyxxl==0.4.7",
     "pydantic==2.13.4",
     "python-dotenv==1.2.2",
-    "python-multipart==0.0.30",
+    "python-multipart==0.0.32",
     "pyyaml==6.0.3",
     "redis==7.4.0",
-    "sentry-sdk[fastapi]==2.61.1",
+    "sentry-sdk[fastapi]==2.62.0",
     "sqlalchemy[asyncio]==2.0.50",
-    "starlette[full]==1.2.1",
+    "starlette[full]==1.3.0",
     "tiktoken==0.13.0",
-    "uvicorn==0.48.0",
+    "uvicorn==0.49.0",
     "wecom-aibot-python-sdk==1.0.2",
     "twine==6.2.0",
     "minio==7.2.20",
     "langchain-mcp-adapters==0.2.2",
     "fastapi-mcp==0.4.0",
     "psycopg[binary,pool]==3.3.4",
+    "acp-sdk>=1.0.3",
 ]
 
 [tool.setuptools]

sycommon_python_lib-0.2.6a5/src/sycli/acp/__init__.py

@@ -0,0 +1,48 @@
+"""ACP (Agent Communication Protocol) 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)
+
+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
+
+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
+
+__all__ = [
+    "ACPConfig",
+    "CLIToolAgent",
+    "ToolArgument",
+    "ToolDef",
+    "build_agents",
+    "build_cli_command",
+    "create_acp_server",
+    "execute_command",
+    "run_acp_server",
+    "stream_command",
+]

sycommon_python_lib-0.2.6a5/src/sycli/acp/config.py

@@ -0,0 +1,112 @@
+"""ACP configuration models.
+
+Defines the Pydantic models for declaring which CLI tools to expose
+as ACP agents. Configuration is loaded from a YAML or JSON file.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ToolArgument(BaseModel):
+    """Definition of a named argument that the CLI tool accepts."""
+
+    name: str = Field(description="Argument name (used for key=value parsing)")
+    description: str = Field(default="", description="Human-readable description")
+    required: bool = Field(default=False, description="Whether this argument is required")
+    default: str | None = Field(default=None, description="Default value if not provided")
+    flag: str | None = Field(
+        default=None,
+        description="CLI flag (e.g. '--path', '-v'); None means positional",
+    )
+    separator: str = Field(
+        default=" ",
+        description="Separator between flag and value: ' ' for '--flag value', '=' for '--flag=value'",
+    )
+
+
+class ToolDef(BaseModel):
+    """Definition of a single CLI tool to expose as an ACP agent."""
+
+    name: str = Field(description="ACP agent name")
+    command: str = Field(description="The actual CLI command to run")
+    description: str = Field(default="", description="Agent description for ACP discovery")
+    args: list[str] = Field(default_factory=list, description="Fixed arguments always appended")
+    tool_args: list[ToolArgument] = Field(
+        default_factory=list, description="Dynamic arguments mapped from ACP message input"
+    )
+    timeout: int = Field(default=120, description="Execution timeout in seconds")
+    working_dir: str | None = Field(default=None, description="Override working directory")
+    env: dict[str, str] = Field(default_factory=dict, description="Extra environment variables")
+    stream_output: bool = Field(default=True, description="Stream stdout line-by-line")
+    input_mode: str = Field(
+        default="args",
+        description="How to pass input: 'args' (parse into CLI args) | 'stdin' (pipe to stdin)",
+    )
+    output_content_type: str = Field(
+        default="text/plain", description="ACP content type for output"
+    )
+    allowed_exit_codes: list[int] = Field(
+        default_factory=lambda: [0], description="Exit codes considered success"
+    )
+
+
+class ACPConfig(BaseModel):
+    """Root ACP server configuration."""
+
+    host: str = Field(default="127.0.0.1", description="Server bind host")
+    port: int = Field(default=8100, description="Server bind port")
+    tools: list[ToolDef] = Field(default_factory=list, description="Registered CLI tools")
+    global_timeout: int = Field(default=300, description="Global maximum execution timeout")
+    max_output_bytes: int = Field(
+        default=100_000, description="Maximum output size in bytes (matches sandbox.py)"
+    )
+
+    @classmethod
+    def load(cls, path: Path) -> ACPConfig:
+        """Load ACP configuration from a YAML or JSON file.
+
+        Args:
+            path: Path to the configuration file.
+
+        Returns:
+            Parsed ACPConfig instance.
+
+        Raises:
+            FileNotFoundError: If the config file doesn't exist.
+            ValueError: If the file cannot be parsed.
+        """
+        if not path.exists():
+            raise FileNotFoundError(f"ACP config file not found: {path}")
+
+        text = path.read_text(encoding="utf-8")
+
+        if path.suffix in (".yaml", ".yml"):
+            try:
+                data = yaml.safe_load(text)
+            except yaml.YAMLError as e:
+                raise ValueError(f"Failed to parse YAML config: {e}") from e
+        elif path.suffix == ".json":
+            try:
+                data = json.loads(text)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Failed to parse JSON config: {e}") from e
+        else:
+            # Try YAML first, then JSON
+            try:
+                data = yaml.safe_load(text)
+            except yaml.YAMLError:
+                try:
+                    data = json.loads(text)
+                except json.JSONDecodeError as e:
+                    raise ValueError(f"Failed to parse config file: {e}") from e
+
+        if not isinstance(data, dict):
+            raise ValueError("Config file must contain a mapping (dict)")
+
+        return cls.model_validate(data)

sycommon_python_lib-0.2.6a5/src/sycli/acp/executor.py

@@ -0,0 +1,332 @@
+"""Async subprocess executor for ACP tool agents.
+
+Provides command execution with process isolation, timeout handling,
+output truncation, and line-by-line streaming — reusing patterns from
+sycommon's sandbox service.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import signal
+import sys
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from sycli.acp.config import ToolDef
+
+# Process group isolation on Unix
+_SUBPROCESS_NEW_SESSION = sys.platform != "win32"
+
+# Maximum output size per stream (matches sandbox.py)
+MAX_OUTPUT_BYTES = 100_000
+
+
+class ExecutionResult(BaseModel):
+    """Result of a CLI command execution."""
+
+    stdout: str = ""
+    stderr: str = ""
+    exit_code: int = 0
+    truncated: bool = False
+    timed_out: bool = False
+
+
+def _kill_process_tree(process: asyncio.subprocess.Process) -> None:
+    """Kill a process and its entire process group.
+
+    Mirrors sandbox.py's _kill_process_tree pattern.
+    """
+    try:
+        if sys.platform == "win32":
+            process.kill()
+        else:
+            pgid = os.getpgid(process.pid)
+            os.killpg(pgid, signal.SIGKILL)
+    except (ProcessLookupError, PermissionError, OSError):
+        try:
+            process.kill()
+        except ProcessLookupError:
+            pass
+
+
+def _truncate_output(output: str, max_bytes: int = MAX_OUTPUT_BYTES) -> tuple[str, bool]:
+    """Truncate output to max_bytes, returning (truncated_output, was_truncated)."""
+    encoded = output.encode("utf-8", errors="replace")
+    if len(encoded) <= max_bytes:
+        return output, False
+    truncated = encoded[:max_bytes].decode("utf-8", errors="replace")
+    return truncated + f"\n... (truncated, {len(encoded)} bytes total)", True
+
+
+async def execute_command(
+    command: str,
+    *,
+    cwd: str | None = None,
+    timeout: int = 120,
+    env: dict[str, str] | None = None,
+    max_output_bytes: int = MAX_OUTPUT_BYTES,
+    stdin_input: str | None = None,
+) -> ExecutionResult:
+    """Execute a CLI command asynchronously.
+
+    Mirrors sandbox.py execute endpoint logic:
+    - asyncio.create_subprocess_shell with process group isolation
+    - Timeout with process tree kill
+    - Output truncation at max_output_bytes
+
+    Args:
+        command: Shell command string to execute.
+        cwd: Working directory for the command.
+        timeout: Maximum execution time in seconds.
+        env: Additional environment variables (merged with os.environ).
+        max_output_bytes: Maximum output size before truncation.
+        stdin_input: Optional text to pipe to stdin.
+
+    Returns:
+        ExecutionResult with stdout, stderr, exit_code, and status flags.
+    """
+    full_env = None
+    if env:
+        full_env = {**os.environ, **env}
+
+    stdin_data = stdin_input.encode("utf-8") if stdin_input else None
+
+    process = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.PIPE if stdin_data else asyncio.subprocess.DEVNULL,
+        start_new_session=_SUBPROCESS_NEW_SESSION,
+        cwd=cwd,
+        env=full_env,
+    )
+
+    timed_out = False
+    try:
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(
+            process.communicate(input=stdin_data),
+            timeout=timeout,
+        )
+    except asyncio.TimeoutError:
+        _kill_process_tree(process)
+        try:
+            await process.wait()
+        except Exception:
+            pass
+        timed_out = True
+        stdout_bytes = b""
+        stderr_bytes = b""
+
+    stdout_raw = stdout_bytes.decode("utf-8", errors="replace") if stdout_bytes else ""
+    stderr_raw = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else ""
+
+    stdout, stdout_truncated = _truncate_output(stdout_raw, max_output_bytes)
+    stderr, stderr_truncated = _truncate_output(stderr_raw, max_output_bytes)
+
+    return ExecutionResult(
+        stdout=stdout,
+        stderr=stderr,
+        exit_code=process.returncode if process.returncode is not None else -1,
+        truncated=stdout_truncated or stderr_truncated,
+        timed_out=timed_out,
+    )
+
+
+async def stream_command(
+    command: str,
+    *,
+    cwd: str | None = None,
+    timeout: int = 120,
+    env: dict[str, str] | None = None,
+    max_output_bytes: int = MAX_OUTPUT_BYTES,
+) -> AsyncGenerator[str, None]:
+    """Execute a CLI command and yield stdout lines as they arrive.
+
+    For ACP stream mode: each yielded line becomes a MessagePart.
+    Uses asyncio.create_subprocess_shell with stdout=PIPE and
+    iterates process.stdout line by line.
+
+    Args:
+        command: Shell command string to execute.
+        cwd: Working directory for the command.
+        timeout: Maximum execution time in seconds.
+        env: Additional environment variables.
+        max_output_bytes: Maximum total output before stopping.
+
+    Yields:
+        Each line from stdout as a string.
+    """
+    full_env = None
+    if env:
+        full_env = {**os.environ, **env}
+
+    process = await asyncio.create_subprocess_shell(
+        command,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        start_new_session=_SUBPROCESS_NEW_SESSION,
+        cwd=cwd,
+        env=full_env,
+    )
+
+    total_bytes = 0
+    try:
+        try:
+            async with asyncio.timeout(timeout):
+                if process.stdout is not None:
+                    async for raw_line in process.stdout:
+                        line = raw_line.decode("utf-8", errors="replace")
+                        total_bytes += len(raw_line)
+                        if total_bytes > max_output_bytes:
+                            yield "... (output truncated)"
+                            break
+                        yield line
+        except asyncio.TimeoutError:
+            _kill_process_tree(process)
+            yield f"\n... (timed out after {timeout}s)"
+
+        # Wait for process to finish
+        try:
+            await asyncio.wait_for(process.wait(), timeout=5)
+        except asyncio.TimeoutError:
+            _kill_process_tree(process)
+    finally:
+        try:
+            if process.returncode is None:
+                _kill_process_tree(process)
+                try:
+                    await process.wait()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+
+def build_cli_command(tool_def: ToolDef, input_text: str) -> str:
+    """Build the full CLI command string from a ToolDef and user input.
+
+    Parses the input message text to extract tool_args values.
+
+    For input_mode="args":
+        Parses key=value pairs or positional args from message text.
+        Example: "target=tests/test_api.py verbose=true"
+        -> "pytest tests/test_api.py -v"
+
+    For input_mode="stdin":
+        Returns the command as-is (input will be piped to stdin).
+
+    Args:
+        tool_def: Tool configuration.
+        input_text: Raw text extracted from ACP input messages.
+
+    Returns:
+        Complete shell command string ready for execution.
+    """
+    parts = [tool_def.command]
+
+    # Add fixed arguments
+    if tool_def.args:
+        parts.extend(tool_def.args)
+
+    if tool_def.input_mode == "stdin":
+        # Input will be piped separately; no arg mapping needed
+        return " ".join(parts)
+
+    # Parse input text into key-value pairs
+    parsed_args = _parse_input_text(input_text)
+
+    # Map tool_args to CLI flags/positionals
+    for arg_def in tool_def.tool_args:
+        value = parsed_args.get(arg_def.name)
+
+        if value is None:
+            if arg_def.required and arg_def.default is None:
+                # Required arg missing — skip gracefully, let the CLI tool report the error
+                continue
+            if arg_def.default is not None:
+                value = arg_def.default
+            else:
+                continue
+
+        if arg_def.flag is not None:
+            if _is_truthy(value):
+                # Boolean flag present — only emit the flag itself (e.g. -v, --verbose)
+                parts.append(arg_def.flag)
+            else:
+                # Value flag (e.g. --path /some/dir, -e PATTERN)
+                parts.append(f"{arg_def.flag}{arg_def.separator}{value}")
+        else:
+            # Positional argument
+            parts.append(value)
+
+    # Any remaining unparsed input text becomes trailing positional args
+    remaining = _get_remaining_input(parsed_args, tool_def.tool_args)
+    if remaining:
+        parts.append(remaining)
+
+    return " ".join(parts)
+
+
+def _parse_input_text(text: str) -> dict[str, str]:
+    """Parse input text into key=value pairs.
+
+    Supports:
+    - "key=value" pairs (space or newline separated)
+    - Bare values are stored under the key "__positional__"
+
+    Args:
+        text: Raw input text from ACP message.
+
+    Returns:
+        Dict mapping argument names to values.
+    """
+    result: dict[str, str] = {}
+    positional: list[str] = []
+
+    # Split on whitespace (spaces, newlines, tabs)
+    tokens = text.strip().split()
+
+    for token in tokens:
+        if "=" in token:
+            key, _, val = token.partition("=")
+            key = key.strip()
+            val = val.strip()
+            if key:
+                result[key] = val
+        else:
+            positional.append(token)
+
+    if positional:
+        result["__positional__"] = " ".join(positional)
+
+    return result
+
+
+def _is_truthy(value: str) -> bool:
+    """Check if a string value represents a boolean 'true' (flag present, no value needed)."""
+    return value.lower() in ("true", "yes", "1", "")
+
+
+def _get_remaining_input(
+    parsed: dict[str, str], tool_args: list
+) -> str:
+    """Get remaining input that wasn't matched to any tool_arg definition."""
+    known_keys = {arg.name for arg in tool_args}
+    known_keys.add("__positional__")
+
+    remaining = []
+    for key, value in parsed.items():
+        if key not in known_keys:
+            remaining.append(f"{key}={value}" if "=" in f"{key}={value}" else value)
+
+    # Also include positional text
+    positional = parsed.get("__positional__")
+    if positional:
+        remaining.insert(0, positional)
+
+    return " ".join(remaining)