Update app.py

app.py

@@ -1,14 +1,9 @@
 import os
 import json
 import gradio as gr
-from typing import Dict, Any, List, Optional
-from qwen_agent.agents import Agent
-from qwen_agent.tools import Tool
+from qwen_agent.llm import get_chat_model
 
-# Initialize environment settings
-HUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN")
-
-# Define a static weather tool
+# Define a static weather tool function
 def get_current_weather(location, unit="fahrenheit"):
     """Get the current weather in a given location"""
     if "tokyo" in location.lower():
@@ -20,56 +15,93 @@ def get_current_weather(location, unit="fahrenheit"):
     else:
         return json.dumps({"location": location, "temperature": "unknown"})
 
-# Create a tool object for the Qwen Agent
-weather_tool = Tool(
-    name="get_current_weather",
-    description="Get the current weather in a given location",
-    func=get_current_weather,
-    parameters={
-        "type": "object",
-        "properties": {
-            "location": {
-                "type": "string",
-                "description": "The city and state, e.g. San Francisco, CA"
+# Set up the weather function definition
+weather_function = {
+    'name': 'get_current_weather',
+    'description': 'Get the current weather in a given location',
+    'parameters': {
+        'type': 'object',
+        'properties': {
+            'location': {
+                'type': 'string',
+                'description': 'The city and state, e.g. San Francisco, CA',
+            },
+            'unit': {
+                'type': 'string',
+                'enum': ['celsius', 'fahrenheit'],
+                'description': 'The unit of temperature to use. Infer this from the user\'s location.'
             },
-            "unit": {
-                "type": "string",
-                "enum": ["celsius", "fahrenheit"],
-                "description": "The unit of temperature to use. Infer this from the user's location."
-            }
         },
-        "required": ["location"]
-    }
-)
+        'required': ['location'],
+    },
+}
 
-# Initialize the Qwen Agent
-def init_agent():
-    agent = Agent(
-        llm={
-            "model": "Qwen/Qwen2.5-Coder-32B-Instruct",
-            "endpoint_type": "huggingface_hub",
-            "token": HUGGINGFACE_TOKEN,
-        },
-        tools=[weather_tool],
-    )
-    return agent
+# Initialize the Qwen model
+def init_model():
+    llm = get_chat_model({
+        'model': 'Qwen/Qwen2.5-Coder-32B-Instruct',
+        'endpoint_type': 'huggingface_hub',
+        'token': os.environ.get("HUGGINGFACE_TOKEN"),
+    })
+    return llm
 
 # Processing function for Gradio
 def process_message(message, history):
-    # Initialize agent on first run
-    if not hasattr(process_message, "agent"):
-        process_message.agent = init_agent()
+    # Initialize model on first run
+    if not hasattr(process_message, "llm"):
+        process_message.llm = init_model()
+    
+    # Set up the conversation
+    messages = [{'role': 'user', 'content': message}]
+    functions = [weather_function]
     
-    # Send the message to Qwen Agent and get the response
-    response = process_message.agent.run(message)
+    # Step 1: Get the initial response
+    try:
+        *_, response = process_message.llm.chat(
+            messages=messages,
+            functions=functions,
+            stream=True,
+        )
+        
+        # Step 2: Check if the model wanted to call a function
+        if response.get('function_call', None):
+            # Step 3: Call the function
+            function_name = response['function_call']['name']
+            function_args = json.loads(response['function_call']['arguments'])
+            
+            # Only process weather function calls
+            if function_name == 'get_current_weather':
+                function_response = get_current_weather(
+                    location=function_args.get('location'),
+                    unit=function_args.get('unit'),
+                )
+                
+                # Step 4: Send the function result back to the model
+                messages.append(response)  # Add the model's response with function call
+                messages.append({
+                    'role': 'function',
+                    'name': function_name,
+                    'content': function_response,
+                })
+                
+                # Get final response from the model
+                *_, final_response = process_message.llm.chat(
+                    messages=messages,
+                    functions=functions,
+                    stream=False,
+                )
+                return final_response['content']
+        
+        # If no function was called, return the initial response
+        return response['content']
     
-    # Return the response text
-    return response.text
+    except Exception as e:
+        return f"Error processing your request: {str(e)}"
 
 # Set up the Gradio interface
-with gr.Blocks(title="Qwen Agent with Weather Tool") as demo:
-    gr.Markdown("# Qwen Agent with Weather Tool")
-    gr.Markdown("This demo uses Qwen2.5-Coder-32B-Instruct with Qwen-Agent. You can ask about the weather for any city!")
+with gr.Blocks(title="Qwen Weather Assistant") as demo:
+    gr.Markdown("# Qwen Weather Assistant")
+    gr.Markdown("This demo uses Qwen2.5-Coder-32B-Instruct with function calling. You can ask about the weather for any city!")
     gr.Markdown("### Example cities with data: Tokyo, San Francisco, Paris")
     
     chatbot = gr.ChatInterface(
@@ -80,7 +112,7 @@ with gr.Blocks(title="Qwen Agent with Weather Tool") as demo:
             "I'm planning a trip to Paris. How's the weather there?",
             "What should I wear in Tokyo based on the weather?"
         ],
-        title="Chat with Qwen Agent"
+        title="Chat with Qwen Weather Assistant"
     )
 
 # Launch the app