python-agent-harness 1.5.3__tar.gz → 1.5.4.1__tar.gz

{python_agent_harness-1.5.3/python_agent_harness.egg-info → python_agent_harness-1.5.4.1}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.3
+Version: 1.5.4.1
 Summary: A lightweight, hackable mini-OpenCode written in Python.
+Author: huming
+License-Expression: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -143,6 +145,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
       "model": "qwen3.5-coder"
     }
   },
+  "context_windows": {
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
+    "deepseek-v4*": 1000000
+  },
   "subagent_llm": {
     "profile": null,
     "base_url": null,
@@ -182,6 +188,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 - **`llm`** — main LLM configuration. Optional keys include `backend`, `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `run --no-stream` overrides `stream`.
 - **`models`** — named LLM profiles for runtime switching with `/model`. A profile is a partial settings dictionary; unset keys inherit from the main `llm`. `default` restores the main LLM configuration.
+- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g., `deepseek-v4*`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
 - **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
 - **`paths.context_path` / `paths.skill_path`** — locations from which to load context files and skills. When unset, the project-local `<project>/contexts` and `<project>/skills` directories are used.
 - **`mcp.servers`** — MCP server configuration. Requires the `[mcp]` extra. Each server supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, and `enabled`.

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/README.md

@@ -122,6 +122,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
       "model": "qwen3.5-coder"
     }
   },
+  "context_windows": {
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
+    "deepseek-v4*": 1000000
+  },
   "subagent_llm": {
     "profile": null,
     "base_url": null,
@@ -161,6 +165,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 - **`llm`** — main LLM configuration. Optional keys include `backend`, `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `run --no-stream` overrides `stream`.
 - **`models`** — named LLM profiles for runtime switching with `/model`. A profile is a partial settings dictionary; unset keys inherit from the main `llm`. `default` restores the main LLM configuration.
+- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g., `deepseek-v4*`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
 - **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
 - **`paths.context_path` / `paths.skill_path`** — locations from which to load context files and skills. When unset, the project-local `<project>/contexts` and `<project>/skills` directories are used.
 - **`mcp.servers`** — MCP server configuration. Requires the `[mcp]` extra. Each server supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, and `enabled`.

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/pyproject.toml

@@ -4,10 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.3"
+version = "1.5.4.1"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 readme = "README.md"
 requires-python = ">=3.11"
+authors = [
+    { name = "huming" }
+]
+license = 'MIT'
+license-files = ["LICENSE"]
 dependencies = [
     "rich>=13.0",
     "httpx>=0.27",

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/__init__.py

@@ -5,7 +5,7 @@ from .mcp.manager import MCPManager
 from .models import AgentMode, Message, ToolCall, ToolSpec
 from .session import Session
 
-__version__ = "1.5.3"
+__version__ = "1.5.4.1"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/cli.py

@@ -221,6 +221,14 @@ def cmd_config(args: argparse.Namespace) -> int:
             print(f"  {name}: model={model_name}, base_url={base_url}")
     else:
         print("models: (none configured — add a 'models' section to use /model)")
+    # Show context-window overrides
+    context_windows = config.load_context_windows_config(args.path)
+    if context_windows:
+        print("context_windows:")
+        for pattern, size in context_windows:
+            print(f"  {pattern}: {size}")
+    else:
+        print("context_windows: (none configured — built-in table in config.py applies)")
     return 0
 
 

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/client.py

@@ -11,6 +11,7 @@ import contextlib
 import json
 import os
 import random
+import socket as _socket
 import threading
 import time
 import uuid
@@ -211,6 +212,8 @@ class Client:
         )
         self._config_path = config_path
         self._http = httpx.Client(timeout=timeout, verify=self.verify)
+        # Resolve context window for this model (API discovery + fallbacks)
+        self._context_window = None  # lazy-loaded
         # True while the in-flight request was aborted (Ctrl-C): a
         # connection error on an aborted request must NOT be retried —
         # the user asked to stop.  Cleared at the start of each chat()
@@ -224,6 +227,26 @@ class Client:
             else (_llm_log_path() if config.LLM_LOG_ENABLED else None)
         )
 
