kader 1.0.0__tar.gz → 1.1.0__tar.gz

{kader-1.0.0 → kader-1.1.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: kader
-Version: 1.0.0
+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

{kader-1.0.0 → kader-1.1.0}/cli/app.py

@@ -26,6 +26,7 @@ from kader.memory import (
 )
 from kader.workflows import PlannerExecutorWorkflow
 
+from .llm_factory import LLMProviderFactory
 from .utils import (
     DEFAULT_MODEL,
     HELP_TEXT,
@@ -114,9 +115,13 @@ class KaderApp(App):
 
     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",
-            model_name=model_name,
+            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,
@@ -268,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
@@ -569,7 +573,7 @@ Please resize your terminal."""
 
         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")
 

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-1.0.0 → 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 = "kimi-k2.5: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}*"

kader-1.1.0/examples/google_example.py

@@ -0,0 +1,331 @@
+"""
+Google Provider Example
+
+Demonstrates how to use the Kader Google provider for:
+- Basic LLM invocation
+- Streaming responses
+- Asynchronous operations
+- Configuration options
+- Tool/function calling
+- Dynamic model listing
+
+API Key Setup:
+    Set your GEMINI_API_KEY in ~/.kader/.env:
+    GEMINI_API_KEY='your-api-key-here'
+"""
+
+import asyncio
+import os
+import sys
+
+# Add project root to path for direct execution
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from kader.providers.base import Message, ModelConfig
+from kader.providers.google import GoogleProvider
+
+
+def demo_basic_invocation():
+    """Demonstrate basic synchronous invocation."""
+    print("\n=== Basic Google Invocation Demo ===")
+
+    # Initialize the provider with a model
+    # Note: Set GEMINI_API_KEY or GOOGLE_API_KEY environment variable
+    provider = GoogleProvider(model="gemini-2.5-flash")
+
+    # Create a simple conversation
+    messages = [
+        Message.system("You are a helpful assistant that responds concisely."),
+        Message.user("What are the benefits of using Google Gemini models?"),
+    ]
+
+    try:
+        # Invoke the model synchronously
+        response = provider.invoke(messages)
+
+        print(f"Model: {response.model}")
+        print(f"Content: {response.content}")
+        print(f"Prompt tokens: {response.usage.prompt_tokens}")
+        print(f"Completion tokens: {response.usage.completion_tokens}")
+        print(f"Total tokens: {response.usage.total_tokens}")
+        print(f"Finish reason: {response.finish_reason}")
+
+        # Show cost tracking
+        if response.cost:
+            print(f"Cost: {response.cost.format()}")
+
+        # Show total usage tracking
+        print(f"Total usage tracked: {provider.total_usage.total_tokens} tokens")
+
+    except Exception as e:
+        print(f"Error during invocation: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_streaming():
+    """Demonstrate streaming responses."""
+    print("\n=== Google Streaming Demo ===")
+
+    provider = GoogleProvider(model="gemini-2.5-flash")
+
+    messages = [Message.user("Write a short poem about artificial intelligence.")]
+
+    try:
+        print("Streaming response:")
+        full_content = ""
+        for chunk in provider.stream(messages):
+            if chunk.delta:
+                print(chunk.delta, end="", flush=True)
+                full_content = chunk.content
+
+        print(f"\n\nFinal content length: {len(full_content)} characters")
+        print(f"Total usage: {provider.total_usage.total_tokens} tokens")
+
+    except Exception as e:
+        print(f"Error during streaming: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_async_invocation():
+    """Demonstrate asynchronous invocation."""
+    print("\n=== Google Async Invocation Demo ===")
+
+    async def async_demo():
+        provider = GoogleProvider(model="gemini-2.5-flash")
+
+        messages = [
+            Message.system("You are a helpful assistant."),
+            Message.user(
+                "What is the difference between Gemini 2.5 Flash and Pro models?"
+            ),
+        ]
+
+        try:
+            # Asynchronously invoke the model
+            response = await provider.ainvoke(messages)
+
+            print(f"Model: {response.model}")
+            print(f"Content: {response.content}")
+            print(f"Tokens: {response.usage.total_tokens}")
+            print(f"Finish reason: {response.finish_reason}")
+
+        except Exception as e:
+            print(f"Error during async invocation: {e}")
+            print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+    asyncio.run(async_demo())
+
+
+def demo_async_streaming():
+    """Demonstrate asynchronous streaming."""
+    print("\n=== Google Async Streaming Demo ===")
+
+    async def async_stream_demo():
+        provider = GoogleProvider(model="gemini-2.5-flash")
+
+        messages = [Message.user("Explain quantum computing in simple terms.")]
+
+        try:
+            print("Async streaming response:")
+            full_content = ""
+            async for chunk in provider.astream(messages):
+                if chunk.delta:
+                    print(chunk.delta, end="", flush=True)
+                    full_content = chunk.content
+
+            print(f"\n\nFinal content length: {len(full_content)} characters")
+
+        except Exception as e:
+            print(f"Error during async streaming: {e}")
+            print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+    asyncio.run(async_stream_demo())
+
+
+def demo_configuration():
+    """Demonstrate using different configurations."""
+    print("\n=== Google Configuration Demo ===")
+
+    # Create a provider with default configuration
+    default_config = ModelConfig(
+        temperature=0.7,  # More creative
+        max_tokens=150,  # Limit response length
+        top_p=0.9,
+    )
+
+    provider = GoogleProvider(model="gemini-2.5-flash", default_config=default_config)
+
+    messages = [Message.user("Tell me a creative fact about space.")]
+
+    try:
+        # This will use the default configuration
+        response = provider.invoke(messages)
+        print(f"Using default config - Content: {response.content[:100]}...")
+        print(f"Tokens: {response.usage.total_tokens}")
+
+        # Override configuration for this specific call
+        creative_config = ModelConfig(
+            temperature=1.2,  # Even more creative/random
+            max_tokens=200,
+        )
+
+        messages = [Message.user("Generate an original haiku about technology.")]
+        response = provider.invoke(messages, config=creative_config)
+        print(f"\nUsing creative config - Content: {response.content}")
+
+    except Exception as e:
+        print(f"Error during configuration demo: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_conversation_history():
+    """Demonstrate maintaining conversation context."""
+    print("\n=== Google Conversation History Demo ===")
+
+    provider = GoogleProvider(model="gemini-2.5-flash")
+
+    # Simulate a multi-turn conversation
+    conversation = [
+        Message.system("You are a helpful coding assistant."),
+        Message.user("What is Python used for?"),
+        Message.assistant(
+            "Python is a versatile programming language used for web development, data science, AI/ML, automation, and more."
+        ),
+        Message.user("Can you give me a simple Python example?"),
+    ]
+
+    try:
+        response = provider.invoke(conversation)
+        print(f"Response to follow-up: {response.content}")
+        print(f"Tokens used: {response.usage.total_tokens}")
+
+    except Exception as e:
+        print(f"Error during conversation demo: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_list_models():
+    """Demonstrate listing available models dynamically."""
+    print("\n=== Google List Models Demo ===")
+
+    try:
+        # Get supported models without creating a provider instance
+        models = GoogleProvider.get_supported_models()
+
+        print(f"Found {len(models)} Gemini models:")
+        for model in models[:10]:  # Show first 10
+            print(f"  - {model}")
+
+        if len(models) > 10:
+            print(f"  ... and {len(models) - 10} more")
+
+    except Exception as e:
+        print(f"Error listing models: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_model_info():
+    """Demonstrate getting model information."""
+    print("\n=== Google Model Info Demo ===")
+
+    provider = GoogleProvider(model="gemini-2.5-flash")
+
+    try:
+        model_info = provider.get_model_info()
+
+        if model_info:
+            print(f"Model Name: {model_info.name}")
+            print(f"Provider: {model_info.provider}")
+            print(f"Context Window: {model_info.context_window:,} tokens")
+            print(f"Max Output Tokens: {model_info.max_output_tokens}")
+            print(f"Supports Tools: {model_info.supports_tools}")
+            print(f"Supports Streaming: {model_info.supports_streaming}")
+            print(f"Supports Vision: {model_info.supports_vision}")
+        else:
+            print("Could not retrieve model info.")
+
+    except Exception as e:
+        print(f"Error getting model info: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_token_counting():
+    """Demonstrate token counting."""
+    print("\n=== Google Token Counting Demo ===")
+
+    provider = GoogleProvider(model="gemini-2.5-flash")
+
+    try:
+        # Count tokens in a string
+        text = "Hello, how are you today? I'm looking forward to our conversation."
+        token_count = provider.count_tokens(text)
+        print(f"Text: '{text}'")
+        print(f"Token count: {token_count}")
+
+        # Count tokens in messages
+        messages = [
+            Message.system("You are a helpful assistant."),
+            Message.user("What is the meaning of life?"),
+        ]
+        msg_token_count = provider.count_tokens(messages)
+        print(f"\nMessages token count: {msg_token_count}")
+
+    except Exception as e:
+        print(f"Error counting tokens: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def demo_cost_estimation():
+    """Demonstrate cost estimation."""
+    print("\n=== Google Cost Estimation Demo ===")
+
+    provider = GoogleProvider(model="gemini-2.5-flash")
+
+    messages = [Message.user("Write a brief summary of machine learning.")]
+
+    try:
+        response = provider.invoke(messages)
+
+        print(f"Response: {response.content[:100]}...")
+        print("\nUsage:")
+        print(f"  Prompt tokens: {response.usage.prompt_tokens}")
+        print(f"  Completion tokens: {response.usage.completion_tokens}")
+        print(f"  Total tokens: {response.usage.total_tokens}")
+
+        if response.cost:
+            print("\nCost Breakdown:")
+            print(f"  Input cost: ${response.cost.input_cost:.6f}")
+            print(f"  Output cost: ${response.cost.output_cost:.6f}")
+            print(f"  Total cost: {response.cost.format()}")
+
+    except Exception as e:
+        print(f"Error during cost estimation demo: {e}")
+        print("Make sure GEMINI_API_KEY or GOOGLE_API_KEY is set.")
+
+
+def main():
+    """Run all Google provider demos."""
+    print("Kader Google Provider Examples")
+    print("=" * 40)
+
+    print("\nAPI Key Setup:")
+    print("  Add your GEMINI_API_KEY to ~/.kader/.env:")
+    print("  GEMINI_API_KEY='your-api-key-here'")
+    print("\n  Get your API key from: https://aistudio.google.com/apikey")
+
+    demo_basic_invocation()
+    demo_streaming()
+    demo_async_invocation()
+    demo_async_streaming()
+    demo_configuration()
+    demo_conversation_history()
+    demo_list_models()
+    demo_model_info()
+    demo_token_counting()
+    demo_cost_estimation()
+
+    print("\n[OK] All Google demos completed!")
+
+
+if __name__ == "__main__":
+    main()

{kader-1.0.0 → kader-1.1.0}/kader/agent/base.py

@@ -23,7 +23,9 @@ from kader.providers.base import (
     Message,
     ModelConfig,
     StreamChunk,
+    Usage,
 )
+from kader.providers.google import GoogleProvider
 from kader.providers.ollama import OllamaProvider
 from kader.tools import BaseTool, ToolRegistry
 
@@ -222,6 +224,8 @@ class BaseAgent:
             provider_type = "openai"
             if isinstance(self.provider, OllamaProvider):
                 provider_type = "ollama"
+            elif isinstance(self.provider, GoogleProvider):
+                provider_type = "google"
 
             base_config = ModelConfig(
                 temperature=base_config.temperature,
@@ -624,7 +628,12 @@ class BaseAgent:
                     )
 
                     # estimate the cost...
-                    estimated_cost = self.provider.estimate_cost(token_usage)
+                    usage_obj = Usage(
+                        prompt_tokens=token_usage["prompt_tokens"],
+                        completion_tokens=token_usage["completion_tokens"],
+                        total_tokens=token_usage["total_tokens"],
+                    )
+                    estimated_cost = self.provider.estimate_cost(usage_obj)
 
                     # Calculate and log cost
                     agent_logger.calculate_cost(
@@ -796,7 +805,12 @@ class BaseAgent:
                     )
 
                     # estimate the cost...
-                    estimated_cost = self.provider.estimate_cost(token_usage)
+                    usage_obj = Usage(
+                        prompt_tokens=token_usage["prompt_tokens"],
+                        completion_tokens=token_usage["completion_tokens"],
+                        total_tokens=token_usage["total_tokens"],
+                    )
+                    estimated_cost = self.provider.estimate_cost(usage_obj)
 
                     # Calculate and log cost
                     agent_logger.calculate_cost(

{kader-1.0.0 → kader-1.1.0}/kader/config.py

@@ -69,13 +69,21 @@ def ensure_kader_directory():
 def ensure_env_file(kader_dir):
     """
     Ensure that the .env file exists in the .kader directory with the
-    required OLLAMA_API_KEY configuration.
+    required API key configurations.
     """
     env_file = kader_dir / ".env"
 
     # Create the .env file if it doesn't exist
     if not env_file.exists():
-        env_file.write_text("OLLAMA_API_KEY=''\n", encoding="utf-8")
+        default_env_content = """# Kader Configuration
+# Ollama API Key (for local Ollama models)
+OLLAMA_API_KEY=''
+
+# Google Gemini API Key (for Google Gemini models)
+# Get your API key from: https://aistudio.google.com/apikey
+GEMINI_API_KEY=''
+"""
+        env_file.write_text(default_env_content, encoding="utf-8")
 
         # Set appropriate permissions for the .env file on Unix-like systems
         if not sys.platform.startswith("win"):