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

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")
 

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 = "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/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/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"):

kader/providers/__init__.py

@@ -1,9 +1,11 @@
 from .base import Message
+from .google import GoogleProvider
 from .mock import MockLLM
 from .ollama import OllamaProvider
 
 __all__ = [
     "Message",
     "OllamaProvider",
+    "GoogleProvider",
     "MockLLM",
 ]

kader/providers/google.py

@@ -0,0 +1,690 @@
+"""
+Google LLM Provider implementation.
+
+Provides synchronous and asynchronous access to Google Gemini models
+via the Google Gen AI SDK.
+"""
+
+import os
+from typing import AsyncIterator, Iterator
+
+from google import genai
+from google.genai import types
+
+# Import config to ensure ~/.kader/.env is loaded
+import kader.config  # noqa: F401
+
+from .base import (
+    BaseLLMProvider,
+    CostInfo,
+    LLMResponse,
+    Message,
+    ModelConfig,
+    ModelInfo,
+    ModelPricing,
+    StreamChunk,
+    Usage,
+)
+
+# Pricing data for Gemini models (per 1M tokens, in USD)
+GEMINI_PRICING: dict[str, ModelPricing] = {
+    "gemini-2.5-flash": ModelPricing(
+        input_cost_per_million=0.15,
+        output_cost_per_million=0.60,
+        cached_input_cost_per_million=0.0375,
+    ),
+    "gemini-2.5-flash-preview-05-20": ModelPricing(
+        input_cost_per_million=0.15,
+        output_cost_per_million=0.60,
+        cached_input_cost_per_million=0.0375,
+    ),
+    "gemini-2.5-pro": ModelPricing(
+        input_cost_per_million=1.25,
+        output_cost_per_million=10.00,
+        cached_input_cost_per_million=0.3125,
+    ),
+    "gemini-2.5-pro-preview-05-06": ModelPricing(
+        input_cost_per_million=1.25,
+        output_cost_per_million=10.00,
+        cached_input_cost_per_million=0.3125,
+    ),
+    "gemini-2.0-flash": ModelPricing(
+        input_cost_per_million=0.10,
+        output_cost_per_million=0.40,
+        cached_input_cost_per_million=0.025,
+    ),
+    "gemini-2.0-flash-lite": ModelPricing(
+        input_cost_per_million=0.075,
+        output_cost_per_million=0.30,
+        cached_input_cost_per_million=0.01875,
+    ),
+    "gemini-1.5-flash": ModelPricing(
+        input_cost_per_million=0.075,
+        output_cost_per_million=0.30,
+        cached_input_cost_per_million=0.01875,
+    ),
+    "gemini-1.5-pro": ModelPricing(
+        input_cost_per_million=1.25,
+        output_cost_per_million=5.00,
+        cached_input_cost_per_million=0.3125,
+    ),
+}
+
+
+class GoogleProvider(BaseLLMProvider):
+    """
+    Google LLM Provider.
+
+    Provides access to Google Gemini models with full support
+    for synchronous and asynchronous operations, including streaming.
+
+    The API key is loaded from (in order of priority):
+    1. The `api_key` parameter passed to the constructor
+    2. The GEMINI_API_KEY environment variable (loaded from ~/.kader/.env)
+    3. The GOOGLE_API_KEY environment variable
+
+    Example:
+        provider = GoogleProvider(model="gemini-2.5-flash")
+        response = provider.invoke([Message.user("Hello!")])
+        print(response.content)
+    """
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None = None,
+        default_config: ModelConfig | None = None,
+    ) -> None:
+        """
+        Initialize the Google provider.
+
+        Args:
+            model: The Gemini model identifier (e.g., "gemini-2.5-flash")
+            api_key: Optional API key. If not provided, uses GEMINI_API_KEY
+                     from ~/.kader/.env or GOOGLE_API_KEY environment variable.
+            default_config: Default configuration for all requests
+        """
+        super().__init__(model=model, default_config=default_config)
+
+        # Resolve API key: parameter > GEMINI_API_KEY > GOOGLE_API_KEY
+        if api_key is None:
+            api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get(
+                "GOOGLE_API_KEY"
+            )
+            # Filter out empty strings from the .env default
+            if api_key == "":
+                api_key = None
+
+        self._api_key = api_key
+        self._client = genai.Client(api_key=api_key) if api_key else genai.Client()
+
+    def _convert_messages(
+        self, messages: list[Message]
+    ) -> tuple[list[types.Content], str | None]:
+        """
+        Convert Message objects to Google GenAI Content format.
+
+        Returns:
+            Tuple of (contents list, system_instruction if present)
+        """
+        contents: list[types.Content] = []
+        system_instruction: str | None = None
+
+        for msg in messages:
+            if msg.role == "system":
+                # System messages are handled separately in Google's API
+                system_instruction = msg.content
+            elif msg.role == "user":
+                contents.append(
+                    types.Content(
+                        role="user",
+                        parts=[types.Part.from_text(text=msg.content)],
+                    )
+                )
+            elif msg.role == "assistant":
+                parts: list[types.Part] = []
+                if msg.content:
+                    parts.append(types.Part.from_text(text=msg.content))
+                if msg.tool_calls:
+                    for tc in msg.tool_calls:
+                        parts.append(
+                            types.Part.from_function_call(
+                                name=tc["function"]["name"],
+                                args=tc["function"]["arguments"]
+                                if isinstance(tc["function"]["arguments"], dict)
+                                else {},
+                            )
+                        )
+                contents.append(types.Content(role="model", parts=parts))
+            elif msg.role == "tool":
+                contents.append(
+                    types.Content(
+                        role="tool",
+                        parts=[
+                            types.Part.from_function_response(
+                                name=msg.name or "tool",
+                                response={"result": msg.content},
+                            )
+                        ],
+                    )
+                )
+
+        return contents, system_instruction
+
+    def _convert_config_to_generate_config(
+        self, config: ModelConfig, system_instruction: str | None = None
+    ) -> types.GenerateContentConfig:
+        """Convert ModelConfig to Google GenerateContentConfig."""
+        generate_config = types.GenerateContentConfig(
+            temperature=config.temperature if config.temperature != 1.0 else None,
+            max_output_tokens=config.max_tokens,
+            top_p=config.top_p if config.top_p != 1.0 else None,
+            top_k=config.top_k,
+            stop_sequences=config.stop_sequences,
+            system_instruction=system_instruction,
+        )
+
+        # Handle tools - convert from dict format to Google's FunctionDeclaration format
+        if config.tools:
+            google_tools = self._convert_tools_to_google_format(config.tools)
+            if google_tools:
+                generate_config.tools = google_tools
+
+        # Handle response format
+        if config.response_format:
+            resp_format_type = config.response_format.get("type")
+            if resp_format_type == "json_object":
+                generate_config.response_mime_type = "application/json"
+
+        return generate_config
+
+    def _convert_tools_to_google_format(
+        self, tools: list[dict]
+    ) -> list[types.Tool] | None:
+        """
+        Convert tool definitions from dict format to Google's Tool format.
+
+        Args:
+            tools: List of tool definitions (from to_google_format or to_openai_format)
+
+        Returns:
+            List of Google Tool objects, or None if no valid tools
+        """
+        if not tools:
+            return None
+
+        function_declarations: list[types.FunctionDeclaration] = []
+
+        for tool in tools:
+            # Handle OpenAI format (type: "function", function: {...})
+            if tool.get("type") == "function" and "function" in tool:
+                func_def = tool["function"]
+                name = func_def.get("name", "")
+                description = func_def.get("description", "")
+                parameters = func_def.get("parameters", {})
+            # Handle Google format (directly has name, description, parameters)
+            elif "name" in tool:
+                name = tool.get("name", "")
+                description = tool.get("description", "")
+                parameters = tool.get("parameters", {})
+            else:
+                continue
+
+            if not name:
+                continue
+
+            # Create FunctionDeclaration
+            try:
+                func_decl = types.FunctionDeclaration(
+                    name=name,
+                    description=description,
+                    parameters=parameters if parameters else None,
+                )
+                function_declarations.append(func_decl)
+            except Exception:
+                # Skip invalid function declarations
+                continue
+
+        if not function_declarations:
+            return None
+
+        # Wrap all function declarations in a single Tool
+        return [types.Tool(function_declarations=function_declarations)]
+
+    def _parse_response(self, response, model: str) -> LLMResponse:
+        """Parse Google GenAI response to LLMResponse."""
+        # Extract content
+        content = ""
+        tool_calls = None
+
+        if response.candidates and len(response.candidates) > 0:
+            candidate = response.candidates[0]
+            if candidate.content and candidate.content.parts:
+                text_parts = []
+                function_calls = []
+
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        text_parts.append(part.text)
+                    if hasattr(part, "function_call") and part.function_call:
+                        fc = part.function_call
+                        function_calls.append(
+                            {
+                                "id": f"call_{len(function_calls)}",
+                                "type": "function",
+                                "function": {
+                                    "name": fc.name,
+                                    "arguments": dict(fc.args) if fc.args else {},
+                                },
+                            }
+                        )
+
+                content = "".join(text_parts)
+                if function_calls:
+                    tool_calls = function_calls
+
+        # Extract usage
+        usage = Usage()
+        if hasattr(response, "usage_metadata") and response.usage_metadata:
+            usage = Usage(
+                prompt_tokens=getattr(response.usage_metadata, "prompt_token_count", 0)
+                or 0,
+                completion_tokens=getattr(
+                    response.usage_metadata, "candidates_token_count", 0
+                )
+                or 0,
+                cached_tokens=getattr(
+                    response.usage_metadata, "cached_content_token_count", 0
+                )
+                or 0,
+            )
+
+        # Determine finish reason
+        finish_reason = "stop"
+        if response.candidates and len(response.candidates) > 0:
+            candidate = response.candidates[0]
+            if hasattr(candidate, "finish_reason") and candidate.finish_reason:
+                reason = str(candidate.finish_reason).lower()
+                if "stop" in reason:
+                    finish_reason = "stop"
+                elif "length" in reason or "max_tokens" in reason:
+                    finish_reason = "length"
+                elif "tool" in reason or "function" in reason:
+                    finish_reason = "tool_calls"
+                elif "safety" in reason or "filter" in reason:
+                    finish_reason = "content_filter"
+
+        # Calculate cost
+        cost = self.estimate_cost(usage)
+
+        return LLMResponse(
+            content=content,
+            model=model,
+            usage=usage,
+            finish_reason=finish_reason,
+            cost=cost,
+            tool_calls=tool_calls,
+            raw_response=response,
+        )
+
+    def _parse_stream_chunk(
+        self, chunk, accumulated_content: str, model: str
+    ) -> StreamChunk:
+        """Parse streaming chunk to StreamChunk."""
+        delta = ""
+        tool_calls = None
+
+        if chunk.candidates and len(chunk.candidates) > 0:
+            candidate = chunk.candidates[0]
+            if candidate.content and candidate.content.parts:
+                for part in candidate.content.parts:
+                    if hasattr(part, "text") and part.text:
+                        delta = part.text
+                    if hasattr(part, "function_call") and part.function_call:
+                        fc = part.function_call
+                        tool_calls = [
+                            {
+                                "id": "call_0",
+                                "type": "function",
+                                "function": {
+                                    "name": fc.name,
+                                    "arguments": dict(fc.args) if fc.args else {},
+                                },
+                            }
+                        ]
+
+        # Extract usage from final chunk
+        usage = None
+        if hasattr(chunk, "usage_metadata") and chunk.usage_metadata:
+            usage = Usage(
+                prompt_tokens=getattr(chunk.usage_metadata, "prompt_token_count", 0)
+                or 0,
+                completion_tokens=getattr(
+                    chunk.usage_metadata, "candidates_token_count", 0
+                )
+                or 0,
+            )
+
+        # Determine finish reason
+        finish_reason = None
+        if chunk.candidates and len(chunk.candidates) > 0:
+            candidate = chunk.candidates[0]
+            if hasattr(candidate, "finish_reason") and candidate.finish_reason:
+                reason = str(candidate.finish_reason).lower()
+                if "stop" in reason:
+                    finish_reason = "stop"
+                elif "length" in reason:
+                    finish_reason = "length"
+
+        return StreamChunk(
+            content=accumulated_content + delta,
+            delta=delta,
+            finish_reason=finish_reason,
+            usage=usage,
+            tool_calls=tool_calls,
+        )
+
+    # -------------------------------------------------------------------------
+    # Synchronous Methods
+    # -------------------------------------------------------------------------
+
+    def invoke(
+        self,
+        messages: list[Message],
+        config: ModelConfig | None = None,
+    ) -> LLMResponse:
+        """
+        Synchronously invoke the Google Gemini model.
+
+        Args:
+            messages: List of messages in the conversation
+            config: Optional configuration overrides
+
+        Returns:
+            LLMResponse with the model's response
+        """
+        merged_config = self._merge_config(config)
+        contents, system_instruction = self._convert_messages(messages)
+        generate_config = self._convert_config_to_generate_config(
+            merged_config, system_instruction
+        )
+
+        response = self._client.models.generate_content(
+            model=self._model,
+            contents=contents,
+            config=generate_config,
+        )
+
+        llm_response = self._parse_response(response, self._model)
+        self._update_tracking(llm_response)
+        return llm_response
+
+    def stream(
+        self,
+        messages: list[Message],
+        config: ModelConfig | None = None,
+    ) -> Iterator[StreamChunk]:
+        """
+        Synchronously stream the Google Gemini model response.
+
+        Args:
+            messages: List of messages in the conversation
+            config: Optional configuration overrides
+
+        Yields:
+            StreamChunk objects as they arrive
+        """
+        merged_config = self._merge_config(config)
+        contents, system_instruction = self._convert_messages(messages)
+        generate_config = self._convert_config_to_generate_config(
+            merged_config, system_instruction
+        )
+
+        response_stream = self._client.models.generate_content_stream(
+            model=self._model,
+            contents=contents,
+            config=generate_config,
+        )
+
+        accumulated_content = ""
+        for chunk in response_stream:
+            stream_chunk = self._parse_stream_chunk(
+                chunk, accumulated_content, self._model
+            )
+            accumulated_content = stream_chunk.content
+            yield stream_chunk
+
+            # Update tracking on final chunk
+            if stream_chunk.is_final and stream_chunk.usage:
+                final_response = LLMResponse(
+                    content=accumulated_content,
+                    model=self._model,
+                    usage=stream_chunk.usage,
+                    finish_reason=stream_chunk.finish_reason,
+                    cost=self.estimate_cost(stream_chunk.usage),
+                )
+                self._update_tracking(final_response)
+
+    # -------------------------------------------------------------------------
+    # Asynchronous Methods
+    # -------------------------------------------------------------------------
+
+    async def ainvoke(
+        self,
+        messages: list[Message],
+        config: ModelConfig | None = None,
+    ) -> LLMResponse:
+        """
+        Asynchronously invoke the Google Gemini model.
+
+        Args:
+            messages: List of messages in the conversation
+            config: Optional configuration overrides
+
+        Returns:
+            LLMResponse with the model's response
+        """
+        merged_config = self._merge_config(config)
+        contents, system_instruction = self._convert_messages(messages)
+        generate_config = self._convert_config_to_generate_config(
+            merged_config, system_instruction
+        )
+
+        response = await self._client.aio.models.generate_content(
+            model=self._model,
+            contents=contents,
+            config=generate_config,
+        )
+
+        llm_response = self._parse_response(response, self._model)
+        self._update_tracking(llm_response)
+        return llm_response
+
+    async def astream(
+        self,
+        messages: list[Message],
+        config: ModelConfig | None = None,
+    ) -> AsyncIterator[StreamChunk]:
+        """
+        Asynchronously stream the Google Gemini model response.
+
+        Args:
+            messages: List of messages in the conversation
+            config: Optional configuration overrides
+
+        Yields:
+            StreamChunk objects as they arrive
+        """
+        merged_config = self._merge_config(config)
+        contents, system_instruction = self._convert_messages(messages)
+        generate_config = self._convert_config_to_generate_config(
+            merged_config, system_instruction
+        )
+
+        response_stream = await self._client.aio.models.generate_content_stream(
+            model=self._model,
+            contents=contents,
+            config=generate_config,
+        )
+
+        accumulated_content = ""
+        async for chunk in response_stream:
+            stream_chunk = self._parse_stream_chunk(
+                chunk, accumulated_content, self._model
+            )
+            accumulated_content = stream_chunk.content
+            yield stream_chunk
+
+            # Update tracking on final chunk
+            if stream_chunk.is_final and stream_chunk.usage:
+                final_response = LLMResponse(
+                    content=accumulated_content,
+                    model=self._model,
+                    usage=stream_chunk.usage,
+                    finish_reason=stream_chunk.finish_reason,
+                    cost=self.estimate_cost(stream_chunk.usage),
+                )
+                self._update_tracking(final_response)
+
+    # -------------------------------------------------------------------------
+    # Token & Cost Methods
+    # -------------------------------------------------------------------------
+
+    def count_tokens(
+        self,
+        text: str | list[Message],
+    ) -> int:
+        """
+        Count the number of tokens in the given text or messages.
+
+        Args:
+            text: A string or list of messages to count tokens for
+
+        Returns:
+            Number of tokens
+        """
+        try:
+            if isinstance(text, str):
+                response = self._client.models.count_tokens(
+                    model=self._model,
+                    contents=text,
+                )
+            else:
+                contents, _ = self._convert_messages(text)
+                response = self._client.models.count_tokens(
+                    model=self._model,
+                    contents=contents,
+                )
+            return getattr(response, "total_tokens", 0) or 0
+        except Exception:
+            # Fallback to character-based estimation
+            if isinstance(text, str):
+                return len(text) // 4
+            else:
+                total_chars = sum(len(msg.content) for msg in text)
+                return total_chars // 4
+
+    def estimate_cost(
+        self,
+        usage: Usage,
+    ) -> CostInfo:
+        """
+        Estimate the cost for the given token usage.
+
+        Args:
+            usage: Token usage information
+
+        Returns:
+            CostInfo with cost breakdown
+        """
+        # Try to find exact pricing, then fall back to base model name
+        pricing = GEMINI_PRICING.get(self._model)
+
+        if not pricing:
+            # Try to match by prefix (e.g., "gemini-2.5-flash-preview" -> "gemini-2.5-flash")
+            for model_prefix, model_pricing in GEMINI_PRICING.items():
+                if self._model.startswith(model_prefix):
+                    pricing = model_pricing
+                    break
+
+        if not pricing:
+            # Default to gemini-2.5-flash pricing if unknown model
+            pricing = GEMINI_PRICING.get(
+                "gemini-2.5-flash",
+                ModelPricing(
+                    input_cost_per_million=0.15,
+                    output_cost_per_million=0.60,
+                ),
+            )
+
+        return pricing.calculate_cost(usage)
+
+    # -------------------------------------------------------------------------
+    # Utility Methods
+    # -------------------------------------------------------------------------
+
+    def get_model_info(self) -> ModelInfo | None:
+        """Get information about the current model."""
+        try:
+            model_info = self._client.models.get(model=self._model)
+
+            return ModelInfo(
+                name=self._model,
+                provider="google",
+                context_window=getattr(model_info, "input_token_limit", 0) or 128000,
+                max_output_tokens=getattr(model_info, "output_token_limit", None),
+                pricing=GEMINI_PRICING.get(self._model),
+                supports_tools=True,
+                supports_streaming=True,
+                supports_json_mode=True,
+                supports_vision=True,
+                capabilities={
+                    "display_name": getattr(model_info, "display_name", None),
+                    "description": getattr(model_info, "description", None),
+                },
+            )
+        except Exception:
+            return None
+
+    @classmethod
+    def get_supported_models(cls, api_key: str | None = None) -> list[str]:
+        """
+        Get list of models available from Google.
+
+        Args:
+            api_key: Optional API key
+
+        Returns:
+            List of available model names that support generation
+        """
+        try:
+            client = genai.Client(api_key=api_key) if api_key else genai.Client()
+            models = []
+
+            for model in client.models.list():
+                model_name = getattr(model, "name", "")
+                # Filter to only include gemini models that support generateContent
+                if model_name and "gemini" in model_name.lower():
+                    supported_methods = getattr(
+                        model, "supported_generation_methods", []
+                    )
+                    if supported_methods is None:
+                        supported_methods = []
+                    # Include models that support content generation
+                    if (
+                        any("generateContent" in method for method in supported_methods)
+                        or not supported_methods
+                    ):
+                        # Extract just the model ID from full path
+                        # e.g., "models/gemini-2.5-flash" -> "gemini-2.5-flash"
+                        if "/" in model_name:
+                            model_name = model_name.split("/")[-1]
+                        models.append(model_name)
+
+            return models
+        except Exception:
+            return []
+
+    def list_models(self) -> list[str]:
+        """List all available Gemini models."""
+        return self.get_supported_models(self._api_key)