+    @property
+    def context_window(self) -> int:
+        """Get the context window for this model.
+
+        Resolution order: config-file ``context_windows`` overrides
+        (via ``config.get_context_window_for_model``) -> CONTEXT_WINDOWS
+        pattern match -> DEFAULT_CONTEXT_WINDOW.  The resolved value is
+        cached for the life of the client.
+        """
+        if self._context_window is None:
+            try:
+                self._context_window = config.get_context_window_for_model(
+                    self.model, config_path=self._config_path
+                )
+            except Exception:
+                # a malformed context_windows section must not break
+                # the loop: cache the safe default
+                self._context_window = config.DEFAULT_CONTEXT_WINDOW
+        return self._context_window
+
     def close(self) -> None:
         self._http.close()
 
@@ -810,8 +833,6 @@ def _abort_inflight_sockets(client: httpx.Client) -> None:
     down an idle socket is harmless (the pool is closed right after
     anyway); any failure is ignored (best effort).
     """
-    import socket as _socket
-
     pool = getattr(getattr(client, "_transport", None), "_pool", None)
     for conn in getattr(pool, "_connections", None) or ():
         try:

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/commands.py

@@ -17,6 +17,7 @@ Tool availability per command:
 from __future__ import annotations
 
 import re
+import subprocess
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -35,8 +36,6 @@ def _substitute(text: str, path: str, extra: str | None) -> str:
 
 def _project_root(cwd: str) -> str:
     """Best-effort project root (git dir or parent with AGENTS.md)."""
-    import subprocess
-
     d = Path(cwd).resolve()
     try:
         out = subprocess.run(

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/config.py

@@ -5,34 +5,43 @@ Mirrors the defcustom defaults of the Emacs gptel-agent-harness.
 
 from __future__ import annotations
 
+import fnmatch
 import json
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-if TYPE_CHECKING:
-    from .mcp.config import MCPConfig
+from .mcp.config import MCPConfig
 
 # ---- context management -------------------------------------------------
 CONTEXT_TRIGGER = 0.70
 
 # Entries are matched in order (first match wins): put more specific
-# patterns before general ones.
+# patterns before general ones. Supports wildcards (*).  Trailing `*`
+# on explicit entries preserves prefix matching for suffixed model
+# names (e.g. "deepseek-v4-flash" -> deepseek-v4*), matching the
+# legacy substring behavior.
 CONTEXT_WINDOWS: list[tuple[str, int]] = [
-    ("gpt-5-mini", 128_000),
-    ("gpt-5", 400_000),
-    ("gpt-oss-120b", 128_000),
-    ("claude", 200_000),
-    ("deepseek-v3", 128_000),
-    ("deepseek-v4", 1_000_000),
-    ("qwen3.5", 131_072),
-    ("qwen3.6", 262_144),
-    ("qwen3.8", 262_144),
-    ("qwen3", 131_072),
-    ("glm-5.2", 1_000_000),
-    ("glm-5.1", 128_000),
-    ("kimi-k2.7", 256_000),
-    ("kimi", 128_000),
+    ("gpt-5-mini*", 128_000),
+    ("gpt-5*", 400_000),
+    ("gpt-oss-120b*", 128_000),
+    ("claude*", 200_000),
+    ("deepseek-v3*", 128_000),
+    ("deepseek-v4*", 1_000_000),
+    ("qwen3.5*", 131_072),
+    ("qwen3.6*", 262_144),
+    ("qwen3.8*", 262_144),
+    ("qwen3*", 131_072),
+    ("glm-5.2*", 1_000_000),
+    ("glm-5.1*", 128_000),
+    ("kimi-k2.7*", 256_000),
+    ("kimi*", 128_000),
+    # Wildcard fallbacks for unknown models
+    ("gpt-*", 128_000),
+    ("claude-*", 200_000),
+    ("deepseek-*", 128_000),
+    ("qwen-*", 128_000),
+    ("glm-*", 128_000),
+    ("kimi-*", 128_000),
 ]
 DEFAULT_CONTEXT_WINDOW = 128_000
 
@@ -223,6 +232,10 @@ CONFIG_TEMPLATE = """\
       "model": "gpt-5-mini"
     }}
   }},
