syntaxmatrix 2.5.5.1__tar.gz → 2.5.5.3__tar.gz

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix
-Version: 2.5.5.1
+Version: 2.5.5.3
 Summary: SyntaxMUI: A customizable framework for Python AI Assistant Projects.
 Author: Bob Nti
 Author-email: bob.nti@syntaxmatrix.net

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/SyntaxMatrix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix
-Version: 2.5.5.1
+Version: 2.5.5.3
 Summary: SyntaxMUI: A customizable framework for Python AI Assistant Projects.
 Author: Bob Nti
 Author-email: bob.nti@syntaxmatrix.net

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
 
 setup(
     name="syntaxmatrix",
-    version="2.5.5.1",
+    version="2.5.5.3",
     author="Bob Nti",
     author_email="bob.nti@syntaxmatrix.net",
     description="SyntaxMUI: A customizable framework for Python AI Assistant Projects.",

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/syntaxmatrix/__init__.py

@@ -25,7 +25,7 @@ warning = _app_instance.warning
 
 set_user_icon = _app_instance.set_user_icon
 set_bot_icon = _app_instance.set_bot_icon
-# set_favicon = _app_instance.set_favicon
+set_favicon = _app_instance.set_favicon
 set_project_name = _app_instance.set_project_name
 set_site_title = _app_instance.set_site_title
 set_site_logo = _app_instance.set_site_logo

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/syntaxmatrix/agentic/agents.py

@@ -11,6 +11,7 @@ from .. import profiles as _prof
 from ..gpt_models_latest import set_args as _set_args, extract_output_text as _out
 from google.genai import types 
 import tiktoken
+from google.genai.errors import APIError
 
 
 def token_calculator(total_input_content, llm_profile):
@@ -39,8 +40,7 @@ def token_calculator(total_input_content, llm_profile):
     else:
         enc = tiktoken.encoding_for_model(_model)
         input_prompt_tokens = len(enc.encode(total_input_content))
-        return input_prompt_tokens
-    
+        return input_prompt_tokens    
 
 def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1, max_tokens=4096):
     """
@@ -94,83 +94,73 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
 
     # Google
     def google_generate_code():
+        nonlocal usage
+        """
+        Generates content using the Gemini API and calculates token usage
+        including Context Overhead for consistency.
+        """
+        
         try:
+            # 1. Client Initialization
             config = types.GenerateContentConfig(
                 system_instruction=system_prompt,
-                temperature=temperature,         
+                temperature=temperature,
                 max_output_tokens=max_tokens,
-                response_mime_type="text/plain",    
             )
-        
+
+            # 2. API Call
             resp = _client.models.generate_content(
                 model=_model,
-                contents=user_prompt,
-                config=config
+                contents=[user_prompt],
+                config=config,
             )
-            # --- capture usage for Gemini / python-genai ---
-            um = getattr(resp, "usage_metadata", None) or getattr(resp, "usageMetadata", None)
-            if um is not None:
-                # Try all known names, then fall back to arithmetic
-                prompt = _get_usage_val(um, [
-                    "prompt_token_count",
-                    "promptTokenCount",
-                    "input_tokens",
-                ])
-                candidates = _get_usage_val(um, [
-                    "candidates_token_count",
-                    "candidatesTokenCount",
-                    "output_tokens",
-                ])
-                total = _get_usage_val(um, [
-                    "total_token_count",
-                    "totalTokenCount",
-                    "total_tokens",
-                ])
-
-                usage["input_tokens"] = prompt
-                usage["output_tokens"] = candidates
-                usage["total_tokens"] = total
-
-                # Fallback: if output not provided but prompt + total exist,
-                # derive it as total - prompt
-                if usage["output_tokens"] is None and prompt is not None and total is not None:
-                    try:
-                        usage["output_tokens"] = int(total) - int(prompt)
-                    except Exception:
-                        # if it somehow fails, just leave it as None
-                        pass
-
-            # 1) Fast path: SDK convenience property
+
+            # 3. Token Usage Capture and Context Overhead Calculation
+            um = resp.usage_metadata
+            usage["input_tokens"] = um.prompt_token_count
+            usage["output_tokens"] = um.thoughts_token_count
+            usage["total_tokens"] = um.total_token_count
+
+            # 4. Response Extraction (same robust logic as before)
             text = getattr(resp, "text", None)
             if isinstance(text, str) and text.strip():
                 return text.strip()
+
             chunks = []
             candidates = getattr(resp, "candidates", None) or []
             for cand in candidates:
                 content = getattr(cand, "content", None)
-                parts = getattr(content, "parts", None) or []
-                for part in parts:
-                    t = getattr(part, "text", None)
-                    if t:
-                        chunks.append(str(t))
+                if content:
+                    parts = getattr(content, "parts", None) or []
+                    for part in parts:
+                        t = getattr(part, "text", None)
+                        if t:
+                            chunks.append(str(t))
+                            
             text = "\n".join(chunks).strip()
             if text:
                 return text
 
-            # Try to surface any block reason (safety / policy / etc.)
+            # 5. Handle blocked response
             fb = getattr(resp, "prompt_feedback", None)
             block_reason = getattr(fb, "block_reason", None) if fb else None
-            if block_reason:
-                raise RuntimeError(f"{_model} to blocked the response. Reason: {block_reason}")
-            raise RuntimeError(f"{_model} to say nothing in this section due to insufficient data.")
+            if block_reason and block_reason != types.BlockedReason.REASON_UNSPECIFIED:
+                raise RuntimeError(f"{_model} blocked the response. Reason: {block_reason.name}")
+            raise RuntimeError(f"{_model} failed to return content due to insufficient data.")
 
+        except APIError as e:
+            error_msg = f"Gemini API Error: {e}"
+        
         except Exception as e:
-            msg = f"I smxAI have instructed {e}\n"
-            return (
-                f"# {msg}\n"
-                "from syntaxmatrix.display import show\n"
-                f"show({msg!r})\n"
-            )
+            error_msg = f"An unexpected error occurred during API call or processing: {e}"
+
+        # --- Return the error message wrapped in the required output code structure ---
+        msg = f"I smxAI have instructed {error_msg}\n"
+        return (
+            f"# {msg}\n"
+            "from syntaxmatrix.display import show\n"
+            f"show({msg!r})\n"
+        )
 
     # OpenAI Responses API
     def gpt_models_latest_generate_code():
@@ -196,34 +186,11 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
                 verbosity=reasoning_and_verbosity()[1],
             )
             resp = _client.responses.create(**args)
-
-            # --- Capture token usage (prompt, completion, and total tokens) ---
-            u = getattr(resp, "usage", None)
-            # If usage is not None, extract tokens directly from the response
-            if u is not None:
-                usage["input_tokens"] = getattr(u, "prompt_tokens", None) or getattr(u, "promptTokenCount", None)
-                usage["output_tokens"] = getattr(u, "completion_tokens", None) or getattr(u, "completionTokenCount", None)
-                usage["total_tokens"] = getattr(u, "total_tokens", None) or getattr(u, "totalTokenCount", None)
             
-            # --- If missing input/output tokens, fallback logic --- 
-            if usage["input_tokens"] is None or usage["output_tokens"] is None:
-                # Use the raw response and fallback to manually calculate tokens
-                prompt_text = user_prompt
-                output_text = _out(resp).strip()
-
-                # Calculate input tokens based on the prompt
-                encoding = tiktoken.get_encoding("cl100k_base")  # Use GPT-5's encoding
-                usage["input_tokens"] = len(encoding.encode(prompt_text))
-
-                # Calculate output tokens based on the model's response
-                usage["output_tokens"] = len(encoding.encode(output_text))
-
-                # Total tokens is the sum of input + output
-                usage["total_tokens"] = usage["input_tokens"] + usage["output_tokens"]
-
-            # If tokens are still missing, log the issue
-            if usage["input_tokens"] is None or usage["output_tokens"] is None:
-                raise RuntimeError(f"Missing token data in OpenAI response for model {_model}. Tokens: {usage}")
+            um = resp.usage
+            usage["input_tokens"] = um.input_tokens
+            usage["output_tokens"] = um.output_tokens
+            usage["total_tokens"] = um.total_tokens
 
             code = _out(resp).strip()
             if code: 
@@ -231,17 +198,25 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
 
             # Try to surface any block reason (safety / policy / etc.)
             block_reason = None
-            output = getattr(resp, "output", None) or []
+            output = resp.get("output")
             for item in output:
                 fr = getattr(item, "finish_reason", None)
                 if fr and fr != "stop":
                     block_reason = fr
                     break
-
             if block_reason:
                 raise RuntimeError(f"{_model} stopped with reason: {block_reason}")
             raise RuntimeError(f"{_model} returned an empty response in this section due to insufficient data.")    
 
+        except APIError as e:
+            # IMPORTANT: return VALID PYTHON so the dashboard can show the error
+            msg = f"I smxAI have instructed {e}"
+            return (
+                f"# {msg}\n"
+                "from syntaxmatrix.display import show\n"
+                f"show({msg!r})\n"
+            )
+        
         except Exception as e:
             # IMPORTANT: return VALID PYTHON so the dashboard can show the error
             msg = f"I smxAI have instructed {e}"
@@ -252,7 +227,8 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
             )
         
     # Anthropic
-    def anthropic_generate_code():        
+    def anthropic_generate_code():  
+        nonlocal usage      
         try:        
             resp = _client.messages.create(
                 model=_model,
@@ -263,36 +239,11 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
                     {"role": "user", "content": user_prompt}
                 ]
             )
-            # usage in Responses API is usually a dict-like object
-            um = getattr(resp, "usage", None)
-            if um is not None:
-                # Try all known names, then fall back to arithmetic
-                prompt = _get_usage_val(um, [
-                    "prompt_token_count",
-                    "promptTokenCount",
-                    "input_tokens",
-                ])
-                candidates = _get_usage_val(um, [
-                    "candidates_token_count",
-                    "candidatesTokenCount",
-                    "output_tokens",
-                ])
-                total = _get_usage_val(um, [
-                    "total_token_count",
-                    "totalTokenCount",
-                    "total_tokens",
-                ])
-
-                usage["input_tokens"] = prompt
-                usage["output_tokens"] = candidates
-                usage["total_tokens"] = total
-
-                if usage["output_tokens"] is None and prompt is not None and total is not None:
-                    try:
-                        usage["output_tokens"] = int(total) - int(prompt)
-                    except Exception:
-                        # if it somehow fails, just leave it as None
-                        pass
+            
+            um = resp.usage
+            usage["input_tokens"] = um.input_tokens
+            usage["output_tokens"] = um.output_tokens
+            usage["total_tokens"] = um.input_tokens + um.output_tokens
                 
             # Extract plain text from Claude-style content blocks
             text_blocks = []
@@ -323,6 +274,7 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
 
     # OpenAI Chat Completions
     def openai_sdk_generate_code():
+        nonlocal usage
         try:
             resp = _client.chat.completions.create(
                 model=_model,
@@ -333,10 +285,13 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
                 temperature=temperature,
                 max_tokens=max_tokens,
             )
-            um = getattr(resp, "usage", None)
-            usage["input_tokens"]  = _get_usage_val(um, ["prompt_tokens", "input_tokens"])
-            usage["output_tokens"] = _get_usage_val(um, ["completion_tokens", "output_tokens"])
-            usage["total_tokens"]  = _get_usage_val(um, ["total_tokens"])
+
+
+
+            um = resp.usage
+            usage["input_tokens"] = um.prompt_tokens
+            usage["output_tokens"] = um.completion_tokens
+            usage["total_tokens"] = um.total_tokens
 
             text = resp.choices[0].message.content
             if text:
@@ -364,7 +319,9 @@ def mlearning_agent(user_prompt, system_prompt, coding_profile, temperature=0.1,
                 "from syntaxmatrix.display import show\n"
                 f"show({msg!r})\n"
             )
-                
+
+    # print("TTOOKKEENN: ", token_calculator(system_prompt + user_prompt, coding_profile))   
+
     if _provider == "google":
         code = google_generate_code()
     elif _provider == "openai" and _model in GPT_MODELS_LATEST:

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/syntaxmatrix/core.py

@@ -326,8 +326,8 @@ class SyntaxMUI:
     def set_project_name(self, project_name):
         self.project_name = project_name
 
-    # def set_favicon(self, icon):
-    #     self.favicon = icon
+    def set_favicon(self, icon):
+        self.favicon = icon
 
     def set_site_logo(self, logo):
         self.site_logo = logo

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/syntaxmatrix/routes.py

@@ -205,7 +205,6 @@ def setup_routes(smx):
             )
         return resp
     
-
     def head_html():
         # Determine a contrasting mobile text color based on the sidebar background.
         mobile_text_color = smx.theme["nav_text"]
@@ -497,8 +496,9 @@ def setup_routes(smx):
               padding: 2px 8px;
               color:cyan;
             }}
-          </style>
 
+          </style>
+         
           <!-- Add MathJax -->
           <script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
           <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>

{syntaxmatrix-2.5.5.1 → syntaxmatrix-2.5.5.3}/syntaxmatrix/templates/dashboard.html

@@ -680,29 +680,23 @@
               <br><br>
               <div class="refined-qblock">
                   <span class="refined-q-label"><b>My Thought Process:</b></span><br>
-                  <span class="refined-q">{{ refined_question }}</span>
+                  <span class="refined-q">{{ refined_question|safe }}</span>
               </div><br>
               <div class="refined-qblock">
-                  <span class="refined-q-label"><b>Tasks Performed:</b></span><br>
-                  {% for task in tasks %}
-                    <span class="refined-q">{{ task.replace("_", " ").capitalize() + ", " }}</span>
-                  {% endfor %}
+                <b>Tasks Performed: </b><br>
+                {% for task in tasks %}
+                  <span class="refined-q">- {{ task.replace('_', ' ').capitalize() + ', ' }}</span><br>
+                {%  endfor %}
               </div><br>
               {% if llm_usage %}
                 <div class="refined-qblock">
-                  <span class="refined-q-label"><b>LLM Tokens:</b></span><br>
-                  {% if llm_usage %}
-                    <span class="refined-q">
-                      Provider: {{ llm_usage.provider }},
-                      Model: {{ llm_usage.model }},
-                      Input: {{ llm_usage.input_tokens }},
-                      Output: {{ llm_usage.output_tokens }},
-                      Total: {{ llm_usage.total_tokens }}
-                    </span>
-                  {% else %}
-                    <span class="refined-q"><em>No usage information available.</em></span>
-                  {% endif %}
-                </div><br>
+                  <b>LLM: </b><span>{{ llm_usage.provider.capitalize() }} | {{ llm_usage.model }}</span><br>
+                  <b>Token Usage: </b>
+                    <li>- Input Tokens: {{ llm_usage.input_tokens }}</li>
+                    <li>- Output Tokens: {{ llm_usage.output_tokens }}</li>
+                    <li>- Total Tokens: {{ llm_usage.total_tokens }}</li>         
+                  </ul>
+                </div>
               {% endif %}
             {% endif %}
             {% if ai_outputs %}
@@ -715,7 +709,6 @@
                   </div>
               {% endfor %}
             {% endif %}
-
             {% if ai_code %}
               <div>
                   <a href="#" onclick="toggleCode();return false;" id="toggle-link">Show Code</a>