kolega-code 0.36.0__tar.gz → 0.38.0__tar.gz

{kolega_code-0.36.0 → kolega_code-0.38.0}/CHANGELOG.md

@@ -6,6 +6,71 @@ This project uses GitHub Releases for detailed generated release notes. This fil
 
 ## Unreleased
 
+## 0.38.0 - 2026-09-11
+
+### Added
+
+- **DeepSeek V4.1 Flash (released).** The finished model is served under
+  DeepSeek's canonical `deepseek-flash` id and is available as **DeepSeek V4.1
+  Flash** in the model picker, with vision and `none`/`low`/`high`/`max`
+  reasoning effort (default `high`). Verified live: 1,048,576-token context and a
+  393,216-token API output ceiling. DeepSeek's Responses API ignores the built-in
+  `web_search` tool, so this model does not advertise hosted web search.
+
+### Changed
+
+- **DeepSeek now defaults to V4.1 Flash.** `deepseek-flash` is the default model
+  (and first entry in the picker) for the DeepSeek provider, matching DeepSeek's
+  own guidance that V4.1 Flash supersedes V4 Pro on performance, cost, speed, and
+  total time. `deepseek-v4-pro` remains selectable; DeepSeek routes it to V4.1
+  Flash from September 14, 2026.
+
+### Removed
+
+- **Retired DeepSeek flash ids.** DeepSeek only serves two models now — V4.1 Flash
+  and V4 Pro — so Kolega's DeepSeek catalog lists exactly those two. The retired
+  `deepseek-v4-flash` and `deepseek-v4-flash-vision-exp` entries are gone (they
+  named nothing distinct: DeepSeek routes both to V4.1 Flash). Settings, sessions,
+  and per-role overrides that still name one of them fall back to the DeepSeek
+  default (`deepseek-flash`); naming one explicitly (`--model`,
+  `KOLEGA_CODE_MODEL`) fails with a "not available for" error.
+- **DeepSeek V4.1 Flash preview id.** The expired temporary
+  `deepseek-v4.1-flash-expires-on-0910` id is no longer selectable. Settings and
+  per-role overrides that still name it fall back to the DeepSeek default
+  (`deepseek-flash`); naming it explicitly (`--model`, `KOLEGA_CODE_MODEL`) fails
+  with a "not available for" error. Switch to `deepseek-flash`, which DeepSeek
+  serves the same model under.
+
+### Fixed
+
+- **Hosted web search no longer offered where DeepSeek stopped serving it.**
+  DeepSeek silently removed server-side `web_search` with the V4.1 release, so the
+  flash models' `/web` toggle was advertising a capability that no longer exists.
+  `deepseek-v4-pro` still executes hosted search and keeps it.
+
+## 0.37.0 - 2026-09-09
+
+### Added
+
+- **DeepSeek V4.1 Flash (preview).** DeepSeek's temporary
+  `deepseek-v4.1-flash-expires-on-0910` model is available under **DeepSeek V4.1
+  Flash (Preview, expires Sep 10)** in the model picker, with vision, hosted web
+  search, and `none`/`low`/`high`/`max` reasoning effort (default `high`). It is
+  not the default and is not aliased to a stable model; the ID expires on
+  September 10, 2026, after which an available stable model must be selected.
+
+### Fixed
+
+- Pin PDFium and the Intel Python 3.11/3.12 ONNX Runtime dependency to restore
+  compatible wheel selection on macOS Monterey for both the installer and direct
+  package installs. Intel Monterey requires Python 3.11 or 3.12.
+- Settings saves are merged with concurrent writers instead of replacing the whole
+  file, so a long-running instance can no longer drop a gateway token or API key
+  another process saved after it started.
+- `kolega-code gateway status` now reports an installed background service that
+  is failing to start (service state, start count, last exit code, log path)
+  instead of only printing "not running".
+
 ## 0.36.0 - 2026-09-07
 
 ### Added

