cortexhub 0.1.5__tar.gz → 0.1.8__tar.gz

{cortexhub-0.1.5 → cortexhub-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cortexhub
-Version: 0.1.5
+Version: 0.1.8
 Summary: CortexHub Python SDK - Policy-as-Code for AI Agents
 Project-URL: Homepage, https://cortexhub.ai
 Project-URL: Documentation, https://docs.cortexhub.ai

{cortexhub-0.1.5 → cortexhub-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cortexhub"
-version = "0.1.5"
+version = "0.1.8"
 description = "CortexHub Python SDK - Policy-as-Code for AI Agents"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/adapters/claude_agents.py

@@ -94,13 +94,6 @@ class ClaudeAgentsAdapter(ToolAdapter):
                 return
             
             cortex_hub = self.cortex_hub
-            tools = self._discover_tools()
-            if tools:
-                cortex_hub.backend.register_tool_inventory(
-                    agent_id=cortex_hub.agent_id,
-                    framework=self.framework_name,
-                    tools=tools,
-                )
             
             # Store original decorator
             if not hasattr(claude_agent_sdk, _ORIGINAL_TOOL_ATTR):
@@ -123,6 +116,14 @@ class ClaudeAgentsAdapter(ToolAdapter):
                     original_handler = original_decorated.handler
                     tool_name = original_decorated.name
                     tool_description = original_decorated.description
+                    parameters_schema = None
+                    if isinstance(input_schema, dict):
+                        parameters_schema = input_schema
+                    elif hasattr(input_schema, "model_json_schema"):
+                        try:
+                            parameters_schema = input_schema.model_json_schema()
+                        except Exception:
+                            parameters_schema = None
                     
                     @wraps(original_handler)
                     async def governed_handler(args: dict[str, Any]) -> dict[str, Any]:
@@ -131,6 +132,7 @@ class ClaudeAgentsAdapter(ToolAdapter):
                             "name": tool_name,
                             "description": tool_description,
                             "framework": "claude_agents",
+                            "parameters_schema": parameters_schema,
                         }
                         
                         governed_fn = govern_execution(

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/adapters/crewai.py

@@ -70,13 +70,6 @@ class CrewAIAdapter(ToolAdapter):
             from crewai.tools.structured_tool import CrewStructuredTool
             
             cortex_hub = self.cortex_hub
-            tools = self._discover_tools()
-            if tools:
-                cortex_hub.backend.register_tool_inventory(
-                    agent_id=cortex_hub.agent_id,
-                    framework=self.framework_name,
-                    tools=tools,
-                )
 
             # Patch CrewStructuredTool.invoke (primary execution path)
             if not getattr(CrewStructuredTool, _PATCHED_ATTR, False):

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/adapters/langgraph.py

@@ -93,6 +93,7 @@ class LangGraphAdapter(ToolAdapter):
                 """Governed tool invocation."""
                 tool_name = getattr(self, "name", "unknown_tool")
                 tool_description = getattr(self, "description", None)
+                parameters_schema = adapter._extract_parameters_schema(self)
 
                 # Extract args - preserve structure without rewriting
                 if isinstance(input, dict):
@@ -109,6 +110,7 @@ class LangGraphAdapter(ToolAdapter):
                     "name": tool_name,
                     "description": tool_description,
                     "framework": "langgraph",
+                    "parameters_schema": parameters_schema,
                 }
                 governed_fn = govern_execution(
                     tool_fn=lambda *a, **kw: tool_original_invoke(
@@ -411,12 +413,6 @@ class LangGraphAdapter(ToolAdapter):
             name = tool.get("name") or "unknown_tool"
             self._discovered_tools[name] = tool
 
-        self.cortex_hub.backend.register_tool_inventory(
-            agent_id=self.cortex_hub.agent_id,
-            framework=self.framework_name,
-            tools=list(self._discovered_tools.values()),
-        )
-
     def _normalize_tools(self, tools: Any) -> list[dict[str, Any]]:
         """Convert tool objects to inventory payloads."""
         normalized: list[dict[str, Any]] = []

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/adapters/openai_agents.py

@@ -67,13 +67,6 @@ class OpenAIAgentsAdapter(ToolAdapter):
                 return
 
             cortex_hub = self.cortex_hub
-            tools = self._discover_tools()
-            if tools:
-                cortex_hub.backend.register_tool_inventory(
-                    agent_id=cortex_hub.agent_id,
-                    framework=self.framework_name,
-                    tools=tools,
-                )
             
             # Store original function_tool decorator
             if not hasattr(tool_module, _ORIGINAL_FUNCTION_TOOL_ATTR):
@@ -109,6 +102,7 @@ class OpenAIAgentsAdapter(ToolAdapter):
                     original_invoke = tool.on_invoke_tool
                     tool_name = tool.name
                     tool_description = tool.description
+                    parameters_schema = tool.params_json_schema or tool.strict_json_schema
                     
                     async def governed_invoke(ctx, input_json: str) -> Any:
                         """Governed tool invocation."""
@@ -121,6 +115,7 @@ class OpenAIAgentsAdapter(ToolAdapter):
                             "name": tool_name,
                             "description": tool_description,
                             "framework": "openai_agents",
+                            "parameters_schema": parameters_schema,
                         }
                         
                         # Create governed function

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/backend/client.py

@@ -7,7 +7,6 @@ import httpx
 from typing import Any
 from dataclasses import dataclass
 
-from cortexhub.version import __version__
 
 logger = structlog.get_logger(__name__)
 
@@ -92,7 +91,7 @@ class BackendClient:
                 timeout=10.0,
             )
     
-    def validate_api_key(self) -> tuple[bool, SDKConfig | None]:
+    def validate_api_key(self, *, agent_id: str | None = None) -> tuple[bool, SDKConfig | None]:
         """Validate API key with backend and get SDK configuration.
         
         Returns:
@@ -127,7 +126,46 @@ class BackendClient:
                 
                 # Convert policy objects to Cedar string if needed
                 raw_policies = policies_data.get("policies", [])
+                if agent_id:
+                    raw_policies = [
+                        policy for policy in raw_policies if policy.get("agent_id") == agent_id
+                    ]
                 guardrail_configs: dict[str, GuardrailConfig] = {}
+
+                def _merge_guardrail_config(
+                    existing: GuardrailConfig | None,
+                    incoming: GuardrailConfig,
+                ) -> GuardrailConfig:
+                    if not existing:
+                        return incoming
+                    priority = {"block": 3, "redact": 2, "allow": 1}
+                    action = (
+                        incoming.action
+                        if priority.get(incoming.action, 0) > priority.get(existing.action, 0)
+                        else existing.action
+                    )
+                    if existing.pii_types is None or incoming.pii_types is None:
+                        pii_types = None
+                    else:
+                        pii_types = sorted(set(existing.pii_types + incoming.pii_types))
+                    if existing.secret_types is None or incoming.secret_types is None:
+                        secret_types = None
+                    else:
+                        secret_types = sorted(set(existing.secret_types + incoming.secret_types))
+                    custom_patterns = (existing.custom_patterns or []) + (incoming.custom_patterns or [])
+                    if existing.redaction_scope == "both" or incoming.redaction_scope == "both":
+                        redaction_scope = "both"
+                    elif existing.redaction_scope != incoming.redaction_scope:
+                        redaction_scope = "both"
+                    else:
+                        redaction_scope = existing.redaction_scope
+                    return GuardrailConfig(
+                        action=action,
+                        pii_types=pii_types,
+                        secret_types=secret_types,
+                        custom_patterns=custom_patterns,
+                        redaction_scope=redaction_scope,
+                    )
                 
                 if isinstance(raw_policies, list):
                     # Backend returns list of policy objects - extract Cedar code
@@ -171,12 +209,16 @@ class BackendClient:
                                         description=cp.get("description"),
                                         enabled=cp.get("enabled", True),
                                     ))
-                                guardrail_configs["pii"] = GuardrailConfig(
-                                    action=gc.get("action", "redact"),
-                                    pii_types=gc.get("pii_types"),
-                                    custom_patterns=custom_patterns if custom_patterns else None,
-                                    redaction_scope=gc.get("redaction_scope", "both"),
+                                merged = _merge_guardrail_config(
+                                    guardrail_configs.get("pii"),
+                                    GuardrailConfig(
+                                        action=gc.get("action", "redact"),
+                                        pii_types=gc.get("pii_types"),
+                                        custom_patterns=custom_patterns if custom_patterns else None,
+                                        redaction_scope=gc.get("redaction_scope", "both"),
+                                    ),
                                 )
+                                guardrail_configs["pii"] = merged
                             elif "secrets" in policy_key:
                                 custom_patterns = []
                                 raw_patterns = gc.get("custom_patterns") or []
@@ -187,12 +229,16 @@ class BackendClient:
                                         description=cp.get("description"),
                                         enabled=cp.get("enabled", True),
                                     ))
-                                guardrail_configs["secrets"] = GuardrailConfig(
-                                    action=gc.get("action", "redact"),
-                                    secret_types=gc.get("secret_types"),
-                                    custom_patterns=custom_patterns if custom_patterns else None,
-                                    redaction_scope=gc.get("redaction_scope", "both"),
+                                merged = _merge_guardrail_config(
+                                    guardrail_configs.get("secrets"),
+                                    GuardrailConfig(
+                                        action=gc.get("action", "redact"),
+                                        secret_types=gc.get("secret_types"),
+                                        custom_patterns=custom_patterns if custom_patterns else None,
+                                        redaction_scope=gc.get("redaction_scope", "both"),
+                                    ),
                                 )
+                                guardrail_configs["secrets"] = merged
                     policies_str = "\n".join(cedar_parts)
                 else:
                     policies_str = raw_policies or ""
@@ -254,33 +300,6 @@ class BackendClient:
         if self._client:
             self._client.close()
 
-    def register_tool_inventory(
-        self,
-        *,
-        agent_id: str,
-        framework: str,
-        tools: list[dict],
-    ) -> dict[str, Any]:
-        """Register agent tool inventory on init. Overwrites previous."""
-
-        if not self._client:
-            return {"agent_id": agent_id, "tools_count": 0}
-
-        try:
-            response = self._client.post(
-                "/tool-inventory",
-                json={
-                    "agent_id": agent_id,
-                    "framework": framework,
-                    "sdk_version": __version__,
-                    "tools": tools,
-                },
-            )
-            return response.json()
-        except Exception as e:
-            logger.warning("Failed to register tool inventory", error=str(e))
-            return {"agent_id": agent_id, "tools_count": len(tools)}
-
     def create_approval(
         self,
         *,

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/client.py

@@ -159,7 +159,7 @@ class CortexHub:
 
         # Validate API key and get configuration (including policies)
         self.backend = BackendClient(self.api_key, self.api_base_url)
-        is_valid, sdk_config = self.backend.validate_api_key()
+        is_valid, sdk_config = self.backend.validate_api_key(agent_id=self.agent_id)
         
         if not is_valid:
             raise ConfigurationError(
@@ -439,6 +439,7 @@ class CortexHub:
         framework: str,
         call_original: Callable[[], Any],
         tool_description: str | None = None,
+        parameters_schema: dict[str, Any] | None = None,
         principal: Principal | dict[str, str] | None = None,
         resource_type: str = "Tool",
     ) -> Any:
@@ -475,6 +476,10 @@ class CortexHub:
             PolicyViolationError: If policy denies
             ApprovalDeniedError: If approval denied
         """
+        expected_types = self._extract_expected_arg_types(parameters_schema)
+
+        expected_types = self._extract_expected_arg_types(parameters_schema)
+
         # Step 1: Build request (structured, NOT flattened)
         policy_args = self._sanitize_policy_args(args)
         request = self.build_request(
@@ -515,6 +520,21 @@ class CortexHub:
                 span.set_attribute("cortexhub.raw.args", json.dumps(args, default=str))
 
             try:
+                if expected_types and self.enforce and self.evaluator:
+                    mismatches = self._validate_arg_types(args, expected_types)
+                    if mismatches:
+                        message = f"Tool argument type mismatch: {'; '.join(mismatches)}"
+                        span.add_event(
+                            "policy.decision",
+                            attributes={
+                                "decision.effect": "deny",
+                                "decision.policy_id": "",
+                                "decision.reasoning": message,
+                                "decision.policy_name": "type_mismatch",
+                            },
+                        )
+                        span.set_status(Status(StatusCode.ERROR, message))
+                        raise PolicyViolationError(message, reasoning=message)
                 # Step 4: Policy evaluation (enforcement mode only)
                 if self.enforce and self.evaluator:
                     if os.getenv("CORTEXHUB_DEBUG_POLICY", "").lower() in ("1", "true", "yes"):
@@ -636,6 +656,7 @@ class CortexHub:
         framework: str,
         call_original: Callable[[], Any],
         tool_description: str | None = None,
+        parameters_schema: dict[str, Any] | None = None,
         principal: Principal | dict[str, str] | None = None,
         resource_type: str = "Tool",
     ) -> Any:
@@ -684,6 +705,21 @@ class CortexHub:
                 span.set_attribute("cortexhub.raw.args", json.dumps(args, default=str))
 
             try:
+                if expected_types and self.enforce and self.evaluator:
+                    mismatches = self._validate_arg_types(args, expected_types)
+                    if mismatches:
+                        message = f"Tool argument type mismatch: {'; '.join(mismatches)}"
+                        span.add_event(
+                            "policy.decision",
+                            attributes={
+                                "decision.effect": "deny",
+                                "decision.policy_id": "",
+                                "decision.reasoning": message,
+                                "decision.policy_name": "type_mismatch",
+                            },
+                        )
+                        span.set_status(Status(StatusCode.ERROR, message))
+                        raise PolicyViolationError(message, reasoning=message)
                 # Step 4: Policy evaluation (enforcement mode only)
                 if self.enforce and self.evaluator:
                     decision = self.evaluator.evaluate(request)
@@ -1316,6 +1352,49 @@ class CortexHub:
             return "string"
         return "unknown"
 
+    def _extract_expected_arg_types(self, parameters_schema: dict[str, Any] | None) -> dict[str, str]:
+        if not parameters_schema or not isinstance(parameters_schema, dict):
+            return {}
+        properties = parameters_schema.get("properties")
+        if not isinstance(properties, dict):
+            return {}
+        expected: dict[str, str] = {}
+        for name, schema in properties.items():
+            if not isinstance(schema, dict):
+                continue
+            raw_type = schema.get("type")
+            if isinstance(raw_type, list):
+                raw_type = next((t for t in raw_type if t != "null"), None)
+            if not isinstance(raw_type, str):
+                continue
+            normalized = raw_type.lower()
+            if normalized == "integer":
+                normalized = "number"
+            if normalized in ("number", "string", "boolean"):
+                expected[str(name)] = normalized
+        return expected
+
+    def _validate_arg_types(self, args: dict[str, Any], expected_types: dict[str, str]) -> list[str]:
+        if not isinstance(args, dict):
+            return []
+        mismatches: list[str] = []
+        for name, expected in expected_types.items():
+            if name not in args:
+                continue
+            value = args.get(name)
+            if value is None:
+                continue
+            if expected == "number":
+                if not isinstance(value, int) or isinstance(value, bool):
+                    mismatches.append(f"{name} expected number but got {type(value).__name__}")
+            elif expected == "string":
+                if not isinstance(value, str):
+                    mismatches.append(f"{name} expected string but got {type(value).__name__}")
+            elif expected == "boolean":
+                if not isinstance(value, bool):
+                    mismatches.append(f"{name} expected boolean but got {type(value).__name__}")
+        return mismatches
+
     def trace_llm_call(
         self,
         model: str,
@@ -1785,25 +1864,6 @@ class CortexHub:
         if not isinstance(cleaned_args, dict):
             return {}
 
-        if "amount" in cleaned_args:
-            from decimal import Decimal, InvalidOperation
-
-            amount = cleaned_args.get("amount")
-            dec_amount: Decimal | None = None
-            if isinstance(amount, int):
-                dec_amount = Decimal(amount)
-            elif isinstance(amount, str):
-                try:
-                    dec_amount = Decimal(amount)
-                except InvalidOperation:
-                    dec_amount = None
-            if dec_amount is not None:
-                quantized = dec_amount.quantize(Decimal("0.01"))
-                if quantized == dec_amount:
-                    cleaned_args["amount_cents"] = int(
-                        (quantized * 100).to_integral_value()
-                    )
-
         return cleaned_args
 
     def _summarize_policy_args(self, args: dict[str, Any]) -> dict[str, Any]:

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/pipeline.py

@@ -46,6 +46,12 @@ def govern_execution(
     framework = tool_metadata.get("framework", "unknown")
     model = tool_metadata.get("model", "unknown")
     prompt = tool_metadata.get("prompt")
+    parameters_schema = (
+        tool_metadata.get("parameters_schema")
+        or tool_metadata.get("params_json_schema")
+        or tool_metadata.get("input_schema")
+        or tool_metadata.get("strict_json_schema")
+    )
     call_original = tool_metadata.get("call_original")
     if call_original is None:
         call_original = tool_fn
@@ -78,6 +84,7 @@ def govern_execution(
                 args=kwargs,  # Use kwargs for structured arguments
                 framework=framework,
                 call_original=lambda: tool_fn(*args, **kwargs),
+                parameters_schema=parameters_schema,
             )
         return async_wrapper
     else:
@@ -88,5 +95,6 @@ def govern_execution(
                 args=kwargs,  # Use kwargs for structured arguments
                 framework=framework,
                 call_original=lambda: tool_fn(*args, **kwargs),
+                parameters_schema=parameters_schema,
             )
         return sync_wrapper

{cortexhub-0.1.5 → cortexhub-0.1.8}/src/cortexhub/version.py

@@ -1,3 +1,3 @@
 """Version information for CortexHub SDK."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.5"