ziya 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

app/utils/code_util.py

@@ -3,8 +3,11 @@ Legacy module for backward compatibility.
 This module re-exports all functionality from the diff_utils package.
 """
 
-# Re-export everything from diff_utils
-from app.utils.diff_utils import *
+from typing import List, Dict, Any, Optional
+from app.utils.diff_utils.pipeline import apply_diff_pipeline
+from app.utils.diff_utils.application.git_diff import use_git_to_apply_code_diff
+from app.utils.diff_utils.parsing.diff_parser import parse_unified_diff
+# Import only what's needed, not everything
 
 # For backward compatibility
 from app.utils.diff_utils.core.exceptions import PatchApplicationError

app/utils/context_cache.py

@@ -44,6 +44,8 @@ class ContextCacheManager:
     def __init__(self):
         self.cache_store: Dict[str, CachedContext] = {}
         self.default_ttl = 3600  # 1 hour default TTL
+        self.max_cache_entries = 1000  # Prevent unbounded growth
+        self.max_cache_memory_mb = 500  # Memory limit
         self.min_cache_size = 10000  # Minimum tokens to cache
         self.file_state_manager = FileStateManager()
         self.cache_stats = {"hits": 0, "misses": 0, "splits": 0, "tokens_cached": 0}
@@ -316,6 +318,15 @@ class ContextCacheManager:
         )
         
         self.cache_store[cache_key] = cached_context
+        
+        # Enforce cache limits
+        if len(self.cache_store) > self.max_cache_entries:
+            # Remove oldest entries
+            oldest_keys = sorted(self.cache_store.keys(), 
+                               key=lambda k: self.cache_store[k].created_at)[:100]
+            for key in oldest_keys:
+                del self.cache_store[key]
+        
         logger.info(f"Cached context for conversation {conversation_id}: {token_count} tokens, TTL {ttl_seconds}s")
         
         return cached_context

app/utils/conversation_filter.py

@@ -0,0 +1,90 @@
+"""
+Conversation filtering utilities to prevent tool result contamination.
+
+This module ensures that frontend display artifacts never reach the model,
+preventing the model from learning to hallucinate fake tool results.
+"""
+
+from typing import List, Dict, Any, Union
+from app.utils.logging_utils import logger
+
+
+def filter_conversation_for_model(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Filter out frontend-only messages that should never reach the model.
+    
+    This prevents tool result contamination by excluding:
+    - tool_execution (old contaminating format)
+    - tool_display (new frontend-only format)
+    - tool_start (frontend progress indicators)
+    
+    Args:
+        messages: Raw conversation including frontend artifacts
+        
+    Returns:
+        Clean conversation suitable for model consumption
+    """
+    filtered = []
+    filtered_count = 0
+    
+    for msg in messages:
+        if isinstance(msg, dict):
+            msg_type = msg.get('type')
+            
+            # Skip all frontend display messages
+            if msg_type in ['tool_execution', 'tool_display', 'tool_start']:
+                filtered_count += 1
+                logger.debug(f"Filtered out frontend artifact: {msg_type}")
+                continue
+                
+            # Convert clean tool results for model
+            elif msg_type == 'tool_result_for_model':
+                filtered.append({
+                    'role': 'user',
+                    'content': [
+                        {
+                            'type': 'tool_result',
+                            'tool_use_id': msg.get('tool_use_id'),
+                            'content': msg.get('content', '')
+                        }
+                    ]
+                })
+                logger.debug(f"Converted tool result for model: {msg.get('tool_use_id')}")
+                
+            else:
+                # Include regular conversation messages
+                filtered.append(msg)
+        else:
+            # Include non-dict messages as-is
+            filtered.append(msg)
+    
+    if filtered_count > 0:
+        logger.info(f"Filtered {filtered_count} frontend artifacts from conversation")
+    
+    return filtered
+
+
+def is_contaminating_message(msg: Union[Dict[str, Any], Any]) -> bool:
+    """
+    Check if a message would contaminate the model's understanding.
+    
+    Args:
+        msg: Message to check
+        
+    Returns:
+        True if message should be filtered out
+    """
+    if not isinstance(msg, dict):
+        return False
+        
+    msg_type = msg.get('type')
+    contaminating_types = [
+        'tool_execution',      # Old contaminating format
+        'tool_display',        # New frontend-only format  
+        'tool_start',          # Progress indicators
+        'tool_progress',       # Progress updates
+        'stream_end',          # Stream control
+        'error'                # Error displays
+    ]
+    
+    return msg_type in contaminating_types

