discolike-cli 0.6.2__tar.gz → 0.6.3__tar.gz

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: discolike-cli
-Version: 0.6.2
+Version: 0.6.3
 Summary: Official CLI for the DiscoLike API
 Project-URL: Homepage, https://www.discolike.com
 Project-URL: Documentation, https://docs.discolike.com
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
-Requires-Dist: discolike==0.6.2
+Requires-Dist: discolike==0.6.3
 Requires-Dist: rich>=13.0
 Requires-Dist: typer<0.28,>=0.26.1
 Description-Content-Type: text/markdown
@@ -69,6 +69,10 @@ discolike extract https://stripe.com/enterprise
 
 Top-level commands: `discover`, `count`, `match`, `extract`, `validate-icp`, `append`, `segment` — plus `auth`, `bulk`, `company`, `contacts`, `discogen`, `prospecting`, `queries`, `account`, `search-providers`, and `llm-providers` command groups.
 
+### Contacts runs
+
+`discolike contacts run create --params-file run.json` starts a contacts run from a JSON request (`companies`, `people`, `relevance`, `per_company`, `max_contacts`, `auto_stop`, `find_missing`, `email_cap_usd`, `mode`). `get`, `list`, `continue`, `cancel` and `title-preview` mirror the SDK. `wait RUN_ID` blocks until the run finishes or pauses after a step; `--follow` continues each step for you and stops before `find_emails` unless the run was created with a cap or you pass `--email-cap-usd`. `contacts search`, `count` and `generate` still work but print a deprecation line on stderr after their output: their endpoints sunset on 2026-12-31. `email find --suggested-email` verifies an address you already have before looking for the right one.
+
 ### Volume pulls
 
 `discolike bulk` walks past the 10,000-per-search ceiling and pulls contacts for a whole domain list into one CSV, with checkpoint and resume:

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/README.md

@@ -37,6 +37,10 @@ discolike extract https://stripe.com/enterprise
 
 Top-level commands: `discover`, `count`, `match`, `extract`, `validate-icp`, `append`, `segment` — plus `auth`, `bulk`, `company`, `contacts`, `discogen`, `prospecting`, `queries`, `account`, `search-providers`, and `llm-providers` command groups.
 
+### Contacts runs
+
+`discolike contacts run create --params-file run.json` starts a contacts run from a JSON request (`companies`, `people`, `relevance`, `per_company`, `max_contacts`, `auto_stop`, `find_missing`, `email_cap_usd`, `mode`). `get`, `list`, `continue`, `cancel` and `title-preview` mirror the SDK. `wait RUN_ID` blocks until the run finishes or pauses after a step; `--follow` continues each step for you and stops before `find_emails` unless the run was created with a cap or you pass `--email-cap-usd`. `contacts search`, `count` and `generate` still work but print a deprecation line on stderr after their output: their endpoints sunset on 2026-12-31. `email find --suggested-email` verifies an address you already have before looking for the right one.
+
 ### Volume pulls
 
 `discolike bulk` walks past the 10,000-per-search ceiling and pulls contacts for a whole domain list into one CSV, with checkpoint and resume:

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "discolike-cli"
-version = "0.6.2"
+version = "0.6.3"
 description = "Official CLI for the DiscoLike API"
 readme = "README.md"
 license = "MIT"
@@ -12,7 +12,7 @@ license-files = ["LICENSE"]
 requires-python = ">=3.11"
 authors = [{ name = "DiscoLike", email = "support@discolike.com" }]
 dependencies = [
-  "discolike==0.6.2",
+  "discolike==0.6.3",
   "typer>=0.26.1,<0.28",
   "rich>=13.0",
 ]

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/src/discolike_cli/_help.py

@@ -185,7 +185,7 @@ Output (success, exit 0):
 """,
     "extract": """\
 Output (success, exit 0):
-  {"text": <string>, "language": <ISO 639-1>}
+  {"text": <string>}
   Fetches the page live; use it to confirm a seed domain is the right company.
 
 Common errors:

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/src/discolike_cli/bulk.py

@@ -41,6 +41,7 @@ from discolike_cli.discover import DOMAINS_FILE_HELP
 from discolike_cli.discover import PARAM_HELP
 from discolike_cli.discover import PARAMS_FILE_HELP
 from discolike_cli.discover import RELEVANCE_HELP
+from discolike_cli.discover import VALID_MX_HELP
 from discolike_cli.discover import VARIANCE_HELP
 from discolike_cli.discover import _merge_params
 
@@ -159,6 +160,7 @@ def companies_command(
     state: list[str] | None = typer.Option(None, help="State or region filter (repeatable)."),
     employee_range: str | None = typer.Option(None, help="Employee count range filter."),
     revenue_range: str | None = typer.Option(None, help="Revenue range filter."),
+    valid_mx: bool | None = typer.Option(None, "--valid-mx/--no-valid-mx", help=VALID_MX_HELP),
     relevance: str | None = typer.Option(None, help=RELEVANCE_HELP),
     variance: str | None = typer.Option(None, help=VARIANCE_HELP),
     exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
@@ -187,6 +189,7 @@ def companies_command(
             state=state,
             employee_range=employee_range,
             revenue_range=revenue_range,
+            valid_mx=valid_mx,
             relevance=relevance,
             variance=variance,
         ),

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/src/discolike_cli/contacts.py

@@ -59,6 +59,11 @@ MAX_COMPANIES_HELP = "Maximum number of enriched companies to return; cannot be
 RESULTS_BY_COMPANY_HELP = "Maximum contacts per company domain (default 5; 0 removes the cap)."
 INCLUDE_SEARCH_CONTACTS_HELP = "Include contacts from the search index (broader coverage)."
 CONSENSUS_HELP = "Number of query vectors to combine for consensus search."
+# Printed only after success, so a failed command's stderr stays the single JSON error object.
+DEPRECATED_COMMAND_WARNING = (
+    "warning: `discolike contacts {command}` is deprecated and its endpoint sunsets on 2026-12-31; "
+    "use `discolike contacts run`."
+)
 
 
 def _email_validated_as_has_email(*, email_validated: bool | None, has_email: bool | None) -> bool | None:
@@ -174,6 +179,7 @@ def search_command(
         consensus=consensus,
     )
     emit(get_client(ctx).contacts.search(build_request(ContactsSearchParams, kwargs)), fmt=fmt)
+    typer.echo(DEPRECATED_COMMAND_WARNING.format(command="search"), err=True)
 
 
 @app.command("count")
@@ -510,3 +516,4 @@ def generate_command(
         ),
     )
     run_job(get_client(ctx).contacts.generate(request), wait=wait, timeout=timeout, fmt=fmt)
+    typer.echo(DEPRECATED_COMMAND_WARNING.format(command="generate"), err=True)