{kader-1.0.0.dist-info → kader-1.1.0.dist-info}/METADATA

@@ -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.dist-info → kader-1.1.0.dist-info}/RECORD

@@ -1,18 +1,19 @@
 cli/README.md,sha256=DY3X7w6LPka1GzhtTrGwhpkFmx0YyRpcTCHjFmti3Yg,4654
 cli/__init__.py,sha256=OAi_KSwcuYXR0sRxKuw1DYQrz1jbu8p7vn41_99f36I,107
 cli/__main__.py,sha256=xO2JVjCsh691b-cjSBAEKocJeUeI3P0gfUqM-f1Mp1A,95
-cli/app.py,sha256=NY1o6mfbgw9syDnJJkvlymmcrQ9JTeA9_19V4kklTQI,28059
+cli/app.py,sha256=3JwSr4224k2g7DUrWN3IGkCbzNzYDJdKBoIOfUCDeJM,28313
 cli/app.tcss,sha256=szNaXxCEo0QfFyM1klPB21GzNaXV3wCxTbDm9e71ioA,4488
-cli/utils.py,sha256=V382xxqLQYaPw_o5E-W30n2uOaWovLTb07aywdbqlMw,1722
+cli/llm_factory.py,sha256=wXZtCgf2yBeYYKBwbR2WqSbiYxB_26bTMOqcKlbOACE,5214
+cli/utils.py,sha256=y4unmXrANLk-tTEumotq0wp-sreBlLVYKRxz4BMyWVM,2178
 cli/widgets/__init__.py,sha256=1vj31CrJyxZROLthkKr79i_GbNyj8g3q60ZQPbJHK5k,300
 cli/widgets/confirmation.py,sha256=7hXqGyhW5V9fmtjgiWR4z2fJWmKxWhUH9RigqDrTKp4,9396
 cli/widgets/conversation.py,sha256=n99b9wjgrw4WTbWX4entK2Jx4xcP-n-F0KPJXC4w2oM,2720
 cli/widgets/loading.py,sha256=wlhQ47ppSj8vCEqjrbG2mk1yKnfo8dWC5429Z2q1-0g,1689
 kader/__init__.py,sha256=lv08nSC3h5YLdBU4WqXMz2YHHojy7mcBPMbfP251Rjo,654