+  "context_windows": {{
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py. Remove this section to use the built-in table.",
+    "deepseek-v4*": 1000000
+  }},
   "subagent_llm": {{
     "_comment": "Optional overrides for sub-agent (Agent tool) requests, e.g. a cheaper model. Every key is optional; unset keys inherit the main llm settings above. Set 'profile' to a name from the 'models' section to reuse a model profile (profile settings win over explicit keys below).",
     "profile": null,
@@ -428,8 +441,6 @@ def load_mcp_config(path: str | os.PathLike | None = None) -> MCPConfig:
     ``mcp`` SDK is only needed when servers are actually configured and
     connected — reading the config never requires it.
     """
-    from .mcp.config import MCPConfig
-
     data = _read_config(path)
     section = data.get("mcp") or {}
     if not isinstance(section, dict):
@@ -462,3 +473,80 @@ def load_models_config(path: str | os.PathLike | None = None) -> dict[str, dict]
 
 def mask_secret(value: str | None) -> str:
     return "****" if value else "(unset)"
+
+
+def _match_context_window(model: str) -> int | None:
+    """Match model name against CONTEXT_WINDOWS patterns (supports wildcards).
+
+    Args:
+        model: The model ID to match (e.g., "gpt-5-mini", "claude-3-opus")
+
+    Returns:
+        The context window size if matched, None otherwise
+    """
+    lowered = model.lower()
+    for pattern, size in CONTEXT_WINDOWS:
+        if fnmatch.fnmatch(lowered, pattern.lower()):
+            return size
+    return None
+
+
+def load_context_windows_config(
+    path: str | os.PathLike | None = None,
+) -> list[tuple[str, int]]:
+    """Load per-model context-window overrides from the config file.
+
+    Reads the ``context_windows`` object: a mapping of model names or
+    fnmatch patterns (matched in file order, first match wins) to token
+    counts.  Keys starting with ``_`` are comments and skipped.  A
+    missing file, missing section, or unreadable JSON yields ``[]``
+    (callers fall back to the built-in table); a malformed section or
+    non-integer size raises ValueError so config errors surface.
+    """
+    try:
+        data = _read_config(path)
+    except ValueError:
+        return []
+    section = data.get("context_windows") or {}
+    if not isinstance(section, dict):
+        raise ValueError(f"config file {_config_path(path)}: context_windows must be an object")
+    entries: list[tuple[str, int]] = []
+    for pattern, size in section.items():
+        if pattern.startswith("_"):
+            continue
+        if isinstance(size, bool) or not isinstance(size, int):
+            raise ValueError(
+                f"config file {_config_path(path)}: context_windows.{pattern} must be an integer"
+            )
+        entries.append((pattern, size))
+    return entries
+
+
+def get_context_window_for_model(
+    model: str,
+    config_path: str | os.PathLike | None = None,
+) -> int:
+    """Get the context window for MODEL: config-file overrides, then
+    the built-in table, then the default.
+
+    The config file's ``context_windows`` object (user overrides) is
+    consulted first (fnmatch over its patterns, first match wins,
+    case-insensitive); then the CONTEXT_WINDOWS table in config.py;
+    then DEFAULT_CONTEXT_WINDOW.
+
+    Args:
+        model: The model ID to look up (e.g. "deepseek-v4-flash")
+        config_path: Optional path to the config file; defaults to the
+            standard config location (config.json).
+
+    Returns:
+        The context window size as an integer.
+    """
+    lowered = model.lower()
+    for pattern, size in load_context_windows_config(config_path):
+        if fnmatch.fnmatch(lowered, pattern.lower()):
+            return size
+    matched = _match_context_window(model)
+    if matched is not None:
+        return matched
+    return DEFAULT_CONTEXT_WINDOW

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/context_manager.py

@@ -20,7 +20,10 @@ class ContextManager:
     ``update_context_ratio`` receives the two token-estimator functions
     from the loop's delegate so the call site keeps resolving them
     through the ``agent`` module namespace (tests patch
-    ``python_agent_harness.agent.estimate_payload_tokens``).
+    ``python_agent_harness.agent.estimate_payload_tokens``).  The
+    context window comes from the session's client (cached, config-
+    file aware); ``context_window_for`` is only the fallback for
+    clients without the property.
     """
 
     def __init__(self, loop: Any) -> None:
@@ -39,7 +42,13 @@ class ContextManager:
         )
         loop.session.calibrator.last_raw_estimate = raw
         calibrated = loop.session.calibrator.calibrate(raw)
-        window = context_window_for(loop.session.model)
+        # Prefer the client's cached window (config overrides ->
+        # patterns -> default); fall back to the static resolver for
+        # clients without the property (test doubles).
+        client = loop.session.client
+        window = getattr(client, "context_window", None)
+        if window is None:
+            window = context_window_for(loop.session.model)
         loop.session.context_ratio = calibrated / float(window)
         loop.session.notify("context")
 

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/mcp/client.py

@@ -18,10 +18,12 @@ content-block dicts), ``structured_content`` and ``is_error``.
 
 from __future__ import annotations
 
