import "github.com/capiscio/capiscio-core/v2/pkg/agentcard"

type AgentCapabilities struct {
    Streaming              bool `json:"streaming,omitempty"`
    PushNotifications      bool `json:"pushNotifications,omitempty"`
    StateTransitionHistory bool `json:"stateTransitionHistory,omitempty"`
}

type AgentCard struct {
    ProtocolVersion                   string                    `json:"protocolVersion"`
    Name                              string                    `json:"name"`
    Description                       string                    `json:"description"`
    URL                               string                    `json:"url"`
    PreferredTransport                TransportProtocol         `json:"preferredTransport,omitempty"`
    AdditionalInterfaces              []AgentInterface          `json:"additionalInterfaces,omitempty"`
    Provider                          *AgentProvider            `json:"provider,omitempty"`
    IconURL                           string                    `json:"iconUrl,omitempty"`
    Version                           string                    `json:"version"`
    DocumentationURL                  string                    `json:"documentationUrl,omitempty"`
    Capabilities                      AgentCapabilities         `json:"capabilities"`
    SecuritySchemes                   map[string]SecurityScheme `json:"securitySchemes,omitempty"`
    Security                          []map[string][]string     `json:"security,omitempty"`
    DefaultInputModes                 []string                  `json:"defaultInputModes"`
    DefaultOutputModes                []string                  `json:"defaultOutputModes"`
    Skills                            []AgentSkill              `json:"skills"`
    SupportsAuthenticatedExtendedCard bool                      `json:"supportsAuthenticatedExtendedCard,omitempty"`
    Signatures                        []Signature               `json:"signatures,omitempty"`
    Extensions                        []AgentExtension          `json:"extensions,omitempty"`
}

type AgentExtension struct {
    Name        string `json:"name"`
    Version     string `json:"version"`
    Description string `json:"description,omitempty"`
}

type AgentInterface struct {
    URL       string            `json:"url"`
    Transport TransportProtocol `json:"transport"`
}

type AgentProvider struct {
    Organization string `json:"organization"`
    URL          string `json:"url"`
}

type AgentSkill struct {
    ID          string   `json:"id"`
    Name        string   `json:"name"`
    Description string   `json:"description"`
    Tags        []string `json:"tags"`
    Examples    []string `json:"examples,omitempty"`
    InputModes  []string `json:"inputModes,omitempty"`
    OutputModes []string `json:"outputModes,omitempty"`
}

type SecurityScheme struct {
    Type             string      `json:"type"`
    Scheme           string      `json:"scheme,omitempty"`
    BearerFormat     string      `json:"bearerFormat,omitempty"`
    OpenIDConnectURL string      `json:"openIdConnectUrl,omitempty"`
    Flows            interface{} `json:"flows,omitempty"` // Using interface{} as 'any'
}

type Signature struct {
    Protected string `json:"protected"`
    Signature string `json:"signature"`
}

type TransportProtocol string

const (
    TransportJSONRPC  TransportProtocol = "JSONRPC"
    TransportGRPC     TransportProtocol = "GRPC"
    TransportHTTPJSON TransportProtocol = "HTTP+JSON"
)

import "github.com/capiscio/capiscio-core/v2/pkg/badge"

const (
    // ErrCodeMalformed indicates the JWS structure is invalid.
    ErrCodeMalformed = "BADGE_MALFORMED"

    // ErrCodeSignatureInvalid indicates signature verification failed.
    ErrCodeSignatureInvalid = "BADGE_SIGNATURE_INVALID"

    // ErrCodeExpired indicates current time >= exp.
    ErrCodeExpired = "BADGE_EXPIRED"

    // ErrCodeNotYetValid indicates current time < iat.
    ErrCodeNotYetValid = "BADGE_NOT_YET_VALID"

    // ErrCodeIssuerUntrusted indicates iss is not in the trusted issuer list.
    ErrCodeIssuerUntrusted = "BADGE_ISSUER_UNTRUSTED"

    // ErrCodeAudienceMismatch indicates the verifier is not in the aud claim.
    ErrCodeAudienceMismatch = "BADGE_AUDIENCE_MISMATCH"

    // ErrCodeRevoked indicates the badge jti is on the revocation list.
    ErrCodeRevoked = "BADGE_REVOKED"

    // ErrCodeClaimsInvalid indicates required claims are missing or malformed.
    ErrCodeClaimsInvalid = "BADGE_CLAIMS_INVALID"

    // ErrCodeAgentDisabled indicates the agent sub is disabled.
    ErrCodeAgentDisabled = "BADGE_AGENT_DISABLED"

    // ErrCodeRevocationCheckFailed indicates revocation check failed.
    // RFC-002 v1.3 §7.5: Used when sync fails AND cache stale for levels 2+.
    ErrCodeRevocationCheckFailed = "REVOCATION_CHECK_FAILED"
)

