patchpal 0.22.8__tar.gz → 0.23.1__tar.gz

{patchpal-0.22.8/patchpal.egg-info → patchpal-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.22.8
+Version: 0.23.1
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0
@@ -64,7 +64,7 @@ Most agent frameworks are [built in TypeScript](https://news.ycombinator.com/ite
 - [Built-In](https://amaiya.github.io/patchpal/features/tools/) and [Custom Tools](https://amaiya.github.io/patchpal/features/custom-tools/)
 - [Skills System](https://amaiya.github.io/patchpal/features/skills/) and [MCP Integration](https://amaiya.github.io/patchpal/features/mcp/)
 - [Autopilot Mode](https://amaiya.github.io/patchpal/usage/autopilot/) using [Ralph Wiggum loops](https://github.com/amaiya/patchpal/tree/main/examples/ralph/)
-- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `~/.patchpal/repos/<repo-name>/MEMORY.md` at startup.
+- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `MEMORY.md` (repository root or `~/.patchpal/repos/<repo-name>/MEMORY.md`) at startup.
 
 PatchPal prioritizes customizability: custom tools, custom skills, a flexible Python API, and support for any tool-calling LLM.
 
@@ -177,6 +177,10 @@ While originally designed for software development, PatchPal is also a general-p
 2. PatchPal includes a [unique guardrails system](https://amaiya.github.io/patchpal/safety/) that is better suited to privacy-conscious use cases involving sensitive data.
 3. We needed an agent harness that seamlessly works with [both local and cloud models](https://amaiya.github.io/patchpal/models/overview/#supported-models), including AWS GovCloud Bedrock models.
 
+> I noticed there's another package called PatchPal on GitLab. Are they related?
+
+No, they're separate projects. The [project with the same name on GitLab](https://gitlab.com/patchpal-ai) is unrelated to this one.
+
 > On Windows Subsystem for Linux (WSL), why is it stalling intermittently at "Thinking..."?
 
 This is a [known issue](https://github.com/microsoft/WSL/issues/6264#issuecomment-762154193) with WSL2.

{patchpal-0.22.8 → patchpal-0.23.1}/README.md

@@ -16,7 +16,7 @@ Most agent frameworks are [built in TypeScript](https://news.ycombinator.com/ite
 - [Built-In](https://amaiya.github.io/patchpal/features/tools/) and [Custom Tools](https://amaiya.github.io/patchpal/features/custom-tools/)
 - [Skills System](https://amaiya.github.io/patchpal/features/skills/) and [MCP Integration](https://amaiya.github.io/patchpal/features/mcp/)
 - [Autopilot Mode](https://amaiya.github.io/patchpal/usage/autopilot/) using [Ralph Wiggum loops](https://github.com/amaiya/patchpal/tree/main/examples/ralph/)
-- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `~/.patchpal/repos/<repo-name>/MEMORY.md` at startup.
+- [Project Memory](https://amaiya.github.io/patchpal/features/memory/) automatically loads project context from `MEMORY.md` (repository root or `~/.patchpal/repos/<repo-name>/MEMORY.md`) at startup.
 
 PatchPal prioritizes customizability: custom tools, custom skills, a flexible Python API, and support for any tool-calling LLM.
 
@@ -129,6 +129,10 @@ While originally designed for software development, PatchPal is also a general-p
 2. PatchPal includes a [unique guardrails system](https://amaiya.github.io/patchpal/safety/) that is better suited to privacy-conscious use cases involving sensitive data.
 3. We needed an agent harness that seamlessly works with [both local and cloud models](https://amaiya.github.io/patchpal/models/overview/#supported-models), including AWS GovCloud Bedrock models.
 
+> I noticed there's another package called PatchPal on GitLab. Are they related?
+
+No, they're separate projects. The [project with the same name on GitLab](https://gitlab.com/patchpal-ai) is unrelated to this one.
+
 > On Windows Subsystem for Linux (WSL), why is it stalling intermittently at "Thinking..."?
 
 This is a [known issue](https://github.com/microsoft/WSL/issues/6264#issuecomment-762154193) with WSL2.

{patchpal-0.22.8 → patchpal-0.23.1}/patchpal/__init__.py

@@ -1,6 +1,6 @@
 """PatchPal - An open-source Claude Code clone implemented purely in Python."""
 
-__version__ = "0.22.8"
+__version__ = "0.23.1"
 
 from patchpal.agent import create_agent, create_react_agent
 from patchpal.cli.autopilot import autopilot_loop

patchpal-0.23.1/patchpal/agent/bedrock_profile_utils.py

@@ -0,0 +1,226 @@
+"""Utilities for AWS Bedrock application inference profiles.
+
+Application inference profiles (tagged profiles) don't include model names in their ARNs,
+making it impossible to statically determine model capabilities or pricing. This module
+provides functions to detect the underlying model and its capabilities at runtime.
+"""
+
+import litellm
+
+
+def _extract_model_from_arn(arn: str) -> str | None:
+    """Try to extract underlying model info from an inference profile ARN using AWS API.
+
+    Args:
+        arn: The inference profile ARN
+
+    Returns:
+        Model name if found, None otherwise
+    """
+    try:
+        import os
+
+        import boto3
+
+        # Extract region from ARN (arn:aws-us-gov:bedrock:us-gov-east-1:...)
+        parts = arn.split(":")
+        if len(parts) >= 4:
+            region = parts[3]
+        else:
+            region = os.getenv("AWS_REGION_NAME") or os.getenv("AWS_REGION") or "us-east-1"
+
+        # Create bedrock client
+        bedrock = boto3.client("bedrock", region_name=region)
+
+        # Get inference profile details
+        response = bedrock.get_inference_profile(inferenceProfileIdentifier=arn)
+
+        # Extract model info from response
+        if "models" in response and response["models"]:
+            # Get first model from the profile
+            first_model = response["models"][0]
+            if "modelArn" in first_model:
+                # Extract model ID from ARN
+                # e.g., arn:aws-us-gov:bedrock:us-gov-west-1::foundation-model/anthropic.claude-sonnet-4-5-20250929-v1:0
+                model_arn = first_model["modelArn"]
+
+                # Try multiple extraction methods
+                if "foundation-model" in model_arn:
+                    # Split on the foundation-model part
+                    parts = model_arn.split("foundation-model/")
+                    if len(parts) > 1:
+                        return parts[1]
+
+        return None
+    except Exception:
+        # API call failed or boto3 not available
+        return None
+
+
+def detect_model_capabilities(
+    model_id: str, litellm_kwargs: dict = None
+) -> tuple[bool, str | None]:
+    """Detect prompt caching support and underlying model name for application inference profiles.
+
+    This is useful for application inference profiles (tagged profiles) where the
+    underlying model name is not in the ARN, making it impossible to statically
+    determine model capabilities or pricing.
+
+    Args:
+        model_id: Full LiteLLM model identifier (e.g., bedrock/converse/arn:...)
+        litellm_kwargs: Optional kwargs to pass to litellm.completion
+
+    Returns:
+        Tuple of (caching_supported: bool, model_name: str | None)
+        - caching_supported: True if prompt caching works with tools
+        - model_name: Detected model name from response metadata (e.g., "claude-3-5-sonnet-20241022")
+    """
+    if litellm_kwargs is None:
+        litellm_kwargs = {}
+
+    # Create a minimal test message with cache markers
+    test_messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "What is the capital of France?",
+                    "cache_control": {"type": "ephemeral"},
+                }
+            ],
+        }
+    ]
+
+    # Include a minimal tool to match real usage (some models only support caching without tools)
+    test_tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_info",
+                "description": "Get information",
+                "parameters": {
+                    "type": "object",
+                    "properties": {"query": {"type": "string", "description": "The query"}},
+                    "required": ["query"],
+                },
+            },
+        }
+    ]
+
+    caching_supported = False
+    detected_model = None
+
+    # For ARNs, try to get model info from AWS API first
+    if "arn:aws" in model_id and "inference-profile" in model_id:
+        # Extract just the ARN (remove bedrock/converse/ prefix if present)
+        arn = model_id.replace("bedrock/converse/", "").replace("bedrock/", "")
+        detected_model = _extract_model_from_arn(arn)
+
+    try:
+        # Try with Anthropic-style cache_control AND tools (matches real usage)
+        response = litellm.completion(
+            model=model_id,
+            messages=test_messages,
+            tools=test_tools,
+            tool_choice="auto",  # Include tool_choice like the real agent
+            max_tokens=10,
+            **litellm_kwargs,
+        )
+        # If we got here without error, caching is supported
+        caching_supported = True
+
+        # Only try to extract model from response if we didn't get it from AWS API
+        if not detected_model:
+            # Try to extract model name from response metadata
+            # Bedrock responses include model info in various places
+            if hasattr(response, "_hidden_params") and response._hidden_params:
+                # LiteLLM stores raw response data here
+                hidden = response._hidden_params
+
+                # Check optional_params which may contain raw boto3 response
+                if "optional_params" in hidden and isinstance(hidden["optional_params"], dict):
+                    optional = hidden["optional_params"]
+                    # Bedrock converse API may include model info in the response
+                    if "model" in optional:
+                        detected_model = optional["model"]
+                    elif "modelId" in optional:
+                        detected_model = optional["modelId"]
+
+                # Check standard fields
+                if not detected_model and "model_id" in hidden and hidden["model_id"]:
+                    detected_model = hidden["model_id"]
+                elif not detected_model and "model" in hidden and hidden["model"]:
+                    detected_model = hidden["model"]
+
+            # Check response metadata
+            if not detected_model and hasattr(response, "model"):
+                model_val = response.model
+                # Skip if it's just the ARN we passed in
+                if model_val and "application-inference-profile" not in model_val:
+                    detected_model = model_val
+
+            # Try to extract from response choices/usage if available
+            if not detected_model and hasattr(response, "usage"):
+                usage = response.usage
+                if hasattr(usage, "model") and usage.model:
+                    detected_model = usage.model
+
+    except Exception as e:
+        error_msg = str(e).lower()
+        # Check for caching-specific errors
+        if any(
+            phrase in error_msg
+            for phrase in [
+                "prompt caching",
+                "cache_control",
+                "cachepoint",
+                "unsupported model",
+                "did not allow prompt caching",
+            ]
+        ):
+            # Caching not supported, but still try to detect model without caching
+            caching_supported = False
+
+            # Only retry if we don't already have model from AWS API
+            if not detected_model:
+                try:
+                    # Retry without cache markers to detect model
+                    simple_messages = [{"role": "user", "content": "Hi"}]
+                    response = litellm.completion(
+                        model=model_id,
+                        messages=simple_messages,
+                        tools=test_tools,
+                        max_tokens=5,
+                        **litellm_kwargs,
+                    )
+                    # Try to extract model from response
+                    if hasattr(response, "_hidden_params") and response._hidden_params:
+                        hidden = response._hidden_params
+                        if "model_id" in hidden:
+                            detected_model = hidden["model_id"]
+                        elif "model" in hidden:
+                            detected_model = hidden["model"]
+                    if not detected_model and hasattr(response, "model"):
+                        detected_model = response.model
+                except Exception:
+                    pass  # Could not detect model
+        else:
+            # Different error (auth, network, etc.)
+            caching_supported = False
+
+    return caching_supported, detected_model
+
+
+def test_prompt_caching_support(model_id: str, litellm_kwargs: dict = None) -> bool:
+    """Test if a model supports prompt caching (backward compatibility wrapper).
+
+    Args:
+        model_id: Full LiteLLM model identifier (e.g., bedrock/converse/arn:...)
+        litellm_kwargs: Optional kwargs to pass to litellm.completion
+
+    Returns:
+        True if prompt caching is supported, False otherwise
+    """
+    caching_supported, _ = detect_model_capabilities(model_id, litellm_kwargs)
+    return caching_supported

{patchpal-0.22.8 → patchpal-0.23.1}/patchpal/agent/function_calling.py

@@ -28,14 +28,36 @@ LLM_TIMEOUT = config.LLM_TIMEOUT
 
 
 def _is_bedrock_arn(model_id: str) -> bool:
-    """Check if a model ID is a Bedrock ARN."""
+    """Check if a model ID is a Bedrock ARN.
+
+    Supports all Bedrock inference profile ARN formats:
+    - arn:aws:bedrock:region:account:inference-profile/profile-id
+    - arn:aws-us-gov:bedrock:region:account:inference-profile/profile-id
+    - arn:aws:bedrock:region:account:application-inference-profile/app-id
+    - arn:aws-us-gov:bedrock:region:account:application-inference-profile/app-id
+    """
     return (
         model_id.startswith("arn:aws")
         and ":bedrock:" in model_id
-        and ":inference-profile/" in model_id
+        and "inference-profile/" in model_id
     )
 
 
+def _is_application_inference_profile(model_id: str) -> bool:
+    """Check if a model ID is a Bedrock application inference profile (tagged profile).
+
+    Application inference profiles are tagged profiles that don't include the underlying
+    model name in the ARN, making it impossible to statically determine model capabilities.
+
+    Args:
+        model_id: Model identifier (may or may not have bedrock/ prefix)
+
+    Returns:
+        True if this is an application inference profile ARN
+    """
+    return ":application-inference-profile/" in model_id
+
+
 def _normalize_bedrock_model_id(model_id: str) -> str:
     """Normalize Bedrock model ID to ensure it has the bedrock/ prefix.
 
@@ -51,7 +73,11 @@ def _normalize_bedrock_model_id(model_id: str) -> str:
 
     # If it looks like a Bedrock ARN, add the prefix
     if _is_bedrock_arn(model_id):
-        return f"bedrock/{model_id}"
+        # Application inference profiles require the converse API
+        if ":application-inference-profile/" in model_id:
+            return f"bedrock/converse/{model_id}"
+        else:
+            return f"bedrock/{model_id}"
 
     # If it's a standard Bedrock model ID (e.g., anthropic.claude-v2)
     # Check if it looks like a Bedrock model format
@@ -274,6 +300,10 @@ def _supports_prompt_caching(model_id: str) -> bool:
     # Bedrock Nova models support caching
     if model_id.startswith("bedrock/") and "amazon.nova" in model_id.lower():
         return True
+    # Bedrock ARNs (all types): enable caching and let Bedrock handle it
+    # If the underlying model doesn't support caching, Bedrock will ignore the markers
+    if model_id.startswith("bedrock/") and "inference-profile/" in model_id:
+        return True
     return False
 
 
@@ -301,12 +331,14 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
 
     # Determine cache marker format based on provider
     # Anthropic models (direct or via Bedrock) use cache_control
-    # Other Bedrock models (Nova, etc.) use cachePoint
-    if model_id.startswith("bedrock/") and "anthropic" not in model_id.lower():
-        # Non-Anthropic Bedrock models (Nova, etc.) use cachePoint
+    # Nova models use cachePoint
+    # For Bedrock ARNs without model name, default to cache_control (most common)
+    if model_id.startswith("bedrock/") and "amazon.nova" in model_id.lower():
+        # Nova models explicitly use cachePoint
         cache_marker = {"cachePoint": {"type": "default"}}
     else:
         # Anthropic models (direct or via Bedrock) use cache_control
+        # Also default for Bedrock ARNs (most use Anthropic/Claude)
         cache_marker = {"cache_control": {"type": "ephemeral"}}
 
     # Count existing cache markers across all messages
@@ -328,8 +360,30 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
     max_cache_markers = 4
     available_slots = max_cache_markers - existing_cache_count
 
+    # Debug logging
+    import os
+
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        print("\n[CACHE DEBUG] _apply_prompt_caching called")
+        print(f"  Total messages: {len(messages)}")
+        print(f"  Existing cache markers: {existing_cache_count}")
+        print(f"  Available slots: {available_slots}")
+        # Show which messages have markers
+        marked_indices = []
+        for i, msg in enumerate(messages):
+            if isinstance(msg.get("content"), list):
+                for block in msg["content"]:
+                    if isinstance(block, dict) and (
+                        "cache_control" in block or "cachePoint" in block
+                    ):
+                        marked_indices.append(i)
+                        break
+        print(f"  Messages with existing markers: {marked_indices}")
+
     if available_slots <= 0:
         # Already at or over limit, don't add any more cache markers
+        if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+            print("  Result: No slots available, returning without changes")
         return messages
 
     # Find system messages (usually at the start)
@@ -341,6 +395,9 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
         non_system_messages[-2:] if len(non_system_messages) >= 2 else non_system_messages
     )
 
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        print(f"  Last 2 non-system indices: {last_two_indices}")
+
     # Build list of candidate indices to cache (prioritize system messages)
     candidates = []
 
@@ -373,6 +430,12 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
             if not has_cache:
                 candidates.append(idx)
 
+    import os
+
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        print(f"  Candidates for marking: {candidates}")
+        print(f"  Will mark first {available_slots} candidates")
+
     # Apply cache markers to candidates, respecting the available slots
     # This ensures we never exceed the 4 marker limit
     for idx in candidates[:available_slots]:
@@ -393,6 +456,20 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
                     "content": [{"type": "text", "text": content_text, **cache_marker}],
                 }
 
+    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+        # Show final state
+        final_marked = []
+        for i, msg in enumerate(messages):
+            if isinstance(msg.get("content"), list):
+                for block in msg["content"]:
+                    if isinstance(block, dict) and (
+                        "cache_control" in block or "cachePoint" in block
+                    ):
+                        final_marked.append(i)
+                        break
+        print(f"  Final messages with markers: {final_marked}")
+        print(f"  Markers applied to indices: {[c for c in candidates[:available_slots]]}")
+
     return messages
 
 
@@ -509,6 +586,49 @@ class PatchPalAgent:
         if litellm_kwargs:
             self.litellm_kwargs.update(litellm_kwargs)
 
+        # Detect capabilities for application inference profiles
+        # These ARNs don't include model names, so we test with a minimal request
+        self.prompt_caching_supported = None  # None = untested, True/False after test
+        self.detected_model_name = None  # Store detected model for cost tracking
+        if _is_application_inference_profile(self.model_id):
+            # Test capabilities with a minimal request
+            try:
+                from patchpal.agent.bedrock_profile_utils import detect_model_capabilities
+
+                print("\033[2mℹ️  Detecting model capabilities...\033[0m", flush=True)
+                self.prompt_caching_supported, self.detected_model_name = detect_model_capabilities(
+                    self.model_id, self.litellm_kwargs
+                )
+                if self.prompt_caching_supported:
+                    print("\033[2m✓ Prompt caching is supported\033[0m", flush=True)
+                else:
+                    print("\033[2m✗ Prompt caching is not supported\033[0m", flush=True)
+
+                if self.detected_model_name:
+                    print(f"\033[2m✓ Detected model: {self.detected_model_name}\033[0m", flush=True)
+
+                    # Update context limit based on detected model
+                    try:
+                        model_info = litellm.get_model_info(f"bedrock/{self.detected_model_name}")
+                        max_input = model_info.get("max_input_tokens")
+                        if max_input and isinstance(max_input, (int, float)) and max_input > 0:
+                            self.context_manager.context_limit = int(max_input)
+                    except Exception:
+                        pass  # Keep default limit
+                else:
+                    print(
+                        "\033[2m⚠  Could not detect underlying model name (cost tracking may be inaccurate)\033[0m",
+                        flush=True,
+                    )
+            except Exception:
+                # If test fails, assume caching not supported and model unknown
+                self.prompt_caching_supported = False
+                self.detected_model_name = None
+        elif _supports_prompt_caching(self.model_id):
+            self.prompt_caching_supported = True
+        else:
+            self.prompt_caching_supported = False
+
         # Load MEMORY.md if it exists and has non-template content
         self._load_project_memory()
 
@@ -523,38 +643,33 @@ class PatchPalAgent:
     def _load_project_memory(self):
         """Load MEMORY.md file at session start if it has non-template content."""
         try:
-            from patchpal.tools.common import MEMORY_FILE
+            from patchpal.tools.common import get_memory_info
 
-            # Always tell the agent where MEMORY.md is located
-            if not MEMORY_FILE.exists():
-                return
-
-            memory_content = MEMORY_FILE.read_text(encoding="utf-8")
+            info = get_memory_info()
 
-            # Check if user has added content after the "---" separator
-            has_user_content = False
-            if "---" in memory_content:
-                parts = memory_content.split("---", 1)
-                if len(parts) > 1:
-                    user_content = parts[1].strip()
-                    if user_content and len(user_content) > 10:
-                        has_user_content = True
+            if not info["exists"]:
+                return
 
             # Build the message - include full content if user added info, otherwise just location
-            if has_user_content:
+            if info["has_content"]:
                 memory_msg = f"""# Project Memory (from MEMORY.md)
 
-{memory_content}
+{info["content"]}
 
-The information above is from {MEMORY_FILE} and persists across sessions.
-To update it, use edit_file("{MEMORY_FILE}", ...) or write_file("{MEMORY_FILE}", ...)."""
+The information above is from MEMORY.md ({info["location_note"]}) and persists across sessions.
+To update it, use edit_file("{info["path"]}", ...) or write_file("{info["path"]}", ...)."""
             else:
                 # Empty template - just inform agent
                 memory_msg = f"""# Project Memory (MEMORY.md)
 
-Your project memory file is located at: {MEMORY_FILE}
+Your project memory file is located at: {info["path"]}
 
-It's currently empty (just the template). The file is automatically loaded at session start."""
+It's currently empty (just the template). The file is automatically loaded at session start.
+
+Note: You can use MEMORY.md in either location:
+- Repository root: MEMORY.md (can be version controlled)
+- Home directory: ~/.patchpal/repos/<repo-name>/MEMORY.md (default)
+Repository root takes priority if both exist."""
 
             # Add as a system message at the start
             self.messages.insert(
@@ -847,7 +962,17 @@ It's currently empty (just the template). The file is automatically loaded at se
             float: The calculated cost in dollars
         """
         try:
-            model_info = litellm.get_model_info(self.model_id)
+            # For application inference profiles, use detected model name for pricing
+            model_for_pricing = self.model_id
+            if _is_application_inference_profile(self.model_id) and self.detected_model_name:
+                # Map detected model name to a pricing model
+                # e.g., "anthropic.claude-3-5-sonnet-20241022-v2:0" -> "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"
+                if not self.detected_model_name.startswith("bedrock/"):
+                    model_for_pricing = f"bedrock/{self.detected_model_name}"
+                else:
+                    model_for_pricing = self.detected_model_name
+
+            model_info = litellm.get_model_info(model_for_pricing)
             input_cost_per_token = model_info.get("input_cost_per_token", 0)
             output_cost_per_token = model_info.get("output_cost_per_token", 0)
 
@@ -881,19 +1006,26 @@ It's currently empty (just the template). The file is automatically loaded at se
                 cost += cache_read_tokens * input_cost_per_token * 0.1
 
             # Handle OpenAI cache pricing (prompt_tokens_details.cached_tokens)
+            # IMPORTANT: For Bedrock, LiteLLM populates prompt_tokens_details.cached_tokens
+            # with cache_read_input_tokens for compatibility, but we already handled those above.
+            # Only process this field if we're NOT using Bedrock-style cache fields.
             openai_cached_tokens = 0
-            if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details is not None:
-                prompt_details = usage.prompt_tokens_details
-                if hasattr(prompt_details, "cached_tokens") and prompt_details.cached_tokens:
-                    # Ensure cached_tokens is a number, not a mock or None
-                    if isinstance(prompt_details.cached_tokens, (int, float)):
-                        openai_cached_tokens = prompt_details.cached_tokens
-                        # Use cached_input_cost_per_token if available, otherwise fallback to 0.5x multiplier
-                        if cached_input_cost_per_token > 0:
-                            cost += openai_cached_tokens * cached_input_cost_per_token
-                        else:
-                            # Fallback: OpenAI cached tokens typically cost 50% of regular input
-                            cost += openai_cached_tokens * input_cost_per_token * 0.5
+            if not (cache_creation_tokens or cache_read_tokens):  # Only for non-Bedrock models
+                if (
+                    hasattr(usage, "prompt_tokens_details")
+                    and usage.prompt_tokens_details is not None
+                ):
+                    prompt_details = usage.prompt_tokens_details
+                    if hasattr(prompt_details, "cached_tokens") and prompt_details.cached_tokens:
+                        # Ensure cached_tokens is a number, not a mock or None
+                        if isinstance(prompt_details.cached_tokens, (int, float)):
+                            openai_cached_tokens = prompt_details.cached_tokens
+                            # Use cached_input_cost_per_token if available, otherwise fallback to 0.5x multiplier
+                            if cached_input_cost_per_token > 0:
+                                cost += openai_cached_tokens * cached_input_cost_per_token
+                            else:
+                                # Fallback: OpenAI cached tokens typically cost 50% of regular input
+                                cost += openai_cached_tokens * input_cost_per_token * 0.5
 
             # Regular input tokens (excluding all cache tokens)
             regular_input = (
@@ -1048,8 +1180,10 @@ It's currently empty (just the template). The file is automatically loaded at se
             # Filter images if BLOCK_IMAGES is enabled (for non-vision models or user preference)
             messages = self.image_handler.filter_images_if_blocked(messages)
 
-            # Apply prompt caching for supported models (Anthropic/Claude)
-            messages = _apply_prompt_caching(messages, self.model_id)
+            # Apply prompt caching for supported models
+            # Check instance variable for dynamically-tested models (application inference profiles)
+            if self.prompt_caching_supported:
+                messages = _apply_prompt_caching(messages, self.model_id)
 
             # Use LiteLLM for all providers
             try:
@@ -1260,6 +1394,7 @@ It's currently empty (just the template). The file is automatically loaded at se
                                 )
                             elif tool_name == "get_repo_map":
                                 max_files = tool_args.get("max_files", 100)
+                                max_depth = tool_args.get("max_depth")
                                 patterns = ""
                                 if tool_args.get("include_patterns"):
                                     patterns = (
@@ -1269,8 +1404,9 @@ It's currently empty (just the template). The file is automatically loaded at se
                                     patterns = (
                                         f" (exclude: {', '.join(tool_args['exclude_patterns'])})"
                                     )
+                                depth_info = f", depth≤{max_depth}" if max_depth is not None else ""
                                 print(
-                                    f"\033[2m🗺️  Generating repository map (max {max_files} files{patterns})...\033[0m",
+                                    f"\033[2m🗺️  Generating repository map (max {max_files} files{depth_info}{patterns})...\033[0m",
                                     flush=True,
                                 )
                             elif tool_name == "get_file_info":
@@ -1295,8 +1431,12 @@ It's currently empty (just the template). The file is automatically loaded at se
                                 )
                             elif tool_name == "find":
                                 pattern_desc = tool_args.get("pattern", "*")
+                                max_depth = tool_args.get("max_depth")
+                                depth_info = (
+                                    f" (depth≤{max_depth})" if max_depth is not None else ""
+                                )
                                 print(
-                                    f"\033[2m📂 Finding files: {pattern_desc}\033[0m",
+                                    f"\033[2m📂 Finding files: {pattern_desc}{depth_info}\033[0m",
                                     flush=True,
                                 )
                             elif tool_name == "list_skills":