python-agent-harness 1.5.4.3__tar.gz → 1.5.4.6__tar.gz

{python_agent_harness-1.5.4.3/python_agent_harness.egg-info → python_agent_harness-1.5.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.3
+Version: 1.5.4.6
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -138,17 +138,15 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "_comment": "Named LLM profiles for /model switching. Partial settings; unset keys inherit the main llm.",
     "deepseek": {
       "base_url": "https://api.deepseek.com/v1",
-      "model": "deepseek-chat"
+      "model": "deepseek-chat",
+      "context_window": 128000
     },
     "qwen": {
       "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
-      "model": "qwen3.5-coder"
+      "model": "qwen3.5-coder",
+      "context_window": 131072
     }
   },
-  "context_windows": {
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (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,
@@ -158,7 +156,8 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "max_tokens": null,
     "timeout": null,
     "reasoning_effort": null,
-    "stream": null
+    "stream": null,
+    "context_window": null
   },
   "paths": {
     "context_path": null,
@@ -186,13 +185,12 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 ### Configuration options
 
-- **`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 substrings (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.
+- **`llm`** — main LLM configuration. Optional keys include `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, `context_window`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `context_window` (tokens) overrides the built-in table for the active model; when unset, well-known models are matched automatically. `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`. Each profile can include `context_window` to set the context window for that model. `default` restores the main LLM configuration.
+- **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. `context_window` can also be set here to override the inherited value for sub-agents. 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`.
-- **Configuration precedence** — code defaults < config file < `OPENAI_*` environment variables. Sub-agent settings also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`, `_BACKEND`).
+- **Configuration precedence** — code defaults < config file < `OPENAI_*` environment variables. Sub-agent settings also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`).
 - **Custom config** — use `--config PATH` or `PYTHON_AGENT_HARNESS_CONFIG`.
 - **LLM logging** — request and response bodies are logged as JSON to `/tmp/python-agent-harness-<date>-<id>.json`. Set `LLM_LOG_DIR` to change the directory. The log path is printed at startup.
 

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/README.md

@@ -115,17 +115,15 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "_comment": "Named LLM profiles for /model switching. Partial settings; unset keys inherit the main llm.",
     "deepseek": {
       "base_url": "https://api.deepseek.com/v1",
-      "model": "deepseek-chat"
+      "model": "deepseek-chat",
+      "context_window": 128000
     },
     "qwen": {
       "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
-      "model": "qwen3.5-coder"
+      "model": "qwen3.5-coder",
+      "context_window": 131072
     }
   },
-  "context_windows": {
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (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,
@@ -135,7 +133,8 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "max_tokens": null,
     "timeout": null,
     "reasoning_effort": null,
-    "stream": null
+    "stream": null,
+    "context_window": null
   },
   "paths": {
     "context_path": null,
@@ -163,13 +162,12 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 ### Configuration options
 
-- **`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 substrings (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.
+- **`llm`** — main LLM configuration. Optional keys include `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, `context_window`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `context_window` (tokens) overrides the built-in table for the active model; when unset, well-known models are matched automatically. `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`. Each profile can include `context_window` to set the context window for that model. `default` restores the main LLM configuration.
+- **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. `context_window` can also be set here to override the inherited value for sub-agents. 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`.
-- **Configuration precedence** — code defaults < config file < `OPENAI_*` environment variables. Sub-agent settings also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`, `_BACKEND`).
+- **Configuration precedence** — code defaults < config file < `OPENAI_*` environment variables. Sub-agent settings also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`).
 - **Custom config** — use `--config PATH` or `PYTHON_AGENT_HARNESS_CONFIG`.
 - **LLM logging** — request and response bodies are logged as JSON to `/tmp/python-agent-harness-<date>-<id>.json`. Set `LLM_LOG_DIR` to change the directory. The log path is printed at startup.
 

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.4.3"
+version = "1.5.4.6"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 readme = "README.md"
 requires-python = ">=3.11"

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/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.4.3"
+__version__ = "1.5.4.6"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/agent.py

@@ -452,7 +452,7 @@ class AgentLoop:
             )
             # sub-agent runs use their own LLM when one is configured
             # (a per-invocation clone of session.subagent_client,
-            # mirroring gptel-agent-harness-subagent-model/-backend);
+            # mirroring gptel-agent-harness-subagent-model);
             # everything unset inherits the main agent's settings, so
             # the sub-agent path is identical when no separate LLM is
             # configured

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/cli.py