const (
    // REVOCATION_CACHE_MAX_STALENESS is the default maximum age for cached data.
    // RFC-002 v1.3 §7.5: 300 seconds (5 minutes) - revocation cache older than
    // this is considered stale and triggers fail-closed for levels 2+.
    REVOCATION_CACHE_MAX_STALENESS = 5 * time.Minute

    // DefaultStaleThreshold is an alias for backward compatibility.
    // Deprecated: Use REVOCATION_CACHE_MAX_STALENESS instead.
    DefaultStaleThreshold = REVOCATION_CACHE_MAX_STALENESS

    // StaleFailClosedMinLevel is the minimum trust level that enforces fail-closed
    // on stale data. RFC-002 v1.3 §7.5: Levels 2+ MUST fail on stale cache.
    StaleFailClosedMinLevel = 2
)

const DefaultCAURL = "https://registry.capisc.io"

const DefaultTTL = 5 * time.Minute

var (
    // ErrMalformed is returned when the JWS structure is invalid.
    ErrMalformed = NewError(ErrCodeMalformed, "badge structure is invalid")

    // ErrSignatureInvalid is returned when signature verification fails.
    ErrSignatureInvalid = NewError(ErrCodeSignatureInvalid, "signature verification failed")

    // ErrExpired is returned when the badge has expired.
    ErrExpired = NewError(ErrCodeExpired, "badge has expired")

    // ErrNotYetValid is returned when the badge is not yet valid (iat in future).
    ErrNotYetValid = NewError(ErrCodeNotYetValid, "badge is not yet valid")

    // ErrIssuerUntrusted is returned when the issuer is not trusted.
    ErrIssuerUntrusted = NewError(ErrCodeIssuerUntrusted, "issuer is not trusted")

    // ErrAudienceMismatch is returned when verifier is not in audience.
    ErrAudienceMismatch = NewError(ErrCodeAudienceMismatch, "verifier not in badge audience")

    // ErrRevoked is returned when the badge has been revoked.
    ErrRevoked = NewError(ErrCodeRevoked, "badge has been revoked")

    // ErrClaimsInvalid is returned when required claims are missing or malformed.
    ErrClaimsInvalid = NewError(ErrCodeClaimsInvalid, "required claims missing or malformed")

    // ErrAgentDisabled is returned when the agent has been disabled.
    ErrAgentDisabled = NewError(ErrCodeAgentDisabled, "agent has been disabled")

    // ErrRevocationCheckFailed is returned when revocation check fails with stale cache.
    // RFC-002 v1.3 §7.5: Used for fail-closed on stale cache for levels 2+.
    ErrRevocationCheckFailed = NewError(ErrCodeRevocationCheckFailed, "revocation check failed")
)

func GetErrorCode(err error) string

func SignBadge(claims *Claims, privateKey crypto.PrivateKey) (string, error)

type ChallengeResponse struct {
    ChallengeID string    `json:"challenge_id"`
    Nonce       string    `json:"nonce"`
    ExpiresAt   time.Time `json:"expires_at"`
    Aud         string    `json:"aud"`
    HTU         string    `json:"htu"`
    HTM         string    `json:"htm"`
}

type Claims struct {
    // JTI is the unique Badge ID (UUID v4). Used for revocation and audit.
    JTI string `json:"jti"`

    // Issuer is the CA that signed the Badge (e.g., "https://registry.capisc.io").
    Issuer string `json:"iss"`

    // Subject is the agent's DID. MUST be a valid did:web identifier.
    // Format: did:web:registry.capisc.io:agents:<agent-id>
    Subject string `json:"sub"`

    // Audience is the list of trust domains/services where Badge is valid.
    // Optional. If present, verifiers MUST check their identity is included.
    Audience []string `json:"aud,omitempty"`

    // IssuedAt is the timestamp when the badge was issued (Unix timestamp).
    IssuedAt int64 `json:"iat"`

    // Expiry is the timestamp when the badge expires (Unix timestamp).
    Expiry int64 `json:"exp"`

    // NotBefore is the timestamp before which the badge MUST NOT be accepted.
    // Optional. Per RFC-002 §4.3.1.
    NotBefore int64 `json:"nbf,omitempty"`

    // IAL is the Identity Assurance Level. REQUIRED per RFC-002 §4.3.2.
    // "0" = Account-attested (IAL-0), "1" = Proof of Possession (IAL-1).
    IAL string `json:"ial"`

    // Key is the public key of the subject, embedded for offline verification.
    // REQUIRED in production. MAY be omitted in non-production environments.
    Key *jose.JSONWebKey `json:"key,omitempty"`

    // CNF is the confirmation claim per RFC 7800.
    // When present, binds the badge to a specific key holder.
    // Used for Proof of Possession (PoP) badges (RFC-002 §7.2.2, RFC-003).
    CNF *ConfirmationClaim `json:"cnf,omitempty"`

    // PoPChallengeID is a reference to the PoP challenge used during issuance.
    // Optional. Provides audit trail for PoP-issued badges (RFC-002 §4.3.3).
    PoPChallengeID string `json:"pop_challenge_id,omitempty"`

    // AgentCardHash is the SHA-256 hash of the canonical AgentCard at issuance.
    // Optional. Enables verifiers to detect AgentCard drift (RFC-002 §4.3.3).
    AgentCardHash string `json:"agent_card_hash,omitempty"`

    // DIDDocHash is the SHA-256 hash of the DID Document at issuance.
    // Optional. Enables verifiers to detect key rotation (RFC-002 §4.3.3).
    DIDDocHash string `json:"did_doc_hash,omitempty"`

    // VC contains the Verifiable Credential data.
    VC  VerifiableCredential `json:"vc"`
}

func (c *Claims) AgentID() string

func (c *Claims) AssuranceLevel() string

func (c *Claims) Domain() string

func (c *Claims) ExpiresAt() time.Time

func (c *Claims) HasProofOfPossession() bool

func (c *Claims) IsExpired() bool

func (c *Claims) IsNotYetValid() bool

func (c *Claims) IssuedAtTime() time.Time

func (c *Claims) TrustLevel() string

type Client struct {
    CAURL      string
    APIKey     string
    HTTPClient *http.Client
}

func NewClient(caURL, apiKey string) *Client

func (c *Client) RequestBadge(ctx context.Context, opts RequestBadgeOptions) (*RequestBadgeResult, error)

type ClientError struct {
    Code    string
    Message string
}

func (e *ClientError) Error() string

func (e *ClientError) IsAuthError() bool

func (e *ClientError) IsNotFoundError() bool

type ConfirmationClaim struct {
    // KID is the key ID referencing the key in the DID Document.
    // This is the primary mechanism for PoP badges.
    KID string `json:"kid,omitempty"`

    // JWK is the full JWK of the confirmation key (alternative to kid).
    JWK *jose.JSONWebKey `json:"jwk,omitempty"`

    // JKT is the JWK thumbprint (SHA-256) of the confirmation key.
    JKT string `json:"jkt,omitempty"`
}

type CredentialSubject struct {
    // Domain is the agent's home domain.
    // MUST be validated according to the trust level's requirements.
    Domain string `json:"domain,omitempty"`

    // Level indicates the trust level: "1" (DV), "2" (OV), or "3" (EV).
    Level string `json:"level,omitempty"`
}

type DVClient struct {
    CAURL      string
    HTTPClient *http.Client
}

func NewDVClient(caURL string) *DVClient

func NewDVClientWithHTTPClient(caURL string, httpClient *http.Client) *DVClient

func (c *DVClient) CreateOrder(ctx context.Context, domain, challengeType string, jwk *jose.JSONWebKey) (*DVOrder, error)

func (c *DVClient) FinalizeOrder(ctx context.Context, orderID string) (*DVGrant, error)

func (c *DVClient) GetOrder(ctx context.Context, orderID string) (*DVOrder, error)

type DVGrant struct {
    Grant     string
    ExpiresAt time.Time
}

type DVOrder struct {
    ID             string
    Domain         string
    ChallengeType  string
    ChallengeToken string
    Status         string
    ValidationURL  string
    DNSRecord      string
    ExpiresAt      time.Time
    FinalizedAt    *time.Time
}

type Error struct {
    // Code is one of the BADGE_* error codes.
    Code string

    // Message is a human-readable description.
    Message string

    // Cause is the underlying error, if any.
    Cause error
}

func AsError(err error) (*Error, bool)

func NewError(code, message string) *Error

func WrapError(code, message string, cause error) *Error

func (e *Error) Error() string

func (e *Error) Is(target error) bool

func (e *Error) Unwrap() error

type Keeper struct {
    // contains filtered or unexported fields
}

func NewKeeper(config KeeperConfig) (*Keeper, error)

func (k *Keeper) CheckAndRenew() error

func (k *Keeper) Renew() error

func (k *Keeper) Run(ctx context.Context) error

func (k *Keeper) RunWithEvents(ctx context.Context, events chan<- KeeperEvent) error

type KeeperConfig struct {
    // Mode: self-sign, ca (deprecated), or pop (recommended)
    Mode KeeperMode

    // Common settings
    OutputFile    string
    Expiry        time.Duration
    RenewBefore   time.Duration
    CheckInterval time.Duration
    Domain        string
    TrustLevel    string

    // Self-sign mode settings
    PrivateKey crypto.PrivateKey
    Claims     Claims

    // CA mode settings (IAL-0, deprecated)
    CAURL   string
    APIKey  string
    AgentID string

    // PoP mode settings (IAL-1, recommended)
    // AgentDID is the DID of the agent (e.g., did:key:z6Mk...)
    AgentDID string
    // Audience is the optional audience restrictions for the badge
    Audience []string
}

type KeeperEvent struct {
    Type       KeeperEventType
    BadgeJTI   string
    Subject    string
    TrustLevel string
    ExpiresAt  time.Time
    Error      string
    ErrorCode  string
    Timestamp  time.Time
    Token      string // The badge token (optional, for renewed events)
}

type KeeperEventType string

const (
    // KeeperEventStarted indicates the keeper has started.
    KeeperEventStarted KeeperEventType = "started"
    // KeeperEventRenewed indicates a badge was renewed.
    KeeperEventRenewed KeeperEventType = "renewed"
    // KeeperEventError indicates an error occurred.
    KeeperEventError KeeperEventType = "error"
    // KeeperEventStopped indicates the keeper has stopped.
    KeeperEventStopped KeeperEventType = "stopped"
)

type KeeperMode string

const (
    // KeeperModeSelfSign generates self-signed badges locally.
    KeeperModeSelfSign KeeperMode = "self-sign"
    // KeeperModeCA requests badges from a Certificate Authority (IAL-0, deprecated).
    // Deprecated: Use KeeperModePoP for production - IAL-0 lacks cryptographic key binding.
    KeeperModeCA KeeperMode = "ca"
    // KeeperModePoP requests badges using Proof of Possession (RFC-003 IAL-1).
    // This is the recommended mode for production as it provides cryptographic key binding.
    KeeperModePoP KeeperMode = "pop"
)

type PoPClient struct {
    CAURL      string
    APIKey     string
    HTTPClient *http.Client
}

func NewPoPClient(caURL, apiKey string) *PoPClient

func NewPoPClientWithHTTPClient(caURL, apiKey string, httpClient *http.Client) *PoPClient

func (c *PoPClient) RequestPoPBadge(ctx context.Context, opts RequestPoPBadgeOptions) (*RequestPoPBadgeResult, error)

type PoPProofClaims struct {
    CID   string `json:"cid"`   // Challenge ID
    Nonce string `json:"nonce"` // Server nonce
    Sub   string `json:"sub"`   // Subject (DID)
    Aud   string `json:"aud"`   // Audience (registry)
    HTU   string `json:"htu"`   // HTTP Target URI
    HTM   string `json:"htm"`   // HTTP Method
    IAT   int64  `json:"iat"`   // Issued at
    Exp   int64  `json:"exp"`   // Expiration
    JTI   string `json:"jti"`   // Proof JTI (unique)
}