+import contextlib
 import os
 from typing import Any
 
 try:
+    import httpx2  # shipped as part of the mcp SDK
     from mcp import Client
     from mcp.client.sse import sse_client
     from mcp.client.stdio import StdioServerParameters, stdio_client
@@ -93,8 +95,6 @@ class MCPClient:
         assert cfg.url is not None
         if cfg.transport == "streamable-http":
             if cfg.headers:
-                import httpx2  # shipped as part of the mcp SDK
-
                 self._http_client = httpx2.AsyncClient(headers=cfg.headers)
                 return streamable_http_client(cfg.url, http_client=self._http_client)
             return streamable_http_client(cfg.url)
@@ -117,8 +117,6 @@ class MCPClient:
 
     async def close(self) -> None:
         """Tear down the connection (best effort, never raises)."""
-        import contextlib
-
         client, self._client = self._client, None
         if client is not None:
             with contextlib.suppress(Exception):  # teardown noise is not an error

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/mcp/manager.py

@@ -200,8 +200,6 @@ class MCPManager:
 
     def disconnect(self, name: str) -> None:
         """Disconnect one server and drop its discovered tools."""
-        import contextlib
-
         client = self._clients.pop(name, None)
         if client is None:
             return

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/persistence.py

@@ -12,6 +12,7 @@ Ported from gptel-agent-harness-session.el.
 
 from __future__ import annotations
 
+import ast
 import os
 import re
 import threading
@@ -284,8 +285,6 @@ class SessionPersistence:
 
 def _parse_metadata_value(value: str) -> str:
     """Parse a repr()-style metadata value, mirroring elisp read-from-string."""
-    import ast
-
     try:
         parsed = ast.literal_eval(value)
         if isinstance(parsed, str):

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/python_agent_harness/token_estimator.py

@@ -8,6 +8,7 @@ to reduce drift.
 from __future__ import annotations
 
 import json
+import os
 import re
 
 from . import config
@@ -39,17 +40,20 @@ def estimate_tokens(text: str) -> int:
     return round(latin / 4.0 + cjk / 2.0)
 
 
-def context_window_for(model: str) -> int:
+def context_window_for(model: str, config_path: str | os.PathLike | None = None) -> int:
     """Return the context window for MODEL, or a safe fallback.
 
-    Entries are matched in order using substring matching, so more
-    specific patterns must come before general ones (see config).
+    Delegates to ``config.get_context_window_for_model``: config-file
+    ``context_windows`` overrides (config.json) first, then fnmatch
+    over CONTEXT_WINDOWS (first match wins, case-insensitive), then
+    DEFAULT_CONTEXT_WINDOW.
+
+    Args:
+        model: The model ID to look up.
+        config_path: Optional config file path; defaults to the
+            standard config location (config.json).
     """
