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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.15
+Version: 0.2.20
 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.20}/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.20}/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.20}/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.20}/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.20}/omnimancer/providers/base.py

@@ -6,6 +6,8 @@ to ensure consistent behavior across different AI services.
 """
 
 import json
+import logging
+import os
 from abc import ABC, abstractmethod
 from typing import Any, AsyncIterator, Dict, List, Union
 
@@ -19,6 +21,8 @@ from ..core.models import (
     ToolDefinition,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class BaseProvider(ABC):
     """
@@ -28,6 +32,32 @@ class BaseProvider(ABC):
     the required abstract methods to ensure consistent behavior.
     """
 
+    # Default chat-completion timeout. Large models on serverless backends
+    # (e.g. 300B+ models on DigitalOcean inference) can take well over a
+    # minute to first byte with tool-heavy agent prompts — hardcoded 30s/60s
+    # timeouts made those models unusable in headless runs.
+    DEFAULT_REQUEST_TIMEOUT = 120.0
+
+    @classmethod
+    def _resolve_request_timeout(cls, configured: Any) -> float:
+        """
+        Resolve the chat-completion timeout: explicit config wins, then the
+        OMNIMANCER_REQUEST_TIMEOUT environment variable, then the default.
+        Invalid or non-positive values fall back to the default.
+        """
+        for raw in (configured, os.environ.get("OMNIMANCER_REQUEST_TIMEOUT")):
+            if raw is None or raw == "":
+                continue
+            try:
+                value = float(raw)
+            except (TypeError, ValueError):
+                logger.warning("Ignoring invalid request timeout %r", raw)
+                continue
+            if value > 0:
+                return value
+            logger.warning("Ignoring non-positive request timeout %r", raw)
+        return cls.DEFAULT_REQUEST_TIMEOUT
+
     def __init__(self, api_key: str, model: str, **kwargs: Any) -> None:
         """
         Initialize the provider.

{omnimancer_cli-0.2.15 → omnimancer_cli-0.2.20}/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.20}/omnimancer/providers/openai.py

@@ -57,13 +57,18 @@ class OpenAIProvider(BaseProvider):
         Args:
             api_key: OpenAI API key
             model: OpenAI model to use (e.g., 'gpt-4', 'gpt-4o', 'gpt-3.5-turbo')
-            **kwargs: Additional configuration
+            **kwargs: Additional configuration. Supports ``request_timeout``
+                (seconds) for chat completions; the ``OMNIMANCER_REQUEST_TIMEOUT``
+                environment variable is used when the kwarg is not given.
         """
         super().__init__(api_key, model or "gpt-4", **kwargs)
         # Allow overriding the API endpoint for OpenAI-compatible services
         self.base_url = (kwargs.get("base_url") or self.BASE_URL).rstrip("/")
         self.max_tokens = kwargs.get("max_tokens", 4096)
         self.temperature = kwargs.get("temperature", 0.7)
+        self.request_timeout = self._resolve_request_timeout(
+            kwargs.get("request_timeout")
+        )
 
     async def send_message(self, message: str, context: ChatContext) -> ChatResponse:
         """
@@ -88,7 +93,7 @@ class OpenAIProvider(BaseProvider):
                     "max_tokens": self.max_tokens,
                     "temperature": self.temperature,
                 },
-                timeout=30.0,
+                timeout=self.request_timeout,
             )
 
             # Handle response
@@ -249,6 +254,19 @@ class OpenAIProvider(BaseProvider):
             provider=provider,
         )
 
+    async def _post_once(self, body: Dict[str, Any], timeout: float) -> httpx.Response:
+        """Single POST to the chat completions endpoint."""
+        async with httpx.AsyncClient() as client:
+            return await client.post(
+                f"{self.base_url}/chat/completions",
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self.api_key}",
+                },
+                json=body,
+                timeout=timeout,
+            )
+
     async def _post_chat(
         self, request_body: Dict[str, Any], timeout: float
     ) -> httpx.Response:
@@ -264,16 +282,18 @@ class OpenAIProvider(BaseProvider):
         self._require_api_key()
 
         async def _do_post(body: Dict[str, Any]) -> httpx.Response:
-            async with httpx.AsyncClient() as client:
-                return await client.post(
-                    f"{self.base_url}/chat/completions",
-                    headers={
-                        "Content-Type": "application/json",
-                        "Authorization": f"Bearer {self.api_key}",
-                    },
-                    json=body,
-                    timeout=timeout,
+            # Serverless backends (notably DigitalOcean inference) sporadically
+            # time out on an otherwise-fine request; one retry absorbs those
+            # transient stalls instead of failing the whole agent run.
+            try:
+                return await self._post_once(body, timeout)
+            except httpx.TimeoutException:
+                logger.warning(
+                    "%s chat completion timed out after %.0fs — retrying once",
+                    self.PROVIDER_LABEL,
+                    timeout,
                 )
+                return await self._post_once(body, timeout)
 
         body = request_body
         response = await _do_post(body)
@@ -332,7 +352,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(
@@ -413,7 +434,7 @@ class OpenAIProvider(BaseProvider):
             if tools:
                 request_body["tools"] = tools
 
-            response = await self._post_chat(request_body, timeout=60.0)
+            response = await self._post_chat(request_body, timeout=self.request_timeout)
 
             return self._handle_response_with_tools(response)
 
@@ -462,18 +483,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.20}/omnimancer/providers/openrouter.py

@@ -67,6 +67,9 @@ class OpenRouterProvider(BaseProvider):
         self.top_p = kwargs.get("top_p", 1.0)
         self.frequency_penalty = kwargs.get("frequency_penalty", 0.0)
         self.presence_penalty = kwargs.get("presence_penalty", 0.0)
+        self.request_timeout = self._resolve_request_timeout(
+            kwargs.get("request_timeout")
+        )
 
         # Cost optimization settings
         self.enable_fallback = kwargs.get("enable_fallback", True)
@@ -115,7 +118,7 @@ class OpenRouterProvider(BaseProvider):
                         f"{self.base_url}/chat/completions",
                         headers=self._get_headers(),
                         json=payload,
-                        timeout=30.0,
+                        timeout=self.request_timeout,
                     )
 
                 # If we get here, the request succeeded
@@ -201,7 +204,7 @@ class OpenRouterProvider(BaseProvider):
                         f"{self.base_url}/chat/completions",
                         headers=self._get_headers(),
                         json=payload,
-                        timeout=30.0,
+                        timeout=self.request_timeout,
                     )
 
                 # If we get here, the request succeeded
@@ -377,7 +380,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 +451,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.20}/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.20/omnimancer_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.15
+Version: 0.2.20
 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.20}/omnimancer_cli.egg-info/SOURCES.txt

@@ -132,6 +132,7 @@ tests/test_models.py
 tests/test_ollama_provider.py
 tests/test_openai_context_fit.py
 tests/test_openai_provider_tools.py
+tests/test_openai_request_timeout.py
 tests/test_openrouter_provider.py
 tests/test_permission_rules.py
 tests/test_perplexity_provider.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnimancer-cli"
-version = "0.2.15"
+version = "0.2.20"
 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.20}/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]"