type RenewalResult struct {
    JTI        string
    Subject    string
    TrustLevel string
    ExpiresAt  time.Time
    Token      string
}

type RequestBadgeOptions struct {
    AgentID    string
    Domain     string
    TTL        time.Duration
    TrustLevel string
    Audience   []string
}

type RequestBadgeResult struct {
    Token      string
    JTI        string
    Subject    string
    TrustLevel string
    ExpiresAt  time.Time
}

type RequestPoPBadgeOptions struct {
    // AgentDID is the DID of the agent (e.g., did:key:z6Mk... or did:web:...)
    AgentDID string

    // PrivateKey is the agent's private key for signing the PoP proof
    PrivateKey crypto.PrivateKey

    // TTL is the requested badge TTL (optional, default 5 min)
    TTL time.Duration

    // Audience is the optional audience restrictions
    Audience []string
}

type RequestPoPBadgeResult struct {
    Token          string
    JTI            string
    Subject        string
    TrustLevel     string
    AssuranceLevel string // "IAL-1" for PoP badges
    ExpiresAt      time.Time
    CNF            map[string]interface{} // Confirmation claim with key binding
}

type RevocationCache interface {
    // IsRevoked checks if a badge jti is in the revocation cache.
    IsRevoked(jti string) bool

    // IsStale returns true if the cache is older than the threshold.
    IsStale(threshold time.Duration) bool
}

type VerifiableCredential struct {
    // Type is the JSON-LD type(s) of the credential.
    // MUST include "VerifiableCredential" and "AgentIdentity".
    Type []string `json:"type"`

    // CredentialSubject contains the claims about the subject.
    CredentialSubject CredentialSubject `json:"credentialSubject"`
}

type Verifier struct {
    // contains filtered or unexported fields
}

func NewVerifier(reg registry.Registry) *Verifier

func (v *Verifier) Verify(ctx context.Context, token string) (*Claims, error)

func (v *Verifier) VerifyWithOptions(ctx context.Context, token string, opts VerifyOptions) (*VerifyResult, error)

type VerifyMode int

const (
    // VerifyModeOnline performs real-time checks against the registry.
    // This includes revocation checks and agent status checks.
    VerifyModeOnline VerifyMode = iota

    // VerifyModeOffline uses only local trust store and revocation cache.
    // Does not make network requests.
    VerifyModeOffline

    // VerifyModeHybrid uses online checks when available, falls back to cache.
    VerifyModeHybrid
)

type VerifyOptions struct {
    // Mode determines online/offline verification behavior.
    Mode VerifyMode

    // TrustedIssuers is a list of allowed issuer DIDs (did:web or did:key).
    // If empty, all issuers are accepted (not recommended for production).
    // For Level 0 self-signed badges, the did:key issuer must be in this list
    // or AcceptSelfSigned must be true.
    TrustedIssuers []string

    // AcceptSelfSigned allows Level 0 self-signed badges (did:key issuer).
    // WARNING: Production verifiers SHOULD NOT accept self-signed badges
    // unless explicitly required for specific use cases.
    // Default: false (reject self-signed badges)
    AcceptSelfSigned bool

    // Audience is the verifier's identity for audience validation.
    // If set and badge has aud claim, verifier must be in audience.
    Audience string

    // SkipRevocationCheck disables revocation checking (for testing only).
    SkipRevocationCheck bool

    // SkipAgentStatusCheck disables agent status checking (for testing only).
    SkipAgentStatusCheck bool

    // RevocationCache provides cached revocations for offline mode.
    RevocationCache RevocationCache

    // StaleThreshold is the maximum age of cached data before it's considered stale.
    // RFC-002 v1.3: For IAL-2+ badges, stale cache causes verification to fail.
    // Default: 24 hours if not set.
    StaleThreshold time.Duration

    // FailOpen allows verification to succeed even when staleness checks fail.
    // WARNING: This is NOT recommended for production.
    // RFC-002 v1.3 requires fail-closed behavior by default.
    // Default: false (fail-closed)
    FailOpen bool

    // Now overrides the current time (for testing).
    Now func() time.Time
}

type VerifyResult struct {
    // Claims contains the verified badge claims.
    Claims *Claims

    // Mode indicates which verification mode was used.
    Mode VerifyMode

    // Warnings contains non-fatal issues encountered.
    Warnings []string
}

import "github.com/capiscio/capiscio-core/v2/pkg/crypto"

func CreateCanonicalJSON(card *agentcard.AgentCard) ([]byte, error)

type DefaultJWKSFetcher struct {
    // contains filtered or unexported fields
}

func NewDefaultJWKSFetcher() *DefaultJWKSFetcher

func (f *DefaultJWKSFetcher) Fetch(ctx context.Context, url string) (*jose.JSONWebKeySet, error)

func (f *DefaultJWKSFetcher) FlushCache()

func (f *DefaultJWKSFetcher) SetTTL(ttl time.Duration)

type JWKSFetcher interface {
    Fetch(ctx context.Context, url string) (*jose.JSONWebKeySet, error)
}

type SignatureResult struct {
    Index     int
    Valid     bool
    Algorithm string
    KeyID     string
    Issuer    string
    JWKSUri   string
    Error     string
}

type SignatureVerificationResult struct {
    Valid      bool
    Signatures []SignatureResult
    Summary    VerificationSummary
}

type VerificationSummary struct {
    Total  int
    Valid  int
    Failed int
    Errors []string
}

type Verifier struct {
    // contains filtered or unexported fields
}

func NewVerifier() *Verifier

func NewVerifierWithFetcher(fetcher JWKSFetcher) *Verifier

func (v *Verifier) VerifyAgentCardSignatures(ctx context.Context, card *agentcard.AgentCard) (*SignatureVerificationResult, error)

import "github.com/capiscio/capiscio-core/v2/pkg/did"

const (
    // Ed25519MulticodecPrefix is the multicodec prefix for Ed25519 public keys (0xed01)
    Ed25519MulticodecPrefix = 0xed01

    // Ed25519PublicKeySize is the size of an Ed25519 public key in bytes
    Ed25519PublicKeySize = 32
)

const DefaultDomain = "registry.capisc.io"

var (
    ErrInvalidDID         = errors.New("invalid DID format")
    ErrUnsupportedMethod  = errors.New("unsupported DID method (only did:web and did:key supported)")
    ErrMissingAgentID     = errors.New("missing agent ID in DID")
    ErrInvalidKeyDID      = errors.New("invalid did:key format")
    ErrUnsupportedKeyType = errors.New("unsupported key type in did:key (only Ed25519 supported)")
)

func NewAgentDID(domain, agentID string) string

func NewCapiscIOAgentDID(agentID string) string

func NewKeyDID(publicKey []byte) string

func PublicKeyFromKeyDID(didStr string) (ed25519.PublicKey, error)

type DID struct {
    // Method is the DID method ("web" or "key").
    Method string

    // Domain is the domain hosting the DID Document (did:web only).
    Domain string

    // Path segments after the domain (did:web only, e.g., ["agents", "my-agent-001"]).
    PathSegments []string

    // AgentID is the agent identifier (did:web only, extracted from path).
    AgentID string

    // PublicKey is the Ed25519 public key (did:key only, 32 bytes).
    PublicKey []byte

    // Raw is the original DID string.
    Raw string
}

func Parse(did string) (*DID, error)

func (d *DID) DocumentURL() string

func (d *DID) GetPublicKey() ed25519.PublicKey

func (d *DID) IsAgentDID() bool

func (d *DID) IsKeyDID() bool

func (d *DID) IsWebDID() bool

func (d *DID) String() string

import "github.com/capiscio/capiscio-core/v2/pkg/gateway"

func ExtractBadge(r *http.Request) string

func NewAuthMiddleware(verifier *badge.Verifier, next http.Handler) http.Handler

func NewPolicyMiddleware(verifier *badge.Verifier, config PEPConfig, next http.Handler, callbacks ...PolicyEventCallback) http.Handler

type PEPConfig struct {
    PDPClient       pip.PDPClient           // nil = badge-only mode (skip PDP)
    EnforcementMode pip.EnforcementMode     // default EMObserve
    ObligationReg   *pip.ObligationRegistry // nil = no obligation handling
    DecisionCache   pip.DecisionCache       // nil = no caching
    BreakGlassKey   crypto.PublicKey        // nil = break-glass disabled
    PEPID           string                  // PEP instance identifier
    Workspace       string                  // workspace/tenant identifier
    Logger          *slog.Logger            // nil = slog.Default()
}

type PolicyEvent struct {
    Decision     string
    DecisionID   string
    Override     bool
    OverrideJTI  string
    CacheHit     bool
    PDPLatencyMs int64
    Obligations  []string
    ErrorCode    string
}

type PolicyEventCallback func(event PolicyEvent, req *pip.DecisionRequest)

import "github.com/capiscio/capiscio-core/v2/pkg/mcp"

const (
    // CoreVersion is the capiscio-core version
    CoreVersion = "2.5.0"

    // ProtoVersion is the MCP proto schema version
    ProtoVersion = "1.0"

    // MinMCPVersion is the minimum compatible MCP SDK version (capiscio-mcp)
    // The MCP SDK has independent versioning starting from 0.1.0
    MinMCPVersion = "0.1.0"

    // MinVersion is the minimum compatible client SDK version (legacy capiscio-sdk)
    MinVersion = "2.5.0"

    // MaxVersionConstraint is the constraint for maximum compatible version
    MaxVersionConstraint = "< 3.0.0"
)

var (
    // ErrBadgeMissing indicates a badge was required but not provided
    ErrBadgeMissing = errors.New("badge required but not provided")

    // ErrBadgeInvalid indicates the badge is malformed or unverifiable
    ErrBadgeInvalid = errors.New("badge is invalid or malformed")

    // ErrBadgeExpired indicates the badge has expired
    ErrBadgeExpired = errors.New("badge has expired")

    // ErrBadgeRevoked indicates the badge has been revoked
    ErrBadgeRevoked = errors.New("badge has been revoked")

    // ErrTrustInsufficient indicates the trust level is below minimum required
    ErrTrustInsufficient = errors.New("trust level insufficient")

    // ErrToolNotAllowed indicates the tool is not in the allowed list
    ErrToolNotAllowed = errors.New("tool not allowed")

    // ErrIssuerUntrusted indicates the badge issuer is not trusted
    ErrIssuerUntrusted = errors.New("badge issuer not trusted")

    // ErrPolicyDenied indicates policy evaluation failed
    ErrPolicyDenied = errors.New("policy denied access")

    // ErrDIDInvalid indicates the DID is malformed
    ErrDIDInvalid = errors.New("DID is invalid")

    // ErrDIDMismatch indicates the badge subject doesn't match disclosed DID
    ErrDIDMismatch = errors.New("badge subject does not match disclosed DID")

    // ErrOriginMismatch indicates the transport origin doesn't match did:web host
    ErrOriginMismatch = errors.New("transport origin does not match DID host")

    // ErrPathMismatch indicates the endpoint path doesn't match did:web path
    ErrPathMismatch = errors.New("endpoint path does not match DID path")

    // ErrAPIKeyInvalid indicates the API key is invalid
    ErrAPIKeyInvalid = errors.New("API key is invalid")
)

func CheckVersionCompatibility(clientVersion string) (bool, string)

func CreatePoPRequest() (*pop.MCPPoPRequest, error)

func CreatePoPResponse(clientNonce string, privateKey ed25519.PrivateKey, keyID string) (*pop.MCPPoPResponse, error)

func ParsePoPFromMeta(meta map[string]interface{}) (*pop.MCPPoPRequest, *pop.MCPPoPResponse)

type AuthLevel int

const (
    AuthLevelUnspecified AuthLevel = iota
    AuthLevelAnonymous
    AuthLevelAPIKey
    AuthLevelBadge
)

func (a AuthLevel) String() string

type CallerCredential struct {
    // BadgeJWS is the full badge JWT (if badge auth)
    BadgeJWS string

    // APIKey is the API key (if API key auth)
    APIKey string

    // IsAnonymous is true if no credential was provided
    IsAnonymous bool
}

func NewAPIKeyCredential(apiKey string) CallerCredential

func NewAnonymousCredential() CallerCredential

func NewBadgeCredential(badgeJWS string) CallerCredential

func (c CallerCredential) GetAuthLevel() AuthLevel

type Decision int

const (
    DecisionUnspecified Decision = iota
    DecisionAllow
    DecisionDeny
)

