Update to v0.2.2

Author: SyntaxError4Life

README.md

@@ -123,11 +123,11 @@ while True :
 
 ## Roadmap
 
-- [X]   v0.0.1: start
-- [X]   v0.0.x: Add and confirm other API providers (in the cloud, not locally)
-- [X]   v0.1.x: Functionality verifications in [examples](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/)
-- [X] > v0.2.0: Add features for **logic-only coding** approach, start with `agent_base`
-- [ ]   v0.3.x: Add a full agent in **TUI** and upgrade web client **deployments**
+- [X] v0.0.1: start
+- [X] v0.0.x: Add and confirm other API providers (in the cloud, not locally)
+- [X] v0.1.x: Functionality verifications in [examples](https://github.com/SyntaxError4Life/open-taranis/blob/main/examples/)
+- [X] v0.2.x: Add features for **logic-only coding** approach, start with `agent_base`
+- [ ] v0.3.x: Add a full agent in **TUI** and upgrade web client **deployments**
 - The rest will follow soon.
 
 ## Changelog
@@ -152,6 +152,7 @@ while True :
 
 - **v0.2.0** : Adding `agent_base`
 - **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**]() as client and reduce code (**Not official !**)
 </details>   
 
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "open-taranis"
-version = "0.2.1"
+version = "0.2.2"
 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/CLI.py

@@ -85,6 +85,9 @@ def run(stdscr):
                 ("- [x]" if os.environ.get('XAI_API_KEY') else "- [ ]") + " x.ai",
                 ("- [x]" if os.environ.get('GROQ_API_KEY') else "- [ ]") + " groq",
                 "",
+                "=== Codes ===",
+                ("- [x]" if os.environ.get('KIMI_CODE_API_KEY') else "- [ ]") + " Kimi Code",
+                "",
                 "To show the env var : /show more"
             ]
 
@@ -97,6 +100,9 @@ def run(stdscr):
                 "- deepseek.ai = 'DEEPSEEK_API_KEY'",
                 "- x.ai        = 'XAI_API_KEY'",
                 "- groq        = 'GROQ_API_KEY'",
+                "",
+                "=== Codes ===",
+                "- Kimi Code   = 'KIMI_CODE_API_KEY'"
             ]
 
         if display_mode != "NONE" :

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.1"
+__version__ = "0.2.2"
 
 import requests
 from packaging import version
@@ -132,9 +132,14 @@ def function_to_openai_tool(func: Callable) -> dict[str, Any]:
             }
         }
 
-# Utility for multiple functions, code by Kimi k2 thinking
-def functions_to_tools(funcs: list[Callable]) -> list[dict[str, Any]]:
-    return [utils.function_to_openai_tool(f) for f in funcs]
+    @staticmethod
+    def generate_clients(api_key_env:str, base_url:str, **kwargs):
+        def client_builder(api_key:str=None):
+            api_key = os.environ.get(api_key_env) if api_key_env else api_key
+                
+            return openai.OpenAI(api_key=api_key, base_url=base_url, default_headers=kwargs.get("default_headers"))
+
+        return client_builder
 
 
 class clients:
@@ -149,68 +154,25 @@ def generic(api_key:str, base_url:str) -> openai.OpenAI:
         Use `clients.generic_request` for call
         """
         return openai.OpenAI(api_key=api_key, base_url=base_url)
-
-    @staticmethod
-    def veniceai(api_key: str=None) -> openai.OpenAI:
-        """
-        Use `clients.veniceai_request` for call
-        """
-        if os.environ.get('VENICE_API_KEY') :
-            api_key = os.environ.get('VENICE_API_KEY')
-        return openai.OpenAI(api_key=api_key, base_url="https://api.venice.ai/api/v1")
 
-    @staticmethod
-    def deepseek(api_key: str=None) -> openai.OpenAI:
-        """
-        Use `clients.generic_request` for call
-        """
-        if os.environ.get('DEEPSEEK_API_KEY') :
-            api_key = os.environ.get('DEEPSEEK_API_KEY')
-        return openai.OpenAI(api_key=api_key, base_url="https://api.deepseek.com")
+    veniceai = utils.generate_clients('VENICE_API_KEY', "https://api.venice.ai/api/v1")
+    
+    deepseek = utils.generate_clients('DEEPSEEK_API_KEY',"https://api.deepseek.com")
 
-    @staticmethod
-    def xai(api_key: str=None) -> openai.OpenAI:
-        """
-        Use `clients.generic_request` for call
-        """
-        if os.environ.get('XAI_API_KEY') :
-            api_key = os.environ.get('XAI_API_KEY')
-        return openai.OpenAI(api_key=api_key, base_url="https://api.x.ai/v1", timeout=3600)
+    xai = utils.generate_clients('XAI_API_KEY', "https://api.x.ai/v1")
 
-    @staticmethod
-    def groq(api_key: str=None) -> openai.OpenAI:
-        """
-        Use `clients.generic_request` for call
-        """
-        if os.environ.get('GROQ_API_KEY') :
-            api_key = os.environ.get('GROQ_API_KEY')
-        return openai.OpenAI(api_key=api_key, base_url="https://api.groq.com/openai/v1")
-    
-    @staticmethod
-    def huggingface(api_key: str=None) -> openai.OpenAI:
-        """
-        Use `clients.generic_request` for call
-        """
-        if os.environ.get('HUGGINGFACE_API_KEY') :
-            api_key = os.environ.get('HUGGINGFACE_API_KEY')
-        return openai.OpenAI(api_key=api_key, base_url="https://router.huggingface.co/v1")
+    groq = utils.generate_clients('GROQ_API_KEY', "https://api.groq.com/openai/v1")
+
+    huggingface = utils.generate_clients('HUGGINGFACE_API_KEY', "https://router.huggingface.co/v1")
 
-    @staticmethod
-    def openrouter(api_key: str=None) -> openai.OpenAI:
-        """
-        Use `clients.openrouter_request` for call
-        """
-        if os.environ.get('OPENROUTER_API_KEY') :
-            api_key = os.environ.get('OPENROUTER_API_KEY')
-        return openai.OpenAI(api_key=api_key, base_url="https://openrouter.ai/api/v1")   
+    ollama = utils.generate_clients(None, "http://localhost:11434/v1")
 
-    @staticmethod
-    def ollama() -> openai.OpenAI:
-        """
-        Use `clients.generic_request` for call
-        """
-        return openai.OpenAI(api_key="", base_url="http://localhost:11434/v1")   
+    openrouter = utils.generate_clients('OPENROUTER_API_KEY', "https://openrouter.ai/api/v1")
 
+    kimi_code = utils.generate_clients("KIMI_CODE_API_KEY", "https://api.kimi.com/coding/v1",
+        default_headers={"User-Agent": "RooCode/3.30.3","HTTP-Referer": "https://github.com/RooVetGit/Roo-Cline","X-Title": "Roo Code"}
+    )
+    
 # ==============================
 # Customers for calls with their specifications"
 #
@@ -322,18 +284,35 @@ def handle_streaming(stream: openai.Stream):
     accumulated_tool_calls = {}
     arg_chunks = {}  # Per tool_call index: list of argument chunks
 
+    is_thinking = False
+
     # Process each chunk
     for chunk in stream:
         # Skip if no choices
         if not chunk.choices:
             continue
+
         delta = chunk.choices[0].delta
         if delta is None:
             continue
+        
+        # Handle reasoning streaming
+        if getattr(delta, 'reasoning_content', None):
+            if is_thinking :
+                yield delta.reasoning_content, [], False
+            else :
+                yield "<think>\n", [], False
+                yield delta.reasoning_content, [], False
+                is_thinking = True
 
         # Handle content streaming
         if delta.content :
-            yield delta.content, [], False
+            if is_thinking :
+                yield "</think>\n", [], False
+                yield delta.content, [], False
+                is_thinking = False
+            else :
+                yield delta.content, [], False
 
         # Handle tool calls in delta
         if delta.tool_calls:
@@ -412,12 +391,17 @@ def handle_tool_call(tool_call:dict) -> tuple[str, str, dict, str] :
 
     return fid, fname, args, ""
 
+# Utility for multiple functions, code by Kimi k2 thinking
+@staticmethod
+def functions_to_tools(funcs: list[Callable]) -> list[dict[str, Any]]:
+    return [utils.function_to_openai_tool(f) for f in funcs]
+
 # ==============================
 # Functions to simplify the messages roles
 # ==============================
 
 @staticmethod
-def create_assistant_response(content:str, tool_calls:list[dict]=None) -> dict[str, str]:
+def create_assistant_response(content:str, tool_calls:list[dict]=None, reasoning_content:str=None) -> dict[str, str]:
     """
     Creates an assistant message, optionally with tool calls.
     
@@ -428,8 +412,12 @@ def create_assistant_response(content:str, tool_calls:list[dict]=None) -> dict[s
     Returns:
         dict: Message formatted for the API
     """
-    if tool_calls : return {"role": "assistant","content": content,"tool_calls": tool_calls}
-    return {"role": "assistant","content": content}
+    r = {"role": "assistant","content": content}
+    if tool_calls : 
+        r.update({"tool_calls":tool_calls})
+    if reasoning_content :
+        r.update({"reasoning_content":reasoning_content})
+    return r
 
 @staticmethod
 def create_function_response(id:str, result:str, name:str) -> dict[str, str, str]:
@@ -450,14 +438,16 @@ def create_user_prompt(content:str) -> dict[str, str] :
 # ==============================
 
 class agent_base:
-    def __init__(self):
+    def __init__(self, is_thinking_enabled:bool=False, yield_thinking:bool=False):
 
         self._system_prompt = [create_system_prompt("")]
         self.messages = []
         self.tools = []
 
         self.meta = {
-            "create_stream":True
+            "create_stream":True,
+            "is_thinking_enabled":is_thinking_enabled,
+            "yield_thinking":yield_thinking,
         }
 
     def create_stream(self):
@@ -524,6 +514,12 @@ def manage_messages_after_reply(self):
 
     def execute_tools(self, fname, args):
         raise NotImplementedError("Subclasses must implement execute_tools()")
+    
+    def manage_token_yield(self, token, is_thinking=None):
+        """
+        # TO IMPLEMENT if needed for custom front !
+        """
+        return token
 
     def __call__(self, prompt):
 
@@ -534,19 +530,41 @@ def __call__(self, prompt):
         ))
 
         while run :
-
+            is_thinking=False # Reset at each request
             response = ""
+            reasoning = ""
             for token, tool_calls, run in handle_streaming(self.create_stream()) :
                 if token :
-                    yield token
-                    response += token
-            
-            self.messages.append(create_assistant_response(
-                self.manage_assistant_response(response)
-            ))
+
+                    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)
+                    
+                    else :
+                        yield self.manage_token_yield(token, is_thinking)
+                        response += token
 
             if run:
-                self.messages.append(create_assistant_response(response, tool_calls))
+
+                if self.meta["is_thinking_enabled"] :
+                    self.messages.append(create_assistant_response(
+                        self.manage_assistant_response(response), tool_calls,
+                        reasoning_content=reasoning)
+                    )
+                else :
+                    self.messages.append(create_assistant_response(
+                        self.manage_assistant_response(response), tool_calls)
+                    )
 
                 for tool_call in tool_calls :
                     fid, fname, args, _ = handle_tool_call(tool_call)
@@ -558,6 +576,17 @@ def __call__(self, prompt):
                     ))
 
             self.manage_messages_in_reply()
+
+        reasoning = re.sub(r'<think>\n?|</think>\n', '', reasoning).strip()
 
-        self.messages.append(create_assistant_response(response))
+        if self.meta["is_thinking_enabled"] :
+            self.messages.append(create_assistant_response(
+                self.manage_assistant_response(response), tool_calls,
+                reasoning_content=reasoning)
+            )
+        else :
+            self.messages.append(create_assistant_response(
+                self.manage_assistant_response(response), tool_calls)
+            )
+
         self.manage_messages_after_reply()