Update app.py

app.py

@@ -7,10 +7,11 @@ import re
 import math
 import json
 import unicodedata
-from typing import TypedDict, Annotated
+from typing import TypedDict, Annotated, Any, List, Optional
  
-from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage
-from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from huggingface_hub import InferenceClient
+ 
+from langchain_core.messages import AnyMessage, HumanMessage, SystemMessage, AIMessage, ToolMessage
 from langchain_core.tools import tool
 from langchain_community.tools import DuckDuckGoSearchRun
 from langchain_community.utilities import WikipediaAPIWrapper
@@ -89,10 +90,11 @@ def get_task_file(task_id: str) -> str:
             ct = response.headers.get("Content-Type", "")
             if "text" in ct or "json" in ct:
                 return response.text[:5000]
-            return f"[Binary file attached - content-type: {ct}]"
+            return f"[Binary file - content-type: {ct}]"
         return f"No file found for task {task_id}"
     except Exception as e:
         return f"Error fetching task file: {e}"
+ 
 
 
 class AgentState(TypedDict):
@@ -117,14 +119,24 @@ Always end with:
 FINAL ANSWER: <your answer here>
 """
 
+def _tool_to_openai_schema(t) -> dict:
+    """Converte un LangChain tool nel formato tool OpenAI."""
+    return {
+        "type": "function",
+        "function": {
+            "name": t.name,
+            "description": t.description,
+            "parameters": t.args_schema.schema() if t.args_schema else {"type": "object", "properties": {}},
+        }
+    }
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        print("Initializing LangGraph Agent (HF course pattern)...")
+        print("Initializing agent with HF InferenceClient...")
  
-        tools = [
+        self.tools_list = [
             web_search,
             wikipedia_search,
             python_repl,
@@ -132,22 +144,22 @@ class BasicAgent:
             get_task_file,
         ]
  
-        # Pattern esatto dal notebook del corso:
-        # llm.bind_tools() + StateGraph costruito manualmente
-        endpoint = HuggingFaceEndpoint(
-            repo_id="Qwen/Qwen2.5-72B-Instruct",        # tool calling nativo
-            huggingfacehub_api_token=os.getenv("HF_TOKEN"),
-            task="conversational",
-            max_new_tokens=1024,
-            temperature=0.1,
+        # Mappa nome → funzione tool per esecuzione
+        self.tools_by_name = {t.name: t for t in self.tools_list}
+ 
+        # InferenceClient diretto — usa la Serverless Inference API HF
+        self.client = InferenceClient(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            token=os.getenv("HF_TOKEN"),
         )
-        llm = ChatHuggingFace(llm=endpoint, verbose=False)
-        self.llm_with_tools = llm.bind_tools(tools, parallel_tool_calls=False)
  
-        # Grafo ReAct: assistant → tools → assistant (loop)
+        # Schema OpenAI dei tool per passarli al client
+        self.tools_schema = [_tool_to_openai_schema(t) for t in self.tools_list]
+ 
+        # Grafo LangGraph per gestire il loop ReAct
         builder = StateGraph(AgentState)
         builder.add_node("assistant", self._assistant_node)
-        builder.add_node("tools", ToolNode(tools))
+        builder.add_node("tools", ToolNode(self.tools_list))
         builder.add_edge(START, "assistant")
         builder.add_conditional_edges("assistant", tools_condition)
         builder.add_edge("tools", "assistant")
@@ -155,11 +167,69 @@ class BasicAgent:
  
         print("Agent ready.")
  
+    def _messages_to_hf_format(self, messages: list) -> list:
+        """Converte messaggi LangChain nel formato dict che InferenceClient si aspetta."""
+        result = []
+        for m in messages:
+            if isinstance(m, SystemMessage):
+                result.append({"role": "system", "content": m.content})
+            elif isinstance(m, HumanMessage):
+                result.append({"role": "user", "content": m.content})
+            elif isinstance(m, AIMessage):
+                msg = {"role": "assistant", "content": m.content or ""}
+                # Includi tool_calls se presenti
+                if m.tool_calls:
+                    msg["tool_calls"] = [
+                        {
+                            "id": tc["id"],
+                            "type": "function",
+                            "function": {
+                                "name": tc["name"],
+                                "arguments": json.dumps(tc["args"]),
+                            }
+                        }
+                        for tc in m.tool_calls
+                    ]
+                result.append(msg)
+            elif isinstance(m, ToolMessage):
+                result.append({
+                    "role": "tool",
+                    "tool_call_id": m.tool_call_id,
+                    "content": m.content,
+                })
+        return result
+ 
     def _assistant_node(self, state: AgentState):
-        """Chiama il LLM con system prompt + history dei messaggi."""
+        """Nodo assistant: chiama InferenceClient con i tool e restituisce la risposta."""
         sys_msg = SystemMessage(content=SYSTEM_PROMPT)
-        response = self.llm_with_tools.invoke([sys_msg] + state["messages"])
-        return {"messages": [response]}
+        hf_messages = self._messages_to_hf_format([sys_msg] + state["messages"])
+ 
+        response = self.client.chat_completion(
+            messages=hf_messages,
+            tools=self.tools_schema,
+            tool_choice="auto",
+            max_tokens=1024,
+            temperature=0.1,
+        )
+ 
+        choice = response.choices[0].message
+ 
+        # Costruisci AIMessage compatibile con LangGraph
+        tool_calls = []
+        if choice.tool_calls:
+            for tc in choice.tool_calls:
+                tool_calls.append({
+                    "id": tc.id,
+                    "name": tc.function.name,
+                    "args": json.loads(tc.function.arguments),
+                    "type": "tool_call",
+                })
+ 
+        ai_message = AIMessage(
+            content=choice.content or "",
+            tool_calls=tool_calls,
+        )
+        return {"messages": [ai_message]}
  
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")