petfishframework 0.3.1__tar.gz → 0.3.2__tar.gz

{petfishframework-0.3.1 → petfishframework-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: petfishframework
-Version: 0.3.1
+Version: 0.3.2
 Summary: A lightweight runtime framework for reliable, auditable, budget-aware, and permission-aware AI agents.
 Project-URL: Homepage, https://github.com/kylecui/petfishFramework
 Project-URL: Documentation, https://github.com/kylecui/petfishFramework/tree/master/docs
@@ -34,7 +34,7 @@ Description-Content-Type: text/markdown
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/kylecui/petfishFramework/blob/master/LICENSE)
-[![Tests: 259](https://img.shields.io/badge/tests-259-brightgreen.svg)](https://github.com/kylecui/petfishFramework/tree/master/tests/)
+[![Tests: 284](https://img.shields.io/badge/tests-259-brightgreen.svg)](https://github.com/kylecui/petfishFramework/tree/master/tests/)
 
 **Status: Alpha** — API may change. Core runtime works; see [Roadmap](#roadmap).
 
@@ -279,7 +279,7 @@ petfishFramework is **Alpha**. API may change before v1.0.
 git clone https://github.com/kylecui/petfishFramework.git
 cd petfishFramework
 uv sync --all-extras
-uv run pytest              # 259 tests
+uv run pytest              # 284 tests
 uv run ruff check src/ tests/
 ```
 

{petfishframework-0.3.1 → petfishframework-0.3.2}/README.md

@@ -4,7 +4,7 @@
 
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/kylecui/petfishFramework/blob/master/LICENSE)
-[![Tests: 259](https://img.shields.io/badge/tests-259-brightgreen.svg)](https://github.com/kylecui/petfishFramework/tree/master/tests/)
+[![Tests: 284](https://img.shields.io/badge/tests-259-brightgreen.svg)](https://github.com/kylecui/petfishFramework/tree/master/tests/)
 
 **Status: Alpha** — API may change. Core runtime works; see [Roadmap](#roadmap).
 
@@ -249,7 +249,7 @@ petfishFramework is **Alpha**. API may change before v1.0.
 git clone https://github.com/kylecui/petfishFramework.git
 cd petfishFramework
 uv sync --all-extras
-uv run pytest              # 259 tests
+uv run pytest              # 284 tests
 uv run ruff check src/ tests/
 ```
 

{petfishframework-0.3.1 → petfishframework-0.3.2}/docs/api.md

@@ -1,6 +1,6 @@
 # petfishFramework API Reference
 
-This document is the authoritative reference for the public API of `petfishFramework` v0.3.1. Every signature, field, and example below is derived from the source code and from the tests that exercise it.
+This document is the authoritative reference for the public API of `petfishFramework` v0.3.2. Every signature, field, and example below is derived from the source code and from the tests that exercise it.
 
 ## 1. Overview
 

{petfishframework-0.3.1 → petfishframework-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "petfishframework"
-version = "0.3.1"
+version = "0.3.2"
 description = "A lightweight runtime framework for reliable, auditable, budget-aware, and permission-aware AI agents."
 readme = "README.md"
 license = "MIT"

{petfishframework-0.3.1 → petfishframework-0.3.2}/src/petfishframework/__init__.py

@@ -15,7 +15,7 @@ from .reasoning import LATS, LLMPlusP, ReAct
 from .reliability.replay import ReplayMode
 from .tools.base import BaseTool
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 __all__ = [
     "Agent",

{petfishframework-0.3.1 → petfishframework-0.3.2}/src/petfishframework/core/environment.py

@@ -334,7 +334,10 @@ class RuntimeEnvironment(Environment):
             return
         if self.credential_broker is None:
             return
-        token = self.credential_broker.issue_token(tool.name, tool_name=tool.name)
+        credential_name = getattr(tool, "credential_name", None) or tool.name
+        token = self.credential_broker.issue_token(
+            credential_name, tool_name=tool.name, max_uses=1
+        )
         args["_credential_token"] = token
 
     def _prepare_tool_call(self, ref: ToolRef, args: dict) -> tuple[Tool | None, Any]:

{petfishframework-0.3.1 → petfishframework-0.3.2}/src/petfishframework/core/session.py

@@ -133,6 +133,7 @@ class Session:
         self._result = result
 
         self._save_conversation_history(result)
+        self._cleanup_credentials()
 
         self.events.emit(
             "session.end",
@@ -150,6 +151,21 @@ class Session:
         )
         return result
 
+    def _cleanup_credentials(self) -> None:
+        """Clean up scoped credentials at session end."""
+        broker = self.credential_broker
+        if broker is None:
+            return
+
+        cleanup_expired = getattr(broker, "cleanup_expired", None)
+        if callable(cleanup_expired):
+            cleanup_expired()
+
+        revoke_all_for_tool = getattr(broker, "revoke_all_for_tool", None)
+        if callable(revoke_all_for_tool):
+            for tool in self.tools:
+                revoke_all_for_tool(tool.name)
+
     def _save_conversation_history(self, result: Result) -> None:
         """Persist previous history plus the current user/assistant turn."""
         if self.conversation_store is None or self.conversation_id is None:

{petfishframework-0.3.1 → petfishframework-0.3.2}/src/petfishframework/credentials/broker.py

@@ -28,6 +28,7 @@ class CredentialBroker:
         name: str,
         tool_name: str,
         ttl_s: float | None = None,
+        max_uses: int = 0,
     ) -> ScopedToken:
         """Issue a scoped, time-limited token for a specific tool."""
         if name not in self._credentials:
@@ -42,6 +43,7 @@ class CredentialBroker:
             token_id=token_id,
             tool_name=tool_name,
             expires_at=expires_at,
+            max_uses=max_uses,
             _secret=secret,
         )
         self._active_tokens[token_id] = token
@@ -58,6 +60,38 @@ class CredentialBroker:
         """Revoke a token immediately."""
         self._active_tokens.pop(token_id, None)
 
+    def revoke_all_for_tool(self, tool_name: str) -> int:
+        """Revoke all active tokens issued for a specific tool.
+
+        Returns the number of tokens revoked.
+        """
+        token_ids = [
+            token_id
+            for token_id, token in self._active_tokens.items()
+            if token.tool_name == tool_name
+        ]
+        for token_id in token_ids:
+            del self._active_tokens[token_id]
+        return len(token_ids)
+
+    def revoke_all(self) -> int:
+        """Revoke all active tokens.
+
+        Returns the number of tokens revoked.
+        """
+        count = len(self._active_tokens)
+        self._active_tokens.clear()
+        return count
+
+    @property
+    def active_token_count(self) -> int:
+        """Return the number of currently active tokens."""
+        return len(self._active_tokens)
+
+    def list_active_tokens(self) -> list[str]:
+        """Return token IDs for all active tokens (secrets are not exposed)."""
+        return list(self._active_tokens.keys())
+
     def cleanup_expired(self) -> int:
         """Remove all expired tokens. Returns count removed."""
         expired = [

{petfishframework-0.3.1 → petfishframework-0.3.2}/src/petfishframework/credentials/token.py

@@ -5,7 +5,7 @@ import time
 from dataclasses import dataclass, field
 
 
-@dataclass(frozen=True)
+@dataclass
 class ScopedToken:
     """A time-limited, tool-scoped credential token.
 
@@ -15,23 +15,48 @@ class ScopedToken:
     token_id: str          # unique ID
     tool_name: str         # which tool this token is for
     expires_at: float      # unix timestamp
+    max_uses: int = 0      # 0 = unlimited uses
     _secret: str = field(default="", repr=False, compare=False)  # hidden from repr
+    _uses: int = field(default=0, repr=False)
 
     def is_valid(self) -> bool:
         """Check if token is still valid (not expired)."""
         return time.time() < self.expires_at
 
+    def use(self) -> bool:
+        """Consume one use of the token.
+
+        Returns True if the use is allowed, False if max_uses exceeded.
+        """
+        self._uses += 1
+        if self.max_uses > 0 and self._uses > self.max_uses:
+            return False
+        return True
+
+    @property
+    def uses_remaining(self) -> int | None:
+        """Remaining allowed uses, or None when unlimited."""
+        if self.max_uses <= 0:
+            return None
+        return max(0, self.max_uses - self._uses)
+
     def get_secret(self) -> str:
         """Get the actual secret. Only callable by trusted code."""
         if not self.is_valid():
             raise ValueError("Token expired")
+        if not self.use():
+            raise ValueError("Token exceeded max uses")
         return self._secret
 
     def __repr__(self) -> str:
         return (
             f"ScopedToken(token_id={self.token_id!r}, tool_name={self.tool_name!r}, "
-            f"expires_at={self.expires_at}, _secret='[REDACTED]')"
+            f"expires_at={self.expires_at}, max_uses={self.max_uses}, "
+            f"_secret='[REDACTED]')"
         )
 
     def __str__(self) -> str:
-        return f"ScopedToken({self.token_id}, tool={self.tool_name}, valid={self.is_valid()})"
+        return (
+            f"ScopedToken({self.token_id}, tool={self.tool_name}, "
+            f"valid={self.is_valid()}, uses_remaining={self.uses_remaining})"
+        )

petfishframework-0.3.2/src/petfishframework/policies/conditions.py

@@ -0,0 +1,436 @@
+"""Condition matchers for YAML policy rules (v0.3.2).
+
+Each matcher receives the value declared in the YAML ``when:`` block plus the
+SARC evaluation context (Subject, Action, Resource, AccessContext) and the
+metadata of the tool being invoked. Matchers return ``True`` when the condition
+is satisfied.
+
+Unknown condition keys are fail-closed (return ``False``).
+"""
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from petfishframework.core.contracts import RiskLevel
+from petfishframework.permissions.model import AccessContext, Action, Resource, Subject
+
+ConditionMatcher = Callable[
+    [Any, Subject, Action, Resource, AccessContext, dict[str, Any]],
+    bool,
+]
+
+
+def _match_action_tool_name(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Exact string match against ``action.tool_name``."""
+    return action.tool_name == value
+
+
+def _match_subject_role_in(
+    value: Any,
+    subject: Subject,
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """True if any role in ``value`` is present in ``subject.roles``."""
+    return any(role in subject.roles for role in value)
+
+
+def _match_subject_role_not_in(
+    value: Any,
+    subject: Subject,
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """True if NO role in ``value`` is present in ``subject.roles``."""
+    return not any(role in subject.roles for role in value)
+
+
+def _match_action_args_amount_gt(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric greater-than comparison against ``action.args["amount"]``."""
+    amount = action.args.get("amount", 0)
+    try:
+        return float(amount) > float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_action_args_amount_lt(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric less-than comparison against ``action.args["amount"]``."""
+    amount = action.args.get("amount", 0)
+    try:
+        return float(amount) < float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_tool_side_effect(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Boolean match against ``tool_metadata["side_effect"]``."""
+    if not tool_metadata:
+        return False
+    return tool_metadata.get("side_effect") == value
+
+
+def _match_tool_external_egress(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Boolean match against ``tool_metadata["external_egress"]``."""
+    if not tool_metadata:
+        return False
+    return tool_metadata.get("external_egress") == value
+
+
+def _match_action_args_amount_eq(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric equality comparison against ``action.args["amount"]``."""
+    amount = action.args.get("amount", 0)
+    try:
+        return float(amount) == float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_action_args_amount_gte(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric greater-than-or-equal comparison against ``action.args["amount"]``."""
+    amount = action.args.get("amount", 0)
+    try:
+        return float(amount) >= float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_action_args_amount_lte(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric less-than-or-equal comparison against ``action.args["amount"]``."""
+    amount = action.args.get("amount", 0)
+    try:
+        return float(amount) <= float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_subject_role_count_gte(
+    value: Any,
+    subject: Subject,
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """True if ``subject.roles`` has at least ``value`` entries."""
+    try:
+        return len(subject.roles) >= int(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_subject_clearance_eq(
+    value: Any,
+    subject: Subject,
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Exact match against ``subject.clearance``."""
+    return subject.clearance == value
+
+
+def _match_subject_tenant_id_eq(
+    value: Any,
+    subject: Subject,
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Exact match against ``subject.tenant_id``."""
+    return subject.tenant_id == value
+
+
+def _match_resource_classification_eq(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Exact match against ``resource.classification``."""
+    return resource.classification == value
+
+
+def _match_resource_tags_contains(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """True if any tag in ``value`` is present in ``resource.tags``."""
+    return any(tag in resource.tags for tag in value)
+
+
+def _match_tool_risk_level_eq(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Match against ``tool_metadata["risk_level"]`` (string or ``RiskLevel`` enum)."""
+    if not tool_metadata:
+        return False
+    risk_level = tool_metadata.get("risk_level")
+    if risk_level is None:
+        return False
+    if isinstance(value, RiskLevel):
+        return risk_level == value
+    if isinstance(risk_level, RiskLevel):
+        return risk_level.value == str(value).lower()
+    return str(risk_level).lower() == str(value).lower()
+
+
+def _match_tool_capabilities_contains(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """True if any capability in ``value`` is present in tool capabilities."""
+    if not tool_metadata:
+        return False
+    capabilities = tool_metadata.get("capabilities", ())
+    return any(capability in capabilities for capability in value)
+
+
+def _match_tool_requires_credentials(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Boolean match against ``tool_metadata["requires_credentials"]``."""
+    if not tool_metadata:
+        return False
+    return tool_metadata.get("requires_credentials") == value
+
+
+def _match_context_session_risk_gt(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric greater-than comparison against ``context.session_risk``."""
+    try:
+        return float(context.session_risk) > float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_context_prompt_risk_gt(
+    value: Any,
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Numeric greater-than comparison against ``context.prompt_risk``."""
+    try:
+        return float(context.prompt_risk) > float(value)
+    except (TypeError, ValueError):
+        return False
+
+
+def _match_unknown(
+    value: Any,  # noqa: ARG001
+    subject: Subject,  # noqa: ARG001
+    action: Action,  # noqa: ARG001
+    resource: Resource,  # noqa: ARG001
+    context: AccessContext,  # noqa: ARG001
+    tool_metadata: dict[str, Any],  # noqa: ARG001
+) -> bool:
+    """Fail-closed default for unrecognized condition keys."""
+    return False
+
+
+_MATCHERS: dict[str, ConditionMatcher] = {
+    "action.tool_name": _match_action_tool_name,
+    "subject.role_in": _match_subject_role_in,
+    "subject.role_not_in": _match_subject_role_not_in,
+    "action.args.amount_gt": _match_action_args_amount_gt,
+    "action.args.amount_lt": _match_action_args_amount_lt,
+    "action.args.amount_eq": _match_action_args_amount_eq,
+    "action.args.amount_gte": _match_action_args_amount_gte,
+    "action.args.amount_lte": _match_action_args_amount_lte,
+    "tool.side_effect": _match_tool_side_effect,
+    "tool.external_egress": _match_tool_external_egress,
+    "subject.role_count_gte": _match_subject_role_count_gte,
+    "subject.clearance_eq": _match_subject_clearance_eq,
+    "subject.tenant_id_eq": _match_subject_tenant_id_eq,
+    "resource.classification_eq": _match_resource_classification_eq,
+    "resource.tags_contains": _match_resource_tags_contains,
+    "tool.risk_level_eq": _match_tool_risk_level_eq,
+    "tool.capabilities_contains": _match_tool_capabilities_contains,
+    "tool.requires_credentials": _match_tool_requires_credentials,
+    "context.session_risk_gt": _match_context_session_risk_gt,
+    "context.prompt_risk_gt": _match_context_prompt_risk_gt,
+}
+
+
+def match_condition(
+    key: str,
+    value: Any,
+    subject: Subject,
+    action: Action,
+    resource: Resource,
+    context: AccessContext,
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Evaluate a single condition key/value pair.
+
+    Unknown keys fail closed (return ``False``). Empty condition sets are
+    handled by the caller and match everything.
+
+    Supports the generic prefix matcher ``action.args.<field>_eq`` for equality
+    checks against any key in ``action.args``.
+    """
+    matcher = _MATCHERS.get(key)
+    if matcher is not None:
+        return matcher(value, subject, action, resource, context, tool_metadata)
+
+    if key.startswith("action.args.") and key.endswith("_eq"):
+        field = key[len("action.args.") : -len("_eq")]
+        return action.args.get(field) == value
+
+    return _match_unknown(value, subject, action, resource, context, tool_metadata)
+
+
+def match_conditions_with_combinators(
+    conditions: dict[str, Any],
+    subject: Subject,
+    action: Action,
+    resource: Resource,
+    context: AccessContext,
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Evaluate conditions supporting ``any``/``all``/``not`` combinators.
+
+    Flat dictionaries continue to act as implicit AND (backward compatible).
+    An empty condition dict matches everything (default-allow semantics).
+    """
+    if not conditions:
+        return True
+
+    if "any" in conditions:
+        sub_conditions = conditions["any"]
+        if not isinstance(sub_conditions, list):
+            return False
+        return any(
+            match_conditions_with_combinators(sub, subject, action, resource, context, tool_metadata)
+            for sub in sub_conditions
+        )
+
+    if "all" in conditions:
+        sub_conditions = conditions["all"]
+        if not isinstance(sub_conditions, list):
+            return False
+        return all(
+            match_conditions_with_combinators(sub, subject, action, resource, context, tool_metadata)
+            for sub in sub_conditions
+        )
+
+    if "not" in conditions:
+        inner = conditions["not"]
+        if not isinstance(inner, dict):
+            return False
+        return not match_conditions_with_combinators(inner, subject, action, resource, context, tool_metadata)
+
+    return all(
+        match_condition(key, value, subject, action, resource, context, tool_metadata)
+        for key, value in conditions.items()
+    )
+
+
+def match_all_conditions(
+    conditions: dict[str, Any],
+    subject: Subject,
+    action: Action,
+    resource: Resource,
+    context: AccessContext,
+    tool_metadata: dict[str, Any],
+) -> bool:
+    """Return True if every condition in the rule matches.
+
+    An empty condition dict matches everything (default-allow semantics).
+    Delegates to ``match_conditions_with_combinators`` for ``any``/``all``/``not``
+    support while preserving the legacy flat-dictionary AND behavior.
+    """
+    return match_conditions_with_combinators(
+        conditions, subject, action, resource, context, tool_metadata
+    )

{petfishframework-0.3.1 → petfishframework-0.3.2}/src/petfishframework/policies/engine.py

@@ -1,4 +1,4 @@
-"""YAML Policy Engine (v0.3.0 Phase A1).
+"""YAML Policy Engine (v0.3.2).
 
 Loads authorization rules from YAML and evaluates them in priority order.
 Implements the PermissionPolicy protocol so it can be plugged directly into
@@ -58,6 +58,9 @@ class YamlPolicy:
             self._tool_metadata[name] = {
                 "side_effect": getattr(tool, "side_effect", False),
                 "external_egress": getattr(tool, "external_egress", False),
+                "risk_level": getattr(tool, "risk_level", None),
+                "capabilities": getattr(tool, "capabilities", ()),
+                "requires_credentials": getattr(tool, "requires_credentials", False),
             }
 
     def evaluate(self, subject: Subject, action: Action, resource: Resource, context: AccessContext) -> Decision: