agentic-cli 0.4.1__tar.gz → 0.4.2__tar.gz

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.2] - 2026-02-08
+
+### Added
+- **Claude Model Support**: Auto-switch to LangGraph orchestrator for Anthropic models
+- **Tool Result Summaries**: Meaningful one-liners for 18 tools instead of generic "Returned N fields"
+
+### Changed
+- **LangGraph Native ToolNode**: Replaced custom tool node with LangChain's native ToolNode
+- **Workflow Manager Decomposition**: Extracted cohesive collaborators from workflow managers
+- **Message Processor Dispatch**: Extracted event handlers into dispatch table
+- **Tool Module Split**: Split monolithic standard.py into domain-specific tool modules
+- **Code Cleanup**: Deleted re-export shim, moved adk_manager into adk/, renamed context accessors
+- **Atomic File Writes**: write_file and edit_file now use atomic writes
+
+### Fixed
+- `diff_compare` tool producing ugly dict repr for summary field
+
 ## [0.4.1] - 2026-02-08
 
 ### Changed

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/CLAUDE.md

@@ -32,21 +32,28 @@ agentic-cli/
 │   │   └── settings*.py      # Settings UI (introspection, dialog)
 │   ├── workflow/
 │   │   ├── base_manager.py   # BaseWorkflowManager (abstract)
-│   │   ├── adk_manager.py    # GoogleADKWorkflowManager
+│   │   ├── task_progress.py  # build_task_progress_event(), parse_plan_progress()
 │   │   ├── events.py         # WorkflowEvent, EventType
 │   │   ├── thinking.py       # ThinkingDetector
 │   │   ├── config.py         # AgentConfig
 │   │   ├── context.py        # ContextVars for tool access (get_context_*())
-│   │   ├── adk/              # ADK-specific (llm_event_logger)
+│   │   ├── adk/              # ADK orchestrator
+│   │   │   ├── manager.py    # GoogleADKWorkflowManager
+│   │   │   ├── event_processor.py  # ADKEventProcessor
+│   │   │   └── llm_event_logger.py # LLM traffic logging
 │   │   └── langgraph/        # LangGraph orchestrator
 │   │       ├── manager.py    # LangGraphWorkflowManager
+│   │       ├── graph_builder.py # LangGraphBuilder (graph + LLM factory)
 │   │       ├── state.py
 │   │       ├── persistence/  # Checkpointers, stores
 │   │       └── tools/        # LangChain-compatible wrappers
 │   ├── tools/
 │   │   ├── registry.py       # ToolRegistry, @register_tool, ToolCategory, PermissionLevel
 │   │   ├── executor.py       # SafePythonExecutor
-│   │   ├── standard.py       # search_knowledge_base, execute_python, ask_clarification
+│   │   ├── knowledge_tools.py # search_knowledge_base, ingest_to_knowledge_base
+│   │   ├── arxiv_tools.py    # search_arxiv, fetch_arxiv_paper, analyze_arxiv_paper
+│   │   ├── execution_tools.py # execute_python
+│   │   ├── interaction_tools.py # ask_clarification
 │   │   ├── file_read.py      # read_file, diff_compare
 │   │   ├── file_write.py     # write_file, edit_file
 │   │   ├── glob_tool.py      # glob

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-cli
-Version: 0.4.1
+Version: 0.4.2
 Summary: A framework for building domain-specific agentic CLI applications
 Project-URL: Homepage, https://github.com/shoom1/agentic-cli
 Project-URL: Repository, https://github.com/shoom1/agentic-cli

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentic-cli"
-version = "0.4.1"
+version = "0.4.2"
 description = "A framework for building domain-specific agentic CLI applications"
 readme = "README.md"
 license = "MIT"

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/src/agentic_cli/__init__.py

