nimcode 0.8.3__tar.gz → 0.8.4__tar.gz

{nimcode-0.8.3 → nimcode-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.8.3
+Version: 0.8.4
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent

nimcode-0.8.4/src/nimcode/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.8.4"

{nimcode-0.8.3 → nimcode-0.8.4}/src/nimcode/agent.py

@@ -373,7 +373,7 @@ class Agent:
                         else:
                             display_text = parts[0]
                             
-                    tool_tag_idx = display_text.find("<tool_call>")
+                    tool_tag_idx = display_text.find("<tool_call")
                     if tool_tag_idx != -1:
                         display_text = display_text[:tool_tag_idx] + "\n\n*[dim]⚙️ Preparing tool execution...[/dim]*"
                         

{nimcode-0.8.3 → nimcode-0.8.4}/src/nimcode/lenient_parser.py

@@ -7,17 +7,22 @@ logger = logging.getLogger(__name__)
 
 class LenientParser:
     @staticmethod
-    def extract_tool_calls(text: str) -> List[str]:
-        """Extracts JSON strings from <tool_call> fenced blocks."""
-        # The model might forget the closing tag, or put markdown fences around it.
-        # We look for <tool_call> and extract everything until </tool_call> or EOF.
-        pattern = re.compile(r"<tool_call>\s*(.*?)(?:</tool_call>|\Z)", re.DOTALL | re.IGNORECASE)
+    def extract_tool_calls(text: str) -> List[Tuple[str, str]]:
+        """Extracts tool names and JSON strings from <tool_call> fenced blocks."""
+        # We look for <tool_call> or <tool_call name="..."> and extract everything until </tool_call> or EOF.
+        pattern = re.compile(r"<tool_call([^>]*)>\s*(.*?)(?:</tool_call>|\Z)", re.DOTALL | re.IGNORECASE)
         matches = pattern.findall(text)
         
         # Clean up markdown code blocks if the model wrapped the JSON in them
         cleaned_matches = []
-        for match in matches:
-            match = match.strip()
+        for attr_str, inner_text in matches:
+            # Parse name from attributes if it exists (e.g., name="Read")
+            name = ""
+            name_match = re.search(r'name=["\'](.*?)["\']', attr_str, re.IGNORECASE)
+            if name_match:
+                name = name_match.group(1).strip()
+
+            match = inner_text.strip()
             if match.startswith("```json"):
                 match = match[7:]
             elif match.startswith("```"):
@@ -26,7 +31,7 @@ class LenientParser:
             if match.endswith("```"):
                 match = match[:-3]
                 
-            cleaned_matches.append(match.strip())
+            cleaned_matches.append((name, match.strip()))
             
         return cleaned_matches
 
@@ -86,14 +91,19 @@ class LenientParser:
         Returns (plain_text_message, list_of_tool_calls).
         """
         # First, extract the tool calls
-        tool_call_strings = cls.extract_tool_calls(text)
+        tool_call_tuples = cls.extract_tool_calls(text)
         
         tool_calls = []
-        for tc_str in tool_call_strings:
+        for name, tc_str in tool_call_tuples:
             if not tc_str:
                 continue
             try:
-                tc = cls.parse_tool_call(tc_str)
+                tc_json = cls.parse_tool_call(tc_str)
+                # If model used <tool_call name="..."> and provided raw arguments in JSON
+                if isinstance(tc_json, dict) and "tool" not in tc_json and name:
+                    tc = {"tool": name, "args": tc_json}
+                else:
+                    tc = tc_json
                 tool_calls.append(tc)
             except ValueError:
                 # We could append an error message or raise. We'll raise to let the agent loop handle it and re-prompt.
@@ -101,7 +111,7 @@ class LenientParser:
                 
         # The plain text is whatever is not in the tool_call blocks.
         # We remove the tool call blocks from the original text to get the assistant's prose.
-        plain_text = re.sub(r"<tool_call>\s*(.*?)(?:</tool_call>|\Z)", "", text, flags=re.DOTALL | re.IGNORECASE)
+        plain_text = re.sub(r"<tool_call[^>]*>\s*(.*?)(?:</tool_call>|\Z)", "", text, flags=re.DOTALL | re.IGNORECASE)
         plain_text = plain_text.strip()
         
         return plain_text, tool_calls

{nimcode-0.8.3 → nimcode-0.8.4}/src/nimcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nimcode
-Version: 0.8.3
+Version: 0.8.4
 Summary: A standalone, robust coding agent for NVIDIA NIM models.
 Home-page: https://github.com/Batunash/nimcode
 Author: Autonomous Agent

{nimcode-0.8.3 → nimcode-0.8.4}/tests/test_lenient_parser.py

@@ -5,7 +5,7 @@ def test_extract_tool_calls_clean():
     text = "Here is my tool call:\n<tool_call>\n{\"tool\": \"Read\", \"args\": {}}\n</tool_call>\nAnd some prose."
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\", \"args\": {}}"
+    assert calls[0] == ("", "{\"tool\": \"Read\", \"args\": {}}")
 
 def test_repair_truncated_json():
     # Test unclosed quote
@@ -19,19 +19,19 @@ def test_extract_tool_calls_unclosed():
     text = "Here is my tool call:\n<tool_call>\n{\"tool\": \"Read\"}"
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\"}"
+    assert calls[0] == ("", "{\"tool\": \"Read\"}")
 
 def test_extract_tool_calls_markdown_wrapped():
     text = "<tool_call>\n```json\n{\"tool\": \"Read\"}\n```\n</tool_call>"
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\"}"
+    assert calls[0] == ("", "{\"tool\": \"Read\"}")
 
 def test_extract_tool_calls_markdown_wrapped_no_lang():
     text = "<tool_call>\n```\n{\"tool\": \"Read\"}\n```\n</tool_call>"
     calls = LenientParser.extract_tool_calls(text)
     assert len(calls) == 1
-    assert calls[0] == "{\"tool\": \"Read\"}"
+    assert calls[0] == ("", "{\"tool\": \"Read\"}")
 
 def test_repair_trailing_comma():
     bad_json = '{"tool": "Read", "args": {"file": "a.txt",},}'
@@ -65,3 +65,18 @@ def test_process_model_response_raises_on_invalid():
     text = "<tool_call>\n{invalid}\n</tool_call>"
     with pytest.raises(ValueError, match="Malformed tool call JSON"):
         LenientParser.process_model_response(text)
+
+def test_extract_tool_calls_with_name_attr():
+    text = "Here is DeepSeek output:\n<tool_call name=\"Read\">\n{\"file_path\": \"a.txt\"}\n</tool_call>"
+    calls = LenientParser.extract_tool_calls(text)
+    assert len(calls) == 1
+    assert calls[0] == ("Read", "{\"file_path\": \"a.txt\"}")
+
+def test_process_model_response_deepseek_format():
+    text = "Thinking... <tool_call name=\"Write\">\n{\"file_path\": \"a.txt\", \"content\": \"hello\"}\n</tool_call>"
+    prose, calls = LenientParser.process_model_response(text)
+    assert prose == "Thinking..."
+    assert len(calls) == 1
+    assert calls[0]["tool"] == "Write"
+    assert calls[0]["args"]["file_path"] == "a.txt"
+    assert calls[0]["args"]["content"] == "hello"

nimcode-0.8.3/src/nimcode/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.8.3"