modified functions

application/agents/scraper_agent.py

@@ -42,57 +42,42 @@ model_with_tools = model.bind_tools(tools)
 def invoke_model(state: AgentState) -> dict:
     """Invokes the LLM with the current conversation history."""
     logger.info("--- Invoking Model ---")
-    # LangGraph automatically passes the entire state
-    # The model_with_tools expects a list of BaseMessages
     response = model_with_tools.invoke(state['messages'])
-    # logger.info(f"Model response: {response}")
-    # We return a dictionary with the key corresponding to the state field name
-    return {"messages": [response]} # The response is already an AIMessage
+    return {"messages": [response]}
 
 def invoke_tools(state: AgentState) -> dict:
     """Invokes the necessary tools based on the last AI message."""
     logger.info("--- Invoking Tools ---")
-    # The state contains the history, the last message is the AI's request
     last_message = state['messages'][-1]
 
-    # Check if the last message is an AIMessage with tool_calls
     if not hasattr(last_message, 'tool_calls') or not last_message.tool_calls:
          logger.info("No tool calls found in the last message.")
-         # This scenario might indicate the conversation should end or requires clarification
-         # For now, return an empty dict, which won't update the state significantly.
-         # Consider adding a message indicating no tools were called if needed.
          return {}
-         # Alternative: return {"messages": [SystemMessage(content="No tool calls requested.")]}
 
     tool_invocation_messages = []
 
-    # Find the tool object by name
     tool_map = {tool.name: tool for tool in tools}
 
     for tool_call in last_message.tool_calls:
         tool_name = tool_call['name']
         tool_args = tool_call['args']
-        tool_call_id = tool_call['id'] # Crucial for linking the result
+        tool_call_id = tool_call['id'] 
 
         logger.info(f"Executing tool: {tool_name} with args: {tool_args}")
 
         if tool_name in tool_map:
             selected_tool = tool_map[tool_name]
             try:
-                # Use the tool's invoke method, passing the arguments dictionary
                 result = selected_tool.invoke(tool_args)
 
-                # IMPORTANT: Convert the result to a string or a JSON serializable format
-                # if it's a complex object. ToolMessage content should be simple.
-                # Adjust this based on what your tools actually return.
                 if isinstance(result, list) or isinstance(result, dict):
-                    result_content = json.dumps(result) # Convert dict/list to JSON string
-                elif hasattr(result, 'companies') and isinstance(result.companies, list): # Handle CompanyListResponse example
+                    result_content = json.dumps(result) 
+                elif hasattr(result, 'companies') and isinstance(result.companies, list):
                      result_content = f"Companies found: {', '.join(result.companies)}"
                 elif result is None:
                     result_content = "Tool executed successfully, but returned no specific data (None)."
                 else:
-                    result_content = str(result) # Default to string conversion
+                    result_content = str(result) 
 
                 logger.info(f"Tool {tool_name} result: {result_content}")
                 tool_invocation_messages.append(
@@ -100,7 +85,6 @@ def invoke_tools(state: AgentState) -> dict:
                 )
             except Exception as e:
                 logger.error(f"Error executing tool {tool_name}: {e}")
-                # Return an error message in the ToolMessage
                 tool_invocation_messages.append(
                     ToolMessage(content=f"Error executing tool {tool_name}: {str(e)}", tool_call_id=tool_call_id)
                 )
@@ -110,29 +94,22 @@ def invoke_tools(state: AgentState) -> dict:
                 ToolMessage(content=f"Error: Tool '{tool_name}' not found.", tool_call_id=tool_call_id)
             )
 
-    # Return the collected ToolMessages to be added to the state
     return {"messages": tool_invocation_messages}
 
-# --- Graph Definition ---
 graph_builder = StateGraph(AgentState)
 
-# Add nodes
 graph_builder.add_node("scraper_agent", invoke_model)
-graph_builder.add_node("tools", invoke_tools) # Renamed for clarity
+graph_builder.add_node("tools", invoke_tools)
 
-# Define edges
 graph_builder.set_entry_point("scraper_agent")
 
-# Conditional edge: After the agent runs, decide whether to call tools or end.
 def router(state: AgentState) -> str:
     """Determines the next step based on the last message."""
     last_message = state['messages'][-1]
     if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
-        # If the AI message has tool calls, invoke the tools node
         logger.info("--- Routing to Tools ---")
         return "tools"
     else:
-        # Otherwise, the conversation can end
         logger.info("--- Routing to End ---")
         return END
 
@@ -140,12 +117,11 @@ graph_builder.add_conditional_edges(
     "scraper_agent",
     router,
     {
-        "tools": "tools", # If router returns "tools", go to the "tools" node
-         END: END,       # If router returns END, finish the graph execution
+        "tools": "tools",
+         END: END,
     }
 )
 
-# After tools are invoked, their results (ToolMessages) should go back to the agent
 graph_builder.add_edge("tools", "scraper_agent")
 
 # Compile the graph

application/services/gemini_api_service.py

@@ -152,13 +152,11 @@ def upload_file(
         Exception: If upload fails.
     """
     try:
-        # Determine if input is a URL
         is_url = isinstance(file, str) and file.startswith(('http://', 'https://'))
 
-        # Determine file name if not provided
         if not file_name:
             if is_url:
-                file_name = os.path.basename(file.split("?")[0])  # Remove query params
+                file_name = os.path.basename(file.split("?")[0]) 
             elif isinstance(file, str):
                 file_name = os.path.basename(file)
             elif hasattr(file, "name"):
@@ -172,14 +170,12 @@ def upload_file(
         config.update({"name": sanitized_name, "mime_type": mime_type})
         gemini_file_key = f"files/{sanitized_name}"
 
-        # Check if file already exists
         if gemini_file_key in get_files():
             logger.info(f"File already exists on Gemini: {gemini_file_key}")
             return client.files.get(name=gemini_file_key)
 
         logger.info(f"Uploading file to Gemini: {gemini_file_key}")
 
-        # Handle URL
         if is_url:
             headers = {
                 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
@@ -189,14 +185,12 @@ def upload_file(
             file_content = io.BytesIO(response.content)
             return client.files.upload(file=file_content, config=config)
 
-        # Handle local file path
         if isinstance(file, str):
             if not os.path.isfile(file):
                 raise FileNotFoundError(f"Local file '{file}' does not exist.")
             with open(file, "rb") as f:
                 return client.files.upload(file=f, config=config)
 
-        # Handle already opened binary file object
         return client.files.upload(file=file, config=config)
 
     except Exception as e:

main.py

@@ -147,15 +147,15 @@ workflow.set_entry_point("supervisor")
 graph = workflow.compile()
 
 # # === Example Run ===
-if __name__ == "__main__":
-    logger.info("Starting the graph execution...")
-    initial_message = HumanMessage(content="Can you get zalando pdf link")
-    input_state = {"messages": [initial_message]}
-
-    for step in graph.stream(input_state):
-        if "__end__" not in step:
-            logger.info(f"Graph Step Output: {step}")
-            print(step)
-            print("----")
-
-    logger.info("Graph execution completed.")
+# if __name__ == "__main__":
+#     logger.info("Starting the graph execution...")
+#     initial_message = HumanMessage(content="Can you get zalando pdf link")
+#     input_state = {"messages": [initial_message]}
+
+#     for step in graph.stream(input_state):
+#         if "__end__" not in step:
+#             logger.info(f"Graph Step Output: {step}")
+#             print(step)
+#             print("----")
+
+#     logger.info("Graph execution completed.")