{kolega_code-0.36.0 → kolega_code-0.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.36.0
+Version: 0.38.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/
@@ -47,6 +47,7 @@ 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: 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'
 Requires-Dist: openai==2.46.0
 Requires-Dist: packaging==25.0
@@ -56,6 +57,7 @@ Requires-Dist: playwright==1.59.0
 Requires-Dist: psutil==7.2.2
 Requires-Dist: pydantic==2.13.4
 Requires-Dist: pygments==2.20.0
+Requires-Dist: pypdfium2==5.11.0
 Requires-Dist: python-dotenv==1.2.2
 Requires-Dist: pyyaml==6.0.3
 Requires-Dist: readability-lxml==0.8.4.1

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/__init__.py

@@ -174,4 +174,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.36.0"
+__version__ = "0.38.0"

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/agent/__init__.py

@@ -51,4 +51,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.36.0"
+__version__ = "0.38.0"

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/agent/compression.py

@@ -157,7 +157,7 @@ class HistoryCompressor:
     # Don't bother summarizing a trivially short prefix.
     MIN_PREFIX_TO_SUMMARIZE = 3
     # Cap the summary length. The prompt targets ~600 words, but reasoning
-    # models (deepseek-v4-flash Responses, etc.) can consume the entire budget
+    # models (DeepSeek Responses models, etc.) can consume the entire budget
     # on chain-of-thought and leave no room for text output, producing an empty
     # summary. A generous ceiling gives reasoning headroom while still staying
     # well under the model's full completion budget.

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/cli/gateway.py

@@ -33,6 +33,7 @@ from kolega_code.gateway.service import (
     install_service,
     is_service_installed,
     restart_service,
+    service_state_summary,
     uninstall_service,
 )
 
@@ -290,6 +291,7 @@ def _gateway_status(config: GatewayConfig) -> int:
     if payload is not None:
         # A heartbeat from a process that no longer exists (e.g. SIGKILLed).
         print(f"gateway: not running (stale heartbeat from pid {payload.get('pid')})")
+        _print_service_state(config)
         return 0
     lock = FileLock(str(config.state_dir / LOCK_FILE_NAME))
     try:
@@ -303,9 +305,20 @@ def _gateway_status(config: GatewayConfig) -> int:
         return 0
     lock.release()
     print(f"gateway: not running (state: {config.state_dir})")
+    _print_service_state(config)
     return 0
 
 
+def _print_service_state(config: GatewayConfig) -> None:
+    summary = service_state_summary()
+    if summary is None:
+        return
+    print(f"  service: {summary}")
+    log_path = config.state_dir / "gateway.log"
+    if log_path.exists():
+        print(f"  log: {log_path}")
+
+
 def _pid_alive(pid: Any) -> bool:
     if not isinstance(pid, int) or pid <= 0:
         return False

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/cli/provider_registry.py

@@ -70,9 +70,8 @@ MODEL_LABELS: dict[str, str] = {
     "kimi-for-coding": "Kimi for Coding",
     "kimi-for-coding-highspeed": "Kimi for Coding (HighSpeed)",
     # DeepSeek
+    "deepseek-flash": "DeepSeek V4.1 Flash",
     "deepseek-v4-pro": "DeepSeek V4 Pro",
-    "deepseek-v4-flash": "DeepSeek V4 Flash",
-    "deepseek-v4-flash-vision-exp": "DeepSeek V4 Flash Vision (Exp)",
     # Z.AI (GLM Coding Plan)
     "glm-5.3": "GLM-5.3",
     "glm-5.3-flash": "GLM-5.3 Flash",
@@ -163,7 +162,7 @@ MODEL_LABELS: dict[str, str] = {
 # "available set is everything, default pick is curated" split.
 PROVIDER_DEFAULT_MODEL: dict[ModelProvider, str] = {
     ModelProvider.MOONSHOT: "kimi-k3",
-    ModelProvider.DEEPSEEK: "deepseek-v4-pro",
+    ModelProvider.DEEPSEEK: "deepseek-flash",
     ModelProvider.ZAI: "glm-5.3",
     ModelProvider.KIMI_CODING: "kimi-for-coding",
     ModelProvider.ANTHROPIC: "claude-opus-5",
@@ -188,7 +187,7 @@ PROVIDER_DEFAULT_MODEL: dict[ModelProvider, str] = {
 UI_DEFAULT_PROVIDER = ModelProvider.MOONSHOT.value
 UI_DEFAULT_MODEL = "kimi-k3"
 MOONSHOT_K26_MODEL = "kimi-k2.6"
-DEEPSEEK_DEFAULT_MODEL = "deepseek-v4-pro"
+DEEPSEEK_DEFAULT_MODEL = "deepseek-flash"
 
 
 @dataclass(frozen=True)

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/cli/settings.py

@@ -2,11 +2,15 @@
 
 from __future__ import annotations
 
+import copy
 import json
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Optional
 
+from filelock import FileLock
+from filelock import Timeout as FileLockTimeout
+
 from kolega_code.local_state import write_private_text
 from kolega_code.llm.specs.custom_endpoints import (
     API_STYLES,
@@ -33,6 +37,41 @@ class SettingsStoreError(RuntimeError):
     """Raised when CLI settings cannot be loaded or saved."""
 
 
+SETTINGS_LOCK_TIMEOUT_SECONDS = 10.0
+
+
+def _merge_settings_documents(
+    base: dict[str, Any],
+    current: dict[str, Any],
+    on_disk: dict[str, Any],
+) -> dict[str, Any]:
+    """Apply one writer's changes on top of the current document.
+
+    ``base`` is the state the writer loaded, so keys it did not touch keep the
+    on-disk value and a stale writer cannot revert another process's change.
+    Nested dicts merge key by key, and keys the writer never saw survive.
+    """
+    merged: dict[str, Any] = {}
+    for key in set(base) | set(current) | set(on_disk):
+        if key not in current:
+            if key in base:
+                continue
+            if key in on_disk:
+                merged[key] = on_disk[key]
+            continue
+        if key in base and base[key] == current[key]:
+            merged[key] = on_disk[key] if key in on_disk else current[key]
+            continue
+        if key not in base and current[key] is None and key in on_disk:
+            merged[key] = on_disk[key]
+            continue
+        if isinstance(base.get(key), dict) and isinstance(current[key], dict) and isinstance(on_disk.get(key), dict):
+            merged[key] = _merge_settings_documents(base[key], current[key], on_disk[key])
+            continue
+        merged[key] = current[key]
+    return merged
+
+
 def _coerce_model_entries(raw: object) -> dict[str, dict]:
     """Normalize a stored key -> {provider, model, ...} mapping.
 
@@ -272,6 +311,9 @@ class CliSettings:
     # Additive optional field — absent in older files -> empty mapping.
     custom_endpoints: dict[str, dict] = field(default_factory=dict)
     schema_version: int = SETTINGS_SCHEMA_VERSION
+    # The document this instance was loaded from, used as the merge base by
+    # SettingsStore.save(). Never serialized.
+    _merge_base: Optional[dict[str, Any]] = field(default=None, repr=False, compare=False)
 
     @classmethod
     def from_dict(cls, data: dict) -> "CliSettings":
@@ -452,12 +494,47 @@ class SettingsStore:
 
     def load(self) -> CliSettings:
         if not self.path.exists():
-            return CliSettings()
+            settings = CliSettings()
+            settings._merge_base = copy.deepcopy(settings.to_dict())
+            return settings
         try:
-            return CliSettings.from_dict(json.loads(self.path.read_text(encoding="utf-8")))
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+            settings = CliSettings.from_dict(data)
         except json.JSONDecodeError as exc:
             raise SettingsStoreError(f"Settings file is not valid JSON: {self.path}") from exc
+        # The merge base is what this process understood, not the raw file:
+        # a key it never saw (newer schema, hand-edit) must survive its save.
+        settings._merge_base = copy.deepcopy(settings.to_dict())
+        if isinstance(data, dict) and "schema_version" in data:
+            settings._merge_base["schema_version"] = data["schema_version"]
+        return settings
 
     def save(self, settings: CliSettings) -> None:
-        payload = json.dumps(settings.to_dict(), indent=2, sort_keys=True)
-        write_private_text(self.path, payload + "\n")
+        """Write this instance's changes, keeping concurrent writers' fields."""
+        lock = FileLock(f"{self.path}.lock")
+        try:
+            lock.acquire(timeout=SETTINGS_LOCK_TIMEOUT_SECONDS)
+        except FileLockTimeout as exc:
+            raise SettingsStoreError(f"Timed out locking the settings file: {self.path}") from exc
+        try:
+            merged = self._merged_document(settings)
+            payload = json.dumps(merged, indent=2, sort_keys=True)
+            write_private_text(self.path, payload + "\n")
+        finally:
+            lock.release()
+        settings._merge_base = copy.deepcopy(merged)
+
+    def _merged_document(self, settings: CliSettings) -> dict[str, Any]:
+        current = settings.to_dict()
+        if settings._merge_base is None:
+            return current
+        return _merge_settings_documents(settings._merge_base, current, self._read_document())
+
+    def _read_document(self) -> dict[str, Any]:
+        try:
+            raw = json.loads(self.path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            return {}
+        except (json.JSONDecodeError, OSError) as exc:
+            raise SettingsStoreError(f"Settings file is not valid JSON: {self.path}") from exc
+        return raw if isinstance(raw, dict) else {}

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/gateway/service.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import os
 import plistlib
+import re
 import shlex
 import shutil
 import subprocess
@@ -214,6 +215,41 @@ def run_service_command(argv: list[str]) -> subprocess.CompletedProcess[str] | N
         return None
 
 
+def service_state_summary(
+    *,
+    systemd_dir: Optional[Path] = None,
+    launchd_dir: Optional[Path] = None,
+    platform: Optional[str] = None,
+) -> Optional[str]:
+    """One line of service-manager state for an installed gateway, else None.
+
+    ``gateway status`` uses this to explain a service that is installed but not
+    running, which the daemon's own status file cannot show.
+    """
+    platform = platform if platform is not None else sys.platform
+    if not is_service_installed(systemd_dir=systemd_dir, launchd_dir=launchd_dir, platform=platform):
+        return None
+    if platform == "darwin":
+        proc = run_service_command(["launchctl", "print", f"gui/{os.getuid()}/{LAUNCHD_LABEL}"])
+        if proc is None or proc.returncode != 0:
+            return "launchd agent installed but not loaded"
+        output = proc.stdout or ""
+        parts: list[str] = []
+        state = re.search(r"^\s*state = (.+)$", output, re.MULTILINE)
+        if state:
+            parts.append(f"state {state.group(1).strip()}")
+        runs = re.search(r"^\s*runs = (\d+)$", output, re.MULTILINE)
+        if runs:
+            parts.append(f"{runs.group(1)} starts")
+        last_exit = re.search(r"^\s*last exit code = (\d+)$", output, re.MULTILINE)
+        if last_exit:
+            parts.append(f"last exit code {last_exit.group(1)}")
+        return "launchd agent " + (", ".join(parts) if parts else "loaded")
+    proc = run_service_command(["systemctl", "--user", "is-active", SERVICE_NAME])
+    state_text = (proc.stdout or "").strip() if proc is not None else ""
+    return f"systemd unit {state_text or 'unknown'}"
+
+
 def restart_service(
     *,
     unit_path: Optional[Path] = None,

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/llm/providers/deepseek_responses.py

@@ -1,6 +1,6 @@
 """DeepSeek provider that speaks the **Responses API** (``/responses``).
 
-The whole DeepSeek catalog (``deepseek-v4-pro`` and ``deepseek-v4-flash``) speaks
+The whole DeepSeek catalog (``deepseek-flash`` and ``deepseek-v4-pro``) speaks
 the Responses API, so the ``deepseek`` provider routes here wholesale from
 ``LLMClient._provider_class`` (no model-name branching). DeepSeek models hosted on
 other providers (Fireworks/OpenRouter/Ollama-Cloud) still use Chat Completions via
@@ -49,7 +49,7 @@ from .models import GenerationParams
 from .responses_common import ResponsesProviderBase
 
 DEFAULT_BASE_URL = "https://api.deepseek.com"
-DEFAULT_MODEL = "deepseek-v4-flash"
+DEFAULT_MODEL = "deepseek-flash"
 
 
 class DeepSeekResponsesProvider(ResponsesProviderBase):

{kolega_code-0.36.0 → kolega_code-0.38.0}/kolega_code/llm/specs/accessors.py

@@ -201,8 +201,10 @@ def preferred_edit_protocol(provider: str, model_name: str) -> Optional[str]:
 # takes its catalog value instead.
 DEEPSEEK_WIRE_OUTPUT_CAP = 64000
 
-# Routes whose catalog max_completion_tokens is itself the real ceiling.
-_UNCLAMPED_DEEPSEEK_ROUTES = {("deepseek", "deepseek-v4-flash"), ("deepseek", "deepseek-v4-flash-vision-exp")}
+# Routes that use the catalog output budget without the legacy Pro/chat clamp.
+_UNCLAMPED_DEEPSEEK_ROUTES = {
+    ("deepseek", "deepseek-flash"),
+}
 
 
 def is_deepseek_model(model_name: str) -> bool:

kolega_code-0.38.0/kolega_code/llm/specs/catalog/deepseek.py

@@ -0,0 +1,99 @@
+from kolega_code.llm.specs.types import ThinkingEffortSpec
+
+# max_completion_tokens is the MEASURED per-response output ceiling, not
+# DeepSeek's published 384000. Probed 2026-08-03 by
+# tests/agent/llm/test_deepseek_output_cap_live.py:
+#   - deepseek-v4-pro (chat), uncapped: the server cuts the stream at exactly
+#     65536 output tokens, reported honestly as finish_reason="length".
+#   - deepseek-v4-flash (Responses), uncapped: no hard cut observed — the model
+#     SELF-CENSORS ~7.4k tokens in ("response would exceed the maximum output
+#     length allowed for this chat interface") with a clean status="completed".
+#     With an explicit max_output_tokens=64000 it streams the full 64000 and
+#     reports the cap hit honestly (status="incomplete"/max_output_tokens).
+#   - Over-ceiling caps (384000) are accepted silently on both paths.
+# flash is 384000 (corrected from 65536, which was pro's measured chat ceiling
+# assumed to apply here): those probes only measured visible output, while a
+# reasoning-heavy call was later measured running to 112990 tokens in a single
+# Responses call.
+# pro never sends this value raw: the Responses path clamps to
+# DEEPSEEK_WIRE_OUTPUT_CAP=64000 (specs/accessors.py) so the client cap fires
+# before the server ceiling and truncation is reported honestly. flash passes
+# through.
+#
+# INSERTION ORDER IS LOAD-BEARING: the first entry is what the Settings model
+# picker shows first and what a provider switch falls back to
+# (ui_model_options(provider)[0]); it must stay in sync with
+# PROVIDER_DEFAULT_MODEL[DEEPSEEK] in cli/provider_registry.py.
+DEEPSEEK_SPECS = {
+    # Released DeepSeek Flash (V4.1), served under the canonical `deepseek-flash`, and
+    # the provider default. Verified live on /responses 2026-09-10: the retired preview
+    # ID (`deepseek-v4.1-flash-expires-on-0910`) as well as the older `deepseek-v4-flash`
+    # and `deepseek-v4-flash-vision-exp` aliases all now answer as
+    # `model="deepseek-flash"`, and `/models` lists exactly `deepseek-flash` and
+    # `deepseek-v4-pro`; a versioned `deepseek-v4.1-flash` is rejected ("The supported
+    # API model names are ..."). Vision (image input), function calls, and
+    # none/low/high/max reasoning effort all work on this route.
+    # NO hosted web search: DeepSeek removed it silently with the V4.1 release. Their
+    # Responses guide said "web_search / web_search_2025_08_26: Supported, executed on
+    # the server side" and listed {"type": "web_search"} under tool_choice on
+    # 2026-09-09; by 2026-09-10 the same rows read "web_search / file_search /
+    # code_interpreter / computer_use / mcp / other built-in tools: Ignored", with
+    # web_search dropped from tool_choice and its streaming events deleted. Nothing on
+    # /updates, /news, the docs home, or the FAQ mentions the removal. Live probes on
+    # 2026-09-10 returned zero web_search_call items while the model answered that it
+    # has no such tool (at effort=high it emitted bogus tool-call XML as text instead).
+    # Requests with the tool declared are accepted and silently do nothing, so Kolega
+    # must not advertise the /web toggle here. Replayed web_search_call items from
+    # older requests are still restored into context, per the same guide.
+    # Context measured at 1048576 tokens (oversized request -> "This model's maximum
+    # context length is 1048576 tokens"); keep the Flash-family 1000000 budget so the
+    # window_minus_output input budget retains margin under the hard ceiling.
+    # max_output_tokens above 393216 is rejected ("the valid range of max_tokens is
+    # [1, 393216]"), so the conservative 384000 output budget stands.
+    # Reasoning mechanics (inherited from the retired V4 Flash entries this id replaces,
+    # and still the shape this backend serves): effort must ride the Responses
+    # `reasoning` block, not the Chat-Completions `reasoning_effort` field the shared
+    # builder ignores, and this mode excludes flash from the flat reasoning_content
+    # replay path — reasoning comes back as Responses reasoning ITEMS instead. The
+    # endpoint returns no reasoning.encrypted_content (the include param is silently
+    # ignored) but exposes raw chain-of-thought as plain reasoning_text content, which
+    # the stream wrapper retains and resends next turn (mirroring Codex) so the context
+    # gauge counts it like any other content. The backend ALSO re-attaches prior CoT
+    # server-side keyed on its own function_call call_ids, billing it as input and
+    # deduping explicit copies (verified live 2026-08-04 on V4 Flash); reasoning-bearing
+    # replays with a foreign call_id 400 with "reasoning_text must be passed back",
+    # while minimal single-round histories with foreign ids are tolerated.
+    ("deepseek", "deepseek-flash"): {
+        "context_length": 1000000,
+        "max_completion_tokens": 384000,
+        "input_budget": "window_minus_output",
+        "default_temperature": 1.0,
+        "supports_vision": True,
+        "supports_hosted_web_search": False,
+        "preferred_edit_protocol": "claude_code",
+        "thinking_effort": ThinkingEffortSpec(
+            options=("none", "low", "high", "max"),
+            default="high",
+            mode="openai_responses_reasoning",
+        ),
+    },
+    ("deepseek", "deepseek-v4-pro"): {
+        "context_length": 1000000,
+        "max_completion_tokens": 65536,
+        "input_budget": "window_minus_output",
+        "default_temperature": 1.0,
+        "supports_vision": False,
+        # Hosted search still works on the V4 Pro model — re-verified live 2026-09-10
+        # (probe A body -> ws_calls=1, real answer), and it is the last first-party
+        # route that executes it. NOTE: from 12:00 Beijing Time 2026-09-14 DeepSeek
+        # routes deepseek-v4-pro requests to V4.1 Flash, whose architecture has no
+        # server-side web search; re-check this flag and the /web toggle after that.
+        "supports_hosted_web_search": True,
+        "preferred_edit_protocol": "claude_code",
+        "thinking_effort": ThinkingEffortSpec(
+            options=("none", "low", "high", "max"),
+            default="high",
+            mode="openai_responses_reasoning",
+        ),
+    },
+}

{kolega_code-0.36.0 → kolega_code-0.38.0}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kolega-code"
-version = "0.36.0"
+version = "0.38.0"
 description = "Multi-agent coding in the terminal"
 readme = "README.md"
 license = "BUSL-1.1"
@@ -69,6 +69,9 @@ dependencies = [
     "markitdown[docx,pdf,pptx,xls,xlsx]==0.1.6",
     "mcp==1.28.1",
     "nest-asyncio==1.6.0",
+    # Magika: 1.19.2 has Monterey-compatible Intel wheels for Python 3.11/3.12.
+    # It has no Python 3.13 wheels; that interpreter requires newer macOS.
+    "onnxruntime==1.19.2; sys_platform == 'darwin' and platform_machine == 'x86_64' and python_version < '3.13'",
     # Magika's cross-platform resolution selects onnxruntime 1.20.1, which has no CPython 3.14 wheels.
     "onnxruntime==1.27.0; python_version >= '3.14' and sys_platform != 'win32'",
     "openai==2.46.0",
@@ -78,6 +81,9 @@ dependencies = [
     "playwright==1.59.0",
     "psutil==7.2.2",
     "pydantic==2.13.4",
+    # MarkItDown/pdfplumber: newer PDFium wheels require macOS 13.
+    # Preserve Intel macOS 12 installs; bumps must pass the Monterey wheel guard.
+    "pypdfium2==5.11.0",
     "python-dotenv==1.2.2",
     # Load-bearing for the web UI: code highlighting is generated with the same
     # Pygments styles the TUI renders with, so both stay identical.

kolega_code-0.36.0/kolega_code/llm/specs/catalog/deepseek.py

@@ -1,82 +0,0 @@
-from kolega_code.llm.specs.types import ThinkingEffortSpec
-
-# max_completion_tokens is the MEASURED per-response output ceiling, not
-# DeepSeek's published 384000. Probed 2026-08-03 by
-# tests/agent/llm/test_deepseek_output_cap_live.py:
-#   - deepseek-v4-pro (chat), uncapped: the server cuts the stream at exactly
-#     65536 output tokens, reported honestly as finish_reason="length".
-#   - deepseek-v4-flash (Responses), uncapped: no hard cut observed — the model
-#     SELF-CENSORS ~7.4k tokens in ("response would exceed the maximum output
-#     length allowed for this chat interface") with a clean status="completed".
-#     With an explicit max_output_tokens=64000 it streams the full 64000 and
-#     reports the cap hit honestly (status="incomplete"/max_output_tokens).
-#   - Over-ceiling caps (384000) are accepted silently on both paths.
-# flash is 384000 (corrected from 65536, which was pro's measured chat ceiling
-# assumed to apply here): those probes only measured visible output, while a
-# reasoning-heavy call was later measured running to 112990 tokens in a single
-# Responses call.
-# pro never sends this value raw: the Responses path clamps to
-# DEEPSEEK_WIRE_OUTPUT_CAP=64000 (specs/accessors.py) so the client cap fires
-# before the server ceiling and truncation is reported honestly. flash passes
-# through.
-DEEPSEEK_SPECS = {
-    ("deepseek", "deepseek-v4-pro"): {
-        "context_length": 1000000,
-        "max_completion_tokens": 65536,
-        "input_budget": "window_minus_output",
-        "default_temperature": 1.0,
-        "supports_vision": False,
-        "supports_hosted_web_search": True,
-        "preferred_edit_protocol": "claude_code",
-        "thinking_effort": ThinkingEffortSpec(
-            options=("none", "low", "high", "max"),
-            default="high",
-            mode="openai_responses_reasoning",
-        ),
-    },
-    # deepseek-v4-flash speaks the Responses API (see DeepSeekResponsesProvider), so its
-    # reasoning effort must be emitted as the Responses `reasoning` block rather than the
-    # Chat-Completions `reasoning_effort` field the shared Responses request builder ignores.
-    # This mode also correctly excludes flash from the flat reasoning_content replay path:
-    # flash's reasoning rides in Responses reasoning ITEMS instead. The endpoint returns no
-    # reasoning.encrypted_content (the include param is silently ignored) but exposes the
-    # raw chain-of-thought as plain reasoning_text content, which the stream wrapper
-    # retains and resends next turn (mirroring Codex, the client this endpoint was adapted
-    # for) — so the context gauge counts it from the history like any other content. The
-    # backend ALSO restores prior CoT server-side keyed on its own function_call call_ids,
-    # billing it as input and deduping explicit copies (verified live 2026-08-04); deep
-    # reasoning-bearing replays with a foreign call_id 400 with "reasoning_text must be
-    # passed back", minimal single-round histories with foreign ids are tolerated.
-    ("deepseek", "deepseek-v4-flash"): {
-        "context_length": 1000000,
-        "max_completion_tokens": 384000,
-        "input_budget": "window_minus_output",
-        "default_temperature": 1.0,
-        "supports_vision": False,
-        # /responses executes {"type": "web_search"} server-side (search +
-        # open_page) and restores the searched content on replay of the
-        # web_search_call items, billed as input (verified live 2026-08-04,
-        # findings/probes/hosted_web_search_probe.py).
-        "supports_hosted_web_search": True,
-        "preferred_edit_protocol": "claude_code",
-        "thinking_effort": ThinkingEffortSpec(
-            options=("none", "low", "high", "max"),
-            default="high",
-            mode="openai_responses_reasoning",
-        ),
-    },
-    ("deepseek", "deepseek-v4-flash-vision-exp"): {
-        "context_length": 1000000,
-        "max_completion_tokens": 384000,
-        "input_budget": "window_minus_output",
-        "default_temperature": 1.0,
-        "supports_vision": True,
-        "supports_hosted_web_search": True,
-        "preferred_edit_protocol": "claude_code",
-        "thinking_effort": ThinkingEffortSpec(
-            options=("none", "low", "high", "max"),
-            default="high",
-            mode="openai_responses_reasoning",
-        ),
-    },
-}