-kader/config.py,sha256=B1s1PNgZ5SrFEJU5TtJG-ZAc7Umff4cwyHR7mfQgeLA,4261
+kader/config.py,sha256=ra0VAUnbuo4rvIuMIqq3G9Kg5YYpzrc1Wp9bBMED9vo,4503
 kader/agent/__init__.py,sha256=UJzUw9NIzggCrhIBHC6nJnfzkhCjCZnIzmD6uUn2SNA,159
 kader/agent/agents.py,sha256=qG594bZ71tbTshwhSrbKOIpkSz1y3FjcLztxPKJRrfE,4837
-kader/agent/base.py,sha256=Ql9QcvJjFgf0CtZF2c249r12zRmXhTFnYLW_GW-aRGk,39463
+kader/agent/base.py,sha256=uqLv4WEzEw9Nga9e_B4i2oriu9S3XquI4GfOPIKEaVI,40163
 kader/agent/logger.py,sha256=3vFwz_yycSBU-5mcdalfZ3KBVT9P_20Q-WT5Al8yIXo,5796
 kader/memory/__init__.py,sha256=VUzzhGOWvO_2aYB6uuavmtNI8l94K7H3uPn4_1MVUUs,1473
 kader/memory/conversation.py,sha256=h6Bamd8_rYnk0Bwt4MJWZRfv2wxCcg6eUxPvzP-tIyA,11810