@@ -45,7 +45,7 @@ from agentic_cli.cli.settings import CLISettingsMixin
 
 # Heavy imports - lazy loaded on first access
 _lazy_imports = {
-    "GoogleADKWorkflowManager": "agentic_cli.workflow.adk_manager",
+    "GoogleADKWorkflowManager": "agentic_cli.workflow.adk.manager",
     "BaseWorkflowManager": "agentic_cli.workflow.base_manager",
     "LangGraphWorkflowManager": "agentic_cli.workflow.langgraph.manager",
 }
@@ -95,4 +95,4 @@ __all__ = [
     "PathResolver",
 ]
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/src/agentic_cli/cli/message_processor.py

@@ -11,7 +11,7 @@ import asyncio
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from agentic_cli.logging import Loggers, bind_context
 
@@ -92,6 +92,34 @@ class MessageHistory:
         return len(self._messages)
 
 
+# === Event Processing State ===
+
+
+@dataclass
+class _EventProcessingState:
+    """Mutable state shared across event handlers during process()."""
+
+    status_line: str = "Processing..."
+    task_progress_display: str | None = None
+    thinking_started: bool = False
+    thinking_content: list[str] = field(default_factory=list)
+    response_content: list[str] = field(default_factory=list)
+
+    def get_status(self) -> str:
+        """Build status display with current action and task progress."""
+        lines = [self.status_line]
+        if self.task_progress_display:
+            lines.append(self.task_progress_display)
+        return "\n".join(lines)
+
+    def reset_for_retry(self) -> None:
+        """Reset state for retry after rate limit."""
+        self.status_line = "Processing..."
+        self.task_progress_display = None
+        self.thinking_content.clear()
+        self.response_content.clear()
+
+
 # === Message Processor ===
 
 
@@ -156,8 +184,8 @@ class MessageProcessor:
             )
             return
 
-        # Import EventType and WorkflowEvent here (workflow module is now loaded)
-        from agentic_cli.workflow import EventType, WorkflowEvent
+        # Import WorkflowEvent here (workflow module is now loaded)
+        from agentic_cli.workflow import WorkflowEvent
 
         bind_context(user_id=settings.default_user)
         logger.info("handling_message", message_length=len(message))
@@ -166,35 +194,17 @@ class MessageProcessor:
         if settings.log_activity:
             self._message_history.add(message, MessageType.USER)
 
-        # Status line for thinking box (multi-line with task progress)
-        status_line = "Processing..."
-        task_progress_display: str | None = None
-        thinking_started = False
-
-        # Accumulate content for history
-        thinking_content: list[str] = []
-        response_content: list[str] = []
-
-        def get_status() -> str:
-            """Build status display with current action and task progress."""
-            lines = [status_line]
-
-            # Add task progress if available (from TASK_PROGRESS events)
-            if task_progress_display:
-                lines.append(task_progress_display)
-
-            return "\n".join(lines)
-
+        state = _EventProcessingState()
         workflow = workflow_controller.workflow
+        dispatch = self._get_event_dispatch()
 
         # Set up direct callback so HITL tools can prompt the user without
         # deadlocking (the Future pattern blocks the ADK runner, preventing
         # the USER_INPUT_REQUIRED event from ever being yielded).
         async def _handle_input(request: "UserInputRequest") -> str:
-            nonlocal thinking_started
-            if thinking_started:
+            if state.thinking_started:
                 ui.finish_thinking(add_to_history=False)
-                thinking_started = False
+                state.thinking_started = False
 
             wf_event = WorkflowEvent.user_input_required(
                 request_id=request.request_id,
@@ -206,129 +216,52 @@ class MessageProcessor:
             )
             response = await self._prompt_user_input(wf_event, workflow, ui)
 
-            ui.start_thinking(get_status)
-            thinking_started = True
+            ui.start_thinking(state.get_status)
+            state.thinking_started = True
             return response
 
         workflow._user_input_callback = _handle_input
         try:
             while True:
                 try:
-                    ui.start_thinking(get_status)
-                    thinking_started = True
+                    ui.start_thinking(state.get_status)
+                    state.thinking_started = True
 
                     async for event in workflow.process(
                         message=message,
                         user_id=settings.default_user,
                     ):