-    lowered = model.lower()
-    for pattern, size in config.CONTEXT_WINDOWS:
-        if pattern in lowered:
-            return size
-    return config.DEFAULT_CONTEXT_WINDOW
+    return config.get_context_window_for_model(model, config_path=config_path)
 
 
 class TokenCalibrator:

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1/python_agent_harness.egg-info}/PKG-INFO

@@ -1,7 +1,9 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.3
+Version: 1.5.4.1
 Summary: A lightweight, hackable mini-OpenCode written in Python.
+Author: huming
+License-Expression: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -143,6 +145,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
       "model": "qwen3.5-coder"
     }
   },
+  "context_windows": {
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
+    "deepseek-v4*": 1000000
+  },
   "subagent_llm": {
     "profile": null,
     "base_url": null,
@@ -182,6 +188,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 - **`llm`** — main LLM configuration. Optional keys include `backend`, `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `run --no-stream` overrides `stream`.
 - **`models`** — named LLM profiles for runtime switching with `/model`. A profile is a partial settings dictionary; unset keys inherit from the main `llm`. `default` restores the main LLM configuration.
+- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g., `deepseek-v4*`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
 - **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
 - **`paths.context_path` / `paths.skill_path`** — locations from which to load context files and skills. When unset, the project-local `<project>/contexts` and `<project>/skills` directories are used.
 - **`mcp.servers`** — MCP server configuration. Requires the `[mcp]` extra. Each server supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, and `enabled`.

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/tests/test_client.py

@@ -6,6 +6,7 @@ import sys
 import tempfile
 import time
 import unittest
+from pathlib import Path
 from unittest import mock
 
 import httpx
@@ -27,13 +28,14 @@ def make_client(
     retry_max: int | None = None,
     retry_base_delay: float | None = None,
     retry_max_delay: float | None = None,
+    model: str = "fake",
 ) -> Client:
     srv = serve()
     host, port = srv.server_address
     c = Client(
         base_url=f"http://{host}:{port}/v1",
         api_key="test",
-        model="fake",
+        model=model,
         retry_max=retry_max,
         retry_base_delay=retry_base_delay,
         retry_max_delay=retry_max_delay,
@@ -1690,5 +1692,83 @@ class TestAuthRefreshOn401(unittest.TestCase):
         c.close()
 
 
+class TestContextWindow(unittest.TestCase):
+    """Client.context_window: config-file overrides -> CONTEXT_WINDOWS
+    patterns -> DEFAULT_CONTEXT_WINDOW.  The resolved value is cached
+    for the life of the client."""
+
+    def _client(self, model: str, config_path: str | None = None) -> Client:
+        c = Client(base_url="http://x/v1", api_key="k", model=model, config_path=config_path)
+        self.addCleanup(c.close)
+        return c
+
+    def test_config_file_override_wins(self):
+        """A context_windows entry in the config file beats the
+        built-in table, and the resolved value is cached."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"fake*": 999999}}', encoding="utf-8")
+            c = self._client(model="fake", config_path=str(p))
+            self.assertEqual(c.context_window, 999_999)
+            # cached: a later config change must not affect the window
+            p.write_text('{"context_windows": {"fake*": 111111}}', encoding="utf-8")
+            self.assertEqual(c.context_window, 999_999)
+
+    def test_config_file_wildcard_matching(self):
+        """Config-file patterns support fnmatch wildcards, first match
+        wins in file order."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text(
+                '{"context_windows": {"gpt-4*": 500000, "gpt-4-turbo": 300000}}',
+                encoding="utf-8",
+            )
+            # "gpt-4-turbo" hits the FIRST entry ("gpt-4*")
+            self.assertEqual(self._client("gpt-4-turbo", str(p)).context_window, 500_000)
+            self.assertEqual(self._client("gpt-4o", str(p)).context_window, 500_000)
+
+    def test_unknown_model_in_config_file_falls_to_table(self):
+        """Config-file overrides that don't match fall through to the
+        built-in CONTEXT_WINDOWS table."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"deepseek-v4*": 1000000}}', encoding="utf-8")
+            self.assertEqual(self._client("gpt-5-mini", str(p)).context_window, 128_000)
+            self.assertEqual(self._client("deepseek-v4-flash", str(p)).context_window, 1_000_000)
+
+    def test_fallback_to_pattern_match(self):
+        """No config-file overrides -> CONTEXT_WINDOWS wildcard."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"llm": {"model": "x"}}', encoding="utf-8")
+            self.assertEqual(self._client("gpt-4-turbo", str(p)).context_window, 128_000)
+
+    def test_fallback_to_default(self):
+        """No config-file overrides and no pattern match ->
+        DEFAULT_CONTEXT_WINDOW."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"llm": {"model": "x"}}', encoding="utf-8")
+            self.assertEqual(
+                self._client("totally-unknown-model", str(p)).context_window,
+                config.DEFAULT_CONTEXT_WINDOW,
+            )
+
+    def test_missing_config_file_uses_table(self):
+        """No config file at all -> CONTEXT_WINDOWS patterns."""
+        self.assertEqual(
+            self._client("deepseek-v4-flash", "/no/such/config.json").context_window,
+            1_000_000,
+        )
+
+    def test_malformed_config_file_falls_back_to_default(self):
+        """A broken context_windows section must not break the loop:
+        the client caches DEFAULT_CONTEXT_WINDOW."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"fake": "not-a-number"}}', encoding="utf-8")
+            self.assertEqual(self._client("fake", str(p)).context_window, 128_000)
+
+
 if __name__ == "__main__":
     unittest.main()

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/tests/test_config.py

@@ -180,6 +180,118 @@ class TestConfigFile(unittest.TestCase):
         self.assertIn("reasoning_effort", config.CONFIG_TEMPLATE)
         self.assertIn('"stream"', config.CONFIG_TEMPLATE)
         self.assertIn('"subagent_llm"', config.CONFIG_TEMPLATE)
+        self.assertIn('"context_windows"', config.CONFIG_TEMPLATE)
+
+
+class TestContextWindowsConfig(unittest.TestCase):
+    """Config-file context-window overrides: loaded from the
+    ``context_windows`` object, matched before the built-in table."""
+
+    def setUp(self):
+        self._saved = {k: os.environ.get(k) for k in ENV_KEYS}
+        for k in ENV_KEYS:
+            os.environ.pop(k, None)
+
+    def tearDown(self):
+        for k, v in self._saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+
+    def test_missing_file_returns_empty(self):
+        self.assertEqual(config.load_context_windows_config("/no/such/file.json"), [])
+
+    def test_empty_section_returns_empty(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"llm": {"model": "m"}}', encoding="utf-8")
+            self.assertEqual(config.load_context_windows_config(p), [])
+
+    def test_bad_json_returns_empty(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text("not {valid json", encoding="utf-8")
+            self.assertEqual(config.load_context_windows_config(p), [])
+
+    def test_overrides_loaded_in_order(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text(
+                '{"context_windows": {"deepseek-v4*": 1000000, "gpt-5*": 400000}}',
+                encoding="utf-8",
+            )
+            self.assertEqual(
+                config.load_context_windows_config(p),
+                [("deepseek-v4*", 1000000), ("gpt-5*", 400000)],
+            )
+
+    def test_comment_keys_skipped(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text(
+                '{"context_windows": {"_comment": "hi", "kimi*": 256000}}',
+                encoding="utf-8",
+            )
+            self.assertEqual(config.load_context_windows_config(p), [("kimi*", 256000)])
+
+    def test_section_must_be_object(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": "nope"}', encoding="utf-8")
+            with self.assertRaises(ValueError):
+                config.load_context_windows_config(p)
+
+    def test_size_must_be_integer(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"m*": "big"}}', encoding="utf-8")
+            with self.assertRaises(ValueError):
+                config.load_context_windows_config(p)
+
+    def test_bool_size_rejected(self):
+        """True is an int subclass but not a valid token count."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"m*": true}}', encoding="utf-8")
+            with self.assertRaises(ValueError):
+                config.load_context_windows_config(p)
+
+    def test_get_context_window_precedence(self):
+        """Config-file override -> CONTEXT_WINDOWS -> default."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text(
+                '{"context_windows": {"deepseek-v4*": 1000000, "gpt-4-turbo": 300000}}',
+                encoding="utf-8",
+            )
+            self.assertEqual(config.get_context_window_for_model("deepseek-v4-flash", p), 1000000)
+            # config-file match beats the built-in table
+            self.assertEqual(config.get_context_window_for_model("gpt-4-turbo", p), 300000)
+            # built-in table still applies when no override matches
+            self.assertEqual(config.get_context_window_for_model("gpt-5-mini", p), 128000)
+            self.assertEqual(config.get_context_window_for_model("kimi-k2.7-0613", p), 256000)
+            # unknown model -> default
+            self.assertEqual(
+                config.get_context_window_for_model("unknown-model", p),
+                config.DEFAULT_CONTEXT_WINDOW,
+            )
+
+    def test_get_context_window_case_insensitive(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"DeepSeek-V4*": 1000000}}', encoding="utf-8")
+            self.assertEqual(config.get_context_window_for_model("deepseek-v4-flash", p), 1000000)
+
+    def test_get_context_window_no_file(self):
+        self.assertEqual(
+            config.get_context_window_for_model("deepseek-v4", "/no/such/file.json"),
+            1_000_000,
+        )
+        self.assertEqual(
+            config.get_context_window_for_model("totally-unknown", "/no/such/file.json"),
+            config.DEFAULT_CONTEXT_WINDOW,
+        )
 
 
 class TestSubagentLlmConfig(unittest.TestCase):

{python_agent_harness-1.5.3 → python_agent_harness-1.5.4.1}/tests/test_token_estimator.py

@@ -1,4 +1,7 @@
+import os
+import tempfile
 import unittest
+from pathlib import Path
 
 from python_agent_harness.token_estimator import (
     TokenCalibrator,
@@ -11,6 +14,18 @@ from python_agent_harness.token_estimator import (
 
 
 class TestTokenizer(unittest.TestCase):
+    def setUp(self):
+        # pin the default config path to a nonexistent file so the
+        # tests never read the user's real config.json
+        self._saved_cfg = os.environ.get("PYTHON_AGENT_HARNESS_CONFIG")
+        os.environ["PYTHON_AGENT_HARNESS_CONFIG"] = "/no/such/harness-config.json"
+
+    def tearDown(self):
+        if self._saved_cfg is None:
+            os.environ.pop("PYTHON_AGENT_HARNESS_CONFIG", None)
+        else:
+            os.environ["PYTHON_AGENT_HARNESS_CONFIG"] = self._saved_cfg
+
     def test_empty_text_zero_tokens(self):
         self.assertEqual(estimate_tokens(""), 0)
 
@@ -26,10 +41,26 @@ class TestTokenizer(unittest.TestCase):
 
     def test_context_window_matching(self):
         self.assertEqual(context_window_for("deepseek-v4"), 1_000_000)
+        self.assertEqual(context_window_for("deepseek-v4-flash"), 1_000_000)
+        self.assertEqual(context_window_for("deepseek-v4-pro"), 1_000_000)
         self.assertEqual(context_window_for("gpt-5-mini"), 128_000)
+        self.assertEqual(context_window_for("gpt-5-pro"), 400_000)
         self.assertEqual(context_window_for("claude-sonnet"), 200_000)
+        self.assertEqual(context_window_for("qwen3.5-32b"), 131_072)
+        self.assertEqual(context_window_for("kimi-k2.7-0613"), 256_000)
         self.assertEqual(context_window_for("unknown-model"), 128_000)
 
+    def test_context_window_config_file_override(self):
+        """A context_windows section in the config file overrides the
+        built-in table (matched before CONTEXT_WINDOWS)."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"deepseek-v4*": 2000000}}', encoding="utf-8")
+            self.assertEqual(context_window_for("deepseek-v4-flash", str(p)), 2_000_000)
+            # models the override doesn't cover still use the table
+            self.assertEqual(context_window_for("gpt-5-mini", str(p)), 128_000)
+            self.assertEqual(context_window_for("unknown-model", str(p)), 128_000)
+
     def test_calibrator(self):
         c = TokenCalibrator()
         c.last_raw_estimate = 1000