@@ -26,8 +27,9 @@ kader/prompts/templates/executor_agent.j2,sha256=YtKH2LBbY4FrGxam-3Q0YPnnNnLxcV_
 kader/prompts/templates/kader_planner.j2,sha256=ONpeuu6OvNuxv8d6zrjYSF1QFPoIDFBCqe7P0RmcD-I,3429
 kader/prompts/templates/planning_agent.j2,sha256=Uc4SnMPv4vKWchhO0RLRNjbEio5CVlRgqDJG_dgM2Pk,1315
 kader/prompts/templates/react_agent.j2,sha256=yME6Qgj2WTW8jRZ_yuQcY6xlXKcV7YUv5sz5ZfCl8P4,606
-kader/providers/__init__.py,sha256=DYEZakt2SRy0Xd2vem93V_TRlY2s19KaJC9bSaOB1WY,154
+kader/providers/__init__.py,sha256=6vZvD0nPIMblZWddn7hZjO6a0VlL5ZKBDuLn7OE_0_w,211
 kader/providers/base.py,sha256=gxpomjRAX9q3Qf4GHYxdiGI_GsRW9BG7PM38SKUAeCk,17105
+kader/providers/google.py,sha256=UaTl2jodVNcsJ7SwARjIf6Q4XGtqA_h_g7cfx903xZE,24724
 kader/providers/mock.py,sha256=VBuOFFPvDWn4QVFS9HXlwu3jswP0NNNxrMyL4Qgvm50,2723
 kader/providers/ollama.py,sha256=R5F0zlmbGGwSxNVURU0dWa-gMG_V-CmVZdRvy_GMmuw,15577
 kader/tools/README.md,sha256=lmw-Ghm8ie2pNcSTL4sJ7OKerkGvbXmlD9Zi87hiC-8,14347