@@ -54,8 +54,8 @@ def make_session(
         config_path=config_path,
     )
     # A separate client for sub-agent requests only when a different
-    # LLM is configured (mirrors gptel-agent-harness-subagent-model /
-    # -backend); otherwise the sub-agent shares the main client.
+    # LLM is configured (mirrors gptel-agent-harness-subagent-model);
+    # otherwise the sub-agent shares the main client.
     subagent_client = None
     if any(
         subagent_settings[k] != settings[k] for k in ("base_url", "api_key", "model", "timeout")
@@ -101,7 +101,6 @@ def make_session(
         project_dir=abs_project,
         client=client,
         model=model,
-        backend=settings["backend"],
         system_prompt=system_prompt,
         subagent_system_prompt=subagent_system_prompt,
         temperature=settings["temperature"],
@@ -176,7 +175,7 @@ def cmd_config(args: argparse.Namespace) -> int:
     print(f"config file: {path}")
     if not path.exists():
         print("(file does not exist yet — run `python-agent-harness config --init` to create it)")
-    for key in ("base_url", "model", "backend"):
+    for key in ("base_url", "model"):
         print(f"{key}: {settings[key]}")
     print(f"api_key: {config.mask_secret(settings['api_key'])}")
     print(f"temperature: {settings['temperature']}")
@@ -218,17 +217,11 @@ def cmd_config(args: argparse.Namespace) -> int:
         for name, profile in sorted(model_profiles.items()):
             model_name = profile.get("model", "(inherited)")
             base_url = profile.get("base_url", "(inherited)")
-            print(f"  {name}: model={model_name}, base_url={base_url}")
+            cw = profile.get("context_window")
+            cw_str = f", context_window={cw}" if cw is not None else ""
+            print(f"  {name}: model={model_name}, base_url={base_url}{cw_str}")
     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.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/client.py

@@ -217,6 +217,10 @@ class Client:
         # the user asked to stop.  Cleared at the start of each chat()
         # so a fresh turn may retry normally.
         self._aborted = False
+        # Per-model context-window override: set by the session when
+        # switching to a model profile that carries its own
+        # context_window.  None means "resolve from config / table".
+        self._context_window: int | None = None
         # an explicit log file is inherited by clones so every request
         # of one session (main + all sub-agents) lands in a single log
         self.log_path = (
@@ -229,18 +233,21 @@ class Client:
     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.  Resolved on every
-        access (no caching), so a runtime model switch or config-file
-        edit takes effect immediately; a malformed config falls back to
-        the default for that access and recovers once the file is fixed.
+        Resolution order: explicit ``_context_window`` override (set by
+        the session on model switch) → ``llm.context_window`` from the
+        config file → built-in CONTEXT_WINDOWS table (substring match)
+        → DEFAULT_CONTEXT_WINDOW.  Resolved on every access (no
+        caching), so a runtime model switch or config-file edit takes
+        effect immediately; a malformed config falls back to the default
+        for that access and recovers once the file is fixed.
         """
+        if self._context_window is not None:
+            return self._context_window
         try:
             return 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: use the safe default, retry on the next access
+            # a malformed config must not break the loop: use the safe
+            # default, retry on the next access
             return config.DEFAULT_CONTEXT_WINDOW
 
     def close(self) -> None:
@@ -259,7 +266,7 @@ class Client:
         flag strictly per-request.  The log file is shared so one
         session's LLM interactions stay in one log.
         """
-        return Client(
+        c = Client(
             base_url=self.base_url,
             api_key=self.api_key,
             model=self.model,
@@ -271,6 +278,8 @@ class Client:
             config_path=self._config_path,
             log_path=self.log_path,
         )
+        c._context_window = self._context_window
+        return c
 
     def abort(self) -> None:
         """Abort the in-flight request (called on cancel).

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/config.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import json
 import os
+import warnings
 from pathlib import Path
 
 from .mcp.config import MCPConfig
@@ -168,12 +169,12 @@ DEFAULT_LLM: dict = {
     "base_url": "https://api.openai.com/v1",
     "api_key": None,
     "model": "gpt-5-mini",
-    "backend": "OpenAI-compatible",
     "temperature": TEMPERATURE,
     "max_tokens": MAX_TOKENS,
     "timeout": 600.0,
     "reasoning_effort": None,
     "stream": True,
+    "context_window": None,
 }
 
 DEFAULT_PATHS: dict = {
@@ -182,8 +183,7 @@ DEFAULT_PATHS: dict = {
 }
 
 # Sub-agent LLM overrides: every key defaults to None, meaning "inherit
-# the main LLM setting" (mirrors gptel-agent-harness-subagent-model /
-# -backend).  Only the keys the user actually sets differ from the main
+# the main LLM setting" (mirrors gptel-agent-harness-subagent-model).
 # agent's LLM.  ``profile`` references a named profile from the
 # ``models`` section: its settings are applied on top of any explicit
 # subagent_llm keys (profile wins), and unset keys still inherit the
@@ -193,12 +193,12 @@ DEFAULT_SUBAGENT_LLM: dict = {
     "base_url": None,
     "api_key": None,
     "model": None,
-    "backend": None,
     "temperature": None,
     "max_tokens": None,
     "timeout": None,
     "reasoning_effort": None,
     "stream": None,
+    "context_window": None,
 }
 
 CONFIG_TEMPLATE = """\
@@ -211,20 +211,18 @@ CONFIG_TEMPLATE = """\
     "stream": true
   }},
   "models": {{
-    "_comment": "Named LLM profiles for /model switching. Each entry is a full set of LLM settings (base_url, api_key, model, etc.). Use /model in the TUI to switch at runtime.",
+    "_comment": "Named LLM profiles for /model switching. Each entry is a full set of LLM settings (base_url, api_key, model, context_window, etc.). Use /model in the TUI to switch at runtime. Unset keys inherit the main llm settings.",
     "deepseek": {{
       "base_url": "https://api.deepseek.com/v1",
-      "model": "deepseek-chat"
+      "model": "deepseek-chat",
+      "context_window": 128000
     }},
     "openai": {{
       "base_url": "https://api.openai.com/v1",
-      "model": "gpt-5-mini"
+      "model": "gpt-5-mini",
+      "context_window": 128000
     }}
   }},
-  "context_windows": {{
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (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,
@@ -235,7 +233,8 @@ CONFIG_TEMPLATE = """\
     "max_tokens": null,
     "timeout": null,
     "reasoning_effort": null,
-    "stream": null
+    "stream": null,
+    "context_window": null
   }},
   "paths": {{
     "_comment": "Optional overrides for context and skill directories. Absolute paths or ~ expansion supported.",
@@ -264,17 +263,31 @@ _ENV_OVERRIDES = {
     "base_url": "OPENAI_BASE_URL",
     "api_key": "OPENAI_API_KEY",
     "model": "OPENAI_MODEL",
-    "backend": "OPENAI_BACKEND",
 }
 
 _SUBAGENT_ENV_OVERRIDES = {
     "base_url": "OPENAI_SUBAGENT_BASE_URL",
     "api_key": "OPENAI_SUBAGENT_API_KEY",
     "model": "OPENAI_SUBAGENT_MODEL",
-    "backend": "OPENAI_SUBAGENT_BACKEND",
 }
 
 
+def _validate_context_window(
+    value: object, section: str, path: str | os.PathLike | None = None
+) -> None:
+    """Raise ValueError if *value* is set but not a positive integer."""
+    if value is None:
+        return
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(
+            f"config file {_config_path(path)}: {section}.context_window must be an integer"
+        )
+    if value <= 0:
+        raise ValueError(
+            f"config file {_config_path(path)}: {section}.context_window must be positive"
+        )
+
+
 def _config_path(path: str | os.PathLike | None = None) -> Path:
     """Resolve the config file path: explicit arg > $PYTHON_AGENT_HARNESS_CONFIG > default."""
     if path:
@@ -310,6 +323,9 @@ def load_llm_config(path: str | os.PathLike | None = None) -> dict:
 
     The config file is JSON with an ``llm`` object (see `CONFIG_TEMPLATE`).
     Environment variables still win if set, so existing setups keep working.
+    ``context_window`` is an optional integer (tokens); when unset it
+    defaults to None, meaning "resolve from the built-in table at
+    runtime".
     """
     settings = dict(DEFAULT_LLM)
     data = _read_config(path)
@@ -320,15 +336,24 @@ def load_llm_config(path: str | os.PathLike | None = None) -> dict:
         "base_url",
         "api_key",
         "model",
-        "backend",
         "temperature",
         "max_tokens",
         "timeout",
         "reasoning_effort",
         "stream",
+        "context_window",
     ):
         if key in llm and llm[key] is not None:
             settings[key] = llm[key]
+    _validate_context_window(settings.get("context_window"), "llm", path)
+    # Warn if the old top-level context_windows section is still present.
+    if data.get("context_windows"):
+        warnings.warn(
+            "The top-level 'context_windows' section in config.json is deprecated and ignored. "
+            "Set 'context_window' inside 'llm' or each model profile in 'models' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
     for key, env in _ENV_OVERRIDES.items():
         val = os.environ.get(env)
         if val:
@@ -342,7 +367,7 @@ def load_subagent_llm_config(
 ) -> dict:
     """Resolve sub-agent LLM settings; unset keys inherit ``main``.
 
-    Mirrors gptel-agent-harness-subagent-model/-backend: sub-agents
+    Mirrors gptel-agent-harness-subagent-model: sub-agents
     (the Agent tool) use their own LLM when configured, otherwise the
     main agent's.  Precedence: ``main`` settings < config file
     ``subagent_llm`` object < referenced ``models`` profile (when
@@ -379,12 +404,12 @@ def load_subagent_llm_config(
             "base_url",
             "api_key",
             "model",
-            "backend",
             "temperature",
             "max_tokens",
             "timeout",
             "reasoning_effort",
             "stream",
+            "context_window",
         ):
             if key in profile and profile[key] is not None:
                 overrides[key] = profile[key]
@@ -480,61 +505,62 @@ def _match_context_window(model: str) -> int | None:
     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
-    substrings (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.
+def get_context_window_for_model(
+    model: str,
+    config_path: str | os.PathLike | None = None,
+) -> int:
+    """Get the context window for MODEL.
+
+    Resolution order:
+    1. ``llm.context_window`` from the config file (when the active
+       model matches — this is already baked into the settings dict
+       returned by ``load_llm_config``; callers that use a resolved
+       settings dict should prefer ``resolve_context_window`` instead).
+    2. Built-in CONTEXT_WINDOWS table (substring match, first wins).
+    3. DEFAULT_CONTEXT_WINDOW.
+
+    This function is the fallback for callers that only have a model
+    name and no resolved settings dict (e.g. ``token_estimator``
+    or ``FakeClient``).
     """
+    # Try the llm.context_window from the config file first.
     try:
-        data = _read_config(path)
+        data = _read_config(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
+        data = {}
+    llm = data.get("llm") or {}
+    if isinstance(llm, dict):
+        cw = llm.get("context_window")
+        if cw is not None and isinstance(cw, int) and not isinstance(cw, bool) and cw > 0:
+            return cw
+    # Fall back to the built-in table, then the default.
+    matched = _match_context_window(model)
+    if matched is not None:
+        return matched
+    return DEFAULT_CONTEXT_WINDOW
 
 
-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.
+def resolve_context_window(settings: dict, model: str | None = None) -> int:
+    """Resolve the context window from a fully-merged settings dict.
 
-    The config file's ``context_windows`` object (user overrides) is
-    consulted first (substring match over its keys, first match wins,
-    case-insensitive); then the CONTEXT_WINDOWS table in config.py;
-    then DEFAULT_CONTEXT_WINDOW.
+    Precedence:
+    1. ``settings["context_window"]`` — set by the active profile,
+       ``llm`` section, or ``subagent_llm`` section (already merged
+       by the load functions).
+    2. Built-in CONTEXT_WINDOWS table (substring match on *model*).
+    3. 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.
+        settings: A resolved LLM settings dict (from ``load_llm_config``,
+            ``load_subagent_llm_config``, or a merged profile).
+        model: The model ID to match against the built-in table when
+            ``context_window`` is not set.  Defaults to
+            ``settings["model"]`` when omitted.
     """
-    lowered = model.lower()
-    for pattern, size in load_context_windows_config(config_path):
-        if pattern.lower() in lowered:
-            return size
+    cw = settings.get("context_window")
+    if cw is not None and isinstance(cw, int) and not isinstance(cw, bool) and cw > 0:
+        return cw
+    model = model or settings.get("model") or ""
     matched = _match_context_window(model)
     if matched is not None:
         return matched

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/persistence.py

@@ -107,7 +107,6 @@ class SessionPersistence:
         self,
         project_dir: str,
         model: str,
-        backend: str,
         system_prompt: str | None = None,
         temperature: float | None = None,
         max_tokens: int | None = None,
@@ -116,7 +115,6 @@ class SessionPersistence:
     ) -> None:
         self.project_dir = project_dir
         self.model = model
-        self.backend = backend
         self.system_prompt = system_prompt
         self.temperature = temperature
         self.max_tokens = max_tokens
@@ -173,7 +171,6 @@ class SessionPersistence:
         pairs = [
             ("python-agent-harness--project-dir", self.project_dir),
             ("gptel-model", self.model),
-            ("gptel--backend-name", self.backend),
             ("gptel-system-prompt", self.system_prompt),
             ("gptel-temperature", self.temperature),
             ("gptel-max-tokens", self.max_tokens),

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/session.py

@@ -71,7 +71,6 @@ class Session:
         project_dir: str,
         client: Client,
         model: str,
-        backend: str = "OpenAI-compatible",
         system_prompt: str | None = None,
         subagent_system_prompt: str | None = None,
         temperature: float = config.TEMPERATURE,
@@ -96,7 +95,6 @@ class Session:
         self.project_dir = project_dir
         self.client = client
         self.model = model
-        self.backend = backend
         self.system_prompt = system_prompt
         self.subagent_system_prompt = subagent_system_prompt
         self.temperature = temperature
@@ -113,7 +111,7 @@ class Session:
         # Sub-agent LLM: a dedicated client (base_url/api_key/model/
         # timeout) and per-request options when a different LLM is
         # configured for sub-agents (mirrors gptel-agent-harness-
-        # subagent-model/-backend); every unset option inherits the
+        # subagent-model); every unset option inherits the
         # main agent's value.  The sub-agent loop never uses this
         # client directly — each Agent tool invocation clones it
         # (see run_subagent) so concurrent sub-agents never share a
@@ -161,7 +159,6 @@ class Session:
         self.store = SessionPersistence(
             project_dir=project_dir,
             model=model,
-            backend=backend,
             system_prompt=system_prompt,
             temperature=temperature,
             max_tokens=max_tokens,
@@ -659,12 +656,12 @@ class Session:
             "base_url": self.client.base_url,
             "api_key": self.client.api_key,
             "model": self.model,
-            "backend": self.backend,
             "temperature": self.temperature,
             "max_tokens": self.max_tokens,
             "timeout": self.client.timeout,
             "reasoning_effort": self.reasoning_effort,
             "stream": self.stream,
+            "context_window": getattr(self.client, "_context_window", None),
         }
         for key, val in current.items():
             merged.setdefault(key, val)
@@ -673,12 +670,12 @@ class Session:
                 "base_url",
                 "api_key",
                 "model",
-                "backend",
                 "temperature",
                 "max_tokens",
                 "timeout",
                 "reasoning_effort",
                 "stream",
+                "context_window",
             ):
                 if key in profile and profile[key] is not None:
                     merged[key] = profile[key]
@@ -690,8 +687,6 @@ class Session:
         # the calibration factor is tokenizer-specific: a factor tuned
         # to the previous model must not skew estimates for the new one
         self.calibrator.reset()
-        self.backend = merged["backend"]
-        self.store.backend = merged["backend"]
         self.temperature = merged["temperature"]
         self.max_tokens = merged["max_tokens"]
         if hasattr(self.client, "set_timeout"):
@@ -700,6 +695,10 @@ class Session:
             self.client.timeout = merged["timeout"]
         self.reasoning_effort = merged["reasoning_effort"]
         self.stream = merged["stream"]
+        # context_window: set the client override so subsequent
+        # client.context_window accesses use the profile's value
+        # (None means "resolve from config / built-in table").
+        self.client._context_window = merged.get("context_window")
         return True, f"switched to {name} ({self.model})"
 
     # ------------------------------------------------------------------

{python_agent_harness-1.5.4.3 → python_agent_harness-1.5.4.6}/python_agent_harness/token_estimator.py

@@ -44,9 +44,9 @@ def context_window_for(model: str, config_path: str | os.PathLike | None = None)
     """Return the context window for MODEL, or a safe fallback.
 
     Delegates to ``config.get_context_window_for_model``: config-file
-    ``context_windows`` overrides (config.json) first, then substring
-    match over CONTEXT_WINDOWS (first match wins, case-insensitive),
-    then DEFAULT_CONTEXT_WINDOW.
+    ``llm.context_window`` first, then substring match over
+    CONTEXT_WINDOWS (first match wins, case-insensitive), then
+    DEFAULT_CONTEXT_WINDOW.
 
     Args:
         model: The model ID to look up.