kader 0.1.6__py3-none-any.whl → 1.1.0__py3-none-any.whl

cli/app.py

@@ -1,7 +1,9 @@
 """Kader CLI - Modern Vibe Coding CLI with Textual."""
 
 import asyncio
+import atexit
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from importlib.metadata import version as get_version
 from pathlib import Path
 from typing import Optional
@@ -18,14 +20,13 @@ from textual.widgets import (
     Tree,
 )
 
-from kader.agent.agents import ReActAgent
 from kader.memory import (
     FileSessionManager,
     MemoryConfig,
-    SlidingWindowConversationManager,
 )
-from kader.tools import get_default_registry
+from kader.workflows import PlannerExecutorWorkflow
 
+from .llm_factory import LLMProviderFactory
 from .utils import (
     DEFAULT_MODEL,
     HELP_TEXT,
@@ -103,22 +104,83 @@ class KaderApp(App):
         self._model_selector: Optional[ModelSelector] = None
         self._update_info: Optional[str] = None  # Latest version if update available
 
-        self._agent = self._create_agent(self._current_model)
+        # Dedicated thread pool for agent invocation (isolated from default pool)
+        self._agent_executor = ThreadPoolExecutor(
+            max_workers=2, thread_name_prefix="kader_agent"
+        )
+        # Ensure executor is properly shut down on exit
+        atexit.register(self._agent_executor.shutdown, wait=False)
+
+        self._workflow = self._create_workflow(self._current_model)
 
-    def _create_agent(self, model_name: str) -> ReActAgent:
-        """Create a new ReActAgent with the specified model."""
-        registry = get_default_registry()
-        memory = SlidingWindowConversationManager(window_size=10)
-        return ReActAgent(
+    def _create_workflow(self, model_name: str) -> PlannerExecutorWorkflow:
+        """Create a new PlannerExecutorWorkflow with the specified model."""
+        # Create provider using factory (supports provider:model format)
+        provider = LLMProviderFactory.create_provider(model_name)
+
+        return PlannerExecutorWorkflow(
             name="kader_cli",
-            tools=registry,
-            memory=memory,
-            model_name=model_name,
-            use_persistence=True,
+            provider=provider,
+            model_name=model_name,  # Keep for reference
             interrupt_before_tool=True,
             tool_confirmation_callback=self._tool_confirmation_callback,
+            direct_execution_callback=self._direct_execution_callback,
+            tool_execution_result_callback=self._tool_execution_result_callback,
+            use_persistence=True,
+            executor_names=["executor"],
+        )
+
+    def _direct_execution_callback(self, message: str, tool_name: str) -> None:
+        """
+        Callback for direct execution tools - called from agent thread.
+
+        Shows a message in the conversation view without blocking for confirmation.
+        """
+        # Schedule message display on main thread
+        self.call_from_thread(self._show_direct_execution_message, message, tool_name)
+
+    def _show_direct_execution_message(self, message: str, tool_name: str) -> None:
+        """Show a direct execution message in the conversation view."""
+        try:
+            conversation = self.query_one("#conversation-view", ConversationView)
+            # User-friendly message showing the tool is executing
+            friendly_message = f"[>] Executing {tool_name}..."
+            conversation.add_message(friendly_message, "assistant")
+            conversation.scroll_end()
+        except Exception:
+            pass
+
+    def _tool_execution_result_callback(
+        self, tool_name: str, success: bool, result: str
+    ) -> None:
+        """
+        Callback for tool execution results - called from agent thread.
+
+        Updates the conversation view with the execution result.
+        """
+        # Schedule result display on main thread
+        self.call_from_thread(
+            self._show_tool_execution_result, tool_name, success, result
         )
 
+    def _show_tool_execution_result(
+        self, tool_name: str, success: bool, result: str
+    ) -> None:
+        """Show the tool execution result in the conversation view."""
+        try:
+            conversation = self.query_one("#conversation-view", ConversationView)
+            if success:
+                # User-friendly success message
+                friendly_message = f"(+) {tool_name} completed successfully"
+            else:
+                # User-friendly error message with truncated result
+                error_preview = result[:100] + "..." if len(result) > 100 else result
+                friendly_message = f"(-) {tool_name} failed: {error_preview}"
+            conversation.add_message(friendly_message, "assistant")
+            conversation.scroll_end()
+        except Exception:
+            pass
+
     def _tool_confirmation_callback(self, message: str) -> tuple[bool, Optional[str]]:
         """
         Callback for tool confirmation - called from agent thread.
@@ -135,7 +197,10 @@ class KaderApp(App):
 
         # Wait for user response (blocking in agent thread)
         # This is safe because we're in a background thread
-        self._confirmation_event.wait()
+        # Timeout after 5 minutes to prevent indefinite blocking
+        if not self._confirmation_event.wait(timeout=300):
+            # Timeout occurred - decline tool execution gracefully
+            return (False, "Tool confirmation timed out after 5 minutes")
 
         # Return the result
         return self._confirmation_result
@@ -183,7 +248,8 @@ class KaderApp(App):
         if event.confirmed:
             if tool_message:
                 conversation.add_message(tool_message, "assistant")
-            conversation.add_message("(+) Executing tool...", "assistant")
+            # Show executing message - will be updated by result callback
+            conversation.add_message("[>] Executing tool...", "assistant")
             # Restart spinner
             try:
                 spinner = self.query_one(LoadingSpinner)
@@ -207,13 +273,12 @@ class KaderApp(App):
 
     async def _show_model_selector(self, conversation: ConversationView) -> None:
         """Show the model selector widget."""
-        from kader.providers import OllamaProvider
-
         try:
-            models = OllamaProvider.get_supported_models()
+            # Get models from all available providers
+            models = LLMProviderFactory.get_flat_model_list()
             if not models:
                 conversation.add_message(
-                    "## Models (^^)\n\n*No models found. Is Ollama running?*",
+                    "## Models (^^)\n\n*No models found. Check provider configurations.*",
                     "assistant",
                 )
                 return
@@ -249,7 +314,7 @@ class KaderApp(App):
         # Update model and recreate agent
         old_model = self._current_model
         self._current_model = event.model
-        self._agent = self._create_agent(self._current_model)
+        self._workflow = self._create_workflow(self._current_model)
 
         conversation.add_message(
             f"(+) Model changed from `{old_model}` to `{self._current_model}`",
@@ -431,8 +496,8 @@ Please resize your terminal."""
             await self._show_model_selector(conversation)
         elif cmd == "/clear":
             conversation.clear_messages()
-            self._agent.memory.clear()
-            self._agent.provider.reset_tracking()  # Reset usage/cost tracking
+            self._workflow.planner.memory.clear()
+            self._workflow.planner.provider.reset_tracking()  # Reset usage/cost tracking
             self._current_session_id = None
             self.notify("Conversation cleared!", severity="information")
         elif cmd == "/save":
@@ -462,7 +527,7 @@ Please resize your terminal."""
             )
 
     async def _handle_chat(self, message: str) -> None:
-        """Handle regular chat messages with ReActAgent."""
+        """Handle regular chat messages with PlannerExecutorWorkflow."""
         if self._is_processing:
             self.notify("Please wait for the current response...", severity="warning")
             return
@@ -490,20 +555,25 @@ Please resize your terminal."""
         spinner = self.query_one(LoadingSpinner)
 
         try:
-            # Run the agent invoke in a thread
+            # Run the workflow in a dedicated thread pool
             loop = asyncio.get_event_loop()
             response = await loop.run_in_executor(
-                None, lambda: self._agent.invoke(message)
+                self._agent_executor, lambda: self._workflow.run(message)
             )
 
             # Hide spinner and show response (this runs on main thread via await)
             spinner.stop()
-            if response and response.content:
-                conversation.add_message(response.content, "assistant")
+            if response:
+                conversation.add_message(
+                    response,
+                    "assistant",
+                    model_name=self._workflow.planner.provider.model,
+                    usage_cost=self._workflow.planner.provider.total_cost.total_cost,
+                )
 
         except Exception as e:
             spinner.stop()
-            error_msg = f"(-) **Error:** {str(e)}\n\nMake sure Ollama is running and the model `{self._current_model}` is available."
+            error_msg = f"(-) **Error:** {str(e)}\n\nMake sure the provider for `{self._current_model}` is configured and available."
             conversation.add_message(error_msg, "assistant")
             self.notify(f"Error: {e}", severity="error")
 
@@ -516,7 +586,7 @@ Please resize your terminal."""
         """Clear the conversation (Ctrl+L)."""
         conversation = self.query_one("#conversation-view", ConversationView)
         conversation.clear_messages()
-        self._agent.memory.clear()
+        self._workflow.planner.memory.clear()
         self.notify("Conversation cleared!", severity="information")
 
     def action_save_session(self) -> None:
@@ -548,8 +618,10 @@ Please resize your terminal."""
                 session = self._session_manager.create_session("kader_cli")
                 self._current_session_id = session.session_id
 
-            # Get messages from agent memory and save
-            messages = [msg.message for msg in self._agent.memory.get_messages()]
+            # Get messages from planner memory and save
+            messages = [
+                msg.message for msg in self._workflow.planner.memory.get_messages()
+            ]
             self._session_manager.save_conversation(self._current_session_id, messages)
 
             conversation.add_message(
@@ -580,11 +652,11 @@ Please resize your terminal."""
 
             # Clear current state
             conversation.clear_messages()
-            self._agent.memory.clear()
+            self._workflow.planner.memory.clear()
 
             # Add loaded messages to memory and UI
             for msg in messages:
-                self._agent.memory.add_message(msg)
+                self._workflow.planner.memory.add_message(msg)
                 role = msg.get("role", "user")
                 content = msg.get("content", "")
                 if role in ["user", "assistant"] and content:
@@ -633,9 +705,9 @@ Please resize your terminal."""
         """Display LLM usage costs."""
         try:
             # Get cost and usage from the provider
-            cost = self._agent.provider.total_cost
-            usage = self._agent.provider.total_usage
-            model = self._agent.provider.model
+            cost = self._workflow.planner.provider.total_cost
+            usage = self._workflow.planner.provider.total_usage
+            model = self._workflow.planner.provider.model
 
             lines = [
                 "## Usage Costs ($)\n",

cli/app.tcss

@@ -132,6 +132,26 @@ ConversationView {
     scrollbar-size: 1 1;
 }
 
+.message-footer {
+    height: auto;
+    margin-top: 0;
+    padding: 0 1;
+    border-top: none;
+}
+
+.footer-left {
+    color: $secondary;
+    text-style: italic;
+    width: 1fr;
+}
+
+.footer-right {
+    color: $success;
+    text-style: bold;
+    text-align: right;
+    width: auto;
+}
+
 /* ===== Welcome Message ===== */
 
 #welcome {

cli/llm_factory.py

@@ -0,0 +1,165 @@
+"""LLM Provider Factory for Kader CLI.
+
+Factory pattern implementation for creating LLM provider instances
+with automatic provider detection based on model name format.
+"""
+
+from typing import Optional
+
+from kader.providers import GoogleProvider, OllamaProvider
+from kader.providers.base import BaseLLMProvider, ModelConfig
+
+
+class LLMProviderFactory:
+    """
+    Factory for creating LLM provider instances.
+
+    Supports multiple providers with automatic detection based on model name format.
+    Model names can be specified as:
+    - "provider:model" (e.g., "google:gemini-2.5-flash", "ollama:kimi-k2.5:cloud")
+    - "model" (defaults to Ollama for backward compatibility)
+
+    Example:
+        factory = LLMProviderFactory()
+        provider = factory.create_provider("google:gemini-2.5-flash")
+
+        # Or with default provider (Ollama)
+        provider = factory.create_provider("kimi-k2.5:cloud")
+    """
+
+    # Registered provider classes
+    PROVIDERS: dict[str, type[BaseLLMProvider]] = {
+        "ollama": OllamaProvider,
+        "google": GoogleProvider,
+    }
+
+    # Default provider when no prefix is specified
+    DEFAULT_PROVIDER = "ollama"
+
+    @classmethod
+    def parse_model_name(cls, model_string: str) -> tuple[str, str]:
+        """
+        Parse model string to extract provider and model name.
+
+        Args:
+            model_string: Model string in format "provider:model" or just "model"
+
+        Returns:
+            Tuple of (provider_name, model_name)
+        """
+        # Check if the string starts with a known provider prefix
+        for provider_name in cls.PROVIDERS.keys():
+            prefix = f"{provider_name}:"
+            if model_string.lower().startswith(prefix):
+                return provider_name, model_string[len(prefix) :]
+
+        # No known provider prefix found, use default
+        return cls.DEFAULT_PROVIDER, model_string
+
+    @classmethod
+    def create_provider(
+        cls,
+        model_string: str,
+        config: Optional[ModelConfig] = None,
+    ) -> BaseLLMProvider:
+        """
+        Create an LLM provider instance.
+
+        Args:
+            model_string: Model identifier (e.g., "google:gemini-2.5-flash" or "kimi-k2.5:cloud")
+            config: Optional model configuration
+
+        Returns:
+            Configured provider instance
+
+        Raises:
+            ValueError: If provider is not supported
+        """
+        provider_name, model_name = cls.parse_model_name(model_string)
+
+        provider_class = cls.PROVIDERS.get(provider_name)
+        if not provider_class:
+            supported = ", ".join(cls.PROVIDERS.keys())
+            raise ValueError(
+                f"Unknown provider: {provider_name}. Supported: {supported}"
+            )
+
+        return provider_class(model=model_name, default_config=config)
+
+    @classmethod
+    def get_all_models(cls) -> dict[str, list[str]]:
+        """
+        Get all available models from all registered providers.
+
+        Returns:
+            Dictionary mapping provider names to their available models
+            (with provider prefix included in model names)
+        """
+        models: dict[str, list[str]] = {}
+
+        # Get Ollama models
+        try:
+            ollama_models = OllamaProvider.get_supported_models()
+            models["ollama"] = [f"ollama:{m}" for m in ollama_models]
+        except Exception:
+            models["ollama"] = []
+
+        # Get Google models
+        try:
+            google_models = GoogleProvider.get_supported_models()
+            models["google"] = [f"google:{m}" for m in google_models]
+        except Exception:
+            models["google"] = []
+
+        return models
+
+    @classmethod
+    def get_flat_model_list(cls) -> list[str]:
+        """
+        Get a flattened list of all available models with provider prefixes.
+
+        Returns:
+            List of model strings in "provider:model" format
+        """
+        all_models = cls.get_all_models()
+        flat_list: list[str] = []
+        for models in all_models.values():
+            flat_list.extend(models)
+        return flat_list
+
+    @classmethod
+    def is_provider_available(cls, provider_name: str) -> bool:
+        """
+        Check if a provider is available and configured.
+
+        Args:
+            provider_name: Name of the provider to check
+
+        Returns:
+            True if provider is available and has models, False otherwise
+        """
+        provider_name = provider_name.lower()
+        if provider_name not in cls.PROVIDERS:
+            return False
+
+        # Try to get models to verify provider is working
+        try:
+            provider_class = cls.PROVIDERS[provider_name]
+            models = provider_class.get_supported_models()
+            return len(models) > 0
+        except Exception:
+            return False
+
+    @classmethod
+    def get_provider_name(cls, model_string: str) -> str:
+        """
+        Get the provider name for a given model string.
+
+        Args:
+            model_string: Model string in format "provider:model" or just "model"
+
+        Returns:
+            Provider name (e.g., "ollama", "google")
+        """
+        provider_name, _ = cls.parse_model_name(model_string)
+        return provider_name

cli/utils.py

@@ -1,9 +1,9 @@
 """Utility constants and helpers for Kader CLI."""
 
-from kader.providers import OllamaProvider
+from .llm_factory import LLMProviderFactory
 
-# Default model
-DEFAULT_MODEL = "qwen3-coder:480b-cloud"
+# Default model (with provider prefix for clarity)
+DEFAULT_MODEL = "ollama:kimi-k2.5:cloud"
 
 HELP_TEXT = """## Kader CLI Commands
 
@@ -40,24 +40,32 @@ HELP_TEXT = """## Kader CLI Commands
 ### Tips:
 - Type any question to chat with the AI
 - Use **Tab** to navigate between panels
+- Model format: `provider:model` (e.g., `google:gemini-2.5-flash`)
 """
 
 
 def get_models_text() -> str:
-    """Get formatted text of available Ollama models."""
+    """Get formatted text of available models from all providers."""
     try:
-        models = OllamaProvider.get_supported_models()
-        if not models:
-            return "## Available Models (^^)\n\n*No models found. Is Ollama running?*"
+        all_models = LLMProviderFactory.get_all_models()
+        flat_list = LLMProviderFactory.get_flat_model_list()
+
+        if not flat_list:
+            return "## Available Models (^^)\n\n*No models found. Check provider configurations.*"
 
         lines = [
             "## Available Models (^^)\n",
-            "| Model | Status |",
-            "|-------|--------|",
+            "| Provider | Model | Status |",
+            "|----------|-------|--------|",
         ]
-        for model in models:
-            lines.append(f"| {model} | (+) Available |")
+        for provider_name, provider_models in all_models.items():
+            for model in provider_models:
+                lines.append(f"| {provider_name.title()} | `{model}` | (+) Available |")
+
         lines.append(f"\n*Currently using: **{DEFAULT_MODEL}***")
+        lines.append(
+            "\n> (!) Tip: Use `provider:model` format (e.g., `google:gemini-2.5-flash`)"
+        )
         return "\n".join(lines)
     except Exception as e:
         return f"## Available Models (^^)\n\n*Error fetching models: {e}*"

cli/widgets/conversation.py

@@ -1,23 +1,43 @@
 """Conversation display widget for Kader CLI."""
 
 from textual.app import ComposeResult
-from textual.containers import VerticalScroll
+from textual.containers import Horizontal, VerticalScroll
 from textual.widgets import Markdown, Static
 
 
 class Message(Static):
     """A single message in the conversation."""
 
-    def __init__(self, content: str, role: str = "user") -> None:
+    def __init__(
+        self,
+        content: str,
+        role: str = "user",
+        model_name: str | None = None,
+        usage_cost: float | None = None,
+    ) -> None:
         super().__init__()
         self.content = content
         self.role = role
+        self.model_name = model_name
+        self.usage_cost = usage_cost
         self.add_class(f"message-{role}")
 
     def compose(self) -> ComposeResult:
         prefix = "(**) **You:**" if self.role == "user" else "(^^) **Kader:**"
         yield Markdown(f"{prefix}\n\n{self.content}")
 
+        if self.role == "assistant" and (
+            self.model_name or self.usage_cost is not None
+        ):
+            with Horizontal(classes="message-footer"):
+                model_label = f"[*] {self.model_name}" if self.model_name else ""
+                yield Static(model_label, classes="footer-left")
+
+                usage_label = (
+                    f"($) {self.usage_cost:.6f}" if self.usage_cost is not None else ""
+                )
+                yield Static(usage_label, classes="footer-right")
+
 
 class ConversationView(VerticalScroll):
     """Scrollable conversation history with markdown rendering."""
@@ -41,11 +61,37 @@ class ConversationView(VerticalScroll):
         background: $surface-darken-1;
         border-left: thick $success;
     }
+
+    .message-footer {
+        height: auto;
+        margin-top: 0;
+        padding: 0 1;
+        border-top: none;
+    }
+
+    .footer-left {
+        color: $secondary;
+        text-style: italic;
+        width: 1fr;
+    }
+
+    .footer-right {
+        color: $success;
+        text-style: bold;
+        text-align: right;
+        width: auto;
+    }
     """
 
-    def add_message(self, content: str, role: str = "user") -> None:
+    def add_message(
+        self,
+        content: str,
+        role: str = "user",
+        model_name: str | None = None,
+        usage_cost: float | None = None,
+    ) -> None:
         """Add a message to the conversation."""
-        message = Message(content, role)
+        message = Message(content, role, model_name, usage_cost)
         self.mount(message)
         self.scroll_end(animate=True)
 

kader/__init__.py

@@ -8,6 +8,7 @@ creating the .kader directory in the user's home directory.
 from .config import ENV_FILE_PATH, KADER_DIR, initialize_kader_config
 from .providers import *  # noqa: F401, F403
 from .tools import *  # noqa: F401, F403
+from .utils import Checkpointer
 
 # Initialize the configuration when the module is imported
 initialize_kader_config()
@@ -18,5 +19,6 @@ __all__ = [
     "KADER_DIR",
     "ENV_FILE_PATH",
     "initialize_kader_config",
+    "Checkpointer",
     # Export everything from providers and tools
 ]

kader/agent/agents.py

@@ -31,6 +31,8 @@ class ReActAgent(BaseAgent):
         use_persistence: bool = False,
         interrupt_before_tool: bool = True,
         tool_confirmation_callback: Optional[callable] = None,
+        direct_execution_callback: Optional[callable] = None,
+        tool_execution_result_callback: Optional[callable] = None,
     ) -> None:
         # Resolve tools for prompt context if necessary
         # The base agent handles tool registration, but for the prompt template
@@ -67,6 +69,8 @@ class ReActAgent(BaseAgent):
             use_persistence=use_persistence,
             interrupt_before_tool=interrupt_before_tool,
             tool_confirmation_callback=tool_confirmation_callback,
+            direct_execution_callback=direct_execution_callback,
+            tool_execution_result_callback=tool_execution_result_callback,
         )
 
 
@@ -90,6 +94,8 @@ class PlanningAgent(BaseAgent):
         use_persistence: bool = False,
         interrupt_before_tool: bool = True,
         tool_confirmation_callback: Optional[callable] = None,
+        direct_execution_callback: Optional[callable] = None,
+        tool_execution_result_callback: Optional[callable] = None,
     ) -> None:
         # Ensure TodoTool is available
         _todo_tool = TodoTool()
@@ -123,4 +129,6 @@ class PlanningAgent(BaseAgent):
             use_persistence=use_persistence,
             interrupt_before_tool=interrupt_before_tool,
             tool_confirmation_callback=tool_confirmation_callback,
+            direct_execution_callback=direct_execution_callback,
+            tool_execution_result_callback=tool_execution_result_callback,
         )