steerable-sidecar 0.6.0__tar.gz

steerable_sidecar-0.6.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: steerable-sidecar
+Version: 0.6.0
+Summary: Steerable agent runtime sidecar — JSON-RPC over stdio.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: httpx[socks]>=0.27
+Requires-Dist: steerable-agent-protocol<1.0.0,>=0.1.0
+Requires-Dist: steerable-agent-harness<1.0.0,>=0.1.0
+Requires-Dist: steerable-agent-runtime<1.0.0,>=0.1.0
+Requires-Dist: ag-ui-protocol>=0.1.21
+Requires-Dist: agent-client-protocol>=0.12.1
+
+# steerable-sidecar
+
+The portable Python entrypoint for the **steerable** framework. Designed to be
+spawned by an Electron / desktop host (or directly from a CLI) and addressed
+via stdio JSON-RPC 2.0.
+
+## Quick start
+
+```bash
+pip install steerable-sidecar
+python -m steerable_sidecar
+```
+
+Or use the console script:
+
+```bash
+steerable-sidecar
+```
+
+The process:
+
+1. Initializes the in-memory storage and a default tool router.
+2. Prints the **ready signal** on **stderr** as a single line:
+   `__SIDECAR_READY__:<json>` matching `spec/sidecar/SidecarHealth`.
+3. Begins reading JSON-RPC frames from stdin (one frame per line).
+4. Writes responses and notifications to stdout.
+
+See `spec/sidecar/README.md` for the full method/notification catalog.
+
+## Embedding
+
+```python
+import asyncio
+from steerable_sidecar import Sidecar
+
+async def main() -> None:
+    sidecar = Sidecar()
+    sidecar.tools.register(my_tool)
+    await sidecar.serve()
+
+asyncio.run(main())
+```

steerable_sidecar-0.6.0/README.md

@@ -0,0 +1,42 @@
+# steerable-sidecar
+
+The portable Python entrypoint for the **steerable** framework. Designed to be
+spawned by an Electron / desktop host (or directly from a CLI) and addressed
+via stdio JSON-RPC 2.0.
+
+## Quick start
+
+```bash
+pip install steerable-sidecar
+python -m steerable_sidecar
+```
+
+Or use the console script:
+
+```bash
+steerable-sidecar
+```
+
+The process:
+
+1. Initializes the in-memory storage and a default tool router.
+2. Prints the **ready signal** on **stderr** as a single line:
+   `__SIDECAR_READY__:<json>` matching `spec/sidecar/SidecarHealth`.
+3. Begins reading JSON-RPC frames from stdin (one frame per line).
+4. Writes responses and notifications to stdout.
+
+See `spec/sidecar/README.md` for the full method/notification catalog.
+
+## Embedding
+
+```python
+import asyncio
+from steerable_sidecar import Sidecar
+
+async def main() -> None:
+    sidecar = Sidecar()
+    sidecar.tools.register(my_tool)
+    await sidecar.serve()
+
+asyncio.run(main())
+```

steerable_sidecar-0.6.0/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "steerable-sidecar"
+version = "0.6.0"
+description = "Steerable agent runtime sidecar — JSON-RPC over stdio."
+readme = "README.md"
+requires-python = ">=3.10"
+# Pre-1.0 inter-package pins use `>=X,<1.0.0` ranges — flexible enough
+# that any 0.x lockstep version installs cleanly. `bump_to.sh` keeps
+# all 7 Steerable packages at the same X.Y.Z, enforced by the
+# release.yml lockstep gate. Tighten to `~=1.0` post-GA.
+# See packages/agent-harness/py/pyproject.toml for the rationale.
+dependencies = [
+  "pydantic>=2.10.0",
+  # httpx backs OpenAICompatProvider — the default provider family for
+  # agent.chat.stream (openai_compat / ollama). Not optional here: the
+  # sidecar exists to talk to LLM endpoints. (anthropic stays a lazy
+  # import, only loaded when provider=anthropic.)
+  # The `socks` extra covers hosts exporting `all_proxy=socks5://…`: httpx
+  # builds a transport per declared proxy at client construction, so the scheme
+  # must be buildable or every provider call fails before reaching a URL.
+  "httpx[socks]>=0.27",
+  "steerable-agent-protocol>=0.1.0,<1.0.0",
+  "steerable-agent-harness>=0.1.0,<1.0.0",
+  "steerable-agent-runtime>=0.1.0,<1.0.0",
+  "ag-ui-protocol>=0.1.21",
+  "agent-client-protocol>=0.12.1",
+]
+
+[project.scripts]
+steerable-sidecar = "steerable_sidecar.__main__:main"
+steerable-sidecar-acp = "steerable_sidecar.acp_adapter:main"
+steerable-sidecar-headless = "steerable_sidecar.headless:main"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+# tool_contract.json is loaded via __file__ by tool_contract.py; ship it so the
+# canonical tool contract resolves from an installed wheel, not only from source.
+[tool.setuptools.package-data]
+steerable_sidecar = ["*.json"]
+
+[tool.uv.sources]
+steerable-agent-protocol = { workspace = true }
+steerable-agent-harness = { workspace = true }
+steerable-agent-runtime = { workspace = true }
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

