klaude-code 2.8.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

klaude_code/app/runtime.py

@@ -178,6 +178,7 @@ async def handle_keyboard_interrupt(executor: Executor) -> None:
     log("Bye!")
     session_id = executor.context.current_session_id()
     if session_id and Session.exists(session_id):
-        log(("Resume with:", "dim"), (f"klaude --resume {session_id}", "green"))
+        short_id = Session.shortest_unique_prefix(session_id)
+        log(("Resume with:", "dim"), (f"klaude -r {short_id}", "green"))
     with contextlib.suppress(Exception):
         await executor.submit(op.InterruptOperation(target_session_id=None))

klaude_code/auth/antigravity/oauth.py

@@ -309,12 +309,3 @@ class AntigravityOAuth:
             state = self.refresh()
 
         return state.access_token, state.project_id
-
-    def get_api_key_json(self) -> str:
-        """Get API key as JSON string for LLM client.
-
-        Returns:
-            JSON string with token and projectId.
-        """
-        access_token, project_id = self.ensure_valid_token()
-        return json.dumps({"token": access_token, "projectId": project_id})

klaude_code/auth/antigravity/token_manager.py

@@ -25,21 +25,3 @@ class AntigravityTokenManager(BaseTokenManager[AntigravityAuthState]):
 
     def _create_state(self, data: dict[str, Any]) -> AntigravityAuthState:
         return AntigravityAuthState.model_validate(data)
-
-    def get_access_token(self) -> str:
-        """Get access token, raising if not logged in."""
-        state = self.get_state()
-        if state is None:
-            from klaude_code.auth.antigravity.exceptions import AntigravityNotLoggedInError
-
-            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
-        return state.access_token
-
-    def get_project_id(self) -> str:
-        """Get project ID, raising if not logged in."""
-        state = self.get_state()
-        if state is None:
-            from klaude_code.auth.antigravity.exceptions import AntigravityNotLoggedInError
-
-            raise AntigravityNotLoggedInError("Not logged in to Antigravity. Run 'klaude login antigravity' first.")
-        return state.project_id

klaude_code/auth/base.py

@@ -3,12 +3,15 @@
 import json
 import time
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any, cast
 
+from filelock import FileLock, Timeout
 from pydantic import BaseModel
 
 KLAUDE_AUTH_FILE = Path.home() / ".klaude" / "klaude-auth.json"
+LOCK_TIMEOUT_SECONDS = 30  # Maximum time to wait for lock acquisition
 
 
 class BaseAuthState(BaseModel):
@@ -99,3 +102,53 @@ class BaseTokenManager[T: BaseAuthState](ABC):
     def clear_cached_state(self) -> None:
         """Clear in-memory cached state to force reload from file on next access."""
         self._state = None
+
+    def _get_lock_file(self) -> Path:
+        """Get the lock file path for this auth file."""
+        return self.auth_file.with_suffix(".lock")
+
+    def refresh_with_lock(self, refresh_fn: Callable[[T], T]) -> T:
+        """Refresh token with file locking to prevent concurrent refresh.
+
+        This prevents multiple instances from simultaneously refreshing the same token.
+        If another instance has already refreshed, returns the updated state.
+
+        Args:
+            refresh_fn: Function that takes current state and returns new state.
+
+        Returns:
+            The new or already-refreshed authentication state.
+
+        Raises:
+            Timeout: If unable to acquire the lock within timeout.
+            ValueError: If not logged in.
+        """
+        lock_file = self._get_lock_file()
+        lock = FileLock(lock_file, timeout=LOCK_TIMEOUT_SECONDS)
+
+        try:
+            with lock:
+                # Re-read file after acquiring lock - another instance may have refreshed
+                self.clear_cached_state()
+                state = self.load()
+
+                if state is None:
+                    raise ValueError(f"Not logged in to {self.storage_key}")
+
+                # Check if token is still expired after re-reading
+                if not state.is_expired():
+                    # Another instance already refreshed, use their result
+                    return state
+
+                # Token still expired, we need to refresh
+                new_state = refresh_fn(state)
+                self.save(new_state)
+                return new_state
+
+        except Timeout:
+            # Lock timeout - try to re-read file in case another instance succeeded
+            self.clear_cached_state()
+            state = self.load()
+            if state and not state.is_expired():
+                return state
+            raise