func (d Decision) String() string

type DenyReason int

const (
    DenyReasonUnspecified DenyReason = iota
    DenyReasonBadgeMissing
    DenyReasonBadgeInvalid
    DenyReasonBadgeExpired
    DenyReasonBadgeRevoked
    DenyReasonTrustInsufficient
    DenyReasonToolNotAllowed
    DenyReasonIssuerUntrusted
    DenyReasonPolicyDenied
)

func ErrorToDenyReason(err error) DenyReason

func (r DenyReason) String() string

type Dependencies struct {
    BadgeVerifier *badge.Verifier
    EvidenceStore EvidenceStore
}

type EvaluateConfig struct {
    // TrustedIssuers is a list of trusted badge issuers
    TrustedIssuers []string

    // MinTrustLevel is the minimum required trust level (0-4)
    MinTrustLevel int

    // AcceptLevelZero allows self-signed did:key badges (Trust Level 0)
    AcceptLevelZero bool

    // AllowedTools is a list of allowed tool patterns (glob patterns)
    AllowedTools []string

    // PolicyVersion is the version of the policy being applied (RFC-006 §7.2)
    PolicyVersion string
}

type EvaluateResult struct {
    // Decision is the access decision (allow or deny)
    Decision Decision

    // DenyReason is the reason for denial (only set if Decision == DecisionDeny)
    DenyReason DenyReason

    // DenyDetail is a human-readable denial detail
    DenyDetail string

    // AgentDID is the extracted agent DID
    AgentDID string

    // BadgeJTI is the badge ID (if present)
    BadgeJTI string

    // AuthLevel is the authentication level
    AuthLevel AuthLevel

    // TrustLevel is the verified trust level (0-4)
    TrustLevel int

    // EvidenceJSON is the RFC-006 §7 compliant evidence JSON
    EvidenceJSON string

    // EvidenceID is the unique evidence record ID
    EvidenceID string

    // Timestamp is when the evaluation occurred
    Timestamp time.Time

    // PolicyDecisionID is the PDP decision ID (RFC-005, only set when PDP is configured)
    PolicyDecisionID string

    // PolicyDecision is the PDP decision string: ALLOW, DENY, or ALLOW_OBSERVE (RFC-005)
    PolicyDecision string
}

type EvaluateToolAccessInput struct {
    ToolName   string
    ParamsHash string
    Origin     string
    Credential CallerCredential
    Config     *EvaluateConfig
}

type EvidenceRateLimiter struct {
    // contains filtered or unexported fields
}

func NewEvidenceRateLimiter(window time.Duration, maxPerWindow int) *EvidenceRateLimiter

func (r *EvidenceRateLimiter) IsRateLimited(record EvidenceRecord) bool

type EvidenceRecord struct {
    // EventName MUST be "capiscio.tool_invocation" per RFC-006 §7.2
    EventName string `json:"event.name"`

    // AgentDID is the agent DID or equivalent principal
    AgentDID string `json:"capiscio.agent.did"`

    // BadgeJTI is the badge identifier, if present
    BadgeJTI string `json:"capiscio.badge.jti,omitempty"`

    // AuthLevel is "badge", "apikey", or "anonymous"
    AuthLevel string `json:"capiscio.auth.level"`

    // Target is the tool identifier
    Target string `json:"capiscio.target"`

    // PolicyVersion is the policy version used
    PolicyVersion string `json:"capiscio.policy_version"`

    // Decision is "ALLOW" or "DENY"
    Decision string `json:"capiscio.decision"`

    // ParamsHash is the SHA-256 hash of canonicalized tool parameters (optional)
    ParamsHash string `json:"capiscio.tool.params_hash,omitempty"`

    // DenyReason is the error code when decision is DENY (optional)
    DenyReason string `json:"capiscio.deny_reason,omitempty"`

    // Non-RFC fields for internal use
    ID           string    `json:"id"`
    Timestamp    time.Time `json:"timestamp"`
    TrustLevel   int       `json:"trust_level"`
    ServerOrigin string    `json:"server_origin,omitempty"`
}

type EvidenceStore interface {
    // Store saves an evidence record
    Store(ctx context.Context, record EvidenceRecord) error
}

type EvidenceStoreMode string