deepagents-code 0.1.87__tar.gz → 0.1.88__tar.gz

{deepagents_code-0.1.87 → deepagents_code-0.1.88}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.88](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.87...deepagents-code==0.1.88) (2026-10-22)
+
+### Bug Fixes
+
+- Fixed async subagents to pass through `webhook` configuration.
+- Fixed bridge compatibility with Python 3.14.
+- Silenced no-op automatic cache offloads.
+
 ## [0.1.87](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.86...deepagents-code==0.1.87) (2026-10-20)
 
 ### Features

{deepagents_code-0.1.87 → deepagents_code-0.1.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: deepagents-code
-Version: 0.1.87
+Version: 0.1.88
 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
@@ -30,7 +30,7 @@ Requires-Python: <4.0,>=3.12
 Requires-Dist: aiosqlite<1.0.0,>=0.22.1
 Requires-Dist: anyio<5.0.0,>=4.14.2
 Requires-Dist: deepagents-acp<1.0.0,>=0.0.10
-Requires-Dist: deepagents==0.7.29
+Requires-Dist: deepagents==0.7.30
 Requires-Dist: fastmcp<5.0.0,>=4.0.0b4
 Requires-Dist: filelock<3.30,>=3.29.7
 Requires-Dist: genai-prices<0.2.0,>=0.1.13
@@ -48,7 +48,7 @@ Requires-Dist: langsmith[sandbox]>=0.14.11
 Requires-Dist: markdownify<2.0.0,>=1.2.3
 Requires-Dist: mcp<3.0.0,>=2.0.0
 Requires-Dist: packaging>=26.2
-Requires-Dist: pillow<13.0.0,>=12.3.0
+Requires-Dist: pillow<14.0.0,>=13.0.0
 Requires-Dist: prompt-toolkit<4.0.0,>=3.0.53
 Requires-Dist: pydantic<2.14.0a0,>=2.12.5
 Requires-Dist: pyperclip<2.0.0,>=1.11.0
@@ -120,7 +120,7 @@ Provides-Extra: litellm
 Requires-Dist: langchain-litellm<2.0.0,>=0.11.1; extra == 'litellm'
 Provides-Extra: media
 Requires-Dist: av<19.0.0,>=18.0.0; extra == 'media'
-Requires-Dist: pillow<13.0.0,>=12.3.0; extra == 'media'
+Requires-Dist: pillow<14.0.0,>=13.0.0; extra == 'media'
 Provides-Extra: meta
 Requires-Dist: langchain-meta<2.0.0,>=0.5.0; extra == 'meta'
 Provides-Extra: mistralai

{deepagents_code-0.1.87 → deepagents_code-0.1.88}/deepagents_code/_build_info.py

@@ -1,3 +1,3 @@
 """Generated at build time. Do not edit or commit."""
 
-BUILD_COMMIT = "d1962cf"
+BUILD_COMMIT = "0324ff3"

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

{deepagents_code-0.1.87 → deepagents_code-0.1.88}/deepagents_code/agent.py

@@ -1160,6 +1160,7 @@ def load_async_subagents(config_path: Path | None = None) -> list[AsyncSubAgent]
     description = "Research agent"
     url = "https://my-deployment.langsmith.dev"
     graph_id = "agent"
+    webhook = "https://example.com/webhooks/subagent-finished"
     ```
 
     Args:
@@ -1225,6 +1226,8 @@ def load_async_subagents(config_path: Path | None = None) -> list[AsyncSubAgent]
         }
         if "url" in spec and isinstance(spec["url"], str):
             agent["url"] = spec["url"]
+        if "webhook" in spec and isinstance(spec["webhook"], str):
+            agent["webhook"] = spec["webhook"]
         if "headers" in spec and isinstance(spec["headers"], dict):
             agent["headers"] = spec["headers"]
         agents.append(agent)

{deepagents_code-0.1.87 → deepagents_code-0.1.88}/deepagents_code/app.py

@@ -7692,17 +7692,30 @@ class DeepAgentsApp(App):
             await self._mount_message(
                 AppMessage(f"Update log: {format_log_follow_command(log_path)}"),
             )
+
+        notices: list[str] = []
+        deferred: list[bool] = []
+        unverified: list[bool] = []
+
+        async def show_upgrade_notice(message: str) -> None:
+            notices.append(message)
+            await self._mount_message(AppMessage(message))
+
+        # A Python migration rebuilds the environment this session imports
+        # from, so the TUI defers it to `dcode update` from the shell.
         success, output, installed = await perform_upgrade(
+            on_notice=show_upgrade_notice,
             log_path=log_path,
             include_prereleases=include_prereleases,
             target_version=latest,
+            allow_python_migration=False,
+            on_migration_deferred=lambda: deferred.append(True),
+            on_unverified_install=lambda: unverified.append(True),
         )
         if success:
             self._update_available = (False, None)
-            # The install command is unpinned, so the installer may have
-            # resolved a release newer than the one the update check observed
-            # (a release published while the session sat open). Report what
-            # actually landed on disk rather than the stale check result.
+            # uv installs are pinned and verified, and other methods report
+            # the target, so this matches `latest`; the fallback is defensive.
             upgraded_to = installed or latest
             # uv may have installed the upgraded shim into a directory that
             # isn't first on the user's PATH (e.g. a leftover pre-uv
@@ -7729,6 +7742,24 @@ class DeepAgentsApp(App):
                 await self._mount_message(
                     ErrorMessage(format_shadowed_dcode_warning(shadow)),
                 )
+        elif unverified:
+            # This session lazily imports modules that uv may have replaced.
+            await self._mount_message(
+                ErrorMessage(
+                    "Update could not be verified; see above. Quit and relaunch "
+                    "dcode before continuing."
+                ),
+            )
+        elif deferred:
+            # Nothing ran, so there is no failure or log to point at.
+            await self._mount_message(AppMessage("Update deferred; see above."))
+        elif notices:
+            # The notice already carries its own recovery steps; a generic
+            # command here would contradict them.
+            log_line = f"\nLog: {log_path}" if log_path is not None else ""
+            await self._mount_message(
+                AppMessage(f"Update failed; see the message above.{log_line}"),
+            )
         else:
             cmd = upgrade_command(
                 include_prereleases=upgrade_include_prereleases,
@@ -18614,7 +18645,9 @@ class DeepAgentsApp(App):
         _, conversation = await self._get_context_usage_counts()
         return conversation
 
-    async def _handle_server_offload(self, config: RunnableConfig) -> None:
+    async def _handle_server_offload(
+        self, config: RunnableConfig, *, automatic: bool = False
+    ) -> None:
         """Request and render the built-in server-owned offload operation."""
         from deepagents_code.hooks.client_lifecycle import ClientHookStopError
 
@@ -18641,6 +18674,8 @@ class DeepAgentsApp(App):
             await self._sync_session_cost_from_checkpoint()
 
             status = result.get("status")
+            if automatic and status in {"empty", "noop"}:
+                return
             if status == "empty":
                 await self._mount_message(
                     AppMessage("Nothing to offload — start a conversation first")
@@ -18829,7 +18864,7 @@ class DeepAgentsApp(App):
                     "Compacting idle context before cache expiry.",
                     markup=False,
                 )
-            await self._handle_offload(reserved=True)
+            await self._handle_offload(reserved=True, automatic=idle_window is not None)
         finally:
             self._offload_task_started = False
             self._offload_worker = None
@@ -18837,16 +18872,19 @@ class DeepAgentsApp(App):
             if not self._startup_sequence_running:
                 await self._process_next_from_queue()
 
-    async def _handle_offload(self, *, reserved: bool = False) -> None:
+    async def _handle_offload(
+        self, *, reserved: bool = False, automatic: bool = False
+    ) -> None:
         """Run `/offload`, always releasing its busy-state reservation.
 
         Args:
             reserved: Whether the caller already reserved the turn synchronously.
+            automatic: Suppress no-op feedback for idle cache maintenance.
         """
         if not reserved:
             self._set_agent_running(True)
         try:
-            await self._offload_impl()
+            await self._offload_impl(automatic=automatic)
         finally:
             self._set_agent_running(False)
             try:
@@ -18854,7 +18892,7 @@ class DeepAgentsApp(App):
             except Exception:  # best-effort spinner cleanup
                 logger.exception("Failed to dismiss spinner after offload")
 
-    async def _offload_impl(self) -> None:
+    async def _offload_impl(self, *, automatic: bool = False) -> None:
         """Offload older messages through the dcode server operation."""
         if not self._agent or not self._lc_thread_id:
             await self._mount_message(
@@ -18870,7 +18908,7 @@ class DeepAgentsApp(App):
             return
 
         config: RunnableConfig = {"configurable": {"thread_id": self._lc_thread_id}}
-        await self._handle_server_offload(config)
+        await self._handle_server_offload(config, automatic=automatic)
 
     def _start_plugin_auto_update(self) -> None:
         """Start the plugin auto-update worker."""
@@ -26424,7 +26462,7 @@ class DeepAgentsApp(App):
             cli_version="0.1.0",
             release_age=" (released 2 days ago)",
             installed_age="",
-            upgrade_cmd="uv tool upgrade deepagents-code",
+            upgrade_cmd="uv tool install -U deepagents-code",
         )
         self._notice_registry.add(update_notification)
         self._update_modal_pending.set()
@@ -27261,10 +27299,25 @@ class DeepAgentsApp(App):
                             show_toast=not progress_modal_visible,
                         )
                         return
+
+                    notices: list[str] = []
+                    deferred: list[bool] = []
+                    unverified: list[bool] = []
+
+                    def show_upgrade_notice(message: str) -> None:
+                        notices.append(message)
+                        screen.append_line(message)
+                        self.notify(message, timeout=15, markup=False)
+
+                    # Same live-session constraint as `/update`.
                     success, output, installed = await perform_upgrade(
                         progress=screen.append_line,
+                        on_notice=show_upgrade_notice,
                         log_path=log_path,
                         target_version=payload.latest,
+                        allow_python_migration=False,
+                        on_migration_deferred=lambda: deferred.append(True),
+                        on_unverified_install=lambda: unverified.append(True),
                     )
                     if success:
                         self._notice_registry.remove(entry.key)
@@ -27289,11 +27342,9 @@ class DeepAgentsApp(App):
                                 markup=False,
                             )
                             return
-                        # The install command is unpinned, so the installer
-                        # may have resolved a release newer than the one this
-                        # notification advertised (a release published while
-                        # the notice sat open). Report what actually landed on
-                        # disk rather than the stale payload version.
+                        # uv installs are pinned and verified, and other
+                        # methods report the target, so this matches the
+                        # payload; the fallback is defensive.
                         upgraded_to = installed or payload.latest
                         # After `mark_success`: the modal stays un-dismissable
                         # until it is marked done, and this worker runs with
@@ -27311,12 +27362,35 @@ class DeepAgentsApp(App):
                             markup=False,
                         )
                         return
+                    self._notice_registry.remove(entry.key)
+                    if deferred:
+                        logger.info(
+                            "Deferred the Python migration for v%s", payload.latest
+                        )
+                        screen.mark_warning("Update deferred. See details.")
+                        return
                     logger.warning(
                         "Auto-upgrade failed for v%s. Output:\n%s",
                         payload.latest,
                         output,
                     )
-                    self._notice_registry.remove(entry.key)
+                    if unverified:
+                        # This session lazily imports modules that uv may have
+                        # replaced.
+                        restart = (
+                            "Update could not be verified. Quit and relaunch dcode "
+                            "before continuing."
+                        )
+                        screen.mark_warning(restart)
+                        self.notify(
+                            restart, severity="warning", timeout=20, markup=False
+                        )
+                        return
+                    if notices:
+                        # The notice toast and modal line already carry the
+                        # notice's own recovery steps.
+                        screen.mark_warning("Update did not complete. See details.")
+                        return
                     screen.mark_failure(cmd)
                     snippet = _truncate(output, limit=160) if output else ""
                     message = f"Auto-update failed. Run manually: {cmd}"

{deepagents_code-0.1.87 → deepagents_code-0.1.88}/deepagents_code/main.py

@@ -561,6 +561,32 @@ def _exit_after_unrestartable_update(
     raise SystemExit(0 if cause is None else 1)
 
 
+def _exit_after_unverified_update(console: "Console", *, persisted: bool) -> NoReturn:
+    """Exit after uv reported success but the install could not be verified.
+
+    The installed files may no longer match the code this process has loaded,
+    so launching could mix releases. The failure notice is already printed.
+
+    Args:
+        console: Console to print the notice to.
+        persisted: Whether the startup cooldown marker was saved.
+
+    Raises:
+        SystemExit: Always, to stop the launch.
+    """
+    from deepagents_code._invocation import invoked_name
+
+    message = (
+        "The installed files may have changed, so this session cannot start on "
+        f"the previous version. Run [cyan]{invoked_name()}[/cyan] again; if it "
+        "fails to start, rerun the installer named above."
+    )
+    if not persisted:
+        message += _UNPERSISTED_AUTO_UPDATE_FAILURE_NOTE
+    console.print(message, markup=True, highlight=False)
+    raise SystemExit(1)
+
+
 def _run_startup_auto_update(console: "Console") -> None:
     """Apply enabled auto-updates before the TUI and server start.
 
@@ -669,19 +695,18 @@ def _run_startup_auto_update(console: "Console") -> None:
             )
             return
         if should_skip_startup_auto_update_after_failure(latest):
-            # A same-version upgrade failed recently; retrying it here would
-            # very likely fail again and re-stall every launch (this runs before
-            # the TUI). Skip for the cooldown window and point at a manual
-            # command instead.
-            update_needs_prereleases = release_requires_prereleases(latest)
-            cmd = upgrade_command(
-                include_prereleases=True if update_needs_prereleases else None,
-                version=latest if update_needs_prereleases else None,
-            )
+            # A same-version upgrade failed or was deferred recently; retrying
+            # it here would very likely fail again and re-stall every launch
+            # (this runs before the TUI). Skip for the cooldown window and
+            # point at `dcode update`: unlike a bare uv command, it also
+            # handles a Python migration that startup deferred.
+            from deepagents_code._invocation import invoked_name
+
             console.print(
                 f"[bold yellow]Warning:[/bold yellow] Skipping automatic update to "
-                f"v{latest} after a recent failed attempt. Update manually: "
-                f"[cyan]{cmd}[/cyan]\nContinuing with v{cli_version}.",
+                f"v{latest}; the last attempt did not complete. Run "
+                f"[cyan]{invoked_name()} update[/cyan] to retry.\n"
+                f"Continuing with v{cli_version}.",
                 highlight=False,
             )
             return
@@ -749,8 +774,26 @@ def _run_startup_auto_update(console: "Console") -> None:
                     markup=False,
                 )
             pending_failure_version = latest
+            notices: list[str] = []
+            deferred: list[bool] = []
+            unverified: list[bool] = []
+
+            def show_notice(message: str) -> None:
+                notices.append(message)
+                console.print(message, markup=False, highlight=False)
+
+            # A Python migration rebuilds the shared tool environment, which
+            # would break dcode sessions running in other terminals. Defer it
+            # to an explicit `dcode update`.
             success, output, _installed = asyncio.run(
-                perform_upgrade(log_path=log_path, target_version=latest)
+                perform_upgrade(
+                    on_notice=show_notice,
+                    log_path=log_path,
+                    target_version=latest,
+                    allow_python_migration=False,
+                    on_migration_deferred=lambda: deferred.append(True),
+                    on_unverified_install=lambda: unverified.append(True),
+                )
             )
         if success:
             pending_failure_version = None
@@ -806,22 +849,38 @@ def _run_startup_auto_update(console: "Console") -> None:
                 _exit_after_unrestartable_update(console, latest)
             return
         persisted = mark_startup_auto_update_failed(latest)
-        update_needs_prereleases = release_requires_prereleases(latest)
-        cmd = upgrade_command(
-            include_prereleases=True if update_needs_prereleases else None,
-            version=latest if update_needs_prereleases else None,
-        )
-        detail = f": {escape(output[:200])}" if output else ""
-        message = (
-            f"[bold red]Auto-update failed{detail}[/bold red]\n"
-            f"Run manually: [cyan]{cmd}[/cyan]\n"
-            f"Continuing with v{cli_version}."
-        )
-        if not persisted:
+        if unverified:
+            _exit_after_unverified_update(console, persisted=persisted)
+        if deferred:
+            # Nothing failed: the notice above explains how to migrate.
+            message = f"Continuing with v{cli_version}."
+        elif notices:
+            # The notice above carries its own recovery steps; a generic
+            # command here would contradict them.
+            log_line = f"Log: {escape(str(log_path))}\n" if log_path else ""
+            message = (
+                "[bold red]Auto-update failed; see the message above.[/bold red]\n"
+                f"{log_line}Continuing with v{cli_version}."
+            )
+        else:
+            update_needs_prereleases = release_requires_prereleases(latest)
+            cmd = upgrade_command(
+                include_prereleases=True if update_needs_prereleases else None,
+                version=latest if update_needs_prereleases else None,
+            )
+            detail = f": {escape(output[:200])}" if output else ""
+            message = (
+                f"[bold red]Auto-update failed{detail}[/bold red]\n"
+                f"Run manually: [cyan]{cmd}[/cyan]\n"
+                f"Continuing with v{cli_version}."
+            )
+        if not persisted and not deferred:
             # The cooldown marker could not be saved (e.g. a read-only state
             # dir), so this same failing upgrade would otherwise be retried on
             # every launch. Surface it rather than silently re-stalling, the
             # way the consent-announce path surfaces its un-persisted state.
+            # After a deferral nothing failed: a lost marker only repeats the
+            # deferral notice, which installs nothing.
             message += _UNPERSISTED_AUTO_UPDATE_FAILURE_NOTE
         console.print(message, markup=True, highlight=False)
     except SystemExit:
@@ -6030,15 +6089,37 @@ def cli_main() -> None:
                             highlight=False,
                             markup=False,
                         )
+                    notices: list[str] = []
+                    deferred: list[bool] = []
+
+                    def show_notice(message: str) -> None:
+                        notices.append(message)
+                        console.print(message, markup=False, highlight=False)
+
                     success, output, _installed = asyncio.run(
                         perform_upgrade(
+                            on_notice=show_notice,
                             log_path=log_path,
                             include_prereleases=include_prereleases,
                             target_version=latest,
+                            on_migration_deferred=lambda: deferred.append(True),
                         )
                     )
                 if success:
                     console.print(f"[green]Updated to v{latest}.[/green]")
+                elif deferred:
+                    # Windows: the notice names the command to run outside
+                    # dcode, and nothing ran, so there is no log to show.
+                    sys.exit(1)
+                elif notices:
+                    # The notice carries its own recovery steps; a generic
+                    # command here would contradict them.
+                    log_line = f"\nLog: {escape(str(log_path))}" if log_path else ""
+                    console.print(
+                        "[bold red]Update failed; see the message above."
+                        f"[/bold red]{log_line}"
+                    )
+                    sys.exit(1)
                 else:
                     cmd = upgrade_command(
                         include_prereleases=upgrade_include_prereleases,