steerable_sidecar-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

steerable_sidecar-0.6.0/src/steerable_sidecar/__init__.py

@@ -0,0 +1,28 @@
+"""steerable-sidecar — portable runtime entrypoint."""
+
+from .landlock import LandlockExecBackend, landlock_available
+from .sandbox import (
+    BwrapExecBackend,
+    SeatbeltExecBackend,
+    build_seatbelt_profile,
+    bwrap_available,
+    seatbelt_argv,
+    seatbelt_available,
+    select_exec_backend,
+)
+from .sidecar import Sidecar, SidecarConfig
+
+__all__ = [
+    "BwrapExecBackend",
+    "LandlockExecBackend",
+    "SeatbeltExecBackend",
+    "Sidecar",
+    "SidecarConfig",
+    "build_seatbelt_profile",
+    "bwrap_available",
+    "landlock_available",
+    "seatbelt_argv",
+    "seatbelt_available",
+    "select_exec_backend",
+]
+__version__ = "0.1.0"

steerable_sidecar-0.6.0/src/steerable_sidecar/__main__.py

@@ -0,0 +1,84 @@
+"""``python -m steerable_sidecar`` entrypoint."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+
+from steerable_agent_runtime.errors import StoreAlreadyOwnedError
+
+from .sidecar import Sidecar, SidecarConfig
+from .web_tools import register_web_tools
+from .run_code import register_run_code, run_code_enabled
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="steerable-sidecar")
+    parser.add_argument(
+        "--log-level",
+        default="INFO",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        help="Sidecar log level (logged on stderr).",
+    )
+    parser.add_argument(
+        "--quiet-ready",
+        action="store_true",
+        help="Skip the __SIDECAR_READY__ stderr marker.",
+    )
+    parser.add_argument(
+        "--storage-path",
+        default=None,
+        metavar="PATH",
+        help="Persist sessions/traces/history to a sqlite database at PATH "
+        "(W2.6.1). Default: in-memory, per-process only.",
+    )
+    return parser
+
+
+def main() -> int:
+    parser = _build_parser()
+    args = parser.parse_args()
+    config = SidecarConfig(
+        log_level=args.log_level,
+        quiet_stderr=args.quiet_ready,
+        storage_path=args.storage_path,
+    )
+    try:
+        sidecar = Sidecar(config=config)
+    except StoreAlreadyOwnedError as exc:
+        logging.getLogger("steerable_sidecar").error("%s", exc)
+        return 1
+    # web_search / web_fetch on the RPC router: the desktop host delegates
+    # these calls here over forward `tool.invoke` (single implementation —
+    # the host carries schemas only). A malformed STEERABLE_WEB_* bound must
+    # not brick chat for an optional feature, so the misconfiguration logs
+    # loud and the sidecar serves without the web pair.
+    try:
+        register_web_tools(sidecar.tools)
+    except ValueError as exc:
+        logging.getLogger("steerable_sidecar").error(
+            "web tools disabled: %s", exc
+        )
+    if run_code_enabled():
+        register_run_code(sidecar.tools)
+    # Third-party tools: discover packages that registered the
+    # ``steerable.tools`` entry-point group and load their tools onto the
+    # router. A broken entry point fails the boot loud (PluginLoadError
+    # names the offender) rather than silently dropping an installed tool.
+    from steerable_agent_runtime import PluginLoadError, load_tool_entry_points
+
+    try:
+        load_tool_entry_points(sidecar.tools)
+    except PluginLoadError as exc:
+        logging.getLogger("steerable_sidecar").error("tool plugin: %s", exc)
+        return 1
+    try:
+        asyncio.run(sidecar.serve())
+    except KeyboardInterrupt:
+        logging.getLogger("steerable_sidecar").info("interrupted")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())