klaude_code/auth/codex/exceptions.py

@@ -15,7 +15,3 @@ class CodexTokenExpiredError(CodexAuthError):
 
 class CodexOAuthError(CodexAuthError):
     """OAuth flow failed."""
-
-
-class CodexUnsupportedModelError(CodexAuthError):
-    """Model is not supported by codex_oauth protocol."""

klaude_code/auth/codex/oauth.py

@@ -177,43 +177,47 @@ class CodexOAuth:
         )
 
     def refresh(self) -> CodexAuthState:
-        """Refresh the access token using refresh token."""
-        state = self.token_manager.get_state()
-        if state is None:
-            from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
+        """Refresh the access token using refresh token with file locking.
 
-            raise CodexNotLoggedInError("Not logged in to Codex. Run 'klaude login codex' first.")
+        Uses file locking to prevent multiple instances from refreshing simultaneously.
+        If another instance has already refreshed, returns the updated state.
+        """
 
-        data = {
-            "grant_type": "refresh_token",
-            "client_id": CLIENT_ID,
-            "refresh_token": state.refresh_token,
-        }
+        def do_refresh(current_state: CodexAuthState) -> CodexAuthState:
+            data = {
+                "grant_type": "refresh_token",
+                "client_id": CLIENT_ID,
+                "refresh_token": current_state.refresh_token,
+            }
 
-        with httpx.Client() as client:
-            response = client.post(TOKEN_URL, data=data)
+            with httpx.Client() as client:
+                response = client.post(TOKEN_URL, data=data)
 
-        if response.status_code != 200:
-            from klaude_code.auth.codex.exceptions import CodexTokenExpiredError
+            if response.status_code != 200:
+                from klaude_code.auth.codex.exceptions import CodexTokenExpiredError
 
-            raise CodexTokenExpiredError(f"Token refresh failed: {response.text}")
+                raise CodexTokenExpiredError(f"Token refresh failed: {response.text}")
 
-        tokens = response.json()
-        access_token = tokens["access_token"]
-        refresh_token = tokens.get("refresh_token", state.refresh_token)
-        expires_in = tokens.get("expires_in", 3600)
+            tokens = response.json()
+            access_token = tokens["access_token"]
+            refresh_token = tokens.get("refresh_token", current_state.refresh_token)
+            expires_in = tokens.get("expires_in", 3600)
 
-        account_id = extract_account_id(access_token)
+            account_id = extract_account_id(access_token)
 
-        new_state = CodexAuthState(
-            access_token=access_token,
-            refresh_token=refresh_token,
-            expires_at=int(time.time()) + expires_in,
-            account_id=account_id,
-        )
+            return CodexAuthState(
+                access_token=access_token,
+                refresh_token=refresh_token,
+                expires_at=int(time.time()) + expires_in,
+                account_id=account_id,
+            )
+
+        try:
+            return self.token_manager.refresh_with_lock(do_refresh)
+        except ValueError as e:
+            from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
 
-        self.token_manager.save(new_state)
-        return new_state
+            raise CodexNotLoggedInError(str(e)) from e
 
     def ensure_valid_token(self) -> str:
         """Ensure we have a valid access token, refreshing if needed."""

klaude_code/auth/codex/token_manager.py

@@ -24,21 +24,3 @@ class CodexTokenManager(BaseTokenManager[CodexAuthState]):
 
     def _create_state(self, data: dict[str, Any]) -> CodexAuthState:
         return CodexAuthState.model_validate(data)
-
-    def get_access_token(self) -> str:
-        """Get access token, raising if not logged in."""
-        state = self.get_state()
-        if state is None:
-            from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
-
-            raise CodexNotLoggedInError("Not logged in to Codex. Run 'klaude login codex' first.")
-        return state.access_token
-
-    def get_account_id(self) -> str:
-        """Get account ID, raising if not logged in."""
-        state = self.get_state()
-        if state is None:
-            from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
-
-            raise CodexNotLoggedInError("Not logged in to Codex. Run 'klaude login codex' first.")
-        return state.account_id

klaude_code/cli/cost_cmd.py

@@ -34,6 +34,16 @@ class ModelUsageStats:
     def total_tokens(self) -> int:
         return self.input_tokens + self.output_tokens
 
