synapse-cli-agent 0.1.35__tar.gz → 0.1.37__tar.gz

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/.github/workflows/native-compression-wheels.yml

@@ -67,3 +67,23 @@ jobs:
         with:
           files: dist/*.whl
           name: synapse-tool-compress-core ${{ github.ref_name }}
+
+  publish-pypi:
+    if: startsWith(github.ref, 'refs/tags/synapse-tool-compress-core-v')
+    needs: wheel
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/synapse-tool-compress-core
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheel-*
+          merge-multiple: true
+          path: dist
+      - name: Publish wheels to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/.github/workflows/release.yml

@@ -85,7 +85,7 @@ jobs:
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Install dependencies (builds local synapse-core-tool)
+      - name: Install dependencies (builds local synapse-core-tool and synapse-tool-compress-core)
         run: uv sync --frozen
 
       - name: Install PyInstaller
@@ -101,6 +101,7 @@ jobs:
             --collect-all textual_image `
             --collect-all termaid `
             --collect-all texicode `
+            --collect-all synapse_tool_compress_core `
             src/synapse/entry.py
 
       - name: Rename executable for artifact

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/AGENTS.md

@@ -23,7 +23,7 @@
 | `src/synapse/ui/` | Textual TUI, stream, timeline, dialogs, topbar/bottombar |
 | `tests/` | Python tests, usually mirroring domain modules |
 | `rust/synapse-core-tool/` | Native filesystem tools (read/edit/patch/search) and math rendering; published to PyPI as `synapse-core-tool` |
-| `rust/synapse-tool-compress-core/` | Optional native tool-output compression core |
+| `rust/synapse-tool-compress-core/` | Native tool-output compression core; required dependency, published to PyPI as `synapse-tool-compress-core` |
 | `docs/`, `mkdocs.yml` | User docs and MkDocs config |
 | `.github/workflows/` | CI, docs, Python release, native wheel builds |
 
@@ -83,10 +83,10 @@ uv build                        # after packaging/entry-point changes
 
 ## Rust/PyO3 native crates
 
-Two optional crates; the Python app must work without their wheels and must keep `ImportError`/`OSError` fallbacks.
+One optional crate; the Python app must work without its wheel and must keep `ImportError`/`OSError` fallbacks.
 
 - `rust/synapse-core-tool` (`synapse-core-tool` on PyPI): native filesystem tools (read/edit/patch/search) and math rendering. Release with tag `synapse-core-tool-v*`; `native-core-tool-wheels.yml` builds wheels and publishes to GitHub Release + PyPI. Keep the `pyproject.toml` version in sync with `Cargo.toml` — maturin names wheels from `pyproject.toml`.
-- `rust/synapse-tool-compress-core`: native tool-output compression core. Release with tag `synapse-tool-compress-core-v*`; `native-compression-wheels.yml` publishes wheels to GitHub Release.
+- `rust/synapse-tool-compress-core` (`synapse-tool-compress-core` on PyPI): native tool-output compression core. **Required dependency** of `synapse-cli-agent`. Release with tag `synapse-tool-compress-core-v*`; `native-compression-wheels.yml` builds wheels and publishes to GitHub Release + PyPI. Keep the `pyproject.toml` version in sync with `Cargo.toml`. Because the main package hard-depends on it, publish the compress-core wheels to PyPI before tagging the main `v*` release.
 
 When changing either crate, at least run:
 

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/CHANGELOG.md

@@ -8,6 +8,33 @@ All entries are written in English.
 
 ---
 
+## v0.1.37
+
+### Engineering
+
+- Made the native tool-output compression core (`synapse-tool-compress-core`) a required dependency of the main package: pip/uv installs now pull it by default and standalone PyInstaller executables bundle the native compression module.
+- Publish `synapse-tool-compress-core` wheels to PyPI in addition to GitHub Releases so the hard dependency resolves for package installs.
+- Updated the release workflow to collect the native compression extension into Windows/macOS/Linux executables.
+
+---
+
+## v0.1.36
+
+### New Features
+
+- Added turbo mode routing: OpenAI-compatible model traffic is relayed through the local headroom-turbo proxy via the `x-headroom-base-url` header, enabling compression for any selected profile without `models.json` changes.
+- Added a global turbo switch (`AGENT_TURBO`) that applies to the whole workspace, not just a single model profile.
+- Added a TURBO badge to the bottombar.
+- Added headroom-turbo sidecar management: pinned binary download, proxy lifecycle management with health check and fallback, and pinned sidecar v0.1.2 (runs standalone without `HEADROOM_TURBO`).
+- Added a zoomable image viewer with high-res mermaid re-rasterization.
+
+### Bug Fixes
+
+- Turbo mode now sends only the origin `x-headroom-base-url` header, preventing the proxy from rewriting the destination.
+- Hidden bottombar idle/busy key hints.
+
+---
+
 ## v0.1.35
 
 ### New Features

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: synapse-cli-agent
-Version: 0.1.35
+Version: 0.1.37
 Summary: Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)
 Project-URL: Homepage, https://github.com/alex8224/synapse-agent
 Project-URL: Repository, https://github.com/alex8224/synapse-agent
@@ -214,6 +214,7 @@ Requires-Dist: pydantic-settings==2.14.2
 Requires-Dist: python-dotenv==1.2.2
 Requires-Dist: rich==15.0.0
 Requires-Dist: synapse-core-tool<0.2.0,>=0.1.0
+Requires-Dist: synapse-tool-compress-core<0.2.0,>=0.1.2
 Requires-Dist: termaid==0.7.1
 Requires-Dist: texicode==1.0.3
 Requires-Dist: textual-diff-view==0.1.5

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synapse-cli-agent"
-version = "0.1.35"
+version = "0.1.37"
 description = "Local coding agent built on LangChain Deep Agents (LocalShell, no sandbox)"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -11,6 +11,7 @@ requires-python = ">=3.12"
 
 dependencies = [
     "synapse-core-tool>=0.1.0,<0.2.0",
+    "synapse-tool-compress-core>=0.1.2,<0.2.0",
     "aiosqlite==0.22.1",
     "deepagents==0.6.12",
     "httpx[socks]==0.28.1",
@@ -73,6 +74,7 @@ exclude = [
 
 [tool.uv.sources]
 synapse-core-tool = { path = "rust/synapse-core-tool" }
+synapse-tool-compress-core = { path = "rust/synapse-tool-compress-core" }
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

synapse_cli_agent-0.1.37/release_body.md

@@ -0,0 +1,9 @@
+## v0.1.37
+
+### Engineering
+
+- Made the native tool-output compression core (`synapse-tool-compress-core`) a required dependency of the main package: pip/uv installs now pull it by default and standalone PyInstaller executables bundle the native compression module.
+- Publish `synapse-tool-compress-core` wheels to PyPI in addition to GitHub Releases so the hard dependency resolves for package installs.
+- Updated the release workflow to collect the native compression extension into Windows/macOS/Linux executables.
+
+---

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/rust/synapse-tool-compress-core/Cargo.lock

@@ -507,7 +507,7 @@ dependencies = [
 
 [[package]]
 name = "synapse-tool-compress-core"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "aho-corasick",
  "dashmap",

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/rust/synapse-tool-compress-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "synapse-tool-compress-core"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 rust-version = "1.80"
 license = "Apache-2.0"

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/rust/synapse-tool-compress-core/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "synapse-tool-compress-core"
-version = "0.1.2"
+version = "0.1.3"
 description = "Deterministic native compression algorithms for Synapse tool output"
 requires-python = ">=3.12"
 license = { text = "Apache-2.0" }

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/app/agent.py

@@ -136,6 +136,8 @@ def _subagent_model_factory(registry: Any, settings: Settings) -> SubagentModelF
                 fallback_parallel_tool_calls=settings.parallel_tool_calls,
                 fallback_websocket=getattr(settings, "openai_websocket", False),
                 fallback_stream_chunk_timeout=getattr(settings, "stream_chunk_timeout", None),
+                fallback_turbo=bool(getattr(settings, "turbo", False)),
+                fallback_turbo_proxy_url=getattr(settings, "turbo_proxy_url", None),
                 enable_thinking=enabled,
                 reasoning_effort=effort,
             )
@@ -304,6 +306,17 @@ def build_coding_agent(
     model_cache_hit = False
     if model_cache is None:
         model_cache = {}
+    if getattr(settings, "turbo", False):
+        # Turbo mode routes through a local headroom-turbo sidecar; make sure
+        # the pinned binary is downloaded and the proxy is healthy before
+        # building clients. A failed proxy degrades to direct connections.
+        from synapse.integrations.turbo import ensure_turbo_binary, ensure_turbo_running
+
+        ensure_turbo_binary(progress=progress)
+        if not ensure_turbo_running(progress=progress):
+            logger.warning(
+                "headroom-turbo proxy unavailable; turbo mode disabled for this run"
+            )
     if model is None:
         cache_key = model_cache_key(settings, model_name=model_name)
         cached = model_cache.get(cache_key)
@@ -591,6 +604,10 @@ def build_coding_agent(
             goal_service=goal_service,
             steer_queue=steer_queue,
             prompt_cache_key=prompt_cache_key,
+            turbo=bool(
+                getattr(settings, "turbo", False)
+                or getattr(selected_profile, "turbo", False)
+            ),
         )
     )
 

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/app/agent_assembly.py

@@ -98,6 +98,10 @@ class MiddlewareContext:
     goal_service: Any | None
     steer_queue: SteerQueue
     prompt_cache_key: Any | None = None
+    # Turbo mode: model traffic is routed through a headroom-turbo proxy, so
+    # the built-in reversible tool-output compression is skipped (they are
+    # mutually exclusive).
+    turbo: bool = False
 
 
 def build_tool_output_pipeline(settings: Any) -> ToolOutputTransformPipeline:
@@ -142,6 +146,11 @@ def build_agent_middleware(context: MiddlewareContext) -> list[Any]:
         ),
     ]
     transform_enabled = bool(getattr(settings, "enable_tool_output_transform", True))
+    if context.turbo:
+        # Turbo routes tool outputs through the headroom proxy for compression;
+        # running the built-in transformer too would double-compress and break
+        # the proxy's content-type routing.
+        transform_enabled = False
     middleware.append(
         build_tool_output_transform_middleware(
             context.output_repository,

synapse_cli_agent-0.1.37/src/synapse/integrations/turbo.py

@@ -0,0 +1,222 @@
+"""headroom-turbo sidecar binary management.
+
+Turbo mode routes model traffic through a local ``headroom-turbo`` proxy
+binary. This module pins a compatible release version and downloads the
+platform asset from GitHub Releases on first use (or when the installed
+version drifts).
+
+Layout::
+
+    ~/.synapse/bin/
+      headroom-turbo(.exe)     # the sidecar binary
+      headroom-turbo.version   # installed turbo release version
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.request
+from collections.abc import Callable
+from pathlib import Path
+
+from synapse.settings.config_paths import user_config_dir
+
+# Pinned compatible turbo release. Bump together with the headroom-turbo fork
+# tag (turbo-v{version}) when the sidecar contract changes.
+# 0.1.1 bundles orjson (proxy dependency gate), excludes litellm, and builds
+# windowed (--noconsole) on Windows so no console window pops up.
+# 0.1.2 forces turbo mode in the binary entry, so the sidecar also starts
+# standalone without HEADROOM_TURBO=1 in the environment.
+TURBO_VERSION = "0.1.2"
+TURBO_RELEASE_REPO = "alex8224/headroom"
+DEFAULT_PORT = 8787
+
+_BIN_DIRNAME = "bin"
+_VERSION_FILENAME = "headroom-turbo.version"
+_RELEASE_BASE = f"https://github.com/{TURBO_RELEASE_REPO}/releases/download"
+
+# Runtime availability state, set by ensure_turbo_running(). Models only route
+# through the proxy when it is actually healthy; otherwise turbo degrades to a
+# direct connection for the current process.
+_proxy_ready = False
+
+
+def _asset_name() -> str | None:
+    """Return the release asset name for the current platform, or None."""
+    machine = platform.machine().lower()
+    if sys.platform.startswith("win") and machine in {"amd64", "x86_64"}:
+        return "headroom-turbo-windows-x86_64.exe"
+    if sys.platform.startswith("linux") and machine in {"amd64", "x86_64"}:
+        return "headroom-turbo-linux-x86_64"
+    if sys.platform == "darwin" and machine in {"arm64", "aarch64"}:
+        return "headroom-turbo-macos-arm64"
+    return None
+
+
+def turbo_bin_dir() -> Path:
+    """Directory holding the sidecar binary and its version marker."""
+    return user_config_dir() / _BIN_DIRNAME
+
+
+def turbo_binary_path() -> Path:
+    """Path to the sidecar binary for the current platform."""
+    asset = _asset_name() or "headroom-turbo"
+    if sys.platform.startswith("win") and not asset.endswith(".exe"):
+        asset += ".exe"
+    return turbo_bin_dir() / asset
+
+
+def turbo_version_path() -> Path:
+    """Path to the installed-version marker file."""
+    return turbo_bin_dir() / _VERSION_FILENAME
+
+
+def installed_turbo_version() -> str | None:
+    """Return the installed turbo version, or None when not installed."""
+    try:
+        value = turbo_version_path().read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    return value or None
+
+
+def ensure_turbo_binary(
+    progress: Callable[[str], None] | None = None,
+) -> Path:
+    """Ensure the pinned headroom-turbo binary is present and current.
+
+    Downloads from GitHub Releases when missing or when the installed version
+    does not match :data:`TURBO_VERSION`. Returns the binary path.
+    """
+    installed = installed_turbo_version()
+    if installed == TURBO_VERSION and turbo_binary_path().is_file():
+        return turbo_binary_path()
+
+    asset = _asset_name()
+    if asset is None:
+        raise RuntimeError(
+            "no headroom-turbo binary for "
+            f"{sys.platform}/{platform.machine()}; install it manually into "
+            f"{turbo_bin_dir()}"
+        )
+
+    url = f"{_RELEASE_BASE}/turbo-v{TURBO_VERSION}/{asset}"
+    dest = turbo_binary_path()
+    if progress is not None:
+        progress(f"downloading headroom-turbo v{TURBO_VERSION}")
+    _download(url, dest)
+    turbo_version_path().write_text(TURBO_VERSION, encoding="utf-8")
+    if progress is not None:
+        progress(f"headroom-turbo v{TURBO_VERSION} ready")
+    return dest
+
+
+def _download(url: str, dest: Path) -> None:
+    """Download ``url`` to ``dest`` atomically (temp file + rename)."""
+    turbo_bin_dir().mkdir(parents=True, exist_ok=True)
+    request = urllib.request.Request(url, headers={"User-Agent": "synapse-turbo"})
+    fd, tmp = tempfile.mkstemp(prefix=".turbo-", dir=turbo_bin_dir())
+    os.close(fd)
+    try:
+        with urllib.request.urlopen(request, timeout=600) as resp, open(
+            tmp, "wb"
+        ) as out:
+            shutil.copyfileobj(resp, out, length=1024 * 256)
+        os.replace(tmp, dest)
+        if not sys.platform.startswith("win"):
+            dest.chmod(0o755)
+    finally:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+
+
+def proxy_ready() -> bool:
+    """Return True once the local turbo proxy has passed a health check."""
+    return _proxy_ready
+
+
+def _health_ok(url: str) -> bool:
+    """True when the proxy /health endpoint reports healthy."""
+    try:
+        with urllib.request.urlopen(url, timeout=2) as resp:
+            if resp.status != 200:
+                return False
+            data = json.loads(resp.read().decode("utf-8"))
+            return str(data.get("status", "")).lower() == "healthy"
+    except Exception:  # noqa: BLE001 - any failure means not ready yet
+        return False
+
+
+def _start_proxy(port: int) -> None:
+    """Launch the sidecar proxy detached from the current process."""
+    binary = turbo_binary_path()
+    if not binary.is_file():
+        raise RuntimeError(f"headroom-turbo binary missing: {binary}")
+    cmd = [
+        str(binary),
+        "proxy",
+        "--port",
+        str(port),
+        "--disable-kompress",
+        "--host",
+        "127.0.0.1",
+    ]
+    # The turbo binary is built for headroom's deterministic turbo profile
+    # (no ML/MCP/watchdog extras bundled). HEADROOM_TURBO=1 makes its startup
+    # dependency gate treat optional modules as warn-only instead of hard
+    # failing when they are absent from the bundle.
+    env = dict(os.environ)
+    env["HEADROOM_TURBO"] = "1"
+    kwargs: dict[str, object] = {
+        "stdout": subprocess.DEVNULL,
+        "stderr": subprocess.DEVNULL,
+        "env": env,
+    }
+    if sys.platform.startswith("win"):
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW | subprocess.DETACHED_PROCESS
+    else:
+        kwargs["start_new_session"] = True
+    subprocess.Popen(cmd, **kwargs)  # noqa: S603 - fixed args, no shell
+
+
+def ensure_turbo_running(
+    progress: Callable[[str], None] | None = None,
+    *,
+    port: int = DEFAULT_PORT,
+    timeout: float = 30.0,
+) -> bool:
+    """Start the sidecar proxy (if needed) and wait until it is healthy.
+
+    Reuses an already-running healthy proxy on the same port. Returns True when
+    the proxy is ready; False means turbo mode should degrade to direct
+    connections for this process.
+    """
+    global _proxy_ready
+    url = f"http://127.0.0.1:{port}/health"
+    if _health_ok(url):
+        _proxy_ready = True
+        return True
+
+    if progress is not None:
+        progress("starting headroom-turbo proxy")
+    try:
+        _start_proxy(port)
+    except Exception:  # noqa: BLE001 - startup failure degrades, never blocks
+        return False
+
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if _health_ok(url):
+            _proxy_ready = True
+            return True
+        time.sleep(0.5)
+    return False

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/models/config.py

@@ -21,6 +21,8 @@ _PROFILE_META_KEYS = {
     "model_kwargs", "extra_body", "params",
     # Import metadata (Codex config): provider name and original wire API.
     "provider", "wire_api",
+    # Turbo mode: route through headroom-turbo proxy.
+    "turbo", "turbo_base_url",
 }
 
 def expand_env_string(value: Any) -> Any:

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/models/profile.py

@@ -50,6 +50,13 @@ class ModelProfile:
     # Whether the selected primary model accepts native image content.
     # None means infer from provider/model name.
     image_input: bool | None = None
+    # Turbo mode: route model traffic through a local headroom-turbo proxy.
+    # The profile's original base_url is forwarded via the x-headroom-base-url
+    # header so the proxy compresses and relays to the real upstream.
+    turbo: bool = False
+    # Optional override for the turbo proxy base URL. Defaults to
+    # SYNAPSE_TURBO_PROXY_URL, then http://localhost:8787/v1.
+    turbo_base_url: str | None = None
 
     def resolved_api_key(self) -> str | None:
         if self.api_key:

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/models/registry.py

@@ -30,10 +30,12 @@ from __future__ import annotations
 
 import hashlib
 import json
+import os
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
+from urllib.parse import urlparse
 
 from synapse.integrations.llm_openai_compat import (
     deepseek_thinking_kwargs,
@@ -107,6 +109,36 @@ def _resolve_init_chat_model() -> Callable[..., Any]:
     return __getattr__("init_chat_model")
 
 
+def _resolve_turbo_proxy_url(profile: ModelProfile, fallback: str | None = None) -> str:
+    """Resolve the headroom-turbo proxy base URL for a profile.
+
+    Priority: profile ``turbo_base_url`` → explicit fallback (Settings) →
+    ``SYNAPSE_TURBO_PROXY_URL`` env → the local default ``http://localhost:8787/v1``.
+    """
+    return (
+        profile.turbo_base_url
+        or fallback
+        or os.environ.get("SYNAPSE_TURBO_PROXY_URL")
+        or "http://localhost:8787/v1"
+    )
+
+
+def _turbo_upstream_origin(base_url: str) -> str:
+    """Reduce an upstream base URL to scheme://host[:port] for the proxy.
+
+    Headroom's OpenAI chat path appends ``/v1/chat/completions`` to the
+    ``x-headroom-base-url`` value itself, so forwarding the full base URL
+    (e.g. ``http://host/v1``) would produce a duplicated ``/v1/v1/...`` path.
+    Sending the bare origin keeps sub-path routing correct for standard
+    OpenAI-compatible endpoints.
+    """
+    parsed = urlparse(str(base_url).strip())
+    if not parsed.scheme or not parsed.hostname:
+        return str(base_url).rstrip("/")
+    port = f":{parsed.port}" if parsed.port else ""
+    return f"{parsed.scheme}://{parsed.hostname}{port}"
+
+
 @dataclass
 class ModelRegistry:
     """Alias catalog for chat models + shared thinking level catalog."""
@@ -168,6 +200,8 @@ class ModelRegistry:
         fallback_parallel_tool_calls: bool = True,
         fallback_websocket: bool = False,
         fallback_stream_chunk_timeout: float | None = None,
+        fallback_turbo: bool = False,
+        fallback_turbo_proxy_url: str | None = None,
         enable_thinking: bool | None = None,
         reasoning_effort: str | None = None,
         progress: Callable[[str], None] | None = None,
@@ -250,6 +284,22 @@ class ModelRegistry:
             with span("model:openai_compat_patch"):
                 enable_openai_compat_reasoning_patch()
                 enable_responses_reasoning_patch()
+            # Turbo mode: route through the headroom-turbo proxy and forward the
+            # original upstream via x-headroom-base-url so the proxy compresses
+            # and relays. Enabled globally (Settings.turbo) or per profile
+            # (profile.turbo), and only when the local sidecar is healthy.
+            # OAuth-backed Codex is excluded (its base_url is pinned to the
+            # first-party backend and must never be redirected).
+            turbo_enabled = bool(fallback_turbo or profile.turbo)
+            if turbo_enabled and base_url and oauth_provider is None:
+                from synapse.integrations.turbo import proxy_ready as _turbo_ready
+
+                if _turbo_ready():
+                    configured_headers = _merge_headers(
+                        configured_headers,
+                        {"x-headroom-base-url": _turbo_upstream_origin(base_url)},
+                    )
+                    base_url = _resolve_turbo_proxy_url(profile, fallback_turbo_proxy_url)
             if base_url:
                 kwargs["base_url"] = str(base_url).rstrip("/")
             if api_key:
@@ -545,6 +595,8 @@ def _profiles_from_mapping(data: dict[str, Any]) -> ModelRegistry:
             parallel_tool_calls=None if parallel is None else bool(parallel),
             websocket=websocket,
             image_input=image_input,
+            turbo=bool(cfg.get("turbo") or False),
+            turbo_base_url=cfg.get("turbo_base_url") or None,
             extra=expanded_params,
             model_kwargs=dict(model_kwargs),
             extra_body=dict(extra_body),
@@ -649,6 +701,8 @@ def merge_model_profiles(base: ModelProfile, override: ModelProfile) -> ModelPro
             if override.image_input is not None
             else base.image_input
         ),
+        turbo=(override.turbo or base.turbo),
+        turbo_base_url=(override.turbo_base_url or base.turbo_base_url),
         extra={**base.extra, **override.extra},
         model_kwargs={**base.model_kwargs, **override.model_kwargs},
         extra_body={**base.extra_body, **override.extra_body},
@@ -844,6 +898,9 @@ def model_cache_key(settings: Any, *, model_name: str | None = None) -> str:
         "provider": profile.provider,
         "wire_api": profile.wire_api,
         "base_url": profile.base_url or getattr(settings, "openai_base_url", None),
+        "turbo": bool(getattr(settings, "turbo", False)) or profile.turbo,
+        "turbo_base_url": profile.turbo_base_url
+        or getattr(settings, "turbo_proxy_url", None),
         "api_key_sha256": hashlib.sha256((api_key or "").encode()).hexdigest(),
         "enable_thinking": bool(getattr(settings, "enable_thinking", True)),
         "reasoning_effort": getattr(settings, "reasoning_effort", None),
@@ -884,6 +941,8 @@ def build_model_from_settings(
         fallback_stream_chunk_timeout=getattr(
             settings, "stream_chunk_timeout", None
         ),
+        fallback_turbo=bool(getattr(settings, "turbo", False)),
+        fallback_turbo_proxy_url=getattr(settings, "turbo_proxy_url", None),
         # Session Settings always win over profile defaults.
         enable_thinking=bool(settings.enable_thinking),
         reasoning_effort=settings.reasoning_effort,

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/settings/schema.py

@@ -143,6 +143,14 @@ class Settings(BaseSettings):
     models_json: str | None = Field(default=None, validation_alias="MODELS_JSON")
     # Selected profile alias (optional; falls back to model / registry default)
     active_model: str | None = Field(default=None, validation_alias="AGENT_ACTIVE_MODEL")
+    # Turbo mode: route all OpenAI-compatible model traffic through a local
+    # headroom-turbo proxy. The profile's original base_url is forwarded via the
+    # x-headroom-base-url header so the proxy compresses and relays. Requires no
+    # models.json change — any selected profile is affected.
+    turbo: bool = Field(default=False, validation_alias="AGENT_TURBO")
+    turbo_proxy_url: str = Field(
+        default="http://localhost:8787/v1", validation_alias="AGENT_TURBO_PROXY_URL"
+    )
     # Independent OpenAI-compatible image-to-text model configuration.
     # Example: {"model": "qwen-vl-max", "base_url": "...", "api_key_env": "VISION_API_KEY"}
     vision_model: dict[str, Any] | None = Field(default=None, validation_alias="VISION_MODEL")

{synapse_cli_agent-0.1.35 → synapse_cli_agent-0.1.37}/src/synapse/ui/bottombar/components/__init__.py

@@ -27,6 +27,7 @@ from synapse.ui.bottombar.components import (
     mcp,
     mode,
     model,
+    turbo,
     turn_stats,
 )
 from synapse.ui.bottombar.core import (
@@ -50,6 +51,7 @@ DEFAULT_COMPONENT_INSTALLERS: list[ComponentInstaller] = [
     turn_stats.install,
     model.install,
     fast.install,
+    turbo.install,
     codex_usage.install,
     mcp.install,
 ]
@@ -107,6 +109,7 @@ def install_default_components(
     codex_usage: Callable[[], str | object] | None = None,
     mcp: Callable[[], str] | None = None,
     fast_mode: Callable[[], bool] | None = None,
+    turbo: Callable[[], bool] | None = None,
     goal: Callable[[], str | object] | None = None,
     turn_stats: Callable[[], str | object] | None = None,
     installers: list[ComponentInstaller] | None = None,
@@ -143,6 +146,7 @@ def install_default_components(
             codex_usage=codex_usage or _empty,
             mcp=mcp or _empty,
             fast_mode=fast_mode or _off,
+            turbo=turbo or _off,
             goal=goal or _empty,
             turn_stats=turn_stats or _empty,
         )
@@ -157,6 +161,7 @@ def install_default_components(
             codex_usage=codex_usage or ctx.codex_usage,
             mcp=mcp or ctx.mcp,
             fast_mode=fast_mode or ctx.fast_mode,
+            turbo=turbo or ctx.turbo,
             goal=goal or ctx.goal,
             turn_stats=turn_stats or ctx.turn_stats,
         )