Update app.py

app.py

@@ -155,90 +155,66 @@ def safe_calculator(expression: str) -> str:
 class HfAgentWrapper:
     def __init__(self):
         print("Initializing HfAgentWrapper...")
-        model_id_or_path = "bigcode/starcoderbase-1b" # Compatible model
-        
-        try:
-            print(f"Attempting to initialize HfAgent with model: {model_id_or_path}")
+        model_id_or_path = "bigcode/starcoderbase-1b" # A model compatible with transformers v4.36.0
 
-            # Optional: Check if the secret is present for better logging.
-            # HfAgent will look for 'HF_TOKEN' on its own.
-            if not os.getenv("HF_TOKEN"):
-                print("CRITICAL WARNING: Space Secret 'HF_TOKEN' is not set. HfAgent will likely fail on gated models.")
-                # You can raise an error to stop if the token is essential
+        try:
+            print(f"Strategy: Pre-creating pipeline for model: {model_id_or_path}")
+            hf_auth_token = os.getenv("HF_TOKEN") # Secret should be named HF_TOKEN
+            if not hf_auth_token:
+                print("WARNING: HF_TOKEN secret not found. This may fail if model requires token.")
+                # Starcoderbase is gated, so this is needed.
                 raise ValueError("HF_TOKEN secret is missing and is required for this model.")
             else:
-                print("HF_TOKEN secret is present. HfAgent will use it automatically.")
+                print(f"HF_TOKEN secret found (length: {len(hf_auth_token)}).")
+
+            # --- Step 1: Create the pipeline object FIRST ---
+            # This allows us to handle errors from pipeline creation directly.
+            llm_pipeline = pipeline(
+                task="text-generation",
+                model=model_id_or_path,
+                token=hf_auth_token
+                # trust_remote_code=True # Not generally needed for starcoder with this version
+            )
+            print("Successfully created LLM pipeline object.")
 
-            # --- CRITICAL: Ensure Tool names are correct ---
+            # --- Step 2: Ensure your tools are created WITH proper names ---
             if not get_current_time_in_timezone.__doc__: raise ValueError("Tool 'get_current_time_in_timezone' is missing a docstring.")
             if not web_search.__doc__: raise ValueError("Tool 'web_search' is missing a docstring.")
             if not safe_calculator.__doc__: raise ValueError("Tool 'safe_calculator' is missing a docstring.")
 
             time_tool_obj = Tool(
-                name=get_current_time_in_timezone.__name__,
+                name=get_current_time_in_timezone.__name__, # Use the function's name
                 func=get_current_time_in_timezone,
                 description=get_current_time_in_timezone.__doc__
             )
             search_tool_obj = Tool(
-                name=web_search.__name__,
+                name=web_search.__name__, # Use the function's name
                 func=web_search,
                 description=web_search.__doc__
             )
             calculator_tool_obj = Tool(
-                name=safe_calculator.__name__,
+                name=safe_calculator.__name__, # Use the function's name
                 func=safe_calculator,
                 description=safe_calculator.__doc__
             )
             self.actual_tools_for_agent = [time_tool_obj, search_tool_obj, calculator_tool_obj]
-            
-            tool_names_for_log = [tool.name for tool in self.actual_tools_for_agent]
-            # This print MUST show your actual tool names. If it shows empty strings, the agent will not work.
-            print(f"Prepared Tool objects with names: {tool_names_for_log} and descriptions.") 
-            # --- End Tool Name Check ---
-
-            # Let HfAgent create its own pipeline internally.
-            # We REMOVE the hf_token argument. HfAgent will find the HF_TOKEN environment variable itself.
+            print(f"Prepared Tool objects with names: {[tool.name for tool in self.actual_tools_for_agent]}")
+
+            # --- Step 3: Pass the PRE-INITIALIZED pipeline object to HfAgent ---
+            print("Initializing HfAgent with the pre-created pipeline...")
             self.agent = HfAgent(
-                model_id_or_path,  # Pass model ID string as the first positional argument
+                llm_pipeline,  # Pass the pipeline object directly as the first argument
                 additional_tools=self.actual_tools_for_agent
             )
-            print(f"HfAgent successfully instantiated for model {model_id_or_path}.")
-
-            # --- Robust toolbox inspection (still useful) ---
-            print(f"Inspecting self.agent.toolbox...")
-            if hasattr(self.agent, 'toolbox'):
-                toolbox_attr = self.agent.toolbox
-                print(f"Type of self.agent.toolbox: {type(toolbox_attr)}")
-
-                if isinstance(toolbox_attr, dict):
-                    print(f"Toolbox is a dict. Keys: {list(toolbox_attr.keys())}")
-                    tools_info_from_dict = {}
-                    for key, value in list(toolbox_attr.items())[:5]: 
-                        tool_name_in_dict = key 
-                        if hasattr(value, 'name'): tool_name_in_dict = value.name
-                        elif isinstance(value, dict) and 'name' in value: tool_name_in_dict = value['name']
-                        tools_info_from_dict[key] = {'name_attr': tool_name_in_dict, 'type': str(type(value))}
-                    print(f"Sample of toolbox dict content: {tools_info_from_dict}")
-                    print(f"Names of tools we passed to HfAgent: {[tool.name for tool in self.actual_tools_for_agent]}")
-                elif hasattr(toolbox_attr, 'tools') and callable(toolbox_attr.tools):
-                    try:
-                        tools_in_toolbox = toolbox_attr.tools()
-                        print(f"Toolbox has .tools() method. Tool names: {[tool.name for tool in tools_in_toolbox if hasattr(tool, 'name')]}")
-                    except Exception as e_toolbox_call:
-                        print(f"Error calling or processing self.agent.toolbox.tools(): {e_toolbox_call}")
-                else:
-                    print(f"Toolbox is of type {type(toolbox_attr)} but not a dict or recognized Toolbox object for this debug print.")
-            else:
-                print("self.agent does not have a 'toolbox' attribute (this would be unexpected).")
-            # --- End of robust toolbox inspection ---
+            print("HfAgent successfully instantiated with pre-initialized pipeline.")
 
         except Exception as e:
-            print(f"CRITICAL ERROR: Failed to initialize HfAgent: {e}")
-            print("Full traceback of HfAgent initialization error:")
+            print(f"CRITICAL ERROR: Failed to initialize HfAgent or Pipeline: {e}")
+            print("Full traceback of HfAgent/Pipeline initialization error:")
             traceback.print_exc() 
-            raise RuntimeError(f"HfAgent initialization failed: {e}") from e
+            raise RuntimeError(f"HfAgent/Pipeline initialization failed: {e}") from e
 
-    # __call__ method remains the same
+    # The __call__ method remains the same
     def __call__(self, question: str) -> str:
         print(f"\n--- HfAgentWrapper received question (first 100 chars): {question[:100]}... ---")
         try: