deepagents-code 0.1.64__tar.gz → 0.1.65__tar.gz

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/AGENTS.md

@@ -126,7 +126,7 @@ Debug logging is configured **once**, on the `deepagents_code` package logger, b
 
 - Do **not** add per-module `configure_debug_logging(logger)` calls. They are redundant now that the package logger is configured at import, and they reintroduce the duplicate-handler problem the single-config approach solves.
 - Every module should create its logger with `logging.getLogger(__name__)` so it stays inside the `deepagents_code.*` hierarchy and inherits the package handler. Don't set `logger.propagate = False` or attach your own handlers.
-- The **file** handler only attaches when `DEEPAGENTS_CODE_DEBUG` is truthy; that path is a single env-var read, so it's safe on the startup hot path. See `DEVELOPMENT.md` for the `DEEPAGENTS_CODE_DEBUG` / `DEEPAGENTS_CODE_DEBUG_FILE` / `DEEPAGENTS_CODE_LOG_LEVEL` env vars.
+- The **file** handler only attaches when `DEEPAGENTS_CODE_DEBUG` is truthy and the active thread is known; that path is a small env-var read and filesystem operation, so it's safe on the startup hot path. See `DEVELOPMENT.md` for the `DEEPAGENTS_CODE_DEBUG` / `DEEPAGENTS_CODE_DEBUG_DIRECTORY` / `DEEPAGENTS_CODE_LOG_LEVEL` env vars.
 - Separately, an **always-on in-memory ring buffer** (`_debug_buffer.install_log_buffer`, called from `__init__.py` right before `configure_debug_logging`) attaches unconditionally at import so the in-app Debug Console (`Ctrl+\`) can tail recent `deepagents_code.*` records without file logging. It captures `INFO` and above by default (or `DEEPAGENTS_CODE_LOG_LEVEL`), and may lower the package logger to `INFO` for the process lifetime. It never spills to the terminal (a handler is always found, so `lastResort` is skipped) and is bounded (a `deque` of 1000 records *per log level*), so it's cheap enough to keep on. Because it installs *before* `configure_debug_logging`, warnings that helper emits at startup are captured and visible in the console.
 
 ## CLI help screen

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/ARCHITECTURE.md

@@ -85,4 +85,6 @@ The main cost is the client/server boundary. When debugging, first decide which
 - For cost estimates and local pricing overrides (`prices.json`), see
   [`PRICING.md`](./PRICING.md).
 - For security boundaries, see [`THREAT_MODEL.md`](./THREAT_MODEL.md).
+- For how a transient model failure is retried after output has already streamed,
+  see [`STREAMING_RETRY_DESIGN.md`](./STREAMING_RETRY_DESIGN.md).
 - For package-specific coding conventions, see [`AGENTS.md`](./AGENTS.md).

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.65](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.64...deepagents-code==0.1.65) (2026-08-28)
+
+### Features
+
+- Added Python extension support, including discovery, configuration and loading, runtime hosting, and trust and inspection UX ([#5631](https://github.com/langchain-ai/deepagents/issues/5631), [#5632](https://github.com/langchain-ai/deepagents/issues/5632), [#5633](https://github.com/langchain-ai/deepagents/issues/5633), [#5634](https://github.com/langchain-ai/deepagents/issues/5634))
+- Added a `/summarization-model` command and model picker for configuring the summarization model ([#5884](https://github.com/langchain-ai/deepagents/issues/5884), [#5932](https://github.com/langchain-ai/deepagents/issues/5932))
+- Added support for optional extra uninstall commands ([#5875](https://github.com/langchain-ai/deepagents/issues/5875))
+- Added an option to show visible reasoning ([#5887](https://github.com/langchain-ai/deepagents/issues/5887))
+
+### Bug Fixes
+
+- Improved model and task reliability by retrying interrupted model streams, recovering stale pending work before compaction, and isolating parallel `task` failures ([#5905](https://github.com/langchain-ai/deepagents/issues/5905), [#5909](https://github.com/langchain-ai/deepagents/issues/5909), [#5954](https://github.com/langchain-ai/deepagents/issues/5954))
+- Improved server restart handling by waiting for graph readiness before continuing ([#5947](https://github.com/langchain-ai/deepagents/issues/5947))
+- Capped MCP tool names for provider compatibility ([#5953](https://github.com/langchain-ai/deepagents/issues/5953))
+- Fixed Auto approval gate path expansion handling and now records Auto classifier deadline misses as traced errors ([#5941](https://github.com/langchain-ai/deepagents/issues/5941), [#5944](https://github.com/langchain-ai/deepagents/issues/5944))
+- Completed ASCII UI fallbacks and hid inactive F2 tool hints ([#5930](https://github.com/langchain-ai/deepagents/issues/5930), [#5939](https://github.com/langchain-ai/deepagents/issues/5939))
+- Isolated debug logs by thread ([#5921](https://github.com/langchain-ai/deepagents/issues/5921))
+- Updated rubric grader model changes to apply without a restart ([#5885](https://github.com/langchain-ai/deepagents/issues/5885))
+
 ## [0.1.64](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.63...deepagents-code==0.1.64) (2026-08-28)
 
 ### Features

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/COMMANDS.md

@@ -8,7 +8,7 @@ Regenerate this file with `make commands-catalog` after changing command names,
 aliases, descriptions, visibility, or hidden-command metadata.
 
 
-## Public (43)
+## Public (45)
 
 | Command | Aliases | Description |
 | --- | --- | --- |
@@ -46,12 +46,14 @@ aliases, descriptions, visibility, or hidden-command metadata.
 | `/rubric` | `/criteria` | Set explicit acceptance criteria for rubric grading |
 | `/scrollbar` |  | Show or hide the chat scrollbar |
 | `/skill-creator` |  | Create or refine agent skills |
+| `/summarization-model` |  | Set the model used for context-compaction summaries |
 | `/theme` |  | Change color theme |
 | `/threads` |  | Browse and resume past threads |
 | `/timestamps` |  | Show or hide message timestamps |
 | `/tokens` |  | Show token usage |
 | `/tools` |  | List the tools available to the agent |
 | `/trace` |  | Open this thread in LangSmith |
+| `/uninstall` |  | Remove an installed optional extra |
 | `/update` |  | Check for and install updates |
 | `/version` | `/about` | Show version information |
 | `/yolo` |  | Switch to YOLO approval mode (no review) |

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/DEVELOPMENT.md

@@ -102,14 +102,15 @@ uv run deepagents-code
 | Variable | Effect |
 | --- | --- |
 | `DEEPAGENTS_CODE_DEBUG` | Master switch. Preserves the server subprocess log on exit (printing its path to stderr) and attaches the client `DEBUG` file handler. Truthy: `1`/`true`/`yes`/`on` (case-insensitive). Falsy: `0`/`false`/`no`/`off`/empty/unset. |
-| `DEEPAGENTS_CODE_DEBUG_FILE=<path>` | Overrides the client log path (default `/tmp/deepagents_debug.log`). **Only takes effect when `DEEPAGENTS_CODE_DEBUG` is truthy**; does **not** affect the server subprocess log. |
+| `DEEPAGENTS_CODE_DEBUG_DIRECTORY=<path>` | Overrides the client log directory (default `/tmp/deepagents_debug`). Each thread writes to `<thread-id>.log`. **Only takes effect when `DEEPAGENTS_CODE_DEBUG` is truthy**; does **not** affect the server subprocess log. |
+| `DEEPAGENTS_CODE_DEBUG_FILE=<path>` | Deprecated compatibility override. When `DEEPAGENTS_CODE_DEBUG_DIRECTORY` and `[debug].directory` are unset, per-thread logs use this path's parent directory. Existing `[debug].file` config works the same way. |
 
 Then pick the log you need by symptom:
 
 | Symptom | Log you want | Default location |
 | --- | --- | --- |
 | App crashes on launch (one-line failure banner) | **Server subprocess log** — the real traceback | `$TMPDIR/deepagents_server_log_*.txt` |
-| App starts, then misbehaves (UI, model calls, slash commands) | **Client app log** — `deepagents_code` at `DEBUG` | `/tmp/deepagents_debug.log` |
+| App starts, then misbehaves (UI, model calls, slash commands) | **Client app log** — `deepagents_code` at `DEBUG` | `/tmp/deepagents_debug/<thread-id>.log` |
 
 ### Startup crash -> server subprocess log
 
@@ -133,12 +134,12 @@ The TUI only surfaces a one-line banner; the actual exception lives in the subpr
 For problems that appear after the app is up, tail the client log in another terminal while reproducing:
 
 ```bash
-tail -f /tmp/deepagents_debug.log
+tail -f /tmp/deepagents_debug/<thread-id>.log
 ```
 
-To send it elsewhere, also `export DEEPAGENTS_CODE_DEBUG_FILE=<path>`. The handler appends across runs, so a single file accumulates every session.
+To send logs elsewhere, also `export DEEPAGENTS_CODE_DEBUG_DIRECTORY=<path>`. Each thread gets its own append-only file, and changing threads in the app switches the active log file.
 
-The file is created or tightened to user-only access. A symlink at the path is refused. If the file cannot be secured, no file handler is attached and a warning goes to stderr. Use the in-app Debug Console in that case.
+The directory is created or tightened to owner-only access, and each file is created or tightened to user-only access. Symlinks are refused. If either cannot be secured, no file handler is attached and a warning goes to stderr. Use the in-app Debug Console in that case.
 
 Stdio MCP server stderr is captured here at `DEBUG`. This keeps server-side failures visible when the TUI cannot show process stderr. Each record is one line, capped at 4096 characters. Characters in the Unicode `C` categories are removed, which includes control and format characters. The ESC byte of an ANSI sequence is removed but the rest stays as literal text, so the log is not free of escape-sequence residue. The text comes from the server. It can contain credentials or other sensitive values. Enable `DEBUG` logging only if you accept that risk, and do not share the log file.
 

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepagents-code
-Version: 0.1.64
+Version: 0.1.65
 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
@@ -42,9 +42,9 @@ Requires-Dist: langchain-quickjs<0.4.0,>=0.3.4
 Requires-Dist: langchain<2.0.0,>=1.3.18
 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.33.0
+Requires-Dist: langgraph-runtime-inmem<1.0.0,>=0.33.2
 Requires-Dist: langgraph-sdk<1.0.0,>=0.4.4
-Requires-Dist: langsmith[sandbox]>=0.11.1
+Requires-Dist: langsmith[sandbox]>=0.11.2
 Requires-Dist: markdownify<2.0.0,>=1.2.3
 Requires-Dist: mcp<2.0.0,>=1.28.1
 Requires-Dist: packaging>=26.2
@@ -200,128 +200,6 @@ By default, `dcode` trusts the directory you run it in. Human-in-the-loop approv
 
 Do not run `dcode` in a directory you do not trust without a sandbox backend. For untrusted repositories, use a [remote sandbox](https://docs.langchain.com/oss/python/deepagents/code/remote-sandboxes) so execution is isolated from your machine. Running `dcode` in a directory lets that directory's files shape execution. See [`THREAT_MODEL.md`](https://github.com/langchain-ai/deepagents/blob/main/libs/code/THREAT_MODEL.md) for details.
 
-## Managed configuration
-
-Administrators can enforce any supported `config.toml` setting with a read-only
-`managed_config.toml` using the same TOML schema:
-
-- macOS: `/Library/Application Support/dcode/managed_config.toml`
-- Windows: the `ProgramData` directory reported by the registry, usually
-  `C:\ProgramData\dcode\managed_config.toml`. The `%ProgramData%` environment
-  variable is ignored, because any user can change it.
-- Linux and other supported POSIX systems: `/etc/dcode/managed_config.toml`
-
-Managed values override two lower layers: the `DEEPAGENTS_CODE_` and
-compatibility environment variables, and `~/.deepagents/config.toml`.
-
-For an agent launch, managed values also override these CLI flags: the model,
-the auto-classifier model, the interpreter toggle, the programmatic tool-calling
-list, the recursion limit, the shell allow list, and the startup mode. A managed
-`[sandboxes].default` names the backend of a launch that is already sandboxed;
-it does not sandbox a launch that asked for no sandbox. A managed startup mode
-only revokes `--auto-approve` and `--yolo`; the mode itself reaches the runtime
-through the merged configuration, so a headless launch still works. Subcommand
-display flags such as `dcode threads --relative` are not overridden.
-
-Tables merge recursively. Deny lists are unioned. An explicitly managed allow or
-trust list replaces lower-precedence grants. An empty managed list removes every
-lower-precedence grant.
-
-A managed value whose type contradicts the manifest is ignored, and the
-lower-precedence value stays in effect. Two exceptions:
-
-- The enforced keys (`startup.mode`, `startup.yolo_switcher`,
-  `shell.allow_list`, `skills.extra_allowed_dirs`,
-  `interpreter.enable_interpreter`, `interpreter.ptc`,
-  `interpreter.ptc_acknowledge_unsafe`, `models.allowed`,
-  `models.auto_classifier`, `runtime.recursion_limit`, `sandboxes.default`,
-  `tracing.langsmith_redact`)
-  stop every command except `config`, `doctor`, `auth path`, and the help
-  screens. If one is ignored, the user's flag or environment variable stays in
-  force. This grants the escalation, or it removes the boundary that the policy
-  declared. Three
-  cases stop the launch and block `/reload`: a value the manifest rejects, a
-  `runtime.recursion_limit` outside its bounds, and a key shadowed by a scalar
-  ancestor (`startup = "manual"` in place of `[startup]` and `mode`). A managed
-  `[sandboxes].default` that names an unavailable backend stops a sandboxed
-  launch; a launch that asked for no sandbox is unaffected. A scalar at any
-  known configuration section (for example, `threads = "bad"` instead of
-  `[threads]`) also stops launch and reload rather than replacing the user's
-  whole section.
-- Inside structured tables (`[models.providers]`, `[themes]`,
-  `[async_subagents]`, `[sandboxes.providers]`) the dedicated typed reader
-  validates instead, so a wrong-typed managed leaf can displace a valid user
-  leaf. The reader then falls back to the built-in default. A managed scalar
-  still replaces a colliding user table there, the same as on the top-level
-  merge.
-
-`[shell].allow_list` is read from `~/.deepagents/config.toml` and from
-`DEEPAGENTS_CODE_SHELL_ALLOW_LIST`, so a managed file can enforce it. A user can
-also grant themselves shell auto-approval from their own config file. An empty
-managed list removes every lower-precedence grant.
-
-`[models].allowed` narrows dcode to exact `provider:model` specifications:
-
-```toml
-[models]
-allowed = ["acme:production", "acme:production-fast"]
-```
-
-The rules:
-
-- A missing key preserves unrestricted model selection.
-- An empty list blocks all local model use.
-- A list that dcode cannot parse also blocks all local model use. A typo must not
-  silently remove the restriction the user asked for. Fix or remove the key.
-- Matching is exact and splits only the first colon, so model identifiers may
-  contain additional colons. Matching is also case-sensitive.
-- Entries must be fully qualified. A bare model name that you type at a prompt
-  is first resolved to `provider:model`, the same as at construction, so
-  `gpt-5.6-terra` matches an `openai:gpt-5.6-terra` entry. A bare name whose
-  provider dcode cannot infer never matches.
-- Write a Bedrock model as `bedrock:<id>`. A bare Bedrock ID is rejected,
-  because its version colon would make it a specification that nothing matches.
-- The list filters model discovery and the selector. Construction-time checks
-  are authoritative for CLI flags, runtime switches, Auto classifiers, rubric
-  graders, and explicit local subagent models.
-- A managed list replaces a user list. Managed default, recent, and
-  Auto-classifier models must also appear in it.
-- `[models.providers.<name>].models` registers models additively. It does not
-  grant permission, so a custom model may need both registration and an
-  allowlist entry.
-
-`dcode` never writes the managed file. Users can still save a preference. The
-theme, terminal-mapping, UI-toggle, and MCP-server screens, and the
-`--auto-update` flag, report when a managed value keeps a saved preference from
-taking effect. The model-default, recent-model, and Auto-classifier writers
-refuse a value outside the effective allowlist, and report the policy as the
-reason. Other save paths do not check the allowlist.
-
-A missing managed file applies no policy. If one exists but is unreadable, not
-UTF-8, or invalid TOML, every command fails closed except the ones needed to
-diagnose it: `--help`, `--version`, `help`, `config`, `doctor`, and
-`auth path`. A managed file that becomes unusable later also blocks `/reload`:
-the session keeps the policy that was in force, and the reload reports that it
-kept it. Use `dcode config path` and `dcode doctor` to inspect its
-fixed path and parse health; `dcode config` also warns when the file exists but
-could not be parsed, or parses and declares a value that cannot be enforced.
-
-A deny list that cannot be read denies everything rather than nothing. This
-covers a managed `[mcp].disabled_servers` that is neither an array of names nor
-a comma-separated string, and a `[mcp]` section that is not a table. A managed
-`[mcp].enabled_project_server_approvals` that is not an array is treated the
-same way: the key is present, so policy means to narrow access, and reading its
-presence as absence would leave both the user's approvals and the
-`DEEPAGENTS_CODE_DANGEROUSLY_ENABLE_PROJECT_MCP_SERVERS` bypass in force.
-
-A corrupt `~/.deepagents/config.toml` does not disable managed policy: the user
-file is ignored and managed values still apply.
-
-Deployment tooling must create and protect this file with administrator or root
-permissions. `dcode` does not validate the file owner or mode. `dcode` provides
-no privileged writer. Deployment and `sudo` policy are the administrator's
-responsibility.
-
 ## 📖 Resources
 
 - **[Documentation](https://docs.langchain.com/deepagents-code)**

deepagents_code-0.1.65/README.md

@@ -0,0 +1,72 @@
+# 🧠🤖 Deep Agents Code
+
+[![PyPI - Version](https://img.shields.io/pypi/v/deepagents-code?label=%20)](https://pypi.org/project/deepagents-code/#history)
+[![PyPI - License](https://img.shields.io/pypi/l/deepagents-code)](https://opensource.org/licenses/MIT)
+[![PyPI - Downloads](https://img.shields.io/pepy/dt/deepagents-code)](https://pypistats.org/packages/deepagents-code)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchain_oss.svg?style=social&label=Follow%20%40LangChain)](https://x.com/langchain_oss)
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/langchain-ai/deepagents/main/libs/code/images/tui.png" alt="Deep Agents Code" width="600"/>
+</p>
+
+## Quick Install
+
+```bash
+curl -LsSf https://langch.in/dcode | bash
+```
+
+```bash
+# With model provider extras
+# OpenAI, Anthropic, and Gemini are included by default
+DEEPAGENTS_CODE_EXTRAS="nvidia,ollama" curl -LsSf https://langch.in/dcode | bash
+```
+
+Run:
+
+```bash
+dcode
+```
+
+## 🤔 What is this?
+
+The fastest way to start using Deep Agents. `deepagents-code` is a pre-built coding agent in your terminal — similar to Claude Code or Cursor — powered by any LLM that supports tool calling. One install command and you're up and running, no code required.
+
+**What `deepagents-code` adds on top of the SDK:**
+
+- **Interactive TUI** — rich terminal interface with streaming responses
+- **Conversation resume** — pick up where you left off across sessions
+- **Web search** — ground responses in live information
+- **Remote sandboxes** — run code in isolated environments (LangSmith, AgentCore, Daytona, Modal, Runloop, & more)
+- **Persistent memory** — agent remembers context across conversations
+- **Custom skills** — extend the agent with your own slash commands
+- **Headless mode** — run non-interactively for scripting and CI
+- **Human-in-the-loop** — approve or reject tool calls before execution
+
+## 🔒 Security model
+
+By default, `dcode` trusts the directory you run it in. Human-in-the-loop approval gates model-requested tool calls, but project artifacts are read before any approval prompt.
+
+Do not run `dcode` in a directory you do not trust without a sandbox backend. For untrusted repositories, use a [remote sandbox](https://docs.langchain.com/oss/python/deepagents/code/remote-sandboxes) so execution is isolated from your machine. Running `dcode` in a directory lets that directory's files shape execution. See [`THREAT_MODEL.md`](https://github.com/langchain-ai/deepagents/blob/main/libs/code/THREAT_MODEL.md) for details.
+
+## 📖 Resources
+
+- **[Documentation](https://docs.langchain.com/deepagents-code)**
+- **[Changelog](https://github.com/langchain-ai/deepagents/blob/main/libs/code/CHANGELOG.md)**
+- **[Source code](https://github.com/langchain-ai/deepagents/tree/main/libs/code)**
+- **[Deep Agents SDK](https://github.com/langchain-ai/deepagents)** — underlying agent harness
+- [LangChain Academy](https://academy.langchain.com/) — Comprehensive, free courses on LangChain libraries and products, made by the LangChain team.
+- [Code of Conduct](https://github.com/langchain-ai/langchain/?tab=coc-ov-file) — community guidelines and standards
+
+## 📕 Releases & Versioning
+
+See our [Releases](https://docs.langchain.com/oss/python/release-policy) and [Versioning](https://docs.langchain.com/oss/python/versioning) policies.
+
+## 💁 Contributing
+
+As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
+
+For detailed information on how to contribute, see the [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview).
+
+## 🤝 Acknowledgements
+
+This project was primarily inspired by Claude Code, and initially was largely an attempt to see what made Claude Code general purpose, and make it even more so.

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/deepagents_code/_build_info.py

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

{deepagents_code-0.1.64 → deepagents_code-0.1.65}/deepagents_code/_cli_context.py

@@ -9,7 +9,7 @@ middleware stack.
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, TypedDict
+from typing import Any, TypedDict, cast
 
 INHERIT_CLASSIFIER_MODEL = "__dcode_inherit_classifier__"
 """Per-run `classifier_model` value meaning "review with the main agent model".
@@ -30,6 +30,15 @@ startup classifier authorizing actions after the UI reported the clear, so the
 sentinel stays plain ASCII.
 """
 
+INHERIT_SUMMARIZATION_MODEL = "__dcode_inherit_summarization__"
+"""Per-run `summarization_model` value meaning "use the main agent model".
+
+An absent (or `None`) `summarization_model` leaves the graph's startup summary
+model in effect. `/summarization-model clear` needs the stronger statement that
+summaries go back to the main agent model, which this sentinel carries across
+the remote JSON boundary without being mistaken for a model spec.
+"""
+
 
 @dataclass
 class CLIContextSchema:
@@ -54,6 +63,8 @@ class CLIContextSchema:
 
     model_params: dict[str, Any] = field(default_factory=dict)
 
+    summarization_model: str | None = None
+
     profile_overrides: dict[str, Any] = field(default_factory=dict)
 
     model_context_limit: int | None = None
@@ -76,6 +87,80 @@ class CLIContextSchema:
 
     prompt_id: str | None = None
 
+    @classmethod
+    def from_payload(cls, payload: object) -> CLIContextSchema | None:
+        """Coerce a run's `context=` payload into this schema.
+
+        In-process LangGraph coerces the payload before consumers see it, so a
+        schema instance is returned unchanged. Over the API server (RemoteGraph)
+        the payload is JSON and arrives as a plain dict, which this rebuilds
+        field by field. Single conversion point for every consumer: a second
+        hand-rolled copy drifts field by field, and the copy that forgets a
+        field drops it silently.
+
+        Args:
+            payload: The value read from `runtime.context`.
+
+        Returns:
+            The coerced schema, or `None` when the payload is neither a
+            `CLIContextSchema` nor a dict.
+        """
+        if isinstance(payload, cls):
+            return payload
+        if not isinstance(payload, dict):
+            return None
+        data = cast("dict[str, Any]", payload)
+
+        def _str(key: str) -> str | None:
+            value = data.get(key)
+            return value if isinstance(value, str) else None
+
+        def _mapping(key: str) -> dict[str, Any]:
+            # `dict(...)` on a non-mapping (`"x"`, `7`, ...) raises
+            # `TypeError`/`ValueError`, which would abort the request before the
+            # model handler runs — even when the malformed field is unrelated to
+            # model selection. Fall back to empty instead.
+            value = data.get(key)
+            return dict(value) if isinstance(value, dict) else {}
+
+        # `bool` is an `int` subclass, so exclude it explicitly.
+        raw_limit = data.get("model_context_limit")
+        limit = (
+            raw_limit
+            if isinstance(raw_limit, int) and not isinstance(raw_limit, bool)
+            else None
+        )
+        approval_mode = _str("approval_mode")
+        raw_auto_approve = data.get("auto_approve")
+        # Only a real list is safe to iterate: `7` raises `TypeError`, and a
+        # bare string (`"PreToolUse"`) would explode into per-character events.
+        raw_events = data.get("hooks_server_events")
+        events = (
+            [event for event in raw_events if isinstance(event, str)]
+            if isinstance(raw_events, list)
+            else []
+        )
+        return cls(
+            model=_str("model"),
+            model_params=_mapping("model_params"),
+            summarization_model=_str("summarization_model"),
+            profile_overrides=_mapping("profile_overrides"),
+            model_context_limit=limit,
+            classifier_model=_str("classifier_model"),
+            approval_mode=approval_mode or "manual",
+            # Fail closed for malformed remote payloads. In particular,
+            # `bool("false")` is `True` and would enable legacy YOLO mode.
+            auto_approve=(
+                raw_auto_approve if isinstance(raw_auto_approve, bool) else False
+            ),
+            approval_mode_key=_str("approval_mode_key"),
+            thread_id=_str("thread_id"),
+            turn_id=_str("turn_id"),
+            hooks_snapshot_id=_str("hooks_snapshot_id"),
+            hooks_server_events=events,
+            prompt_id=_str("prompt_id"),
+        )
+
 
 class CLIContext(TypedDict, total=False):
     """Client-facing builder for the per-run graph context payload.
@@ -94,6 +179,17 @@ class CLIContext(TypedDict, total=False):
     """Invocation params (e.g. `temperature`, `max_tokens`) to merge
     into `model_settings`."""
 
+    summarization_model: str | None
+    """Model spec used only for context-compaction summary generation.
+
+    `None` or an absent key keeps the graph's startup summary model.
+    `INHERIT_SUMMARIZATION_MODEL` explicitly selects the main agent model. This
+    value never changes the main model or its system-prompt identity: its only
+    consumers are the summary-generation slots installed by
+    `offload_middleware._summarization_for_runtime`, so compaction thresholds
+    and token counting still track the main model.
+    """
+
     profile_overrides: dict[str, Any]
     """Model profile metadata supplied by `--profile-override`."""
 

deepagents_code-0.1.65/deepagents_code/_content_blocks.py

@@ -0,0 +1,30 @@
+"""Shared reading of provider content blocks.
+
+The three surfaces that render a streamed or replayed `AIMessage` -- the
+transcript projection in `deepagents_code.app`, the interactive TUI
+(`deepagents_code.tui.textual_adapter`), and the headless runner
+(`deepagents_code.client.non_interactive`) -- all have to decide which blocks
+carry reasoning. Keeping that decision here stops the three from drifting when
+the block schema grows a new shape.
+"""
+
+from __future__ import annotations
+
+
+def reasoning_text(block: object) -> str | None:
+    """Extract renderable reasoning text from a content block.
+
+    Args:
+        block: One entry of `AIMessage.content_blocks`. Typed loosely because
+            the three surfaces reach it through differently typed streams.
+
+    Returns:
+        The block's reasoning text, or `None` when the block is not reasoning
+        or carries nothing worth rendering.
+    """
+    if not isinstance(block, dict) or block.get("type") != "reasoning":
+        return None
+    text = block.get("reasoning")
+    if not isinstance(text, str) or not text:
+        return None
+    return text