arbiter-smtp 0.9.1.dev2__tar.gz → 0.9.2.dev1__tar.gz

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arbiter-smtp
-Version: 0.9.1.dev2
+Version: 0.9.2.dev1
 Summary: SMTP service plugin for Arbiter
 Author-email: Omry Yadan <omry@yadan.net>
 Maintainer-email: Omry Yadan <omry@yadan.net>
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Communications :: Email
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: arbiter-server<0.10.0,>=0.9.1.dev2
+Requires-Dist: arbiter-server<0.10.0,>=0.9.2.dev1
 Requires-Dist: diskcache<6.0,>=5.6
 
 SMTP service plugin for Arbiter.

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "arbiter-smtp"
-version = "0.9.1.dev2"
+version = "0.9.2.dev1"
 description = "SMTP service plugin for Arbiter"
 readme = { text = "SMTP service plugin for Arbiter.", content-type = "text/markdown" }
 requires-python = ">=3.10,<3.15"
@@ -29,7 +29,7 @@ classifiers = [
   "Topic :: Communications :: Email",
 ]
 dependencies = [
-  "arbiter-server>=0.9.1.dev2,<0.10.0",
+  "arbiter-server>=0.9.2.dev1,<0.10.0",
   "diskcache>=5.6,<6.0",
 ]
 
@@ -54,5 +54,5 @@ name = "Arbiter SMTP"
 package = "arbiter_smtp"
 package_dir = "src"
 filename = "NEWS.md"
-directory = "newsfragments"
+directory = "news"
 issue_format = "#{issue}"

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/src/arbiter_smtp/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from email import policy as email_policy
 from email.message import EmailMessage
@@ -17,6 +17,8 @@ from hydra.core.config_store import ConfigStore
 
 from arbiter_server.services import (
     CapabilityDescriptor,
+    ConfigCheckError,
+    ConfigCheckIssue,
     OperationDescriptor,
     ServicePluginContext,
     ServiceRuntimeContext,
@@ -30,6 +32,7 @@ from .config import (
     register_configs as register_smtp_configs,
 )
 from .idempotency import SMTPIdempotencyResult, SMTPIdempotencyStore
+from .runtime_policy import _SMTPRuntimePolicyMixin
 
 SERVER_API_VERSION = "0.9"
 
@@ -67,6 +70,13 @@ class SMTPClientProtocol(Protocol):
 
 
 class SentMessageAppender(Protocol):
+    def check_destination(
+        self,
+        *,
+        account: str,
+        folder: str | None,
+    ) -> SentCopyDestination: ...
+
     def resolve_destination(
         self,
         *,
@@ -94,51 +104,39 @@ SEND_EMAIL_DESCRIPTION = (
     "one of text_body or html_body."
 )
 
-SEND_EMAIL_INPUT_SCHEMA: dict[str, object] = {
-    "type": "object",
-    "properties": {
-        "account": {
-            "type": "string",
-            "description": "Configured SMTP account name.",
-        },
-        "to": {
-            "type": "array",
-            "items": {"type": "string"},
-            "description": "Primary recipient email addresses.",
-        },
-        "subject": {
-            "type": "string",
-            "description": "Email subject line.",
-        },
-        "text_body": {
-            "type": "string",
-            "description": "Plain text body.",
-        },
-        "html_body": {
-            "type": "string",
-            "description": "HTML body.",
-        },
-        "cc": {
-            "type": "array",
-            "items": {"type": "string"},
-            "description": "CC recipient email addresses.",
-        },
-        "bcc": {
-            "type": "array",
-            "items": {"type": "string"},
-            "description": "BCC recipient email addresses.",
-        },
-        "idempotency_key": {
-            "type": "string",
-            "description": "Optional caller-supplied key for retry-safe dedupe.",
-        },
-    },
-    "required": ["account", "to", "subject"],
-    "additionalProperties": False,
-}
-
-
-class SMTPRuntime:
+
+@dataclass(frozen=True)
+class SendEmailInput:
+    account: str = field(
+        metadata={"description": "Configured SMTP account name."},
+    )
+    to: list[str] = field(
+        metadata={"description": "Primary recipient email addresses."},
+    )
+    subject: str = field(metadata={"description": "Email subject line."})
+    text_body: str | None = field(
+        default=None,
+        metadata={"description": "Plain text body."},
+    )
+    html_body: str | None = field(
+        default=None,
+        metadata={"description": "HTML body."},
+    )
+    cc: list[str] | None = field(
+        default=None,
+        metadata={"description": "CC recipient email addresses."},
+    )
+    bcc: list[str] | None = field(
+        default=None,
+        metadata={"description": "BCC recipient email addresses."},
+    )
+    idempotency_key: str | None = field(
+        default=None,
+        metadata={"description": "Optional caller-supplied key for retry-safe dedupe."},
+    )
+
+
+class SMTPRuntime(_SMTPRuntimePolicyMixin):
     service_name = "smtp"
 
     def __init__(
@@ -179,16 +177,19 @@ class SMTPRuntime:
                 "policy": account.policy,
                 "enabled": True,
                 "send": "allowed",
-                "require_confirmation": self._policies[
-                    account.policy
-                ].require_confirmation,
             }
             for account_name, account in sorted(self._accounts.items())
         }
 
-    def test_accounts(self) -> dict[str, object]:
+    def test_accounts(
+        self,
+        *,
+        progress: Callable[[str], None] | None = None,
+    ) -> dict[str, object]:
         results: dict[str, object] = {}
         for account_name, smtp_config in sorted(self._accounts.items()):
+            if progress is not None:
+                progress(account_name)
             smtp_policy = self._policies[smtp_config.policy]
             stage = "connect_auth_noop_idempotency"
             strict_sent_copy = self._sent_copy_requires_readiness_check(smtp_policy)
@@ -309,8 +310,18 @@ class SMTPRuntime:
                     account=account,
                     smtp_config=smtp_config,
                     smtp_policy=smtp_policy,
+                    enforce_required=False,
                 )
             )