-                        if event.type == EventType.TEXT:
-                            # Stream response directly to console
-                            ui.add_response(event.content, markdown=True)
-                            response_content.append(event.content)
-
-                        elif event.type == EventType.THINKING:
-                            # Stream thinking to console only if verbose_thinking is enabled
-                            status_line = "Thinking..."
-                            if settings.verbose_thinking:
-                                ui.add_message("system", event.content)
-                            thinking_content.append(event.content)
-
-                        elif event.type == EventType.TOOL_CALL:
-                            # Update status line in thinking box
-                            tool_name = event.metadata.get("tool_name", "unknown")
-                            status_line = f"Calling: {tool_name}"
-
-                        elif event.type == EventType.TOOL_RESULT:
-                            # Display tool result summary
-                            tool_name = event.metadata.get("tool_name", "unknown")
-                            success = event.metadata.get("success", True)
-                            duration = event.metadata.get("duration_ms")
-                            icon = "+" if success else "x"
-                            duration_str = f" ({duration}ms)" if duration else ""
-                            status_line = f"{icon} {tool_name}: {event.content}{duration_str}"
-                            # Also show in message area for visibility
-                            style = "green" if success else "red"
-                            ui.add_rich(
-                                f"[{style}]{icon}[/{style}] {tool_name}: {event.content}{duration_str}"
-                            )
-
-                        elif event.type == EventType.USER_INPUT_REQUIRED:
-                            # Legacy path: handle USER_INPUT_REQUIRED events
-                            # that may still arrive from the ADK event stream.
-                            if thinking_started:
-                                ui.finish_thinking(add_to_history=False)
-                                thinking_started = False
-
-                            response = await self._prompt_user_input(event, workflow, ui)
-                            workflow.provide_user_input(
-                                event.metadata["request_id"],
-                                response,
-                            )
-
-                            # Resume thinking box
-                            ui.start_thinking(get_status)
-                            thinking_started = True
-
-                        elif event.type == EventType.CODE_EXECUTION:
-                            # Update status with execution result
-                            result_preview = (
-                                event.content[:40] + "..."
-                                if len(event.content) > 40
-                                else event.content
-                            )
-                            status_line = f"Result: {result_preview}"
-
-                        elif event.type == EventType.EXECUTABLE_CODE:
-                            # Update status when executing code
-                            lang = event.metadata.get("language", "python")
-                            status_line = f"Running {lang} code..."
-
-                        elif event.type == EventType.FILE_DATA:
-                            # Update status with file info
-                            status_line = f"File: {event.content}"
-
-                        elif event.type == EventType.TASK_PROGRESS:
-                            # Task progress update - event.content has compact display,
-                            # event.metadata has progress stats
-                            progress = event.metadata.get("progress", {})
-                            if progress.get("total", 0) > 0:
-                                completed = progress.get("completed", 0)
-                                total = progress["total"]
-                                # Build display: separator + task list
-                                task_progress_display = f"--- Tasks: {completed}/{total} ---"
-                                if event.content:
-                                    task_progress_display += f"\n{event.content}"
-
-                            # Update status line with current task if available
-                            current_task = event.metadata.get("current_task_description")
-                            if current_task:
-                                status_line = f"Working on: {current_task}"
+                        handler = dispatch.get(event.type)
+                        if handler is not None:
+                            await handler(self, event, state, ui, settings, workflow)
 
                     # Finish thinking box (don't add status to history)
-                    if thinking_started:
+                    if state.thinking_started:
                         ui.finish_thinking(add_to_history=False)
 
                     # Add accumulated content to message history (if logging enabled)
                     if settings.log_activity:
-                        if thinking_content:
+                        if state.thinking_content:
                             self._message_history.add(
-                                "".join(thinking_content), MessageType.THINKING
+                                "".join(state.thinking_content),
+                                MessageType.THINKING,
                             )