@@ -48,7 +50,7 @@ kader/utils/context_aggregator.py,sha256=5_2suuWSsJZhJ60zWTIkiEx5R5EIIdXak7MU98z
 kader/workflows/__init__.py,sha256=qaarPRT7xcY86dHmAUM6IQpLedKKBayFiASZr8-dSSA,297
 kader/workflows/base.py,sha256=BCTMMWE-LW_qIU7TWZgTzu82EMem6Uy2hJv0sa7buc0,1892
 kader/workflows/planner_executor.py,sha256=VK4bCGvoUJ0eezNmkVb-iPjis1HsZFjlAUTtmluF9zw,9392
-kader-1.0.0.dist-info/METADATA,sha256=nwJMl3g7VMF6OCcMfX-3zhGRmaqwqqY1nbwMRzzQf5w,10932
-kader-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kader-1.0.0.dist-info/entry_points.txt,sha256=TK0VOtrfDFqZ8JQfxpuAHHvDLHyoiafUjS-VOixl02c,39
-kader-1.0.0.dist-info/RECORD,,
+kader-1.1.0.dist-info/METADATA,sha256=BI_L65fwCoPTFwx7Un9P2B804lYc3TVcjOGx_jwIys4,10968
+kader-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kader-1.1.0.dist-info/entry_points.txt,sha256=TK0VOtrfDFqZ8JQfxpuAHHvDLHyoiafUjS-VOixl02c,39
+kader-1.1.0.dist-info/RECORD,,