agentevo-core 0.1.0__py3-none-any.whl

agentevo_core/__init__.py

@@ -0,0 +1,181 @@
+"""Agentevo core domain contracts (classification, events, objects, trust, errors)."""
+
+from agentevo_core.actions import (
+    MAX_ACTION_STRING_LENGTH as MAX_ACTION_STRING_LENGTH,
+    MAX_ACTION_TYPE_LENGTH as MAX_ACTION_TYPE_LENGTH,
+    MAX_TIMEOUT_SECONDS as MAX_TIMEOUT_SECONDS,
+    ActionFallback as ActionFallback,
+    ActionIdempotency as ActionIdempotency,
+    ActionTarget as ActionTarget,
+    TargetKind as TargetKind,
+    TypedAction as TypedAction,
+)
+from agentevo_core.classification import (
+    Classification as Classification,
+    PrivacyMode as PrivacyMode,
+    inherit_source as inherit_source,
+    must_redact_before_persistence as must_redact_before_persistence,
+    saas_egress_allowed as saas_egress_allowed,
+)
+from agentevo_core.compat import Compat as Compat, auto_exec_allowed as auto_exec_allowed
+from agentevo_core.dlp_patterns import (
+    DETECTOR_PATTERNS as DETECTOR_PATTERNS,
+    DetectorPattern as DetectorPattern,
+)
+from agentevo_core.errors import (
+    HTTP_STATUS as HTTP_STATUS,
+    AgentevoError as AgentevoError,
+    ErrorCode as ErrorCode,
+    retryable as retryable,
+)
+from agentevo_core.events import (
+    CanonicalEvent as CanonicalEvent,
+    EventEnvironment as EventEnvironment,
+    EventProvenance as EventProvenance,
+    EventSource as EventSource,
+    EventType as EventType,
+    compute_content_hash as compute_content_hash,
+)
+from agentevo_core.idempotency import (
+    MAX_IDEMPOTENCY_KEY_LENGTH as MAX_IDEMPOTENCY_KEY_LENGTH,
+    IdempotencyTier as IdempotencyTier,
+    auto_retry_allowed as auto_retry_allowed,
+    body_conflicts as body_conflicts,
+    check_expected_version as check_expected_version,
+    validate_key as validate_key,
+)
+from agentevo_core.metering import (
+    BILLABLE_OPERATIONS as BILLABLE_OPERATIONS,
+    FREE_MONTHLY_BILLABLE_REQUESTS as FREE_MONTHLY_BILLABLE_REQUESTS,
+    MAX_BATCH_EVENTS as MAX_BATCH_EVENTS,
+    NON_BILLABLE_OPERATIONS as NON_BILLABLE_OPERATIONS,
+    is_billable as is_billable,
+)
+from agentevo_core.objects import (
+    LearnedObject as LearnedObject,
+    LearnedObjectType as LearnedObjectType,
+    Ownership as Ownership,
+    Validity as Validity,
+    Verification as Verification,
+)
+from agentevo_core.risk import (
+    GuardVerdict as GuardVerdict,
+    RiskClass as RiskClass,
+    apply_policy_risk as apply_policy_risk,
+    is_high_or_destructive as is_high_or_destructive,
+    requires_human_approval as requires_human_approval,
+)
+from agentevo_core.sync import (
+    CURSOR_VERSION as CURSOR_VERSION,
+    ED25519_PUBLIC_KEY_BYTES as ED25519_PUBLIC_KEY_BYTES,
+    ED25519_SIGNATURE_BYTES as ED25519_SIGNATURE_BYTES,
+    ENVELOPE_VERSION as ENVELOPE_VERSION,
+    MAX_CURSOR_LENGTH as MAX_CURSOR_LENGTH,
+    MAX_ENVELOPE_BYTES as MAX_ENVELOPE_BYTES,
+    MAX_NONCE_LENGTH as MAX_NONCE_LENGTH,
+    MAX_PULL_LIMIT as MAX_PULL_LIMIT,
+    PUSH_BATCH_LIMIT as PUSH_BATCH_LIMIT,
+    REPLAY_WINDOW as REPLAY_WINDOW,
+    DeltaKind as DeltaKind,
+    PullPage as PullPage,
+    PushAccepted as PushAccepted,
+    PushReceipt as PushReceipt,
+    SyncEnvelope as SyncEnvelope,
+    canonical_json as canonical_json,
+    content_hash_for as content_hash_for,
+    decode_cursor as decode_cursor,
+    encode_cursor as encode_cursor,
+    initial_cursor as initial_cursor,
+    within_replay_window as within_replay_window,
+)
+from agentevo_core.trust import (
+    LEGAL_TRANSITIONS as LEGAL_TRANSITIONS,
+    TERMINAL_STATES as TERMINAL_STATES,
+    ApprovalRecord as ApprovalRecord,
+    PromotionRequirement as PromotionRequirement,
+    Tombstone as Tombstone,
+    TrustState as TrustState,
+    check_transition as check_transition,
+    may_transition as may_transition,
+    promotion_requirement as promotion_requirement,
+)
+
+__all__ = [
+    "BILLABLE_OPERATIONS",
+    "CURSOR_VERSION",
+    "DETECTOR_PATTERNS",
+    "ED25519_PUBLIC_KEY_BYTES",
+    "ED25519_SIGNATURE_BYTES",
+    "ENVELOPE_VERSION",
+    "FREE_MONTHLY_BILLABLE_REQUESTS",
+    "HTTP_STATUS",
+    "LEGAL_TRANSITIONS",
+    "MAX_ACTION_STRING_LENGTH",
+    "MAX_ACTION_TYPE_LENGTH",
+    "MAX_BATCH_EVENTS",
+    "MAX_CURSOR_LENGTH",
+    "MAX_ENVELOPE_BYTES",
+    "MAX_IDEMPOTENCY_KEY_LENGTH",
+    "MAX_NONCE_LENGTH",
+    "MAX_PULL_LIMIT",
+    "MAX_TIMEOUT_SECONDS",
+    "NON_BILLABLE_OPERATIONS",
+    "PUSH_BATCH_LIMIT",
+    "REPLAY_WINDOW",
+    "TERMINAL_STATES",
+    "ActionFallback",
+    "ActionIdempotency",
+    "ActionTarget",
+    "AgentevoError",
+    "ApprovalRecord",
+    "CanonicalEvent",
+    "Classification",
+    "Compat",
+    "DeltaKind",
+    "DetectorPattern",
+    "ErrorCode",
+    "EventEnvironment",
+    "EventProvenance",
+    "EventSource",
+    "EventType",
+    "GuardVerdict",
+    "IdempotencyTier",
+    "LearnedObject",
+    "LearnedObjectType",
+    "Ownership",
+    "PrivacyMode",
+    "PromotionRequirement",
+    "PullPage",
+    "PushAccepted",
+    "PushReceipt",
+    "RiskClass",
+    "SyncEnvelope",
+    "TargetKind",
+    "Tombstone",
+    "TrustState",
+    "TypedAction",
+    "Validity",
+    "Verification",
+    "apply_policy_risk",
+    "auto_exec_allowed",
+    "auto_retry_allowed",
+    "body_conflicts",
+    "canonical_json",
+    "check_expected_version",
+    "check_transition",
+    "compute_content_hash",
+    "content_hash_for",
+    "decode_cursor",
+    "encode_cursor",
+    "inherit_source",
+    "initial_cursor",
+    "is_billable",
+    "is_high_or_destructive",
+    "may_transition",
+    "must_redact_before_persistence",
+    "promotion_requirement",
+    "requires_human_approval",
+    "retryable",
+    "validate_key",
+    "within_replay_window",
+]

agentevo_core/actions.py

@@ -0,0 +1,323 @@
+"""Typed action contract: the executable unit agents propose and guards evaluate.
+
+Spec: PRD §20, API §21. Actions are typed data (never prompt strings): nine
+contract fields plus the declared timeout/retry policy. Secrets appear only as
+``vault://`` references; structural validation lives here, secret-shape
+rejection at the guard boundary (local DLP).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any
+
+from agentevo_core.errors import AgentevoError, ErrorCode
+from agentevo_core.risk import RiskClass
+
+#: Longest canonical operation identifier (adapter-mapped tool capability).
+MAX_ACTION_TYPE_LENGTH = 128
+
+#: Longest single argument key / permission / condition string.
+MAX_ACTION_STRING_LENGTH = 1024
+
+#: Upper bound for a declared step timeout (24h; policy may cap lower).
+MAX_TIMEOUT_SECONDS = 86400.0
+
+_ACTION_TYPE_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:-]*\Z")
+
+
+class ActionIdempotency(StrEnum):
+    """Retry semantics the execution engine must honor."""
+
+    SAFE = "safe"
+    BUSINESS_KEY = "business-key"
+    UNSAFE = "unsafe"
+
+
+class ActionFallback(StrEnum):
+    """What the runner may do when the deterministic path stops."""
+
+    STOP = "stop"
+    REQUIRE_APPROVAL = "require_approval"
+    INVOKE_AGENT = "invoke_agent"
+
+
+class TargetKind(StrEnum):
+    """Closed vocabulary for typed resource references."""
+
+    PATH = "path"
+    REPO = "repo"
+    SERVICE = "service"
+    API = "api"
+    DB = "db"
+    NONE = "none"
+
+
+@dataclass(frozen=True)
+class ActionTarget:
+    """Typed resource reference. ``NONE`` carries no ``ref``."""
+
+    kind: TargetKind
+    ref: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        """JSON-ready mapping (enums as values)."""
+        return {"kind": self.kind.value, "ref": self.ref}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ActionTarget:
+        """Parse a mapping; 400 INVALID_ARGUMENT when malformed."""
+        if not isinstance(data, dict):
+            raise AgentevoError(ErrorCode.INVALID_ARGUMENT, "target must be an object", {})
+        try:
+            target = cls(kind=TargetKind(data["kind"]), ref=data.get("ref", ""))
+        except (KeyError, ValueError, TypeError) as exc:
+            raise AgentevoError(ErrorCode.INVALID_ARGUMENT, f"malformed target: {exc}", {}) from exc
+        target.validate()
+        return target
+
+    def validate(self) -> None:
+        """Raise 400 INVALID_ARGUMENT unless the reference is well-formed."""
+        if not isinstance(self.kind, TargetKind):
+            raise AgentevoError(
+                ErrorCode.INVALID_ARGUMENT,
+                f"unknown target kind: {self.kind!r}",
+                {"kind": str(self.kind)},
+            )
+        if self.kind is TargetKind.NONE:
+            if self.ref != "":
+                raise AgentevoError(
+                    ErrorCode.INVALID_ARGUMENT,
+                    "target NONE must not carry a ref",
+                    {"ref": self.ref[:64]},
+                )
+            return
+        if not self.ref or len(self.ref) > MAX_ACTION_STRING_LENGTH:
+            raise AgentevoError(
+                ErrorCode.INVALID_ARGUMENT,
+                "target ref must be a non-empty string",
+                {"kind": self.kind.value},
+            )
+
+
+@dataclass(frozen=True)
+class TypedAction:
+    """One guard-evaluated action: nine contract fields plus retry policy."""
+
+    action_type: str
+    target: ActionTarget
+    arguments: dict[str, Any]
+    preconditions: tuple[str, ...]
+    postcondition: str | None
+    risk_class: RiskClass
+    permissions: tuple[str, ...]
+    idempotency: ActionIdempotency
+    fallback: ActionFallback
+    timeout_seconds: float = 60.0
+    max_retries: int = 0
+
+    def validate(self) -> None:
+        """Raise 400 INVALID_ARGUMENT unless the action is well-formed."""
+        _check_type(self.action_type)
+        self.target.validate()
+        _check_arguments(self.arguments)
+        _check_conditions(self.preconditions, self.postcondition)
+        _check_policy_fields(self)
+
+    def ensure_executable(self) -> None:
+        """Raise 400 unless the action may run on the compiled path.
+
+        A machine-checkable postcondition is required for compiled execution
+        (API §21); advisory/interpreted paths may omit it.
+        """
+        self.validate()
+        if not self.postcondition:
+            raise AgentevoError(
+                ErrorCode.INVALID_ARGUMENT,
+                "compiled execution requires a postcondition",
+                {"action_type": self.action_type},
+            )
+
+    def to_dict(self) -> dict[str, Any]:
+        """JSON-ready mapping (enums as values, tuples as lists)."""
+        return {
+            "action_type": self.action_type,
+            "target": self.target.to_dict(),
+            "arguments": self.arguments,
+            "preconditions": list(self.preconditions),
+            "postcondition": self.postcondition,
+            "risk_class": self.risk_class.value,
+            "permissions": list(self.permissions),
+            "idempotency": self.idempotency.value,
+            "fallback": self.fallback.value,
+            "timeout_seconds": self.timeout_seconds,
+            "max_retries": self.max_retries,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TypedAction:
+        """Parse a mapping; 400 INVALID_ARGUMENT when malformed."""
+        if not isinstance(data, dict):
+            raise AgentevoError(ErrorCode.INVALID_ARGUMENT, "action must be an object", {})
+        for key in ("preconditions", "permissions"):
+            value = data.get(key, ())
+            if not isinstance(value, (list, tuple)):
+                raise AgentevoError(
+                    ErrorCode.INVALID_ARGUMENT,
+                    f"action {key} must be a list",
+                    {"key": key},
+                )
+        try:
+            action = cls(
+                action_type=data["action_type"],
+                target=ActionTarget.from_dict(data["target"]),
+                arguments=data.get("arguments", {}),
+                preconditions=tuple(data.get("preconditions", ())),
+                postcondition=data.get("postcondition"),
+                risk_class=RiskClass(data["risk_class"]),
+                permissions=tuple(data.get("permissions", ())),
+                idempotency=ActionIdempotency(data["idempotency"]),
+                fallback=ActionFallback(data["fallback"]),
+                timeout_seconds=data.get("timeout_seconds", 60.0),
+                max_retries=data.get("max_retries", 0),
+            )
+        except (KeyError, ValueError, TypeError) as exc:
+            raise AgentevoError(ErrorCode.INVALID_ARGUMENT, f"malformed action: {exc}", {}) from exc
+        action.validate()
+        return action
+
+    def canonical_hash(self) -> str:
+        """SHA-256 over canonical JSON. Approval tokens bind to this."""
+        canonical = {
+            "action_type": self.action_type,
+            "arguments": self.arguments,
+            "fallback": self.fallback.value,
+            "idempotency": self.idempotency.value,
+            "max_retries": self.max_retries,
+            "permissions": list(self.permissions),
+            "postcondition": self.postcondition,
+            "preconditions": list(self.preconditions),
+            "risk_class": self.risk_class.value,
+            "target": {"kind": self.target.kind.value, "ref": self.target.ref},
+            "timeout_seconds": self.timeout_seconds,
+        }
+        blob = json.dumps(canonical, sort_keys=True, separators=(",", ":"), default=str)
+        return f"sha256:{hashlib.sha256(blob.encode('utf-8')).hexdigest()}"
+
+
+def _check_type(action_type: str) -> None:
+    if (
+        not isinstance(action_type, str)
+        or not action_type
+        or len(action_type) > MAX_ACTION_TYPE_LENGTH
+        or _ACTION_TYPE_RE.match(action_type) is None
+    ):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "action_type must be a canonical operation identifier",
+            {"action_type": str(action_type)[:64]},
+        )
+
+
+def _check_arguments(arguments: dict[str, Any]) -> None:
+    if not isinstance(arguments, dict):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "arguments must be an object",
+            {"type": type(arguments).__name__},
+        )
+    for key in arguments:
+        if not isinstance(key, str) or not key or len(key) > MAX_ACTION_STRING_LENGTH:
+            raise AgentevoError(
+                ErrorCode.INVALID_ARGUMENT,
+                "argument keys must be non-empty strings",
+                {"key": str(key)[:64]},
+            )
+    try:
+        json.dumps(arguments, sort_keys=True, separators=(",", ":"))
+    except (TypeError, ValueError) as exc:
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            f"arguments must be JSON-serializable: {exc}",
+            {},
+        ) from exc
+
+
+def _check_conditions(preconditions: tuple[str, ...], postcondition: str | None) -> None:
+    for condition in preconditions:
+        if not isinstance(condition, str) or not condition:
+            raise AgentevoError(
+                ErrorCode.INVALID_ARGUMENT,
+                "preconditions must be non-empty strings",
+                {},
+            )
+    if postcondition is not None and (not isinstance(postcondition, str) or not postcondition):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "postcondition must be a non-empty string or null",
+            {},
+        )
+
+
+def _check_policy_fields(action: TypedAction) -> None:
+    if not isinstance(action.risk_class, RiskClass):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            f"unknown risk class: {action.risk_class!r}",
+            {"risk_class": str(action.risk_class)},
+        )
+    if (
+        not action.permissions
+        or any(not p or not isinstance(p, str) for p in action.permissions)
+        or any(len(p) > MAX_ACTION_STRING_LENGTH for p in action.permissions)
+    ):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "permissions must list the exact required capabilities",
+            {"action_type": action.action_type},
+        )
+    if not isinstance(action.idempotency, ActionIdempotency):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            f"unknown idempotency: {action.idempotency!r}",
+            {"idempotency": str(action.idempotency)},
+        )
+    if not isinstance(action.fallback, ActionFallback):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            f"unknown fallback: {action.fallback!r}",
+            {"fallback": str(action.fallback)},
+        )
+    timeout = action.timeout_seconds
+    if (
+        not isinstance(timeout, (int, float))
+        or isinstance(timeout, bool)
+        or not math.isfinite(timeout)
+        or timeout <= 0
+        or timeout > MAX_TIMEOUT_SECONDS
+    ):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "timeout_seconds must be within (0, 86400]",
+            {"action_type": action.action_type},
+        )
+    retries = action.max_retries
+    if not isinstance(retries, int) or isinstance(retries, bool) or retries < 0:
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "max_retries must be a non-negative integer",
+            {"action_type": action.action_type},
+        )
+    if retries > 0 and (
+        action.idempotency is ActionIdempotency.UNSAFE or action.risk_class is RiskClass.DESTRUCTIVE
+    ):
+        raise AgentevoError(
+            ErrorCode.INVALID_ARGUMENT,
+            "unsafe or destructive actions are never auto-retried",
+            {"action_type": action.action_type},
+        )

agentevo_core/classification.py

@@ -0,0 +1,55 @@
+"""Data classification C0-C4 and SaaS-egress rules.
+
+Spec: PRD §7, Data Flow §4, API §18. Embeddings and derivatives inherit the
+classification of their source text. Telemetry schemas are allow-lists with no
+generic payload field.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class Classification(StrEnum):
+    """Sensitivity class. Higher number means more sensitive."""
+
+    C0 = "C0"  # Public: SDK versions, public schemas.
+    C1 = "C1"  # Control: tenant/user IDs, plan, counters, flags, device public keys.
+    C2 = "C2"  # Derived sanitized: skill steps, fingerprints, verification summaries.
+    C3 = "C3"  # Raw operational: prompts, outputs, tool I/O, code, diffs, logs.
+    C4 = "C4"  # Secrets: tokens, keys, cookies, auth headers. Never a valid payload.
+
+
+class PrivacyMode(StrEnum):
+    """Deployment privacy modes. Local-only is the default."""
+
+    LOCAL_ONLY = "local_only"
+    OPAQUE_RELAY = "opaque_relay"  # Cloud stores E2EE envelopes only, no semantic index.
+    SEARCHABLE_MANAGED_SYNC = "searchable_managed_sync"  # Sanitized C2, tenant-scoped.
+    CUSTOMER_VPC = "customer_vpc"  # Data plane in the customer VPC, same logical contract.
+
+
+def inherit_source(source: Classification) -> Classification:
+    """Derivatives (embeddings, summaries, fingerprints) inherit source classification."""
+    return source
+
+
+def saas_egress_allowed(payload: Classification, mode: PrivacyMode) -> bool:
+    """Whether a payload class may leave the customer boundary for Agentevo SaaS.
+
+    C4 is never allowed anywhere. C3 has no SaaS endpoint in any mode. C2
+    requires an explicit sync mode. C0/C1 are the default SaaS payload.
+
+    Note: in CUSTOMER_VPC mode the C2/C3 plane runs inside the customer VPC, so
+    Agentevo SaaS itself still receives C0/C1 only — hence ``False`` for C2.
+    """
+    if payload is Classification.C4 or payload is Classification.C3:
+        return False
+    if payload is Classification.C2:
+        return mode in (PrivacyMode.OPAQUE_RELAY, PrivacyMode.SEARCHABLE_MANAGED_SYNC)
+    return True
+
+
+def must_redact_before_persistence(payload: Classification) -> bool:
+    """C4 must be replaced by a redaction marker or opaque vault reference."""
+    return payload is Classification.C4