discolike_cli-0.6.3/src/discolike_cli/contacts_run.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import pathlib
+
+import typer
+
+from discolike.requests import ContactsRunEventsParams
+from discolike.requests import ContactsRunGetParams
+from discolike.requests import ContactsRunListParams
+from discolike.requests import ContactsRunRequest
+from discolike.requests import ContinueRunRequest
+from discolike.requests import TitlePreviewRequest
+from discolike_cli._output import build_request
+from discolike_cli._output import emit
+from discolike_cli._output import handle_errors
+from discolike_cli.discover import _merge_params
+
+DEFAULT_WAIT_TIMEOUT_SECONDS = 3600.0
+
+FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
+PARAMS_FILE_HELP = (
+    "JSON object with the run request: companies (source prompt, domains or lookalike), relevance, "
+    "people.fit, max_companies, per_company, email_cap_usd, exclusions and create_key. --param and flags override its values."
+)
+PARAM_HELP = "Extra key=value body field (repeatable)."
+EMAIL_CAP_HELP = "Maximum USD to spend on validated delivery; omit for no cap."
+GENERATION_HELP = "Generation of the companies run you are continuing; fetched when omitted."
+
+app = typer.Typer(help="Find and validate contacts automatically. Poll company progress and delivery totals.")
+
+
+@app.command("create")
+@handle_errors
+def create_command(
+    ctx: typer.Context,
+    params_file: pathlib.Path | None = typer.Option(None, help=PARAMS_FILE_HELP),
+    param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
+    email_cap_usd: float | None = typer.Option(None, "--email-cap-usd", help=EMAIL_CAP_HELP),
+) -> None:
+    """Start a contacts run from a JSON request."""
+    from discolike_cli.main import get_client
+
+    request = build_request(ContactsRunRequest, _merge_params(param, params_file, email_cap_usd=email_cap_usd))
+    emit(get_client(ctx).contacts_run.create(request))
+
+
+@app.command("list")
+@handle_errors
+def list_command(
+    ctx: typer.Context,
+    before: str | None = typer.Option(
+        None, help="Only runs created before this time, ISO 8601 with offset, e.g. 2026-10-30T12:00:00Z."
+    ),
+    limit: int | None = typer.Option(None, help="Runs per page (default 20, maximum 100)."),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """List your runs, newest first."""
+    from discolike_cli.main import get_client
+
+    params = build_request(ContactsRunListParams, _merge_params(None, before=before, limit=limit))
+    emit(get_client(ctx).contacts_run.list(params), fmt=fmt)
+
+
+@app.command("get")
+@handle_errors
+def get_command(
+    ctx: typer.Context,
+    run_id: str = typer.Argument(..., help="Run ID."),
+    rows_offset: int | None = typer.Option(None, help="Company domains to skip for contacts runs."),
+    rows_limit: int | None = typer.Option(
+        None, help="Company domains per page for contacts runs (default 100, maximum 1000)."
+    ),
+    all_rows: bool = typer.Option(False, "--all-rows", help="Print every row of the run as a list instead."),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Show a run with a page of its rows."""
+    from discolike_cli.main import get_client
+
+    client = get_client(ctx)
+    if all_rows:
+        emit(client.contacts_run.rows(run_id), fmt=fmt)
+        return
+    params = build_request(ContactsRunGetParams, _merge_params(None, rows_offset=rows_offset, rows_limit=rows_limit))
+    emit(client.contacts_run.get(run_id, params))
+
+
+@app.command("continue")
+@handle_errors
+def continue_command(
+    ctx: typer.Context,
+    run_id: str = typer.Argument(..., help="Run ID."),
+    generation: int | None = typer.Option(None, help=GENERATION_HELP),
+    redo: bool | None = typer.Option(None, "--redo/--no-redo", help="Run the current step again."),
+) -> None:
+    """Advance or redo a companies run. Contacts runs proceed automatically (409 here)."""
+    from discolike_cli.main import get_client
+
+    client = get_client(ctx)
+    request = build_request(
+        ContinueRunRequest,
+        _merge_params(
+            None,
+            generation=client.contacts_run.get(run_id).generation if generation is None else generation,
+            redo=redo,
+        ),
+    )
+    emit(client.contacts_run.continue_(run_id, request))
+
+
+@app.command("cancel")
+@handle_errors
+def cancel_command(ctx: typer.Context, run_id: str = typer.Argument(..., help="Run ID.")) -> None:
+    """Cancel a run; charges already incurred stay."""
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).contacts_run.cancel(run_id))
+
+
+@app.command("wait")
+@handle_errors
+def wait_command(
+    ctx: typer.Context,
+    run_id: str = typer.Argument(..., help="Run ID."),
+    timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help="Max seconds to wait."),
+) -> None:
+    """Block until done, failed or cancelled. A timeout stops local polling only."""
+    from discolike_cli.main import get_client
+
+    emit(get_client(ctx).contacts_run.wait(run_id, max_wait=timeout))
+
+
+@app.command("events")
+@handle_errors
+def events_command(
+    ctx: typer.Context,
+    run_id: str = typer.Argument(..., help="Run ID."),
+    after: int | None = typer.Option(None, help="Return events after this cursor."),
+    limit: int | None = typer.Option(None, help="Events per page (default 100, maximum 500)."),
+) -> None:
+    """Read company progress events and the next cursor."""
+    from discolike_cli.main import get_client
+
+    params = build_request(ContactsRunEventsParams, _merge_params(None, after=after, limit=limit))
+    emit(get_client(ctx).contacts_run.events(run_id, params))
+
+
+@app.command("title-preview")
+@handle_errors
+def title_preview_command(
+    ctx: typer.Context,
+    title: list[str] = typer.Option(..., "--title", help="Job title to preview (repeatable)."),
+    exclude_title: list[str] | None = typer.Option(
+        None, "--exclude-title", help="Job title to leave out (repeatable)."
+    ),
+    match: str = typer.Option("similar", help="similar also accepts close variants of a title; exact does not."),
+    relevance: str | None = typer.Option(None, help="max_relevance, balanced or max_coverage."),
+    auto_stop: bool | None = typer.Option(None, "--auto-stop/--no-auto-stop", help="Apply the relevance threshold."),
+    fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
+) -> None:
+    """Preview the titles a people spec matches, with role scores and contact counts."""
+    from discolike_cli.main import get_client
+
+    request = build_request(
+        TitlePreviewRequest,
+        _merge_params(
+            None, titles=title, exclude_titles=exclude_title, match=match, relevance=relevance, auto_stop=auto_stop
+        ),
+    )
+    emit(get_client(ctx).contacts_run.title_preview(request).titles, fmt=fmt)

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/src/discolike_cli/discover.py

@@ -42,6 +42,7 @@ NEGATE_SOCIAL_HELP = "Exclude companies with this social profile (repeatable); s
 LANGUAGE_HELP = "Filter by site language as an ISO 639-1 code, e.g. en, de, pb, zt (repeatable)."
 NEGATE_LANGUAGE_HELP = "Exclude this site language (repeatable); same values as --language."
 EXCLUDE_LEADGEN_HELP = "Exclude suspected lead generation sites (on by default)."
+VALID_MX_HELP = "Exclude companies with no mail server (off by default)."
 COUNT_EXCLUDE_LEADGEN_HELP = "Exclude suspected lead generation sites (off by default for count)."
 RELEVANCE_HELP = (
     "Where the list stops, by estimated ICP fit: MAX_RELEVANCE (tightest), BALANCED, MAX_COVERAGE (longest). "
@@ -114,6 +115,7 @@ def discover_command(
     consensus: int | None = typer.Option(
         None, help="Deprecated, no-op. Discover applies consensus itself to single-domain lookalike searches."
     ),
+    valid_mx: bool | None = typer.Option(None, "--valid-mx/--no-valid-mx", help=VALID_MX_HELP),
     redirect: bool | None = typer.Option(None, "--redirect/--no-redirect", help=REDIRECT_HELP),
     exclude_leadgen: bool | None = typer.Option(
         None, "--exclude-leadgen/--no-exclude-leadgen", help=EXCLUDE_LEADGEN_HELP
@@ -193,6 +195,7 @@ def discover_command(
             relevance=relevance,
             variance=variance,
             consensus=consensus,
+            valid_mx=valid_mx,
             redirect=redirect,
             exclude_leadgen=exclude_leadgen,
             retrieval=retrieval,
@@ -245,6 +248,7 @@ def count_command(
     negate_tech_stack: list[str] | None = typer.Option(None, help="Negate the --tech-stack filter (repeatable)."),
     min_digital_footprint: int | None = typer.Option(None, help="Minimum digital footprint score."),
     max_digital_footprint: int | None = typer.Option(None, help="Maximum digital footprint score."),
+    valid_mx: bool | None = typer.Option(None, "--valid-mx/--no-valid-mx", help=VALID_MX_HELP),
     redirect: bool | None = typer.Option(None, "--redirect/--no-redirect", help=REDIRECT_HELP),
     exclude_leadgen: bool | None = typer.Option(
         None, "--exclude-leadgen/--no-exclude-leadgen", help=COUNT_EXCLUDE_LEADGEN_HELP
@@ -291,6 +295,7 @@ def count_command(
             negate_tech_stack=negate_tech_stack,
             min_digital_footprint=min_digital_footprint,
             max_digital_footprint=max_digital_footprint,
+            valid_mx=valid_mx,
             redirect=redirect,
             exclude_leadgen=exclude_leadgen,
         ),

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/src/discolike_cli/email.py

@@ -86,6 +86,12 @@ def find_command(
     known_pattern: str | None = typer.Option(
         None, "--known-pattern", help="Known email local-part pattern for this domain, e.g. first.last."
     ),
+    suggested_email: str | None = typer.Option(
+        None,
+        "--suggested-email",
+        help="Address you think is right: verified first, and the right one recovered if it is not proven. "
+        "Must be at DOMAIN or the company's mail domain.",
+    ),
     wait: bool = typer.Option(False, "--wait/--no-wait", help=WAIT_HELP),
     timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
@@ -95,7 +101,14 @@ def find_command(
 
     request = build_request(
         FindEmailRequest,
-        _merge_params(None, first_name=first_name, last_name=last_name, domain=domain, known_pattern=known_pattern),
+        _merge_params(
+            None,
+            first_name=first_name,
+            last_name=last_name,
+            domain=domain,
+            known_pattern=known_pattern,
+            suggested_email=suggested_email,
+        ),
     )
     job = get_client(ctx).email.find(request)
     if not wait:

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/src/discolike_cli/main.py

@@ -18,6 +18,7 @@ from discolike_cli import auth
 from discolike_cli import bulk
 from discolike_cli import company
 from discolike_cli import contacts
+from discolike_cli import contacts_run
 from discolike_cli import discogen
 from discolike_cli import discover
 from discolike_cli import email
@@ -83,6 +84,7 @@ app.add_typer(auth.app, name="auth")
 app.add_typer(bulk.app, name="bulk")
 app.add_typer(company.app, name="company")
 app.add_typer(contacts.app, name="contacts")
+contacts.app.add_typer(contacts_run.app, name="run")
 app.add_typer(discogen.app, name="discogen")
 app.add_typer(email.app, name="email")
 app.add_typer(queries.app, name="queries")

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/tests/test_bulk_cli.py

@@ -661,3 +661,16 @@ def test_bulk_rejects_non_positive_rate_limit(
     result = runner.invoke(app, ["bulk", *command, *extra, "--out", str(tmp_path / "c.csv"), "--rate-limit", "0"])
     assert result.exit_code == 2, result.output
     assert recorder.requests == []
+
+
+@pytest.mark.parametrize(("flags", "expected"), [([], None), (["--valid-mx"], "true"), (["--no-valid-mx"], "false")])
+def test_bulk_companies_valid_mx(
+    install_build_client: Callable[[Handler], None], tmp_path: Path, flags: list[str], expected: str | None
+) -> None:
+    recorder = Recorder(discover=[_companies("a", 1)])
+    install_build_client(recorder)
+    result = runner.invoke(
+        app, ["bulk", "companies", "--out", str(tmp_path / "companies.csv"), "--max-companies", "1", *flags]
+    )
+    assert result.exit_code == 0, result.output
+    assert recorder.params("/v1/discover")[0].get("valid_mx") == expected

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/tests/test_company.py

@@ -135,7 +135,7 @@ def test_extract_hits_extract_endpoint_with_url(install_build_client: Callable[[
 
     def handler(request: httpx2.Request) -> httpx2.Response:
         captured["request"] = request
-        return httpx2.Response(200, json={"text": "hello", "language": "en"})
+        return httpx2.Response(200, json={"text": "hello"})
 
     install_build_client(handler)
     result = runner.invoke(app, ["extract", "https://acme.com/about"])
@@ -143,7 +143,7 @@ def test_extract_hits_extract_endpoint_with_url(install_build_client: Callable[[
     request = captured["request"]
     assert request.url.path == "/v1/extract"
     assert request.url.params.get("url") == "https://acme.com/about"
-    assert json.loads(result.stdout) == {"text": "hello", "language": "en"}
+    assert json.loads(result.stdout) == {"text": "hello"}
 
 
 def test_extract_domain_option_replaces_url(install_build_client: Callable[[Handler], None]) -> None:
@@ -151,7 +151,7 @@ def test_extract_domain_option_replaces_url(install_build_client: Callable[[Hand
 
     def handler(request: httpx2.Request) -> httpx2.Response:
         captured["request"] = request
-        return httpx2.Response(200, json={"text": "hello", "language": "en"})
+        return httpx2.Response(200, json={"text": "hello"})
 
     install_build_client(handler)
     result = runner.invoke(app, ["extract", "--domain", "acme.com"])

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/tests/test_contacts_cli.py

@@ -532,7 +532,7 @@ def test_contacts_without_email_validated_does_not_warn(install_build_client: Ca
     install_build_client(lambda request: httpx2.Response(200, json=[]))
     result = runner.invoke(app, ["contacts", "search", "--name", "Jane"])
     assert result.exit_code == 0, result.output
-    assert "deprecated" not in result.stderr
+    assert "email-validated" not in result.stderr
 
 
 def test_contacts_generate_forwards_full_and_partial_domains(install_build_client: Callable[[Handler], None]) -> None:

discolike_cli-0.6.3/tests/test_contacts_run_cli.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import json
+import pathlib
+import time
+from collections.abc import Callable
+from typing import Any
+
+import httpx2
+import pytest
+from typer.testing import CliRunner
+
+from discolike_cli.main import app
+from discolike_testkit import Handler
+
+runner = CliRunner()
+
+RUN_ID = "00000000-0000-0000-0000-0000000000bb"
+RUN_PATH = f"/v1/contacts/run/{RUN_ID}"
+TIMESTAMP = "2026-10-30T12:00:00Z"
+STEPS = ("find_contacts", "find_missing", "review", "find_emails")
+
+
+@pytest.fixture(autouse=True)
+def no_sleep(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(time, "sleep", lambda seconds: None)
+
+
+def run_payload(*, status: str = "waiting", step: int = 0, generation: int = 1) -> dict[str, Any]:
+    return {
+        "id": RUN_ID,
+        "kind": "contacts",
+        "status": status,
+        "current_step": STEPS[step],
+        "generation": generation,
+        "steps": {STEPS[step]: {"status": "done"}},
+        "created_at": TIMESTAMP,
+        "updated_at": TIMESTAMP,
+        "expires_at": TIMESTAMP,
+    }
+
+
+def test_run_create_posts_params_file(install_build_client: Callable[[Handler], None], tmp_path: pathlib.Path) -> None:
+    bodies: list[dict[str, Any]] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        bodies.append(json.loads(request.content))
+        return httpx2.Response(202, json=run_payload(status="running"))
+
+    install_build_client(handler)
+    params_file = tmp_path / "run.json"
+    params_file.write_text(
+        json.dumps({"companies": {"source": "prompt", "icp_text": "dental clinics"}, "people": {"fit": "Owners"}})
+    )
+    result = runner.invoke(
+        app, ["contacts", "run", "create", "--params-file", str(params_file), "--email-cap-usd", "20"]
+    )
+
+    assert result.exit_code == 0, result.output
+    assert bodies == [
+        {
+            "companies": {"source": "prompt", "icp_text": "dental clinics"},
+            "people": {"fit": "Owners"},
+            "email_cap_usd": "20.0",
+        }
+    ]
+    assert json.loads(result.stdout)["status"] == "running"
+
+
+def test_run_continue_fetches_generation_when_omitted(install_build_client: Callable[[Handler], None]) -> None:
+    seen: list[tuple[str, str, Any]] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        body = json.loads(request.content) if request.content else None
+        seen.append((request.method, request.url.path, body))
+        return httpx2.Response(200, json=run_payload(generation=4))
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "run", "continue", RUN_ID, "--redo"])
+
+    assert result.exit_code == 0, result.output
+    assert seen == [
+        ("GET", RUN_PATH, None),
+        ("POST", f"{RUN_PATH}/continue", {"generation": 4, "redo": True}),
+    ]
+
+
+def test_run_wait_polls_automatically(install_build_client: Callable[[Handler], None]) -> None:
+    statuses = iter(["ready", "running", "done"])
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        assert request.method == "GET"
+        return httpx2.Response(200, json=run_payload(status=next(statuses)))
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "run", "wait", RUN_ID])
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout)["status"] == "done"
+
+
+def test_run_events(install_build_client: Callable[[Handler], None]) -> None:
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        assert request.url.path == RUN_PATH + "/events"
+        assert dict(request.url.params) == {"after": "4", "limit": "10"}
+        return httpx2.Response(200, json={"events": [], "next_cursor": 5})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "run", "events", RUN_ID, "--after", "4", "--limit", "10"])
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout)["next_cursor"] == 5
+
+
+@pytest.mark.parametrize("flag", ["--follow", "--email-cap-usd"])
+def test_removed_wait_flags(flag: str) -> None:
+    assert runner.invoke(app, ["contacts", "run", "wait", RUN_ID, flag]).exit_code == 2
+
+
+def test_run_cancel_and_get(install_build_client: Callable[[Handler], None]) -> None:
+    seen: list[tuple[str, str, str]] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        seen.append((request.method, request.url.path, request.url.query.decode()))
+        return httpx2.Response(200, json=run_payload(status="cancelled"))
+
+    install_build_client(handler)
+    assert runner.invoke(app, ["contacts", "run", "cancel", RUN_ID]).exit_code == 0
+    assert runner.invoke(app, ["contacts", "run", "get", RUN_ID, "--rows-limit", "10"]).exit_code == 0
+    assert seen == [("POST", f"{RUN_PATH}/cancel", ""), ("GET", RUN_PATH, "rows_limit=10")]
+
+
+def test_run_list_sends_before(install_build_client: Callable[[Handler], None]) -> None:
+    queries: list[httpx2.QueryParams] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        queries.append(request.url.params)
+        return httpx2.Response(200, json=[run_payload()])
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "run", "list", "--before", "2026-10-30T00:00:00+00:00", "--limit", "5"])
+    assert result.exit_code == 0, result.output
+    assert queries[0]["before"] == "2026-10-30T00:00:00Z"
+    assert queries[0]["limit"] == "5"
+
+
+def test_run_title_preview(install_build_client: Callable[[Handler], None]) -> None:
+    bodies: list[dict[str, Any]] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        bodies.append(json.loads(request.content))
+        return httpx2.Response(200, json={"titles": [{"title": "Owner", "role": 1.0, "count": 3}]})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "run", "title-preview", "--title", "Owner", "--format", "json"])
+    assert result.exit_code == 0, result.output
+    assert bodies == [{"titles": ["Owner"], "match": "similar"}]
+    assert json.loads(result.stdout) == [{"title": "Owner", "role": 1.0, "count": 3}]
+
+
+def test_old_contacts_commands_print_deprecation(install_build_client: Callable[[Handler], None]) -> None:
+    install_build_client(lambda request: httpx2.Response(200, json=[]))
+    result = runner.invoke(app, ["contacts", "search", "--name", "Jane"])
+    assert result.exit_code == 0, result.output
+    assert "`discolike contacts search` is deprecated" in result.stderr
+    assert "use `discolike contacts run`" in result.stderr
+
+
+def test_contacts_discover_prints_no_deprecation(install_build_client: Callable[[Handler], None]) -> None:
+    install_build_client(lambda request: httpx2.Response(200, json={"results": {}}))
+    result = runner.invoke(app, ["contacts", "discover", "--domain", "acme.com"])
+    assert result.exit_code == 0, result.output
+    assert "deprecated" not in result.stderr
+
+
+def test_email_find_sends_suggested_email(install_build_client: Callable[[Handler], None]) -> None:
+    bodies: list[dict[str, Any]] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        bodies.append(json.loads(request.content))
+        return httpx2.Response(202, json={"job_id": "j-1", "status": "queued"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["email", "find", "Grace", "Hopper", "navy.mil", "--suggested-email", "grace@navy.mil"])
+    assert result.exit_code == 0, result.output
+    assert bodies == [
+        {"first_name": "Grace", "last_name": "Hopper", "domain": "navy.mil", "suggested_email": "grace@navy.mil"}
+    ]
+
+
+def test_run_insufficient_balance(install_build_client: Callable[[Handler], None], tmp_path: pathlib.Path) -> None:
+    install_build_client(
+        lambda _: httpx2.Response(
+            403,
+            json={
+                "detail": {
+                    "code": "INSUFFICIENT_BALANCE",
+                    "message": "Top up to continue",
+                    "remaining_usd": 1,
+                    "max_affordable_records": 2,
+                }
+            },
+        )
+    )
+    params = tmp_path / "run.json"
+    params.write_text(json.dumps({"companies": {"source": "domains", "domains": ["acme.com"]}}))
+    result = runner.invoke(app, ["contacts", "run", "create", "--params-file", str(params)])
+    assert result.exit_code == 3
+    error = json.loads(result.stderr)
+    assert error["code"] == "insufficient_balance"
+    assert error["max_affordable_records"] == 2

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/tests/test_discover.py

@@ -4,6 +4,7 @@ import json
 from collections.abc import Callable
 
 import httpx2
+import pytest
 from typer.testing import CliRunner
 
 from discolike_cli.main import app
@@ -411,3 +412,20 @@ def test_discover_unauthorized_exits_3(install_build_client: Callable[[Handler],
     assert result.exit_code == 3
     payload = json.loads(result.stderr)
     assert payload["error"] == "AuthenticationError"
+
+
+@pytest.mark.parametrize("command", ["discover", "count"])
+@pytest.mark.parametrize(("flags", "expected"), [([], None), (["--valid-mx"], "true"), (["--no-valid-mx"], "false")])
+def test_valid_mx_flag(
+    install_build_client: Callable[[Handler], None], command: str, flags: list[str], expected: str | None
+) -> None:
+    seen: list[httpx2.QueryParams] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        seen.append(request.url.params)
+        return _count_ok(request) if command == "count" else _discover_ok(request)
+
+    install_build_client(handler)
+    result = runner.invoke(app, [command, *flags])
+    assert result.exit_code == 0, result.output
+    assert seen[0].get("valid_mx") == expected

{discolike_cli-0.6.2 → discolike_cli-0.6.3}/tests/test_sdk_parity.py

@@ -29,7 +29,10 @@ DELIBERATELY_OMITTED: dict[str, frozenset[str]] = {
 }
 # ``discolike bulk`` takes the full vocabulary through --params-file / --param and manages the paging
 # fields itself; its flags are the handful a volume run needs, not one per SDK field.
-PARAMS_FILE_SITES = frozenset({"bulk.companies_command", "bulk.estimate_command", "bulk.contacts_command"})
+# ``contacts run create`` takes its nested companies/people request the same way.
+PARAMS_FILE_SITES = frozenset(
+    {"bulk.companies_command", "bulk.estimate_command", "bulk.contacts_command", "contacts_run.create_command"}
+)
 DICT_ONLY_FIELDS: dict[str, frozenset[str]] = {
     "ContactGenerateRequest": frozenset({"initial_contact_counts"}),
     "DiscoGenProcessRequest": frozenset({"previous_discogen_data"}),
@@ -97,7 +100,7 @@ def test_cli_forwards_every_sdk_field(site: str, model_name: str, forwarded: set
 
 
 def test_every_request_model_has_a_cli_command() -> None:
-    used = {model_name for _, model_name, _ in SITES}
+    used = {model_name for _, model_name, _ in _build_request_sites()}
     declared = {
         name
         for name in dir(requests_module)