omnimancer-cli 0.3.1__tar.gz → 0.3.3__tar.gz

{omnimancer_cli-0.3.1 → omnimancer_cli-0.3.3}/PKG-INFO

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

{omnimancer_cli-0.3.1 → omnimancer_cli-0.3.3}/omnimancer/core/agent/web_client.py

@@ -16,7 +16,7 @@ from urllib.parse import urljoin, urlparse
 
 import aiohttp
 import html2text
-from bs4 import BeautifulSoup
+from bs4 import BeautifulSoup, Tag
 from readability import Document
 
 from ..security import SecurityManager
@@ -668,6 +668,9 @@ class WebClient:
         # Extract links
         links: List[Dict[str, str]] = []
         for link in soup.find_all("a", href=True):
+            # bs4>=4.13 types find_all() as PageElement | Tag | NavigableString
+            if not isinstance(link, Tag):
+                continue
             href = str(link["href"])
             text = link.get_text().strip()
             if href and text:
@@ -677,6 +680,8 @@ class WebClient:
         # Extract images
         images: List[Dict[str, str]] = []
         for img in soup.find_all("img", src=True):
+            if not isinstance(img, Tag):
+                continue
             src = str(img["src"])
             alt_attr = img.get("alt", "")
             alt = str(alt_attr).strip() if alt_attr else ""

{omnimancer_cli-0.3.1 → omnimancer_cli-0.3.3}/omnimancer/providers/bedrock.py

@@ -8,7 +8,7 @@ API key authentication, and region configuration.
 
 import json
 from datetime import datetime
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 import httpx
 
@@ -70,10 +70,13 @@ class BedrockProvider(BaseProvider):
         # AWS-specific configuration
         self.aws_region = kwargs.get("aws_region", "us-east-1")
 
-        # Standard parameters
+        # Standard parameters. Bedrock fronts third-party models that reject
+        # temperature/topP in inferenceConfig outright, and nothing in
+        # Omnimancer lets a user pick these values, so an unset param stays
+        # None and is omitted rather than defaulted into every request.
         self.max_tokens = kwargs.get("max_tokens", 4096)
-        self.temperature = kwargs.get("temperature", 0.7)
-        self.top_p = kwargs.get("top_p", 1.0)
+        self.temperature = kwargs.get("temperature")
+        self.top_p = kwargs.get("top_p")
         self.top_k = kwargs.get("top_k", 250)
 
         # Build base URL for Bedrock API key authentication
@@ -258,7 +261,7 @@ class BedrockProvider(BaseProvider):
             # Test the specific model with a minimal request
             test_request = {
                 "messages": [{"role": "user", "content": [{"text": "Hi"}]}],
-                "inferenceConfig": {"maxTokens": 10, "temperature": 0.1},
+                "inferenceConfig": self._build_inference_config(max_tokens=10),
             }
 
             # If using ARN format, include the model ARN in the request
@@ -373,6 +376,23 @@ class BedrockProvider(BaseProvider):
                 "message": f"Failed to test model: {str(e)}",
             }
 