agentevo_core/compat.py

@@ -0,0 +1,32 @@
+"""Layered environment-compatibility classification.
+
+Spec: PRD §18. Compatibility is layered (artifact hashes, dependency-lock
+subset, tool/API/model versions, schema, policy) — never a whole-repo hash.
+Fail closed: high-risk or destructive auto-execution is denied when
+compatibility is UNKNOWN or INCOMPATIBLE. Low/medium risk gets a grace path
+under UNKNOWN; INCOMPATIBLE denies all auto-execution.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+from agentevo_core.risk import RiskClass
+
+
+class Compat(StrEnum):
+    """Environment compatibility of a learned object against the current run."""
+
+    EXACT = "EXACT"
+    COMPATIBLE = "COMPATIBLE"
+    UNKNOWN = "UNKNOWN"
+    INCOMPATIBLE = "INCOMPATIBLE"
+
+
+def auto_exec_allowed(compat: Compat, risk: RiskClass) -> bool:
+    """Fail-closed auto-execution matrix for compatibility vs risk."""
+    if compat is Compat.INCOMPATIBLE:
+        return False
+    if compat is Compat.UNKNOWN:
+        return risk in (RiskClass.LOW, RiskClass.MEDIUM)
+    return True

agentevo_core/dlp_patterns.py

@@ -0,0 +1,82 @@
+"""Shared C4 detector patterns (single source for both DLP passes).
+
+Spec: Data Flow §8, API §12/§17. The local runtime redacts with these
+patterns before egress; the managed server re-scans with the same
+patterns at ingest (second-pass DLP, 422 on C4). Keeping the expressions
+here guarantees the two passes can never drift apart. Entropy heuristics
+stay local-only: the server gate is high-signal patterns, fail-closed,
+with no fuzzy rejection of legitimate compact C2 content.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import NamedTuple
+
+
+class DetectorPattern(NamedTuple):
+    """One named C4 pattern (regex source shared by both passes)."""
+
+    name: str
+    label: str
+    expression: str
+    flags: int = 0
+
+
+#: Ordered most-specific-first; on overlap the earlier detector wins.
+DETECTOR_PATTERNS: tuple[DetectorPattern, ...] = (
+    DetectorPattern(
+        "pem_private_key",
+        "private_key",
+        r"-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----"
+        r".*?-----END [A-Z0-9 ]*PRIVATE KEY-----",
+        re.DOTALL,
+    ),
+    DetectorPattern("aws_access_key", "aws_access_key", r"AKIA[0-9A-Z]{16}"),
+    DetectorPattern(
+        "aws_secret",
+        "aws_secret",
+        r"(?i)aws_secret_access_key[\"'\s:=]+[A-Za-z0-9/+=]{40}",
+    ),
+    DetectorPattern(
+        "github_token",
+        "github_token",
+        r"(?:ghp_[A-Za-z0-9]{8,}|gho_[A-Za-z0-9]{8,}|github_pat_[A-Za-z0-9_]{8,})",
+    ),
+    DetectorPattern("gitlab_token", "gitlab_token", r"glpat-[A-Za-z0-9_-]{8,}"),
+    DetectorPattern("anthropic_key", "anthropic_key", r"sk-ant-[A-Za-z0-9_-]{8,}"),
+    DetectorPattern("openai_project_key", "openai_key", r"sk-proj-[A-Za-z0-9_-]{8,}"),
+    DetectorPattern("openai_key", "openai_key", r"sk-[A-Za-z0-9]{20,}"),
+    DetectorPattern("google_api_key", "google_api_key", r"AIza[0-9A-Za-z_-]{35}"),
+    DetectorPattern(
+        "stripe_secret",
+        "stripe_secret",
+        r"(?:sk_live|rk_live)_[A-Za-z0-9]{10,}",
+    ),
+    DetectorPattern("slack_token", "slack_token", r"xox[baprs]-[A-Za-z0-9-]{8,}"),
+    DetectorPattern(
+        "jwt",
+        "jwt",
+        r"eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}",
+    ),
+    DetectorPattern(
+        "bearer_token",
+        "bearer_token",
+        r"(?i)Bearer\s+[A-Za-z0-9._~+/-]{8,}",
+    ),
+    DetectorPattern("basic_auth", "basic_auth", r"(?i)Basic\s+[A-Za-z0-9+/=]{8,}"),
+    DetectorPattern(
+        "url_password",
+        "url_password",
+        r"(?i)([a-z][a-z0-9+.-]*://[^/\s:@]+:)([^/\s@]{1,})@",
+    ),
+    DetectorPattern(
+        "password_assignment",
+        "password",
+        # Requires an explicit : or = separator so prose ("secret sauce") and
+        # bare commands ("pwd /home/user") do not match. JSON, env, YAML, and
+        # header assignments ("password": "...", API_KEY=..., key: ...) match.
+        r"(?i)(?:password|passwd|pwd|secret|api[_-]?key|auth[_-]?token|"
+        r"access[_-]?token|session(?:id|[_-]?token)?)[\"']?\s*[:=]\s*[\"']?[^\s\"',;}]{4,}",
+    ),
+)