codeboarding 0.10.3__tar.gz → 0.10.4__tar.gz

{codeboarding-0.10.3/codeboarding.egg-info → codeboarding-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.10.3
+Version: 0.10.4
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.10.3 → codeboarding-0.10.4}/agents/abstraction_agent.py

@@ -70,8 +70,20 @@ class AbstractionAgent(ClusterMethodsMixin, CodeBoardingAgent):
 
         programming_langs = self.static_analysis.get_languages()
 
-        # Build cluster string using the pre-computed cluster results
-        cluster_str = self._build_cluster_string(programming_langs, cluster_results)
+        # Measure everything that wraps cfg_clusters (system message + rendered
+        # template with an empty slot) so the skip planner can back it out of
+        # the input window before budgeting the cluster string.
+        overhead_chars = len(str(self.system_message.content)) + len(
+            self.prompts["group_clusters"].format(
+                project_name=self.project_name,
+                cfg_clusters="",
+                meta_context=meta_context_str,
+                project_type=project_type,
+            )
+        )
+        cluster_str = self._build_cluster_string(
+            programming_langs, cluster_results, prompt_overhead_chars=overhead_chars
+        )
 
         prompt = self.prompts["group_clusters"].format(
             project_name=self.project_name,

{codeboarding-0.10.3 → codeboarding-0.10.4}/agents/agent_responses.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import logging
 from abc import abstractmethod
@@ -6,8 +8,6 @@ from typing import get_origin, Optional
 
 from pydantic import BaseModel, Field
 
-from agents.change_status import ChangeStatus
-
 logger = logging.getLogger(__name__)
 
 
@@ -142,10 +142,6 @@ class MethodEntry(BaseModel):
     start_line: int = Field(description="Starting line number in the file.")
     end_line: int = Field(description="Ending line number in the file.")
     node_type: str = Field(description="Node type name matching NodeType enum (e.g. METHOD, FUNCTION, CLASS).")
-    status: ChangeStatus = Field(
-        default=ChangeStatus.UNCHANGED,
-        description="Diff status of this method: added, modified, deleted, or unchanged.",
-    )
 
     def __hash__(self) -> int:
         return hash(self.qualified_name)
@@ -156,13 +152,12 @@ class MethodEntry(BaseModel):
         return self.qualified_name == other.qualified_name
 
     @classmethod
-    def from_method_change(cls, method_change, *, status_override: ChangeStatus | None = None) -> "MethodEntry":
+    def from_method_change(cls, method_change) -> MethodEntry:
         return cls(
             qualified_name=method_change.qualified_name,
             start_line=method_change.start_line,
             end_line=method_change.end_line,
             node_type=method_change.node_type,
-            status=status_override or method_change.change_type,
         )
 
 
@@ -170,10 +165,6 @@ class FileMethodGroup(BaseModel):
     """All methods/functions belonging to a component within a single file."""
 
     file_path: str = Field(description="Relative path to the source file.")
-    file_status: ChangeStatus = Field(
-        default=ChangeStatus.UNCHANGED,
-        description="Diff status of this file: added, modified, deleted, renamed, or unchanged.",
-    )
     methods: list[MethodEntry] = Field(
         default_factory=list,
         description="Methods and functions in this file that belong to the component, sorted by start_line.",
@@ -183,10 +174,6 @@ class FileMethodGroup(BaseModel):
 class FileEntry(BaseModel):
     """Single source of truth for methods in one file."""
 
-    file_status: ChangeStatus = Field(
-        default=ChangeStatus.UNCHANGED,
-        description="Diff status of this file: added, modified, deleted, renamed, or unchanged.",
-    )
     methods: list[MethodEntry] = Field(
         default_factory=list,
         description="Methods and functions in this file, sorted by start line.",

codeboarding-0.10.4/agents/cluster_budget.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+from agents.constants import ModelCapabilities
+
+OUTPUT_HEADROOM_TOKENS = 8_000
+CONTEXT_MARGIN = 0.9
+
+
+@dataclass(frozen=True)
+class ClusterPromptBudget:
+    """Character budget for the full rendered ``cfg_clusters`` prompt slot."""
+
+    input_tokens: int
+    output_headroom_tokens: int = OUTPUT_HEADROOM_TOKENS
+    chars_per_token: float = ModelCapabilities.CHARS_PER_TOKEN
+    margin: float = CONTEXT_MARGIN
+
+    def available_chars(self, prompt_overhead_chars: int) -> int:
+        prompt_overhead_tokens = prompt_overhead_chars / self.chars_per_token
+        available_tokens = (self.input_tokens - self.output_headroom_tokens - prompt_overhead_tokens) * self.margin
+        return int(available_tokens * self.chars_per_token)

{codeboarding-0.10.3 → codeboarding-0.10.4}/agents/cluster_methods_mixin.py

@@ -1,7 +1,9 @@
 import logging
 import os
 from collections import defaultdict
+from dataclasses import dataclass
 from pathlib import Path
+from typing import NoReturn
 
 import networkx as nx
 
@@ -13,8 +15,11 @@ from agents.agent_responses import (
     FileMethodGroup,
     MethodEntry,
 )
+from agents.cluster_budget import ClusterPromptBudget
+from agents.llm_config import get_current_agent_context_window
 from constants import MIN_CLUSTERS_THRESHOLD
 from static_analyzer.analysis_result import StaticAnalysisResults
+from static_analyzer.cfg_skip_planner import ContextBudgetExceededError, plan_skip_set
 from static_analyzer.cluster_helpers import (
     MAX_LLM_CLUSTERS,
     enforce_cross_language_budget,
@@ -34,6 +39,13 @@ from static_analyzer.node import Node
 logger = logging.getLogger(__name__)
 
 
+@dataclass(frozen=True)
+class _RenderedClusterString:
+    text: str
+    by_language: dict[str, str]
+    cluster_ids: set[int]
+
+
 class ClusterMethodsMixin:
     """
     Mixin providing shared cluster-related functionality for agents.
@@ -61,6 +73,7 @@ class ClusterMethodsMixin:
         programming_langs: list[str],
         cluster_results: dict[str, ClusterResult],
         cluster_ids: set[int] | None = None,
+        prompt_overhead_chars: int = 0,
     ) -> str:
         """
         Build a cluster string for LLM consumption using pre-computed cluster results.
@@ -69,29 +82,59 @@ class ClusterMethodsMixin:
             programming_langs: List of languages to include
             cluster_results: Pre-computed cluster results mapping language -> ClusterResult
             cluster_ids: Optional set of cluster IDs to filter by
+            prompt_overhead_chars: Characters used by everything else in the
+                prompt (system message + rendered template with an empty
+                ``cfg_clusters`` slot). The skip planner subtracts this from
+                the model's input window before computing the char budget for
+                the cluster string.
 
         Returns:
             Formatted cluster string with headers per language
         """
-        cluster_lines = []
+        rendered = self._render_cluster_string(programming_langs, cluster_results, cluster_ids, {})
+        if cluster_ids:
+            return rendered.text
+
+        char_budget = self._cluster_prompt_budget(prompt_overhead_chars)
+        if len(rendered.text) <= char_budget:
+            return rendered.text
+
+        per_lang_skip = self._plan_skip_sets(programming_langs, cluster_results, prompt_overhead_chars)
+        rendered_with_skips = self._render_cluster_string(
+            programming_langs, cluster_results, cluster_ids, per_lang_skip
+        )
+        if len(rendered_with_skips.text) > char_budget:
+            self._raise_cluster_budget_error(char_budget, rendered_with_skips, per_lang_skip)
+
+        return rendered_with_skips.text
+
+    def _render_cluster_string(
+        self,
+        programming_langs: list[str],
+        cluster_results: dict[str, ClusterResult],
+        cluster_ids: set[int] | None,
+        skip_sets: dict[str, set[str]],
+    ) -> _RenderedClusterString:
+        cluster_lines: list[str] = []
+        by_language: dict[str, str] = {}
         all_cluster_ids: set[int] = set()
 
         for lang in programming_langs:
             cfg = self.static_analysis.get_cfg(lang)
-            # Get cluster result for this language
             cluster_result = cluster_results.get(lang)
-            cluster_str = cfg.to_cluster_string(cluster_ids, cluster_result)
+            cluster_str = cfg.to_cluster_string(
+                cluster_ids or set(), cluster_result, skip_nodes=skip_sets.get(lang, set())
+            )
 
             if cluster_str.strip() and cluster_str not in ("empty", "none", "No clusters found."):
                 header = "Component CFG" if cluster_ids else "Clusters"
-                cluster_lines.append(f"\n## {lang.capitalize()} - {header}\n")
-                cluster_lines.append(cluster_str)
-                cluster_lines.append("\n")
+                lang_text = f"\n## {lang.capitalize()} - {header}\n{cluster_str}\n"
+                cluster_lines.append(lang_text)
+                by_language[lang] = lang_text
                 if cluster_result:
                     lang_ids = cluster_ids if cluster_ids else cluster_result.get_cluster_ids()
                     all_cluster_ids.update(lang_ids)
 
-        # Add explicit ID checklist so the LLM knows exactly which IDs to assign
         if all_cluster_ids and not cluster_ids:
             sorted_cluster_ids = sorted(all_cluster_ids)
             cluster_lines.append(
@@ -99,7 +142,117 @@ class ClusterMethodsMixin:
                 f"Every one of these IDs: {sorted_cluster_ids} must appear in exactly one group."
             )
 
-        return "".join(cluster_lines)
+        return _RenderedClusterString(text="".join(cluster_lines), by_language=by_language, cluster_ids=all_cluster_ids)
+
+    def _plan_skip_sets(
+        self,
+        programming_langs: list[str],
+        cluster_results: dict[str, ClusterResult],
+        prompt_overhead_chars: int,
+    ) -> dict[str, set[str]]:
+        """Compute per-language skip sets so the final combined cluster string fits."""
+        char_budget = self._cluster_prompt_budget(prompt_overhead_chars)
+        if char_budget <= 0:
+            ctx = get_current_agent_context_window()
+            msg = (
+                f"Prompt overhead ({prompt_overhead_chars} chars) consumes the entire agent input "
+                f"window ({ctx.input_tokens} tokens); no room for cluster renderings."
+            )
+            logger.error("[CFG skip planner] %s", msg)
+            raise ContextBudgetExceededError(msg)
+
+        langs_with_clusters = [l for l in programming_langs if cluster_results.get(l)]
+        if not langs_with_clusters:
+            return {}
+
+        skip_sets: dict[str, set[str]] = {}
+        rendered = self._render_cluster_string(programming_langs, cluster_results, None, skip_sets)
+        if len(rendered.text) <= char_budget:
+            return skip_sets
+
+        max_iterations = max(1, len(langs_with_clusters) * 5)
+        for _ in range(max_iterations):
+            deficit = len(rendered.text) - char_budget
+            ordered_langs = sorted(
+                langs_with_clusters,
+                key=lambda lang: len(rendered.by_language.get(lang, "")),
+                reverse=True,
+            )
+            progressed = False
+
+            for lang in ordered_langs:
+                lang_text = rendered.by_language.get(lang, "")
+                current_len = len(lang_text)
+                if current_len == 0:
+                    continue
+
+                for target in self._language_budget_targets(current_len, deficit):
+                    try:
+                        skip = plan_skip_set(self.static_analysis.get_cfg(lang), cluster_results[lang], target)
+                    except ContextBudgetExceededError:
+                        continue
+
+                    if skip == skip_sets.get(lang, set()):
+                        continue
+
+                    trial_skip_sets = dict(skip_sets)
+                    if skip:
+                        trial_skip_sets[lang] = skip
+                    else:
+                        trial_skip_sets.pop(lang, None)
+
+                    trial_rendered = self._render_cluster_string(
+                        programming_langs, cluster_results, None, trial_skip_sets
+                    )
+                    if len(trial_rendered.text) >= len(rendered.text):
+                        continue
+
+                    skip_sets = trial_skip_sets
+                    rendered = trial_rendered
+                    progressed = True
+                    break
+
+                if progressed:
+                    break
+
+            if len(rendered.text) <= char_budget:
+                return skip_sets
+            if not progressed:
+                break
+
+        self._raise_cluster_budget_error(char_budget, rendered, skip_sets)
+
+    @staticmethod
+    def _language_budget_targets(current_len: int, deficit: int) -> list[int]:
+        exact_target = max(0, current_len - deficit)
+        targets = {
+            exact_target,
+            int(current_len * 0.9),
+            int(current_len * 0.75),
+            int(current_len * 0.5),
+            0,
+        }
+        return sorted((target for target in targets if target < current_len), reverse=True)
+
+    @staticmethod
+    def _raise_cluster_budget_error(
+        char_budget: int,
+        rendered: _RenderedClusterString,
+        skip_sets: dict[str, set[str]],
+    ) -> NoReturn:
+        per_lang_sizes = {lang: len(text) for lang, text in rendered.by_language.items()}
+        skipped_counts = {lang: len(skip) for lang, skip in skip_sets.items() if skip}
+        msg = (
+            f"Cluster render {len(rendered.text)} chars exceeds budget {char_budget}. "
+            f"Per-language sizes: {per_lang_sizes}; skipped nodes: {skipped_counts}."
+        )
+        logger.error("[CFG skip planner] %s", msg)
+        raise ContextBudgetExceededError(msg)
+
+    @staticmethod
+    def _cluster_prompt_budget(prompt_overhead_chars: int) -> int:
+        ctx = get_current_agent_context_window()
+        return ClusterPromptBudget(input_tokens=ctx.input_tokens).available_chars(prompt_overhead_chars)
 
     def _ensure_unique_key_entities(self, analysis: AnalysisInsights):
         """
@@ -247,11 +400,11 @@ class ClusterMethodsMixin:
             logger.warning(f"Component {component.name} has no assigned files")
             return "No assigned files found for this component.", {}, {}
 
-        # Convert files to absolute paths for comparison
-        assigned_file_set = set()
-        for f in component_files:
-            abs_path = os.path.join(self.repo_dir, f) if not os.path.isabs(f) else f
-            assigned_file_set.add(abs_path)
+        # Collect qualified names for method-level filtering
+        assigned_qnames: set[str] = set()
+        for group in component.file_methods:
+            for method in group.methods:
+                assigned_qnames.add(method.qualified_name)
 
         cluster_results: dict[str, ClusterResult] = {}
         subgraph_cfgs: dict[str, CallGraph] = {}
@@ -259,8 +412,8 @@ class ClusterMethodsMixin:
         for lang in self.static_analysis.get_languages():
             cfg = self.static_analysis.get_cfg(lang)
 
-            # Use strict filtering logic
-            sub_cfg = cfg.filter_by_files(assigned_file_set)
+            # Filter by exact method set to prevent scope leakage
+            sub_cfg = cfg.filter_by_nodes(assigned_qnames)
 
             if sub_cfg.nodes:
                 subgraph_cfgs[lang] = sub_cfg
@@ -299,7 +452,7 @@ class ClusterMethodsMixin:
         result = "".join(result_parts)
 
         if not result.strip():
-            logger.warning(f"No CFG found for component {component.name} with {len(component_files)} files")
+            logger.warning(f"No CFG found for component {component.name} with {len(assigned_qnames)} methods")
             return "No relevant CFG clusters found for this component.", cluster_results, subgraph_cfgs
 
         return result, cluster_results, subgraph_cfgs
@@ -556,7 +709,7 @@ class ClusterMethodsMixin:
             for fmg in component.file_methods:
                 entry = files.get(fmg.file_path)
                 if entry is None:
-                    entry = FileEntry(file_status=fmg.file_status, methods=[])
+                    entry = FileEntry(methods=[])
                     files[fmg.file_path] = entry
 
                 methods_by_qname = {m.qualified_name: m for m in entry.methods}

codeboarding-0.10.4/agents/constants.py

@@ -0,0 +1,38 @@
+"""Constants for the agents module."""
+
+
+class LLMDefaults:
+    DEFAULT_AGENT_TEMPERATURE = 0
+    DEFAULT_PARSING_TEMPERATURE = 0
+    AWS_MAX_TOKENS = 4096
+
+
+class FileStructureConfig:
+    MAX_LINES = 500
+    DEFAULT_MAX_DEPTH = 10
+    FALLBACK_MAX_LINES = 50000
+
+
+class ModelCapabilities:
+    FALLBACK_INPUT = 256_000
+    FALLBACK_OUTPUT = 64_000
+    CACHE_TTL_SECONDS = 24 * 3600
+    CHARS_PER_TOKEN = 3.5  # community consensus conversion is around 3 or 4 chars/token.
+
+    SOURCES = {
+        "litellm": "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json",
+        "modelsdev": "https://models.dev/api.json",
+        "openrouter": "https://openrouter.ai/api/v1/models",
+    }
+
+    # models.dev uses slugs that diverge from our internal provider names.
+    MODELSDEV_SLUG = {
+        "aws": "amazon-bedrock",
+        "kimi": "moonshotai",
+        "glm": "zai",
+    }
+
+    OPENROUTER_PREFIX = {
+        "kimi": "moonshotai",
+        "glm": "z-ai",
+    }

{codeboarding-0.10.3 → codeboarding-0.10.4}/agents/details_agent.py

@@ -84,8 +84,18 @@ class DetailsAgent(ClusterMethodsMixin, CodeBoardingAgent):
 
         programming_langs = self.static_analysis.get_languages()
 
-        # Build cluster string using the pre-computed cluster results (same as AbstractionAgent)
-        cluster_str = self._build_cluster_string(programming_langs, subgraph_cluster_results)
+        overhead_chars = len(str(self.system_message.content)) + len(
+            self.prompts["group_clusters"].format(
+                project_name=self.project_name,
+                cfg_clusters="",
+                component=component.llm_str(),
+                meta_context=meta_context_str,
+                project_type=project_type,
+            )
+        )
+        cluster_str = self._build_cluster_string(
+            programming_langs, subgraph_cluster_results, prompt_overhead_chars=overhead_chars
+        )
 
         prompt = self.prompts["group_clusters"].format(
             project_name=self.project_name,

{codeboarding-0.10.3 → codeboarding-0.10.4}/agents/llm_config.py

@@ -11,7 +11,8 @@ from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_ollama import ChatOllama
 from langchain_openai import ChatOpenAI
 
-from agents.constants import LLMDefaults
+from agents.constants import LLMDefaults, ModelCapabilities
+from agents.model_capabilities import ContextWindow, get_context_window
 from agents.prompts.prompt_factory import LLMType, initialize_global_factory
 from monitoring.callbacks import MonitoringCallback
 
@@ -123,7 +124,7 @@ LLM_PROVIDERS = {
         chat_class=ChatOpenAI,
         api_key_env="VERCEL_API_KEY",
         agent_model="google/gemini-3-flash",
-        parsing_model="openai/gpt-5-mini",  # Use OpenAI model for parsing to avoid trustcall compatibility issues with Gemini
+        parsing_model="openai/gpt-5-mini",
         llm_type=LLMType.GEMINI_FLASH,
         alt_env_vars=["VERCEL_BASE_URL"],
         extra_args={
@@ -136,8 +137,8 @@ LLM_PROVIDERS = {
     "anthropic": LLMConfig(
         chat_class=ChatAnthropic,
         api_key_env="ANTHROPIC_API_KEY",
-        agent_model="claude-sonnet-4-5-20250929",
-        parsing_model="claude-3-haiku-20240307",
+        agent_model="claude-sonnet-4-6",
+        parsing_model="claude-haiku-4-5",
         llm_type=LLMType.CLAUDE,
         extra_args={
             "max_tokens": 8192,
@@ -149,7 +150,7 @@ LLM_PROVIDERS = {
         chat_class=ChatGoogleGenerativeAI,
         api_key_env="GOOGLE_API_KEY",
         agent_model="gemini-3-flash",
-        parsing_model="gemini-3-flash",
+        parsing_model="gemini-3.1-flash-lite-preview",
         llm_type=LLMType.GEMINI_FLASH,
         extra_args={
             "max_tokens": None,
@@ -160,9 +161,9 @@ LLM_PROVIDERS = {
     "aws": LLMConfig(
         chat_class=ChatBedrockConverse,
         api_key_env="AWS_BEARER_TOKEN_BEDROCK",  # Used for existence check
-        agent_model="us.anthropic.claude-sonnet-4-5-20250929-v1:0",
-        parsing_model="us.anthropic.claude-3-haiku-20240307-v1:0",
-        llm_type=LLMType.CLAUDE,
+        agent_model="anthropic.claude-sonnet-4-6",
+        parsing_model="claude-haiku-4-5",
+        llm_type=LLMType.CLAUDE_SONNET,
         extra_args={
             "max_tokens": 4096,
             "region_name": lambda: os.getenv("AWS_DEFAULT_REGION", "us-east-1"),
@@ -172,9 +173,9 @@ LLM_PROVIDERS = {
     "cerebras": LLMConfig(
         chat_class=ChatCerebras,
         api_key_env="CEREBRAS_API_KEY",
-        agent_model="gpt-oss-120b",
-        parsing_model="llama3.1-8b",
-        llm_type=LLMType.GPT4,
+        agent_model="zai-glm-4.7",
+        parsing_model="gpt-oss-120b",
+        llm_type=LLMType.KIMI,
         extra_args={
             "max_tokens": None,
             "timeout": None,
@@ -238,8 +239,8 @@ LLM_PROVIDERS = {
     "openrouter": LLMConfig(
         chat_class=ChatOpenAI,
         api_key_env="OPENROUTER_API_KEY",
-        agent_model="google/gemini-2.5-flash",
-        parsing_model="google/gemini-2.5-flash",
+        agent_model="google/gemini-3-flash",
+        parsing_model="google/gemini-3.1-flash-lite-preview",
         llm_type=LLMType.GEMINI_FLASH,
         extra_args={
             "base_url": lambda: os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1"),
@@ -258,41 +259,53 @@ def _initialize_llm(
     log_prefix: str,
     init_factory: bool = False,
 ) -> tuple[BaseChatModel, str]:
-    for name, config in LLM_PROVIDERS.items():
-        if not config.is_active():
-            continue
+    resolved = _resolve_active_provider(model_override, model_attr)
+    if resolved is None:
+        required_vars = []
+        for config in LLM_PROVIDERS.values():
+            required_vars.append(config.api_key_env)
+            required_vars.extend(config.alt_env_vars)
 
-        model_name = model_override or getattr(config, model_attr)
+        raise ValueError(
+            f"No valid LLM configuration found. Please set one of: {', '.join(sorted(set(required_vars)))}"
+        )
 
-        if init_factory:
-            detected_llm_type = LLMType.from_model_name(model_name)
-            initialize_global_factory(detected_llm_type)
-            logger.info(
-                f"Initialized prompt factory for {name} provider with model '{model_name}' "
-                f"-> {detected_llm_type.value} prompt factory"
-            )
+    name, config, model_name = resolved
 
-        logger.info(f"Using {name.title()} {log_prefix}LLM with model: {model_name}")
+    if init_factory:
+        detected_llm_type = LLMType.from_model_name(model_name)
+        initialize_global_factory(detected_llm_type)
+        logger.info(
+            f"Initialized prompt factory for {name} provider with model '{model_name}' "
+            f"-> {detected_llm_type.value} prompt factory"
+        )
 
-        kwargs = {
-            "model": model_name,
-            "temperature": getattr(config, temperature_attr),
-        }
-        kwargs.update(config.get_resolved_extra_args())
+    logger.info(f"Using {name.title()} {log_prefix}LLM with model: {model_name}")
 
-        if name not in ["aws", "ollama"]:
-            api_key = config.get_api_key()
-            kwargs["api_key"] = api_key or "no-key-required"
+    kwargs = {
+        "model": model_name,
+        "temperature": getattr(config, temperature_attr),
+    }
+    kwargs.update(config.get_resolved_extra_args())
 
-        model = config.chat_class(**kwargs)  # type: ignore[call-arg, arg-type]
-        return model, model_name
+    if name not in ["aws", "ollama"]:
+        api_key = config.get_api_key()
+        kwargs["api_key"] = api_key or "no-key-required"
 
-    required_vars = []
-    for config in LLM_PROVIDERS.values():
-        required_vars.append(config.api_key_env)
-        required_vars.extend(config.alt_env_vars)
+    model = config.chat_class(**kwargs)  # type: ignore[call-arg, arg-type]
+    return model, model_name
 
-    raise ValueError(f"No valid LLM configuration found. Please set one of: {', '.join(sorted(set(required_vars)))}")
+
+def _resolve_active_provider(
+    model_override: str | None,
+    model_attr: str,
+) -> tuple[str, LLMConfig, str] | None:
+    """Return the active provider, config, and resolved model name."""
+    for name, config in LLM_PROVIDERS.items():
+        if not config.is_active():
+            continue
+        return name, config, model_override or getattr(config, model_attr)
+    return None
 
 
 def validate_api_key_provided() -> None:
@@ -311,6 +324,20 @@ def initialize_agent_llm(model_override: str | None = None) -> BaseChatModel:
     return model
 
 
+def get_current_agent_context_window() -> ContextWindow:
+    """Context window for the currently active agent provider/model.
+
+    Resolves the first active provider (same rule as ``_initialize_llm``) on
+    every call. ``get_context_window`` handles its own caching, so this is
+    cheap enough to call without a module-level cache.
+    """
+    resolved = _resolve_active_provider(_agent_model_override or os.getenv("AGENT_MODEL"), "agent_model")
+    if resolved is not None:
+        name, _config, model_name = resolved
+        return get_context_window(name, model_name)
+    return ContextWindow(ModelCapabilities.FALLBACK_INPUT, ModelCapabilities.FALLBACK_OUTPUT)
+
+
 def initialize_parsing_llm(model_override: str | None = None) -> BaseChatModel:
     model, _ = _initialize_llm(model_override, "parsing_model", "parsing_temperature", "Extractor ")
     return model