kolega-code 0.35.0__tar.gz → 0.35.1__tar.gz

{kolega_code-0.35.0 → kolega_code-0.35.1}/CHANGELOG.md

@@ -6,6 +6,18 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.35.1 - 2026-09-03
+
+### Fixed
+
+- **Gateway (Telegram):** the tool-activity status now re-appears below the
+  newest reply bubble. Previously it stayed stranded in an older message once
+  a reply opened, so later tool calls looked detached from the conversation.
+  Adapters without message-delete support keep the edit-in-place behavior.
+- **Gateway service:** the background daemon now launches through the user's
+  login shell, so gateway-driven agent sessions see user-installed tools such
+  as Homebrew instead of the minimal `PATH` that launchd and systemd provide.
+
 ## 0.35.0 - 2026-09-03
 
 ### Added

{kolega_code-0.35.0 → kolega_code-0.35.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.35.0
+Version: 0.35.1
 Summary: Multi-agent coding in the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.35.0 → kolega_code-0.35.1}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.35.0"
+__version__ = "0.35.1"

{kolega_code-0.35.0 → kolega_code-0.35.1}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.35.0"
+__version__ = "0.35.1"

{kolega_code-0.35.0 → kolega_code-0.35.1}/kolega_code/gateway/bridge.py

@@ -12,8 +12,11 @@ turns:
 - a placeholder reply is created on first content and edited in place on a
   throttle until the turn ends (final-only transports get one message at the
   end);
-- tool activity lands in a separate "working…" status message, edited as
-  events arrive and deleted when the turn finishes;
+- each round of tool activity lands in its own "working…" message below the
+  newest reply bubble: a round that starts after text was streamed opens a
+  fresh message (Telegram cannot move messages, so appending to an older one
+  would surface above the latest text), and the messages persist as a trail
+  of what the agent did during the turn;
 - text is chunked at the adapter's limit; the first chunk is the edited
   message and overflow chunks are sent as continuations on finalize.
 
@@ -34,10 +37,10 @@ from kolega_code.gateway.adapters.telegram.formatting import chunk_text
 
 logger = logging.getLogger(__name__)
 
-#: Cap on status-message lines so a chatty turn cannot spam an unbounded edit.
+#: Cap on a round message's lines so a chatty turn cannot spam an unbounded edit.
 MAX_STATUS_LINES = 8
-#: Events the status pump renders; everything else on the stream is ignored.
-STATUS_MESSAGE_TYPES = {"tool_call", "tool_result", "tool_error"}
+#: Rendered status line: (icon, tool description, tool call id).
+StatusLine = tuple[str, str, str]
 
 
 class TurnRenderer:
@@ -69,10 +72,17 @@ class TurnRenderer:
         self._reply_id: Optional[str] = None
         self._edited_text = ""
         self._last_flush = 0.0
+        #: The current tool round's message, one per burst of tool activity.
+        #: Older rounds' messages stay in the chat as a trail of the turn.
         self._status_id: Optional[str] = None
-        self._status_lines: list[str] = []
+        self._status_lines: list[StatusLine] = []
         self._status_sent_text = ""
         self._last_status_flush = 0.0
+        #: Set when a reply message was sent after the current round message:
+        #: the next tool event then opens a fresh round message below the
+        #: newest bubble (Telegram cannot move messages) instead of appending
+        #: to the stale one higher up the chat.
+        self._status_stale = False
 
     async def run(self, chunks: AsyncIterator[dict[str, Any]]) -> str:
         """Consume the turn generator and mirror it into the chat.
@@ -118,7 +128,6 @@ class TurnRenderer:
                 except asyncio.CancelledError:
                     pass
             await self._adapter.set_typing(self._chat_id, False)
-            await self._finalize_status()
 
     # -- Reply messages (one per response segment) -------------------------
 
@@ -144,6 +153,7 @@ class TurnRenderer:
                 return  # final-only transports send once, at the end
             self._reply_id = await self._adapter.send_text(self._chat_id, chunks[0])
             self._edited_text = chunks[0]
+            self._status_stale = True
             return
         if not final:
             if len(chunks) > 1:
@@ -155,6 +165,7 @@ class TurnRenderer:
         await self._edit_reply(chunks[0])
         for extra in chunks[1:]:
             await self._adapter.send_text(self._chat_id, extra)
+            self._status_stale = True
 
     async def _edit_reply(self, text: str) -> None:
         if text == self._edited_text:
@@ -163,39 +174,58 @@ class TurnRenderer:
             await self._adapter.edit_text(self._chat_id, self._reply_id or "", text)
         self._edited_text = text
 
-    # -- Tool status message ----------------------------------------------
+    # -- Tool round messages ----------------------------------------------
 
     async def _event_pump(self) -> None:
         try:
             while True:
                 event = await self._events.get()
-                line = self._status_line_for(event)
-                if line is None:
+                record = self._line_record_for(event)
+                if record is None:
                     continue
-                self._status_lines.append(line)
-                self._status_lines = self._status_lines[-MAX_STATUS_LINES:]
+                if self._status_stale:
+                    # The newest reply bubble was sent after the current round
+                    # message: open a fresh round message below it instead of
+                    # appending to the stale one higher up the chat.
+                    self._status_stale = False
+                    self._status_id = None
+                    self._status_lines = []
+                self._record_line(record)
                 await self._flush_status()
         except asyncio.CancelledError:
             raise
 
     @staticmethod
-    def _status_line_for(event: AgentEvent) -> Optional[str]:
+    def _line_record_for(event: AgentEvent) -> Optional[StatusLine]:
         if event.event_type != "chat_message":
             return None
         message_type = event.content.get("message_type")
+        description = str(event.content.get("tool_description") or "tool")
+        call_id = str(event.content.get("tool_call_id") or "")
         if message_type == "tool_call":
-            description = event.content.get("tool_description") or "tool"
-            return f"⏳ {description}"
+            return ("⏳", description, call_id)
         if message_type == "tool_result":
-            return "✅ tool finished"
+            return ("✅", description, call_id)
         if message_type == "tool_error":
-            return "❌ tool failed"
+            return ("❌", description, call_id)
         return None
 
+    def _record_line(self, record: StatusLine) -> None:
+        icon, _, call_id = record
+        if icon != "⏳" and call_id:
+            # A finished call replaces its pending line so the round message
+            # reads as a settled trail (⏳ bash -> ✅ bash), not an append log.
+            for index, (pending_icon, _, pending_id) in enumerate(self._status_lines):
+                if pending_icon == "⏳" and pending_id == call_id:
+                    self._status_lines[index] = record
+                    return
+        self._status_lines.append(record)
+        self._status_lines = self._status_lines[-MAX_STATUS_LINES:]
+
     async def _flush_status(self) -> None:
         if not self._status_lines:
             return
-        text = "\n".join(self._status_lines)
+        text = "\n".join(f"{icon} {description}" for icon, description, _ in self._status_lines)
         if text == self._status_sent_text:
             # Line-cap truncation can make a new event's rendered text
             # identical to the previous one; re-sending the same content is a
@@ -206,20 +236,10 @@ class TurnRenderer:
             return
         self._last_status_flush = now
         if self._status_id is None:
-            # No status message on transports that cannot edit it away.
+            # No round message on transports that cannot edit it away.
             if not self._adapter.capabilities.supports_edits:
                 return
             self._status_id = await self._adapter.send_text(self._chat_id, text)
         else:
             await self._adapter.edit_text(self._chat_id, self._status_id, text)
         self._status_sent_text = text
-
-    async def _finalize_status(self) -> None:
-        if self._status_id is None:
-            return
-        message_id, self._status_id = self._status_id, None
-        if self._adapter.capabilities.supports_delete:
-            try:
-                await self._adapter.delete_message(self._chat_id, message_id)
-            except Exception:  # noqa: BLE001 — a stuck status message is cosmetic
-                logger.debug("gateway: status delete failed for chat %s", self._chat_id)

{kolega_code-0.35.0 → kolega_code-0.35.1}/kolega_code/gateway/service.py

@@ -50,6 +50,34 @@ class ServiceInstallResult:
     unit_path: Optional[Path] = None
 
 
+def login_shell(platform: Optional[str] = None) -> str:
+    """The user's login shell: ``$SHELL`` when set, else the platform default.
+
+    launchd and systemd start service programs directly, so the daemon would
+    inherit the service manager's minimal environment (launchd gives agents
+    ``PATH=/usr/bin:/bin:/usr/sbin:/sbin``), which starves gateway-driven
+    agent sessions of Homebrew and other user-installed tools.  The service
+    therefore launches through the user's login shell: ``-l`` runs the shell
+    profile files, so the daemon's environment matches what an interactive
+    terminal sees, and nothing is captured at install time.
+    """
+    platform = platform if platform is not None else sys.platform
+    from_env = os.environ.get("SHELL")
+    if from_env:
+        return from_env
+    return "/bin/zsh" if platform == "darwin" else "/bin/bash"
+
+
+def service_launch_command(config: GatewayConfig, executable: str, *, shell: str) -> list[str]:
+    """The service-level argv: the login shell exec-ing the daemon.
+
+    ``exec`` replaces the shell process, so termination signals reach the
+    daemon directly and launchd/KeepAlive track the real process.
+    """
+    inner = " ".join(shlex.quote(part) for part in service_command(config, executable))
+    return [shell, "-l", "-c", f"exec {inner}"]
+
+
 def service_command(config: GatewayConfig, executable: str) -> list[str]:
     """The exact argv the service runs."""
     return [
@@ -69,6 +97,7 @@ def install_service(
     config: GatewayConfig,
     *,
     executable: Optional[str] = None,
+    shell: Optional[str] = None,
     systemd_dir: Optional[Path] = None,
     launchd_dir: Optional[Path] = None,
     platform: Optional[str] = None,
@@ -76,12 +105,16 @@ def install_service(
     """Write the service definition.
 
     ``systemd_dir``/``launchd_dir`` are the unit destination directories;
-    callers resolve the platform defaults (tests pass temp dirs).
+    callers resolve the platform defaults (tests pass temp dirs).  ``shell``
+    overrides the login shell the service launches through (tests pass one
+    for determinism); by default the user's ``$SHELL`` or the platform
+    default is used.
     """
     platform = platform if platform is not None else sys.platform
     executable = executable or shutil.which("kolega-code") or ""
     if not executable:
         raise RuntimeError("kolega-code executable not found; is it on PATH?")
+    launch_shell = shell or login_shell(platform)
     config.state_dir.mkdir(parents=True, exist_ok=True)
     result = ServiceInstallResult()
     if platform == "darwin":
@@ -90,7 +123,7 @@ def install_service(
         plist_path = launchd_dir / LAUNCHD_PLIST_NAME
         plist: dict[str, object] = {
             "Label": LAUNCHD_LABEL,
-            "ProgramArguments": service_command(config, executable),
+            "ProgramArguments": service_launch_command(config, executable, shell=launch_shell),
             "RunAtLoad": True,
             "KeepAlive": True,
             "StandardOutPath": str(config.state_dir / "gateway.log"),
@@ -103,10 +136,14 @@ def install_service(
         systemd_dir = systemd_dir or (Path.home() / ".config" / "systemd" / "user")
         systemd_dir.mkdir(parents=True, exist_ok=True)
         unit_path = systemd_dir / SYSTEMD_UNIT_NAME
-        command = " ".join(shlex.quote(part) for part in service_command(config, executable))
+        command = " ".join(shlex.quote(part) for part in service_launch_command(config, executable, shell=launch_shell))
         unit_path.write_text(_SYSTEMD_UNIT_TEMPLATE.format(command=command), encoding="utf-8")
         result.unit_path = unit_path
         result.notes.append(f"systemd user unit written to {unit_path}")
+    result.notes.append(
+        f"the service launches via your login shell ({launch_shell}), so it inherits your "
+        "normal terminal environment; restart it after changing your shell profile"
+    )
     result.notes.append(
         "the service reads settings.json from the same state dir — make sure your provider "
         "API keys are saved in Settings (they apply to the gateway too)"

{kolega_code-0.35.0 → kolega_code-0.35.1}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kolega-code"
-version = "0.35.0"
+version = "0.35.1"
 description = "Multi-agent coding in the terminal"
 readme = "README.md"
 license = "BUSL-1.1"