chat-console 0.2.9__py3-none-any.whl → 0.2.99__py3-none-any.whl

app/__init__.py

@@ -3,4 +3,4 @@ Chat CLI
 A command-line interface for chatting with various LLM providers like ChatGPT and Claude.
 """
 
-__version__ = "0.2.9"
+__version__ = "0.2.99"

app/api/anthropic.py

@@ -1,11 +1,20 @@
 import anthropic
+import asyncio  # Add missing import
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
 from .base import BaseModelClient
 from ..config import ANTHROPIC_API_KEY
+from ..utils import resolve_model_id  # Import the resolve_model_id function
 
 class AnthropicClient(BaseModelClient):
     def __init__(self):
-        self.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
+        self.client = None  # Initialize in create()
+
+    @classmethod
+    async def create(cls) -> 'AnthropicClient':
+        """Create a new instance with async initialization."""
+        instance = cls()
+        instance.client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
+        return instance
     
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> List[Dict[str, str]]:
         """Prepare messages for Claude API"""
@@ -47,16 +56,26 @@ class AnthropicClient(BaseModelClient):
         
         return styles.get(style, "")
     
-    async def generate_completion(self, messages: List[Dict[str, str]], 
-                           model: str, 
-                           style: Optional[str] = None, 
-                           temperature: float = 0.7, 
+    async def generate_completion(self, messages: List[Dict[str, str]],
+                           model: str,
+                           style: Optional[str] = None,
+                           temperature: float = 0.7,
                            max_tokens: Optional[int] = None) -> str:
         """Generate a text completion using Claude"""
+        try:
+            from app.main import debug_log
+        except ImportError:
+            debug_log = lambda msg: None
+            
+        # Resolve the model ID right before making the API call
+        original_model = model
+        resolved_model = resolve_model_id(model)
+        debug_log(f"Anthropic: Original model ID '{original_model}' resolved to '{resolved_model}' in generate_completion")
+        
         processed_messages = self._prepare_messages(messages, style)
         
         response = await self.client.messages.create(
-            model=model,
+            model=resolved_model,  # Use the resolved model ID
             messages=processed_messages,
             temperature=temperature,
             max_tokens=max_tokens or 1024,
@@ -64,29 +83,147 @@ class AnthropicClient(BaseModelClient):
         
         return response.content[0].text
     
-    async def generate_stream(self, messages: List[Dict[str, str]], 
-                            model: str, 
+    async def generate_stream(self, messages: List[Dict[str, str]],
+                            model: str,
                             style: Optional[str] = None,
-                            temperature: float = 0.7, 
+                            temperature: float = 0.7,
                             max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
         """Generate a streaming text completion using Claude"""
+        try:
+            from app.main import debug_log  # Import debug logging if available
+        except ImportError:
+            # If debug_log not available, create a no-op function
+            debug_log = lambda msg: None
+            
+        # Resolve the model ID right before making the API call
+        original_model = model
+        resolved_model = resolve_model_id(model)
+        debug_log(f"Anthropic: Original model ID '{original_model}' resolved to '{resolved_model}'")
+        debug_log(f"Anthropic: starting streaming generation with model: {resolved_model}")
+            
         processed_messages = self._prepare_messages(messages, style)
         
-        stream = await self.client.messages.stream(
-            model=model,
-            messages=processed_messages,
-            temperature=temperature,
-            max_tokens=max_tokens or 1024,
-        )
-        async for chunk in stream:
-            if chunk.type == "content_block":
-                yield chunk.text
-    
+        try:
+            debug_log(f"Anthropic: requesting stream with {len(processed_messages)} messages")
+            # Remove await from this line - it returns the context manager, not an awaitable
+            stream = self.client.messages.stream(
+                model=resolved_model,  # Use the resolved model ID
+                messages=processed_messages,
+                temperature=temperature,
+                max_tokens=max_tokens or 1024,
+            )
+            
+            debug_log("Anthropic: stream created successfully, processing chunks using async with")
+            async with stream as stream_context: # Use async with
+                async for chunk in stream_context: # Iterate over the context
+                    try:
+                        if chunk.type == "content_block_delta": # Check for delta type
+                            # Ensure we always return a string
+                            if chunk.delta.text is None:
+                                debug_log("Anthropic: skipping empty text delta chunk")
+                                continue
+                                
+                            text = str(chunk.delta.text) # Get text from delta
+                            debug_log(f"Anthropic: yielding chunk of length: {len(text)}")
+                            yield text
+                        else:
+                            debug_log(f"Anthropic: skipping non-content_delta chunk of type: {chunk.type}")
+                    except Exception as chunk_error: # Restore the except block for chunk processing
+                        debug_log(f"Anthropic: error processing chunk: {str(chunk_error)}")
+                        # Skip problematic chunks but continue processing
+                        continue # This continue is now correctly inside the loop and except block
+                    
+        except Exception as e:
+            debug_log(f"Anthropic: error in generate_stream: {str(e)}")
+            raise Exception(f"Anthropic streaming error: {str(e)}")
+
+    async def _fetch_models_from_api(self) -> List[Dict[str, Any]]:
+        """Fetch available models directly from the Anthropic API."""
+        try:
+            from app.main import debug_log
+        except ImportError:
+            debug_log = lambda msg: None
+
+        try:
+            debug_log("Anthropic: Fetching models from API...")
+            # The Anthropic Python SDK might not have a direct high-level method for listing models yet.
+            # We might need to use the underlying HTTP client or make a direct request.
+            # Let's assume for now the SDK client *does* have a way, like self.client.models.list()
+            # If this fails, we'd need to implement a direct HTTP GET request.
+            # response = await self.client.models.list() # Hypothetical SDK method
+
+            # --- Alternative: Direct HTTP Request using httpx (if client exposes it) ---
+            # Check if the client has an internal http_client we can use
+            if hasattr(self.client, '_client') and hasattr(self.client._client, 'get'):
+                 response = await self.client._client.get(
+                     "/v1/models",
+                     headers={"anthropic-version": "2023-06-01"} # Add required version header
+                 )
+                 response.raise_for_status() # Raise HTTP errors
+                 models_data = response.json()
+                 debug_log(f"Anthropic: API response received: {models_data}")
+                 if 'data' in models_data and isinstance(models_data['data'], list):
+                      # Format the response as expected: list of {"id": ..., "name": ...}
+                      formatted_models = [
+                          {"id": model.get("id"), "name": model.get("display_name", model.get("id"))}
+                          for model in models_data['data']
+                          if model.get("id") # Ensure model has an ID
+                      ]
+                      # Log each model ID clearly for debugging
+                      debug_log(f"Anthropic: Available models from API:")
+                      for model in formatted_models:
+                          debug_log(f"  - ID: {model.get('id')}, Name: {model.get('name')}")
+                      return formatted_models
+                 else:
+                      debug_log("Anthropic: Unexpected API response format for models.")
+                      return []
+            else:
+                 debug_log("Anthropic: Client does not expose HTTP client for model listing. Returning empty list.")
+                 return [] # Cannot fetch dynamically
+
+        except Exception as e:
+            debug_log(f"Anthropic: Failed to fetch models from API: {str(e)}")
+            # Fallback to a minimal hardcoded list in case of API error
+            # Include Claude 3.7 Sonnet with the correct full ID
+            fallback_models = [
+                {"id": "claude-3-opus-20240229", "name": "Claude 3 Opus"},
+                {"id": "claude-3-sonnet-20240229", "name": "Claude 3 Sonnet"},
+                {"id": "claude-3-haiku-20240307", "name": "Claude 3 Haiku"},
+                {"id": "claude-3-5-sonnet-20240620", "name": "Claude 3.5 Sonnet"},
+                {"id": "claude-3-7-sonnet-20250219", "name": "Claude 3.7 Sonnet"},  # Add Claude 3.7 Sonnet
+            ]
+            debug_log("Anthropic: Using fallback model list:")
+            for model in fallback_models:
+                debug_log(f"  - ID: {model['id']}, Name: {model['name']}")
+            return fallback_models
+
+    # Keep this synchronous for now, but make it call the async fetcher
+    # Note: This is slightly awkward. Ideally, config loading would be async.
+    # For now, we'll run the async fetcher within the sync method using asyncio.run()
+    # This is NOT ideal for performance but avoids larger refactoring of config loading.
     def get_available_models(self) -> List[Dict[str, Any]]:
-        """Get list of available Claude models"""
-        return [
-            {"id": "claude-3-opus", "name": "Claude 3 Opus"},
-            {"id": "claude-3-sonnet", "name": "Claude 3 Sonnet"},
-            {"id": "claude-3-haiku", "name": "Claude 3 Haiku"},
-            {"id": "claude-3.7-sonnet", "name": "Claude 3.7 Sonnet"},
-        ]
+        """Get list of available Claude models by fetching from API."""
+        try:
+            # Run the async fetcher method synchronously
+            models = asyncio.run(self._fetch_models_from_api())
+            return models
+        except RuntimeError as e:
+             # Handle cases where asyncio.run can't be called (e.g., already in an event loop)
+             # This might happen during app runtime if called again. Fallback needed.
+             try:
+                 from app.main import debug_log
+             except ImportError:
+                 debug_log = lambda msg: None
+             debug_log(f"Anthropic: Cannot run async model fetch synchronously ({e}). Falling back to hardcoded list.")
+             # Use the same fallback list as in _fetch_models_from_api
+             fallback_models = [
+                 {"id": "claude-3-opus-20240229", "name": "Claude 3 Opus"},
+                 {"id": "claude-3-sonnet-20240229", "name": "Claude 3 Sonnet"},
+                 {"id": "claude-3-haiku-20240307", "name": "Claude 3 Haiku"},
+                 {"id": "claude-3-5-sonnet-20240620", "name": "Claude 3.5 Sonnet"},
+                 {"id": "claude-3-7-sonnet-20250219", "name": "Claude 3.7 Sonnet"},  # Add Claude 3.7 Sonnet
+             ]
+             debug_log("Anthropic: Using fallback model list in get_available_models:")
+             for model in fallback_models:
+                 debug_log(f"  - ID: {model['id']}, Name: {model['name']}")
+             return fallback_models

app/api/base.py

@@ -28,7 +28,50 @@ class BaseModelClient(ABC):
         pass
     
     @staticmethod
-    def get_client_for_model(model_name: str) -> 'BaseModelClient':
+    def get_client_type_for_model(model_name: str) -> type:
+        """Get the client class for a model without instantiating it"""
+        from ..config import CONFIG, AVAILABLE_PROVIDERS
+        from .anthropic import AnthropicClient
+        from .openai import OpenAIClient
+        from .ollama import OllamaClient
+        import logging
+        
+        logger = logging.getLogger(__name__)
+        
+        # Get model info and provider
+        model_info = CONFIG["available_models"].get(model_name)
+        model_name_lower = model_name.lower()
+        
+        # If model is in config, use its provider
+        if model_info:
+            provider = model_info["provider"]
+        # For custom models, try to infer provider
+        else:
+            # First try Ollama for known model names or if selected from Ollama UI
+            if (any(name in model_name_lower for name in ["llama", "mistral", "codellama", "gemma"]) or
+                model_name in [m["id"] for m in CONFIG.get("ollama_models", [])]):
+                provider = "ollama"
+            # Then try other providers
+            elif any(name in model_name_lower for name in ["gpt", "text-", "davinci"]):
+                provider = "openai"
+            elif any(name in model_name_lower for name in ["claude", "anthropic"]):
+                provider = "anthropic"
+            else:
+                # Default to Ollama for unknown models
+                provider = "ollama"
+        
+        # Return appropriate client class
+        if provider == "ollama":
+            return OllamaClient
+        elif provider == "openai":
+            return OpenAIClient
+        elif provider == "anthropic":
+            return AnthropicClient
+        else:
+            return None
+            
+    @staticmethod
+    async def get_client_for_model(model_name: str) -> 'BaseModelClient':
         """Factory method to get appropriate client for model"""
         from ..config import CONFIG, AVAILABLE_PROVIDERS
         from .anthropic import AnthropicClient
@@ -75,7 +118,7 @@ class BaseModelClient(ABC):
         
         # Return appropriate client
         if provider == "ollama":
-            return OllamaClient()
+            return await OllamaClient.create()
         elif provider == "openai":
             return OpenAIClient()
         elif provider == "anthropic":

app/api/ollama.py

@@ -3,7 +3,6 @@ import asyncio
 import json
 import logging
 import os
-import time
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import List, Dict, Any, Optional, Generator, AsyncGenerator
@@ -15,7 +14,6 @@ logger = logging.getLogger(__name__)
 class OllamaClient(BaseModelClient):
     def __init__(self):
         from ..config import OLLAMA_BASE_URL
-        from ..utils import ensure_ollama_running
         self.base_url = OLLAMA_BASE_URL.rstrip('/')
         logger.info(f"Initializing Ollama client with base URL: {self.base_url}")
         
@@ -27,24 +25,77 @@ class OllamaClient(BaseModelClient):
         
         # Path to the cached models file
         self.models_cache_path = Path(__file__).parent.parent / "data" / "ollama-models.json"
+
+    @classmethod
+    async def create(cls) -> 'OllamaClient':
+        """Factory method to create and initialize an OllamaClient instance"""
+        from ..utils import ensure_ollama_running
+        client = cls()
         
         # Try to start Ollama if not running
-        if not ensure_ollama_running():
+        if not await ensure_ollama_running():
             raise Exception(f"Failed to start Ollama server. Please ensure Ollama is installed and try again.")
+            
+        return client
         
     def _prepare_messages(self, messages: List[Dict[str, str]], style: Optional[str] = None) -> str:
         """Convert chat messages to Ollama format"""
+        try:
+            from app.main import debug_log  # Import debug logging
+            debug_log(f"_prepare_messages called with {len(messages)} messages and style: {style}")
+        except ImportError:
+            # If debug_log not available, create a no-op function
+            debug_log = lambda msg: None
+        
         # Start with any style instructions
         formatted_messages = []
         if style and style != "default":
-            formatted_messages.append(self._get_style_instructions(style))
-            
+            style_instructions = self._get_style_instructions(style)
+            debug_log(f"Adding style instructions: {style_instructions[:50]}...")
+            formatted_messages.append(style_instructions)
+        
         # Add message content, preserving conversation flow
-        for msg in messages:
-            formatted_messages.append(msg["content"])
-            
+        for i, msg in enumerate(messages):
+            try:
+                debug_log(f"Processing message {i}: role={msg.get('role', 'unknown')}, content length={len(msg.get('content', ''))}")
+                
+                # Safely extract content with fallback
+                if "content" in msg and msg["content"] is not None:
+                    content = msg["content"]
+                    formatted_messages.append(content)
+                else:
+                    debug_log(f"Message {i} has no valid content key, using fallback")
+                    # Try to get content from alternative sources
+                    if isinstance(msg, dict):
+                        # Try to convert the whole message to string as last resort
+                        content = str(msg)
+                        debug_log(f"Using fallback content: {content[:50]}...")
+                        formatted_messages.append(content)
+                    else:
+                        debug_log(f"Message {i} is not a dict, skipping")
+                
+            except KeyError as e:
+                debug_log(f"KeyError processing message {i}: {e}, message: {msg}")
+                # Handle missing key more gracefully
+                content = msg.get('content', '')
+                if content:
+                    formatted_messages.append(content)
+                else:
+                    debug_log(f"Warning: Message {i} has no content, skipping")
+            except Exception as e:
+                debug_log(f"Error processing message {i}: {e}")
+                # Continue processing other messages
+                continue
+        
+        # Defensive check to ensure we have something to return
+        if not formatted_messages:
+            debug_log("Warning: No formatted messages were created, using fallback")
+            formatted_messages = ["Please provide some input for the model to respond to."]
+        
         # Join with double newlines for better readability
-        return "\n\n".join(formatted_messages)
+        result = "\n\n".join(formatted_messages)
+        debug_log(f"Final formatted prompt length: {len(result)}")
+        return result
     
     def _get_style_instructions(self, style: str) -> str:
         """Get formatting instructions for different styles"""
@@ -168,7 +219,49 @@ class OllamaClient(BaseModelClient):
                             max_tokens: Optional[int] = None) -> AsyncGenerator[str, None]:
         """Generate a streaming text completion using Ollama"""
         logger.info(f"Starting streaming generation with model: {model}")
-        prompt = self._prepare_messages(messages, style)
+        try:
+            from app.main import debug_log  # Import debug logging if available
+            debug_log(f"Starting streaming generation with model: {model}")
+        except ImportError:
+            # If debug_log not available, create a no-op function
+            debug_log = lambda msg: None
+            
+        debug_log(f"generate_stream called with model: {model}, {len(messages)} messages")
+        
+        # At the beginning of the method, check messages format
+        if not messages:
+            debug_log("Error: messages is empty")
+            raise ValueError("Messages list is empty")
+        
+        for i, msg in enumerate(messages):
+            try:
+                if not isinstance(msg, dict):
+                    debug_log(f"Error: message {i} is not a dict: {type(msg)}")
+                    raise ValueError(f"Message {i} is not a dictionary")
+                if 'role' not in msg:
+                    debug_log(f"Error: message {i} missing 'role' key, using default")
+                    msg['role'] = 'user'
+                if 'content' not in msg:
+                    debug_log(f"Error: message {i} missing 'content' key, using default")
+                    msg['content'] = ''
+            except Exception as e:
+                debug_log(f"Error validating message {i}: {str(e)}")
+        
+        # Now prepare the messages with our robust _prepare_messages method
+        try:
+            debug_log("Calling _prepare_messages to format prompt")
+            prompt = self._prepare_messages(messages, style)
+            debug_log(f"Prompt prepared, length: {len(prompt)}")
+        except Exception as prep_error:
+            debug_log(f"Error preparing messages: {str(prep_error)}")
+            # Create a simple fallback prompt
+            if len(messages) > 0 and isinstance(messages[-1], dict) and 'content' in messages[-1]:
+                prompt = messages[-1]['content']
+                debug_log(f"Using last message content as fallback prompt: {prompt[:100]}...")
+            else:
+                prompt = "Please respond to the user's query."
+                debug_log("Using generic fallback prompt")
+                
         retries = 2
         last_error = None
         self._active_stream_session = None  # Track the active session
@@ -179,36 +272,63 @@ class OllamaClient(BaseModelClient):
                 async with aiohttp.ClientSession() as session:
                     try:
                         logger.info("Testing model availability...")
-                        async with session.post(
-                            f"{self.base_url}/api/generate",
-                            json={
-                                "model": model,
+                        debug_log("Testing model availability...")
+                        # Build test payload with careful error handling
+                        try:
+                            test_payload = {
+                                "model": str(model) if model is not None else "gemma:2b",
+                                "prompt": "test",
+                                "temperature": float(temperature) if temperature is not None else 0.7,
+                                "stream": False
+                            }
+                            debug_log(f"Prepared test payload: {test_payload}")
+                        except Exception as payload_error:
+                            debug_log(f"Error preparing test payload: {str(payload_error)}, using defaults")
+                            test_payload = {
+                                "model": "gemma:2b",  # Safe default
                                 "prompt": "test",
-                                "temperature": temperature,
+                                "temperature": 0.7,
                                 "stream": False
-                            },
+                            }
+                            
+                        async with session.post(
+                            f"{self.base_url}/api/generate",
+                            json=test_payload,
                             timeout=2
                         ) as response:
                             if response.status != 200:
                                 logger.warning(f"Model test request failed with status {response.status}")
+                                debug_log(f"Model test request failed with status {response.status}")
                                 raise aiohttp.ClientError("Model not ready")
                     except (aiohttp.ClientError, asyncio.TimeoutError) as e:
                         logger.info(f"Model cold start detected: {str(e)}")
+                        debug_log(f"Model cold start detected: {str(e)}")
                         # Set model loading flag
                         self._model_loading = True
                         logger.info("Setting model_loading state to True")
+                        debug_log("Setting model_loading state to True")
                         
                         # Model might need loading, try pulling it
+                        # Prepare pull payload safely
+                        try:
+                            pull_payload = {"name": str(model) if model is not None else "gemma:2b"}
+                            debug_log(f"Prepared pull payload: {pull_payload}")
+                        except Exception as pull_err:
+                            debug_log(f"Error preparing pull payload: {str(pull_err)}, using default")
+                            pull_payload = {"name": "gemma:2b"}  # Safe default
+                            
                         async with session.post(
                             f"{self.base_url}/api/pull",
-                            json={"name": model},
+                            json=pull_payload,
                             timeout=60
                         ) as pull_response:
                             if pull_response.status != 200:
                                 logger.error("Failed to pull model")
+                                debug_log("Failed to pull model")
                                 self._model_loading = False  # Reset flag on failure
                                 raise Exception("Failed to pull model")
                             logger.info("Model pulled successfully")
+                            debug_log("Model pulled successfully")
                             self._model_loading = False  # Reset flag after successful pull
                 
                 # Now proceed with actual generation
@@ -217,67 +337,106 @@ class OllamaClient(BaseModelClient):
                 
                 try:
                     logger.debug(f"Sending streaming request to {self.base_url}/api/generate")
+                    debug_log(f"Sending streaming request to {self.base_url}/api/generate with model: {model}")
+                    debug_log(f"Request payload: model={model}, prompt_length={len(prompt) if prompt else 0}, temperature={temperature}")
+                    
+                    # Build request payload with careful error handling
+                    try:
+                        request_payload = {
+                            "model": str(model) if model is not None else "gemma:2b",  # Default if model is None
+                            "prompt": str(prompt) if prompt is not None else "Please respond to the user's query.",
+                            "temperature": float(temperature) if temperature is not None else 0.7,
+                            "stream": True
+                        }
+                        debug_log(f"Prepared request payload successfully")
+                    except Exception as payload_error:
+                        debug_log(f"Error preparing payload: {str(payload_error)}, using defaults")
+                        request_payload = {
+                            "model": "gemma:2b",  # Safe default
+                            "prompt": "Please respond to the user's query.",
+                            "temperature": 0.7,
+                            "stream": True
+                        }
+                    
+                    debug_log(f"Sending request to Ollama API")
                     response = await session.post(
                         f"{self.base_url}/api/generate",
-                        json={
-                            "model": model,
-                            "prompt": prompt,
-                            "temperature": temperature,
-                            "stream": True
-                        },
+                        json=request_payload,
                         timeout=60  # Longer timeout for actual generation
                     )
                     response.raise_for_status()
+                    debug_log(f"Response status: {response.status}")
                     
-                    # Process the response stream
-                    while True:
-                        if not self._active_stream_session:
-                            logger.info("Stream session was closed externally")
+                    # Use a simpler async iteration pattern that's less error-prone
+                    debug_log("Starting to process response stream")
+                    async for line in response.content:
+                        # Check cancellation periodically
+                        if self._active_stream_session is None:
+                            debug_log("Stream session closed, stopping stream processing")
                             break
                             
                         try:
-                            line = await asyncio.wait_for(response.content.readline(), timeout=0.5)
-                            if not line:  # End of stream
-                                break
-                                
-                            chunk = line.decode().strip()
-                            try:
-                                data = json.loads(chunk)
-                                if "response" in data:
-                                    yield data["response"]
-                            except json.JSONDecodeError:
+                            # Process the chunk
+                            if line:
+                                chunk = line.decode().strip()
+                                chunk_str = line.decode().strip()
+                                # Check if it looks like JSON before trying to parse
+                                if chunk_str.startswith('{') and chunk_str.endswith('}'):
+                                    try:
+                                        data = json.loads(chunk_str)
+                                        if isinstance(data, dict) and "response" in data:
+                                            chunk_length = len(data["response"]) if data["response"] else 0
+                                            debug_log(f"Yielding chunk of length: {chunk_length}")
+                                            yield data["response"]
+                                        else:
+                                            debug_log(f"JSON chunk missing 'response' key: {chunk_str}")
+                                    except json.JSONDecodeError:
+                                        debug_log(f"JSON decode error for chunk: {chunk_str}")
+                                else:
+                                    # Log unexpected non-JSON lines but don't process them
+                                    if chunk_str: # Avoid logging empty lines
+                                        debug_log(f"Received unexpected non-JSON line: {chunk_str}")
+                                # Continue processing next line regardless of parsing success/failure of current line
                                 continue
-                        except asyncio.TimeoutError:
-                            # This allows checking for cancellation regularly
+                        except Exception as chunk_err:
+                            debug_log(f"Error processing chunk: {str(chunk_err)}")
+                            # Continue instead of breaking to try processing more chunks
                             continue
-                        except asyncio.CancelledError:
-                            logger.info("Stream processing was cancelled")
-                            raise
-                            
+                    
                     logger.info("Streaming completed successfully")
+                    debug_log("Streaming completed successfully")
                     return
                 finally:
                     self._active_stream_session = None  # Clear reference when done
                     await session.close()  # Ensure session is closed
+                    debug_log("Stream session closed")
                         
             except aiohttp.ClientConnectorError:
                 last_error = "Could not connect to Ollama server. Make sure Ollama is running and accessible at " + self.base_url
+                debug_log(f"ClientConnectorError: {last_error}")
             except aiohttp.ClientResponseError as e:
                 last_error = f"Ollama API error: {e.status} - {e.message}"
+                debug_log(f"ClientResponseError: {last_error}")
             except aiohttp.ClientTimeout:
                 last_error = "Request to Ollama server timed out"
+                debug_log(f"ClientTimeout: {last_error}")
             except asyncio.CancelledError:
                 logger.info("Streaming cancelled by client")
+                debug_log("CancelledError: Streaming cancelled by client")
                 raise  # Propagate cancellation
             except Exception as e:
                 last_error = f"Error streaming completion: {str(e)}"
+                debug_log(f"General exception: {last_error}")
             
             logger.error(f"Streaming attempt failed: {last_error}")
+            debug_log(f"Streaming attempt failed: {last_error}")
             retries -= 1
             if retries >= 0:
                 logger.info(f"Retrying stream... {retries} attempts remaining")
+                debug_log(f"Retrying stream... {retries} attempts remaining")
                 await asyncio.sleep(1)
                 
+        debug_log(f"All retries failed. Last error: {last_error}")
         raise Exception(last_error)
         
     async def cancel_stream(self) -> None: