precleared 0.1.0__tar.gz → 0.2.0__tar.gz

{precleared-0.1.0 → precleared-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: precleared
-Version: 0.1.0
+Version: 0.2.0
 Summary: Cold-email legality check for AI agents: a Python client for the Precleared API, with LangChain, CrewAI, LlamaIndex and OpenAI Agents tools.
 Project-URL: Homepage, https://precleared.dev
 Project-URL: Documentation, https://precleared.dev/docs
@@ -45,7 +45,7 @@ Description-Content-Type: text/markdown
 
 Python client for [Precleared](https://precleared.dev), a cold-email legality check for AI agents.
 
-One call per recipient, before the first cold email, answers: is it legal to send this person a cold or marketing email? Precleared looks the recipient up live (for the UK: Companies House, the domain and the company website) and applies the local rules (UK PECR and GDPR, US CAN-SPAM, Canadian CASL, German UWG, French CNIL guidance and the rules for Australia, Ireland and the Netherlands). It returns a verdict, the rule that decided it with its source, what the footer must include, the next step and a signed receipt.
+One call per recipient, before the first cold email, answers: is it legal to send this person a cold or marketing email? Precleared looks the recipient up live (for the UK: Companies House, the domain and the company website) and applies the local rules (UK PECR and GDPR, US CAN-SPAM, Canadian CASL, German UWG, French CNIL guidance and the rules for Australia, Ireland, the Netherlands, Spain, Italy, Latvia and the United Arab Emirates). It returns a verdict, the rule that decided it with its source, what the footer must include, the next step and a signed receipt.
 
 Decision support with sources, not legal advice.
 
@@ -75,7 +75,7 @@ else:
     print(result.verdict, result.next_step, result.receipt_url)
 ```
 
-`check()` takes the same fields as the API: `recipient_email` or `recipient_domain`, `pitch`, `address_source` (`published`, `bought`, `scraped`, `given` or `unknown`), `sender_country` (default `GB`), `existing_customer`, `pitch_relevant`, `company_number`, `recipient_country`, `default_recipient_country` and `suppressed`.
+`check()` takes the same fields as the API: `recipient_email` or `recipient_domain`, `pitch`, `address_source` (`published`, `bought`, `scraped`, `given` or `unknown`), `sender_country` (`GB`, `US`, `AE` or `CA`, default `GB`), `existing_customer`, `pitch_relevant`, `company_number`, `company_name`, `recipient_name`, `recipient_country`, `default_recipient_country`, `suppressed` and `email`. Pass the draft as `email={"subject": ..., "body": ..., "from_name": ..., "from_email": ...}` and the result's `email_check` says whether its footer has an opt-out, names the sender and, where the rule needs one, carries a postal address; the draft is not stored.
 
 `address_source` defaults to `unknown` and is always sent (the API treats a missing value as `unknown` too). It changes verdicts, so never pass `published` unless the recipient put the address on their website or a public listing for people to contact them.
 
@@ -121,7 +121,7 @@ async with AsyncPrecleared("pc_live_...") as client:
 
 ## Framework tools
 
-Each adapter exposes the same two tools, `precleared_check` and `precleared_verify_receipt`, with descriptions that tell the model when to call them: before the first cold email to anyone who is not already a customer, in the UK, US, Canada, Germany, France, Australia, Ireland or the Netherlands, and not for transactional email. The tools return compact text (verdict, rule, footer_text, next_step, receipt URL) rather than the whole JSON. Pass `to_dict=True` for a dictionary instead. Every factory takes an optional `api_key`.
+Each adapter exposes the same two tools, `precleared_check` and `precleared_verify_receipt`, with descriptions that tell the model when to call them: before the first cold email to anyone who is not already a customer, in the UK, US, Canada, Germany, France, Australia, Ireland, the Netherlands, Spain, Italy, Latvia or the UAE, and not for transactional email. The tools return compact text (verdict, rule, footer_text, next_step, receipt URL) rather than the whole JSON. Pass `to_dict=True` for a dictionary instead. Every factory takes an optional `api_key`.
 
 Example tool output:
 
@@ -206,9 +206,9 @@ The API key is never logged, printed or included in an exception.
 ## Allowances and limits
 
 - Without a key: 10 checks a day over the REST API, shared by everyone on the same network.
-- With a free key (`https://precleared.dev/get-key`): 25 checks a day over the REST API.
+- With a free key (`https://precleared.dev/get-key`, no card): 100 checks a day for the first 14 days, then 25 a day over the REST API and 100 over MCP.
 - 60 checks a minute per key. Above that the API returns 429 `rate_limited` with `retry_after`.
-- Days run on UK time. After the free checks, checks use pack credits: a pack is £39 for 2,000 checks, packs never expire and stack on the same key. When no credits are left the API returns 402 with `buy_url`.
+- Days run on UK time. For more, £15 a month keeps 100 checks a day, or buy a pack: £9 for 300 checks (a key's first purchase) or £39 for 2,000. Pack checks are used after the day's free checks, never expire and stack on the same key. When no credits are left the API returns 402 with `buy_url`.
 - A check can take up to 25 seconds when a register or website is slow; the client's default timeout is 30 seconds.
 
 ## Configuration

{precleared-0.1.0 → precleared-0.2.0}/README.md

@@ -2,7 +2,7 @@
 
 Python client for [Precleared](https://precleared.dev), a cold-email legality check for AI agents.
 
-One call per recipient, before the first cold email, answers: is it legal to send this person a cold or marketing email? Precleared looks the recipient up live (for the UK: Companies House, the domain and the company website) and applies the local rules (UK PECR and GDPR, US CAN-SPAM, Canadian CASL, German UWG, French CNIL guidance and the rules for Australia, Ireland and the Netherlands). It returns a verdict, the rule that decided it with its source, what the footer must include, the next step and a signed receipt.
+One call per recipient, before the first cold email, answers: is it legal to send this person a cold or marketing email? Precleared looks the recipient up live (for the UK: Companies House, the domain and the company website) and applies the local rules (UK PECR and GDPR, US CAN-SPAM, Canadian CASL, German UWG, French CNIL guidance and the rules for Australia, Ireland, the Netherlands, Spain, Italy, Latvia and the United Arab Emirates). It returns a verdict, the rule that decided it with its source, what the footer must include, the next step and a signed receipt.
 
 Decision support with sources, not legal advice.
 
@@ -32,7 +32,7 @@ else:
     print(result.verdict, result.next_step, result.receipt_url)
 ```
 
-`check()` takes the same fields as the API: `recipient_email` or `recipient_domain`, `pitch`, `address_source` (`published`, `bought`, `scraped`, `given` or `unknown`), `sender_country` (default `GB`), `existing_customer`, `pitch_relevant`, `company_number`, `recipient_country`, `default_recipient_country` and `suppressed`.
+`check()` takes the same fields as the API: `recipient_email` or `recipient_domain`, `pitch`, `address_source` (`published`, `bought`, `scraped`, `given` or `unknown`), `sender_country` (`GB`, `US`, `AE` or `CA`, default `GB`), `existing_customer`, `pitch_relevant`, `company_number`, `company_name`, `recipient_name`, `recipient_country`, `default_recipient_country`, `suppressed` and `email`. Pass the draft as `email={"subject": ..., "body": ..., "from_name": ..., "from_email": ...}` and the result's `email_check` says whether its footer has an opt-out, names the sender and, where the rule needs one, carries a postal address; the draft is not stored.
 
 `address_source` defaults to `unknown` and is always sent (the API treats a missing value as `unknown` too). It changes verdicts, so never pass `published` unless the recipient put the address on their website or a public listing for people to contact them.
 
@@ -78,7 +78,7 @@ async with AsyncPrecleared("pc_live_...") as client:
 
 ## Framework tools
 
-Each adapter exposes the same two tools, `precleared_check` and `precleared_verify_receipt`, with descriptions that tell the model when to call them: before the first cold email to anyone who is not already a customer, in the UK, US, Canada, Germany, France, Australia, Ireland or the Netherlands, and not for transactional email. The tools return compact text (verdict, rule, footer_text, next_step, receipt URL) rather than the whole JSON. Pass `to_dict=True` for a dictionary instead. Every factory takes an optional `api_key`.
+Each adapter exposes the same two tools, `precleared_check` and `precleared_verify_receipt`, with descriptions that tell the model when to call them: before the first cold email to anyone who is not already a customer, in the UK, US, Canada, Germany, France, Australia, Ireland, the Netherlands, Spain, Italy, Latvia or the UAE, and not for transactional email. The tools return compact text (verdict, rule, footer_text, next_step, receipt URL) rather than the whole JSON. Pass `to_dict=True` for a dictionary instead. Every factory takes an optional `api_key`.
 
 Example tool output:
 
@@ -163,9 +163,9 @@ The API key is never logged, printed or included in an exception.
 ## Allowances and limits
 
 - Without a key: 10 checks a day over the REST API, shared by everyone on the same network.
-- With a free key (`https://precleared.dev/get-key`): 25 checks a day over the REST API.
+- With a free key (`https://precleared.dev/get-key`, no card): 100 checks a day for the first 14 days, then 25 a day over the REST API and 100 over MCP.
 - 60 checks a minute per key. Above that the API returns 429 `rate_limited` with `retry_after`.
-- Days run on UK time. After the free checks, checks use pack credits: a pack is £39 for 2,000 checks, packs never expire and stack on the same key. When no credits are left the API returns 402 with `buy_url`.
+- Days run on UK time. For more, £15 a month keeps 100 checks a day, or buy a pack: £9 for 300 checks (a key's first purchase) or £39 for 2,000. Pack checks are used after the day's free checks, never expire and stack on the same key. When no credits are left the API returns 402 with `buy_url`.
 - A check can take up to 25 seconds when a register or website is slow; the client's default timeout is 30 seconds.
 
 ## Configuration

{precleared-0.1.0 → precleared-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "precleared"
-version = "0.1.0"
+version = "0.2.0"
 description = "Cold-email legality check for AI agents: a Python client for the Precleared API, with LangChain, CrewAI, LlamaIndex and OpenAI Agents tools."
 readme = "README.md"
 license = "MIT"

{precleared-0.1.0 → precleared-0.2.0}/src/precleared/_schemas.py

@@ -25,6 +25,8 @@ class PreclearedCheckArgs(BaseModel):
     recipient_country: Optional[str] = Field(default=None, description=_D["recipient_country"])
     company_number: Optional[str] = Field(default=None, description=_D["company_number"])
     suppressed: Optional[bool] = Field(default=None, description=_D["suppressed"])
+    company_name: Optional[str] = Field(default=None, description=_D["company_name"])
+    recipient_name: Optional[str] = Field(default=None, description=_D["recipient_name"])
 
 
 class PreclearedVerifyReceiptArgs(BaseModel):

{precleared-0.1.0 → precleared-0.2.0}/src/precleared/_tools.py

@@ -24,9 +24,9 @@ VERIFY_TOOL_NAME = "precleared_verify_receipt"
 CHECK_DESCRIPTION = (
     "Check whether a cold or marketing email to one recipient is legal. "
     "Call this once per address before the first cold email to anyone who is not already a customer, "
-    "in the UK, US, Canada, Germany, France, Australia, Ireland or the Netherlands, including every "
-    "address in a lead list. Not needed for transactional email such as invoices or password resets. "
-    "It applies the local rules (UK PECR, US CAN-SPAM, Canadian CASL and others) using live lookups "
+    "in the UK, US, Canada, Germany, France, Australia, Ireland, the Netherlands, Spain, Italy, Latvia or the UAE, "
+    "including every address in a lead list. Not needed for transactional email such as invoices. "
+    "It applies the local rules (UK PECR, US CAN-SPAM, CASL and others) with live lookups "
     "such as UK Companies House. Returns a verdict, the rule that decided it with its source, "
     "footer_text, next_step and a signed receipt id. ok_to_email means send, with a footer that meets "
     "footer_text (a requirement, not wording to paste). consent_needed and blocked mean do not send; "
@@ -57,7 +57,15 @@ ARG_DESCRIPTIONS: Dict[str, str] = {
         "True if the pitch relates to the recipient's role or business, false if it does not. "
         "Leave unset when unsure."
     ),
-    "sender_country": "Two-letter code for where the sender is based, for example GB or US. Default GB.",
+    "sender_country": "Two-letter code for where the sender is based: GB, US, AE or CA. Default GB.",
+    "company_name": (
+        "The recipient's company or organisation name when you know it, for example from a CRM. Helps find "
+        "a UK company at Companies House when the domain alone does not."
+    ),
+    "recipient_name": (
+        "The recipient's full name when you know it. For UK recipients it is matched against the company's "
+        "officers. Precleared does not store it."
+    ),
     "recipient_country": (
         "Two-letter country code for the recipient when you know it. Otherwise Precleared works it out "
         "from the domain, the register and the website."
@@ -177,6 +185,8 @@ class PreclearedTools:
         recipient_country: Optional[str] = None,
         company_number: Optional[str] = None,
         suppressed: Optional[bool] = None,
+        company_name: Optional[str] = None,
+        recipient_name: Optional[str] = None,
     ) -> Union[str, Dict[str, Any]]:
         """Run one check and return compact text (or a dict when ``to_dict``)."""
         try:
@@ -192,6 +202,8 @@ class PreclearedTools:
                 company_number=_blank_to_none(company_number),
                 recipient_country=_blank_to_none(recipient_country),
                 suppressed=coerce_bool(suppressed, "suppressed"),
+                company_name=_blank_to_none(company_name),
+                recipient_name=_blank_to_none(recipient_name),
             )
         except (PreclearedError, ValueError) as exc:
             return self._failure(exc)

precleared-0.2.0/src/precleared/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{precleared-0.1.0 → precleared-0.2.0}/src/precleared/client.py

@@ -91,6 +91,9 @@ def build_check_body(
     recipient_country: Optional[str] = None,
     default_recipient_country: Optional[str] = None,
     suppressed: Optional[bool] = None,
+    company_name: Optional[str] = None,
+    recipient_name: Optional[str] = None,
+    email: Optional[Dict[str, Any]] = None,
     **extra: Any,
 ) -> Dict[str, Any]:
     """Validate the check fields and build the JSON body.
@@ -143,6 +146,29 @@ def build_check_body(
         )
     if suppressed is not None:
         body["suppressed"] = _require_bool(suppressed, "suppressed")
+    for name, value in (("company_name", company_name), ("recipient_name", recipient_name)):
+        if value is not None:
+            if not isinstance(value, str):
+                raise ValueError(f"{name} must be a string")
+            text = value.strip()
+            if text:
+                body[name] = text
+    if email is not None:
+        if not isinstance(email, dict):
+            raise ValueError("email must be a dict with a body, for example {'body': '...'}")
+        draft_body = email.get("body")
+        if not isinstance(draft_body, str) or not draft_body.strip():
+            raise ValueError("email.body is required: the draft's text or HTML, including the footer")
+        draft: Dict[str, str] = {"body": draft_body}
+        for name in ("subject", "from_name", "from_email"):
+            value = email.get(name)
+            if value is None:
+                continue
+            if not isinstance(value, str):
+                raise ValueError(f"email.{name} must be a string")
+            if value.strip():
+                draft[name] = value
+        body["email"] = draft
 
     for key, value in extra.items():
         if value is not None and key not in body:
@@ -394,6 +420,9 @@ class Precleared(_Base):
         recipient_country: Optional[str] = None,
         default_recipient_country: Optional[str] = None,
         suppressed: Optional[bool] = None,
+        company_name: Optional[str] = None,
+        recipient_name: Optional[str] = None,
+        email: Optional[Dict[str, Any]] = None,
         **extra: Any,
     ) -> CheckResult:
         """Check whether a cold email may lawfully be sent to one address.
@@ -407,7 +436,8 @@ class Precleared(_Base):
                 ``scraped``, ``given`` or ``unknown``. Defaults to ``unknown``.
                 Only say ``published`` when the recipient put the address on
                 their own website or a public listing for people to contact them.
-            sender_country: Two-letter code for where you send from. Default ``GB``.
+            sender_country: Two-letter code for where you send from: ``GB``,
+                ``US``, ``AE`` or ``CA``. Default ``GB``.
             existing_customer: True if the recipient has bought from you.
             pitch_relevant: Whether the pitch relates to the recipient's role.
             company_number: UK Companies House number, when you know it.
@@ -415,6 +445,15 @@ class Precleared(_Base):
             default_recipient_country: Used only when the country cannot be
                 worked out from the address, register or website.
             suppressed: True if the address is on your own suppression list.
+            company_name: The recipient's company or organisation name, if you have it.
+            recipient_name: The recipient's full name, if you have it. Used during
+                the check and not stored.
+            email: The draft, if you want the answer to say whether its footer
+                meets the rule: ``{"subject": ..., "body": ..., "from_name": ...,
+                "from_email": ...}`` (``body`` required). The result's
+                ``email_check`` then says whether the footer has an opt-out, names
+                the sender and, where the rule needs one, carries a postal
+                address. The draft is not stored; only its hash goes on the receipt.
             **extra: Forwarded as is, for request fields newer than this client.
 
         Raises:
@@ -433,6 +472,9 @@ class Precleared(_Base):
             recipient_country=recipient_country,
             default_recipient_country=default_recipient_country,
             suppressed=suppressed,
+            company_name=company_name,
+            recipient_name=recipient_name,
+            email=email,
             **extra,
         )
         response = self._request("POST", "/api/v1/check", json=body)
@@ -506,6 +548,9 @@ class AsyncPrecleared(_Base):
         recipient_country: Optional[str] = None,
         default_recipient_country: Optional[str] = None,
         suppressed: Optional[bool] = None,
+        company_name: Optional[str] = None,
+        recipient_name: Optional[str] = None,
+        email: Optional[Dict[str, Any]] = None,
         **extra: Any,
     ) -> CheckResult:
         """Async version of :meth:`Precleared.check`."""
@@ -521,6 +566,9 @@ class AsyncPrecleared(_Base):
             recipient_country=recipient_country,
             default_recipient_country=default_recipient_country,
             suppressed=suppressed,
+            company_name=company_name,
+            recipient_name=recipient_name,
+            email=email,
             **extra,
         )
         response = await self._request("POST", "/api/v1/check", json=body)

{precleared-0.1.0 → precleared-0.2.0}/src/precleared/errors.py

@@ -64,7 +64,7 @@ class DailyLimit(PreclearedError):
     """HTTP 429 ``daily_limit``: the free daily allowance is used up.
 
     Keyless use allows 10 REST checks a day, shared by everyone on the same
-    network. A free key allows 25 a day.
+    network. A free key allows 100 a day for its first 14 days, then 25 a day.
 
     Attributes:
         get_key_url: Where to get a free key.

{precleared-0.1.0 → precleared-0.2.0}/src/precleared/models.py

@@ -255,6 +255,10 @@ class CheckResult:
         usage: Remaining free checks and pack credits.
         disclaimer: Fixed line: decision support with sources, not legal advice.
         rules_version: Version of the rule set used.
+        email_check: Only when a draft was passed in ``email``: whether its
+            footer meets the rule (``status``, ``requirements``, ``missing``).
+        charged: False when the answer was free: no rule applied, a re-check
+            within a day, or an address on your opt-out list.
         raw: The full response as returned by the API.
     """
 
@@ -269,6 +273,8 @@ class CheckResult:
     usage: Optional[Usage] = None
     disclaimer: Optional[str] = None
     rules_version: Optional[str] = None
+    email_check: Optional[Dict[str, Any]] = None
+    charged: Optional[bool] = None
     raw: Dict[str, Any] = field(default_factory=dict, repr=False)
     base_url: str = field(default=DEFAULT_BASE_URL, repr=False)
 
@@ -305,6 +311,8 @@ class CheckResult:
             usage=Usage.from_dict(data["usage"]) if isinstance(data.get("usage"), dict) else None,
             disclaimer=_opt_str(data.get("disclaimer")),
             rules_version=_opt_str(data.get("rules_version")),
+            email_check=dict(data["email_check"]) if isinstance(data.get("email_check"), dict) else None,
+            charged=bool(data["charged"]) if isinstance(data.get("charged"), bool) else None,
             raw=dict(data),
             base_url=base_url,
         )

{precleared-0.1.0 → precleared-0.2.0}/src/precleared/openai_agents.py

@@ -45,6 +45,8 @@ _CHECK_ARGS = [
     "recipient_country",
     "company_number",
     "suppressed",
+    "company_name",
+    "recipient_name",
 ]
 
 
@@ -60,6 +62,8 @@ def _check_tool(runner: PreclearedTools) -> FunctionTool:
         recipient_country: Optional[str] = None,
         company_number: Optional[str] = None,
         suppressed: Optional[bool] = None,
+        company_name: Optional[str] = None,
+        recipient_name: Optional[str] = None,
     ) -> Union[str, Dict[str, Any]]:
         return runner.check(
             recipient_email=recipient_email,
@@ -72,6 +76,8 @@ def _check_tool(runner: PreclearedTools) -> FunctionTool:
             recipient_country=recipient_country,
             company_number=company_number,
             suppressed=suppressed,
+            company_name=company_name,
+            recipient_name=recipient_name,
         )
 
     precleared_check.__doc__ = google_docstring(

{precleared-0.1.0 → precleared-0.2.0}/tests/test_async_client.py

@@ -30,7 +30,7 @@ async def test_async_check_success(make_async_client, recorder):
     assert result.rule == "gb_pecr_corporate_subscriber"
     assert result.receipt_url == "https://precleared.dev/r/cc_rcpt_0123456789ABCDEF"
     assert recorder.last.headers["authorization"] == f"Bearer {KEY}"
-    assert recorder.last.headers["user-agent"] == "precleared-python/0.1.0"
+    assert recorder.last.headers["user-agent"] == "precleared-python/0.2.0"
     assert recorder.last_json()["address_source"] == "given"
     assert client._http.is_closed
 

{precleared-0.1.0 → precleared-0.2.0}/tests/test_client.py

@@ -85,7 +85,7 @@ def test_check_sends_expected_body_and_headers_keyless(make_client, recorder):
     assert request.method == "POST"
     assert str(request.url) == "https://precleared.dev/api/v1/check"
     assert request.headers["content-type"] == "application/json"
-    assert request.headers["user-agent"] == "precleared-python/0.1.0" == DEFAULT_USER_AGENT
+    assert request.headers["user-agent"] == "precleared-python/0.2.0" == DEFAULT_USER_AGENT
     assert request.headers["accept"] == "application/json"
     assert "authorization" not in request.headers
 
@@ -494,6 +494,37 @@ def test_public_exports():
     ):
         assert name in precleared.__all__
         assert hasattr(precleared, name)
-    assert precleared.__version__ == "0.1.0"
+    assert precleared.__version__ == "0.2.0"
     for cls in (InvalidRequest, InvalidKey, PaymentRequired, DailyLimit, RateLimited, ReceiptNotFound, ServerError, NetworkError):
         assert issubclass(cls, PreclearedError)
+
+
+
+def test_check_sends_company_name_recipient_name_and_draft_email(make_client, recorder):
+    payload = {
+        "verdict": "ok_to_email",
+        "email_check": {"status": "fail", "country": "US", "requirements": [], "missing": ["postal_address"], "footer_text": None, "note": "Presence checks for US."},
+        "charged": True,
+    }
+    client = make_client(routed(check=json_response(200, payload)))
+    result = client.check(
+        "sales@precleared.dev",
+        sender_country="ca",
+        company_name=" Acme Ltd ",
+        recipient_name="Jane Smith",
+        email={"subject": "Hi", "body": "Hello {{unsubscribe}}", "from_name": "Sam", "from_email": ""},
+    )
+    body = recorder.last_json()
+    assert body["sender_country"] == "CA"
+    assert body["company_name"] == "Acme Ltd"
+    assert body["recipient_name"] == "Jane Smith"
+    assert body["email"] == {"subject": "Hi", "body": "Hello {{unsubscribe}}", "from_name": "Sam"}
+    assert result.email_check == payload["email_check"]
+    assert result.charged is True
+
+
+def test_check_rejects_a_draft_without_a_body(make_client, recorder):
+    client = make_client()
+    with pytest.raises(ValueError, match="email.body is required"):
+        client.check("a@b.co", email={"subject": "Hi"})
+    assert recorder.requests == []

{precleared-0.1.0 → precleared-0.2.0}/tests/test_langchain.py

@@ -20,6 +20,7 @@ from conftest import json_response, routed  # noqa: E402
 CHECK_FIELDS = {
     "recipient_email", "recipient_domain", "pitch", "address_source", "existing_customer",
     "pitch_relevant", "sender_country", "recipient_country", "company_number", "suppressed",
+    "company_name", "recipient_name",
 }
 
 

{precleared-0.1.0 → precleared-0.2.0}/tests/test_openai_agents.py

@@ -37,6 +37,8 @@ FULL_ARGS = {
     "recipient_country": None,
     "company_number": None,
     "suppressed": None,
+    "company_name": None,
+    "recipient_name": None,
 }
 
 

{precleared-0.1.0 → precleared-0.2.0}/tests/test_tools_common.py

@@ -28,7 +28,7 @@ def test_tool_names_and_descriptions_tell_the_model_when_to_call():
     for phrase in (
         "before the first cold email",
         "not already a customer",
-        "UK, US, Canada, Germany, France, Australia, Ireland or the Netherlands",
+        "UK, US, Canada, Germany, France, Australia, Ireland, the Netherlands, Spain, Italy, Latvia or the UAE",
         "Not needed for transactional email",
         "ok_to_email means send, with a footer that meets footer_text",
         "consent_needed and blocked mean do not send",

precleared-0.1.0/src/precleared/_version.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"