Update to v0.1.4

Author: SyntaxError4Life

README.md

@@ -1,6 +1,6 @@
 # open-taranis
 
-Minimalist Python framework for AI agents logic-only coding with streaming, tool calls, and multi-LLM provider support.
+Python framework for AI agents logic-only coding with streaming, tool calls, and multi-LLM provider support.
 
 ## Installation
 
@@ -35,13 +35,14 @@ To create a simple display using gradio as backend :
 ```python
 import open_taranis as T
 import open_taranis.web_front as W
+import gradio as gr
 
-W.gr.ChatInterface(
+gr.ChatInterface(
     fn=W.chat_fn_gradio(
-    client=T.clients.openrouter(api_key="api_key"),
+    client=T.clients.openrouter(API_KEY),
     request=T.clients.openrouter_request,
     model="mistralai/mistral-7b-instruct:free",
-    _system_prompt=""
+    _system_prompt="You are an agent named **Taranis**"
 ).create_fn(),
     title="web front"
 ).launch()
@@ -71,6 +72,7 @@ W.gr.ChatInterface(
 - **v0.1.1** : Code to deploy a **frontend with gradio** added (no complex logic at the moment, ex: tool_calls)
 - **v0.1.2** : Fixed a display bug in the **web_front** and experimentally added **ollama as a backend**
 - **v0.1.3** : Fixed the memory reset in the **web_front** and remove **ollama module** for **openai front** (work 100 times better)
+- **v0.1.4** : Fixed `web_front` for native use on huggingface, as well as `handle_streaming` which had tool retrieval issues
 
 ## Advanced Examples
 

pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-taranis"
-version = "0.1.3" 
+version = "0.1.4" 
 description = "Minimalist Python framework for AI agents logic-only coding with streaming, tool calls, and multi-LLM provider support"
 authors = [{name = "SyntaxError4Life", email = "lilian@zanomega.com"}]
-dependencies = ["openai","gradio"]
+dependencies = ["openai"]
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "GPL-3.0-or-later"}

src/open_taranis/__init__.py

@@ -7,7 +7,7 @@
 from typing import Any, Callable, Literal, Union, get_args, get_origin
 
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"
 
 import requests
 from packaging import version
@@ -334,11 +334,9 @@ def handle_streaming(stream: openai.Stream):
                         "arg_chunks": []  # New: list for arguments
                     }
                     arg_chunks[index] = []
+                if tool_call.function:
                     if tool_call.function.name:
-                        # Ollama sends full name each chunk, OpenAI sends incrementally
-                        if accumulated_tool_calls[index]["function"]["name"] == "":
-                            accumulated_tool_calls[index]["function"]["name"] = tool_call.function.name
-                        # else: skip (already set, don't +=)
+                        accumulated_tool_calls[index]["function"]["name"] += tool_call.function.name
                     if tool_call.function.arguments:
                         # Append to list instead of +=
                         arg_chunks[index].append(tool_call.function.arguments)
@@ -380,6 +378,7 @@ def handle_streaming(stream: openai.Stream):
         ]
     yield "", tool_calls, len(tool_calls) > 0
 
+
 def handle_tool_call(tool_call:dict) -> tuple[str, str, dict, str] :
     """
     Return :

src/open_taranis/web_front.py

@@ -1,6 +1,4 @@
-import gradio as gr
 import open_taranis as T
-from time import time
 
 class chat_fn_gradio:
     def __init__(self, 
@@ -15,77 +13,55 @@ def __init__(self,
         self.model = model
         self._system_prompt = [{"role":"system", "content":_system_prompt}]
 
-        self.meta = {
-            "defaut_create_stream_used":False
-        }
-        self.memory = []
-
     def create_stream(self, messages):
         """
         TO IMPLEMENT
-
-        ```
-        if self.meta["defaut_create_stream_used"]==False : # Just used to detect, must be rewritten by the user
-            print("Classic create_stream method used !")
-            self.meta=True
-
-        return self.request(self.client,messages=messages,model=self.model)
-        ```
-
         """
-        if self.meta["defaut_create_stream_used"]==False : # Just used to detect, must be rewritten by the user
-            print("Classic create_stream method used !")
-            self.meta=True
 
-        return self.request(self.client,messages=messages,model=self.model)
+        return self.request(
+            self.client,
+            messages=messages,
+            model=self.model
+        )
 
     def create_fn(self):
 
             # Gradio chat function
             #   Gradio sends:  message, history
         def fn(message, history, *args):
 
-            if history == []: # Reset memory
-                self.memory = []
+            messages=[]
+
+            for user, assistant in history :
+                messages.append(T.create_user_prompt(user))
+                messages.append(T.create_assistant_response(assistant))   
+            messages.append(T.create_user_prompt(message))    
 
-            # Here we use our own internal memory rather than that of the gradio :
-            self.memory.append(T.create_user_prompt(message))
-            is_thinking = False
 
-            tempo_time = 0.0
-            time_thinking = 0.0
+            stream = self.request(
+                self.client,
+                messages=self._system_prompt+messages,
+                model=self.model
+            )
 
             stream = self.create_stream(
-                self._system_prompt+self.memory # We make the system prompt adaptable and never at the beginning of the memory
+                messages=messages
             )
 
             partial = ""
-            token_nb = 0
+            is_thinking = False
 
             for token, _, _ in T.handle_streaming(stream):
                 if token :
 
-                    if "<think>" in token or not is_thinking :
-                        tempo_time = time()
                     if "<think>" in token or is_thinking :
                         is_thinking = True
 
                         if "</think>" in token :
-                            time_thinking = time() - tempo_time 
                             is_thinking = False
 
                     else : partial += token
-                    token_nb += 1
-
-                    # ====================================
-                    yield f"""Tokens : {token_nb} 
-Model : {self.model}
 
----
-{f"**Think : {time_thinking:.4f}s**\n\n---\n\n" if time_thinking!=0.0 else ""}
-{f"**Thinking for {(time() - tempo_time):.4f}s....**" if is_thinking else partial}"""
-                    
-                    # ====================================
-            self.memory.append(T.create_assistant_response(partial))
+                    yield partial
             return
         return fn