V 1.1 (Agno)

app.py

@@ -2,10 +2,19 @@ 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)
 
-client = OpenAI(base_url="http://0.0.0.0:8000/v1", api_key="sk-local", timeout=600)
+agent = Agent(
+    model=OpenAILike(
+        id="model",
+        api_key="no-token",
+        base_url="http://0.0.0.0:8000/v1",
+    )
+)
+
 
 def handle_function_call(function_name, arguments):
     """Handle function calls from the model"""
@@ -30,8 +39,6 @@ def respond(
     message,
     history: list[tuple[str, str]] = [],
     system_message=None,
-    max_tokens=None,
-    temperature=0.7,
 ):
     messages = []
     if system_message:
@@ -46,97 +53,12 @@ def respond(
     messages.append({"role": "user", "content": message})
 
     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)
-        output = ""
-        reasoning = ""
-        function_calls_to_handle = []
+        stream = agent.run(messages=messages, stream=True)
 
         for chunk in stream:
-            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
+            print("chunk", chunk)
+            yield chunk.choices[0].delta.content
 
     except Exception as e:
         print(f"[Error] {e}")