deepagents-code 0.1.38__tar.gz → 0.1.39__tar.gz

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/AGENTS.md

@@ -92,7 +92,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.
-- 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), 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.
+- 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.38 → deepagents_code-0.1.39}/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.39](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.38...deepagents-code==0.1.39) (2026-07-14)
+
+### Bug fixes
+
+- Improved Debug Console log retention by partitioning retained logs by level ([#4718](https://github.com/langchain-ai/deepagents/issues/4718)) ([c6e3b35](https://github.com/langchain-ai/deepagents/commit/c6e3b351f1826aa6ea97be244acd867950a032ee)).
+- Fixed `/offload` to run server-side ([#4696](https://github.com/langchain-ai/deepagents/issues/4696)) ([564e5a0](https://github.com/langchain-ai/deepagents/commit/564e5a05bca5236ae33ce1147865111f931d257c)).
+
 ## [0.1.38](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.37...deepagents-code==0.1.38) (2026-07-14)
 
 ### Features

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.38
+Version: 0.1.39
 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://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "4338671"
+BUILD_COMMIT = "8eb909a"

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/deepagents_code/_cli_context.py

@@ -35,6 +35,10 @@ class CLIContextSchema:
 
     model_params: dict[str, Any] = field(default_factory=dict)
 
+    profile_overrides: dict[str, Any] = field(default_factory=dict)
+
+    model_context_limit: int | None = None
+
     auto_approve: bool = False
 
     approval_mode_key: str | None = None
@@ -43,6 +47,8 @@ class CLIContextSchema:
 
     blocked_goal_retry_context: str | None = None
 
+    offload_tool_call_id: str | None = None
+
 
 class CLIContext(TypedDict, total=False):
     """Client-facing builder for the per-run graph context payload.
@@ -61,6 +67,12 @@ class CLIContext(TypedDict, total=False):
     """Invocation params (e.g. `temperature`, `max_tokens`) to merge
     into `model_settings`."""
 
+    profile_overrides: dict[str, Any]
+    """Model profile metadata supplied by `--profile-override`."""
+
+    model_context_limit: int | None
+    """Effective context-window limit for profile-aware middleware."""
+
     auto_approve: bool
     """Whether gated tool calls should skip the human-approval interrupt.
 
@@ -94,3 +106,10 @@ class CLIContext(TypedDict, total=False):
     message so it is not parsed as a file mention or checkpointed as human
     input.
     """
+
+    offload_tool_call_id: str | None
+    """The sole tool-call ID authorized during a server-driven `/offload` run.
+
+    This is set by the client, not graph state, so model-generated calls cannot
+    grant themselves permission to execute during the hidden compaction turn.
+    """

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/deepagents_code/_debug_buffer.py

@@ -1,10 +1,12 @@
 r"""In-memory ring buffer of recent log records for the in-app Debug Console.
 
-A lightweight `logging.Handler` keeps the most recent structured log records in a
-bounded `deque` so the Debug Console (`Ctrl+\`) can show a live tail without
-requiring the opt-in file logging from `_debug.configure_debug_logging`. The
-handler is installed once on the `deepagents_code` package logger (see
-`__init__.py`); child module loggers reach it via propagation.
+A lightweight `logging.Handler` keeps the most recent structured log records in
+bounded per-level `deque`s so the Debug Console (`Ctrl+\`) can show a live tail
+without requiring the opt-in file logging from `_debug.configure_debug_logging`.
+Partitioning retention by level means a burst of `DEBUG` output cannot evict the
+rarer `INFO`/`WARNING`/`ERROR` records the level filter needs. The handler is
+installed once on the `deepagents_code` package logger (see `__init__.py`); child
+module loggers reach it via propagation.
 
 Installation is negligible, and each emitted record only appends a structured
 record to a bounded `deque`, so the buffer is cheap enough to keep always on.
@@ -12,21 +14,37 @@ record to a bounded `deque`, so the buffer is cheap enough to keep always on.
 
 from __future__ import annotations
 
-import itertools
 import logging
+import operator
 import os
 from collections import deque
 from dataclasses import dataclass
 
+from deepagents_code._debug import LOG_LEVELS
 from deepagents_code._env_vars import LOG_LEVEL
 
 DEFAULT_CAPACITY = 1000
-"""Maximum number of records retained in the ring buffer."""
+"""Maximum number of records retained per level in the ring buffer."""
+
+_FALLBACK_LEVEL_BUCKET = "_other"
+"""Retention bucket for records whose level name is not in `LOG_LEVELS`.
+
+Non-standard level names are retained here rather than discarded at
+classification time, and sharing one bucket keeps the number of per-level deques
+bounded no matter how many distinct custom names appear. Like every bucket, this
+one is bounded to *capacity* and evicts oldest-first, so — unlike the standard
+levels, which each get isolated retention — distinct custom levels compete for a
+single budget and can evict one another."""
 
 _DATE_FORMAT = "%H:%M:%S"
 _FORMATTER = logging.Formatter(datefmt=_DATE_FORMAT)
 
 
+def retention_bucket_for_level(level: str) -> str:
+    """Return the bounded retention bucket key for a log level name."""
+    return level if level in LOG_LEVELS else _FALLBACK_LEVEL_BUCKET
+
+
 @dataclass(frozen=True, slots=True)
 class InMemoryLogRecord:
     """Structured log record retained by the in-memory debug buffer."""
@@ -44,13 +62,24 @@ class InMemoryLogRecord:
 
 
 class InMemoryLogBuffer(logging.Handler):
-    """Logging handler retaining the most recent structured records in memory."""
+    """Logging handler retaining the most recent structured records in memory.
+
+    Retention is partitioned by level: each recognized level name (see
+    `LOG_LEVELS`) keeps its own bounded `deque` of *capacity* records, while
+    unrecognized names share the `_FALLBACK_LEVEL_BUCKET` deque. A burst of
+    high-volume records at one recognized level (typically `DEBUG`) therefore
+    cannot evict the rarer, higher-severity records at other recognized levels,
+    so the Debug Console's level filter can still surface them. Each retained
+    record is tagged with its monotonic emission sequence number so snapshots
+    stay chronologically ordered across levels.
+    """
 
     def __init__(self, capacity: int = DEFAULT_CAPACITY) -> None:
-        """Create the handler with a bounded backing `deque`.
+        """Create the handler with a bounded backing `deque` per level.
 
         Args:
-            capacity: Maximum records to retain; oldest are dropped first.
+            capacity: Maximum records to retain per level; oldest are dropped
+                first.
 
         Raises:
             ValueError: If *capacity* is less than 1. A zero-capacity buffer
@@ -61,20 +90,32 @@ class InMemoryLogBuffer(logging.Handler):
             msg = f"capacity must be >= 1, got {capacity}"
             raise ValueError(msg)
         super().__init__()
-        self._records: deque[InMemoryLogRecord] = deque(maxlen=capacity)
+        self._capacity = capacity
+        self._levels: dict[str, deque[tuple[int, InMemoryLogRecord]]] = {}
         self._total = 0
 
     def emit(self, record: logging.LogRecord) -> None:
-        """Append the structured *record* to the ring buffer."""
+        """Append the structured *record* to its level's ring buffer."""
         self.acquire()
         try:
-            self._records.append(self._make_record(record))
+            structured = self._make_record(record)
+            bucket = self._level_bucket(structured.level)
+            bucket.append((self._total, structured))
             self._total += 1
         except Exception:  # noqa: BLE001  # never let logging crash the app
             self.handleError(record)
         finally:
             self.release()
 
+    def _level_bucket(self, level: str) -> deque[tuple[int, InMemoryLogRecord]]:
+        """Return the retention deque for *level*, creating it on first use."""
+        key = retention_bucket_for_level(level)
+        bucket = self._levels.get(key)
+        if bucket is None:
+            bucket = deque(maxlen=self._capacity)
+            self._levels[key] = bucket
+        return bucket
+
     @property
     def total_emitted(self) -> int:
         """Total records ever emitted (monotonic; survives buffer eviction)."""
@@ -107,15 +148,20 @@ class InMemoryLogBuffer(logging.Handler):
             self.release()
 
     def _records_since_unlocked(self, index: int) -> list[InMemoryLogRecord]:
-        """Return retained records from *index* while the handler lock is held."""
-        start_abs = self._total - len(self._records)
-        offset = index - start_abs
-        if offset <= 0:
-            return list(self._records)
-        if offset >= len(self._records):
-            return []
-        # islice avoids materializing the full deque just to slice off the tail.
-        return list(itertools.islice(self._records, offset, None))
+        """Return retained records from *index* while the handler lock is held.
+
+        Merges the per-level deques and restores chronological order using each
+        record's emission sequence number, so callers see one ordered tail even
+        though retention is partitioned by level.
+        """
+        tagged = [
+            entry
+            for bucket in self._levels.values()
+            for entry in bucket
+            if entry[0] >= index
+        ]
+        tagged.sort(key=operator.itemgetter(0))
+        return [record for _seq, record in tagged]
 
     @staticmethod
     def _make_record(record: logging.LogRecord) -> InMemoryLogRecord:

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/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.38"  # x-release-please-version
+__version__ = "0.1.39"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.38 → deepagents_code-0.1.39}/deepagents_code/agent.py

@@ -86,6 +86,8 @@ from deepagents_code.local_context import (
     _AsyncExecutableBackend,
     _ExecutableBackend,
 )
+from deepagents_code.offload import _offload_fallback_root
+from deepagents_code.offload_middleware import _create_cli_compaction_middleware
 from deepagents_code.project_utils import ProjectContext, get_server_project_context
 from deepagents_code.reliable_rubric import ReliableRubricMiddleware
 from deepagents_code.subagents import list_subagents
@@ -1916,7 +1918,7 @@ def create_cli_agent(
             virtual_mode=True,
         )
         conversation_history_backend = FilesystemBackend(
-            root_dir=tempfile.mkdtemp(prefix="deepagents_conversation_history_"),
+            root_dir=_offload_fallback_root() / "conversation_history",
             virtual_mode=True,
         )
         composite_backend = CompositeBackend(
@@ -1933,11 +1935,7 @@ def create_cli_agent(
             routes={},
         )
 
-    from deepagents.middleware.summarization import create_summarization_tool_middleware
-
-    agent_middleware.append(
-        create_summarization_tool_middleware(model, composite_backend)
-    )
+    agent_middleware.append(_create_cli_compaction_middleware(model, composite_backend))
 
     # Rubric-driven self-evaluation. The middleware is a no-op until a
     # `rubric` is supplied on invocation state, so installing it is safe.