kash-shell 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

kash/actions/core/combine_docs.py

@@ -0,0 +1,52 @@
+from chopdiff.html.html_in_md import div_wrapper
+
+from kash.config.logger import get_logger
+from kash.exec import kash_action
+from kash.model import ONE_OR_MORE_ARGS, ActionInput, ActionResult, Param
+from kash.utils.errors import InvalidInput
+
+log = get_logger(__name__)
+
+
+@kash_action(
+    expected_args=ONE_OR_MORE_ARGS,
+    params=(
+        Param(
+            "class_name",
+            "CSS class name to use for wrapping each document in a div.",
+            type=str,
+            default_value="doc",
+        ),
+    ),
+)
+def combine_docs(input: ActionInput, class_name: str = "page") -> ActionResult:
+    """
+    Combine multiple text items into a single document, wrapping each piece
+    in a div with the specified CSS class.
+    """
+    items = input.items
+
+    if not items:
+        raise InvalidInput("No items provided for combination")
+
+    # Create wrapper function
+    wrapper = div_wrapper(class_name=class_name)
+
+    # Collect and wrap all bodies
+    wrapped_bodies = []
+    for item in items:
+        if not item.body:
+            raise InvalidInput(f"Item has no body: {item.store_path}")
+        wrapped_bodies.append(wrapper(item.body))
+
+    # Concatenate with double newlines
+    combined_body = "\n\n".join(wrapped_bodies)
+
+    # Create title
+    count = len(items)
+    title = f"Combined ({count} doc{'s' if count != 1 else ''})"
+
+    # Create result item based on first item
+    result_item = items[0].derived_copy(body=combined_body, title=title, original_filename=None)
+
+    return ActionResult([result_item])

kash/actions/core/concat_docs.py

@@ -0,0 +1,47 @@
+from kash.config.logger import get_logger
+from kash.exec import kash_action
+from kash.model import ONE_OR_MORE_ARGS, ActionInput, ActionResult, Param
+from kash.utils.errors import InvalidInput
+
+log = get_logger(__name__)
+
+
+@kash_action(
+    expected_args=ONE_OR_MORE_ARGS,
+    params=(
+        Param(
+            "separator",
+            "String to use between concatenated items.",
+            type=str,
+            default_value="\n\n",
+        ),
+    ),
+)
+def concat_docs(input: ActionInput, separator: str = "\n\n") -> ActionResult:
+    """
+    Concatenate multiple text items into a single document with the specified
+    separator between each piece.
+    """
+    items = input.items
+
+    if not items:
+        raise InvalidInput("No items provided for concatenation")
+
+    # Collect all bodies
+    bodies = []
+    for item in items:
+        if not item.body:
+            raise InvalidInput(f"Item has no body: {item.store_path}")
+        bodies.append(item.body)
+
+    # Concatenate with the specified separator
+    concat_body = separator.join(bodies)
+
+    # Create title
+    count = len(items)
+    title = f"Concat ({count} doc{'s' if count != 1 else ''})"
+
+    # Create result item based on first item
+    result_item = items[0].derived_copy(body=concat_body, title=title, original_filename=None)
+
+    return ActionResult([result_item])

kash/commands/workspace/workspace_commands.py

@@ -474,8 +474,8 @@ def fetch_url(*files_or_urls: str, refetch: bool = False) -> ShellResult:
     store_paths = []
     for locator in locators:
         try:
-            fetched_item = fetch_url_item(locator, refetch=refetch)
-            store_paths.append(fetched_item.store_path)
+            fetch_result = fetch_url_item(locator, refetch=refetch)
+            store_paths.append(fetch_result.item.store_path)
         except InvalidInput as e:
             log.warning(
                 "Not a URL or URL resource, will not fetch metadata: %s: %s", fmt_loc(locator), e

kash/config/logger.py

@@ -254,9 +254,10 @@ def _do_logging_setup(log_settings: LogSettings):
         _console_handler = basic_stderr_handler(log_settings.log_console_level)
 
     # Manually adjust logging for a few packages, removing previous verbose default handlers.
-
+    # Set root logger to most permissive level so handlers can do the filtering
+    root_level = min(log_settings.log_console_level.value, log_settings.log_file_level.value)
     log_levels = {
-        None: INFO,
+        None: root_level,
         "LiteLLM": INFO,
         "LiteLLM Router": INFO,
         "LiteLLM Proxy": INFO,

kash/config/settings.py

@@ -210,6 +210,12 @@ class Settings:
     use_nerd_icons: bool
     """If true, use Nerd Icons in file listings. Requires a compatible font."""
 
+    limit_rps: float
+    """Default rate limit for API calls."""
+
+    limit_concurrency: int
+    """Default concurrency limit for API calls."""
+
 
 ws_root_dir = Path("~/Kash").expanduser()
 
@@ -276,6 +282,8 @@ def _read_settings():
         mcp_server_port=DEFAULT_MCP_SERVER_PORT,
         use_kerm_codes=False,
         use_nerd_icons=True,
+        limit_rps=5.0,
+        limit_concurrency=10,
     )
 
 

kash/docs/markdown/topics/a2_installation.md

@@ -124,7 +124,7 @@ These are for `kash-media` but you can use a `kash-shell` for a more basic setup
 
 You can use kash from your MCP client (such as Anthropic Desktop or Cursor).
 
-You do this by running the the `kash_mcp` binary to make kash actions available as MCP
+You do this by running the the `kash-mcp` binary to make kash actions available as MCP
 tools.
 
 For Claude Desktop, my config looks like this:
@@ -133,7 +133,7 @@ For Claude Desktop, my config looks like this:
 {
   "mcpServers": {
     "kash": {
-      "command": "/Users/levy/.local/bin/kash_mcp",
+      "command": "/Users/levy/.local/bin/kash-mcp",
       "args": ["--proxy"]
     }
   }

kash/embeddings/embeddings.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import ast
 from collections.abc import Iterable
 from pathlib import Path
-from typing import TYPE_CHECKING, TypeAlias, cast
+from typing import TYPE_CHECKING, TypeAlias
 
 from pydantic.dataclasses import dataclass
 from strif import abbrev_list
@@ -65,12 +65,11 @@ class Embeddings:
     @classmethod
     def embed(cls, keyvals: list[KeyVal], model=DEFAULT_EMBEDDING_MODEL) -> Embeddings:
         from litellm import embedding
-        from litellm.types.utils import EmbeddingResponse
 
         init_litellm()
 
         data = {}
-        log.message(
+        log.info(
             "Embedding %d texts (model %s, batch size %s)…",
             len(keyvals),
             model.litellm_name,
@@ -82,9 +81,8 @@ class Embeddings:
             keys = [kv[0] for kv in batch]
             texts = [kv[1] for kv in batch]
 
-            response: EmbeddingResponse = cast(
-                EmbeddingResponse, embedding(model=model.litellm_name, input=texts)
-            )
+            response = embedding(model=model.litellm_name, input=texts)
+
             if not response.data:
                 raise ValueError("No embedding response data")
 

kash/embeddings/text_similarity.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 from funlog import log_calls
 
@@ -24,12 +24,9 @@ def cosine_relatedness(x: ArrayLike, y: ArrayLike) -> float:
 def embed_query(model: EmbeddingModel, query: str) -> EmbeddingResponse:
     import litellm
     from litellm import embedding
-    from litellm.types.utils import EmbeddingResponse
 
     try:
-        response: EmbeddingResponse = cast(
-            EmbeddingResponse, embedding(model=model.litellm_name, input=[query])
-        )
+        response = embedding(model=model.litellm_name, input=[query])
     except litellm.exceptions.APIError as e:
         log.info("API error embedding query: %s", e)
         raise ApiResultError(str(e))

kash/exec/action_exec.py

@@ -55,7 +55,7 @@ def prepare_action_input(*input_args: CommandArg, refetch: bool = False) -> Acti
     if input_items:
         log.message("Assembling metadata for input items:\n%s", fmt_lines(input_items))
         input_items = [
-            fetch_url_item_content(item, refetch=refetch) if is_url_resource(item) else item
+            fetch_url_item_content(item, refetch=refetch).item if is_url_resource(item) else item
             for item in input_items
         ]
 

kash/exec/fetch_url_items.py

@@ -1,23 +1,42 @@
+from dataclasses import dataclass
+
 from kash.config.logger import get_logger
 from kash.exec.preconditions import is_url_resource
-from kash.media_base.media_services import get_media_metadata
 from kash.model.items_model import Item, ItemType
 from kash.model.paths_model import StorePath
 from kash.utils.common.format_utils import fmt_loc
 from kash.utils.common.url import Url, is_url
 from kash.utils.common.url_slice import add_slice_to_url, parse_url_slice
 from kash.utils.errors import InvalidInput
+from kash.web_content.web_page_model import WebPageData
 
 log = get_logger(__name__)
 
 
+@dataclass(frozen=True)
+class FetchItemResult:
+    """
+    Result of fetching a URL item.
+    """
+
+    item: Item
+
+    was_cached: bool
+    """Whether this item was already present in cache (or if we skipped the fetch
+    because we already had the data)."""
+
+    page_data: WebPageData | None = None
+    """If the item was fetched from a URL via the web content cache,
+    this will hold additional metadata whether it was cached."""
+
+
 def fetch_url_item(
     locator: Url | StorePath,
     *,
     save_content: bool = True,
     refetch: bool = False,
     cache: bool = True,
-) -> Item:
+) -> FetchItemResult:
     from kash.workspaces import current_ws
 
     ws = current_ws()
@@ -37,7 +56,7 @@ def fetch_url_item(
 
 def fetch_url_item_content(
     item: Item, *, save_content: bool = True, refetch: bool = False, cache: bool = True
-) -> Item:
+) -> FetchItemResult:
     """
     Fetch content and metadata for a URL using a media service if we
     recognize the URL as a known media service. Otherwise, fetch and extract the
@@ -51,6 +70,7 @@ def fetch_url_item_content(
     The content item is returned if content was saved. Otherwise, the updated
     URL item is returned.
     """
+    from kash.media_base.media_services import get_media_metadata
     from kash.web_content.canon_url import canonicalize_url
     from kash.web_content.web_extract import fetch_page_content
     from kash.workspaces import current_ws
@@ -61,7 +81,7 @@ def fetch_url_item_content(
             "Already have title, description, and body, will not fetch: %s",
             item.fmt_loc(),
         )
-        return item
+        return FetchItemResult(item, was_cached=True)
 
     if not item.url:
         raise InvalidInput(f"No URL for item: {item.fmt_loc()}")
@@ -74,6 +94,8 @@ def fetch_url_item_content(
     media_metadata = get_media_metadata(url)
     url_item: Item | None = None
     content_item: Item | None = None
+    page_data: WebPageData | None = None
+
     if media_metadata:
         url_item = Item.from_media_metadata(media_metadata)
         # Preserve and canonicalize any slice suffix on the URL.
@@ -101,7 +123,6 @@ def fetch_url_item_content(
                 original_filename=item.get_filename(),
                 format=page_data.format_info.format,
             )
-            ws.save(content_item)
 
     if not url_item.title:
         log.warning("Failed to fetch page data: title is missing: %s", item.url)
@@ -112,8 +133,15 @@ def fetch_url_item_content(
     if content_item:
         ws.save(content_item)
         assert content_item.store_path
-        log.info("Saved content item: %s", content_item.fmt_loc())
+        log.info(
+            "Saved both URL and content item: %s, %s",
+            url_item.fmt_loc(),
+            content_item.fmt_loc(),
+        )
     else:
-        log.info("Saved URL item: %s", url_item.fmt_loc())
+        log.info("Saved URL item (no content): %s", url_item.fmt_loc())
 
-    return content_item or url_item
+    was_cached = bool(
+        not page_data or (page_data.cache_result and page_data.cache_result.was_cached)
+    )
+    return FetchItemResult(content_item or url_item, was_cached=was_cached, page_data=page_data)

kash/help/help_embeddings.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
+from typing_extensions import override
+
 from kash.config.logger import get_logger
 from kash.embeddings.embeddings import Embeddings
 from kash.embeddings.text_similarity import rank_by_relatedness
@@ -19,6 +21,7 @@ class DocKey:
     doc_type: HelpDocType
     index: int
 
+    @override
     def __str__(self) -> str:
         return f"{self.doc_type.value}:{self.index}"
 

kash/llm_utils/llm_completion.py

@@ -107,7 +107,7 @@ def llm_completion(
 
     total_input_len = sum(len(m["content"]) for m in messages)
     speed = len(content) / elapsed
-    log.message(
+    log.info(
         f"{EMOJI_TIMING} LLM completion from {model.litellm_name} in {format_duration(elapsed)}: "
         f"input {total_input_len} chars in {len(messages)} messages, output {len(content)} chars "
         f"({speed:.0f} char/s)"

kash/llm_utils/llm_features.py

@@ -68,5 +68,5 @@ preferred_llms: list[LLMName] = [
     LLM.claude_4_opus,
     LLM.claude_3_7_sonnet,
     LLM.claude_3_5_haiku,
-    LLM.gemini_2_5_pro_preview_05_06,
+    LLM.gemini_2_5_pro,
 ]

kash/llm_utils/llms.py

@@ -15,6 +15,7 @@ class LLM(LLMName, Enum):
     # https://platform.openai.com/docs/models
     o4_mini = LLMName("o4-mini")
     o3 = LLMName("o3")
+    o3_pro = LLMName("o3-pro")
     o3_mini = LLMName("o3-mini")
     o1 = LLMName("o1")
     o1_mini = LLMName("o1-mini")
@@ -35,13 +36,9 @@ class LLM(LLMName, Enum):
     claude_3_5_haiku = LLMName("claude-3-5-haiku-latest")
 
     # https://ai.google.dev/gemini-api/docs/models
-    gemini_2_5_pro_preview_06_05 = LLMName("gemini/gemini-2.5-pro-preview-06-05")
-    gemini_2_5_pro_preview_05_06 = LLMName("gemini/gemini-2.5-pro-preview-05-06")
-    gemini_2_5_pro_preview_03_25 = LLMName("gemini/gemini-2.5-pro-preview-03-25")
-    gemini_2_5_flash_preview = LLMName("gemini-2.5-flash-preview-05-20")
-    gemini_2_0_flash = LLMName("gemini/gemini-2_0-flash")
-    gemini_2_0_flash_lite = LLMName("gemini/gemini-2.0-flash-lite")
-    gemini_2_0_pro_exp_02_05 = LLMName("gemini/gemini-2.0-pro-exp-02-05")
+    gemini_2_5_pro = LLMName("gemini/gemini-2.5-pro")
+    gemini_2_5_flash = LLMName("gemini/gemini-2.5-flash")
+    gemini_2_5_flash_lite = LLMName("gemini-2.5-flash-lite-preview-06-17")
 
     # https://docs.x.ai/docs/models
     xai_grok_3 = LLMName("xai/grok-3")
@@ -56,6 +53,7 @@ class LLM(LLMName, Enum):
     deepseek_reasoner = LLMName("deepseek/deepseek-reasoner")
 
     # https://console.groq.com/docs/models
+    groq_gemma2_9b_it = LLMName("groq/gemma2-9b-it")
     groq_llama_3_1_8b_instant = LLMName("groq/llama-3.1-8b-instant")
     groq_llama_3_3_70b_versatile = LLMName("groq/llama-3.3-70b-versatile")
     groq_deepseek_r1_distill_llama_70b = LLMName("groq/deepseek-r1-distill-llama-70b")

kash/mcp/mcp_cli.py

@@ -114,10 +114,10 @@ def main():
     args = build_parser().parse_args()
 
     if args.list_tools or args.tool_help:
-        kash_setup(rich_logging=True, level=LogLevel.warning)
+        kash_setup(rich_logging=True, log_level=LogLevel.warning)
         show_tool_info(args.tool_help)
     else:
-        kash_setup(rich_logging=False, level=LogLevel.info)
+        kash_setup(rich_logging=False, log_level=LogLevel.info)
         run_server(args)
 
 

kash/model/params_model.py

@@ -209,7 +209,7 @@ A list of parameter declarations, possibly with default values.
 DEFAULT_CAREFUL_LLM = LLM.o3
 DEFAULT_STRUCTURED_LLM = LLM.gpt_4o
 DEFAULT_STANDARD_LLM = LLM.claude_4_sonnet
-DEFAULT_FAST_LLM = LLM.o1_mini
+DEFAULT_FAST_LLM = LLM.gpt_4o
 
 
 # Parameters set globally such as in the workspace.

kash/utils/api_utils/api_retries.py

@@ -5,6 +5,8 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
 
+from kash.utils.api_utils.http_utils import extract_http_status_code
+
 
 class HTTPRetryBehavior(Enum):
     """HTTP status code retry behavior classification."""
@@ -62,51 +64,6 @@ class RetryExhaustedException(RetryException):
         )
 
 
-def extract_http_status_code(exception: Exception) -> int | None:
-    """
-    Extract HTTP status code from various exception types.
-
-    Args:
-        exception: The exception to extract status code from
-
-    Returns:
-        HTTP status code or None if not found
-    """
-    # Check for httpx.HTTPStatusError and requests.HTTPError
-    if hasattr(exception, "response"):
-        response = getattr(exception, "response", None)
-        if response and hasattr(response, "status_code"):
-            return getattr(response, "status_code", None)
-
-    # Check for aiohttp errors
-    if hasattr(exception, "status"):
-        return getattr(exception, "status", None)
-
-    # Parse from exception message as fallback
-    exception_str = str(exception)
-
-    # Try to find status code patterns in the message
-    import re
-
-    # Pattern for "403 Forbidden", "HTTP 429", etc.
-    status_patterns = [
-        r"\b(\d{3})\s+(?:Forbidden|Unauthorized|Not Found|Too Many Requests|Internal Server Error|Bad Gateway|Service Unavailable|Gateway Timeout)\b",
-        r"\bHTTP\s+(\d{3})\b",
-        r"\b(\d{3})\s+error\b",
-        r"status\s*(?:code)?:\s*(\d{3})\b",
-    ]
-
-    for pattern in status_patterns:
-        match = re.search(pattern, exception_str, re.IGNORECASE)
-        if match:
-            try:
-                return int(match.group(1))
-            except (ValueError, IndexError):
-                continue
-
-    return None
-
-
 def default_is_retriable(exception: Exception) -> bool:
     """
     Default retriable exception checker with HTTP status code awareness.
@@ -204,22 +161,22 @@ def default_is_retriable(exception: Exception) -> bool:
 
 def is_http_status_retriable(
     status_code: int,
-    retry_map: dict[int, HTTPRetryBehavior] | None = None,
+    retry_policy: dict[int, HTTPRetryBehavior] | None = None,
 ) -> bool:
     """
     Determine if an HTTP status code should be retried.
 
     Args:
         status_code: HTTP status code
-        retry_map: Custom retry behavior map (uses default if None)
+        retry_policy: Custom retry behavior policy (uses default if None)
 
     Returns:
         True if the status code should be retried
     """
-    if retry_map is None:
-        retry_map = DEFAULT_HTTP_RETRY_MAP
+    if retry_policy is None:
+        retry_policy = DEFAULT_HTTP_RETRY_MAP
 
-    behavior = retry_map.get(status_code)
+    behavior = retry_policy.get(status_code)
 
     if behavior == HTTPRetryBehavior.FULL:
         return True
@@ -265,36 +222,46 @@ class RetrySettings:
     """Exponential backoff multiplier"""
 
     is_retriable: Callable[[Exception], bool] = default_is_retriable
-    """Function to determine if an exception should be retried"""
-
-    http_retry_map: dict[int, HTTPRetryBehavior] | None = None
-    """Custom HTTP status code retry behavior (None = use defaults)"""
+    """Function to determine if non-HTTP exceptions should be retried (network errors, timeouts, etc.)"""
+
+    http_retry_policy: dict[int, HTTPRetryBehavior] | None = None
+    """Custom HTTP status code retry behavior policy (None = use defaults)"""
+
+    def should_retry(self, exception: Exception) -> bool:
+        """
+        Determine if an exception should be retried.
+
+        First checks for HTTP status codes and uses http_retry_policy if present.
+        For non-HTTP exceptions, uses the is_retriable function to determine
+        if other exception types (network errors, timeouts, etc.) should be retried.
+        """
+        # First check if this is an HTTP exception with a status code
+        status_code = extract_http_status_code(exception)
+        if status_code:
+            retry_policy = (
+                self.http_retry_policy
+                if self.http_retry_policy is not None
+                else DEFAULT_HTTP_RETRY_MAP
+            )
+            return is_http_status_retriable(status_code, retry_policy)
+
+        # Not an HTTP error - use is_retriable for other exception types
+        # (network errors, timeouts, connection issues, etc.)
+        return self.is_retriable(exception)
 
 
 DEFAULT_RETRIES = RetrySettings(
-    max_task_retries=10,
-    max_total_retries=100,
+    max_task_retries=15,
+    max_total_retries=1000,
     initial_backoff=1.0,
-    max_backoff=128.0,
-    backoff_factor=2.0,
+    max_backoff=60.0,
+    backoff_factor=1.5,
     is_retriable=default_is_retriable,
 )
 """Reasonable default retry settings with both per-task and global limits."""
 
-
-# Preset configurations for different use cases
-AGGRESSIVE_RETRIES = RetrySettings(
-    max_task_retries=15,
-    max_total_retries=200,
-    initial_backoff=0.5,
-    max_backoff=64.0,
-    backoff_factor=1.8,
-)
-"""Aggressive retry settings - retry more often with shorter initial backoff."""
-
-
-# Conservative retry settings use a custom retry map that excludes conservative retries
-_CONSERVATIVE_HTTP_RETRY_MAP = {
+# Conservative retry settings use a custom retry policy that excludes conservative retries
+_CONSERVATIVE_HTTP_RETRY_POLICY = {
     # Fully retriable: server errors and explicit rate limiting
     429: HTTPRetryBehavior.FULL,
     500: HTTPRetryBehavior.FULL,
@@ -319,7 +286,7 @@ CONSERVATIVE_RETRIES = RetrySettings(
     initial_backoff=2.0,
     max_backoff=60.0,
     backoff_factor=2.5,
-    http_retry_map=_CONSERVATIVE_HTTP_RETRY_MAP,
+    http_retry_policy=_CONSERVATIVE_HTTP_RETRY_POLICY,
 )
 """Conservative retry settings - fewer retries, longer backoff, no conservative HTTP retries."""
 
@@ -455,9 +422,9 @@ def test_is_http_status_retriable():
     assert is_http_status_retriable(403)  # Forbidden
     assert is_http_status_retriable(408)  # Request Timeout
 
-    # Conservative retriable with custom conservative map (disabled)
-    assert not is_http_status_retriable(403, _CONSERVATIVE_HTTP_RETRY_MAP)
-    assert not is_http_status_retriable(408, _CONSERVATIVE_HTTP_RETRY_MAP)
+    # Conservative retriable with custom conservative policy (disabled)
+    assert not is_http_status_retriable(403, _CONSERVATIVE_HTTP_RETRY_POLICY)
+    assert not is_http_status_retriable(408, _CONSERVATIVE_HTTP_RETRY_POLICY)
 
     # Never retriable
     assert not is_http_status_retriable(400)  # Bad Request
@@ -629,3 +596,44 @@ def test_calculate_backoff():
         backoff_factor=2.0,
     )
     assert high_backoff <= 5.0
+
+
+def test_retry_settings_should_retry():
+    """Test RetrySettings.should_retry method with custom HTTP maps."""
+
+    class MockHTTPXResponse:
+        def __init__(self, status_code):
+            self.status_code = status_code
+
+    class MockHTTPXException(Exception):
+        def __init__(self, status_code):
+            self.response = MockHTTPXResponse(status_code)
+            super().__init__(f"HTTP {status_code} error")
+
+    # Test with default settings (conservative retries enabled)
+    default_settings = RetrySettings(max_task_retries=3)
+    assert default_settings.should_retry(MockHTTPXException(429))  # Rate limit - retriable
+    assert default_settings.should_retry(MockHTTPXException(500))  # Server error - retriable
+    assert default_settings.should_retry(
+        MockHTTPXException(403)
+    )  # Conservative - retriable by default
+    assert not default_settings.should_retry(MockHTTPXException(404))  # Not found - not retriable
+
+    # Test with conservative settings (conservative retries disabled)
+    conservative_settings = CONSERVATIVE_RETRIES
+    assert conservative_settings.should_retry(
+        MockHTTPXException(429)
+    )  # Rate limit - still retriable
+    assert conservative_settings.should_retry(
+        MockHTTPXException(500)
+    )  # Server error - still retriable
+    assert not conservative_settings.should_retry(
+        MockHTTPXException(403)
+    )  # Conservative - now not retriable
+    assert not conservative_settings.should_retry(
+        MockHTTPXException(404)
+    )  # Not found - still not retriable
+
+    # Test with non-HTTP exception
+    assert default_settings.should_retry(Exception("Network error"))
+    assert not default_settings.should_retry(Exception("Authentication failed"))