kolega-code 0.26.9__tar.gz → 0.27.0__tar.gz

{kolega_code-0.26.9 → kolega_code-0.27.0}/CHANGELOG.md

@@ -6,6 +6,261 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.27.0 - 2026-08-06
+
+### Changed
+
+- The `eval`, `exec_command`, and `lsp` tool descriptions shipped to model
+  providers are slimmer (about 450 cl100k tokens less across the three,
+  roughly 8% of the whole tool payload): prose now states decision rules and
+  contracts instead of restating parameter schema text, `eval`'s JavaScript
+  prelude folds to "same helpers as Python, camelCase" with only the
+  JS-specific pitfalls spelled out, `lsp`'s operation list groups the seven
+  operations that share the `(path, line, symbol)` arguments onto one line,
+  and `exec_command`'s `timeout`-alias note is gone (the alias layer absorbs
+  it silently). No parameter names, types, or presence change, and no
+  behavior changes ride along.
+
+- Tool definitions sent to model providers no longer duplicate parameter
+  documentation. Every tool docstring's `Args:` section is still parsed into
+  per-parameter schema descriptions, but the wire description no longer also
+  carries the whole section verbatim (and the schema descriptions no longer
+  include the raw docstring continuation-line indentation). Tools whose
+  parameters are not fully documented in their schema — freeform tools and
+  tools with enum-only schema properties such as the browser tools' `button`,
+  `action`, `level`, `part`, `image_type`, and `scale` — keep their `Args:`
+  block, since it is the only place those parameters are documented.
+
+- The per-type agent dispatch tools (`dispatch_general_agent`,
+  `dispatch_investigation_agent`, `dispatch_browser_agent`,
+  `dispatch_coding_agent`, and `dispatch_custom_agent`) are consolidated into a
+  single `dispatch_agent(agent_type, task, model_override?, browser_target?)`
+  tool. `agent_type` is an enum computed per session from the same conditions
+  that previously gated the individual tools: `general` and `investigation`
+  whenever dispatch is available, `browser` only when the browser-agent model
+  supports vision, `coding` where the coding dispatch was previously offered
+  (never for the coder itself), and custom agent names when definitions are
+  discovered. The description documents the shared dispatch mechanics once plus
+  one line per available agent type, and an unavailable `agent_type` returns an
+  error listing the valid values. Old sessions that used the removed tool names
+  still restore and display normally.
+
+- All terminal-capable agents (coder, planning, investigation, general) now
+  share a terminal-tools prompt section with codex-style guidance: prefer
+  `rg` / `rg --files` over `grep`/`find` when searching for text or files (it is
+  much faster; use alternatives if `rg` is not found), and do not use Python
+  scripts (or `eval`) to print chunks of a file — use the file-reading tools
+  instead.
+- The `resolve` tool — which applies or discards a pending `lsp_edit(apply: false)`
+  preview — is now gated like the other LSP tools. With LSP disabled (via
+  settings, `KOLEGA_CODE_LSP`, or `--lsp off`) it is removed from the model's
+  toolset entirely, since pending actions can only be created while LSP is on.
+  Applying a pending action with `resolve` now also goes through the same
+  edit-permission prompt as `edit`, `lsp_edit`, and `write`.
+- The two file-read tools are merged into one `read(file_path, offset?, limit?)`
+  tool. `offset` is the 1-indexed first line (default 1) and `limit` bounds the
+  number of lines; omitted parameters read from the top. Output is truncated to
+  2000 lines or 50KB — whichever binds first — snapped to line boundaries, with
+  actionable notices such as "[Showing lines a-b of N (50KB limit). Use
+  offset=b+1 to continue.]" instead of the old line-only warning and
+  100,000-character backstop. A single line larger than the 50KB budget gets an
+  explicit message suggesting `rg` / `exec_command` for targeted extraction.
+  `path` is accepted at the dispatch boundary as an alias for the canonical
+  `file_path`.
+
+- `write(path=…)` now also succeeds under the claude_code edit protocol, where
+  `write` binds to `claude_write(file_path, content)`: `path` is accepted at
+  the dispatch boundary as an alias for `file_path`, matching every other file
+  tool. Under the search/replace protocol `path` stays the canonical
+  parameter and passes through untouched — alias resolution is signature-aware
+  and never rewrites an argument name the bound tool itself accepts.
+
+- A successful whole-file `write` (including `hashline_write` and `apply_patch`'s
+  Add File) now records the just-written contents as read, so the read-before-edit
+  guard accepts a subsequent edit without a fresh read — exactly as it would
+  right after a read. Staleness tracking is unchanged: a file modified after the
+  write still requires a fresh read before editing.
+- The three skill host tools (`list_skills`, `activate_skill`, and
+  `read_skill_resource`) are consolidated into a single `skill` tool with the
+  same contract as the old `activate_skill`: it takes the skill name (without a
+  leading slash) and returns the activation envelope with the skill's
+  instructions, its absolute directory, and the resource file list. Activating
+  an already-active skill short-circuits as before, and an unknown name now
+  lists close matches (prefix first, then fuzzy) from the catalog so a
+  mistyped activation self-corrects in one turn. The in-prompt skill roster
+  always lists every skill by name: description text is shed first when the
+  metadata budget binds, and skills are never omitted wholesale.
+
+### Removed
+
+- The `read_entire_file` and `read_file_section` tools are gone, replaced by the
+  merged `read` tool above. Deleted: the `ReadFileTool.read_entire_file` /
+  `read_file_section` methods and their `read_only_tools` registrations, the
+  truncation notices that named `read_file_section`, and the stale
+  `dispatch_investigation_agent` docstring tool list. Existing session
+  histories keep the old tool names as recorded data and render as-is (restore
+  is name-agnostic).
+
+- The file-discovery tools are gone from the agent toolset: `glob` (which had
+  replaced `list_directory` and `find_files_by_pattern`), and `search_codebase`.
+  File and text discovery is now done through the terminal with `rg` /
+  `rg --files` (falling back to `find`/`grep`). Deleted: the `GlobTool` and
+  `SearchCodebaseTool` backends (the underlying `workspace_scan` service stays),
+  the `ToolCollection.glob` / `ToolCollection.search_codebase` methods and their
+  `read_only_tools` registrations, the stale `dispatch_investigation_agent`
+  docstring tool list (now naming the real surface, including terminal access),
+  and the `search_codebase` name from hashline history adaptation.
+  `@`-mention autocomplete (`cli/file_index.py`) keeps its exclusions by
+  inlining the constants it borrowed. Permission rules and custom-agent
+  allowlists naming the removed tools must be updated to the terminal tools
+  (`exec_command`, `write_stdin`, `kill_command`, `list_sessions`). Existing
+  session histories keep the old tool names as recorded data and render as-is.
+
+- The `sleep` tool is gone from the agent toolset: its blind wall-clock wait is
+  strictly dominated by `write_stdin`'s empty-input poll, which waits for more
+  output or process exit and returns early when the process finishes. The
+  `yield_time_ms` clamp semantics (250–30000 ms when writing, 5000–300000 ms
+  when polling) moved from the `write_stdin` docstring body into its parameter
+  description so the poll path stays discoverable. Existing session histories
+  keep the old tool name as recorded data and render as-is.
+
+- The `think_hard` tool is gone from the agent toolset, along with the thinking
+  model slot that powered it. Deleted: the `ThinkHardTool` backend and its
+  `auxiliary/tools/think_hard.system.md` prompt template, the
+  `ToolCollection.think_hard` method and its `read_only_tools` registration, the
+  `THINK_HARD_PROMPT` constant, and the `thinking_config` model slot itself.
+  `prompt` hooks now select only `"fast"` or `"long"`; the
+  `--thinking-provider`/`--thinking-model` flags, the
+  `KOLEGA_CODE_THINKING_PROVIDER`/`KOLEGA_CODE_THINKING_MODEL` env vars, and the
+  Settings Thinking slot row were removed, and a saved `thinking` slot entry in
+  `settings.json` is ignored on load. The active model's own thinking effort
+  (`--thinking-effort`, `KOLEGA_CODE_THINKING_EFFORT`) is unaffected.
+
+- The `get_host` tool is gone from the local toolset. It needs a sandbox host
+  provider, so it is now offered only when a terminal manager carrying a
+  `sandbox` attribute is injected (cloud sandbox deployments), and the
+  localhost fallback branch in the handler is deleted — a registered
+  `get_host` always has a sandbox. The gate duck-types on the attribute rather
+  than `isinstance`, so kolega-code-e2b's injected `SandboxTerminalManager`
+  (possibly subclassed from a pinned older version) keeps qualifying. Existing
+  session histories that recorded `get_host` calls keep them as data and
+  render as-is (restore is name-agnostic).
+
+- The `list_skills`, `activate_skill`, and `read_skill_resource` host tools are
+  gone, replaced by the single `skill` tool above. Deleted:
+  `SkillCatalog.read_resource` and its truncation cap and traversal guard
+  (skill resources are read with the ordinary `read` tool, whose `file_path`
+  is relative to the absolute skill directory in the activation output), the
+  model-facing list query surface (`format_model_catalog`), and the
+  omitted-skills budget pathway in the prompt roster. Existing session
+  histories keep the old tool names as recorded data and render as-is
+  (restore is name-agnostic).
+
+### Fixed
+
+- Kimi-family usage is no longer dropped when a request is served entirely from
+  the provider's prompt cache. `kimi-for-coding` / `moonshot` report
+  `input_tokens: -1` as a sentinel for "no uncached input tokens" on a full
+  cache hit; the strict usage validator previously classified that as malformed
+  and nulled the whole record, silently removing both input and output tokens
+  from session accounting for those turns. The sentinel is now interpreted as
+  zero, and the inclusive input total is reconstructed from the cache fields
+  (verified live: `-1` + 33 cached = 33 total, matching the same prompt's
+  partial-cache report of 27 uncached + 6 cached).
+
+## 0.26.10 - 2026-08-05
+
+### Added
+
+- Hosted (server-side) web search for Responses-API providers. On DeepSeek
+  flash and OpenAI gpt-5.x (API key or ChatGPT subscription), kolega can
+  request the provider's own
+  `{"type": "web_search"}` tool: searches and page-opens execute on the
+  provider's servers and the content is injected directly into the model's
+  context (billed as input tokens; the context gauge accounts for it from
+  usage, since the content never reaches the client). Calls render in the
+  transcript as `web_search (hosted)`. Controlled by a new web tool mode —
+  `auto` (default: hosted when the model supports it, else the client tools) /
+  `hosted` / `client` / `off` — via Settings, `KOLEGA_CODE_WEB_SEARCH_MODE`,
+  `ask --web-search`, or the TUI's `/web-search`. When hosted search is active
+  the client-side `web_search`/`web_fetch` tools are not registered; `off`
+  removes all web tools (for sandboxed/benchmark runs). Notes: provider
+  per-search fees, if any, are not modeled in cost reporting (injected tokens
+  are); sessions that used hosted search store a new `web_search_call` history
+  block that older kolega builds cannot load.
+- LSP tools can now be forced on or off for a single launch: `--lsp on|off`
+  on both the TUI and `kolega-code ask`, plus a `KOLEGA_CODE_LSP` env var,
+  resolved flag > env > settings > default-enabled. `--lsp on` overrides a
+  persisted `lsp_enabled=false` without writing back to settings. Turning LSP
+  off now removes the `lsp`/`lsp_edit` tools from the model entirely —
+  previously they stayed registered and could only answer "LSP is not
+  available" — and the Settings LSP status notes when the launch flag is
+  forcing the mode.
+- The per-session scratchpad directory is now exported as `KOLEGA_SCRATCHPAD`
+  to every shell command and eval kernel, so scripts and kernels can reach the
+  session's throwaway workspace by environment variable instead of hardcoding
+  a temp path.
+
+### Changed
+
+- Thinking now renders as a collapsed row in the TUI transcript — `● Thinking
+  · … · 1.2k words` while streaming (a live word counter, never the text),
+  flipping to `● Thought · 12s · 1.2k words` on completion; expand the row to
+  read the full reasoning. Long reasoning turns (DeepSeek flash especially) no
+  longer dominate the transcript with full-height thinking walls.
+- Resumed sessions now restore reasoning as the same collapsed thinking rows,
+  in true interleaved order with tool and hosted web-search rows: Anthropic
+  thinking text, DeepSeek flash's raw chain-of-thought, and OpenAI/ChatGPT
+  reasoning summaries all render (encrypted-only reasoning items have no
+  renderable text and are skipped). Previously reasoning vanished entirely
+  from restored transcripts.
+- The coder prompt now follows a Codex-style final-message contract: the
+  closing report leads with what was delivered and its verified state, stays
+  brief by default with structure scaled to complexity, references files by
+  path instead of re-pasting contents, and never restates the plan step by
+  step. Preambles before tool calls are tightened to a single short line
+  naming the purpose of the next action, and verification effort is bounded —
+  tool results are trusted (no re-reading a file to confirm an edit applied)
+  and verification stops once no remaining check could realistically fail.
+
+### Fixed
+
+- Hosted web-search calls now render in their true position in the TUI
+  transcript. Previously the rows mounted at the bottom and stayed pinned
+  there while post-search reasoning kept streaming into the thinking bubble
+  above them; the stream now closes the open thinking/response segment at
+  each hosted call, so reasoning after a search opens a new bubble below its
+  rows (think → search → think → answer). Resumed sessions now render hosted
+  `web_search (hosted)` rows from history too — previously they were dropped
+  from the restored transcript.
+- `ask --json` no longer emits spurious synthetic message fragments when
+  hosted web search flushes response text mid-stream: the lost-text fallback
+  now applies once at end of turn, and only when the turn produced no
+  assistant message.
+- The context gauge no longer under-reads on `deepseek-v4-flash`. DeepSeek's
+  Responses API silently re-attaches every prior round's reasoning server-side and
+  bills it as input, but the client history held none of it, so the gauge (and the
+  auto-compaction trigger) could run over 100k tokens behind the real billed
+  context on reasoning-heavy sessions. Flash's plain-text reasoning is now retained
+  in history and resent each turn — the same shape Codex replays, deduped by the
+  server so billing is unchanged — which keeps the gauge on the real number and
+  preserves chain-of-thought continuity across session restores. The retained
+  reasoning text also now appears in `ask --json` message payloads (parity with
+  Anthropic thinking text); encrypted-only reasoning from OpenAI/ChatGPT stays
+  stripped as before.
+
+### Security
+
+- Dependency bumps for advisories published 2026-08-03/04: `cryptography`
+  48.0.1 → 50.0.0 (PKCS#7 Bleichenbacher oracle CVE-2026-69247, a name-constraint
+  wildcard bypass CVE-2026-69248, and a path-building DoS CVE-2026-69249) and
+  `aiohttp` 3.14.1 → 3.14.3 (three parser advisories, including an out-of-bounds
+  heap read in the C response parser). Exception: Intel Macs stay on
+  `cryptography` 48.0.1 — every fixed release dropped Intel-mac wheels, and
+  upgrading would break the curl installer there with a Rust+OpenSSL source
+  build — so those three advisories are knowingly accepted on that legacy
+  platform only.
+
 ## 0.26.9 - 2026-08-03
 
 ### Added

{kolega_code-0.26.9 → kolega_code-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.26.9
+Version: 0.27.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/
@@ -231,6 +231,7 @@ Requires-Python: >=3.11
 Requires-Dist: anthropic==0.101.0
 Requires-Dist: beautifulsoup4==4.14.3
 Requires-Dist: cryptography==48.0.1; sys_platform == 'darwin' and platform_machine == 'x86_64'
+Requires-Dist: cryptography==50.0.0; sys_platform != 'darwin' or platform_machine != 'x86_64'
 Requires-Dist: ddgs==9.14.4
 Requires-Dist: fastapi==0.139.2
 Requires-Dist: filelock==3.20.3

{kolega_code-0.26.9 → kolega_code-0.27.0}/kolega_code/__init__.py

@@ -151,4 +151,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.26.9"
+__version__ = "0.27.0"

{kolega_code-0.26.9 → kolega_code-0.27.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.26.9"
+__version__ = "0.27.0"

{kolega_code-0.26.9 → kolega_code-0.27.0}/kolega_code/agent/baseagent.py

@@ -43,7 +43,15 @@ from kolega_code.llm.exceptions import (
 )
 from kolega_code.llm.instrumented_client import get_output_tokens
 from kolega_code.llm.ledger import HISTORY_ORIGIN, LlmCallOrigin, helper_origin, llm_call_origin
-from kolega_code.llm.models import ImageBlock, Message, MessageHistory, TextBlock, ToolCall, ToolResult
+from kolega_code.llm.models import (
+    ImageBlock,
+    Message,
+    MessageHistory,
+    TextBlock,
+    ToolCall,
+    ToolResult,
+    WebSearchCallBlock,
+)
 from kolega_code.llm.providers.models import TokenCount
 from kolega_code.llm.specs import (
     deepseek_output_token_cap,
@@ -461,6 +469,15 @@ class BaseAgent(LogMixin):
         # tool) and used by _unsupported_attachment_message to reject image
         # attachments for non-vision models with a clear message.
         self.supports_vision = bool(model_specs.get("supports_vision", False))
+        # Web tool mode: whether the provider's hosted (server-side) web_search
+        # tool is requested and whether the client-side web_search/web_fetch
+        # tools are registered. Resolved from config.web_search_mode plus the
+        # model's supports_hosted_web_search catalog flag; the ToolCollection
+        # gate reads client_web_tools_enabled, the stream call reads
+        # hosted_web_search_active.
+        self.supports_hosted_web_search = bool(model_specs.get("supports_hosted_web_search", False))
+        self.web_search_mode = getattr(self.config, "web_search_mode", "auto") or "auto"
+        self._apply_web_search_state()
 
         self.llm = context.create_llm_client(agent_name=self.agent_name)
 
@@ -487,6 +504,15 @@ class BaseAgent(LogMixin):
         self._workflow_accounting: Optional["WorkflowRunAccounting"] = None
         self._accounting_reservation: Optional["AgentReservation"] = None
         self.total_tokens_used: int = 0
+        # Hosted web-search accounting side-channel. Searched/fetched content is
+        # injected into the model's context SERVER-side (restored on replay of
+        # web_search_call items, billed as input) and never reaches the client,
+        # so tiktoken-over-history can't see it. The residual — billed input
+        # minus the client-side count of the request actually sent — measures it
+        # and is added to the gauge in count_current_context. Updated by
+        # _update_hosted_search_residual; zeroed by compress_history.
+        self._hosted_injected_tokens: int = 0
+        self._last_raw_context_count: Optional[int] = None
         # Set by a blocking PostToolUse hook to end the turn after the current tool batch.
         self._hook_end_turn = False
         self.queued_input_provider: Optional[Callable[[], Awaitable[List[QueuedUserInput]]]] = None
@@ -652,6 +678,74 @@ class BaseAgent(LogMixin):
         if callable(initialize):
             initialize()
 
+    def _apply_web_search_state(self) -> None:
+        """Resolve web_search_mode + model capability into the two live gates.
+
+        ``hosted_web_search_active`` — request the provider's server-side
+        web_search tool on main-loop stream calls. ``client_web_tools_enabled``
+        — register the client-side web_search/web_fetch tools (read by the
+        ToolCollection gate). Hosted active always excludes the client tools:
+        two search paths confuse the model and waste schema tokens.
+        """
+        mode = (self.web_search_mode or "auto").lower()
+        supported = self.supports_hosted_web_search
+        if mode == "off":
+            hosted, client = False, False
+        elif mode == "client":
+            hosted, client = False, True
+        elif mode == "hosted":
+            if not supported:
+                provider = self.primary_model_config.provider
+                logger.warning(
+                    "web_search_mode=hosted, but %s/%s has no hosted web search; falling back to the client tools",
+                    getattr(provider, "value", provider),
+                    self.primary_model_config.model,
+                )
+            hosted, client = supported, not supported
+        else:  # auto
+            hosted, client = supported, not supported
+        self.hosted_web_search_active = hosted
+        self.client_web_tools_enabled = client
+
+    def apply_web_search_mode(self, mode: str) -> None:
+        """Change the web tool mode mid-session (TUI ``/web-search``).
+
+        Mirrors :meth:`apply_gigacode`: the tool registry rebuilds per call and
+        the next stream call reads the hosted gate, so no cache invalidation is
+        needed. No prompt work — the tools carry their own affordances.
+        """
+        self.web_search_mode = (mode or "auto").lower()
+        self._apply_web_search_state()
+
+    async def _emit_hosted_tool_call(self, delta: Dict[str, Any]) -> None:
+        """Render a completed hosted web_search call as a tool_call/tool_result pair.
+
+        The call executed on the provider's servers; there is no local tool
+        invocation and the searched content never reaches the client (it is
+        injected into the model's context server-side). The shared item id
+        correlates the pair in every transcript consumer.
+        """
+        block = WebSearchCallBlock(
+            item_id=delta.get("id") or None,
+            status=delta.get("status"),
+            action=delta.get("action") or {},
+        )
+        tool_call_id = block.item_id or str(uuid.uuid4())
+        await self.send_chat_message(
+            message_type="tool_call",
+            content=f"Calling {WebSearchCallBlock.TOOL_LABEL}: {block.label()}",
+            is_streaming=False,
+            tool_description=WebSearchCallBlock.TOOL_LABEL,
+            tool_call_id=tool_call_id,
+        )
+        await self.send_chat_message(
+            message_type="tool_result",
+            content=block.result_summary(),
+            is_streaming=False,
+            tool_description=WebSearchCallBlock.TOOL_LABEL,
+            tool_call_id=tool_call_id,
+        )
+
     def apply_goal(self, condition: Optional[str], prompt_extension: Optional["PromptExtension"] = None) -> None:
         """Set, replace, or clear the active autonomous goal for this session.
 
@@ -944,12 +1038,61 @@ class BaseAgent(LogMixin):
             model=self.primary_model_config.model,
             tools=self.tool_collection.get_tool_list(),
         )
+        # Hosted web-search content lives only in the server's copy of the
+        # context (restored on replay of the web_search_call items, billed as
+        # input) — the client history has nothing to count for it. Add the
+        # residual measured from billed usage so the gauge AND the compaction
+        # check both see the true context size. Nonzero only while un-compacted
+        # web_search_call blocks exist (see _update_hosted_search_residual).
+        self._last_raw_context_count = token_count.input_tokens
+        if self._hosted_injected_tokens > 0:
+            token_count.input_tokens += self._hosted_injected_tokens
 
         # Send context update event
         await self._send_context_update(token_count)
 
         return token_count
 
+    # Provisional residual bump per hosted web-search call, applied while the
+    # search-bearing response's own billing is telescoped (a response that
+    # searched is several internal invocations billed cumulatively, so its
+    # billed−counted residual overstates the persistent injected size). The next
+    # clean response replaces the estimate with the measured residual. Probe
+    # calibration 2026-08-04 (findings/probes/hosted_web_search_probe.py):
+    # one-call persistent overhead ≈850 (deepseek) / ≈5000 (openai) tokens —
+    # 6000 overestimates safely, and overestimating only compacts early.
+    HOSTED_SEARCH_PROVISIONAL_TOKENS = 6000
+
+    def _update_hosted_search_residual(self, assistant_message: Message) -> None:
+        """Track server-injected hosted-search content from billed usage.
+
+        Search-bearing responses bump the estimate by a provisional per-call
+        constant (their own billing telescopes internal rounds, so the direct
+        residual would overshoot and could trip compaction spuriously). Clean
+        responses — single invocation, so ``billed − counted`` is exact —
+        replace it with the measurement. No-ops for sessions that never
+        searched, keeping the known ±tokenizer-drift band out of the gauge.
+        """
+        content = assistant_message.content if isinstance(assistant_message.content, list) else []
+        new_calls = sum(1 for block in content if isinstance(block, WebSearchCallBlock))
+        if new_calls:
+            self._hosted_injected_tokens += self.HOSTED_SEARCH_PROVISIONAL_TOKENS * new_calls
+            return
+        if self._hosted_injected_tokens <= 0 and not self._history_contains_hosted_search():
+            return
+        billed = (assistant_message.usage_metadata or {}).get("prompt_tokens")
+        counted = self._last_raw_context_count
+        if not isinstance(billed, int) or counted is None:
+            return
+        self._hosted_injected_tokens = max(0, billed - counted)
+
+    def _history_contains_hosted_search(self) -> bool:
+        for message in self.history:
+            content = getattr(message, "content", None)
+            if isinstance(content, list) and any(isinstance(block, WebSearchCallBlock) for block in content):
+                return True
+        return False
+
     async def _send_context_update(self, token_count: TokenCount) -> None:
         """Send an event to update the UI about current context usage."""
         usage_percentage = (token_count.input_tokens / self.model_context_length) * 100
@@ -977,6 +1120,11 @@ class BaseAgent(LogMixin):
         show progress, then recounts + emits a context_update so the gauge
         refreshes. Returns the structured outcome.
         """
+        # Compacted-away web_search_call blocks stop being replayed, so the
+        # server stops restoring their content. Reset the hosted-search residual
+        # rather than carrying a stale figure; if search blocks survive in the
+        # verbatim tail, the next clean response re-measures it.
+        self._hosted_injected_tokens = 0
 
         async def on_info(message: str) -> None:
             await self.log_info(message, sender=self.agent_name)
@@ -1455,15 +1603,13 @@ class BaseAgent(LogMixin):
     async def _run_hook_prompt(self, prompt_text: str, model_hint: Optional[str]) -> str:
         """Run a `prompt` hook: a single completion on a chosen model slot.
 
-        ``model_hint`` selects a configured slot ("fast" (default), "long", or
-        "thinking"); arbitrary model ids are not used here to keep provider/API-key
+        ``model_hint`` selects a configured slot ("fast" (default) or "long");
+        arbitrary model ids are not used here to keep provider/API-key
         pairing correct across kolega's multi-provider setup.
         """
         slot = (model_hint or "fast").lower()
         if slot in ("long", "main", "long_context"):
             model_config = self.config.long_context_config
-        elif slot == "thinking":
-            model_config = self.config.thinking_config
         else:
             model_config = self.config.fast_config
 
@@ -2093,6 +2239,7 @@ class BaseAgent(LogMixin):
                             model=self.primary_model_config.model,
                             tools=self.tool_collection.get_tool_list(),
                             thinking=self.primary_model_config.thinking_effort,
+                            hosted_web_search=self.hosted_web_search_active,
                         ),
                     )
                 async with stream_cm as stream:
@@ -2135,8 +2282,46 @@ class BaseAgent(LogMixin):
 
                             await self.on_tool_use_start(event.tool_call_delta)
 
+                        elif event.type == "hosted_tool_call" and event.tool_call_delta:
+                            # A server-side web_search call completed on the
+                            # provider's infrastructure — no local execution.
+                            # Surface it as a normal tool_call/tool_result pair
+                            # so every transcript view renders it.
+                            #
+                            # Close the current thinking/response segment first
+                            # and rotate both uuids: transcript consumers key
+                            # streamed entries by uuid, so without rotation the
+                            # post-search reasoning folds into the bubble above
+                            # these rows instead of opening a new one below
+                            # them. Guards mirror the end-of-stream flushes: an
+                            # unopened thinking segment yields nothing, while
+                            # the response flush is unconditional (an empty
+                            # complete response chunk is a documented no-op for
+                            # every consumer) so a partially streamed response
+                            # entry is never stranded incomplete by rotation.
+                            if thinking_started or current_thinking:
+                                yield {
+                                    "type": "thinking",
+                                    "content": current_thinking,
+                                    "complete": True,
+                                    "uuid": thinking_uuid,
+                                }
+                                current_thinking = ""
+                                thinking_started = False
+                                thinking_uuid = str(uuid.uuid4())
+                            yield {
+                                "type": "response",
+                                "content": current_response,
+                                "complete": True,
+                                "uuid": response_uuid,
+                            }
+                            current_response = ""
+                            response_uuid = str(uuid.uuid4())
+                            await self._emit_hosted_tool_call(event.tool_call_delta)
+
                 assistant_message = await stream.get_final_message()
                 self._normalize_freeform_tool_calls(assistant_message)
+                self._update_hosted_search_residual(assistant_message)
                 assistant_message.usage_metadata["edit_protocol"] = self.edit_protocol.value
                 response_output_tokens = get_output_tokens(
                     assistant_message.usage_metadata,

{kolega_code-0.26.9 → kolega_code-0.27.0}/kolega_code/agent/coder.py

@@ -123,27 +123,26 @@ class CoderAgent(BaseAgent, LogMixin):
             memory_enabled=memory_enabled,
         )
 
-        # Configure tool collection with custom coder agent tools
+        # Configure tool collection with custom coder agent tools. The
+        # coder_agent_tools dispatch group already omits the "coding"
+        # agent_type, so the coder never dispatches itself.
         tool_exclusions = [
             "execute_terminal_command",
             "get_tool_list",
             "log_error",
             "log_info",
-            # Exclude task-specific dispatch tools since coder shouldn't call itself or other agents
-            "dispatch_coding_agent",
         ]
         mode_value = self.agent_mode.value if isinstance(self.agent_mode, AgentMode) else self.agent_mode
         if mode_value in (AgentMode.CLI.value, AgentMode.ASK.value):
             tool_exclusions.extend(["build_backend", "build_frontend"])
-        if sub_agent:
-            # A dispatched coder must not fan out into further sub-agents
-            tool_exclusions.append("dispatch_general_agent")
 
         tool_config = ToolCollectionConfig(
             custom_tool_groups=["coder_agent_tools"],
             tool_exclusions=tool_exclusions,
             include_memory_tools=True,
             memory_write_access=True,
+            # A dispatched coder must not fan out into further general sub-agents
+            excluded_agent_types=["general"] if sub_agent else None,
         )
 
         self.tool_collection = ToolCollection(

{kolega_code-0.26.9 → kolega_code-0.27.0}/kolega_code/agent/conversation.py

@@ -22,6 +22,7 @@ from kolega_code.llm.models import (
     ThinkingBlock,
     ToolCall,
     ToolResult,
+    WebSearchCallBlock,
 )
 from kolega_code.llm.specs import prior_reasoning_is_replayable
 from kolega_code.utils import images as image_utils
@@ -336,7 +337,7 @@ def _adapt_content_blocks_for_provider(
             )
             adapted.append(adapted_block)
             changed = changed or image_changed
-        elif isinstance(block, (ThinkingBlock, RedactedThinkingBlock, ResponsesReasoningBlock)):
+        elif isinstance(block, (ThinkingBlock, RedactedThinkingBlock, ResponsesReasoningBlock, WebSearchCallBlock)):
             if _preserve_reasoning_block(
                 block,
                 source_provider=source_provider,
@@ -396,7 +397,7 @@ def _adapt_content_blocks_for_provider(
             call_protocol = (tool_call_protocols or {}).get(
                 block.tool_use_id, _source_edit_protocol(block, source_usage_metadata)
             )
-            is_hashline_read = block.name in {"read_entire_file", "read_file_section", "search_codebase"}
+            is_hashline_read = block.name == "read"
             if (
                 is_hashline_read
                 and call_protocol == "hashline_v2"
@@ -406,7 +407,7 @@ def _adapt_content_blocks_for_provider(
                 adapted.append(
                     _tool_result_with_content(
                         block,
-                        strip_hashline_read_output(block.content, search=block.name == "search_codebase"),
+                        strip_hashline_read_output(block.content, search=False),
                     )
                 )
                 changed = True