-                        if response_content:
+                        if state.response_content:
                             self._message_history.add(
-                                "".join(response_content), MessageType.ASSISTANT
+                                "".join(state.response_content),
+                                MessageType.ASSISTANT,
                             )
 
                     logger.debug("message_handled_successfully")
                     break  # Success — exit retry loop
 
                 except Exception as e:
-                    if thinking_started:
+                    if state.thinking_started:
                         ui.finish_thinking(add_to_history=False)
-                        thinking_started = False
+                        state.thinking_started = False
 
                     # Check for 429 rate limit errors — prompt user to wait and retry
-                    from agentic_cli.workflow.adk_manager import (
+                    from agentic_cli.workflow.adk.event_processor import (
                         _is_rate_limit_error,
                         _parse_retry_delay,
                     )
@@ -342,11 +275,7 @@ class MessageProcessor:
                         if retry:
                             ui.add_warning(f"Waiting {delay:.0f}s before retrying...")
                             await asyncio.sleep(delay)
-                            # Reset state for retry
-                            status_line = "Processing..."
-                            task_progress_display = None
-                            thinking_content.clear()
-                            response_content.clear()
+                            state.reset_for_retry()
                             continue  # Retry the loop
 
                     # Non-429 or user chose cancel
@@ -406,3 +335,169 @@ class MessageProcessor:
                 default=default or "",
             )
             return result or ""
