deepagents-cli 0.0.29__tar.gz → 0.0.30__tar.gz

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.0.30](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.29...deepagents-cli==0.0.30) (2026-03-07)
+
+### Features
+
+* `--acp` mode to run CLI agent as ACP server ([#1297](https://github.com/langchain-ai/deepagents/issues/1297)) ([c9ba00a](https://github.com/langchain-ai/deepagents/commit/c9ba00a56b7ee5e48b56b13f9f093bb8bf639700))
+* Model detail footer + persist `--profile-override` on hot-swap ([#1700](https://github.com/langchain-ai/deepagents/issues/1700)) ([f2c8b54](https://github.com/langchain-ai/deepagents/commit/f2c8b54e9b4c541bf6f91139bfb9b6a2f20c8de0))
+* Show message timestamp toast on click ([#1702](https://github.com/langchain-ai/deepagents/issues/1702)) ([4f403ec](https://github.com/langchain-ai/deepagents/commit/4f403ecb3332010062158ec30fd55f349654a533))
+
+### Bug Fixes
+
+* Expire `ctrl+c` quit window when toast disappears ([#1701](https://github.com/langchain-ai/deepagents/issues/1701)) ([38b5ea9](https://github.com/langchain-ai/deepagents/commit/38b5ea9484ab121c9b2919dd74469e82fce19b82))
+* Preserve input text when escaping shell/command mode ([#1706](https://github.com/langchain-ai/deepagents/issues/1706)) ([3c00edb](https://github.com/langchain-ai/deepagents/commit/3c00edb93eddf74e87d58526a02be72577ed65b1))
+* Right-align token count next to model name in status bar ([#1705](https://github.com/langchain-ai/deepagents/issues/1705)) ([311c919](https://github.com/langchain-ai/deepagents/commit/311c9191cf663540e1b62eb9452abecda5bc7b4f))
+
 ## [0.0.29](https://github.com/langchain-ai/deepagents/compare/deepagents-cli==0.0.28...deepagents-cli==0.0.29) (2026-03-06)
 
 ### Features

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-cli
-Version: 0.0.29
+Version: 0.0.30
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
@@ -25,6 +25,7 @@ Classifier: Topic :: Terminals
 Requires-Python: <4.0,>=3.11
 Requires-Dist: aiosqlite<1.0.0,>=0.19.0
 Requires-Dist: daytona<1.0.0,>=0.113.0
+Requires-Dist: deepagents-acp>=0.0.4
 Requires-Dist: deepagents==0.4.7
 Requires-Dist: langchain-mcp-adapters<1.0.0,>=0.2.0
 Requires-Dist: langchain-openai<2.0.0,>=1.1.8

deepagents_cli-0.0.30/deepagents_cli/_version.py

@@ -0,0 +1,3 @@
+"""Version information for `deepagents-cli`."""
+
+__version__ = "0.0.30"  # x-release-please-version

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/deepagents_cli/app.py

@@ -539,6 +539,7 @@ class DeepAgentsApp(App):
         sandbox: SandboxBackendProtocol | None = None,
         sandbox_type: str | None = None,
         mcp_server_info: list[MCPServerInfo] | None = None,
+        profile_override: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the Deep Agents application.
@@ -556,6 +557,8 @@ class DeepAgentsApp(App):
             sandbox: Sandbox backend (for model hot-swap)
             sandbox_type: Type of sandbox provider (for model hot-swap)
             mcp_server_info: MCP server metadata for the `/mcp` viewer.
+            profile_override: Extra profile fields from `--profile-override`,
+                retained for model hot-swap and footer display.
             **kwargs: Additional arguments passed to parent
         """
         super().__init__(**kwargs)
@@ -573,6 +576,7 @@ class DeepAgentsApp(App):
         self._sandbox = sandbox
         self._sandbox_type = sandbox_type
         self._mcp_server_info = mcp_server_info
+        self._profile_override = profile_override
         self._mcp_tool_count = sum(len(s.tools) for s in (mcp_server_info or []))
         self._status_bar: StatusBar | None = None
         self._chat_input: ChatInput | None = None
@@ -1649,7 +1653,10 @@ class DeepAgentsApp(App):
 
             try:
                 model_spec = f"{settings.model_provider}:{settings.model_name}"
-                result = create_model(model_spec)
+                result = create_model(
+                    model_spec,
+                    profile_overrides=self._profile_override,
+                )
                 model = result.model
             except Exception as exc:  # noqa: BLE001  # surface model config errors to user
                 await self._mount_message(
@@ -1659,10 +1666,10 @@ class DeepAgentsApp(App):
                 )
                 return
 
-            # create_model() applies config.toml overrides but not CLI
-            # --profile-override (the raw CLI dict isn't retained after
-            # startup). Patch settings.model_context_limit — which reflects
-            # both sources — into the fresh model
+            # create_model() receives --profile-override via self._profile_override,
+            # but settings.model_context_limit may have been set by additional
+            # runtime logic. Patch it into the fresh model when it differs from
+            # the profile value.
             ctx = settings.model_context_limit
             if ctx is not None:
                 # Guard against models that lack a profile dict
@@ -2340,6 +2347,10 @@ class DeepAgentsApp(App):
 
         # Store message data for virtualization
         message_data = MessageData.from_widget(widget)
+        # Ensure the widget's DOM id matches the store id so that
+        # features like click-to-show-timestamp can look it up.
+        if not widget.id:
+            widget.id = message_data.id
         self._message_store.append(message_data)
 
         # Queued-message widgets must always stay at the bottom so they
@@ -2485,7 +2496,9 @@ class DeepAgentsApp(App):
             self.exit()
         else:
             self._quit_pending = True
-            self.notify("Press Ctrl+C again to quit", timeout=3)
+            quit_timeout = 3
+            self.notify("Press Ctrl+C again to quit", timeout=quit_timeout)
+            self.set_timer(quit_timeout, lambda: setattr(self, "_quit_pending", False))
 
     def action_interrupt(self) -> None:
         """Handle escape key.
@@ -2733,6 +2746,7 @@ class DeepAgentsApp(App):
         screen = ModelSelectorScreen(
             current_model=settings.model_name,
             current_provider=settings.model_provider,
+            cli_profile_override=self._profile_override,
         )
         self.push_screen(screen, handle_result)
 
@@ -2982,7 +2996,11 @@ class DeepAgentsApp(App):
             return
 
         try:
-            result = create_model(model_spec, extra_kwargs=extra_kwargs)
+            result = create_model(
+                model_spec,
+                extra_kwargs=extra_kwargs,
+                profile_overrides=self._profile_override,
+            )
         except ModelConfigError as e:
             await self._mount_message(ErrorMessage(str(e)))
             return
@@ -3140,6 +3158,7 @@ async def run_textual_app(
     sandbox: SandboxBackendProtocol | None = None,
     sandbox_type: str | None = None,
     mcp_server_info: list[MCPServerInfo] | None = None,
+    profile_override: dict[str, Any] | None = None,
 ) -> AppResult:
     """Run the Textual application.
 
@@ -3156,6 +3175,8 @@ async def run_textual_app(
         sandbox: Sandbox backend (for model hot-swap)
         sandbox_type: Type of sandbox provider (for model hot-swap)
         mcp_server_info: MCP server metadata for the `/mcp` viewer.
+        profile_override: Extra profile fields from `--profile-override`,
+            retained for model hot-swap and footer display.
 
     Returns:
         An `AppResult` with the return code and final thread ID.
@@ -3173,6 +3194,7 @@ async def run_textual_app(
         sandbox=sandbox,
         sandbox_type=sandbox_type,
         mcp_server_info=mcp_server_info,
+        profile_override=profile_override,
     )
     await app.run_async()
     return AppResult(

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/deepagents_cli/main.py

@@ -436,6 +436,12 @@ def parse_args() -> argparse.Namespace:
     except Exception:
         logger.warning("Unexpected error looking up SDK version", exc_info=True)
         sdk_version = "unknown"
+    parser.add_argument(
+        "--acp",
+        action="store_true",
+        help="Run as an ACP server over stdio instead of launching the Textual UI",
+    )
+
     parser.add_argument(
         "-v",
         "--version",
@@ -629,6 +635,7 @@ async def run_textual_cli_async(
                 sandbox=sandbox_backend,
                 sandbox_type=sandbox_type if sandbox_type != "none" else None,
                 mcp_server_info=mcp_server_info,
+                profile_override=profile_override,
             )
         finally:
             # Clean up MCP session manager if initialized
@@ -647,6 +654,114 @@ async def run_textual_cli_async(
         return result
 
 
+async def _run_acp_cli_async(
+    assistant_id: str,
+    *,
+    run_acp_agent: Callable[[Any], Any],
+    agent_server_cls: type[Any],
+    model_name: str | None = None,
+    model_params: dict[str, Any] | None = None,
+    profile_override: dict[str, Any] | None = None,
+    mcp_config_path: str | None = None,
+    no_mcp: bool = False,
+    trust_project_mcp: bool | None = None,
+) -> int:
+    """Run ACP server mode and return a process exit code.
+
+    Args:
+        assistant_id: Agent identifier to initialize.
+        run_acp_agent: ACP server runner function.
+        agent_server_cls: ACP server class constructor.
+        model_name: Optional model name to use.
+        model_params: Extra kwargs from `--model-params` to pass to the model.
+        profile_override: Extra profile fields from `--profile-override`.
+        mcp_config_path: Optional path to MCP servers JSON configuration file.
+        no_mcp: Disable all MCP tool loading.
+        trust_project_mcp: Controls project-level stdio server trust.
+
+    Returns:
+        Exit code for ACP mode.
+    """
+    from deepagents_cli.agent import create_cli_agent
+    from deepagents_cli.config import create_model, settings
+    from deepagents_cli.model_config import ModelConfigError
+    from deepagents_cli.tools import fetch_url, http_request, web_search
+
+    try:
+        model_result = create_model(
+            model_name,
+            extra_kwargs=model_params,
+            profile_overrides=profile_override,
+        )
+    except ModelConfigError as exc:
+        sys.stderr.write(f"Error: {exc}\n")
+        sys.stderr.flush()
+        return 1
+    model_result.apply_to_settings()
+
+    tools: list[Any] = [http_request, fetch_url]
+    if settings.has_tavily:
+        tools.append(web_search)
+
+    mcp_session_manager = None
+    mcp_server_info = None
+    try:
+        from deepagents_cli.mcp_tools import resolve_and_load_mcp_tools
+
+        (
+            mcp_tools,
+            mcp_session_manager,
+            mcp_server_info,
+        ) = await resolve_and_load_mcp_tools(
+            explicit_config_path=mcp_config_path,
+            no_mcp=no_mcp,
+            trust_project_mcp=trust_project_mcp,
+        )
+        tools.extend(mcp_tools)
+    except FileNotFoundError as exc:
+        msg = f"Error: MCP config file not found: {exc}\n"
+        sys.stderr.write(msg)
+        sys.stderr.flush()
+        return 1
+    except RuntimeError as exc:
+        msg = f"Error: Failed to load MCP tools: {exc}\n"
+        sys.stderr.write(msg)
+        sys.stderr.flush()
+        return 1
+
+    try:
+        agent_graph, _backend = create_cli_agent(
+            model=model_result.model,
+            assistant_id=assistant_id,
+            tools=tools,
+            mcp_server_info=mcp_server_info,
+        )
+    except Exception as exc:
+        sys.stderr.write(f"Error: failed to create agent: {exc}\n")
+        sys.stderr.flush()
+        logger.debug("ACP agent creation failed", exc_info=True)
+        return 1
+
+    server = agent_server_cls(agent_graph)  # Pregel is a CompiledStateGraph at runtime
+    exit_code = 0
+    try:
+        await run_acp_agent(server)
+    except KeyboardInterrupt:
+        pass
+    except Exception as exc:
+        sys.stderr.write(f"Error: ACP server failed: {exc}\n")
+        sys.stderr.flush()
+        logger.exception("ACP server crashed")
+        exit_code = 1
+    finally:
+        if mcp_session_manager is not None:
+            try:
+                await mcp_session_manager.cleanup()
+            except Exception:
+                logger.warning("MCP session cleanup failed", exc_info=True)
+    return exit_code
+
+
 def apply_stdin_pipe(args: argparse.Namespace) -> None:
     r"""Read piped stdin and merge it into the parsed CLI arguments.
 
@@ -888,20 +1003,16 @@ def cli_main() -> None:
         print(f"deepagents-cli {__version__}\ndeepagents (SDK) {sdk_version}")  # noqa: T201  # CLI version output
         sys.exit(0)
 
-    # Check dependencies first
-    check_cli_dependencies()
+    # ACP mode does not require Textual, so skip UI dependency checks when
+    # the flag is present in raw argv.
+    if "--acp" not in sys.argv[1:]:
+        check_cli_dependencies()
 
     from deepagents_cli.config import console, settings
 
     try:
         args = parse_args()
 
-        # Apply shell-allow-list from command line if provided (overrides env var)
-        if args.shell_allow_list:
-            from deepagents_cli.config import parse_shell_allow_list
-
-            settings.shell_allow_list = parse_shell_allow_list(args.shell_allow_list)
-
         model_params: dict[str, Any] | None = None
         raw_kwargs = getattr(args, "model_params", None)
         if raw_kwargs:
@@ -936,6 +1047,46 @@ def cli_main() -> None:
                 )
                 sys.exit(1)
 
+        if getattr(args, "acp", False):
+            try:
+                from acp import run_agent as run_acp_agent
+                from deepagents_acp.server import AgentServerACP
+            except ImportError as exc:
+                msg = (
+                    f"ACP dependencies not available: {exc}\n"
+                    "Install with: pip install deepagents-acp\n"
+                )
+                sys.stderr.write(msg)
+                sys.stderr.flush()
+                sys.exit(1)
+
+            if getattr(args, "no_mcp", False) and getattr(args, "mcp_config", None):
+                msg = "Error: --no-mcp and --mcp-config are mutually exclusive\n"
+                sys.stderr.write(msg)
+                sys.stderr.flush()
+                sys.exit(2)
+
+            exit_code = asyncio.run(
+                _run_acp_cli_async(
+                    assistant_id=args.agent,
+                    run_acp_agent=run_acp_agent,
+                    agent_server_cls=AgentServerACP,
+                    model_name=getattr(args, "model", None),
+                    model_params=model_params,
+                    profile_override=profile_override,
+                    mcp_config_path=getattr(args, "mcp_config", None),
+                    no_mcp=getattr(args, "no_mcp", False),
+                    trust_project_mcp=getattr(args, "trust_project_mcp", False),
+                )
+            )
+            sys.exit(exit_code)
+
+        # Apply shell-allow-list from command line if provided (overrides env var)
+        if args.shell_allow_list:
+            from deepagents_cli.config import parse_shell_allow_list
+
+            settings.shell_allow_list = parse_shell_allow_list(args.shell_allow_list)
+
         apply_stdin_pipe(args)
 
         if getattr(args, "no_mcp", False) and getattr(args, "mcp_config", None):

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/deepagents_cli/model_config.py

@@ -104,6 +104,20 @@ class ModelSpec:
         return f"{self.provider}:{self.model}"
 
 
+class ModelProfileEntry(TypedDict):
+    """Profile data for a model with override tracking."""
+
+    profile: dict[str, Any]
+    """Merged profile dict (upstream defaults + config.toml overrides).
+
+    Keys vary by provider (e.g., `max_input_tokens`, `tool_calling`).
+    """
+
+    overridden_keys: frozenset[str]
+    """Keys in `profile` whose values came from config.toml rather than the
+    upstream provider package."""
+
+
 class ProviderConfig(TypedDict, total=False):
     """Configuration for a model provider.
 
@@ -194,6 +208,7 @@ registry fallback.
 _available_models_cache: dict[str, list[str]] | None = None
 _builtin_providers_cache: dict[str, Any] | None = None
 _default_config_cache: ModelConfig | None = None
+_profiles_cache: Mapping[str, ModelProfileEntry] | None = None
 
 
 def clear_caches() -> None:
@@ -201,10 +216,11 @@ def clear_caches() -> None:
 
     Intended for tests and for a hypothetical "refresh models" UI action.
     """
-    global _available_models_cache, _builtin_providers_cache, _default_config_cache  # noqa: PLW0603  # Module-level caches require global statement
+    global _available_models_cache, _builtin_providers_cache, _default_config_cache, _profiles_cache  # noqa: PLW0603, E501  # Module-level caches require global statement
     _available_models_cache = None
     _builtin_providers_cache = None
     _default_config_cache = None
+    _profiles_cache = None
 
 
 def _get_builtin_providers() -> dict[str, Any]:
@@ -384,6 +400,111 @@ def get_available_models() -> dict[str, list[str]]:
     return available
 
 
+def _build_entry(
+    base: dict[str, Any],
+    overrides: dict[str, Any],
+    cli_override: dict[str, Any] | None,
+) -> ModelProfileEntry:
+    """Build a profile entry by merging base, overrides, and CLI override.
+
+    Args:
+        base: Upstream profile dict (empty for config-only models).
+        overrides: `config.toml` profile overrides.
+        cli_override: Extra fields from `--profile-override`.
+
+    Returns:
+        Profile entry with merged data and override tracking.
+    """
+    merged = {**base, **overrides}
+    overridden_keys = set(overrides)
+    if cli_override:
+        merged = {**merged, **cli_override}
+        overridden_keys |= set(cli_override)
+    return ModelProfileEntry(
+        profile=merged,
+        overridden_keys=frozenset(overridden_keys),
+    )
+
+
+def get_model_profiles(
+    *,
+    cli_override: dict[str, Any] | None = None,
+) -> Mapping[str, ModelProfileEntry]:
+    """Load upstream profiles merged with config.toml overrides.
+
+    Keyed by `provider:model` spec string. Each entry contains the
+    merged profile dict and the set of keys overridden by config.toml.
+
+    Unlike `get_available_models()`, this includes all models from upstream
+    profiles regardless of capability filters (tool calling, text I/O).
+
+    Results are cached when `cli_override` is None; use `clear_caches()`
+    to reset. When `cli_override` is provided the cache is bypassed
+    because CLI overrides are session-specific.
+
+    Args:
+        cli_override: Extra profile fields from `--profile-override`.
+
+            When provided, these are merged on top of every profile entry
+            (after upstream + config.toml) and their keys are added to
+            `overridden_keys`.
+
+    Returns:
+        Read-only mapping of spec strings to profile entries.
+    """
+    global _profiles_cache  # noqa: PLW0603  # Module-level cache requires global statement
+    if cli_override is None and _profiles_cache is not None:
+        return _profiles_cache
+
+    result: dict[str, ModelProfileEntry] = {}
+    config = ModelConfig.load()
+
+    # Collect upstream profiles from provider packages.
+    seen_specs: set[str] = set()
+    provider_modules = _get_provider_profile_modules()
+    for provider, module_path in provider_modules:
+        try:
+            profiles = _load_provider_profiles(module_path)
+        except ImportError:
+            logger.debug(
+                "Could not import profiles from %s for provider '%s'",
+                module_path,
+                provider,
+            )
+            continue
+        except Exception:
+            logger.warning(
+                "Failed to load profiles from %s for provider '%s'",
+                module_path,
+                provider,
+                exc_info=True,
+            )
+            continue
+
+        for model_name, upstream_profile in profiles.items():
+            spec = f"{provider}:{model_name}"
+            seen_specs.add(spec)
+            overrides = config.get_profile_overrides(provider, model_name=model_name)
+            result[spec] = _build_entry(upstream_profile, overrides, cli_override)
+
+    # Add config-only models that have no upstream profile.
+    for provider_name, provider_config in config.providers.items():
+        config_models = provider_config.get("models", [])
+        for model_name in config_models:
+            spec = f"{provider_name}:{model_name}"
+            if spec not in seen_specs:
+                overrides = config.get_profile_overrides(
+                    provider_name, model_name=model_name
+                )
+                result[spec] = _build_entry({}, overrides, cli_override)
+
+    frozen = MappingProxyType(result)
+    # Only populate cache for the static (no CLI override) path.
+    if cli_override is None:
+        _profiles_cache = frozen
+    return frozen
+
+
 def _is_langchain_supported_provider(provider: str) -> bool:
     """Check if a provider is in langchain's built-in provider registry.
 

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/deepagents_cli/ui.py

@@ -114,6 +114,7 @@ def show_help() -> None:
     )
     console.print("  --default-model [MODEL]    Set, show, or manage the default model")
     console.print("  --clear-default-model      Clear the default model")
+    console.print("  --acp                      Run as an ACP server over stdio")
     console.print("  -v, --version              Show deepagents CLI and SDK versions")
     console.print("  -h, --help                 Show this help message and exit")
     console.print()

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/deepagents_cli/widgets/chat_input.py

@@ -1483,8 +1483,6 @@ class ChatInput(Vertical):
         if self._completion_manager:
             self._completion_manager.reset()
         self.clear_completion_suggestions()
-        if self._text_area:
-            self._text_area.clear()
         return True
 
     def dismiss_completion(self) -> bool:

{deepagents_cli-0.0.29 → deepagents_cli-0.0.30}/deepagents_cli/widgets/messages.py

@@ -37,6 +37,46 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _show_timestamp_toast(widget: Static | Vertical) -> None:
+    """Show a toast with the message's creation timestamp.
+
+    No-ops silently if the widget is not mounted or has no associated message
+    data in the store.
+
+    Args:
+        widget: The message widget whose timestamp to display.
+    """
+    from datetime import UTC, datetime
+
+    try:
+        app = widget.app
+    except Exception:  # noqa: BLE001  # Textual raises when widget has no app
+        return
+    if not widget.id:
+        return
+    store = app._message_store  # type: ignore[attr-defined]
+    data = store.get_message(widget.id)
+    if not data:
+        return
+    dt = datetime.fromtimestamp(data.timestamp, tz=UTC).astimezone()
+    label = f"{dt:%b} {dt.day}, {dt.hour % 12 or 12}:{dt:%M:%S} {dt:%p}"
+    app.notify(label, timeout=3)
+
+
+class _TimestampClickMixin:
+    """Mixin that shows a timestamp toast on click.
+
+    Add to any message widget that should display its creation timestamp when
+    clicked. Widgets needing additional click behavior (e.g. `ToolCallMessage`,
+    `AppMessage`) should override `on_click` and call `_show_timestamp_toast`
+    directly instead.
+    """
+
+    def on_click(self, event: Click) -> None:  # noqa: ARG002  # Textual event handler
+        """Show timestamp toast on click."""
+        _show_timestamp_toast(self)  # type: ignore[arg-type]
+
+
 def _mode_color(mode: str | None) -> str:
     """Return the color string for a mode, falling back to primary.
 
@@ -101,7 +141,7 @@ _TOOLS_WITH_HEADER_INFO: set[str] = {
 }
 
 
-class UserMessage(Static):
+class UserMessage(_TimestampClickMixin, Static):
     """Widget displaying a user message."""
 
     DEFAULT_CSS = """
@@ -231,7 +271,7 @@ class QueuedUserMessage(Static):
         yield Static(text)
 
 
-class AssistantMessage(Vertical):
+class AssistantMessage(_TimestampClickMixin, Vertical):
     """Widget displaying an assistant message with markdown support.
 
     Uses MarkdownStream for smoother streaming instead of re-rendering
@@ -652,9 +692,12 @@ class ToolCallMessage(Vertical):
         self._update_output_display()
 
     def on_click(self, event: Click) -> None:
-        """Handle click to toggle output expansion."""
+        """Toggle output expansion, or show timestamp if no output."""
         event.stop()  # Prevent click from bubbling up and scrolling
-        self.toggle_output()
+        if self._output:
+            self.toggle_output()
+        else:
+            _show_timestamp_toast(self)
 
     def _format_output(
         self, output: str, *, is_preview: bool = False
@@ -1168,7 +1211,7 @@ class ToolCallMessage(Vertical):
         return filtered
 
 
-class DiffMessage(Static):
+class DiffMessage(_TimestampClickMixin, Static):
     """Widget displaying a diff with syntax highlighting."""
 
     DEFAULT_CSS = """
@@ -1239,7 +1282,7 @@ class DiffMessage(Static):
             self.styles.border = ("ascii", "cyan")
 
 
-class ErrorMessage(Static):
+class ErrorMessage(_TimestampClickMixin, Static):
     """Widget displaying an error message."""
 
     DEFAULT_CSS = """
@@ -1307,9 +1350,10 @@ class AppMessage(Static):
         )
         super().__init__(content, **kwargs)
 
-    def on_click(self, event: Click) -> None:  # noqa: PLR6301  # Textual event handler
-        """Open Rich-style hyperlinks on single click."""
+    def on_click(self, event: Click) -> None:
+        """Open Rich-style hyperlinks on single click and show timestamp."""
         open_style_link(event)
+        _show_timestamp_toast(self)
 
 
 class SummarizationMessage(AppMessage):