solstone-linux 0.1.1__tar.gz → 0.2.0__tar.gz

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to solstone-linux are documented here.
 The format is based on Keep a Changelog (https://keepachangelog.com/),
 and this project adheres to Semantic Versioning.
 
+## [0.2.0] - 2026-06-13
+
+setup is now hands-off: the first time the observer runs, it connects itself
+to your journal automatically, with no separate key step.
+
+### Changed
+
+- **first run sets itself up.** earlier versions asked you to create and paste
+  a key to connect the observer to your journal. now the observer introduces
+  itself to your journal on first run and remembers the connection on its own.
+  you go straight from install to observing, with no manual key step.
+
 ## [0.1.1] - 2026-06-02
 
 A focused maintenance release: two reliability fixes and a round of

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/INSTALL.md

@@ -79,7 +79,7 @@ this is the developer/from-source path; most installs should use the `pipx insta
    ```
    solstone-linux setup
    ```
-   this prompts for the journal URL and auto-registers via `sol` when available.
+   this prompts for the journal URL and registers the observer with your journal.
 
 4. verify the service is running:
    ```

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solstone-linux
-Version: 0.1.1
+Version: 0.2.0
 Summary: Standalone Linux desktop observer for solstone
 License-Expression: AGPL-3.0-only
 License-File: LICENSE

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "solstone-linux"
-version = "0.1.1"
+version = "0.2.0"
 description = "Standalone Linux desktop observer for solstone"
 readme = "README.md"
 license = "AGPL-3.0-only"

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/src/solstone_linux/__init__.py

@@ -3,4 +3,4 @@
 
 """Standalone Linux desktop observer for solstone."""
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/src/solstone_linux/activity.py

@@ -24,6 +24,7 @@ from dbus_next.errors import (
 logger = logging.getLogger(__name__)
 
 _DBUS_PROBE_TIMEOUT_SEC = 2.0
+_POWER_SAVE_WARNED_BACKENDS: set[str] = set()
 
 _SERVICE_MISSING_ERRORS = (
     "org.freedesktop.DBus.Error.ServiceUnknown",
@@ -212,6 +213,22 @@ async def is_power_save_active(bus: MessageBus) -> bool:
 
     Returns True if power save is active, False otherwise.
     """
+
+    def log_backend_failure_once(backend: str, bus_name: str, path: str, exc) -> None:
+        level = logger.warning
+        if backend in _POWER_SAVE_WARNED_BACKENDS:
+            level = logger.debug
+        else:
+            _POWER_SAVE_WARNED_BACKENDS.add(backend)
+        level(
+            "is_power_save_active %s backend failed: service=%s path=%s: %s: %s",
+            backend,
+            bus_name,
+            path,
+            type(exc).__name__,
+            exc,
+        )
+
     # Try GNOME Mutter DisplayConfig first
     try:
         intro = await bus.introspect(DISPLAY_CONFIG_BUS, DISPLAY_CONFIG_PATH)
@@ -227,11 +244,10 @@ async def is_power_save_active(bus: MessageBus) -> bool:
         OSError,
     ) as exc:
         if not _is_service_missing(exc):
-            logger.warning(
-                "is_power_save_active Mutter backend failed: service=%s path=%s: %s: %s",
+            log_backend_failure_once(
+                "Mutter",
                 DISPLAY_CONFIG_BUS,
                 DISPLAY_CONFIG_PATH,
-                type(exc).__name__,
                 exc,
             )
 
@@ -248,13 +264,7 @@ async def is_power_save_active(bus: MessageBus) -> bool:
         OSError,
     ) as exc:
         if not _is_service_missing(exc):
-            logger.warning(
-                "is_power_save_active KDE backend failed: service=%s path=%s: %s: %s",
-                KDE_POWER_BUS,
-                KDE_POWER_PATH,
-                type(exc).__name__,
-                exc,
-            )
+            log_backend_failure_once("KDE", KDE_POWER_BUS, KDE_POWER_PATH, exc)
         return False
 
 

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/src/solstone_linux/cli.py

@@ -134,44 +134,23 @@ def cmd_setup(args: argparse.Namespace) -> int:
         )
         return 0
 
-    print(f"Stream: {config.stream}")
     save_config(config)
 
     if not config.key:
-        sol = shutil.which("sol")
-        if sol:
-            print("Registering via sol CLI...")
-            try:
-                result = subprocess.run(
-                    [sol, "observer", "--json", "create", config.stream],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode == 0:
-                    data = json.loads(result.stdout)
-                    config.key = data["key"]
-                    save_config(config)
-                    print(f"Registered (key: {config.key[:8]}...)")
-                else:
-                    print("CLI registration failed, trying HTTP...")
-            except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError, OSError):
-                print("CLI registration failed, trying HTTP...")
-
-        if not config.key:
-            print("Registering with your journal...")
-            client = UploadClient(config)
-            if client.ensure_registered(config):
-                config = load_config()
-                print(f"Registered (key: {config.key[:8]}...)")
-            else:
-                print(
-                    "Warning: registration failed. Run setup again when your journal is available."
-                )
-                if non_interactive:
-                    return 1
+        print("Registering with your journal...")
+        client = UploadClient(config)
+        if client.ensure_registered(config):
+            print(f"Registered (key: {config.key[:8]}...)")
+            print(f"Stream: {config.stream}")
+        else:
+            print(
+                "Warning: registration failed. Run setup again when your journal is available."
+            )
+            if non_interactive:
+                return 1
     else:
         print(f"Already registered (key: {config.key[:8]}...)")
+        print(f"Stream: {config.stream}")
 
     print(f"\nConfig saved to {config.config_path}")
     print(f"Captures will go to {config.captures_dir}")
@@ -203,46 +182,24 @@ def _cmd_setup_interactive() -> int:
         except ValueError as e:
             print(f"Error deriving stream name: {e}", file=sys.stderr)
             return 1
-    print(f"Stream: {config.stream}")
 
     # Save config before registration (so URL is persisted)
     config.ensure_dirs()
     save_config(config)
 
-    # Auto-register — try sol CLI first (no server needed), fall back to HTTP
     if not config.key:
-        sol = shutil.which("sol")
-        if sol:
-            print("Registering via sol CLI...")
-            try:
-                result = subprocess.run(
-                    [sol, "observer", "--json", "create", config.stream],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode == 0:
-                    data = json.loads(result.stdout)
-                    config.key = data["key"]
-                    save_config(config)
-                    print(f"Registered (key: {config.key[:8]}...)")
-                else:
-                    print("CLI registration failed, trying HTTP...")
-            except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError, OSError):
-                print("CLI registration failed, trying HTTP...")
-
-        if not config.key:
-            print("Registering with your journal...")
-            client = UploadClient(config)
-            if client.ensure_registered(config):
-                config = load_config()
-                print(f"Registered (key: {config.key[:8]}...)")
-            else:
-                print(
-                    "Warning: registration failed. Run setup again when your journal is available."
-                )
+        print("Registering with your journal...")
+        client = UploadClient(config)
+        if client.ensure_registered(config):
+            print(f"Registered (key: {config.key[:8]}...)")
+            print(f"Stream: {config.stream}")
+        else:
+            print(
+                "Warning: registration failed. Run setup again when your journal is available."
+            )
     else:
         print(f"Already registered (key: {config.key[:8]}...)")
+        print(f"Stream: {config.stream}")
 
     print(f"\nConfig saved to {config.config_path}")
     print(f"Captures will go to {config.captures_dir}")

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/src/solstone_linux/observer.py

@@ -162,6 +162,7 @@ class Observer:
         self._client = UploadClient(self.config)
         if self.config.server_url:
             self._client.ensure_registered(self.config)
+        self.stream = self.config.stream
         self._sync = SyncService(self.config, self._client)
 
         from .dbus_service import BUS_NAME, OBJECT_PATH, ObserverService
@@ -407,7 +408,6 @@ class Observer:
             duration_seconds=duration_seconds,
             host=HOST,
             platform=PLATFORM,
-            stream=self.stream,
         )
 
     def emit_status(self):
@@ -458,7 +458,6 @@ class Observer:
             activity=activity_info,
             host=HOST,
             platform=PLATFORM,
-            stream=self.stream,
         )
 
     def _refresh_tray(self):

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/src/solstone_linux/sync.py

@@ -25,7 +25,6 @@ import shutil
 import time
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any
 
 from .config import Config
 from .upload import ErrorType, UploadClient
@@ -473,10 +472,8 @@ class SyncService:
         if not files:
             return True  # Nothing to upload
 
-        meta: dict[str, Any] = {"stream": self._config.stream}
-
         result = await asyncio.to_thread(
-            self._client.upload_segment, day, segment_key, files, meta
+            self._client.upload_segment, day, segment_key, files
         )
 
         if result.success:

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/src/solstone_linux/upload.py

@@ -13,10 +13,9 @@ Refinements over tmux baseline:
 
 from __future__ import annotations
 
-import json
 import logging
-import shutil
-import subprocess
+import platform
+import socket
 import time
 from enum import Enum
 from pathlib import Path
@@ -24,6 +23,7 @@ from typing import Any, NamedTuple
 
 import requests
 
+from . import __version__
 from .config import Config
 
 logger = logging.getLogger(__name__)
@@ -32,6 +32,10 @@ UPLOAD_TIMEOUT = 300
 EVENT_TIMEOUT = 30
 
 
+def _auth_headers(key: str) -> dict[str, str]:
+    return {"Authorization": f"Bearer {key}"}
+
+
 class ErrorType(Enum):
     """Classification of upload errors for circuit breaker tuning."""
 
@@ -63,65 +67,47 @@ class UploadClient:
     def is_revoked(self) -> bool:
         return self._revoked
 
-    def _persist_key(self, config: Config, key: str) -> None:
-        """Save auto-registered key back to config."""
+    def _persist_registration(self, config: Config, key: str, stream: str) -> None:
+        """Persist the server-issued handle and locked stream back to config."""
         from .config import save_config
 
         config.key = key
+        config.stream = stream
         save_config(config)
 
     def ensure_registered(self, config: Config) -> bool:
-        """Ensure the client has a valid key, auto-registering if needed.
+        """Register this observer over HTTP, persisting the handle + locked stream.
 
-        Tries sol CLI first (no server needed), falls back to HTTP.
-        Returns True if a key is available.
+        Short-circuits if a key is already present. Returns True if a key is available.
         """
         if self._key:
             return True
-
-        # Try sol CLI registration first
-        name = self._stream or "solstone-linux"
-        sol = shutil.which("sol")
-        if sol:
-            try:
-                result = subprocess.run(
-                    [sol, "observer", "--json", "create", name],
-                    capture_output=True,
-                    text=True,
-                    timeout=10,
-                )
-                if result.returncode == 0:
-                    data = json.loads(result.stdout)
-                    self._key = data["key"]
-                    self._persist_key(config, self._key)
-                    logger.info(f"CLI-registered as '{name}' (key: {self._key[:8]}...)")
-                    return True
-            except (
-                subprocess.TimeoutExpired,
-                json.JSONDecodeError,
-                KeyError,
-                OSError,
-            ) as e:
-                logger.debug(f"CLI registration failed: {e}")
-
         if not self._url:
             return False
 
-        url = f"{self._url}/app/observer/api/create"
+        descriptor: dict[str, Any] = {
+            "platform": platform.system().lower(),
+            "hostname": socket.gethostname(),
+            "stream_type": "desktop",
+            "version": __version__,
+        }
+        if self._stream:
+            descriptor["label"] = self._stream
+
+        url = f"{self._url}/app/observer/register"
 
         retries = min(3, len(self._retry_backoff))
         for attempt in range(retries):
             delay = self._retry_backoff[min(attempt, len(self._retry_backoff) - 1)]
             try:
-                resp = self._session.post(
-                    url, json={"name": name}, timeout=EVENT_TIMEOUT
-                )
+                resp = self._session.post(url, json=descriptor, timeout=EVENT_TIMEOUT)
                 if resp.status_code == 200:
                     data = resp.json()
                     self._key = data["key"]
-                    self._persist_key(config, self._key)
+                    self._stream = data["name"]
+                    self._persist_registration(config, data["key"], data["name"])
                     logger.info(
-                        f"Auto-registered as '{name}' (key: {self._key[:8]}...)"
+                        f"Registered as '{data['name']}' (key: {self._key[:8]}...)"
                     )
                     return True
                 elif resp.status_code == 403:
@@ -161,7 +147,6 @@ class UploadClient:
         day: str,
         segment: str,
         files: list[Path],
-        meta: dict[str, Any] | None = None,
     ) -> UploadResult:
         """Upload a segment's files to the ingest server."""
         if self._revoked or not self._key or not self._url:
@@ -169,7 +154,7 @@ class UploadClient:
                 False, error_type=ErrorType.AUTH if self._revoked else None
             )
 
-        url = f"{self._url}/app/observer/ingest/{self._key}"
+        url = f"{self._url}/app/observer/ingest"
 
         for attempt in range(self._max_retries):
             file_handles = []
@@ -189,12 +174,14 @@ class UploadClient:
                 if not files_data:
                     return UploadResult(False)
 
-                data: dict[str, Any] = {"day": day, "segment": segment}
-                if meta:
-                    data["meta"] = json.dumps(meta)
+                data = {"day": day, "segment": segment}
 
                 response = self._session.post(
-                    url, data=data, files=files_data, timeout=UPLOAD_TIMEOUT
+                    url,
+                    data=data,
+                    files=files_data,
+                    headers=_auth_headers(self._key),
+                    timeout=UPLOAD_TIMEOUT,
                 )
 
                 if response.status_code == 200:
@@ -249,13 +236,12 @@ class UploadClient:
         if self._revoked or not self._key or not self._url:
             return None
 
-        url = f"{self._url}/app/observer/ingest/{self._key}/segments/{day}"
-        params = {}
-        if self._stream:
-            params["stream"] = self._stream
+        url = f"{self._url}/app/observer/ingest/segments/{day}"
 
         try:
-            resp = self._session.get(url, params=params, timeout=EVENT_TIMEOUT)
+            resp = self._session.get(
+                url, headers=_auth_headers(self._key), timeout=EVENT_TIMEOUT
+            )
             if resp.status_code == 200:
                 return resp.json()
             if resp.status_code in (401, 403):
@@ -274,10 +260,15 @@ class UploadClient:
         if self._revoked or not self._key or not self._url:
             return False
 
-        url = f"{self._url}/app/observer/ingest/{self._key}/event"
+        url = f"{self._url}/app/observer/ingest/event"
         payload = {"tract": tract, "event": event, **fields}
         try:
-            resp = self._session.post(url, json=payload, timeout=EVENT_TIMEOUT)
+            resp = self._session.post(
+                url,
+                json=payload,
+                headers=_auth_headers(self._key),
+                timeout=EVENT_TIMEOUT,
+            )
             if resp.status_code == 200:
                 return True
             if resp.status_code == 403:

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/tests/test_activity.py

@@ -269,6 +269,10 @@ class TestIsScreenLocked:
 class TestIsPowerSaveActive:
     """Test power save fallback order."""
 
+    @pytest.fixture(autouse=True)
+    def _clear_warning_cache(self):
+        activity._POWER_SAVE_WARNED_BACKENDS.clear()
+
     @pytest.mark.asyncio
     async def test_gnome_backend_nonzero_mode_returns_true(self):
         bus = MagicMock()
@@ -421,6 +425,37 @@ class TestIsPowerSaveActive:
             "path=/org/kde/Solid/PowerManagement: DBusError: broke",
         ]
 
