revert changes

Author: abraham2512

bugzooka/integrations/gemini_client.py

@@ -12,7 +12,6 @@
     INFERENCE_MAX_TOOL_ITERATIONS,
 )
 from bugzooka.integrations.inference import InferenceAPIUnavailableError
-from bugzooka.analysis.prompts import JIRA_TOOL_PROMPT
 
 
 logger = logging.getLogger(__name__)
@@ -45,7 +44,7 @@ def __init__(self, api_key=None, base_url=None, verify_ssl=None, timeout=None):
         # Timeout configuration
         if timeout is None:
             timeout = float(os.getenv("GEMINI_TIMEOUT", "60.0"))
-        
+
         logger.debug("Gemini client timeout set to %.1f seconds", timeout)
 
         # SSL verification configuration
@@ -80,19 +79,23 @@ def chat_completions_create(self, messages, model="gemini-2.0-flash", **kwargs):
         """
         try:
             logger.debug("Calling Gemini API: %s, Model=%s", self.base_url, model)
-            
+
             response = self.client.chat.completions.create(
                 model=model, messages=messages, **kwargs
             )
-            
+
             # Log token usage information
-            if hasattr(response, 'usage') and response.usage:
+            if hasattr(response, "usage") and response.usage:
                 usage = response.usage
-                logger.info("📊 Token usage - Prompt: %d, Completion: %d, Total: %d",
-                           usage.prompt_tokens, usage.completion_tokens, usage.total_tokens)
+                logger.info(
+                    "📊 Token usage - Prompt: %d, Completion: %d, Total: %d",
+                    usage.prompt_tokens,
+                    usage.completion_tokens,
+                    usage.total_tokens,
+                )
             else:
                 logger.debug("No usage information available in response")
-            
+
             logger.debug("Gemini API call successful")
             return response
         except Exception as e:
@@ -159,19 +162,23 @@ async def execute_tool_call(tool_name, tool_args, available_tools):
         # Log result
         result_str = str(result)
         result_length = len(result_str)
-        
+
         # Check for empty or minimal results
         if not result_str or result_str.strip() in ["", "null", "None", "{}", "[]"]:
             logger.warning("⚠️ Tool %s returned empty or null result", tool_name)
         elif len(result_str.strip()) < 50:
-            logger.warning("⚠️ Tool %s returned small result (%d chars): %s", 
-                          tool_name, result_length, result_str)
+            logger.warning(
+                "⚠️ Tool %s returned small result (%d chars): %s",
+                tool_name,
+                result_length,
+                result_str,
+            )
         else:
             logger.info("✅ Tool %s completed (%d chars)", tool_name, result_length)
-            
+
         # Log full output at DEBUG level
         logger.debug("Tool %s output: %s", tool_name, result_str)
-        
+
         return result_str
     except Exception as e:
         error_msg = f"Error executing tool '{tool_name}': {str(e)}"
@@ -182,20 +189,17 @@ async def execute_tool_call(tool_name, tool_args, available_tools):
 
 
 async def analyze_with_gemini_agentic(
-    messages: list,
-    tools=None,
-    model="gemini-2.0-flash",
-    max_iterations=None
+    messages: list, tools=None, model="gemini-2.0-flash", max_iterations=None
 ):
     """
     Generic agentic loop for Gemini with tool calling support.
-    
+
     This function implements the agentic pattern where Gemini can iteratively:
     1. Analyze the current context
     2. Decide to call tools if needed
     3. Process tool results
     4. Generate final answer
-    
+
     :param messages: List of message dictionaries (system, user, assistant prompts)
     :param tools: List of LangChain tools available for Gemini to call (optional)
     :param model: Gemini model to use (default: gemini-2.0-flash)
