patchpal 0.25.2__tar.gz → 0.25.4__tar.gz

{patchpal-0.25.2/patchpal.egg-info → patchpal-0.25.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.25.2
+Version: 0.25.4
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0

{patchpal-0.25.2 → patchpal-0.25.4}/patchpal/__init__.py

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

{patchpal-0.25.2 → patchpal-0.25.4}/patchpal/agent/function_calling.py

@@ -311,7 +311,9 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
     """Apply prompt caching markers to messages following OpenCode's strategy.
 
     Caches:
-    - System messages (first 1-2 messages with role="system")
+    - The FIRST system message only (the static SYSTEM_PROMPT). The volatile
+      per-call date/time is appended as a trailing system message and is
+      deliberately NOT cached (its content changes every call).
     - Last 2 non-system messages (recent context, any role except system)
 
     IMPORTANT: AWS Bedrock enforces a hard limit of 4 cache control blocks per request.
@@ -389,6 +391,13 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
     # Find system messages (usually at the start)
     system_messages = [i for i, msg in enumerate(messages) if msg.get("role") == "system"]
 
+    # Only the FIRST system message (the static SYSTEM_PROMPT) is a stable cache
+    # prefix. A trailing system message (the per-call date/time, appended at the
+    # end of the list) must NOT be cached: its content changes every call, so a
+    # breakpoint there is wasted and can invalidate the prefix. Restrict caching
+    # to the first system message only.
+    system_messages = system_messages[:1]
+
     # Find last 2 non-system messages (recent context)
     non_system_messages = [i for i, msg in enumerate(messages) if msg.get("role") != "system"]
     last_two_indices = (
@@ -401,8 +410,10 @@ def _apply_prompt_caching(messages: List[Dict[str, Any]], model_id: str) -> List
     # Build list of candidate indices to cache (prioritize system messages)
     candidates = []
 
-    # Add system messages first (up to 2)
-    for idx in system_messages[:2]:
+    # Add the (single, static) system message first. `system_messages` was
+    # already restricted to the first system message above; the trailing
+    # per-call datetime is deliberately excluded.
+    for idx in system_messages:
         msg = messages[idx]
         # Check if this message already has any cache markers
         has_cache = False
@@ -1176,12 +1187,19 @@ Repository root takes priority if both exist."""
             # Show thinking message
             print("\033[2m🤔 Thinking...\033[0m", flush=True)
 
-            # Prepare messages with system prompt and dynamic date/time
-            # Date/time is regenerated on each call to prevent staleness in long sessions
-            messages = [
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "system", "content": _get_current_datetime_message()},
-            ] + self.messages
+            # Prepare messages with system prompt and dynamic date/time.
+            # The static SYSTEM_PROMPT is kept FIRST so it (plus the tools block)
+            # forms a stable, byte-identical cacheable prefix across every call.
+            # The volatile date/time is appended at the END instead of in a second
+            # cached system block: placing a per-call-changing string inside the
+            # cached prefix previously invalidated the prefix every call and wasted
+            # a breakpoint (see COST_RECOMMENDATIONS_RANKED.md, Tier 2 fix).
+            # Date/time is regenerated on each call to prevent staleness in long sessions.
+            messages = (
+                [{"role": "system", "content": SYSTEM_PROMPT}]
+                + self.messages
+                + [{"role": "system", "content": _get_current_datetime_message()}]
+            )
 
             # Filter images if BLOCK_IMAGES is enabled (for non-vision models or user preference)
             messages = self.image_handler.filter_images_if_blocked(messages)
@@ -1268,6 +1286,24 @@ Repository root takes priority if both exist."""
                     ):
                         self.cumulative_cache_read_tokens += response.usage.cache_read_input_tokens
 
+                    # Per-call cache instrumentation (Tier 2 #6): logs this call's
+                    # write/read split so the suffix-rewrite / datetime-breakpoint
+                    # hypotheses can be confirmed with data instead of inference.
+                    # Zero overhead unless PATCHPAL_DEBUG_CACHE=true.
+                    if os.environ.get("PATCHPAL_DEBUG_CACHE") == "true":
+                        _call_writes = (
+                            getattr(response.usage, "cache_creation_input_tokens", 0) or 0
+                        )
+                        _call_reads = getattr(response.usage, "cache_read_input_tokens", 0) or 0
+                        _call_prompt = getattr(response.usage, "prompt_tokens", 0) or 0
+                        _denom = _call_writes + _call_reads
+                        _hit = (_call_reads / _denom * 100) if _denom else 0.0
+                        print(
+                            f"[CACHE DEBUG] call #{self.total_llm_calls}: "
+                            f"prompt={_call_prompt} write={_call_writes} "
+                            f"read={_call_reads} this-call-hit={_hit:.1f}%"
+                        )
+
                     # Track OpenAI cache tokens (prompt_tokens_details.cached_tokens)
                     # Only track for OpenAI models to avoid LiteLLM cross-contamination
                     if self._is_openai_model() and hasattr(response.usage, "prompt_tokens_details"):

{patchpal-0.25.2 → patchpal-0.25.4}/patchpal/cli/sandbox.py

@@ -198,7 +198,14 @@ def detect_llm_endpoints_from_env():
         or os.environ.get("AWS_REGION_NAME")  # LiteLLM-specific
     )
     if aws_region and (
-        os.environ.get("AWS_ACCESS_KEY_ID") or os.environ.get("AWS_SECRET_ACCESS_KEY")
+        os.environ.get("AWS_ACCESS_KEY_ID")
+        or os.environ.get("AWS_SECRET_ACCESS_KEY")
+        # SSO/ADFS profiles (created via `aws configure sso`) authenticate via a
+        # named profile and a cached SSO token instead of static access keys.
+        # In that case AWS_PROFILE is set but AWS_ACCESS_KEY_ID is not, so detect
+        # it here too — otherwise Bedrock endpoints would be omitted from the
+        # firewall allowlist and traffic would be blocked.
+        or os.environ.get("AWS_PROFILE")
     ):
         # Add Bedrock endpoints for the region
         # Support both GovCloud and standard regions
@@ -659,6 +666,19 @@ def build_container_args(sandbox_args, patchpal_args, env_file_keys=None):
         container_args.extend(["-v", f"{patchpal_dir}:/root/.patchpal"])
         mounted_paths.add(patchpal_dir)
 
+    # Mount ~/.aws if it exists (read-only).
+    # Required for AWS SSO/ADFS authentication: credentials for a named profile
+    # (created via `aws configure sso`) are resolved from ~/.aws/config, and the
+    # short-lived SSO token is cached under ~/.aws/sso/cache/. Mounting this
+    # directory lets boto3/LiteLLM inside the container resolve AWS_PROFILE just
+    # as it would on the host. It also covers static shared-credential setups
+    # (~/.aws/credentials). Mounted read-only; refresh the token on the host with
+    # `aws sso login --profile <name>` when it expires.
+    aws_dir = os.path.expanduser("~/.aws")
+    if os.path.isdir(aws_dir) and aws_dir not in mounted_paths:
+        container_args.extend(["-v", f"{aws_dir}:/root/.aws:ro"])
+        mounted_paths.add(aws_dir)
+
     # Development mode: mount local patchpal source code
     dev_mode = False
     if sandbox_args.dev:

{patchpal-0.25.2 → patchpal-0.25.4/patchpal.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchpal
-Version: 0.25.2
+Version: 0.25.4
 Summary: An agentic coding and automation assistant, supporting both local and cloud LLMs
 Author: PatchPal Contributors
 License-Expression: Apache-2.0

{patchpal-0.25.2 → patchpal-0.25.4}/tests/test_agent.py

@@ -645,6 +645,78 @@ def test_prompt_caching_idempotent():
     assert len([k for k in cached_twice[1]["content"][0].keys() if "cache" in k]) == 1
 
 
+def _has_cache_marker(message):
+    """Return True if a message's content carries a cache_control/cachePoint marker."""
+    content = message.get("content")
+    if not isinstance(content, list):
+        return False
+    return any(
+        isinstance(block, dict) and ("cache_control" in block or "cachePoint" in block)
+        for block in content
+    )
+
+
+def test_prompt_caching_excludes_trailing_datetime_system_message():
+    """Regression test for the prompt-caching cost fix.
+
+    The volatile per-call date/time is appended as a TRAILING system message
+    (after the conversation), while the static SYSTEM_PROMPT is the FIRST
+    system message. Only the first system message forms a stable, cacheable
+    prefix; a breakpoint on the trailing date/time would change every call,
+    invalidating the cached prefix and wasting a (Bedrock-limited) breakpoint.
+
+    This test locks in that invariant: _apply_prompt_caching must mark the
+    first system message but must NOT mark a trailing system message.
+    See DATETIME_CACHE_PREFIX_FIX.md / COST_RECOMMENDATIONS_RANKED.md (Tier 2).
+    """
+    from patchpal.agent.function_calling import _apply_prompt_caching
+
+    # Mirrors the message assembly in PatchPalAgent.run(): static SYSTEM_PROMPT
+    # first, conversation in the middle, volatile date/time appended last.
+    messages = [
+        {"role": "system", "content": "STATIC SYSTEM PROMPT (cacheable)"},
+        {"role": "user", "content": "Hello"},
+        {"role": "assistant", "content": "Hi there!"},
+        {"role": "user", "content": "How are you?"},
+        {"role": "system", "content": "## Current Date and Time\nToday is ..."},
+    ]
+
+    cached = _apply_prompt_caching(messages.copy(), "anthropic/claude-sonnet-4-5")
+
+    # First (static) system message MUST be cached.
+    assert cached[0]["role"] == "system"
+    assert _has_cache_marker(cached[0]), "static SYSTEM_PROMPT should be cached"
+
+    # Trailing (volatile) date/time system message MUST NOT be cached.
+    assert cached[-1]["role"] == "system"
+    assert not _has_cache_marker(cached[-1]), (
+        "trailing per-call date/time must never receive a cache breakpoint"
+    )
+
+    # Exactly one system message should carry a marker (the static prefix).
+    cached_system_count = sum(
+        1 for m in cached if m.get("role") == "system" and _has_cache_marker(m)
+    )
+    assert cached_system_count == 1
+
+
+def test_datetime_message_distinct_from_system_prompt():
+    """The date/time message must be a separate string from SYSTEM_PROMPT.
+
+    The fix depends on keeping the volatile date/time OUT of the static
+    SYSTEM_PROMPT so the latter stays byte-identical (and cacheable) across
+    calls. This guards against a future refactor folding the date/time back
+    into the system prompt.
+    """
+    from patchpal.agent.function_calling import SYSTEM_PROMPT, _get_current_datetime_message
+
+    datetime_msg = _get_current_datetime_message()
+
+    assert "Current Date and Time" in datetime_msg
+    # The static prompt must not embed the volatile date/time header.
+    assert "Current Date and Time" not in SYSTEM_PROMPT
+
+
 def test_agent_handles_keyboard_interrupt_during_tool_execution(monkeypatch):
     """Test that agent properly cleans up conversation state when interrupted during tool execution."""
     from patchpal.agent import create_agent