+    @pytest.mark.asyncio
+    async def test_is_power_save_active_repeated_backend_failures_log_debug_after_first(
+        self, caplog
+    ):
+        bus = MagicMock()
+        bus.introspect = AsyncMock(side_effect=[_no_reply("broke")] * 4)
+
+        with caplog.at_level(logging.DEBUG):
+            assert await activity.is_power_save_active(bus) is False
+            assert await activity.is_power_save_active(bus) is False
+
+        warnings = [
+            record.message
+            for record in caplog.records
+            if record.levelno == logging.WARNING
+        ]
+        debug = [
+            record.message
+            for record in caplog.records
+            if record.levelno == logging.DEBUG
+        ]
+        assert warnings == [
+            "is_power_save_active Mutter backend failed: "
+            "service=org.gnome.Mutter.DisplayConfig "
+            "path=/org/gnome/Mutter/DisplayConfig: DBusError: broke",
+            "is_power_save_active KDE backend failed: "
+            "service=org.kde.Solid.PowerManagement "
+            "path=/org/kde/Solid/PowerManagement: DBusError: broke",
+        ]
+        assert debug == warnings
+
 
 class TestProbeActivityServices:
     """Test activity backend probing and logging."""

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/tests/test_cli.py

@@ -325,3 +325,61 @@ def test_cmd_setup_cli_token_beats_env(tmp_path: Path, capsys):
     captured = capsys.readouterr()
     assert saved_config.key == "clitok"
     assert "shared machines" in captured.err
