Update to v0.2.4

Author: SyntaxError4Life

README.md

@@ -44,27 +44,6 @@ for token, tool, tool_bool in T.handle_streaming(stream) :
 ```
 </details> 
 
-<details><summary><b>To create a simple display using gradio as backend</b></summary>
-
-```python
-import open_taranis as T
-import open_taranis.web_front as W
-import gradio as gr
-
-gr.ChatInterface(
-    fn=W.chat_fn_gradio(
-    client=T.clients.openrouter(), # API_KEY in env_var
-    request=T.clients.openrouter_request,
-    model="nvidia/nemotron-3-nano-30b-a3b:free",
-    _system_prompt="You are an agent named **Taranis**"
-).create_fn(),
-    title="web front"
-).launch()
-``` 
-</details>  
-
-
-
 <details><summary><b>Make a simple agent with a context windows on the 6 last turns</b></summary>
 
 ```python
@@ -102,6 +81,33 @@ while True :
 
     print("\n\n","="*60,"\n")
 ```
+</details>
+
+<details><summary><b>To create a simple display using gradio as backend</b></summary>
+
+```python
+import open_taranis as T
+import open_taranis.web_front as W
+import gradio as gr
+
+class Gradio_agent(T.agent_base):
+    def __init__(self):
+        super().__init__()
+
+        self._system_prompt = [T.create_system_prompt("You are a agent nammed **Taranis**")]
+    
+    def create_stream(self):
+        return T.clients.openrouter_request(
+            client=T.clients.openrouter(),
+            messages=self._system_prompt+self.messages,
+            model="nvidia/nemotron-3-nano-30b-a3b:free"
+        )
+
+gr.ChatInterface(
+    fn=W.create_fn_gradio(Gradio_agent()),
+    title="Open-taranis Agent"
+).launch()
+``` 
 </details>  
 
 ---
@@ -156,6 +162,7 @@ Available in [French](https://zanomega.com/open-taranis/fr/)
 - **v0.2.1** : Updated `agent_base` and added a more concrete example of agents
 - **v0.2.2** : Upgraded all the code to add [**Kimi Code**](https://www.kimi.com/code) as client and reduce code (**Not official !**)
 - **v0.2.3** : Updated `agent_base`, add some functions and add a **cool** agent
+- **v0.2.4** : Improved CoT techniques and updated `web_front.py`, deploy an agent to the browser in a few lines
 </details>   
 
 

examples/infinite_agent_v1.py

@@ -6,7 +6,9 @@
 REQUEST = T.clients.openrouter_request
 MAX_TOKENS = 16000
 
-# Made with v0.2.3
+# Made with v0.2.4
+if T.__version__ < "0.2.4":
+    exit(f"Version v0.2.4 minimum required, you have v{T.__version__}")
 
 # =========================================
 
@@ -61,13 +63,11 @@ def manage_messages_after_reply(self):
             is_thinking = False
             new_memory = ""
             for token, _, _ in T.handle_streaming(stream):
-                is_thinking = T.handle_thinking(token, is_thinking)
+                is_thinking, norm_tok, cot_tok = T.handle_thinking(token, is_thinking)
 
-                if is_thinking :
-                    continue
-                else : 
-                    new_memory += token
-            
+                if norm_tok :
+                    new_memory += norm_tok
+                       
             self.memory = T.remove_thinks(new_memory)
             self._system_prompt = [T.create_system_prompt(
                 self.system_prompt + self.memory
@@ -93,4 +93,4 @@ def manage_messages_after_reply(self):
     for t in My_agent(prompt):
         print(t, end="", flush=True)
 
-    print("\n\n","="*60,"\n")
+    print("\n\n","="*60,"\n")

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-taranis"
-version = "0.2.3"
+version = "0.2.4"
 description = "Python framework for AI agents logic-only coding with streaming, tool calls, and multi-LLM provider support"
 authors = [{name = "SyntaxError4Life", email = "contact@zanomega.com"}]
 dependencies = ["requests", "packaging", "openai", "bs4"]

src/open_taranis/__init__.py

@@ -7,7 +7,7 @@
 import inspect
 from typing import Any, Callable, Literal, Union, get_args, get_origin
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"
 
 import requests
 from packaging import version
@@ -395,14 +395,17 @@ def handle_tool_call(tool_call:dict) -> tuple[str, str, dict, str] :
 def functions_to_tools(funcs: list[Callable]) -> list[dict[str, Any]]:
     return [utils.function_to_openai_tool(f) for f in funcs]
 
-def handle_thinking(token, is_thinking):
-    if "<think>" in token or is_thinking :
-        is_thinking=True
+def handle_thinking(TOKEN, is_thinking):
+    token, CoT = TOKEN, None
 
-        if "</think>" in token :
-            is_thinking=False
+    if "<think>" in TOKEN or is_thinking :
+        token, CoT = None, TOKEN
+        is_thinking = True
+
+        if "</think>" in TOKEN :
+            is_thinking = False
 
-    return is_thinking
+    return is_thinking, token, CoT 
 
 def remove_thinks(message:str):
     assert type(message) == str
@@ -500,9 +503,6 @@ def manage_assistant_response(self, response):
     def manage_messages_in_reply(self):
         """
         Function to manage message history, executed at each step (after agent response or tool call)
-
-
-        ```
         """
         pass
 
@@ -547,25 +547,21 @@ def __call__(self, prompt):
             response = ""
             reasoning = ""
             for token, tool_calls, run in handle_streaming(self.create_stream()) :
-                if token :
-
-                    if "<think>" in token or is_thinking :
-                        is_thinking=True
-
-                        if "</think>" in token :
-                            is_thinking=False
-
-                        if self.meta["is_thinking_enabled"] :
-                            reasoning += token
-                        else :
-                            response += token
-                        
-                        if self.meta["yield_thinking"]:
-                            yield self.manage_token_yield(token, is_thinking)
-                    
+                is_thinking, token, CoT = handle_thinking(token, is_thinking)
+
+                if is_thinking:
+                    if self.meta["is_thinking_enabled"]:
+                        reasoning += CoT
                     else :
-                        yield self.manage_token_yield(token, is_thinking)
-                        response += token
+                        response += CoT
+
+                    if self.meta["yield_thinking"]:
+                        yield self.manage_token_yield(token, is_thinking=True)
+
+                else :
+                    yield self.manage_token_yield(token, is_thinking=False)
+                    if token : response += token          
+
 
             if run:
 

src/open_taranis/web_front.py

@@ -1,63 +1,19 @@
 import open_taranis as T
 
-class chat_fn_gradio:
-    def __init__(self, 
-                 client:T.openai.OpenAI,
-                 request:T.openai.Stream,
-                 model:str,
-                 _system_prompt:str=""
-                ):
-        
-        self.client:T.openai.OpenAI = client
-        self.request:T.openai.Stream = request
-        self.model = model
-        self._system_prompt = [{"role":"system", "content":_system_prompt}]
-
-    def create_stream(self, messages):
-        """
-        TO IMPLEMENT
-        """
-
-        return self.request(
-            self.client,
-            messages=self._system_prompt+messages,
-            model=self.model
-        )
-
-    def create_fn(self):
-
-            # Gradio chat function
-            #   Gradio sends:  message, history
-        def fn(message, history, *args):
-
-            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))    
-
-            stream = self.create_stream(
-                messages=messages
-            )
-
-            partial = ""
-            is_thinking = False
-
-            for token, _, _ in T.handle_streaming(stream):
-                if token :
-
-                    if "<think>" in token or is_thinking :
-                        is_thinking = True
-
-                        if "</think>" in token :
-                            is_thinking = False
-                    
-                        yield "Thinking...."
-                        continue
-
-                    else : partial += token
-
-                    yield partial
-            return
-        return fn
+def create_fn_gradio(Agent):
+
+        # Gradio chat function
+        #   Gradio sends:  message, history
+    def fn(message, history, *args): 
+
+        partial = ""
+        for token, is_thinking in Agent(message): 
+            if is_thinking :
+                yield partial + "\nThinking...."
+                continue
+            
+            if token : partial += token
+            yield partial
+
+        return
+    return fn