app/utils/custom_bedrock.py

@@ -49,6 +49,7 @@ class CustomBedrockClient:
         self.last_extended_context_notification = None
         self.model_config = model_config or {}
         self.extended_context_manager = get_extended_context_manager()
+        self.throttled = False  # Track if we've hit throttling
         
         # Get the region from the client
         self.region = self.client.meta.region_name if hasattr(self.client, 'meta') else None
@@ -219,9 +220,50 @@ class CustomBedrockClient:
                     except Exception as e:
                         error_message = str(e)
                         self.last_error = error_message
+                        logger.warning(f"🔄 INITIAL_ERROR: {error_message}")
+                        
+                        # Check for throttling errors - let higher level retry handle it
+                        # But keep timeout retries here since they need immediate retry
+                        if ("ThrottlingException" in error_message or 
+                            "Too many tokens" in error_message or
+                            "rate limit" in error_message.lower()):
+                            # Mark as throttled and recreate client without boto3 retries
+                            if not self.throttled:
+                                self.throttled = True
+                                logger.info("🔄 THROTTLE_DETECTED: Disabling boto3 retries for subsequent attempts")
+                                from botocore.config import Config
+                                import boto3
+                                retry_config = Config(retries={'max_attempts': 1, 'mode': 'standard'})
+                                new_client = boto3.client('bedrock-runtime', region_name=self.region, config=retry_config)
+                                self.client = new_client
+                                self.original_invoke = new_client.invoke_model_with_response_stream
+                                if hasattr(new_client, 'invoke_model'):
+                                    self.original_invoke_model = new_client.invoke_model
+                            # Don't retry here, let streaming_tool_executor handle throttling retries
+                            raise
+                        
+                        if "timeout" in error_message.lower():
+                            # Retry timeouts immediately with short delays
+                            max_retries = 2
+                            for retry_attempt in range(max_retries):
+                                delays = [1, 2]
+                                delay = delays[retry_attempt]
+                                logger.warning(f"🔄 TIMEOUT_RETRY: Attempt {retry_attempt + 1}/{max_retries} after {delay}s delay")
+                                
+                                import time
+                                time.sleep(delay)
+                                
+                                try:
+                                    return self.original_invoke(**kwargs)
+                                except Exception as retry_error:
+                                    if retry_attempt == max_retries - 1:
+                                        logger.error(f"🔄 TIMEOUT_RETRY: All {max_retries} retry attempts failed")
+                                        raise retry_error
+                                    elif "timeout" not in str(retry_error).lower():
+                                        raise retry_error
                         
                         # Check if it's a context limit error