+    @property
+    def non_cached_input_tokens(self) -> int:
+        """Non-cached prompt tokens.
+
+        We store `input_tokens` as the provider-reported prompt token count, which
+        includes cached tokens for providers that support prompt caching.
+        """
+
+        return max(0, self.input_tokens - self.cached_tokens)
+
     def add_usage(self, usage: model.Usage) -> None:
         self.input_tokens += usage.input_tokens
         self.output_tokens += usage.output_tokens
@@ -48,41 +58,99 @@ class ModelUsageStats:
 ModelKey = tuple[str, str]  # (model_name, provider)
 
 
-def group_models_by_provider(
-    models: dict[ModelKey, ModelUsageStats],
-) -> tuple[dict[str, list[ModelUsageStats]], dict[str, ModelUsageStats]]:
-    """Group models by provider and compute provider totals.
+@dataclass
+class SubProviderGroup:
+    """Group of models under a sub-provider."""
+
+    name: str
+    models: list[ModelUsageStats]
+    total: ModelUsageStats
+
+
+@dataclass
+class ProviderGroup:
+    """Group of models/sub-providers under a top-level provider."""
+
+    name: str
+    sub_providers: dict[str, SubProviderGroup]  # empty if no sub-providers
+    models: list[ModelUsageStats]  # direct models (when no sub-provider)
+    total: ModelUsageStats
+
 
-    Returns (models_by_provider, provider_totals) where both are sorted by cost desc.
+def _sort_by_cost(stats: ModelUsageStats) -> tuple[float, float]:
+    return (-stats.cost_usd, -stats.cost_cny)
+
+
+def group_models_by_provider(models: dict[ModelKey, ModelUsageStats]) -> dict[str, ProviderGroup]:
+    """Group models by provider with three-level hierarchy.
+
+    Provider strings like "openrouter/Anthropic" are split into:
+    - Top-level: "openrouter"
+    - Sub-provider: "Anthropic"
+
+    Returns dict of ProviderGroup sorted by cost desc.
     """
-    models_by_provider: dict[str, list[ModelUsageStats]] = {}
-    provider_totals: dict[str, ModelUsageStats] = {}
+    provider_groups: dict[str, ProviderGroup] = {}
 
     for stats in models.values():
-        provider_key = stats.provider or "(unknown)"
-        if provider_key not in models_by_provider:
-            models_by_provider[provider_key] = []
-            provider_totals[provider_key] = ModelUsageStats(model_name=provider_key, provider=provider_key)
-        models_by_provider[provider_key].append(stats)
-        provider_totals[provider_key].input_tokens += stats.input_tokens
-        provider_totals[provider_key].output_tokens += stats.output_tokens
-        provider_totals[provider_key].cached_tokens += stats.cached_tokens
-        provider_totals[provider_key].cost_usd += stats.cost_usd
-        provider_totals[provider_key].cost_cny += stats.cost_cny
+        provider_raw = stats.provider or "(unknown)"
 
-    def sort_by_cost(stats: ModelUsageStats) -> tuple[float, float]:
-        return (-stats.cost_usd, -stats.cost_cny)
+        # Split provider by first "/"
+        if "/" in provider_raw:
+            parts = provider_raw.split("/", 1)
+            top_provider, sub_provider = parts[0], parts[1]
+        else:
+            top_provider, sub_provider = provider_raw, ""
+
+        # Initialize top-level provider group
+        if top_provider not in provider_groups:
+            provider_groups[top_provider] = ProviderGroup(
+                name=top_provider,
+                sub_providers={},
+                models=[],
+                total=ModelUsageStats(model_name=top_provider),
+            )
+
+        group = provider_groups[top_provider]
+
+        # Accumulate to top-level total
+        group.total.input_tokens += stats.input_tokens
+        group.total.output_tokens += stats.output_tokens
+        group.total.cached_tokens += stats.cached_tokens
+        group.total.cost_usd += stats.cost_usd
+        group.total.cost_cny += stats.cost_cny
+
+        if sub_provider:
+            # Has sub-provider, add to sub-provider group
+            if sub_provider not in group.sub_providers:
+                group.sub_providers[sub_provider] = SubProviderGroup(
+                    name=sub_provider,
+                    models=[],
+                    total=ModelUsageStats(model_name=sub_provider),
+                )
+            sub_group = group.sub_providers[sub_provider]
+            sub_group.models.append(stats)
+            sub_group.total.input_tokens += stats.input_tokens
+            sub_group.total.output_tokens += stats.output_tokens
+            sub_group.total.cached_tokens += stats.cached_tokens
+            sub_group.total.cost_usd += stats.cost_usd
+            sub_group.total.cost_cny += stats.cost_cny
+        else:
+            # No sub-provider, add directly to models
+            group.models.append(stats)
 
-    # Sort providers by cost, and models within each provider
-    sorted_providers = sorted(provider_totals.keys(), key=lambda p: sort_by_cost(provider_totals[p]))
-    for provider_key in models_by_provider:
-        models_by_provider[provider_key].sort(key=sort_by_cost)
+    # Sort everything by cost
+    for group in provider_groups.values():
+        group.models.sort(key=_sort_by_cost)
+        for sub_group in group.sub_providers.values():
+            sub_group.models.sort(key=_sort_by_cost)
+        # Sort sub-providers by cost
+        group.sub_providers = dict(sorted(group.sub_providers.items(), key=lambda x: _sort_by_cost(x[1].total)))
 
-    # Rebuild dicts in sorted order
-    sorted_models_by_provider = {p: models_by_provider[p] for p in sorted_providers}
-    sorted_provider_totals = {p: provider_totals[p] for p in sorted_providers}
+    # Sort top-level providers by cost
+    sorted_groups = dict(sorted(provider_groups.items(), key=lambda x: _sort_by_cost(x[1].total)))
 
-    return sorted_models_by_provider, sorted_provider_totals
+    return sorted_groups
 
 
 @dataclass
@@ -223,8 +291,8 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
     table.add_column("Date", style="cyan")
     table.add_column("Model", overflow="ellipsis")
     table.add_column("Input", justify="right")
-    table.add_column("Output", justify="right")
     table.add_column("Cache", justify="right")
+    table.add_column("Output", justify="right")
     table.add_column("Total", justify="right")
     table.add_column("USD", justify="right")
     table.add_column("CNY", justify="right")
@@ -248,9 +316,9 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
         table.add_row(
             date_label,
             model_col,
-            fmt(format_tokens(stats.input_tokens)),
-            fmt(format_tokens(stats.output_tokens)),
+            fmt(format_tokens(stats.non_cached_input_tokens)),
             fmt(format_tokens(stats.cached_tokens)),
+            fmt(format_tokens(stats.output_tokens)),
             fmt(format_tokens(stats.total_tokens)),
             fmt(usd_str),
             fmt(cny_str),
@@ -261,19 +329,40 @@ def render_cost_table(daily_stats: dict[str, DailyStats]) -> Table:
         date_label: str = "",
         show_subtotal: bool = True,
     ) -> None:
-        """Render models grouped by provider with tree structure."""
-        models_by_provider, provider_totals = group_models_by_provider(models)
+        """Render models grouped by provider with three-level tree structure."""
+        provider_groups = group_models_by_provider(models)
 
         first_row = True
-        for provider_key, provider_models in models_by_provider.items():
-            provider_stats = provider_totals[provider_key]
-            add_stats_row(provider_stats, date_label=date_label if first_row else "", bold=True)
+        for group in provider_groups.values():
+            # Top-level provider
+            add_stats_row(group.total, date_label=date_label if first_row else "", bold=True)
             first_row = False
 
-            for i, stats in enumerate(provider_models):
-                is_last = i == len(provider_models) - 1
-                prefix = " └─ " if is_last else " ├─ "
-                add_stats_row(stats, prefix=prefix)
+            if group.sub_providers:
+                # Has sub-providers: render three-level tree
+                sub_list = list(group.sub_providers.values())
+                for sub_idx, sub_group in enumerate(sub_list):
+                    is_last_sub = sub_idx == len(sub_list) - 1
+                    sub_prefix = " └─ " if is_last_sub else " ├─ "
+
+                    # Sub-provider row
+                    add_stats_row(sub_group.total, prefix=sub_prefix, bold=True)
+
+                    # Models under sub-provider
+                    for model_idx, stats in enumerate(sub_group.models):
+                        is_last_model = model_idx == len(sub_group.models) - 1
+                        # Indent based on whether sub-provider is last
+                        if is_last_sub:
+                            model_prefix = "     └─ " if is_last_model else "     ├─ "
+                        else:
+                            model_prefix = " │   └─ " if is_last_model else " │   ├─ "
+                        add_stats_row(stats, prefix=model_prefix)
+            else:
+                # No sub-providers: render two-level tree (direct models)
+                for model_idx, stats in enumerate(group.models):
+                    is_last_model = model_idx == len(group.models) - 1
+                    model_prefix = " └─ " if is_last_model else " ├─ "
+                    add_stats_row(stats, prefix=model_prefix)
 
         if show_subtotal:
             subtotal = ModelUsageStats(model_name="(subtotal)")

klaude_code/cli/list_model.py

@@ -234,10 +234,15 @@ def _get_model_params_display(model: ModelConfig) -> list[Text]:
     return [Text("")]
 
 
-def _build_provider_info_panel(provider: ProviderConfig, available: bool) -> Quote:
+def _build_provider_info_panel(provider: ProviderConfig, available: bool, *, disabled: bool) -> Quote:
     """Build a Quote containing provider name and information using a two-column grid."""
     # Provider name as title
-    if available:
+    if disabled:
+        title = Text.assemble(
+            (provider.provider_name, ThemeKey.CONFIG_PROVIDER),
+            (" (Disabled)", "dim"),
+        )
+    elif available:
         title = Text(provider.provider_name, style=ThemeKey.CONFIG_PROVIDER)
     else:
         title = Text.assemble(
@@ -297,7 +302,8 @@ def _build_models_table(
     config: Config,
 ) -> Table:
     """Build a table for models under a provider."""
-    provider_available = not provider.is_api_key_missing()
+    provider_disabled = provider.disabled
+    provider_available = (not provider_disabled) and (not provider.is_api_key_missing())
 
     def _resolve_selector(value: str | None) -> str | None:
         if not value:
@@ -334,7 +340,15 @@ def _build_models_table(
         is_last = i == model_count - 1
         prefix = " └─ " if is_last else " ├─ "
 
-        if not provider_available:
+        if provider_disabled:
+            name = Text.assemble(
+                (prefix, ThemeKey.LINES),
+                (model.model_name, "dim strike"),
+                (" (provider disabled)", "dim"),
+            )
+            model_id = Text(model.model_id or "", style="dim")
+            params = Text("(disabled)", style="dim")
+        elif not provider_available:
             name = Text.assemble((prefix, ThemeKey.LINES), (model.model_name, "dim"))
             model_id = Text(model.model_id or "", style="dim")
             params = Text("(unavailable)", style="dim")
@@ -408,19 +422,22 @@ def display_models_and_providers(config: Config, *, show_all: bool = False):
     _display_agent_models_table(config, console)
     console.print()
 
-    # Sort providers: available (api_key set) first, unavailable (api_key not set) last
-    sorted_providers = sorted(config.provider_list, key=lambda p: (p.is_api_key_missing(), p.provider_name))
+    # Sort providers: enabled+available first, disabled/unavailable last
+    sorted_providers = sorted(
+        config.provider_list,
+        key=lambda p: (p.disabled, p.is_api_key_missing(), p.provider_name),
+    )
 
-    # Filter out unavailable providers unless show_all is True
+    # Filter out disabled/unavailable providers unless show_all is True
     if not show_all:
-        sorted_providers = [p for p in sorted_providers if not p.is_api_key_missing()]
+        sorted_providers = [p for p in sorted_providers if (not p.disabled) and (not p.is_api_key_missing())]
 
     # Display each provider with its models table
     for provider in sorted_providers:
-        provider_available = not provider.is_api_key_missing()
+        provider_available = (not provider.disabled) and (not provider.is_api_key_missing())
 
         # Provider info panel
-        provider_panel = _build_provider_info_panel(provider, provider_available)
+        provider_panel = _build_provider_info_panel(provider, provider_available, disabled=provider.disabled)
         console.print(provider_panel)
         console.print()
 

klaude_code/cli/main.py

@@ -34,7 +34,7 @@ def _build_env_help() -> str:
             "Tool limits (Read):",
             "  KLAUDE_READ_GLOBAL_LINE_CAP    Max lines to read (default: 2000)",
             "  KLAUDE_READ_MAX_CHARS          Max total chars to read (default: 50000)",
-            "  KLAUDE_READ_MAX_IMAGE_BYTES    Max image bytes to read (default: 4MB)",
+            "  KLAUDE_READ_MAX_IMAGE_BYTES    Max image bytes to read (default: 64MB)",
             "  KLAUDE_IMAGE_OUTPUT_MAX_BYTES  Max decoded image bytes (default: 64MB)",
         ]
     )
@@ -227,10 +227,21 @@ def main_callback(
             log(("Error: --resume <id> cannot be combined with --continue or interactive --resume", "red"))
             raise typer.Exit(2)
 
+        # Resolve resume_by_id with prefix matching support
         if resume_by_id_value is not None and not Session.exists(resume_by_id_value):
-            log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
-            log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
-            raise typer.Exit(2)
+            matches = Session.find_sessions_by_prefix(resume_by_id_value)
+            if not matches:
+                log((f"Error: session id '{resume_by_id_value}' not found for this project", "red"))
+                log(("Hint: run `klaude --resume` to select an existing session", "yellow"))
+                raise typer.Exit(2)
+            if len(matches) == 1:
+                resume_by_id_value = matches[0]
+            else:
+                # Multiple matches: show interactive selection with filtered list
+                selected = select_session_sync(session_ids=matches)
+                if selected is None:
+                    raise typer.Exit(1)
+                resume_by_id_value = selected
 
         if not sys.stdin.isatty() or not sys.stdout.isatty():
             log(("Error: interactive mode requires a TTY", "red"))

klaude_code/config/assets/builtin_config.yaml

@@ -36,7 +36,7 @@ provider_list:
     verbosity: high
     thinking:
       reasoning_effort: high
-      reasoning_summary: detailed
+      reasoning_summary: concise
     cost: {input: 1.75, output: 14, cache_read: 0.17}
 
   - model_name: gpt-5.2-medium
@@ -71,7 +71,7 @@ provider_list:
     context_limit: 400000
     thinking:
       reasoning_effort: medium
-      reasoning_summary: detailed
+      reasoning_summary: concise
     cost: {input: 1.25, output: 10, cache_read: 0.13}
 
 
@@ -87,7 +87,7 @@ provider_list:
     verbosity: high
     thinking:
       reasoning_effort: high
-      reasoning_summary: detailed
+      reasoning_summary: concise
     cost: {input: 1.75, output: 14, cache_read: 0.17}
 
   - model_name: gpt-5.2-medium
@@ -277,6 +277,7 @@ provider_list:
 
 - provider_name: claude-max
   protocol: claude_oauth
+  disabled: true
   model_list:
 
   - model_name: sonnet
@@ -318,7 +319,7 @@ provider_list:
     verbosity: high
     thinking:
       reasoning_effort: high
-      reasoning_summary: detailed
+      reasoning_summary: concise
     cost: {input: 1.75, output: 14, cache_read: 0.17}
 
 
@@ -329,42 +330,25 @@ provider_list:
     model_id: claude-opus-4-5-thinking
     context_limit: 200000
     max_tokens: 64000
-    thinking:
-      type: enabled
-      budget_tokens: 10240
+
   - model_name: sonnet
     model_id: claude-sonnet-4-5
     context_limit: 200000
     max_tokens: 64000
-  - model_name: sonnet-thinking
-    model_id: claude-sonnet-4-5-thinking
-    context_limit: 200000
-    max_tokens: 64000
-    thinking:
-      type: enabled
-      budget_tokens: 10240
+
   - model_name: gemini-pro-high
     model_id: gemini-3-pro-high
     context_limit: 1048576
     max_tokens: 65535
     thinking:
       reasoning_effort: high
-  - model_name: gemini-pro-low
-    model_id: gemini-3-pro-low
-    context_limit: 1048576
-    max_tokens: 65535
-    thinking:
-      reasoning_effort: low
+
   - model_name: gemini-flash
     model_id: gemini-3-flash
     context_limit: 1048576
     max_tokens: 65535
     thinking:
       reasoning_effort: medium
-  - model_name: gpt-oss
-    model_id: gpt-oss-120b-medium
-    context_limit: 131072
-    max_tokens: 32768
 
 
 compact_model: gemini-flash