Update app.py

app.py

@@ -2,20 +2,10 @@ import subprocess
 import gradio as gr
 from openai import OpenAI
 import json
-from agno.agent import Agent, RunResponse
-from agno.models.openai.like import OpenAILike
 
 subprocess.Popen("bash /home/user/app/start.sh", shell=True)
 
-agent = Agent(
-    model=OpenAILike(
-        id="model",
-        api_key="no-token",
-        base_url="http://0.0.0.0:8000/v1",
-    ),
-    reasoning=True
-)
-
+client = OpenAI(base_url="http://0.0.0.0:8000/v1", api_key="sk-local", timeout=600)
 
 def handle_function_call(function_name, arguments):
     """Handle function calls from the model"""
@@ -40,6 +30,8 @@ def respond(
     message,
     history: list[tuple[str, str]] = [],
     system_message=None,
+    max_tokens=None,
+    temperature=0.7,
 ):
     messages = []
     if system_message:
@@ -53,15 +45,98 @@ def respond(
 
     messages.append({"role": "user", "content": message})
 
-    output = ""
     try:
+        stream = client.chat.completions.create(
+            model="Deepseek-R1-0528-Qwen3-8B",
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            stream=True,
+            tools=[
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "browser_search",
+                        "description": (
+                            "Search the web for a given query and return the most relevant results."
+                        ),
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "The search query string.",
+                                },
+                                "max_results": {
+                                    "type": "integer",
+                                    "description": (
+                                        "Maximum number of search results to return. "
+                                        "If omitted the service will use its default."
+                                    ),
+                                    "default": 5,
+                                },
+                            },
+                            "required": ["query"],
+                        },
+                    },
+                },
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "code_interpreter",
+                        "description": (
+                            "Execute Python code and return the results. "
+                            "Can generate plots, perform calculations, and data analysis."
+                        ),
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "code": {
+                                    "type": "string",
+                                    "description": "The Python code to execute.",
+                                },
+                            },
+                            "required": ["code"],
+                        },
+                    },
+                },
+            ],
+        )
+
         print("messages", messages)
-        stream = agent.run(messages=messages, stream=True)
+        output = ""
+        reasoning = ""
+        function_calls_to_handle = []
 
         for chunk in stream:
-            print("chunk", chunk)
-            output += chunk.content
-            yield output
+            delta = chunk.choices[0].delta
+
+            if hasattr(delta, "tool_calls") and delta.tool_calls:
+                for tool_call in delta.tool_calls:
+                    if tool_call.function:
+                        function_calls_to_handle.append(
+                            {
+                                "name": tool_call.function.name,
+                                "arguments": json.loads(tool_call.function.arguments),
+                            }
+                        )
+
+            if hasattr(delta, "reasoning_content") and delta.reasoning_content:
+                reasoning += delta.reasoning_content
+            elif delta.content:
+                output += delta.content
+
+            yield f"*{reasoning}*\n{output}"
+
+        if function_calls_to_handle:
+            for func_call in function_calls_to_handle:
+                func_result = handle_function_call(
+                    func_call["name"], func_call["arguments"]
+                )
+                output += (
+                    f"\n\n**Function Result ({func_call['name']}):**\n{func_result}"
+                )
+                yield output
 
     except Exception as e:
         print(f"[Error] {e}")
@@ -71,4 +146,4 @@ def respond(
 demo = gr.ChatInterface(respond)
 
 if __name__ == "__main__":
-    demo.launch(show_api=False)
+    demo.launch(show_api=False)