omnimancer-cli 0.2.15__tar.gz → 0.2.19__tar.gz

{omnimancer_cli-0.2.15/omnimancer_cli.egg-info → omnimancer_cli-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.15
+Version: 0.2.19
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/cli/tool_handler.py

@@ -150,6 +150,18 @@ class ToolHandler:
         return list(CODING_AGENT_TOOLS)
 
     async def execute_tool_call(self, tool_call: ToolCall) -> ToolResult:
+        # ToolCall normalizes JSON-string arguments on construction; anything
+        # still not a dict here is malformed — tell the model instead of
+        # crashing on args.get(...) inside a handler.
+        if not isinstance(tool_call.arguments, dict):
+            return ToolResult(
+                content="",
+                error=(
+                    f"Malformed arguments for {tool_call.name}: expected a "
+                    f"JSON object, got: {str(tool_call.arguments)[:200]}. "
+                    "Re-issue the call with the parameters as a JSON object."
+                ),
+            )
         try:
             # Read and Edit need post-processing / multi-step logic.
             if tool_call.name in _EDIT_TOOLS:

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/core/agent/file_system_manager.py

@@ -250,14 +250,51 @@ class FileSystemManager:
         """
         Simple boolean check for file existence.
 
+        Performs a lightweight path-validation check followed by an async
+        filesystem probe.  Unlike :meth:`check_file_exists`, this method does
+        *not* invoke the full security-audit pipeline (permission logging, risk
+        assessment, approval workflow).  It is intended for high-frequency
+        callers (e.g. batch operations) that need a fast boolean answer.
+
+        .. warning::
+            This method enforces path-level access controls — hard-restricted
+            system paths (``/etc``, ``~/.ssh``, cloud-credential stores, etc.)
+            and sensitive-name patterns are still blocked via
+            :meth:`~omnimancer.core.security.permission_controller.PermissionController.validate_path_access`.
+            However, it skips the per-operation audit-log entries produced by
+            :meth:`~omnimancer.core.security.SecurityManager.secure_file_access`.
+            Do not use this method where per-access audit trails are required.
+
         Args:
-            path: Path to check for existence
+            path: Path to check for existence.
 
         Returns:
-            True if file exists and is accessible, False otherwise
+            True if the path passes security validation and exists on the
+            filesystem; False if the path is security-denied or does not exist.
         """
-        result = await self.check_file_exists(path)
-        return result["exists"] and result["error"] is None
+        try:
+            resolved = Path(path).resolve()
+        except (OSError, ValueError) as e:
+            logger.warning("file_exists: invalid path %r: %s", path, e)
+            return False
+
+        # Validate path against security policy without invoking the expensive
+        # audit pipeline.  This blocks hard-restricted system paths and
+        # sensitive-name patterns (e.g. /etc, ~/.ssh, *.db) the same way the
+        # full pipeline would.
+        if not self.security.permissions.validate_path_access(str(resolved), "read"):
+            logger.warning(
+                "file_exists: access denied by security policy for %s", resolved
+            )
+            return False
+
+        try:
+            exists = bool(await aiofiles.os.path.exists(resolved))
+            logger.debug("file_exists: %s → %s", resolved, exists)
+            return exists
+        except OSError as e:
+            logger.warning("file_exists: OS error checking %s: %s", resolved, e)
+            return False
 
     async def write_file_with_confirmation(
         self,

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/core/models.py

@@ -113,6 +113,29 @@ class ToolCall:
     # Provider-assigned call id (OpenAI protocol pairs results to calls by id).
     id: Optional[str] = None
 
+    def __post_init__(self) -> None:
+        """Normalize arguments that arrive as a JSON-encoded string.
+
+        OpenAI-protocol servers send ``function.arguments`` as a JSON string,
+        and some models double-encode it. A value that doesn't decode to an
+        object is left as-is so the tool handler can report it to the model.
+        """
+        import json
+
+        if self.arguments is None:
+            self.arguments = {}
+            return
+        decoded: Any = self.arguments
+        for _ in range(2):
+            if not isinstance(decoded, str):
+                break
+            try:
+                decoded = json.loads(decoded)
+            except ValueError:
+                return
+        if isinstance(decoded, dict):
+            self.arguments = decoded
+
 
 @dataclass
 class ToolResultRecord:

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/providers/azure.py

@@ -363,19 +363,23 @@ class AzureProvider(BaseProvider):
 
             if choices and len(choices) > 0:
                 message = choices[0].get("message", {})
-                content = message.get("content", "")
+                # Tool-call responses carry "content": null — coalesce to "".
+                content = message.get("content") or ""
                 usage = data.get("usage", {})
 
-                # Extract tool calls if present
+                # Extract tool calls if present. The wire protocol sends
+                # function.arguments as a JSON string; ToolCall normalizes
+                # it to a dict on construction.
                 tool_calls = []
                 if "tool_calls" in message:
-                    for tool_call in message["tool_calls"]:
+                    for i, tool_call in enumerate(message["tool_calls"]):
                         if tool_call.get("type") == "function":
                             function = tool_call.get("function", {})
                             tool_calls.append(
                                 ToolCall(
                                     name=function.get("name", ""),
                                     arguments=function.get("arguments", {}),
+                                    id=tool_call.get("id") or f"call_{i}",
                                 )
                             )
 

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/providers/mistral.py

@@ -324,19 +324,23 @@ class MistralProvider(BaseProvider):
 
             if choices and len(choices) > 0:
                 message = choices[0].get("message", {})
-                content = message.get("content", "")
+                # Tool-call responses carry "content": null — coalesce to "".
+                content = message.get("content") or ""
                 usage = data.get("usage", {})
 
-                # Extract tool calls if present
+                # Extract tool calls if present. The wire protocol sends
+                # function.arguments as a JSON string; ToolCall normalizes
+                # it to a dict on construction.
                 tool_calls = []
                 if "tool_calls" in message:
-                    for tool_call in message["tool_calls"]:
+                    for i, tool_call in enumerate(message["tool_calls"]):
                         if tool_call.get("type") == "function":
                             function = tool_call.get("function", {})
                             tool_calls.append(
                                 ToolCall(
                                     name=function.get("name", ""),
                                     arguments=function.get("arguments", {}),
+                                    id=tool_call.get("id") or f"call_{i}",
                                 )
                             )
 

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/providers/openai.py

@@ -332,7 +332,8 @@ class OpenAIProvider(BaseProvider):
 
             if choices and len(choices) > 0:
                 message = choices[0].get("message", {})
-                content = message.get("content", "")
+                # Tool-call responses carry "content": null — coalesce to "".
+                content = message.get("content") or ""
                 usage = data.get("usage", {})
 
                 return ChatResponse(
@@ -462,18 +463,16 @@ class OpenAIProvider(BaseProvider):
                 tool_calls = None
                 raw_tool_calls = msg.get("tool_calls")
                 if raw_tool_calls:
-                    import json
-
                     tool_calls = []
                     for i, tc in enumerate(raw_tool_calls):
                         func = tc.get("function", {})
-                        args = func.get("arguments", "{}")
-                        if isinstance(args, str):
-                            args = json.loads(args)
                         tool_calls.append(
                             ToolCall(
+                                # ToolCall normalizes JSON-string arguments
+                                # (including double-encoded ones) on
+                                # construction.
                                 name=func.get("name", ""),
-                                arguments=args,
+                                arguments=func.get("arguments", {}),
                                 # Some OpenAI-compatible servers omit ids;
                                 # synthesize one so results can pair to calls.
                                 id=tc.get("id") or f"call_{i}",

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/providers/openrouter.py

@@ -377,7 +377,9 @@ class OpenRouterProvider(BaseProvider):
 
             if choices and len(choices) > 0:
                 message = choices[0].get("message", {})
-                content = message.get("content", "")
+                # Tool-call responses carry "content": null — coalesce to ""
+                # so the fallback-warning concatenation below can't TypeError.
+                content = message.get("content") or ""
                 usage = data.get("usage", {})
 
                 # Extract model used (OpenRouter may route to different models)
@@ -446,19 +448,24 @@ class OpenRouterProvider(BaseProvider):
 
             if choices and len(choices) > 0:
                 message = choices[0].get("message", {})
-                content = message.get("content", "")
+                # Tool-call responses carry "content": null — coalesce to ""
+                # so the fallback-warning concatenation below can't TypeError.
+                content = message.get("content") or ""
                 usage = data.get("usage", {})
 
-                # Extract tool calls if present
+                # Extract tool calls if present. The wire protocol sends
+                # function.arguments as a JSON string; ToolCall normalizes
+                # it to a dict on construction.
                 tool_calls = []
                 if "tool_calls" in message:
-                    for tool_call in message["tool_calls"]:
+                    for i, tool_call in enumerate(message["tool_calls"]):
                         if tool_call.get("type") == "function":
                             function = tool_call.get("function", {})
                             tool_calls.append(
                                 ToolCall(
                                     name=function.get("name", ""),
                                     arguments=function.get("arguments", {}),
+                                    id=tool_call.get("id") or f"call_{i}",
                                 )
                             )
 

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/omnimancer/providers/xai.py

@@ -327,19 +327,23 @@ class XAIProvider(BaseProvider):
 
             if choices and len(choices) > 0:
                 message = choices[0].get("message", {})
-                content = message.get("content", "")
+                # Tool-call responses carry "content": null — coalesce to "".
+                content = message.get("content") or ""
                 usage = data.get("usage", {})
 
-                # Extract tool calls if present
+                # Extract tool calls if present. The wire protocol sends
+                # function.arguments as a JSON string; ToolCall normalizes
+                # it to a dict on construction.
                 tool_calls = []
                 if "tool_calls" in message:
-                    for tool_call in message["tool_calls"]:
+                    for i, tool_call in enumerate(message["tool_calls"]):
                         if tool_call.get("type") == "function":
                             function = tool_call.get("function", {})
                             tool_calls.append(
                                 ToolCall(
                                     name=function.get("name", ""),
                                     arguments=function.get("arguments", {}),
+                                    id=tool_call.get("id") or f"call_{i}",
                                 )
                             )
 

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19/omnimancer_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.15
+Version: 0.2.19
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnimancer-cli"
-version = "0.2.15"
+version = "0.2.19"
 description = "A unified command-line interface for multiple AI language models"
 readme = "README.md"
 requires-python = ">=3.10"

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/tests/test_models.py

@@ -591,68 +591,117 @@ class TestStreamEvent:
 
         event = StreamEvent(type=StreamEventType.ERROR, error="Connection lost")
         assert event.error == "Connection lost"
-
-
-class TestParseDescribedToolCalls:
-    """parse_described_tool_calls recovers calls a model emitted as text.
-
-    Weak models mimic the "[Called tools: ...]" history notation instead of
-    issuing native tool calls; the parser turns that text back into ToolCall
-    objects so the agent loop can keep going.
-    """
-
-    def test_round_trips_describe_output(self):
-        from omnimancer.core.models import (
-            ToolCall,
-            describe_tool_calls,
-            parse_described_tool_calls,
-        )
-
-        calls = [
-            ToolCall(name="Grep", arguments={"pattern": "auth", "glob": "*.ts"}),
-            ToolCall(name="Read", arguments={"file_path": "/src/main.py"}),
-        ]
-        parsed = parse_described_tool_calls(describe_tool_calls(calls))
-
-        assert [(c.name, c.arguments) for c in parsed] == [
-            (c.name, c.arguments) for c in calls
-        ]
-
-    def test_plain_text_returns_empty(self):
-        from omnimancer.core.models import parse_described_tool_calls
-
-        assert parse_described_tool_calls("The auth flow looks correct.") == []
-        assert parse_described_tool_calls("") == []
-        assert parse_described_tool_calls(None) == []
-
-    def test_nested_json_with_braces_and_commas(self):
-        from omnimancer.core.models import parse_described_tool_calls
-
-        text = (
-            '[Called tools: Grep({"glob": "*.{ts,tsx}", '
-            '"output_mode": "files_with_matches", '
-            '"pattern": "AUTH_SESSION_KEY|automarketer_auth_session"})]'
-        )
-        parsed = parse_described_tool_calls(text)
-
-        assert len(parsed) == 1
-        assert parsed[0].name == "Grep"
-        assert parsed[0].arguments["glob"] == "*.{ts,tsx}"
-
-    def test_marker_embedded_in_other_text(self):
-        from omnimancer.core.models import parse_described_tool_calls
-
-        text = (
-            "Let me search for that.\n"
-            '[Called tools: Bash({"command": "git log --oneline -5"})]'
-        )
-        parsed = parse_described_tool_calls(text)
-
-        assert len(parsed) == 1
-        assert parsed[0].name == "Bash"
-        assert parsed[0].arguments == {"command": "git log --oneline -5"}
-
-    def test_malformed_json_is_skipped(self):
-        from omnimancer.core.models import parse_described_tool_calls
-
-        assert parse_described_tool_calls("[Called tools: Grep({'bad': json})]") == []
+
+
+class TestParseDescribedToolCalls:
+    """parse_described_tool_calls recovers calls a model emitted as text.
+
+    Weak models mimic the "[Called tools: ...]" history notation instead of
+    issuing native tool calls; the parser turns that text back into ToolCall
+    objects so the agent loop can keep going.
+    """
+
+    def test_round_trips_describe_output(self):
+        from omnimancer.core.models import (
+            ToolCall,
+            describe_tool_calls,
+            parse_described_tool_calls,
+        )
+
+        calls = [
+            ToolCall(name="Grep", arguments={"pattern": "auth", "glob": "*.ts"}),
+            ToolCall(name="Read", arguments={"file_path": "/src/main.py"}),
+        ]
+        parsed = parse_described_tool_calls(describe_tool_calls(calls))
+
+        assert [(c.name, c.arguments) for c in parsed] == [
+            (c.name, c.arguments) for c in calls
+        ]
+
+    def test_plain_text_returns_empty(self):
+        from omnimancer.core.models import parse_described_tool_calls
+
+        assert parse_described_tool_calls("The auth flow looks correct.") == []
+        assert parse_described_tool_calls("") == []
+        assert parse_described_tool_calls(None) == []
+
+    def test_nested_json_with_braces_and_commas(self):
+        from omnimancer.core.models import parse_described_tool_calls
+
+        text = (
+            '[Called tools: Grep({"glob": "*.{ts,tsx}", '
+            '"output_mode": "files_with_matches", '
+            '"pattern": "AUTH_SESSION_KEY|automarketer_auth_session"})]'
+        )
+        parsed = parse_described_tool_calls(text)
+
+        assert len(parsed) == 1
+        assert parsed[0].name == "Grep"
+        assert parsed[0].arguments["glob"] == "*.{ts,tsx}"
+
+    def test_marker_embedded_in_other_text(self):
+        from omnimancer.core.models import parse_described_tool_calls
+
+        text = (
+            "Let me search for that.\n"
+            '[Called tools: Bash({"command": "git log --oneline -5"})]'
+        )
+        parsed = parse_described_tool_calls(text)
+
+        assert len(parsed) == 1
+        assert parsed[0].name == "Bash"
+        assert parsed[0].arguments == {"command": "git log --oneline -5"}
+
+    def test_malformed_json_is_skipped(self):
+        from omnimancer.core.models import parse_described_tool_calls
+
+        assert parse_described_tool_calls("[Called tools: Grep({'bad': json})]") == []
+
+
+class TestToolCallArgumentNormalization:
+    """ToolCall normalizes arguments that arrive as JSON-encoded strings.
+
+    OpenAI-protocol servers send function.arguments as a JSON string (and
+    some models double-encode it). Providers that passed the raw value
+    through crashed the tool handler with "'str' object has no attribute
+    'get'".
+    """
+
+    def test_json_string_arguments_become_dict(self):
+        from omnimancer.core.models import ToolCall
+
+        tc = ToolCall(name="Glob", arguments='{"pattern": "**/*.py"}')
+        assert tc.arguments == {"pattern": "**/*.py"}
+
+    def test_double_encoded_arguments_become_dict(self):
+        import json
+
+        from omnimancer.core.models import ToolCall
+
+        double = json.dumps(json.dumps({"pattern": "TODO"}))
+        tc = ToolCall(name="Grep", arguments=double)
+        assert tc.arguments == {"pattern": "TODO"}
+
+    def test_none_arguments_become_empty_dict(self):
+        from omnimancer.core.models import ToolCall
+
+        tc = ToolCall(name="Read", arguments=None)
+        assert tc.arguments == {}
+
+    def test_dict_arguments_unchanged(self):
+        from omnimancer.core.models import ToolCall
+
+        tc = ToolCall(name="Read", arguments={"file_path": "/src/main.py"})
+        assert tc.arguments == {"file_path": "/src/main.py"}
+
+    def test_unparseable_string_left_for_handler_to_report(self):
+        from omnimancer.core.models import ToolCall
+
+        tc = ToolCall(name="Glob", arguments="not json at all")
+        assert tc.arguments == "not json at all"
+
+    def test_non_object_json_left_for_handler_to_report(self):
+        from omnimancer.core.models import ToolCall
+
+        tc = ToolCall(name="Glob", arguments="[1, 2, 3]")
+        assert tc.arguments == "[1, 2, 3]"

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/tests/test_openrouter_provider.py

@@ -613,6 +613,103 @@ class TestOpenRouterProviderToolCalling:
             assert tools[0]["function"]["name"] == "fetch_url"
 
 
+class TestOpenRouterProviderToolResponseParsing:
+    """Parsing of tool-call responses (OpenAI wire protocol)."""
+
+    def test_string_arguments_parsed_to_dict(
+        self, openrouter_provider, mock_tool_response
+    ):
+        """function.arguments arrives as a JSON string — it must reach the
+        tool handler as a dict, not crash it with 'str' has no 'get'."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_tool_response
+
+        response = openrouter_provider._handle_response_with_tools(mock_response)
+
+        assert response.tool_calls[0].arguments == {"url": "https://example.com"}
+
+    def test_tool_call_id_preserved_or_synthesized(self, openrouter_provider):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": "call_abc",
+                                "type": "function",
+                                "function": {"name": "Glob", "arguments": "{}"},
+                            },
+                            {
+                                "type": "function",
+                                "function": {"name": "Grep", "arguments": "{}"},
+                            },
+                        ],
+                    }
+                }
+            ],
+            "model": "anthropic/claude-3.5-sonnet",
+            "usage": {"total_tokens": 10},
+        }
+
+        response = openrouter_provider._handle_response_with_tools(mock_response)
+
+        assert response.tool_calls[0].id == "call_abc"
+        assert response.tool_calls[1].id == "call_1"
+
+    def test_null_content_with_model_fallback_warning(self, openrouter_provider):
+        """Tool-call responses carry content:null; combined with OpenRouter
+        routing to a different model this used to raise TypeError
+        ('can only concatenate str (not "NoneType") to str')."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [
+                            {
+                                "id": "call_1",
+                                "type": "function",
+                                "function": {
+                                    "name": "Glob",
+                                    "arguments": '{"pattern": "*.py"}',
+                                },
+                            }
+                        ],
+                    }
+                }
+            ],
+            "model": "some/other-model",
+            "usage": {"total_tokens": 12},
+        }
+
+        response = openrouter_provider._handle_response_with_tools(mock_response)
+
+        assert "Model Fallback Notice" in response.content
+        assert response.tool_calls[0].arguments == {"pattern": "*.py"}
+
+    def test_null_content_without_tools_fallback_warning(self, openrouter_provider):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "choices": [{"message": {"role": "assistant", "content": None}}],
+            "model": "some/other-model",
+            "usage": {"total_tokens": 3},
+        }
+
+        response = openrouter_provider._handle_response(mock_response)
+
+        assert isinstance(response.content, str)
+        assert "Model Fallback Notice" in response.content
+
+
 # ---------------------------------------------------------------------------
 # TestOpenRouterProviderCredentialValidation
 # ---------------------------------------------------------------------------

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/tests/test_tool_handler.py

@@ -353,6 +353,21 @@ class TestToolHandlerExecution:
 
         assert result.error == "Unknown tool: unknown"
 
+    @pytest.mark.asyncio
+    async def test_non_dict_arguments_return_corrective_error(
+        self, tool_handler, mock_agent_engine
+    ):
+        """A provider that ships unparseable arguments must yield a clear
+        error the model can act on — not "'str' object has no attribute
+        'get'" from inside the handler."""
+        tc = ToolCall(name="Glob", arguments="**/*.py")
+        result = await tool_handler.execute_tool_call(tc)
+
+        assert result.error is not None
+        assert "JSON object" in result.error
+        assert "attribute" not in result.error
+        mock_agent_engine.execute_with_approval.assert_not_called()
+
     @pytest.mark.asyncio
     async def test_execute_multiple_tool_calls(self, tool_handler, mock_agent_engine):
         tool_calls = [

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.19}/tests/test_xai_provider.py

@@ -763,9 +763,11 @@ class TestXAIProviderResponseHandling:
         assert response.tool_calls is not None
         assert len(response.tool_calls) == 1
         assert response.tool_calls[0].name == "web_search"
-        assert '"query": "latest AI developments 2024"' in str(
-            response.tool_calls[0].arguments
-        )
+        # The wire protocol sends arguments as a JSON string; the provider
+        # must deliver them as a dict.
+        assert response.tool_calls[0].arguments == {
+            "query": "latest AI developments 2024"
+        }
 
     def test_handle_response_with_error_json(self, xai_provider):
         """Test handling response with JSON error message."""