+
+    # === Event handler methods ===
+
+    async def _handle_text(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle TEXT events — stream response to console."""
+        ui.add_response(event.content, markdown=True)
+        state.response_content.append(event.content)
+
+    async def _handle_thinking(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle THINKING events — update status, optionally display."""
+        state.status_line = "Thinking..."
+        if settings.verbose_thinking:
+            ui.add_message("system", event.content)
+        state.thinking_content.append(event.content)
+
+    async def _handle_tool_call(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle TOOL_CALL events — update status line."""
+        tool_name = event.metadata.get("tool_name", "unknown")
+        state.status_line = f"Calling: {tool_name}"
+
+    async def _handle_tool_result(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle TOOL_RESULT events — display result summary."""
+        tool_name = event.metadata.get("tool_name", "unknown")
+        success = event.metadata.get("success", True)
+        duration = event.metadata.get("duration_ms")
+        icon = "+" if success else "x"
+        duration_str = f" ({duration}ms)" if duration else ""
+        state.status_line = f"{icon} {tool_name}: {event.content}{duration_str}"
+        style = "green" if success else "red"
+        ui.add_rich(
+            f"[{style}]{icon}[/{style}] {tool_name}: {event.content}{duration_str}"
+        )
+
+    async def _handle_user_input_required(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle USER_INPUT_REQUIRED events — legacy ADK event stream path."""
+        if state.thinking_started:
+            ui.finish_thinking(add_to_history=False)
+            state.thinking_started = False
+
+        response = await self._prompt_user_input(event, workflow, ui)
+        workflow.provide_user_input(
+            event.metadata["request_id"],
+            response,
+        )
+
+        # Resume thinking box
+        ui.start_thinking(state.get_status)
+        state.thinking_started = True
+
+    async def _handle_code_execution(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle CODE_EXECUTION events — update status with result preview."""
+        result_preview = (
+            event.content[:40] + "..."
+            if len(event.content) > 40
+            else event.content
+        )
+        state.status_line = f"Result: {result_preview}"
+
+    async def _handle_executable_code(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle EXECUTABLE_CODE events — update status with language."""
+        lang = event.metadata.get("language", "python")
+        state.status_line = f"Running {lang} code..."
+
+    async def _handle_file_data(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle FILE_DATA events — update status with filename."""
+        state.status_line = f"File: {event.content}"
+
+    async def _handle_task_progress(
+        self,
+        event: "WorkflowEvent",
+        state: _EventProcessingState,
+        ui: "ThinkingPromptSession",
+        settings: "BaseSettings",
+        workflow: object,
+    ) -> None:
+        """Handle TASK_PROGRESS events — update progress display."""
+        progress = event.metadata.get("progress", {})
+        if progress.get("total", 0) > 0:
+            completed = progress.get("completed", 0)
+            total = progress["total"]
+            state.task_progress_display = f"--- Tasks: {completed}/{total} ---"
+            if event.content:
+                state.task_progress_display += f"\n{event.content}"
+
+        current_task = event.metadata.get("current_task_description")
+        if current_task:
+            state.status_line = f"Working on: {current_task}"
+
+    # === Dispatch table ===
+
+    _EVENT_DISPATCH: ClassVar[dict | None] = None
+
+    @classmethod
+    def _get_event_dispatch(cls) -> dict:
+        """Get or build the EventType → handler dispatch table."""
+        if cls._EVENT_DISPATCH is None:
+            from agentic_cli.workflow import EventType
+
+            cls._EVENT_DISPATCH = {
+                EventType.TEXT: cls._handle_text,
+                EventType.THINKING: cls._handle_thinking,
+                EventType.TOOL_CALL: cls._handle_tool_call,
+                EventType.TOOL_RESULT: cls._handle_tool_result,
+                EventType.USER_INPUT_REQUIRED: cls._handle_user_input_required,
+                EventType.CODE_EXECUTION: cls._handle_code_execution,
+                EventType.EXECUTABLE_CODE: cls._handle_executable_code,
+                EventType.FILE_DATA: cls._handle_file_data,
+                EventType.TASK_PROGRESS: cls._handle_task_progress,
+            }
+        return cls._EVENT_DISPATCH

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/src/agentic_cli/cli/workflow_controller.py

@@ -28,6 +28,20 @@ logger = Loggers.cli()
 _init_executor = ThreadPoolExecutor(max_workers=1, thread_name_prefix="workflow-init")
 
 
+def _is_claude_model(model: str | None) -> bool:
+    """Check if a model string refers to a Claude (Anthropic) model."""
+    return model is not None and model.startswith("claude-")
+
+
+def _resolve_effective_model(
+    model: str | None, settings: "BaseSettings"
+) -> str | None:
+    """Resolve the effective model from explicit override or settings."""
+    if model:
+        return model
+    return getattr(settings, "default_model", None)
+
+
 def create_workflow_manager_from_settings(
     agent_configs: list["AgentConfig"],
     settings: "BaseSettings",
@@ -38,7 +52,9 @@ def create_workflow_manager_from_settings(
     """Factory function to create the appropriate workflow manager based on settings.
 
     Creates either a GoogleADKWorkflowManager or LangGraphWorkflowManager
-    based on the settings.orchestrator configuration.
+    based on the settings.orchestrator configuration. Claude models are
+    automatically routed to LangGraph because ADK's LiteLLM adapter has
+    critical issues with tool calling, thinking, and streaming.
 
     Args:
         agent_configs: List of agent configurations.
@@ -61,8 +77,19 @@ def create_workflow_manager_from_settings(
     from agentic_cli.workflow.settings import OrchestratorType
 
     orchestrator = getattr(settings, "orchestrator", OrchestratorType.ADK)
+    effective_model = _resolve_effective_model(model, settings)
+    use_langgraph = orchestrator == OrchestratorType.LANGGRAPH or _is_claude_model(
+        effective_model
+    )
+
+    if use_langgraph and _is_claude_model(effective_model) and orchestrator != OrchestratorType.LANGGRAPH:
+        logger.info(
+            "auto_switching_to_langgraph",
+            model=effective_model,
+            reason="Claude models require LangGraph orchestrator (ADK LiteLLM adapter has critical issues)",
+        )
 
-    if orchestrator == OrchestratorType.LANGGRAPH:
+    if use_langgraph:
         try:
             from agentic_cli.workflow.langgraph import LangGraphWorkflowManager
 
@@ -77,13 +104,13 @@ def create_workflow_manager_from_settings(
             )
         except ImportError as e:
             raise ImportError(
-                f"LangGraph orchestrator selected but dependencies not installed. "
+                f"LangGraph orchestrator required but dependencies not installed. "
                 f"Install with: pip install agentic-cli[langgraph]\n"
                 f"Original error: {e}"
             ) from e
 
     else:  # Default to ADK
-        from agentic_cli.workflow.adk_manager import GoogleADKWorkflowManager
+        from agentic_cli.workflow.adk.manager import GoogleADKWorkflowManager
 
         return GoogleADKWorkflowManager(
             agent_configs=agent_configs,
@@ -129,15 +156,15 @@ class WorkflowController:
             settings: Application settings instance
         """
         self._settings = settings
+        self._agent_configs = agent_configs
+        self._app_name = settings.app_name
 
         # Closure captures agent_configs for lazy creation (used by _background_init)
-        app_name = settings.app_name
-
         def _create_workflow() -> "BaseWorkflowManager":
             return create_workflow_manager_from_settings(
                 agent_configs=agent_configs,
                 settings=settings,
-                app_name=app_name,
+                app_name=self._app_name,
             )
 
         self._create_fn = _create_workflow
@@ -250,9 +277,35 @@ class WorkflowController:
 
         return self._workflow is not None
 
+    def _needs_orchestrator_swap(self, new_model: str | None) -> bool:
+        """Check if switching to new_model requires a different orchestrator.
+
+        Returns True when the model family changes (e.g. Gemini → Claude or
+        Claude → Gemini) and the current manager type doesn't match what the
+        factory would create for the new model.
+        """
+        if new_model is None or self._workflow is None:
+            return False
+
+        from agentic_cli.workflow.settings import OrchestratorType
+
+        orchestrator = getattr(self._settings, "orchestrator", OrchestratorType.ADK)
+        new_needs_langgraph = orchestrator == OrchestratorType.LANGGRAPH or _is_claude_model(new_model)
+
+        # Check current manager type by class name to avoid isinstance issues
+        # when the class may not be importable (LangGraph not installed)
+        current_cls_name = type(self._workflow).__name__
+        current_is_langgraph = current_cls_name == "LangGraphWorkflowManager"
+
+        return new_needs_langgraph != current_is_langgraph
+
     async def reinitialize(self, model: str | None = None) -> None:
         """Reinitialize the workflow with optional new model.
 
+        If the new model requires a different orchestrator (e.g. switching from
+        Gemini on ADK to Claude on LangGraph), the entire workflow manager is
+        replaced. Otherwise, the existing manager is reinitalized in place.
+
         Args:
             model: Optional new model to use
 
@@ -263,7 +316,21 @@ class WorkflowController:
         if self._workflow is None:
             raise RuntimeError("Cannot reinitialize - workflow not initialized")
 
-        await self._workflow.reinitialize(model=model, preserve_sessions=True)
+        if self._needs_orchestrator_swap(model):
+            logger.info(
+                "orchestrator_swap",
+                old_model=self._workflow.model,
+                new_model=model,
+            )
+            self._workflow = create_workflow_manager_from_settings(
+                agent_configs=self._agent_configs,
+                settings=self._settings,
+                app_name=self._app_name,
+                model=model,
+            )
+            await self._workflow.initialize_services()
+        else:
+            await self._workflow.reinitialize(model=model, preserve_sessions=True)
 
     async def cancel_init(self) -> None:
         """Cancel pending initialization task if still running."""

{agentic_cli-0.4.1 → agentic_cli-0.4.2}/src/agentic_cli/constants.py

@@ -10,3 +10,12 @@ def truncate(text: str, max_length: int = CONTENT_PREVIEW_LENGTH) -> str:
     if len(text) > max_length:
         return text[:max_length] + "..."
     return text
+
+
+def format_size(size_bytes: int) -> str:
+    """Format byte count as human-readable string (B, KB, MB)."""
+    if size_bytes < 1024:
+        return f"{size_bytes}B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f}KB"
+    return f"{size_bytes / (1024 * 1024):.1f}MB"