+            sent_copy_decision = self._sent_copy_preflight_decision(
+                smtp_policy=smtp_policy,
+                result=sent_copy_result,
+            ).evaluate()
+            if not sent_copy_decision.allowed:
+                raise RuntimeError(
+                    sent_copy_decision.why_not
+                    or "send_email sent-copy preflight failed"
+                )
             self._consume_rate_limit(account, smtp_policy)
             smtp_client = self._smtp_client_factory(smtp_config)
             smtp_client.send(
@@ -362,6 +373,66 @@ class SMTPRuntime:
         self._raise_if_submitted_sent_copy_required(result, smtp_policy)
         return result
 
+    def check_operation(
+        self,
+        operation: str,
+        arguments: Mapping[str, object],
+    ) -> dict[str, object]:
+        operation_id = f"smtp:{operation}"
+        if operation != "send_email":
+            return {
+                "operation": operation_id,
+                "allowed": False,
+                "why_not": f"unknown SMTP operation: {operation}",
+            }
+        account = cast(str, arguments.get("account"))
+        try:
+            smtp_config, smtp_policy = self._resolve_context(account)
+            recipients_to = self._normalize_recipients(
+                "to", cast(list[str], arguments.get("to"))
+            )
+            recipients_cc = self._normalize_recipients(
+                "cc", cast(list[str] | None, arguments.get("cc")) or []
+            )
+            recipients_bcc = self._normalize_recipients(
+                "bcc", cast(list[str] | None, arguments.get("bcc")) or []
+            )
+            text_body = cast(str | None, arguments.get("text_body"))
+            html_body = cast(str | None, arguments.get("html_body"))
+            if not text_body and not html_body:
+                raise ValueError("send_email requires text_body or html_body")
+            normalized_subject = cast(str, arguments.get("subject")).strip()
+            if not normalized_subject:
+                raise ValueError("send_email requires a non-empty subject")
+
+            recipients = recipients_to + recipients_cc + recipients_bcc
+            send_decision = self._send_policy_decision(
+                account_name=account,
+                smtp_policy=smtp_policy,
+                recipients=recipients,
+            ).evaluate()
+            if not send_decision.allowed:
+                return self._decision_check_result(operation_id, send_decision)
+
+            sent_copy_result = self._check_sent_copy_destination(
+                account=account,
+                smtp_config=smtp_config,
+                smtp_policy=smtp_policy,
+            )
+            return self._check_send_decision(
+                operation_id=operation_id,
+                account=account,
+                smtp_policy=smtp_policy,
+                recipients=recipients,
+                sent_copy_result=sent_copy_result,
+            )
+        except Exception as exc:
+            return {
+                "operation": operation_id,
+                "allowed": False,
+                "why_not": str(exc),
+            }
+
     def _resolve_context(
         self,
         account_name: str,
@@ -380,6 +451,43 @@ class SMTPRuntime:
 
         return smtp_config, smtp_policy
 
+    def _check_sent_copy_destination(
+        self,
+        *,
+        account: str,
+        smtp_config: SMTPConfig,
+        smtp_policy: SMTPServicePolicyConfig,
+    ) -> dict[str, object] | None:
+        if not smtp_policy.sent_copy.enabled:
+            return self._sent_copy_outcome("disabled", account=account)
+
+        folder_override = self._normalize_sent_copy_folder(smtp_config.sent_copy.folder)
+        if self._sent_message_appender is None:
+            return self._sent_copy_outcome(
+                "skipped",
+                account=account,
+                reason="IMAP sent-copy appender is not configured",
+            )
+
+        try:
+            destination = self._sent_message_appender.check_destination(
+                account=account,
+                folder=folder_override,
+            )
+        except Exception as exc:
+            return self._sent_copy_outcome(
+                "skipped",
+                account=account,
+                reason=str(exc),
+                error_type=type(exc).__name__,
+            )
+
+        return self._sent_copy_outcome(
+            "resolved",
+            account=destination.account,
+            folder=destination.folder,
+        )
+
     def _resolve_sent_copy_destination(
         self,
         *,
@@ -614,65 +722,42 @@ class SMTPRuntime:
         _, _, domain = smtp_config.from_email.partition("@")
         return domain or "localhost"
 
+    def _policy_now(self) -> float:
+        return self._time_provider()
+
+    def _rate_limit_attempt_timestamps(self) -> dict[str, list[float]]:
+        return self._attempt_timestamps
+
     def _enforce_policy(
         self,
         account_name: str,
         smtp_policy: SMTPServicePolicyConfig,
         recipients: list[str],
     ) -> None:
-        max_recipients = smtp_policy.limits.max_recipients_per_message
-        if max_recipients is not None and len(recipients) > max_recipients:
-            raise ValueError(
-                f"send_email exceeds max_recipients_per_message for account: {account_name}"
-            )
-
-        recipient_policy = smtp_policy.recipient_policy
-        for recipient in recipients:
-            normalized_recipient = recipient.strip().lower()
-            _, _, domain = normalized_recipient.partition("@")
-            if self._recipient_matches_list(
-                normalized_recipient, recipient_policy.blocked_recipients
-            ):
-                raise ValueError(
-                    f"send_email recipient is blocked by exact address policy: {recipient}"
-                )
-            if self._domain_matches_any_pattern(
-                domain, recipient_policy.blocked_domain_patterns
-            ):
-                raise ValueError(
-                    f"send_email recipient is blocked by domain policy: {recipient}"
-                )
-
-            has_allowlist = bool(
-                recipient_policy.allowed_recipients
-                or recipient_policy.allowed_domain_patterns
-            )
-            if has_allowlist and not (
-                self._recipient_matches_list(
-                    normalized_recipient, recipient_policy.allowed_recipients
-                )
-                or self._domain_matches_any_pattern(
-                    domain, recipient_policy.allowed_domain_patterns
-                )
-            ):
-                raise ValueError(
-                    f"send_email recipient is not allowed by policy: {recipient}"
-                )
+        self._send_policy_decision(
+            account_name=account_name,
+            smtp_policy=smtp_policy,
+            recipients=recipients,
+        ).evaluate().require_allowed()
 
     def _consume_rate_limit(
         self,
         account_name: str,
         smtp_policy: SMTPServicePolicyConfig,
     ) -> None:
+        self._rate_limit_decision(
+            account_name, smtp_policy
+        ).evaluate().require_allowed()
         max_messages = smtp_policy.limits.max_messages_per_minute
         if max_messages is None:
             return
 
-        now = self._time_provider()
+        now = self._policy_now()
         window_start = now - 60.0
+        attempt_timestamps = self._rate_limit_attempt_timestamps()
         active_attempts = [
             timestamp
-            for timestamp in self._attempt_timestamps.get(account_name, [])
+            for timestamp in attempt_timestamps.get(account_name, [])
             if timestamp > window_start
         ]
         if len(active_attempts) >= max_messages:
@@ -681,7 +766,7 @@ class SMTPRuntime:
             )
 
         active_attempts.append(now)
-        self._attempt_timestamps[account_name] = active_attempts
+        attempt_timestamps[account_name] = active_attempts
 
     def _recipient_matches_list(
         self,
@@ -947,7 +1032,7 @@ verify_peer: true
 timeout_seconds: 30
 
 # Optional override for the IMAP sent-copy folder used after successful sends.
-# Leave null to infer the only kind=sent folder on the matching IMAP account.
+# Leave null to infer the only kind=SENT folder on the matching IMAP account.
 sent_copy:
   folder: null
 """
@@ -960,9 +1045,6 @@ defaults:
   - schema@_here_
   - _self_
 
-# Require confirmation before sending through this policy.
-require_confirmation: true
-
 # Basic send-rate limits. Use null to disable a limit.
 limits:
   max_messages_per_minute: 30
@@ -1043,6 +1125,48 @@ class SMTPServicePlugin:
             ),
         )
 
+    def check_config(
+        self,
+        *,
+        accounts: Mapping[str, object],
+        policies: Mapping[str, object],
+    ) -> None:
+        smtp_accounts = cast(Mapping[str, SMTPConfig], accounts)
+        smtp_policies = cast(Mapping[str, SMTPServicePolicyConfig], policies)
+        errors: list[ConfigCheckIssue] = []
+        for account_name, smtp_config in sorted(smtp_accounts.items()):
+            if smtp_config.policy not in smtp_policies:
+                continue
+            if (
+                smtp_config.sent_copy.folder is not None
+                and not smtp_config.sent_copy.folder.strip()
+            ):
+                errors.append(
+                    ConfigCheckIssue(
+                        message="SMTP sent_copy.folder must be non-empty",
+                        account=account_name,
+                        policy=smtp_config.policy,
+                    )
+                )
+        for policy_name, smtp_policy in sorted(smtp_policies.items()):
+            if smtp_policy.idempotency.expiration_days <= 0:
+                errors.append(
+                    ConfigCheckIssue(
+                        message="SMTP idempotency expiration_days must be positive",
+                        policy=policy_name,
+                    )
+                )
+            cache_dir = smtp_policy.idempotency.cache_dir
+            if cache_dir is not None and not cache_dir.strip():
+                errors.append(
+                    ConfigCheckIssue(
+                        message="SMTP idempotency cache_dir must be non-empty",
+                        policy=policy_name,
+                    )
+                )
+        if errors:
+            raise ConfigCheckError(errors)
+
     def describe_capability(
         self,
         context: ServicePluginContext,
@@ -1060,7 +1184,7 @@ class SMTPServicePlugin:
             OperationDescriptor(
                 name="send_email",
                 description=SEND_EMAIL_DESCRIPTION,
-                input_schema=SEND_EMAIL_INPUT_SCHEMA,
+                input_schema=SendEmailInput,
             ),
         )
 
@@ -1092,6 +1216,15 @@ class SMTPServicePlugin:
             "idempotency_replayed": result.idempotency_replayed,
         }
 
+    def check_operation(
+        self,
+        operation: str,
+        arguments: Mapping[str, object],
+        context: ServicePluginContext,
+    ) -> dict[str, object]:
+        runtime = context.runtimes.require(self.name, SMTPRuntime)
+        return runtime.check_operation(operation, arguments)
+
 
 def plugin() -> SMTPServicePlugin:
     return SMTPServicePlugin()

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/src/arbiter_smtp/client.py

@@ -53,9 +53,14 @@ class SMTPSubmissionClient:
         code, message = response
         if code < 200 or code >= 400:
             raise smtplib.SMTPResponseException(
-                code, f"SMTP {action} failed: {message!r}"
+                code, f"SMTP {action} failed: {self._format_response_message(message)}"
             )
 
+    def _format_response_message(self, message: bytes | str) -> str:
+        if isinstance(message, bytes):
+            return message.decode("utf-8", errors="replace")
+        return message
+
     def _build_ssl_context(self) -> ssl.SSLContext:
         if self._config.verify_peer:
             return ssl.create_default_context()

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/src/arbiter_smtp/config.py

@@ -71,7 +71,6 @@ class SMTPConfig(Policy):
 
 @dataclass
 class SMTPServicePolicyConfig(Policy):
-    require_confirmation: bool = False
     limits: SMTPLimitsConfig = field(default_factory=SMTPLimitsConfig)
     idempotency: SMTPIdempotencyConfig = field(default_factory=SMTPIdempotencyConfig)
     recipient_policy: SMTPRecipientPolicyConfig = field(
@@ -98,7 +97,6 @@ SMTP_ACCOUNT_EXAMPLE = SMTPConfig(
 )
 
 SMTP_POLICY_EXAMPLE = SMTPServicePolicyConfig(
-    require_confirmation=True,
     limits=SMTPLimitsConfig(
         max_messages_per_minute=30,
         max_recipients_per_message=10,

arbiter_smtp-0.9.2.dev1/src/arbiter_smtp/runtime_policy.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from arbiter_server.decisions import (
+    AllowDecision,
+    AndDecision,
+    Decision,
+    DecisionResult,
+    DenyDecision,
+)
+
+from .config import SMTPRecipientPolicyConfig, SMTPServicePolicyConfig
+
+
+class _SMTPRuntimePolicyMixin:
+    def _policy_now(self) -> float:
+        raise NotImplementedError
+
+    def _rate_limit_attempt_timestamps(self) -> dict[str, list[float]]:
+        raise NotImplementedError
+
+    def _recipient_matches_list(
+        self,
+        recipient: str,
+        configured_recipients: list[str],
+    ) -> bool:
+        raise NotImplementedError
+
+    def _domain_matches_any_pattern(self, domain: str, patterns: list[str]) -> bool:
+        raise NotImplementedError
+
+    def _decision_check_result(
+        self,
+        operation_id: str,
+        decision: DecisionResult,
+    ) -> dict[str, object]:
+        result: dict[str, object] = {
+            "operation": operation_id,
+            "allowed": decision.allowed,
+            "evidence": decision.evidence,
+        }
+        if not decision.allowed:
+            result["why_not"] = decision.why_not or "operation is not allowed"
+            if decision.failed_gate is not None:
+                result["failed_gate"] = decision.failed_gate
+        return result
+
+    def _send_policy_decision(
+        self,
+        *,
+        account_name: str,
+        smtp_policy: SMTPServicePolicyConfig,
+        recipients: list[str],
+    ) -> Decision:
+        return AndDecision(
+            self._max_recipients_decision(
+                account_name=account_name,
+                smtp_policy=smtp_policy,
+                recipients=recipients,
+            ),
+            *(
+                self._recipient_policy_decision(
+                    recipient=recipient,
+                    recipient_policy=smtp_policy.recipient_policy,
+                )
+                for recipient in recipients
+            ),
+        )
+
+    def _max_recipients_decision(
+        self,
+        *,
+        account_name: str,
+        smtp_policy: SMTPServicePolicyConfig,
+        recipients: list[str],
+    ) -> Decision:
+        max_recipients = smtp_policy.limits.max_recipients_per_message
+        evidence = {
+            "account": account_name,
+            "recipient_count": len(recipients),
+            "max_recipients_per_message": max_recipients,
+        }
+        if max_recipients is None or len(recipients) <= max_recipients:
+            return AllowDecision(evidence)
+        return DenyDecision(
+            f"send_email exceeds max_recipients_per_message for account: {account_name}",
+            evidence,
+            failed_gate="max_recipients_per_message",
+        )
+
+    def _recipient_policy_decision(
+        self,
+        *,
+        recipient: str,
+        recipient_policy: SMTPRecipientPolicyConfig,
+    ) -> Decision:
+        normalized_recipient = recipient.strip().lower()
+        _, _, domain = normalized_recipient.partition("@")
+        evidence = {"recipient": recipient, "domain": domain}
+        if self._recipient_matches_list(
+            normalized_recipient, recipient_policy.blocked_recipients
+        ):
+            return DenyDecision(
+                f"send_email recipient is blocked by exact address policy: {recipient}",
+                evidence,
+                failed_gate="blocked_recipient",
+            )
+        if self._domain_matches_any_pattern(
+            domain, recipient_policy.blocked_domain_patterns
+        ):
+            return DenyDecision(
+                f"send_email recipient is blocked by domain policy: {recipient}",
+                evidence,
+                failed_gate="blocked_domain",
+            )
+
+        has_allowlist = bool(
+            recipient_policy.allowed_recipients
+            or recipient_policy.allowed_domain_patterns
+        )
+        if has_allowlist and not (
+            self._recipient_matches_list(
+                normalized_recipient, recipient_policy.allowed_recipients
+            )
+            or self._domain_matches_any_pattern(
+                domain, recipient_policy.allowed_domain_patterns
+            )
+        ):
+            return DenyDecision(
+                f"send_email recipient is not allowed by policy: {recipient}",
+                evidence,
+                failed_gate="allowed_recipients",
+            )
+        return AllowDecision(evidence)
+
+    def _rate_limit_decision(
+        self,
+        account_name: str,
+        smtp_policy: SMTPServicePolicyConfig,
+    ) -> Decision:
+        max_messages = smtp_policy.limits.max_messages_per_minute
+        evidence: dict[str, object] = {
+            "account": account_name,
+            "max_messages_per_minute": max_messages,
+        }
+        if max_messages is None:
+            return AllowDecision(evidence)
+
+        now = self._policy_now()
+        window_start = now - 60.0
+        attempt_timestamps = self._rate_limit_attempt_timestamps()
+        active_attempts = [
+            timestamp
+            for timestamp in attempt_timestamps.get(account_name, [])
+            if timestamp > window_start
+        ]
+        evidence["active_attempt_count"] = len(active_attempts)
+        if len(active_attempts) < max_messages:
+            return AllowDecision(evidence)
+        return DenyDecision(
+            f"send_email exceeds max_messages_per_minute for account: {account_name}",
+            evidence,
+            failed_gate="max_messages_per_minute",
+        )
+
+    def _sent_copy_preflight_decision(
+        self,
+        *,
+        smtp_policy: SMTPServicePolicyConfig,
+        result: dict[str, object] | None,
+    ) -> Decision:
+        if smtp_policy.sent_copy.on_failure.value != "fail":
+            return AllowDecision({"sent_copy": result or {"status": "not_required"}})
+        if result is None:
+            return AllowDecision({"sent_copy": {"status": "resolved"}})
+        if result.get("status") in {"saved", "disabled", "resolved"}:
+            return AllowDecision({"sent_copy": result})
+        reason = result.get("reason")
+        return DenyDecision(
+            f"send_email sent-copy preflight failed: {reason}",
+            {"sent_copy": result},
+            failed_gate="sent_copy",
+        )
+
+    def _check_send_decision(
+        self,
+        *,
+        operation_id: str,
+        account: str,
+        smtp_policy: SMTPServicePolicyConfig,
+        recipients: list[str],
+        sent_copy_result: dict[str, object] | None,
+    ) -> dict[str, object]:
+        decision = AndDecision(
+            self._send_policy_decision(
+                account_name=account,
+                smtp_policy=smtp_policy,
+                recipients=recipients,
+            ),
+            self._sent_copy_preflight_decision(
+                smtp_policy=smtp_policy,
+                result=sent_copy_result,
+            ),
+            self._rate_limit_decision(account, smtp_policy),
+        ).evaluate()
+        return self._decision_check_result(operation_id, decision)

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/src/arbiter_smtp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arbiter-smtp
-Version: 0.9.1.dev2
+Version: 0.9.2.dev1
 Summary: SMTP service plugin for Arbiter
 Author-email: Omry Yadan <omry@yadan.net>
 Maintainer-email: Omry Yadan <omry@yadan.net>
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Communications :: Email
 Requires-Python: <3.15,>=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: arbiter-server<0.10.0,>=0.9.1.dev2
+Requires-Dist: arbiter-server<0.10.0,>=0.9.2.dev1
 Requires-Dist: diskcache<6.0,>=5.6
 
 SMTP service plugin for Arbiter.

{arbiter_smtp-0.9.1.dev2 → arbiter_smtp-0.9.2.dev1}/src/arbiter_smtp.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ src/arbiter_smtp/client.py
 src/arbiter_smtp/config.py
 src/arbiter_smtp/idempotency.py
 src/arbiter_smtp/py.typed
+src/arbiter_smtp/runtime_policy.py
 src/arbiter_smtp.egg-info/PKG-INFO
 src/arbiter_smtp.egg-info/SOURCES.txt
 src/arbiter_smtp.egg-info/dependency_links.txt

arbiter_smtp-0.9.2.dev1/src/arbiter_smtp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+arbiter-server<0.10.0,>=0.9.2.dev1
+diskcache<6.0,>=5.6

arbiter_smtp-0.9.1.dev2/src/arbiter_smtp.egg-info/requires.txt

@@ -1,2 +0,0 @@
-arbiter-server<0.10.0,>=0.9.1.dev2
-diskcache<6.0,>=5.6