Made agentic

agent/__init__.py

@@ -0,0 +1,9 @@
+from .agent import Agent
+from .tools import Tool, fetch_webpage, FETCH_WEBPAGE_TOOL
+
+__all__ = [
+    "Agent",
+    "Tool",
+    "fetch_webpage",
+    "FETCH_WEBPAGE_TOOL",
+]

agent/agent.py

@@ -0,0 +1,162 @@
+import json
+from typing import Any, Generator
+
+from openai import OpenAI
+
+from .tools import Tool
+
+# ---------------------------------------------------------------------------
+# Streaming event contract
+# ---------------------------------------------------------------------------
+# Each yield from Agent.stream() is a dict with a "type" key:
+#
+#   {"type": "text",     "content": "partial text"}
+#   {"type": "reasoning","content": "model thinking"}
+#   {"type": "tool_call", "name": str, "arguments": '{"url":"..."}'}
+#   {"type": "tool_output","name": str, "content": "result"}
+#   {"type": "done",     "content": "full assistant response"}
+#   {"type": "error",    "content": "error message"}
+# ---------------------------------------------------------------------------
+
+
+class Agent:
+    """OpenAI-compatible tool-calling agent with streaming."""
+
+    def __init__(self, base_url: str, api_key: str, model: str) -> None:
+        self.client = OpenAI(base_url=base_url, api_key=api_key)
+        self.model = model
+        self._tools: list[Tool] = []
+
+    def register_tool(self, tool: Tool) -> None:
+        self._tools.append(tool)
+
+    def stream(self, messages: list[dict]) -> Generator[dict, None, None]:
+        """Yield streaming events until the model produces a final response.
+
+        *messages* is mutated in-place — after the generator completes it
+        contains the full conversation history (including assistant replies,
+        tool calls, and tool outputs).
+        """
+        while True:
+            specs = [t.to_openai_spec() for t in self._tools] if self._tools else None
+
+            collected_content = ""
+            collected_tool_calls: dict[int, dict] = {}
+
+            kwargs: dict[str, Any] = dict(
+                model=self.model,
+                messages=messages,
+                stream=True,
+            )
+            if specs:
+                kwargs["tools"] = specs
+
+            try:
+                stream = self.client.chat.completions.create(**kwargs)
+            except Exception as exc:
+                yield {"type": "error", "content": str(exc)}
+                return
+
+            for chunk in stream:
+                cd = chunk.to_dict()
+                choices = cd.get("choices", [])
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {})
+
+                # Reasoning (e.g. DeepSeek R1)
+                reasoning = delta.get("reasoning_content") or delta.get("reasoning")
+                if reasoning:
+                    yield {"type": "reasoning", "content": reasoning}
+
+                # Text content
+                content = delta.get("content", "")
+                if content:
+                    collected_content += content
+                    yield {"type": "text", "content": content}
+
+                # Tool call fragments
+                for tc in delta.get("tool_calls", []):
+                    idx = tc.get("index", 0)
+                    if idx not in collected_tool_calls:
+                        collected_tool_calls[idx] = {
+                            "id": tc.get("id", ""),
+                            "function": {"name": "", "arguments": ""},
+                        }
+                    if tc.get("id"):
+                        collected_tool_calls[idx]["id"] = tc["id"]
+                    fn = tc.get("function", {})
+                    if fn.get("name"):
+                        collected_tool_calls[idx]["function"]["name"] += fn["name"]
+                    if fn.get("arguments"):
+                        collected_tool_calls[idx]["function"]["arguments"] += fn[
+                            "arguments"
+                        ]
+
+            # --- Handle tool calls ---
+            if collected_tool_calls:
+                tool_call_list = []
+                for idx in sorted(collected_tool_calls.keys()):
+                    tc = collected_tool_calls[idx]
+                    tool_call_list.append(
+                        {
+                            "id": tc["id"],
+                            "type": "function",
+                            "function": {
+                                "name": tc["function"]["name"],
+                                "arguments": tc["function"]["arguments"],
+                            },
+                        }
+                    )
+
+                # Assistant message with tool_calls
+                assistant_msg: dict[str, Any] = {
+                    "role": "assistant",
+                    "content": collected_content or None,
+                }
+                assistant_msg["tool_calls"] = tool_call_list
+                messages.append(assistant_msg)
+
+                # Execute each tool and append results
+                for tc_spec in tool_call_list:
+                    tname = tc_spec["function"]["name"]
+                    try:
+                        targs = json.loads(tc_spec["function"]["arguments"])
+                    except json.JSONDecodeError:
+                        targs = {}
+
+                    yield {
+                        "type": "tool_call",
+                        "name": tname,
+                        "arguments": tc_spec["function"]["arguments"],
+                    }
+
+                    tool_obj = next((t for t in self._tools if t.name == tname), None)
+                    if tool_obj:
+                        try:
+                            result = tool_obj.run(**targs)
+                        except Exception as e:
+                            result = f"Error executing {tname}: {e}"
+                    else:
+                        result = f"Error: Tool '{tname}' not found"
+
+                    result_str = str(result)
+                    # if result is too long, truncate and indicate truncation
+                    if len(result_str) > 5_000:
+                        result_str = result_str[:5_000] + "\n...[truncated]"
+                    yield {"type": "tool_output", "name": tname, "content": result_str}
+
+                    messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tc_spec["id"],
+                            "content": result_str,
+                        }
+                    )
+
+                continue  # Loop back so the model can respond after tools
+
+            # --- No tool calls — final response ---
+            messages.append({"role": "assistant", "content": collected_content})
+            yield {"type": "done", "content": collected_content}
+            break

agent/responses.py

@@ -0,0 +1,29 @@
+"""
+Streaming event types yielded by Agent.stream().
+
+Each event is a plain dict with at least a ``"type"`` key.
+"""
+
+# ── Text chunk ──────────────────────────────────────────────────────────
+# {"type": "text",      "content": "partial assistant message"}
+TEXT = "text"
+
+# ── Reasoning (e.g. DeepSeek R1 chain-of-thought) ──────────────────────
+# {"type": "reasoning", "content": "model thinking"}
+REASONING = "reasoning"
+
+# ── Tool was called by the model ────────────────────────────────────────
+# {"type": "tool_call",   "name": "fetch_webpage", "arguments": '{"url":"..."}'}
+TOOL_CALL = "tool_call"
+
+# ── Tool execution output ───────────────────────────────────────────────
+# {"type": "tool_output", "name": "fetch_webpage", "content": "<html>..."}
+TOOL_OUTPUT = "tool_output"
+
+# ── Final response (no more tool calls) ─────────────────────────────────
+# {"type": "done",       "content": "full assistant message"}
+DONE = "done"
+
+# ── Fatal error ─────────────────────────────────────────────────────────
+# {"type": "error",      "content": "API key invalid"}
+ERROR = "error"

agent/tools.py

@@ -0,0 +1,49 @@
+from markitdown import MarkItDown
+from typing import Any, Callable
+
+
+class Tool:
+    """A callable tool the agent can invoke."""
+
+    def __init__(
+        self, name: str, description: str, parameters: dict, handler: Callable[..., str]
+    ) -> None:
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.handler = handler
+
+    def to_openai_spec(self) -> dict:
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            },
+        }
+
+    def run(self, **kwargs: Any) -> str:
+        return self.handler(**kwargs)
+
+
+def fetch_webpage(url: str) -> str:
+    """Fetch a webpage and return its text content."""
+    md = MarkItDown()
+    return md.convert(url).text_content
+
+FETCH_WEBPAGE_TOOL = Tool(
+    name="fetch_webpage",
+    description="Fetch the content of a webpage and return its text",
+    parameters={
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": "string",
+                "description": "The URL to fetch",
+            }
+        },
+        "required": ["url"],
+    },
+    handler=fetch_webpage,
+)

app.py

@@ -1,19 +1,20 @@
 import time
 import uuid
 import gradio as gr
-from openai import OpenAI
 from dotenv import load_dotenv
+from agent import Agent, FETCH_WEBPAGE_TOOL
 import os
 from pathlib import Path
 
 load_dotenv()
 gr.set_static_paths("static/")
 
-client = OpenAI(
-    api_key=os.getenv("OPENAI_API_KEY"),
+agent = Agent(
     base_url=os.getenv("OPENAI_BASE_URL"),
+    api_key=os.getenv("OPENAI_API_KEY"),
+    model=os.getenv("OPENAI_MODEL"),
 )
-model = os.getenv("OPENAI_MODEL")
+agent.register_tool(FETCH_WEBPAGE_TOOL)
 
 # Load JS from external files
 _js_dir = Path(__file__).parent / "static" / "js"
@@ -69,54 +70,74 @@ class GradioEvents:
 
         yield { msg: gr.update(value=""), chatbot: gr.update(value=ctx["history"]), state: gr.update(value=state_value), conv_choice: _conv_choices(state_value), send_btn: gr.update(visible=False), stop_btn: gr.update(visible=True)}
 
-        normal_content = ""
+        # Agent will populate ctx["history"] with assistant + tool messages
+        display_buffer = ""
         is_reasoning = False
         spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
         spinner_idx = 0
-        temp = []
 
         try:
-            stream = client.chat.completions.create(
-                model=model,
-                messages=ctx["history"],
-                stream=True
-            )
-
-            for chunk in stream:
-                chunk = chunk.to_dict()
-                delta = chunk['choices'][0]['delta']
+            for ev in agent.stream(ctx["history"]):
+                t = ev["type"]
 
-                if delta.get('reasoning_content') or delta.get('reasoning'):
+                if t == "reasoning":
                     if not is_reasoning:
                         is_reasoning = True
                     spinner_idx += 1
-                    temp = [{
+                    if display_buffer:
+                        temp = [{"role": "assistant", "content": display_buffer}]
+                    else:
+                        temp = []
+                    temp.append({
                         "role": "assistant",
                         "content": f"<span class=\"thinking-indicator\">{spinner_frames[spinner_idx % len(spinner_frames)]}  Thinking...</span>",
-                        "metadata": None,
-                        "is_final": False,
-                    }]
-                elif delta.get('content', ''):
+                    })
+
+                elif t == "text":
                     if is_reasoning:
                         is_reasoning = False
-                    normal_content += delta['content']
-                    temp = [{
+                    display_buffer += ev["content"]
+                    temp = [{"role": "assistant", "content": display_buffer}]
+
+                elif t == "tool_call":
+                    display_buffer += (
+                        f'\n<div class="tool-call">'
+                        f'🔧 <strong>{ev["name"]}</strong>'
+                        f'<pre style="display:inline;font-size:0.85em">({ev["arguments"]})</pre>'
+                        f'</div>'
+                    )
+                    temp = [{"role": "assistant", "content": display_buffer}]
+
+                elif t == "tool_output":
+                    display_buffer += (
+                        f'\n<div class="tool-output">'
+                        f'📄 <em>({len(ev["content"])} chars)</em>'
+                        f'</div>'
+                    )
+                    temp = [{"role": "assistant", "content": display_buffer}]
+
+                elif t == "error":
+                    ctx["history"].append({
                         "role": "assistant",
-                        "content": normal_content,
-                        "metadata": None,
-                        "is_final": False,
-                    }]
+                        "content": f'<span style="color: var(--color-red-500)">{ev["content"]}</span>',
+                    })
+                    yield {
+                        chatbot: gr.update(value=ctx["history"]),
+                        state: gr.update(value=state_value),
+                        send_btn: gr.update(visible=True),
+                        stop_btn: gr.update(visible=False),
+                    }
+                    return
+
+                elif t == "done":
+                    # Agent has fully populated ctx["history"]
+                    break
 
                 yield {
                     chatbot: gr.update(value=ctx["history"] + temp),
                     state: gr.update(value=state_value),
                 }
 
-            if not is_reasoning and temp:
-                ctx["history"].extend(temp)
-                if ctx["history"][-1].get("role") == "assistant":
-                    ctx["history"][-1]["is_final"] = True
-
             yield {
                 chatbot: gr.update(value=ctx["history"]),
                 state: gr.update(value=state_value),