# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/when-must-an-instance-re-derive-its-tool-invocation-proof-audience-restricted-tokens-and-per-call-proof-of-possession-at-the-agent-credential-boundary.md
# Remnant Warrant:    https://corpusfetch.com/c/when-must-an-instance-re-derive-its-tool-invocation-proof-audience-restricted-tokens-and-per-call-proof-of-possession-at-the-agent-credential-boundary.warrant.json
# Markdown SHA-256:   a711a604d9a70e0c4d31f0fb51f950d40b44bf8297c9869c13d923c2bd6c7c95
# Code AST SHA-256:   0d0ebaf06c847d1319f2128e5308613fe4374cd1268ed30929224be2f6db3ac3
# Verified Classes:   ProofBindingError, Token, Proof, AgentCredentialBoundary
# Defensive Guards:   3 fail-closed invariants (zero external deps)

import hashlib
import time
from dataclasses import dataclass, field
from typing import Callable, Optional


class ProofBindingError(RuntimeError):
    """Raised when a PoP proof is reused, mis-bound, or paired with a mismatched token."""


@dataclass
class Token:
    audience: str
    expires_at: float
    key_id: str
    raw: str


@dataclass
class Proof:
    method: str
    uri: str
    body_digest: str
    jti: str
    issued_at: float
    key_id: str


class AgentCredentialBoundary:
    """Enforces: cache tokens per audience, derive a fresh proof per call."""

    def __init__(self, mint_token: Callable[[str], Token],
                 sign_proof: Callable[[str, str, str, str], Proof],
                 skew_seconds: float = 30.0):
        self._mint_token = mint_token
        self._sign_proof = sign_proof
        self._skew = skew_seconds
        self._tokens: dict[str, Token] = {}
        self._seen_jti: set[str] = set()

    def _token_for(self, audience: str) -> Token:
        tok = self._tokens.get(audience)
        if tok is None or tok.expires_at - time.time() < self._skew:
            tok = self._mint_token(audience)
            self._tokens[audience] = tok
        return tok

    def invoke(self, audience: str, method: str, uri: str, body: bytes) -> Proof:
        token = self._token_for(audience)
        if token.audience != audience:
            raise ProofBindingError(
                f"token audience {token.audience!r} does not match tool {audience!r}; "
                "re-mint required, proof rotation will not help"
            )
        body_digest = hashlib.sha256(body).hexdigest()
        proof = self._sign_proof(method, uri, body_digest, token.key_id)
        if proof.jti in self._seen_jti:
            raise ProofBindingError(
                f"replayed jti {proof.jti!r}: proof must be derived per call, not cached"
            )
        if proof.key_id != token.key_id:
            raise ProofBindingError(
                f"proof key {proof.key_id!r} does not match token cnf key {token.key_id!r}"
            )
        self._seen_jti.add(proof.jti)
        return proof
