cortexhub 0.1.5__py3-none-any.whl → 0.1.8__py3-none-any.whl

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/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/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/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/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/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/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/version.py

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

{cortexhub-0.1.5.dist-info → cortexhub-0.1.8.dist-info}/METADATA

@@ -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.dist-info → cortexhub-0.1.8.dist-info}/RECORD

@@ -1,21 +1,21 @@
 cortexhub/__init__.py,sha256=hnwsiUy5BT3QaPNK5yXqex6zRzZlok43S04y-dkNWSE,4376
 cortexhub/auto_protect.py,sha256=yW-iW9cdGg-fM8EtR_Z9UkMczn51U8BKh5pOBgV1VqE,3951
-cortexhub/client.py,sha256=LNS63p8jFD3GASOKCQISZR4au52o4NmINF3hv1sTpxg,96968
+cortexhub/client.py,sha256=R2lxM2E4NAYeIo013TYcVZiuYrfXm1KBeP-17hinLgM,100212
 cortexhub/config.py,sha256=kpwVMTRcSisJy8HHBL3ZBeQoMN3lE7zziRzEYaq92LI,941
 cortexhub/errors.py,sha256=hsknLHaVCqk5MkpXvahxYIUshDt2VGZfbBWRronFvVM,3697
 cortexhub/frameworks.py,sha256=WCPokPRVafLqe73MDbJasi8FyNHTM2T4wfaBg0LuWoM,2223
-cortexhub/pipeline.py,sha256=EvkrEz7dGnzc0tlv02B3Kx2KQfdX4gsTuhUxj-MwuFI,3256
-cortexhub/version.py,sha256=L1gsFyWfMZYvly7nYjyH0nlWRAsm65S61_B-imDPgXE,68
+cortexhub/pipeline.py,sha256=5HalesMHy-39KOPtPGidih3YSrX2Xsc_Se0C6CyBaIM,3588
+cortexhub/version.py,sha256=5kkypMZTwNSkQR5pPfUn4kRFz3PtN8_HpqYKHbJkghg,68
 cortexhub/adapters/__init__.py,sha256=Lb6RquGPGs4exdfSB6Qb6q6HyGczozuLWSaLCtgZdyo,130
 cortexhub/adapters/base.py,sha256=_ODoJFLQLYnowse3MHQk8bN9KjE1oQr8QDNNlvPSwSs,4094
-cortexhub/adapters/claude_agents.py,sha256=RzFxMCylL3yCgnTASKnpa5F60t0RD-IrvoDfpRKYPFY,23038
-cortexhub/adapters/crewai.py,sha256=SuyMBF9bzrqDq58ZsGZV-3uAzaAtlLD3xEeyMB2Hgig,24899
-cortexhub/adapters/langgraph.py,sha256=X0UutdATOowXcZYRv_ImiJGSO97MKgYcuxFKV-jTxJA,20850
-cortexhub/adapters/openai_agents.py,sha256=63rNZ8HItZdoxERk1BTYzzpVe8Qq_8j56jfrEICzjpU,21511
+cortexhub/adapters/claude_agents.py,sha256=aOCAje8Rpio6X_mmqka8mHwdw4Xtw0_yKAsLS7jebXw,23260
+cortexhub/adapters/crewai.py,sha256=-8s27SU-_Z1c2D-jgVa1VfrtDbEDub3g6ahBcG5wy-U,24622
+cortexhub/adapters/langgraph.py,sha256=zqE2WkzWRSvmUvqVagzfC83bR4ip6gvHBPZoiq8YEr4,20772
+cortexhub/adapters/openai_agents.py,sha256=IIG894XH5T07gnfXbPg_oVGZYPBNXsQEakuAYugpn64,21393
 cortexhub/audit/__init__.py,sha256=tKE9CdpAIpP04oeLOza96jwZs4er5G5bRBWGibvh4Xw,545
 cortexhub/audit/events.py,sha256=w1uHbYzwBTDRm8gKAY_TQlXHjUj2nZt-iXk0NcqzRak,5965
 cortexhub/backend/__init__.py,sha256=Yt5fcaW24l6YwPCLvKbcKAXhhrWTUjwgqJsLOIzgIAo,133
-cortexhub/backend/client.py,sha256=dYd2aWJORysrEfJ5T_QPLwvs0xUQLrhMVT4FWUVOg6c,13680
+cortexhub/backend/client.py,sha256=542TKmKoGCOG54RdFLj4ur675LOxwhACFmtCFQ4eWgw,15310
 cortexhub/context/__init__.py,sha256=BWoR2s4ogOs1YXPFBO7e8_UOZ_5AWYfMlv5PTVORN2Y,144
 cortexhub/context/enricher.py,sha256=cComyfE10EbaCAI8KLM0ED6j-wKYBc26MRnIn-dxhmU,5322
 cortexhub/guardrails/__init__.py,sha256=RH1u8w3FFLd6u7-OYgj42PqAJO9jXsl8-tcLiL24uOo,103
@@ -33,7 +33,7 @@ cortexhub/policy/models.py,sha256=81NPX36yru0AZ22Wivytv3uxlwir4VsTN4MZgq4bdiA,38
 cortexhub/policy/sync.py,sha256=7kAc3rd5WftipR8XKwvU8SwukIoY-0gcGW2fsf-ij_I,5999
 cortexhub/telemetry/__init__.py,sha256=RSY38hHnYtbRURLoWAhbYYxYMtCItVYZBNN6Bfny8uA,1049
 cortexhub/telemetry/otel.py,sha256=T2pC-K_S_KmrLvfcd3oHMbEwC5ibGZ-PXTZSY0xJgcQ,16633
-cortexhub-0.1.5.dist-info/METADATA,sha256=oZPJ9gFAkIQ6D7jYLElFa9gobzaz3yyqqTGgsMRb7MM,8539
-cortexhub-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cortexhub-0.1.5.dist-info/licenses/LICENSE,sha256=R-lPsEVN69q2o19ge2_O9Vt9cJuGM557oEYX3XdnvIk,1066
-cortexhub-0.1.5.dist-info/RECORD,,
+cortexhub-0.1.8.dist-info/METADATA,sha256=wTMMUuiZkpi_yo269xZftwKVta7yYChZ5OczmAc1NpE,8539
+cortexhub-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cortexhub-0.1.8.dist-info/licenses/LICENSE,sha256=R-lPsEVN69q2o19ge2_O9Vt9cJuGM557oEYX3XdnvIk,1066
+cortexhub-0.1.8.dist-info/RECORD,,