-                        if ("input length and `max_tokens` exceed context limit" in error_message or
+                        elif ("input length and `max_tokens` exceed context limit" in error_message or
                             "Input is too long" in error_message):
                             logger.warning(f"Context limit error detected: {error_message}")
                             

app/utils/diff_utils/validation/validators.py

@@ -291,9 +291,9 @@ def is_hunk_already_applied(file_lines: List[str], hunk: Dict[str, Any], pos: in
     if not removed_lines and not added_lines:
         return True
     
-    # For pure additions, check if content already exists in file
+    # For pure additions, check if content already exists at the expected position
     if len(removed_lines) == 0 and len(added_lines) > 0:
-        return _check_pure_addition_already_applied(file_lines, added_lines)
+        return _check_pure_addition_already_applied(file_lines, added_lines, hunk, pos)
     
     # CRITICAL: For hunks with removals, validate that the content to be removed matches
     # If removal validation fails, the hunk cannot be already applied
@@ -314,38 +314,48 @@ def _is_valid_hunk_header(hunk: Dict[str, Any]) -> bool:
     return True
 
 
-def _check_pure_addition_already_applied(file_lines: List[str], added_lines: List[str]) -> bool:
-    """Check if a pure addition (no removals) is already applied."""
+def _check_pure_addition_already_applied(file_lines: List[str], added_lines: List[str], hunk: Dict[str, Any], pos: int) -> bool:
+    """Check if a pure addition (no removals) is already applied with context validation."""
     
     logger.debug(f"Checking pure addition - added_lines: {added_lines}")
     
-    # Check if the added lines exist as a contiguous block anywhere in the file
-    # This is more precise than checking individual lines scattered throughout
     if not added_lines:
         return True
     
-    # CRITICAL FIX: For very common patterns like closing braces, be more conservative
-    # Don't mark as already applied if the added content consists only of common syntax elements
-    normalized_added = [normalize_line_for_comparison(line).strip() for line in added_lines]
+    # Get context lines from the hunk
+    hunk_lines = hunk.get('lines', [])
+    context_lines = [line[1:] for line in hunk_lines if line.startswith(' ')]
     
-    # Check if all added lines are just common syntax elements (braces, semicolons, etc.)
-    common_syntax_patterns = {'}', '};', '{', ')', '(', ']', '[', ',', ';'}
-    if all(line in common_syntax_patterns for line in normalized_added):
-        logger.debug("Added lines contain only common syntax elements, being conservative")
+    if not context_lines:
+        logger.debug("No context lines in hunk - cannot validate if pure addition is already applied")
         return False
     
     added_block = [normalize_line_for_comparison(line) for line in added_lines]
-    
-    # Look for the exact sequence of added lines in the file
-    for start_pos in range(len(file_lines) - len(added_lines) + 1):
-        file_block = [normalize_line_for_comparison(file_lines[start_pos + i]) 
-                     for i in range(len(added_lines))]
+    context_normalized = [normalize_line_for_comparison(line) for line in context_lines]
+    first_context_line = context_normalized[0]
+    
+    # Search for context lines in the file, then check if added lines follow
+    for context_pos in range(len(file_lines) - len(context_lines) + 1):
+        # Quick check: skip if first context line doesn't match
+        if normalize_line_for_comparison(file_lines[context_pos]) != first_context_line:
+            continue
+            
+        file_context = [normalize_line_for_comparison(file_lines[context_pos + i]) 
+                       for i in range(len(context_lines))]
         
-        if file_block == added_block:
-            logger.debug(f"Found contiguous block of added lines at position {start_pos}")
-            return True
+        if file_context == context_normalized:
+            # Found matching context, check if added lines are right after
+            check_pos = context_pos + len(context_lines)
+            
+            if check_pos + len(added_lines) <= len(file_lines):
+                file_block = [normalize_line_for_comparison(file_lines[check_pos + i]) 
+                             for i in range(len(added_lines))]
+                
+                if file_block == added_block:
+                    logger.debug(f"Found added lines at position {check_pos} with matching context at {context_pos}")
+                    return True
     
-    logger.debug("Added lines not found as contiguous block in file")
+    logger.debug("Added lines not found at expected position after context")
     return False
 
 

app/utils/file_cache.py

@@ -22,9 +22,11 @@ class ThreadStateManager:
     def __new__(cls):
         with cls._lock:
             if cls._instance is None:
-                instance = super().__new__(cls)
-                instance.thread_states = {}
-                cls._instance = instance
+                cls._instance = super().__new__(cls)
+                cls._instance.thread_states = {}
+                cls._instance._initialized = True
+            elif not hasattr(cls._instance, '_initialized'):
+                cls._instance.thread_states = {}
         return cls._instance
 
 

app/utils/precision_prompt_system.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Precision prompt system that achieves 100% equivalence with original Ziya prompts.
+"""
+
+import os
+import sys
+from typing import Dict, List, Any
+
+class PrecisionPromptSystem:
+    """
+    Production-ready system that achieves 100% equivalence with the original Ziya prompts
+    while eliminating the file loss issue caused by regex stripping.
+    """
+    
+    def build_messages(self,
+                      request_path: str,
+                      model_info: Dict[str, Any],
+                      files: List[str],
+                      question: str,
+                      chat_history: List[Dict[str, Any]] = None) -> List:
+        """
+        Drop-in replacement for the original build_messages function.
+        
+        Achieves 100% equivalence with original Ziya prompts while preserving all files.
+        No regex stripping needed - clean templates prevent contamination.
+        """
+        
+        if chat_history is None:
+            chat_history = []
+        
+        try:
+            # Use extended prompt system with native tools context
+            from app.agents.prompts_manager import get_extended_prompt
+            from app.agents.agent import extract_codebase
+            
+            print(f"🎯 PRECISION_DEBUG: Calling extract_codebase with {len(files)} files")
+            file_context = extract_codebase({
+                "config": {"files": files},
+                "conversation_id": f"precision_{hash(str(files))}"
+            })
+            
+            print(f"🎯 PRECISION_DEBUG: Got file_context length: {len(file_context) if file_context else 0}")
+            
+            # Build context with native_tools_available for Bedrock
+            context = {
+                "model_id": model_info.get("model_id", ""),
+                "endpoint": model_info.get("endpoint", "bedrock"),
+                "native_tools_available": model_info.get("endpoint", "bedrock") == "bedrock"
+            }
+            
+            # Get extended prompt with proper context
+            extended_prompt = get_extended_prompt(
+                model_name=model_info.get("model_name", "sonnet4.0"),
+                model_family=model_info.get("model_family", "claude"),
+                endpoint=model_info.get("endpoint", "bedrock"),
+                context=context
+            )
+            
+            # Format the prompt with file context
+            formatted_messages = extended_prompt.format_messages(
+                codebase=file_context,
+                tools="",  # Tools are handled natively
+                question=question
+            )
+            
+            # Convert to dict format
+            messages = []
+            for msg in formatted_messages:
+                if hasattr(msg, 'type') and hasattr(msg, 'content'):
+                    role = 'system' if msg.type == 'system' else ('user' if msg.type == 'human' else 'assistant')
+                    messages.append({"role": role, "content": msg.content})
+            
+            # Add chat history before the question
+            if chat_history:
+                # Insert chat history before the last message (the question)
+                question_msg = messages.pop() if messages else None
+                for msg in chat_history:
+                    if isinstance(msg, dict):
+                        if 'type' in msg:
+                            role = 'user' if msg['type'] in ['human', 'user'] else 'assistant'
+                            messages.append({"role": role, "content": msg.get('content', '')})
+                        elif 'role' in msg:
+                            messages.append(msg)
+                if question_msg:
+                    messages.append(question_msg)
+            
+            print(f"🎯 PRECISION_DEBUG: Generated {len(messages)} messages")
+            
+            return messages
+            
+        except Exception as e:
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Error in precision system: {e}")
+            # Fallback to minimal system
+            return self._fallback_build_messages(question, chat_history)
+    
+    def _fallback_build_messages(self, question, chat_history):
+        """Fallback to minimal system if needed"""
+        messages = [
+            {"role": "system", "content": "You are an excellent coder. Help the user with their coding tasks."}
+        ]
+        
+        # Add chat history
+        for msg in chat_history:
+            messages.append(msg)
+        
+        # Add current question
+        if question:
+            messages.append({"role": "user", "content": question})
+        
+        return messages
+
+# Global instance
+precision_system = PrecisionPromptSystem()

app/utils/streaming_optimizer.py

@@ -0,0 +1,100 @@
+"""
+Streaming Response Optimizer
+Fixes chunking issues identified in streaming analysis
+"""
+
+import re
+import time
+from typing import Generator, Optional
+
+class StreamingContentOptimizer:
+    """Optimizes content streaming to prevent mid-word splits"""
+    
+    def __init__(self, min_chunk_size: int = 15, max_buffer_size: int = 100):
+        self.buffer = ""
+        self.min_chunk_size = min_chunk_size
+        self.max_buffer_size = max_buffer_size
+        self.word_boundary = re.compile(r'(\s+)')
+        
+    def add_content(self, content: str) -> Generator[str, None, None]:
+        """Add content and yield optimized chunks"""
+        self.buffer += content
+        
+        # Force flush if buffer gets too large
+        if len(self.buffer) > self.max_buffer_size:
+            yield from self._flush_complete_words()
+            
+        # Check if we have enough content to send
+        elif len(self.buffer) >= self.min_chunk_size:
+            yield from self._flush_complete_words()
+    
+    def _flush_complete_words(self) -> Generator[str, None, None]:
+        """Flush complete words from buffer"""
+        if not self.buffer.strip():
+            return
+            
+        # Split on word boundaries but keep delimiters
+        parts = self.word_boundary.split(self.buffer)
+        
+        if len(parts) > 2:  # We have at least one complete word
+            # Send all but the last part (which might be incomplete)
+            complete_parts = parts[:-1]
+            chunk_to_send = ''.join(complete_parts)
+            
+            if chunk_to_send.strip():
+                yield chunk_to_send
+                self.buffer = parts[-1]  # Keep the last part
+        
+    def flush_remaining(self) -> Optional[str]:
+        """Flush any remaining content"""
+        if self.buffer.strip():
+            content = self.buffer
+            self.buffer = ""
+            return content
+        return None
+
+    def is_in_code_block(self, accumulated_text: str) -> tuple[bool, str]:
+        """
+        Check if the accumulated text ends in the middle of a code block.
+        
+        Returns:
+            (is_in_block, block_type): True if in block, with block type
+        """
+        lines = accumulated_text.split('\n')
+        open_blocks = []
+        
+        for line in lines:
+            stripped = line.strip()
+            if stripped.startswith('```'):
+                if stripped == '```':
+                    # Closing block
+                    if open_blocks:
+                        open_blocks.pop()
+                else:
+                    # Opening block
+                    block_type = stripped[3:].strip() or 'text'
+                    open_blocks.append(block_type)
+        
+        if open_blocks:
+            return True, open_blocks[-1]  # Return the most recent open block type
+        return False, None
+    
+    def count_code_block_markers(self, text: str) -> int:
+        """Count the number of ``` markers in text."""
+        return text.count('```')
+    
+    def has_incomplete_code_block(self, text: str) -> bool:
+        """Check if text has an odd number of code block markers (incomplete)."""
+        return self.count_code_block_markers(text) % 2 == 1
+def optimize_streaming_chunk(content: str, optimizer: StreamingContentOptimizer) -> Generator[dict, None, None]:
+    """
+    Optimize a streaming content chunk to prevent mid-word splits
+    """
+    chunks = list(optimizer.add_content(content))
+    
+    for chunk in chunks:
+        yield {
+            'type': 'text',
+            'content': chunk,
+            'timestamp': f"{int(time.time() * 1000)}ms"
+        }

{ziya-0.3.0.dist-info → ziya-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ziya
-Version: 0.3.0
+Version: 0.3.2
 Summary: 
 License-File: LICENSE
 Author: Vishnu Krishnaprasad
@@ -17,6 +17,7 @@ Requires-Dist: PyPDF2 (>=3.0.1,<4.0.0)
 Requires-Dist: boto3 (>=1.34.88,<2.0.0)
 Requires-Dist: cryptography (>=3.4.8,<43.0.0)
 Requires-Dist: cssutils (>=2.6.0)
+Requires-Dist: google-generativeai (>=0.8.5)
 Requires-Dist: html5lib (>=1.1)
 Requires-Dist: jinja2 (>=3.1.3,<4.0.0)
 Requires-Dist: langchain (>=0.3,<0.4)
@@ -24,7 +25,7 @@ Requires-Dist: langchain-anthropic (>=0.2,<0.3)
 Requires-Dist: langchain-aws (>=0.2,<0.3)
 Requires-Dist: langchain-cli (>=0.0.15)
 Requires-Dist: langchain-community (>=0.3.1,<0.4.0)
-Requires-Dist: langchain-google-genai (>=2.1.0,<3.0.0)
+Requires-Dist: langchain-google-genai (==2.0.4)
 Requires-Dist: langchainhub (>=0.1.15)
 Requires-Dist: langgraph (>=0.2,<0.3)
 Requires-Dist: numpy (>=1.21.0,<2.0.0)