+    def _build_inference_config(
+        self, max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """Build inferenceConfig, omitting sampling params that are unset.
+
+        Converse raises a ValidationException for any inference field the
+        target model does not accept, so only configured values are sent.
+        """
+        inference: Dict[str, Any] = {
+            "maxTokens": max_tokens if max_tokens is not None else self.max_tokens
+        }
+        if self.temperature is not None:
+            inference["temperature"] = self.temperature
+        if self.top_p is not None:
+            inference["topP"] = self.top_p
+        return inference
+
     # Converse prompt caching is model-gated: sending a cachePoint to an
     # unsupported model is a hard ValidationException, so only inject for
     # families AWS documents as supported.
@@ -429,11 +449,7 @@ class BedrockProvider(BaseProvider):
 
         request_data = {
             "messages": messages,
-            "inferenceConfig": {
-                "maxTokens": self.max_tokens,
-                "temperature": self.temperature,
-                "topP": self.top_p,
-            },
+            "inferenceConfig": self._build_inference_config(),
         }
 
         # If using ARN format, include the model ARN in the request
@@ -470,11 +486,7 @@ class BedrockProvider(BaseProvider):
 
         request_data = {
             "messages": messages,
-            "inferenceConfig": {
-                "maxTokens": self.max_tokens,
-                "temperature": self.temperature,
-                "topP": self.top_p,
-            },
+            "inferenceConfig": self._build_inference_config(),
         }
 
         # Add tools in Bedrock Converse format
@@ -488,18 +500,26 @@ class BedrockProvider(BaseProvider):
 
     def _convert_tool_to_bedrock_format(self, tool: ToolDefinition) -> Dict:
         """
-        Convert tool definition to Bedrock format.
+        Convert tool definition to Bedrock Converse format.
+
+        Converse requires every entry in ``toolConfig.tools`` to set one of
+        toolSpec, systemTool, modelTool or cachePoint, and it nests the JSON
+        Schema under ``inputSchema.json``. Sending the Anthropic Messages
+        shape (name/description/input_schema at the top level) is a hard
+        ValidationException on toolConfig.tool.0.
 
         Args:
             tool: Tool definition
 
         Returns:
-            Tool formatted for Bedrock API
+            Tool formatted for the Bedrock Converse API
         """
         return {
-            "name": tool.name,
-            "description": tool.description,
-            "input_schema": tool.parameters,
+            "toolSpec": {
+                "name": tool.name,
+                "description": tool.description,
+                "inputSchema": {"json": tool.parameters},
+            }
         }
 
     def _handle_response(self, response: httpx.Response) -> ChatResponse:
@@ -587,14 +607,19 @@ class BedrockProvider(BaseProvider):
                 text_content = ""
                 tool_calls = []
 
+                # Converse tags content blocks by key, not by a "type"
+                # field: text is {"text": ...} and a call is
+                # {"toolUse": {"toolUseId", "name", "input"}}.
                 for block in content_blocks:
-                    if block.get("type") == "text":
-                        text_content += block.get("text", "")
-                    elif block.get("type") == "toolUse":
+                    if "text" in block:
+                        text_content += block.get("text") or ""
+                    elif "toolUse" in block:
+                        tool_use = block.get("toolUse") or {}
                         tool_calls.append(
                             ToolCall(
-                                name=block.get("name", ""),
-                                arguments=block.get("input", {}),
+                                name=tool_use.get("name", ""),
+                                arguments=tool_use.get("input") or {},
+                                id=tool_use.get("toolUseId"),
                             )
                         )
 

{omnimancer_cli-0.3.1 → omnimancer_cli-0.3.3}/omnimancer_cli.egg-info/PKG-INFO

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

{omnimancer_cli-0.3.1 → omnimancer_cli-0.3.3}/pyproject.toml

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

{omnimancer_cli-0.3.1 → omnimancer_cli-0.3.3}/tests/test_bedrock_provider.py

@@ -158,17 +158,24 @@ def mock_converse_response():
 
 @pytest.fixture
 def mock_tool_response():
-    """Create a mock Bedrock Converse API response with tool use."""
+    """Create a mock Bedrock Converse API response with tool use.
+
+    Converse identifies content blocks by key, not by a ``type`` field:
+    a text block is ``{"text": ...}`` and a tool call is
+    ``{"toolUse": {"toolUseId", "name", "input"}}``.
+    """
     return {
         "output": {
             "message": {
                 "role": "assistant",
                 "content": [
-                    {"type": "text", "text": "I will query the database."},
+                    {"text": "I will query the database."},
                     {
-                        "type": "toolUse",
-                        "name": "query_database",
-                        "input": {"sql": "SELECT * FROM users LIMIT 10"},
+                        "toolUse": {
+                            "toolUseId": "tooluse_abc123",
+                            "name": "query_database",
+                            "input": {"sql": "SELECT * FROM users LIMIT 10"},
+                        }
                     },
                 ],
             }
@@ -211,12 +218,20 @@ class TestBedrockProviderInitialization:
         assert "eu-west-1" in provider.base_url
 
     def test_initialization_default_generation_params(self, bedrock_provider):
-        """Test default generation parameter values."""
+        """Unset sampling params stay None so the model's defaults apply."""
         assert bedrock_provider.max_tokens == 4096
-        assert bedrock_provider.temperature == 0.7
-        assert bedrock_provider.top_p == 1.0
+        assert bedrock_provider.temperature is None
+        assert bedrock_provider.top_p is None
         assert bedrock_provider.top_k == 250
 
+    def test_initialization_explicit_generation_params(self):
+        """Explicitly configured sampling params are kept."""
+        provider = BedrockProvider(
+            api_key="key", model=_SONNET_MODEL, temperature=0.2, top_p=0.9
+        )
+        assert provider.temperature == 0.2
+        assert provider.top_p == 0.9
+
     def test_initialization_missing_api_key_raises_error(self):
         """Test that missing api_key raises ValueError."""
         with pytest.raises(ValueError, match="API key is required"):
@@ -281,7 +296,59 @@ class TestBedrockProviderRequestPreparation:
 
         assert "inferenceConfig" in body
         assert body["inferenceConfig"]["maxTokens"] == bedrock_provider.max_tokens
-        assert body["inferenceConfig"]["temperature"] == bedrock_provider.temperature
+
+    def test_unset_sampling_params_are_omitted_from_inference_config(
+        self, bedrock_provider, sample_chat_context, sample_tools
+    ):
+        """Bedrock hosts models that reject temperature/topP outright.
+
+        Nothing in Omnimancer lets a user choose these values, so an
+        unconfigured provider must not send them and trigger a
+        ValidationException on models that do not accept them.
+        """
+        for body_str in (
+            bedrock_provider._prepare_bedrock_request("Hello", sample_chat_context),
+            bedrock_provider._prepare_bedrock_request_with_tools(
+                "Hello", sample_chat_context, sample_tools
+            ),
+        ):
+            inference = json.loads(body_str)["inferenceConfig"]
+            assert "temperature" not in inference
+            assert "topP" not in inference
+            assert inference["maxTokens"] == bedrock_provider.max_tokens
+
+    def test_configured_sampling_params_are_sent(
+        self, sample_chat_context, sample_tools
+    ):
+        """A user who configures temperature/top_p still gets them sent."""
+        provider = BedrockProvider(
+            api_key="key", model=_SONNET_MODEL, temperature=0.2, top_p=0.9
+        )
+
+        for body_str in (
+            provider._prepare_bedrock_request("Hello", sample_chat_context),
+            provider._prepare_bedrock_request_with_tools(
+                "Hello", sample_chat_context, sample_tools
+            ),
+        ):
+            inference = json.loads(body_str)["inferenceConfig"]
+            assert inference["temperature"] == 0.2
+            assert inference["topP"] == 0.9
+
+    @pytest.mark.asyncio
+    async def test_validate_model_access_omits_temperature(self, bedrock_provider):
+        """The model-access probe must not send temperature either."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+
+        with patch("httpx.AsyncClient") as mock_client:
+            mock_post = AsyncMock(return_value=mock_response)
+            mock_client.return_value.__aenter__.return_value.post = mock_post
+
+            await bedrock_provider.validate_model_access()
+
+            sent = json.loads(mock_post.call_args.kwargs["content"])
+            assert "temperature" not in sent["inferenceConfig"]
 
     def test_prepare_request_standard_model_has_no_model_id_field(
         self, bedrock_provider, sample_chat_context
@@ -320,13 +387,33 @@ class TestBedrockProviderRequestPreparation:
         assert len(body["toolConfig"]["tools"]) == 2
 
     def test_convert_tool_to_bedrock_format(self, bedrock_provider, sample_tools):
-        """Test tool conversion to Bedrock format."""
+        """Tools are converted to the Converse toolSpec shape."""
         tool = sample_tools[0]
         bedrock_tool = bedrock_provider._convert_tool_to_bedrock_format(tool)
 
-        assert bedrock_tool["name"] == "query_database"
-        assert bedrock_tool["description"] == "Run a query against the database"
-        assert "input_schema" in bedrock_tool
+        assert set(bedrock_tool) == {"toolSpec"}
+        spec = bedrock_tool["toolSpec"]
+        assert spec["name"] == "query_database"
+        assert spec["description"] == "Run a query against the database"
+        # Converse nests the JSON Schema under inputSchema.json.
+        assert spec["inputSchema"] == {"json": tool.parameters}
+
+    def test_every_tool_entry_is_wrapped_in_toolspec(
+        self, bedrock_provider, sample_chat_context, sample_tools
+    ):
+        """Reproduces the Converse ValidationException on toolConfig.tool.0.
+
+        Converse rejects any entry in ``toolConfig.tools`` that does not set
+        one of toolSpec, systemTool, modelTool or cachePoint.
+        """
+        body_str = bedrock_provider._prepare_bedrock_request_with_tools(
+            "Query the DB", sample_chat_context, sample_tools
+        )
+        body = json.loads(body_str)
+
+        allowed = {"toolSpec", "systemTool", "modelTool", "cachePoint"}
+        for entry in body["toolConfig"]["tools"]:
+            assert allowed & set(entry), f"invalid tool entry: {entry}"
 
 
 # ---------------------------------------------------------------------------
@@ -560,6 +647,39 @@ class TestBedrockProviderToolCalling:
             assert response.tool_calls is not None
             assert len(response.tool_calls) == 1
             assert response.tool_calls[0].name == "query_database"
+            assert response.tool_calls[0].arguments == {
+                "sql": "SELECT * FROM users LIMIT 10"
+            }
+            assert response.tool_calls[0].id == "tooluse_abc123"
+
+    @pytest.mark.asyncio
+    async def test_text_only_converse_response_still_parsed_with_tools(
+        self, bedrock_provider, sample_chat_context, sample_tools
+    ):
+        """A tools request answered with text only yields content, no calls."""
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "output": {
+                "message": {
+                    "role": "assistant",
+                    "content": [{"text": "No query needed."}],
+                }
+            },
+            "usage": {"inputTokens": 7, "outputTokens": 4},
+        }
+
+        with patch("httpx.AsyncClient") as mock_client:
+            mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+                return_value=mock_response
+            )
+
+            response = await bedrock_provider.send_message_with_tools(
+                "Say hi", sample_chat_context, sample_tools
+            )
+
+            assert response.content == "No query needed."
+            assert response.tool_calls is None
 
     @pytest.mark.asyncio
     async def test_send_message_with_tools_authentication_error(