+
+
+def test_cmd_setup_registers_via_http_when_no_token(tmp_path: Path):
+    args = argparse.Namespace(
+        server_url="http://localhost:9",
+        token=None,
+        stream_name=None,
+        non_interactive=True,
+    )
+    config = Config(base_dir=tmp_path)
+
+    def _register(cfg):
+        cfg.key = "newkey00"
+        cfg.stream = "locked-stream"
+        return True
+
+    with patch.dict(os.environ, {}, clear=True):
+        with patch("solstone_linux.cli.load_config", return_value=config):
+            with patch("solstone_linux.cli.save_config"):
+                with patch(
+                    "solstone_linux.cli.streams.stream_name", return_value="host-a"
+                ):
+                    with patch(
+                        "solstone_linux.upload.UploadClient.ensure_registered",
+                        side_effect=_register,
+                    ) as reg_mock:
+                        assert cmd_setup(args) == 0
+
+    reg_mock.assert_called_once()
+    assert config.key == "newkey00"
+    assert config.stream == "locked-stream"
+
+
+def test_cmd_setup_http_register_failure_non_interactive_returns_1(
+    tmp_path: Path, capsys
+):
+    args = argparse.Namespace(
+        server_url="http://localhost:9",
+        token=None,
+        stream_name=None,
+        non_interactive=True,
+    )
+    config = Config(base_dir=tmp_path)
+
+    with patch.dict(os.environ, {}, clear=True):
+        with patch("solstone_linux.cli.load_config", return_value=config):
+            with patch("solstone_linux.cli.save_config"):
+                with patch(
+                    "solstone_linux.cli.streams.stream_name", return_value="host-a"
+                ):
+                    with patch(
+                        "solstone_linux.upload.UploadClient.ensure_registered",
+                        return_value=False,
+                    ):
+                        assert cmd_setup(args) == 1
+
+    captured = capsys.readouterr()
+    assert "registration failed" in captured.out.lower()

