deepagents-code 0.1.67__tar.gz → 0.1.68__tar.gz

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.68](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.67...deepagents-code==0.1.68) (2026-09-10)
+
+### Features
+
+- Recommended GLM 5.3 models are now available in code workflows ([#6211](https://github.com/langchain-ai/deepagents/pull/6211)).
+
+### Bug Fixes
+
+- Added pricing support for Fireworks GLM-5.3 and GLM-5.3 Flash usage ([#6221](https://github.com/langchain-ai/deepagents/pull/6221), [#6223](https://github.com/langchain-ai/deepagents/pull/6223)).
+- Workspace switches now ask for confirmation before restarting the server ([#6178](https://github.com/langchain-ai/deepagents/pull/6178)).
+- Effort changes are now included in cache identity for OpenAI and Anthropic requests ([#6196](https://github.com/langchain-ai/deepagents/pull/6196)).
+- Standardized the recent-thread environment variable ([#6205](https://github.com/langchain-ai/deepagents/pull/6205)).
+- Silenced warnings when the themes config is absent ([#6220](https://github.com/langchain-ai/deepagents/pull/6220)).
+
 ## [0.1.67](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.66...deepagents-code==0.1.67) (2026-09-09)
 
 ### Features

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepagents-code
-Version: 0.1.67
+Version: 0.1.68
 Summary: Terminal coding agent built on the Deep Agents SDK - works with any model, with persistent memory, customizable skills, subagents, and approval controls.
 Project-URL: Homepage, https://www.langchain.com/dcode
 Project-URL: Documentation, https://docs.langchain.com/oss/deepagents/code/overview
@@ -44,7 +44,7 @@ Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.1.1
 Requires-Dist: langgraph-cli[inmem]<1.0.0,>=0.4.31
 Requires-Dist: langgraph-runtime-inmem<1.0.0,>=0.34.0
 Requires-Dist: langgraph-sdk<1.0.0,>=0.4.4
-Requires-Dist: langsmith[sandbox]>=0.12.2
+Requires-Dist: langsmith[sandbox]>=0.12.3
 Requires-Dist: markdownify<2.0.0,>=1.2.3
 Requires-Dist: mcp<2.0.0,>=1.28.1
 Requires-Dist: packaging>=26.2

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "d0fbc7c"
+BUILD_COMMIT = "1c477e9"

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/deepagents_code/_env_vars.py

@@ -506,6 +506,9 @@ hostile values the dotenv denylist does not yet enumerate. The global
 repo file, so a project `.env` cannot disable itself.
 """
 
+RECENT_THREADS = "DEEPAGENTS_CODE_RECENT_THREADS"
+"""Maximum number of recent threads loaded and displayed (default: 20)."""
+
 RECURSION_LIMIT = "DEEPAGENTS_CODE_RECURSION_LIMIT"
 """Override the main agent's LangGraph `recursion_limit` (graph step budget).
 

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.1.67"  # x-release-please-version
+__version__ = "0.1.68"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/deepagents_code/app.py

@@ -873,6 +873,14 @@ class _ServerRespawnResult:
     """
 
 
+@dataclass(frozen=True)
+class _CwdServerReuseResult:
+    """Server decision for a destination workspace."""
+
+    outcome: Literal["continue", "abort", "restart"]
+    workspace_snapshot: tuple[str | None, dict[str, dict[str, Any]]] | None = None
+
+
 def _format_mcp_server_changes(
     previous: list[MCPServerInfo] | None,
     current: list[MCPServerInfo] | None,
@@ -9218,7 +9226,7 @@ class DeepAgentsApp(App):
                 type(raw_endpoint).__name__,
             )
 
-    def _stamp_cache_identity_locally(self) -> None:
+    async def _stamp_cache_identity_locally(self) -> None:
         """Record the just-run model as the cache identity, without a checkpoint.
 
         Used when a turn reached the model but ended without a readable
@@ -9231,16 +9239,14 @@ class DeepAgentsApp(App):
         """
         from datetime import UTC, datetime
 
-        from deepagents_code.cold_cache import cache_identity_params
+        from deepagents_code.configurable_model import _effective_cache_params
 
         self._last_model_request_at = datetime.now(UTC).isoformat()
         self._last_cache_model_spec = self._effective_model_spec() or ""
-        # Record only the cache-identity projection of the session overrides,
-        # matching what the middleware checkpoints in `_last_cache_params`:
-        # the comparison side filters through `cache_identity_params` too, so
-        # unrelated knobs must not read as a cache change here either.
-        self._last_cache_model_params = (
-            cache_identity_params(self._model_params_override) or None
+        self._last_cache_model_params = await asyncio.to_thread(
+            _effective_cache_params,
+            self._last_cache_model_spec,
+            self._model_params_override,
         )
 
     async def _sync_session_cost_from_checkpoint(self) -> None:
@@ -11911,6 +11917,7 @@ class DeepAgentsApp(App):
                 parse_cache_timestamp,
                 resolve_prompt_cache_policy,
             )
+            from deepagents_code.config import _compose_openai_reasoning_effort
             from deepagents_code.model_config import (
                 ModelConfig,
                 is_warning_suppressed,
@@ -11941,6 +11948,14 @@ class DeepAgentsApp(App):
                 fallback_base_url = config.get_base_url(provider)
                 if isinstance(fallback_base_url, str):
                     current_params["base_url"] = fallback_base_url
+            # Match model construction before projecting the cache identity.
+            overrides = self._model_params_override or {}
+            current_params = _compose_openai_reasoning_effort(
+                provider,
+                current_params,
+                overrides.get("reasoning_effort"),
+                overrides.get("reasoning"),
+            )
             # Endpoint changes have their own normalized identity. Keeping
             # `base_url` out of this mapping avoids treating the same endpoint
             # as two independent identity changes.
@@ -12042,11 +12057,13 @@ class DeepAgentsApp(App):
                 age_seconds = max(elapsed or 0.0, 0.0)
                 if (
                     model_spec != last_spec
-                    # Only cache-participating params are compared: `/effort`
-                    # and friends rewrite `model_params` without touching the
-                    # prefix, and must not read as a cache identity change.
-                    or cache_identity_params(current_params)
-                    != cache_identity_params(last_params)
+                    # Only cache-participating params are compared. OpenAI and
+                    # Anthropic reasoning-effort settings participate because
+                    # both providers render effort into the prefix: OpenAI may
+                    # rewrite model-side instructions, Anthropic always renders
+                    # the thinking config into the prompt.
+                    or cache_identity_params(current_params, model_spec=model_spec)
+                    != cache_identity_params(last_params, model_spec=last_spec)
                     # `None` means no endpoint was ever recorded -- e.g. a
                     # thread checkpointed before this field existed, or one
                     # whose stored value was unreadable and discarded on load.
@@ -18777,7 +18794,7 @@ class DeepAgentsApp(App):
                 # the in-memory request time. Leaving it stale would make the
                 # very next send report "no record of when this thread last
                 # reached the model" seconds after a turn that plainly did.
-                self._stamp_cache_identity_locally()
+                await self._stamp_cache_identity_locally()
             # Finalize any subagent rows left "running" — an interrupt cancels
             # the worker before the bridge emits terminal events (a cancel is a
             # BaseException, which the bridge's `except Exception` skips), so the
@@ -29109,23 +29126,18 @@ class DeepAgentsApp(App):
 
     async def _reuse_server_after_cwd_switch(
         self, cwd: Path, thread_id: str
-    ) -> Literal["continue", "abort", "restart"]:
+    ) -> _CwdServerReuseResult:
         remote = self._remote_agent()
-        if remote is None or self._sandbox_type is not None:
-            return "restart"
+        if remote is None:
+            return _CwdServerReuseResult("restart")
         from langgraph_sdk.errors import ConflictError
 
-        previous_cwd = Path(self._cwd)
-        previous_server_cwd = (
-            self._server_kwargs.get("cwd") if self._server_kwargs is not None else None
-        )
-        previous_mcp_info = self._mcp_server_info
         workspace_snapshot = remote._snapshot_workspace()
         config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
         try:
-            mcp_info = await remote.aswitch_workspace(config, str(cwd))
+            await remote.aswitch_workspace(config, str(cwd), validate_only=True)
         except ConflictError:
-            return "restart"
+            return _CwdServerReuseResult("restart")
         except Exception as exc:
             logger.exception("Server could not validate the destination workspace")
             self.notify(
@@ -29135,21 +29147,33 @@ class DeepAgentsApp(App):
                 timeout=10,
                 markup=False,
             )
-            return "abort"
+            return _CwdServerReuseResult("abort")
+        return _CwdServerReuseResult(
+            "continue",
+            workspace_snapshot=workspace_snapshot,
+        )
+
+    async def _apply_reused_server_cwd_switch(
+        self, cwd: Path, thread_id: str, reuse: _CwdServerReuseResult
+    ) -> None:
+        remote = self._remote_agent()
+        if remote is None or reuse.workspace_snapshot is None:
+            msg = "A validated workspace switch has no remote workspace snapshot."
+            raise RuntimeError(msg)
+        previous_cwd = Path(self._cwd)
+        previous_server_cwd = (
+            self._server_kwargs.get("cwd") if self._server_kwargs is not None else None
+        )
+        previous_mcp_info = self._mcp_server_info
+        config: RunnableConfig = {"configurable": {"thread_id": thread_id}}
         try:
             self._preserve_launch_relative_server_paths(previous_cwd)
             await self._switch_process_cwd(cwd)
             if self._server_kwargs is not None:
                 self._server_kwargs["cwd"] = self._cwd
-            self._mcp_server_info = mcp_info
-            self._mcp_optimistic_original_server_info.clear()
-            self._pending_mcp_login_reconnect = False
-            self._pending_mcp_disable_reconnect_servers.clear()
-            self._mcp_viewer_disable_toggled = False
-            self._sync_pending_mcp_reconnect()
-            self._refresh_mcp_client_state()
+            mcp_server_info = await remote.aswitch_workspace(config, str(cwd))
         except BaseException:
-            remote._restore_workspace(workspace_snapshot)
+            remote._restore_workspace(reuse.workspace_snapshot)
             self._mcp_server_info = previous_mcp_info
             if self._server_kwargs is not None:
                 self._server_kwargs["cwd"] = previous_server_cwd
@@ -29159,8 +29183,16 @@ class DeepAgentsApp(App):
                 await self._switch_process_cwd(previous_cwd)
             self._refresh_mcp_client_state()
             raise
-        else:
-            return "continue"
+        self._mcp_server_info = mcp_server_info
+        self._mcp_optimistic_original_server_info.clear()
+        self._pending_mcp_login_reconnect = False
+        self._pending_mcp_disable_reconnect_servers.clear()
+        self._mcp_viewer_disable_toggled = False
+        self._sync_pending_mcp_reconnect()
+        try:
+            self._refresh_mcp_client_state()
+        except Exception:
+            logger.exception("Failed to refresh MCP state after cwd switch")
 
     @staticmethod
     async def _preview_project_settings_change(cwd: Path) -> bool:
@@ -29345,6 +29377,9 @@ class DeepAgentsApp(App):
                 failed (the caller should stop the resume). The user-declined
                 abort fires only when `abort` is set, and the switch-failed
                 abort only when `restart_server` is True.
+
+        Raises:
+            RuntimeError: If an in-session switch has no server decision.
         """
         target = await self._thread_cwd_mismatch(thread_id)
         if target is None:
@@ -29352,8 +29387,21 @@ class DeepAgentsApp(App):
 
         from deepagents_code.tui.widgets.cwd_switch import CwdSwitchPromptScreen
 
-        project_settings_change_detected = await self._preview_project_settings_change(
-            target
+        reuse = (
+            await self._reuse_server_after_cwd_switch(target, thread_id)
+            if restart_server
+            else None
+        )
+        if reuse is not None and reuse.outcome == "abort":
+            return "abort"
+        owns_server = self._server_kwargs is not None and self._server_proc is not None
+        server_refusal: Literal["restart", "unavailable"] | None = None
+        if reuse is not None and reuse.outcome == "restart":
+            server_refusal = "restart" if owns_server else "unavailable"
+        project_settings_change_detected = (
+            await self._preview_project_settings_change(target)
+            if server_refusal is None
+            else False
         )
         choice = await self._push_screen_wait(
             CwdSwitchPromptScreen(
@@ -29361,27 +29409,30 @@ class DeepAgentsApp(App):
                 thread_cwd=str(target),
                 project_settings_change_detected=project_settings_change_detected,
                 abort=abort,
+                server_refusal=server_refusal,
             )
         )
+        if server_refusal == "unavailable":
+            return "abort"
+        if server_refusal == "restart" and choice != "switch":
+            return "abort"
         if choice == "abort":
+            if reuse is not None and reuse.workspace_snapshot is not None:
+                remote = self._remote_agent()
+                if remote is not None:
+                    remote._restore_workspace(reuse.workspace_snapshot)
             return "abort"
         if choice == "switch":
             if restart_server:
-                reuse_outcome = await self._reuse_server_after_cwd_switch(
-                    target, thread_id
-                )
-                outcome = (
-                    await self._replace_server_after_cwd_switch(target)
-                    if reuse_outcome == "restart"
-                    else reuse_outcome
-                )
+                if reuse is None:
+                    msg = "An in-session cwd switch has no server decision."
+                    raise RuntimeError(msg)
+                outcome = reuse.outcome
+                if outcome == "restart":
+                    outcome = await self._replace_server_after_cwd_switch(target)
+                elif outcome == "continue":
+                    await self._apply_reused_server_cwd_switch(target, thread_id, reuse)
                 if outcome == "abort":
-                    # A failed restart returns "abort" just like a user-declined
-                    # abort, so the caller cannot tell them apart.
-                    # `_replace_server_after_cwd_switch` already rolled back and
-                    # notified, but that toast is transient -- leave a persistent
-                    # in-chat record so a failed switch is not mistaken for a
-                    # deliberate cancel.
                     await self._mount_message(
                         AppMessage(
                             "Could not switch to the thread's directory; staying "
@@ -29399,6 +29450,10 @@ class DeepAgentsApp(App):
             )
             return "continue"
 
+        if reuse is not None and reuse.workspace_snapshot is not None:
+            remote = self._remote_agent()
+            if remote is not None:
+                remote._restore_workspace(reuse.workspace_snapshot)
         self.notify(
             "Continuing in the current directory. Cached local context may be "
             "stale and tools may operate in the wrong project.",

deepagents_code-0.1.68/deepagents_code/bundled_prices.json

@@ -0,0 +1,39 @@
+[
+  {
+    "id": "openai",
+    "name": "OpenAI",
+    "api_pattern": "https://api\\.openai\\.com",
+    "models": [
+      {
+        "id": "gpt-6-astra",
+        "match": { "or": [{ "equals": "gpt-6-astra" }, { "regex": "^gpt-6-astra-\\d{4}-\\d{2}-\\d{2}$" }] },
+        "price_comments": "Stopgap pending release of merged pydantic/genai-prices#680",
+        "prices": {
+          "input_mtok": { "base": 10.0, "tiers": [{ "start": 271999, "price": 20.0 }] },
+          "cache_write_mtok": { "base": 12.5, "tiers": [{ "start": 271999, "price": 25.0 }] },
+          "cache_read_mtok": { "base": 1.0, "tiers": [{ "start": 271999, "price": 2.0 }] },
+          "output_mtok": { "base": 50.0, "tiers": [{ "start": 271999, "price": 75.0 }] }
+        }
+      }
+    ]
+  },
+  {
+    "id": "baseten",
+    "name": "Baseten",
+    "api_pattern": "https://inference\\.baseten\\.co",
+    "models": [
+      { "id": "zai-org/GLM-4.7", "match": { "equals": "glm-4-7" }, "price_comments": "Bare alias omitted from pydantic/genai-prices#660", "prices": { "input_mtok": 0.6, "cache_read_mtok": 0.12, "output_mtok": 2.2 } },
+      { "id": "thinkingmachines/inkling", "match": { "equals": "inkling" }, "price_comments": "Bare alias omitted from pydantic/genai-prices#660", "prices": { "input_mtok": 1.0, "cache_read_mtok": 0.17, "output_mtok": 4.05 } },
+      { "id": "thinkingmachines/inkling-small", "match": { "equals": "inkling-small" }, "price_comments": "Bare alias omitted from pydantic/genai-prices#660", "prices": { "input_mtok": 0.5, "cache_read_mtok": 0.1, "output_mtok": 1.2 } }
+    ]
+  },
+  {
+    "id": "fireworks",
+    "name": "Fireworks",
+    "api_pattern": "https://api\\.fireworks\\.ai",
+    "models": [
+      { "id": "glm-5p3", "match": { "equals": "accounts/fireworks/models/glm-5p3" }, "price_comments": "Fireworks deployment omitted from pydantic/genai-prices#617", "prices": { "input_mtok": 1.4, "cache_read_mtok": 0.26, "output_mtok": 4.4 } },
+      { "id": "glm-5p3-flash", "match": { "equals": "accounts/fireworks/models/glm-5p3-flash" }, "price_comments": "Fireworks deployment omitted from pydantic/genai-prices#617", "prices": { "input_mtok": 0.15, "cache_read_mtok": 0.03, "output_mtok": 0.5 } }
+    ]
+  }
+]

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/deepagents_code/client/remote_client.py

@@ -803,10 +803,16 @@ class RemoteAgent:
         return await self.abind_workspace(config, self._workspace_cwd)
 
     async def _request_workspace(
-        self, config: Mapping[str, Any], cwd: str
+        self,
+        config: Mapping[str, Any],
+        cwd: str,
+        *,
+        validate_only: bool = False,
     ) -> tuple[dict[str, Any], list[MCPServerInfo] | None]:
         thread_id = _require_thread_id(config)
         payload: dict[str, Any] = {"cwd": cwd}
+        if validate_only:
+            payload["validate_only"] = True
         if self._workspace_config is not None:
             payload["workspace_config"] = self._workspace_config
             payload["config_fingerprint"] = self._workspace_config_fingerprint
@@ -874,18 +880,25 @@ class RemoteAgent:
         self._workspaces.update(workspaces)
 
     async def aswitch_workspace(
-        self, config: Mapping[str, Any], cwd: str
+        self,
+        config: Mapping[str, Any],
+        cwd: str,
+        *,
+        validate_only: bool = False,
     ) -> list[MCPServerInfo] | None:
-        """Bind one thread to a workspace and make it the default for new threads.
+        """Bind or validate one thread's workspace and return MCP metadata.
 
         Returns:
             MCP metadata for the server runtime selected by the binding.
         """
         thread_id = _require_thread_id(config)
-        workspace, mcp_server_info = await self._request_workspace(config, cwd)
-        self._workspace_cwd = cwd
-        self._workspaces.clear()
-        self._workspaces[thread_id] = workspace
+        workspace, mcp_server_info = await self._request_workspace(
+            config, cwd, validate_only=validate_only
+        )
+        if not validate_only:
+            self._workspace_cwd = cwd
+            self._workspaces.clear()
+            self._workspaces[thread_id] = workspace
         return mcp_server_info
 
     def set_workspace(

{deepagents_code-0.1.67 → deepagents_code-0.1.68}/deepagents_code/cold_cache.py

@@ -76,12 +76,14 @@ CACHE_IDENTITY_PARAM_KEYS = frozenset(
 )
 """Invocation params that select or invalidate a provider cache entry.
 
-The identity check compares only these. Comparing whole `model_params` maps
-instead would report a model change for every unrelated knob -- `/effort`
-rewrites `reasoning_effort` wholesale, and `temperature` or `max_tokens` are
-just as inert for caching -- and the modal would then assert that "the previous
-cached prefix cannot be reused" when nothing about the prefix moved. A modal
-that fires on a false premise trains users into the permanent suppression.
+The identity check compares only these, plus the provider's reasoning-effort
+settings where a change is documented to move the cached prefix (see
+`_EFFORT_CACHE_IDENTITY_PROVIDERS`). Comparing whole `model_params` maps
+instead would report a model change for every unrelated knob -- `temperature`
+or `max_tokens`, for example -- and the modal would then assert that "the
+previous cached prefix cannot be reused" when nothing about the prefix moved.
+A modal that fires on a false premise trains users into the permanent
+suppression.
 
 `cache_control` is deliberately absent: `AnthropicPromptCachingMiddleware`
 overwrites `model_settings["cache_control"]` with its own TTL on every
@@ -90,6 +92,28 @@ user-supplied value never reaches the wire. Comparing it would report an
 identity change for a setting the effective requests never differed on.
 """
 
+_EFFORT_CACHE_IDENTITY_PROVIDERS = frozenset({"openai", "openai_codex", "anthropic"})
+"""Providers whose reasoning-effort settings participate in cache identity.
+
+OpenAI documents `reasoning.effort` as a setting that "can change model-side
+reasoning instructions" for its models generally -- the GPT-6 Astra
+`configuration_update` escape hatch exists precisely because the top-level
+knob rewrites the hidden prefix -- and pre-GPT-5.6 minimum cacheable lengths
+vary with request settings including reasoning effort:
+https://developers.openai.com/api/docs/guides/prompt-caching
+
+Anthropic is stricter: the thinking/effort configuration is rendered into the
+prompt, so changing it always invalidates message blocks:
+https://platform.claude.com/docs/en/build-with-claude/prompt-caching
+
+Other providers (`google_genai`, `fireworks`, `xai`, ...) document no link
+between effort and cache identity, so their effort settings stay out of the
+projection: including them would fire the modal on a false premise.
+`openai_codex` resolves no cache policy today (`resolve_prompt_cache_policy`
+gates on the `openai` provider), so its entries matter only for checkpointed
+storage until that changes.
+"""
+
 _OPENAI_MODEL_VERSION = re.compile(r"^gpt-(?P<major>\d+)(?:\.(?P<minor>\d+))?")
 _DEFAULT_ENDPOINT_PORTS = {"http": 80, "https": 443}
 
@@ -865,23 +889,24 @@ def resolve_prompt_cache_policy(
     if provider != "openai" or not endpoint_ok("api.openai.com"):
         return None
 
-    # Write pricing follows the model version, independent of retention: only
-    # GPT-5.6+ bills a miss as a cache write.
-    write_bucket: CacheWriteBucket = (
-        "generic_write" if _openai_uses_thirty_minute_cache(model_name) else "generic"
-    )
+    # GPT-5.6+ uses `prompt_cache_options.ttl = "30m"`; the legacy
+    # `prompt_cache_retention` knob does not extend that family to one or 24
+    # hours. OpenAI documents 30 minutes as a guaranteed minimum, so the prefix
+    # may still be warm after this window.
+    # https://developers.openai.com/api/docs/guides/prompt-caching
+    if _openai_uses_thirty_minute_cache(model_name):
+        return PromptCachePolicy(
+            provider_name="OpenAI",
+            window_seconds=1800,
+            confidence="may_be_cold",
+            minimum_tokens=_OPENAI_MINIMUM_TOKENS,
+            write_bucket="generic_write",
+        )
 
     # `in_memory` and `24h` are documented *maximums* ("up to one hour", "a
     # maximum, not a guarantee"): entries may be evicted earlier, so a warning
     # is only defensible once the maximum has passed -- at which point the
     # entry is gone rather than merely doubtful.
-    #
-    # Checked before the GPT-5.6+ minimum because the two knobs are
-    # independent: `prompt_cache_retention` states a maximum lifetime while the
-    # 5.6+ guarantee states a minimum one, and an explicitly configured
-    # retention is the later, firmer bound. Warning a user who asked for `24h`
-    # at the 30-minute mark would contradict their own configuration.
-    # https://platform.openai.com/docs/guides/prompt-caching
     retention = params.get("prompt_cache_retention")
     retention_windows = {"in_memory": 3600, "24h": 86400}
     window = retention_windows.get(retention) if isinstance(retention, str) else None
@@ -891,41 +916,79 @@ def resolve_prompt_cache_policy(
             window_seconds=window,
             confidence="expired",
             minimum_tokens=_OPENAI_MINIMUM_TOKENS,
-            write_bucket=write_bucket,
-        )
-
-    if write_bucket == "generic_write":
-        # 30 minutes is the documented guaranteed *minimum* for GPT-5.6+ with
-        # no explicit retention configured, but OpenAI may retain the prefix
-        # longer, so past the window it can only be treated as possibly cold.
-        # https://platform.openai.com/docs/guides/prompt-caching
-        return PromptCachePolicy(
-            provider_name="OpenAI",
-            window_seconds=1800,
-            confidence="may_be_cold",
-            minimum_tokens=_OPENAI_MINIMUM_TOKENS,
-            write_bucket=write_bucket,
+            write_bucket="generic",
         )
     return None
 
 
-def cache_identity_params(model_params: Mapping[str, Any] | None) -> dict[str, Any]:
+_EFFORT_IDENTITY_KEY = "reasoning_effort"
+"""Checkpoint key the effective effort value is projected under.
+
+Canonical rather than request-shaped: the identity question is whether the
+effort value changed, not which request shape carried it. Storing the native
+shape would report an identity change for a flat-to-nested representation
+swap that leaves the prefix untouched.
+"""
+
+
+def _effort_identity_entries(
+    model_params: Mapping[str, Any], provider: str
+) -> dict[str, Any]:
+    """Project the provider's effective reasoning effort from `model_params`.
+
+    Uses the same path resolution and precedence as `/effort`
+    (`reasoning_effort._effort_paths`), so native request shapes -- OpenAI's
+    nested `reasoning: {"effort": ...}`, Anthropic's `output_config.effort`
+    -- participate alongside the canonical flat `reasoning_effort`. Sibling
+    keys in nested containers (`reasoning.summary`, say) stay out: they are
+    not documented to move the prefix, and including them would fire the
+    modal on a false premise.
+
+    Args:
+        model_params: Full invocation params.
+        provider: Lowercase provider name from the model spec.
+
+    Returns:
+        `{_EFFORT_IDENTITY_KEY: value}` when an effort setting is present and
+            non-`None`, or `{}` when the provider has none configured.
+    """
+    from deepagents_code.reasoning_effort import _effort_paths
+
+    for path in _effort_paths(provider):
+        if len(path) == 1:
+            if path[0] in model_params and model_params[path[0]] is not None:
+                return {_EFFORT_IDENTITY_KEY: model_params[path[0]]}
+        else:
+            nested = model_params.get(path[0])
+            if isinstance(nested, dict) and nested.get(path[1]) is not None:
+                return {_EFFORT_IDENTITY_KEY: nested[path[1]]}
+    return {}
+
+
+def cache_identity_params(
+    model_params: Mapping[str, Any] | None,
+    *,
+    model_spec: str | None = None,
+) -> dict[str, Any]:
     """Project the params that participate in prompt-cache identity.
 
     Args:
         model_params: Full invocation params, or `None`.
+        model_spec: Optional `provider:model` spec used for model-specific keys.
 
     Returns:
-        Only the `CACHE_IDENTITY_PARAM_KEYS` entries present, so two calls can
-            be compared without unrelated knobs reading as a cache change.
+        Cache-identity entries, excluding unrelated invocation knobs.
     """
     if not model_params:
         return {}
-    return {
-        key: value
-        for key, value in model_params.items()
-        if key in CACHE_IDENTITY_PARAM_KEYS
-    }
+    keys = CACHE_IDENTITY_PARAM_KEYS
+    if model_spec:
+        provider = model_spec.partition(":")[0].strip().lower()
+        if provider in _EFFORT_CACHE_IDENTITY_PROVIDERS:
+            result = {key: value for key, value in model_params.items() if key in keys}
+            result.update(_effort_identity_entries(model_params, provider))
+            return result
+    return {key: value for key, value in model_params.items() if key in keys}
 
 
 def estimate_rewarm_cost(