@@ -204,42 +208,20 @@ async def analyze_with_gemini_agentic(
     """
     if max_iterations is None:
         max_iterations = INFERENCE_MAX_TOOL_ITERATIONS
-    
+
     try:
         gemini_client = GeminiClient()
 
-        prompt_config = product_config["prompt"][product]
-
-        # Check if Jira MCP tools are available and inject Jira prompt
-        has_jira = tools and any(
-            hasattr(t, "name") and t.name == "search_jira_issues" for t in tools
-        )
-        if has_jira:
-            logger.info("Jira MCP tools detected - injecting Jira prompt")
-            system_prompt = prompt_config["system"] + JIRA_TOOL_PROMPT["system_suffix"]
-        else:
-            system_prompt = prompt_config["system"]
-
-        try:
-            formatted_content = prompt_config["user"].format(
-                error_summary=error_summary
-            )
-        except KeyError:
-            formatted_content = prompt_config["user"].format(summary=error_summary)
-
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": formatted_content},
-            {"role": "assistant", "content": prompt_config["assistant"]},
-        ]
-
         # Convert LangChain tools to OpenAI format if provided
         openai_tools = None
         if tools:
             openai_tools = convert_langchain_tools_to_openai_format(tools)
             tool_names = [t["function"]["name"] for t in openai_tools]
-            logger.info("Starting Gemini analysis with %d tools: %s",
-                       len(openai_tools), ", ".join(tool_names))
+            logger.info(
+                "Starting Gemini analysis with %d tools: %s",
+                len(openai_tools),
+                ", ".join(tool_names),
+            )
 
         logger.debug("Starting agentic loop with %d messages", len(messages))
 
@@ -273,15 +255,20 @@ async def analyze_with_gemini_agentic(
                 content = response_message.content
                 if content:
                     logger.info("Analysis complete after %d iteration(s)", iteration)
-                    logger.debug("Response: %s", content[:200] + "..." if len(content) > 200 else content)
+                    logger.debug(
+                        "Response: %s",
+                        content[:200] + "..." if len(content) > 200 else content,
+                    )
                 else:
                     logger.warning("Gemini returned None content, using empty string")
                     content = ""
                 return content
 
             # Gemini wants to call tools - execute them
             tool_names_called = [tc.function.name for tc in tool_calls]
-            logger.info("Calling %d tool(s): %s", len(tool_calls), ", ".join(tool_names_called))
+            logger.info(
+                "Calling %d tool(s): %s", len(tool_calls), ", ".join(tool_names_called)
+            )
 
             # Add the assistant's message with tool calls to conversation
             messages.append(
@@ -305,7 +292,7 @@ async def analyze_with_gemini_agentic(
             # Execute each tool call and add results to messages
             for tool_call in tool_calls:
                 function_name = tool_call.function.name
-                
+
                 try:
                     function_args = json.loads(tool_call.function.arguments)
                 except json.JSONDecodeError as e:
@@ -330,9 +317,11 @@ async def analyze_with_gemini_agentic(
             # Continue loop to let Gemini process tool results
 
         # If we hit max iterations without a final answer
-        logger.warning("Reached maximum iterations (%d) without final answer", max_iterations)
+        logger.warning(
+            "Reached maximum iterations (%d) without final answer", max_iterations
+        )
         return "Analysis incomplete: Maximum tool calling iterations reached. Please try again with a simpler query."
-        
+
     except Exception as e:
         logger.error("Error in Gemini agentic loop: %s", str(e), exc_info=True)
         raise InferenceAPIUnavailableError(
@@ -346,7 +335,7 @@ async def analyze_log_with_gemini(
     error_summary: str,
     model="gemini-2.0-flash",
     tools=None,
-    max_iterations=None
+    max_iterations=None,
 ):
     """
     Analyzes log summaries using Gemini API with product-specific prompts and optional tool calling.
@@ -361,7 +350,7 @@ async def analyze_log_with_gemini(
     """
     try:
         logger.info("Starting log analysis for product: %s", product)
-        
+
         prompt_config = product_config["prompt"][product]
         try:
             formatted_content = prompt_config["user"].format(
@@ -370,7 +359,10 @@ async def analyze_log_with_gemini(
         except KeyError:
             formatted_content = prompt_config["user"].format(summary=error_summary)
 
-        logger.debug("Error summary: %s", error_summary[:150] + "..." if len(error_summary) > 150 else error_summary)
+        logger.debug(
+            "Error summary: %s",
+            error_summary[:150] + "..." if len(error_summary) > 150 else error_summary,
+        )
 
         messages = [
             {"role": "system", "content": prompt_config["system"]},
@@ -380,10 +372,7 @@ async def analyze_log_with_gemini(
 
         # Use the generic agentic loop
         return await analyze_with_gemini_agentic(
-            messages=messages,
-            tools=tools,
-            model=model,
-            max_iterations=max_iterations
+            messages=messages, tools=tools, model=model, max_iterations=max_iterations
         )
 
     except Exception as e: