kolega-code 0.42.0__tar.gz → 0.44.0__tar.gz

{kolega_code-0.42.0 → kolega_code-0.44.0}/CHANGELOG.md

@@ -6,6 +6,64 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.44.0 - 2026-10-19
+
+### Added
+
+- **Background sub-agents.** The agent can delegate with
+  `dispatch_agent(..., background=True)` and keep working while the child runs;
+  foreground dispatch remains the default. Jobs belong to the session in the
+  TUI, `ask`, `--loop`, goal runs, editor (ACP) sessions, and gateway chats.
+  Completion reports arrive automatically and normally start a continuation
+  instead of becoming extra prompts. The new `agent_job` tool lists, inspects,
+  or cancels jobs, with reports retained after completion, failure, or
+  cancellation. Persisted outcomes can be recovered when a session resumes, and
+  reported background usage is attributed to the session. Jobs survive turns,
+  not process exit; cancelling a main turn does not discard child results.
+- The TUI shows a persistent background-agent indicator above the composer,
+  distinguishing running, queued, undelivered, and failed work, and lists
+  retained jobs in the `Ctrl+G` sub-agent inspector. Delivered reports appear as
+  collapsed rows that expand on click or `Enter`, including after a session is
+  restored.
+- Added native Google Gemini 4 Argon (`gemini-4-argon`) and xAI Grok 4.7
+  (`grok-4.7`) support, including model selectors, image input, streaming, tool
+  calling, and named reasoning efforts. Argon uses a shared 1,048,576-token
+  input/thinking/output window; Grok 4.7 uses 500,000 tokens and supports `xhigh`
+  effort. Existing provider defaults remain unchanged.
+
+### Fixed
+
+- Late transcript updates during screen teardown no longer raise while the
+  conversation is being pruned, so exiting or switching sessions can no longer
+  fail on a stale render.
+
+### Security
+
+- Updated mcp to 1.30.0, closing CVE-2026-59951 (GHSA-84m7-p3x7-pcfv), a
+  streamable-HTTP session exhaustion issue in the MCP client.
+
+## 0.43.0 - 2026-10-13
+
+### Added
+
+- **Strict tool schemas.** Code that drives Kolega's LLM client directly can
+  mark a tool definition `strict=True`. The Responses providers then ask the
+  provider to hold the tool call to the schema exactly — every required field
+  present and nothing extra. Tools that are not marked strict behave as before.
+
+### Changed
+
+- DeepSeek requests now use `https://api.deepseek.com/beta`. DeepSeek enforces
+  strict tool schemas only on that endpoint and silently ignores the flag on the
+  bare host, so models that required a field could previously return a tool call
+  without it.
+
+### Fixed
+
+- A tool call whose arguments contain a raw control character — an unescaped tab
+  or newline copied into a JSON string — is now kept instead of degrading to an
+  empty call. Observed live with `deepseek-flash`.
+
 ## 0.42.0 - 2026-10-07
 
 ### Added

{kolega_code-0.42.0 → kolega_code-0.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.42.0
+Version: 0.44.0
 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/
@@ -45,7 +45,7 @@ Requires-Dist: langfuse==3.14.5
 Requires-Dist: lxml-html-clean==0.4.5
 Requires-Dist: markdownify==1.2.3
 Requires-Dist: markitdown[docx,pdf,pptx,xls,xlsx]==0.1.6
-Requires-Dist: mcp==1.28.1
+Requires-Dist: mcp==1.30.0
 Requires-Dist: nest-asyncio==1.6.0
 Requires-Dist: onnxruntime==1.19.2; sys_platform == 'darwin' and platform_machine == 'x86_64' and python_version < '3.13'
 Requires-Dist: onnxruntime==1.27.0; python_version >= '3.14' and sys_platform != 'win32'

{kolega_code-0.42.0 → kolega_code-0.44.0}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.42.0"
+__version__ = "0.44.0"

{kolega_code-0.42.0 → kolega_code-0.44.0}/kolega_code/acp/agent_factory.py

@@ -139,6 +139,15 @@ class AgentFactory:
             return
         self.persist(session)
         try:
+            jobs = getattr(session.agent, "background_jobs", None)
+            if jobs is not None:
+                jobs.set_callbacks(on_ready=None, on_delivered=None)
+                await jobs.close()
+                await jobs.deliver(session.agent)
+            self.persist(session)
+            for old in session.retired_agents:
+                await old.cleanup()
+            session.retired_agents.clear()
             await session.agent.cleanup()
         except Exception:  # noqa: BLE001 — closing must not mask the primary outcome
             logger.exception("acp session close: agent cleanup failed (session=%s)", session_id)
@@ -315,10 +324,24 @@ class AgentFactory:
             permission_mode=old.permission_mode,
             question_state=session.question_state,
         )
+        # New generations must keep publishing into the session-lifetime event
+        # consumer, including children still using the previous generation.
+        if manager is not session.manager:
+            raise RuntimeError("ACP rebuild must preserve the session connection manager")
         session.agent = agent
-        session.manager = manager
+        jobs = getattr(old, "background_jobs", None)
+        if jobs is not None and agent is not old:
+            agent.background_jobs = jobs
+            agent.background_needs_turn = getattr(old, "background_needs_turn", False)
+            old.background_jobs = None
+        if jobs is not None and jobs.active_count and agent is not old:
+            # Children borrow this generation's terminal/browser/extensions.
+            # Keep it alive until the supervisor has joined them.
+            session.retired_agents.append(old)
+            return
         try:
-            await old.cleanup()
+            if agent is not old:
+                await old.cleanup()
         except Exception:  # noqa: BLE001
             logger.exception("acp model switch: old agent cleanup failed (session=%s)", session.session_id)
 
@@ -369,7 +392,8 @@ class AgentFactory:
     ) -> tuple[CoderAgent, CliConnectionManager]:
         journal = self._store.journal(record.session_id)
         recorder = self._store.recorder(record.session_id)
-        manager = CliConnectionManager()
+        existing = self._acp_sessions.get(record.session_id)
+        manager = existing.manager if existing is not None else CliConnectionManager()
         recording = RecordingConnectionManager(
             manager,
             FileSessionEventStore(journal),

{kolega_code-0.42.0 → kolega_code-0.44.0}/kolega_code/acp/bridge.py

@@ -111,6 +111,12 @@ class AcpBridge:
         #: label the dispatching card's title.
         self._dispatch_labels: dict[str, str] = {}
 
+    def begin_turn(self, agent: Any, diff_provider: AcpDiffProvider) -> None:
+        """Reset turn-only projections, retaining session-lifetime tool maps."""
+        self._agent = agent
+        self._diffs = diff_provider
+        self._turn_response_parts.clear()
+
     async def send(self, session_id: str, update: Any) -> None:
         if logger.isEnabledFor(logging.DEBUG):
             logger.debug(

{kolega_code-0.42.0 → kolega_code-0.44.0}/kolega_code/acp/server.py

@@ -188,6 +188,7 @@ class AcpAgent(Agent):
             return await self._load_sub_session(session_id)
         if session_id in self._sessions:
             existing = self._sessions[session_id]
+            self._start_session_tasks(existing)
             return LoadSessionResponse(config_options=self._factory.config_options_for(existing))
         try:
             session = await self._factory.load_session(
@@ -204,6 +205,7 @@ class AcpAgent(Agent):
         await self._emit_initial_usage(session)
         await self._send_available_commands(session)
         await self._replay_transcript(session)
+        self._start_session_tasks(session)
         return LoadSessionResponse(config_options=self._factory.config_options_for(session))
 
     async def _load_sub_session(self, session_id: str) -> LoadSessionResponse:
@@ -254,11 +256,33 @@ class AcpAgent(Agent):
 
     async def close_session(self, session_id: str, **kwargs: Any) -> None:
         logger.info("acp session/close (session=%s)", session_id)
-        self._sessions.pop(session_id, None)
+        session = self._sessions.pop(session_id, None)
+        if session is not None:
+            session.closed = True
+            session.auto_continue_paused = True
+            if session.turn_task is not None:
+                session.turn_task.cancel()
+                await asyncio.gather(session.turn_task, return_exceptions=True)
+            if session.background_task is not None:
+                session.background_task.cancel()
+                await asyncio.gather(session.background_task, return_exceptions=True)
         self._brokers.pop(session_id, None)
-        await self._factory.close_session(session_id)
+        if session is not None:
+            async with session.execution_lock:
+                await self._factory.close_session(session_id)
+        else:
+            await self._factory.close_session(session_id)
+        if session is not None and session.event_task is not None:
+            session.event_task.cancel()
+            await asyncio.gather(session.event_task, return_exceptions=True)
+            await self._drain_residual(session, session.bridge)
         return None
 
+    async def shutdown(self) -> None:
+        """Join session work before the ACP transport and shared services close."""
+        for session_id in list(self._sessions):
+            await self.close_session(session_id)
+
     # -- turns ------------------------------------------------------------
 
     async def prompt(self, session_id: str, prompt: list[_PromptBlock], **kwargs: Any) -> PromptResponse:
@@ -270,13 +294,19 @@ class AcpAgent(Agent):
         text = self._extract_text(prompt)
         if not text:
             raise RequestError.invalid_request({"message": "prompt contains no text"})
-        stop_reason = await self._run_turn(session, text)
-        self._factory.persist(session)
+        self._start_session_tasks(session)
+        async with session.execution_lock:
+            session.auto_continue_paused = False
+            stop_reason = await self._run_turn(session, text)
+            self._factory.persist(session)
         return PromptResponse(stop_reason=stop_reason)
 
     async def cancel(self, session_id: str, **kwargs: Any) -> None:
         session = self._sessions.get(session_id)
-        if session is None or session.turn_task is None:
+        if session is None:
+            return
+        session.auto_continue_paused = True
+        if session.turn_task is None:
             logger.debug("acp session/cancel: nothing to cancel (session=%s)", session_id)
             return
         logger.info("acp session/cancel (session=%s)", session_id)
@@ -314,7 +344,8 @@ class AcpAgent(Agent):
             raise RequestError.invalid_params({"message": f"unknown mode {mode_id!r}; available: build, plan"})
         if not session.idle():
             raise RequestError.invalid_request({"message": "modes apply between turns only"})
-        await self._factory.set_interaction_mode(session, mode_id)
+        async with session.execution_lock:
+            await self._factory.set_interaction_mode(session, mode_id)
         logger.info("acp session mode -> %s (session=%s)", mode_id, session_id)
         await self._emit_current_mode(session)
         return SetSessionModeResponse()
@@ -342,14 +373,16 @@ class AcpAgent(Agent):
                 raise RequestError.invalid_params({"message": "model option expects 'provider/model'"})
             provider, model = value.split("/", 1)
             try:
-                await self._factory.apply_model(session, provider, model)
+                async with session.execution_lock:
+                    await self._factory.apply_model(session, provider, model)
             except _HANDLED_CONFIG_ERRORS as exc:
                 raise AgentFactory.protocol_error(exc) from exc
             logger.info("acp session config: model -> %s/%s (session=%s)", provider, model, session_id)
         elif config_id == CONFIG_MODE:
             if value not in INTERACTION_MODES:
                 raise RequestError.invalid_params({"message": f"unknown mode {value!r}; available: build, plan"})
-            await self._factory.set_interaction_mode(session, str(value))
+            async with session.execution_lock:
+                await self._factory.set_interaction_mode(session, str(value))
             logger.info("acp session config: mode -> %s (session=%s)", value, session_id)
             await self._emit_current_mode(session)
         else:
@@ -438,6 +471,7 @@ class AcpAgent(Agent):
             return
         await self._emit_initial_usage(session)
         await self._send_available_commands(session)
+        self._start_session_tasks(session)
 
     async def _send_available_commands(self, session: AcpSession) -> None:
         """Advertise the agent's slash commands for the client's command UI.
@@ -525,29 +559,107 @@ class AcpAgent(Agent):
 
     # -- turn machinery ----------------------------------------------------
 
-    async def _run_turn(self, session: AcpSession, text: str) -> StopReason:
+    def _start_session_tasks(self, session: AcpSession) -> None:
+        if session.closed:
+            return
+        if session.event_task is None:
+            session.bridge = AcpBridge(
+                self._conn, diff_provider=AcpDiffProvider.for_session(session), agent=session.agent
+            )
+            session.event_task = asyncio.create_task(
+                self._pump_events(session, session.bridge), name=f"acp-events-{session.session_id}"
+            )
+        # Explicit session activity rearms retained presentation work, including
+        # after a transport failure. The worker must not retry itself on failure.
+        if session.completions:
+            session.background_wake.set()
+        if session.background_task is not None and not session.background_task.done():
+            return
+        get_jobs = getattr(session.agent, "get_background_jobs", None)
+        if callable(get_jobs):
+            jobs: Any = get_jobs()
+
+            def delivered(completion: dict[str, Any]) -> None:
+                session.completions.append(completion)
+                session.background_wake.set()
+
+            jobs.set_callbacks(on_ready=session.background_wake.set, on_delivered=delivered)
+            session.background_task = asyncio.create_task(
+                self._background_worker(session, jobs), name=f"acp-background-{session.session_id}"
+            )
+
+    async def _background_worker(self, session: AcpSession, jobs: Any) -> None:
+        await jobs.recover()
+        if jobs.pending_count:
+            session.background_wake.set()
+        while not session.closed:
+            await session.background_wake.wait()
+            session.background_wake.clear()
+            async with session.execution_lock:
+                if session.closed:
+                    return
+                try:
+                    await jobs.deliver(session.agent)
+                    # Delivery callbacks also wake the worker for reports
+                    # inserted by the running agent. Consume those wakeups now,
+                    # not after sending: a failed send must wait for new activity,
+                    # while readiness arriving during presentation must survive.
+                    session.background_wake.clear()
+                    if jobs.pending_count:
+                        session.background_wake.set()
+                    completions = bool(session.completions)
+                    try:
+                        while session.completions:
+                            completion = session.completions[0]
+                            await session.bridge.send(
+                                session.session_id, update_agent_thought_text(str(completion["text"]))
+                            )
+                            # History insertion is already durable. Acknowledge
+                            # presentation separately, only after this send
+                            # succeeds; failure/cancellation retains the suffix.
+                            session.completions.pop(0)
+                    except Exception:
+                        logger.exception("acp background presentation failed (session=%s)", session.session_id)
+                        continue
+                    if (
+                        completions
+                        and not session.auto_continue_paused
+                        and getattr(session.agent, "background_needs_turn", True)
+                    ):
+                        await self._run_turn(session, None)
+                    self._factory.persist(session)
+                    if jobs is not getattr(session.agent, "background_jobs", None):
+                        return  # a context reset installed another epoch's owner
+                    if not jobs.active_count:
+                        for old in session.retired_agents:
+                            await old.cleanup()
+                        session.retired_agents.clear()
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    # A failed automatic turn must not spin or silently kill
+                    # the prompt owner. Explicit input can resume it.
+                    session.auto_continue_paused = True
+                    logger.exception("acp background delivery failed (session=%s)", session.session_id)
+
+    async def _run_turn(self, session: AcpSession, text: str | None) -> StopReason:
         """Drive one agent turn, mapping its output to ACP updates.
 
-        Returns the ACP stop reason. The event pump runs until the turn task
-        completes, then any residual queued events are drained so late tool
-        results still render.
+        The event pump belongs to the session, not this request. It keeps
+        rendering child activity after a prompt's response has been returned.
         """
-        session.drain_events()
-        bridge = AcpBridge(self._conn, diff_provider=AcpDiffProvider.for_session(session), agent=session.agent)
+        self._start_session_tasks(session)
+        bridge = session.bridge
+        bridge.begin_turn(session.agent, AcpDiffProvider.for_session(session))
         session.turn_task = asyncio.create_task(self._drive_turn(session, bridge, text))
-        pump = asyncio.create_task(self._pump_events(session, bridge))
+        reason: StopReason = "cancelled"
         try:
-            return await session.turn_task
+            reason = await session.turn_task
+            return reason
         finally:
-            pump.cancel()
-            try:
-                await pump
-            except asyncio.CancelledError:
-                pass
-            await self._drain_residual(session, bridge)
             session.turn_task = None
             await bridge.emit_usage(session.session_id)
-            plan = self._consume_plan(session, bridge)
+            plan = self._consume_plan(session, bridge) if reason != "cancelled" and not session.closed else None
             if plan:
                 session.record.latest_plan_markdown = plan
                 session.record.plan_pending = True
@@ -606,6 +718,20 @@ class AcpAgent(Agent):
             session.record.plan_pending = False
             session.record.plan_reofferable = False
             if option_id == "implement_plan_clear":
+                jobs = getattr(session.agent, "background_jobs", None)
+                if jobs is not None:
+                    # The reset starts another epoch. Settle old-context work
+                    # before clearing its history and creating a new owner.
+                    jobs.set_callbacks(on_ready=None, on_delivered=None)
+                    await jobs.close()
+                    await jobs.deliver(session.agent)
+                    session.agent.background_jobs = None
+                    if session.background_task is not None and session.background_task is not asyncio.current_task():
+                        session.background_task.cancel()
+                        await asyncio.gather(session.background_task, return_exceptions=True)
+                    session.background_task = None
+                    session.completions.clear()
+                    session.background_wake.clear()
                 self._clear_agent_context(session)
             await self._factory.set_interaction_mode(session, MODE_BUILD)
             await self._emit_current_mode(session)
@@ -630,9 +756,14 @@ class AcpAgent(Agent):
         session.record.history = []
         session.record.compaction = {}
 
-    async def _drive_turn(self, session: AcpSession, bridge: AcpBridge, text: str) -> str:
+    async def _drive_turn(self, session: AcpSession, bridge: AcpBridge, text: str | None) -> StopReason:
         try:
-            async for chunk in session.agent.process_message_stream(text):
+            stream = (
+                session.agent.process_message_stream(text)
+                if text is not None
+                else session.agent.continue_from_history_stream()
+            )
+            async for chunk in stream:
                 await bridge.emit_chunk(session.session_id, chunk)
             return "end_turn"
         except asyncio.CancelledError:

{kolega_code-0.42.0 → kolega_code-0.44.0}/kolega_code/acp/session.py

@@ -33,14 +33,15 @@ class AcpSession:
     question_state: dict[str, Any] = field(default_factory=dict)
     #: In-flight turn task; None when the session is idle. Set and cleared by the server.
     turn_task: asyncio.Task | None = field(default=None, repr=False)
+    execution_lock: asyncio.Lock = field(default_factory=asyncio.Lock, repr=False)
+    event_task: asyncio.Task[None] | None = field(default=None, repr=False)
+    background_task: asyncio.Task[None] | None = field(default=None, repr=False)
+    bridge: Any = field(default=None, repr=False)
+    background_wake: asyncio.Event = field(default_factory=asyncio.Event, repr=False)
+    completions: list[dict[str, Any]] = field(default_factory=list)
+    auto_continue_paused: bool = False
+    closed: bool = False
+    retired_agents: list[Any] = field(default_factory=list, repr=False)
 
     def idle(self) -> bool:
-        return self.turn_task is None or self.turn_task.done()
-
-    def drain_events(self) -> None:
-        """Drop any events left over from a previous turn (stale mapping inputs)."""
-        while not self.manager.events.empty():
-            try:
-                self.manager.events.get_nowait()
-            except asyncio.QueueEmpty:
-                break
+        return not self.execution_lock.locked() and (self.turn_task is None or self.turn_task.done())

{kolega_code-0.42.0 → kolega_code-0.44.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.42.0"
+__version__ = "0.44.0"