kader 0.1.6__tar.gz → 1.1.0__tar.gz

kader-0.1.6/README.md → kader-1.1.0/PKG-INFO

@@ -1,3 +1,22 @@
+Metadata-Version: 2.4
+Name: kader
+Version: 1.1.0
+Summary: kader coding agent
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: faiss-cpu>=1.9.0
+Requires-Dist: google-genai>=1.61.0
+Requires-Dist: jinja2>=3.1.6
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: ollama>=0.6.1
+Requires-Dist: outdated>=0.2.2
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: textual[syntax]>=6.8.0
+Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: wcmatch>=10.1
+Description-Content-Type: text/markdown
+
 # Kader
 
 Kader is an intelligent coding agent designed to assist with software development tasks. It provides a comprehensive framework for building AI-powered agents with advanced reasoning capabilities and tool integration.
@@ -15,6 +34,7 @@ Kader is an intelligent coding agent designed to assist with software developmen
 - 🔄 **ReAct Agent Framework** - Reasoning and Acting agent architecture
 - 🗂️ **File System Tools** - Read, write, search, and edit files
 - 🔍 **Planning Agent** - Task planning and execution capabilities
+- 🤝 **Agent-As-Tool** - Spawn sub-agents for specific tasks with isolated memory
 
 ## Installation
 
@@ -160,6 +180,40 @@ Kader provides several agent types:
 - **PlanningAgent**: Agent that plans multi-step tasks
 - **BaseAgent**: Base agent class for creating custom agents
 
+### Agent-As-Tool (AgentTool)
+
+The `AgentTool` allows you to wrap a `ReActAgent` as a callable tool, enabling agents to spawn sub-agents for specific tasks with isolated memory contexts.
+
+```python
+from kader.tools import AgentTool
+
+# Autonomous execution (runs without pausing for confirmation)
+autonomous_agent = AgentTool(
+    name="research_agent",
+    description="Research topics autonomously",
+    interrupt_before_tool=False,
+)
+result = autonomous_agent.execute(task="Find info about topic X")
+
+# Interactive execution (pauses for user confirmation before each tool)
+def my_callback(tool_call_dict, llm_content=None):
+    user_input = input("Execute? [y/n]: ")
+    return (user_input.lower() == 'y', None)
+
+interactive_agent = AgentTool(
+    name="interactive_agent",
+    interrupt_before_tool=True,
+    tool_confirmation_callback=my_callback,
+)
+result = interactive_agent.execute(task="Analyze data and generate report")
+```
+
+**Key Features:**
+- Each sub-agent has isolated memory (separate `SlidingWindowConversationManager`)
+- Default tools included: filesystem, web search, command executor
+- Optional `interrupt_before_tool` for user confirmation before tool execution
+- Task completes when the agent returns its final response
+
 ### Memory Management
 
 Kader's memory system includes:
@@ -177,6 +231,7 @@ Kader includes a rich set of tools:
 - **Command Executor**: Execute shell commands safely
 - **Web Tools**: Search and fetch web content
 - **RAG Tools**: Retrieval Augmented Generation capabilities
+- **AgentTool**: Spawn sub-agents for specific tasks
 
 ## Examples
 

kader-0.1.6/PKG-INFO → kader-1.1.0/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.4
-Name: kader
-Version: 0.1.6
-Summary: kader coding agent
-Requires-Python: >=3.11
-Requires-Dist: faiss-cpu>=1.9.0
-Requires-Dist: jinja2>=3.1.6
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: ollama>=0.6.1
-Requires-Dist: outdated>=0.2.2
-Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: tenacity>=9.1.2
-Requires-Dist: textual[syntax]>=6.8.0
-Requires-Dist: typing-extensions>=4.15.0
-Requires-Dist: wcmatch>=10.1
-Description-Content-Type: text/markdown
-
 # Kader
 
 Kader is an intelligent coding agent designed to assist with software development tasks. It provides a comprehensive framework for building AI-powered agents with advanced reasoning capabilities and tool integration.
@@ -32,6 +15,7 @@ Kader is an intelligent coding agent designed to assist with software developmen
 - 🔄 **ReAct Agent Framework** - Reasoning and Acting agent architecture
 - 🗂️ **File System Tools** - Read, write, search, and edit files
 - 🔍 **Planning Agent** - Task planning and execution capabilities
+- 🤝 **Agent-As-Tool** - Spawn sub-agents for specific tasks with isolated memory
 
 ## Installation
 
@@ -177,6 +161,40 @@ Kader provides several agent types:
 - **PlanningAgent**: Agent that plans multi-step tasks
 - **BaseAgent**: Base agent class for creating custom agents
 
+### Agent-As-Tool (AgentTool)
+
+The `AgentTool` allows you to wrap a `ReActAgent` as a callable tool, enabling agents to spawn sub-agents for specific tasks with isolated memory contexts.
+
+```python
+from kader.tools import AgentTool
+
+# Autonomous execution (runs without pausing for confirmation)
+autonomous_agent = AgentTool(
+    name="research_agent",
+    description="Research topics autonomously",
+    interrupt_before_tool=False,
+)
+result = autonomous_agent.execute(task="Find info about topic X")
+
+# Interactive execution (pauses for user confirmation before each tool)
+def my_callback(tool_call_dict, llm_content=None):
+    user_input = input("Execute? [y/n]: ")
+    return (user_input.lower() == 'y', None)
+
+interactive_agent = AgentTool(
+    name="interactive_agent",
+    interrupt_before_tool=True,
+    tool_confirmation_callback=my_callback,
+)
+result = interactive_agent.execute(task="Analyze data and generate report")
+```
+
+**Key Features:**
+- Each sub-agent has isolated memory (separate `SlidingWindowConversationManager`)
+- Default tools included: filesystem, web search, command executor
+- Optional `interrupt_before_tool` for user confirmation before tool execution
+- Task completes when the agent returns its final response
+
 ### Memory Management
 
 Kader's memory system includes:
@@ -194,6 +212,7 @@ Kader includes a rich set of tools:
 - **Command Executor**: Execute shell commands safely
 - **Web Tools**: Search and fetch web content
 - **RAG Tools**: Retrieval Augmented Generation capabilities
+- **AgentTool**: Spawn sub-agents for specific tasks
 
 ## Examples
 

{kader-0.1.6 → kader-1.1.0}/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",

{kader-0.1.6 → kader-1.1.0}/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 {

kader-1.1.0/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

{kader-0.1.6 → kader-1.1.0}/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}*"