{solstone_linux-0.1.1 → solstone_linux-0.2.0}/tests/test_observer_emits_stream_silent_event.py

@@ -39,7 +39,6 @@ def test_emits_with_full_fields(tmp_path: Path):
     assert 118 <= kwargs["duration_seconds"] <= 122
     assert kwargs["host"] == HOST
     assert kwargs["platform"] == PLATFORM
-    assert kwargs["stream"] == observer.stream
 
 
 def test_skips_when_client_none(tmp_path: Path):

solstone_linux-0.2.0/tests/test_upload.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from solstone_linux.config import Config, load_config
+from solstone_linux.upload import UploadClient
+
+
+def test_ensure_registered_posts_descriptor_and_persists(tmp_path: Path):
+    config = Config(
+        base_dir=tmp_path,
+        server_url="http://localhost:9999",
+        stream="host-a",
+    )
+    client = UploadClient(config)
+    client._session = MagicMock()
+    client._session.post.return_value = MagicMock(
+        status_code=200,
+        json=lambda: {
+            "key": "K123456789",
+            "prefix": "K1234567",
+            "name": "fedora",
+            "ingest_url": "/app/observer/ingest",
+            "protocol_version": 2,
+        },
+    )
+
+    assert client.ensure_registered(config) is True
+
+    client._session.post.assert_called_once()
+    call = client._session.post.call_args
+    assert call.args[0].endswith("/app/observer/register")
+    descriptor = call.kwargs["json"]
+    assert descriptor["stream_type"] == "desktop"
+    assert descriptor["platform"]
+    assert descriptor["hostname"]
+    assert descriptor["version"]
+    assert descriptor["label"] == "host-a"
+    assert config.key == "K123456789"
+    assert config.stream == "fedora"
+    assert client._key == "K123456789"
+
+    reloaded = load_config(base_dir=tmp_path)
+    assert reloaded.key == "K123456789"
+    assert reloaded.stream == "fedora"
+
+
+def test_ensure_registered_skips_when_key_present(tmp_path: Path):
+    config = Config(
+        base_dir=tmp_path,
+        server_url="http://localhost:9999",
+        key="existing",
+    )
+    client = UploadClient(config)
+    client._session = MagicMock()
+
+    assert client.ensure_registered(config) is True
+    client._session.post.assert_not_called()
+
+
+def test_upload_segment_uses_bearer_and_keyless_route(tmp_path: Path):
+    config = Config(base_dir=tmp_path, server_url="http://localhost:9999", key="K")
+    client = UploadClient(config)
+    client._session = MagicMock()
+    client._session.post.return_value = MagicMock(
+        status_code=200,
+        json=lambda: {"status": "ok"},
+    )
+    media = tmp_path / "audio.flac"
+    media.write_bytes(b"audio")
+
+    result = client.upload_segment("20260101", "120000_005", [media])
+
+    assert result.success
+    call = client._session.post.call_args
+    url = call.args[0]
+    assert url.endswith("/app/observer/ingest")
+    assert "/ingest/K" not in url
+    assert call.kwargs["headers"] == {"Authorization": "Bearer K"}
+    assert call.kwargs["data"] == {"day": "20260101", "segment": "120000_005"}
+    assert "stream" not in call.kwargs["data"]
+    assert "meta" not in call.kwargs["data"]
+    assert "files" in call.kwargs
+
+
+def test_relay_event_uses_bearer_and_keyless_route(tmp_path: Path):
+    config = Config(base_dir=tmp_path, server_url="http://localhost:9999", key="K")
+    client = UploadClient(config)
+    client._session = MagicMock()
+    client._session.post.return_value = MagicMock(status_code=200)
+
+    assert client.relay_event("observe", "status", mode="idle") is True
+
+    call = client._session.post.call_args
+    assert call.args[0].endswith("/app/observer/ingest/event")
+    assert call.kwargs["headers"] == {"Authorization": "Bearer K"}
+    assert call.kwargs["json"] == {
+        "tract": "observe",
+        "event": "status",
+        "mode": "idle",
+    }
+    assert "stream" not in call.kwargs["json"]
+
+
+def test_get_server_segments_uses_bearer_and_keyless_route(tmp_path: Path):
+    config = Config(base_dir=tmp_path, server_url="http://localhost:9999", key="K")
+    client = UploadClient(config)
+    client._session = MagicMock()
+    client._session.get.return_value = MagicMock(status_code=200, json=lambda: [])
+
+    assert client.get_server_segments("20260101") == []
+
+    call = client._session.get.call_args
+    assert call.args[0].endswith("/app/observer/ingest/segments/20260101")
+    assert call.kwargs["headers"] == {"Authorization": "Bearer K"}
+    params = call.kwargs.get("params")
+    assert params is None or "stream" not in params