@zenrows/cli 1.7.0 → 1.8.0

package/README.md

@@ -128,20 +128,75 @@ zenrows extract <url> --output markdown
 
 Zenrows **Batch** (`https://async.api.zenrows.com/v1`) fans a
 protected fetch/extract out over many URLs. The cloud subcommands work
-with any active API key and spend the same credits as Fetch. Local spec
-validation + credit estimation always work (no key needed).
+with any active API key and cost the same credits as Fetch: Batch is the
+reliable path at scale, at Fetch's prices. Local spec validation + credit
+estimation always work (no key needed).
 
 ```bash
-zenrows batch estimate jobs.jsonl                    # validate the spec + estimate credits (local)
-zenrows batch create jobs.jsonl --wait               # submit a job and wait for it to finish
-zenrows batch status <job-id>                        # run status + progress stats
-zenrows batch results <job-id> --out results.jsonl   # collect results (paginated)
-zenrows batch cancel <job-id>                        # stop an in-flight run
+zenrows batch estimate jobs.jsonl                     # validate the spec + estimate credits (local)
+zenrows batch create jobs.jsonl --follow              # submit a job and wait for it to finish
+zenrows batch list                                    # your jobs, newest first
+zenrows batch status <job-id>                         # run status, progress stats, pause state
+zenrows batch wait <job-id> --timeout 30m             # wait for the run to end
+zenrows batch results <job-id> --out results.jsonl    # collect results (paginated)
+zenrows batch content <job-id> <task-id>              # one task's result body
+zenrows batch pause <job-id>                          # pause the run (resume <job-id> continues it)
+zenrows batch cancel <job-id>                         # stop an in-flight run
+zenrows batch retry-failed <job-id> --include-pending # rerun every task that did not succeed
+zenrows batch rerun <job-id>                          # rerun failed + pending tasks (--all: every task)
+zenrows batch delete <job-id> --yes                   # delete the job, its runs and results
 ```
 
 `jobs.jsonl` is one JSON object per line, each with a `url` (plus optional
 per-line overrides like `js_render`, `premium_proxy`, `proxy_country`,
-`extract`). Validate and estimate locally first, then submit with `create`.
+`extract`, nested `zenrows_params`, an `external_id`, string `metadata`, and
+`"method": "POST"` with a `body` of up to 16 KiB). `estimate` and `create`
+check every line against the API's limits before anything is sent: `url` up
+to 2048 bytes, `external_id` up to 128 letters, digits, `.`, `_` or `-`,
+and `metadata` up to 20 string entries (4 KiB). Validate and estimate locally
+first, then submit with `create`. `estimate` takes `create`'s
+`--manual` / `--js-render` / `--premium-proxy` / `--proxy-country` flags and
+prices the same request, as a range (Adaptive Stealth Mode costs 1 to 25).
+
+`create` also takes `--name`, `--external-id` and `--metadata key=value`
+(repeatable) for the job itself. It sends an `Idempotency-Key` (generated, or
+`--idempotency-key`) and retries network errors and 502/503/504 under it; an
+outcome that stays unknown prints the command that repeats the request with
+that key, which cannot create a second job.
+
+The local policy caps a run at 10,000 URLs and 250,000 estimated credits by
+default (an Adaptive Stealth Mode task counts 25), so a default run of up to
+10,000 URLs passes in any mode. Raise them for larger jobs (the API takes up to
+100,000 tasks per job): `zenrows policy set max_pages_per_run 100000` and
+`zenrows policy set max_credits_per_run 2500000`. A workspace created by an
+earlier version keeps its caps (1,000 and 10,000) in `policy.json`.
+
+`wait`, `create --follow` and `rerun --follow` poll until the run ends, the run
+is paused, or `--timeout` runs out (default 10 minutes; `30s`, `5m`, `1h`; a
+bare number is milliseconds, as before). When the time runs out, or the run is
+paused, the command exits 0 and prints the run with a `note` and the next
+command; the job keeps running. Ctrl-C stops the wait, not the job, and exits
+130. A run that ends `failed` exits 1: out of credits is
+`POLICY_MAX_CREDITS_EXCEEDED`, an inactive subscription `AUTH_INVALID`, a key
+cap `KEY_CREDIT_CAP_REACHED` (the same codes a refused request gets), anything
+else `BATCH_FAILED`, each with the run's `failure_reason` as `server_code` and
+the `job_id`. Then run the unfinished tasks with
+`zenrows batch rerun <job-id> --status failed,pending,processing`. With no
+flag, `rerun` reruns the `failed` and `pending` tasks, so successful tasks are
+never billed again by surprise; `--status <list>` picks the statuses and
+`--all` reruns every task (not with `--status`). A partial rerun works for 10
+days after the run started; `--all` always does.
+
+With `--json`, `create`, `status`, `wait`, `cancel`, `pause`, `resume` and
+`rerun` print `{ok, job_id, run_id, status, stats, job}` (`jobId` is kept for
+older scripts), plus `paused`, `ingest_status`, `accepted_tasks`, `rerun_of`,
+`retried_tasks` and `inherited_tasks` when the API sends them. Results are
+kept 14 days by default and then read `expired`; a `result_url` is valid 2
+hours. Lifecycle errors get their own codes (`BATCH_RUN_IN_PROGRESS`,
+`BATCH_NO_MATCHING_TASKS`, `BATCH_RERUN_WINDOW_EXPIRED`,
+`BATCH_REQUEST_IN_FLIGHT`, `BATCH_RESULT_EXPIRED`, ...) and carry the API's code
+as `server_code`. Schedules, webhooks, ZIP exports, CSV inputs and open jobs
+are available through the Batch API and the SDKs, not this CLI.
 
 **Extract in Batch.** Set `"extract": "auto"` on a line to run that URL through
 Extract — structured data instead of raw HTML:
@@ -186,7 +241,7 @@ zenrows crawl stop <crawl-id>                           # stop a running crawl
 follows links until `--max-items` or `--max-pages` stops it, or nothing is left
 to open. `--max-items` and `--max-pages` cap the crawl (API default 100 each),
 and `--max-pages` bounds the cost, since each page is one fetch. The local policy `max_pages_per_run` caps `--max-pages` (default
-1000). `--output-format html` uses up the page budget: each kept page is one
+10000). `--output-format html` uses up the page budget: each kept page is one
 more fetch, and `--max-pages` counts it. `--include-patterns` /
 `--exclude-patterns` are repeatable substring filters on the URL. A crawl whose
 pages held nothing new to follow ends `completed` with no results and exits 0.

package/agent-plugin/skills/batch-jobs/SKILL.md

@@ -7,7 +7,8 @@ version: 0.1.0
 # Batch Jobs (MCP)
 
 Process large workloads asynchronously. Batch is where Zenrows' high-scale
-anti-bot advantage becomes obvious — thousands to millions of URLs.
+anti-bot advantage becomes obvious: thousands to 100,000 URLs per job, at
+Fetch's prices.
 
 > Cloud Batch lives on `async.api.zenrows.com/v1`. A 403 maps to
 > `BATCH_ACCESS_DENIED`. Do not fake a successful
@@ -33,10 +34,22 @@ Optional if exposed by the server: `batch_wait` to block until terminal status.
    `autoparse`, `extract`, `external_id`, `metadata`). `extract: "auto"`
    returns structured data instead of raw HTML, at the same credit cost as a
    regular task; the result carries `html` and `parsed` keys.
-3. Poll `batch_status` until terminal (`completed` / `stopped` / …).
-4. Collect with `batch_results`.
+3. Poll `batch_status` until terminal (`completed`, `stopped`, `failed` or
+   `deleted`). A paused run (`pause_state: paused`) is not terminal and picks
+   up no new task until resumed: report it instead of polling on.
+4. Collect with `batch_results`. Results are kept 14 days by default (then a
+   row reads `expired`); a `result_url` is valid 2 hours.
 5. `batch_cancel` if the user aborts or the run should stop early.
 
+A run ends `failed` when an account problem stops it: `failure_reason`
+`insufficient_credits` (add credits), `subscription_inactive` (fix it in
+Billing) or `api_key_cap_reached` (the key's own cap; the account still has
+credits). The tasks not yet run stay `pending`: once fixed, rerun them with
+status `failed,pending,processing` rather than resubmitting the job.
+
+Schedules, webhooks, ZIP exports and CSV inputs are available through the
+Batch API and the SDKs.
+
 ## Rules
 
 - **Never batch before validating** on a single page ([[extract]] /

package/dist/src/adapters/batch.js

@@ -3,14 +3,28 @@
  *
  * Status: `available`. The cloud subcommands call the Batch API with an API key
  * (see `core/batch-api.ts`); a 403 maps to BATCH_ACCESS_DENIED. This adapter owns
- * the local, no-network pieces: validating a JSONL job spec, estimating credit
- * cost, and mapping the validated spec to the Batch API request body.
+ * the local, no-network pieces: validating a JSONL job spec against the API's
+ * limits, estimating credit cost, and mapping the validated spec to the Batch
+ * API request body.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { ToolkitError } from "../core/errors.js";
-/** Per-task keys handled explicitly; everything else on a line is a scrape param. */
-const TASK_RESERVED = new Set(["url", "external_id", "metadata", "zenrows_params"]);
-/** Parse + validate a JSONL job spec locally. */
+/** Per-task keys sent at task level; everything else on a line is a scrape param. */
+const TASK_RESERVED = new Set(["url", "external_id", "metadata", "zenrows_params", "method", "body"]);
+/** The API's limits on a task and on job-level fields. */
+export const LIMITS = {
+    urlLength: 2048,
+    externalIdLength: 128,
+    metadataEntries: 20,
+    metadataKeyLength: 64,
+    metadataValueLength: 1024,
+    metadataTotalBytes: 4 * 1024,
+    bodyBytes: 16 * 1024,
+    nameLength: 100,
+};
+/** `external_id` and metadata keys: letters, digits, `.`, `_` and `-`. */
+const SAFE_ID = /^[A-Za-z0-9._-]+$/;
+/** Parse + validate a JSONL job spec locally, against the API's per-task limits. */
 export function validateJsonl(file) {
     if (!existsSync(file)) {
         throw new ToolkitError({
@@ -28,45 +42,171 @@ export function validateJsonl(file) {
         if (!trimmed)
             return;
         result.totalLines++;
+        let obj;
         try {
-            const obj = JSON.parse(trimmed);
-            if (!obj.url || typeof obj.url !== "string") {
-                result.errors.push({ line: idx + 1, reason: "missing string `url`" });
-                return;
-            }
-            try {
-                new URL(obj.url);
-            }
-            catch {
-                result.errors.push({ line: idx + 1, reason: `invalid url: ${obj.url}` });
-                return;
-            }
-            result.validJobs++;
-            result.jobs.push(obj);
+            obj = JSON.parse(trimmed);
         }
         catch {
             result.errors.push({ line: idx + 1, reason: "invalid JSON" });
+            return;
+        }
+        const reason = taskError(obj);
+        if (reason) {
+            result.errors.push({ line: idx + 1, reason });
+            return;
         }
+        result.validJobs++;
+        result.jobs.push(obj);
     });
     return result;
 }
+/** Why one JSONL line would be rejected by the API, or null when it is valid. */
+function taskError(obj) {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj))
+        return "a line must be a JSON object";
+    const job = obj;
+    if (!job.url || typeof job.url !== "string")
+        return "missing string `url`";
+    let u;
+    try {
+        u = new URL(job.url);
+    }
+    catch {
+        return `invalid url: ${job.url}`;
+    }
+    if (u.protocol !== "http:" && u.protocol !== "https:")
+        return `url must be http or https: ${job.url}`;
+    // The API counts these limits in UTF-8 bytes, not characters.
+    if (Buffer.byteLength(job.url) > LIMITS.urlLength)
+        return `url is longer than ${LIMITS.urlLength} bytes`;
+    if (job.external_id !== undefined && job.external_id !== null) {
+        const e = externalIdError(job.external_id);
+        if (e)
+            return e;
+    }
+    const meta = metadataError(job.metadata);
+    if (meta)
+        return meta;
+    if (job.zenrows_params !== undefined && (typeof job.zenrows_params !== "object" || job.zenrows_params === null || Array.isArray(job.zenrows_params))) {
+        return "`zenrows_params` must be an object";
+    }
+    return methodBodyError(job.method, job.body);
+}
+/** Why an `external_id` is invalid, or null. Numbers are sent as their string form. */
+export function externalIdError(v) {
+    if (typeof v !== "string" && typeof v !== "number")
+        return "`external_id` must be a string";
+    const s = String(v);
+    if (s.length === 0 || s.length > LIMITS.externalIdLength)
+        return `\`external_id\` must be 1 to ${LIMITS.externalIdLength} characters`;
+    if (!SAFE_ID.test(s))
+        return "`external_id` may only use letters, digits, `.`, `_` and `-`";
+    return null;
+}
 /**
- * Rough local credit estimate using documented multipliers
- * (basic 1x, js 5x, proxies 10x, both 25x). Counts in abstract "credits".
+ * Why `metadata` is invalid, or null: the API takes at most 20 string-to-string
+ * entries, keys of 1 to 64 safe characters, values up to 1024 bytes, 4 KiB
+ * in total. Any other shape fails the whole submit.
  */
-export function estimateCredits(jobs) {
+export function metadataError(metadata) {
+    if (metadata === undefined || metadata === null)
+        return null;
+    if (typeof metadata !== "object" || Array.isArray(metadata))
+        return "`metadata` must be an object of string values";
+    const entries = Object.entries(metadata);
+    if (entries.length > LIMITS.metadataEntries)
+        return `\`metadata\` has more than ${LIMITS.metadataEntries} entries`;
+    let total = 0;
+    for (const [k, v] of entries) {
+        if (k.length === 0 || k.length > LIMITS.metadataKeyLength || !SAFE_ID.test(k)) {
+            return `\`metadata\` key "${k}" must be 1 to ${LIMITS.metadataKeyLength} letters, digits, \`.\`, \`_\` or \`-\``;
+        }
+        if (typeof v !== "string")
+            return `\`metadata.${k}\` must be a string`;
+        if (Buffer.byteLength(v) > LIMITS.metadataValueLength)
+            return `\`metadata.${k}\` is longer than ${LIMITS.metadataValueLength} bytes`;
+        total += Buffer.byteLength(k) + Buffer.byteLength(v);
+    }
+    if (total > LIMITS.metadataTotalBytes)
+        return "`metadata` is larger than 4 KiB";
+    return null;
+}
+/** Why `method` / `body` are invalid, or null. Only GET and POST exist; a body needs POST. */
+function methodBodyError(method, body) {
+    if (method !== undefined && method !== null) {
+        if (typeof method !== "string" || !/^(get|post)$/i.test(method))
+            return "`method` must be GET or POST";
+    }
+    if (body === undefined || body === null)
+        return null;
+    if (!isPost(method))
+        return "`body` needs `\"method\": \"POST\"`";
+    const bytes = typeof body === "string" ? Buffer.byteLength(body) : Buffer.byteLength(JSON.stringify(body));
+    if (bytes > LIMITS.bodyBytes)
+        return `\`body\` is larger than ${LIMITS.bodyBytes / 1024} KiB`;
+    return null;
+}
+function isPost(method) {
+    return typeof method === "string" && method.toUpperCase() === "POST";
+}
+/**
+ * Scrape params the API reads as booleans. It accepts JSON `true`/`false` or the
+ * strings "true"/"false" in any case, and rejects anything else with a 400.
+ */
+const BOOLEAN_PARAMS = new Set(["js_render", "premium_proxy", "original_status", "json_response", "autoparse"]);
+/** JSON `true` and "true" in any case become "true"; likewise "false". Any other value is unchanged. */
+function canonicalBool(v) {
+    if (v === true)
+        return "true";
+    if (v === false)
+        return "false";
+    if (typeof v === "string") {
+        const s = v.trim().toLowerCase();
+        if (s === "true" || s === "false")
+            return s;
+    }
+    return v;
+}
+/** A task's own params: its nested `zenrows_params`, then its flat keys (later wins). */
+function taskParamsOf(job) {
+    const flat = {};
+    for (const [k, v] of Object.entries(job)) {
+        if (!TASK_RESERVED.has(k))
+            flat[k] = v;
+    }
+    return { ...(job.zenrows_params ?? {}), ...flat };
+}
+/**
+ * The params a task actually runs with: the job-level params and the task's
+ * own, each canonicalized exactly as submitted, merged the way the API merges
+ * them (the task wins on a shared key). A task key set to null is not
+ * submitted, so the job's value applies.
+ */
+export function effectiveParams(job, jobParams = {}) {
+    return { ...normalizeParams(jobParams), ...normalizeParams(taskParamsOf(job)) };
+}
+/**
+ * Local credit estimate from the rate card: basic 1, js_render 5,
+ * premium_proxy 10, both 25. An Adaptive Stealth Mode task (`mode=auto`)
+ * costs 1 to 25 depending on what each page needs, so it counts 1 in `min`
+ * and 25 in `credits` (the upper bound). Each task is priced on the params
+ * it is submitted with, job-level flags included.
+ */
+export function estimateCredits(jobs, jobParams = {}) {
+    let min = 0;
     const perJob = jobs.map((j) => {
-        const js = j.js_render || j.mode === "auto";
-        const proxy = j.premium_proxy || j.mode === "auto";
-        if (js && proxy)
+        const p = effectiveParams(j, jobParams);
+        if (p.mode === "auto") {
+            min += 1;
             return 25;
-        if (proxy)
-            return 10;
-        if (js)
-            return 5;
-        return 1;
+        }
+        const js = p.js_render === "true";
+        const proxy = p.premium_proxy === "true";
+        const cost = js && proxy ? 25 : proxy ? 10 : js ? 5 : 1;
+        min += cost;
+        return cost;
     });
-    return { credits: perJob.reduce((a, b) => a + b, 0), perJob };
+    return { credits: perJob.reduce((a, b) => a + b, 0), min, perJob };
 }
 /**
  * Adaptive Stealth Mode (mode=auto) by default, like `fetch` and `extract`: returns
@@ -74,14 +214,17 @@ export function estimateCredits(jobs) {
  * `premium_proxy` or set `mode` itself, and none at all when the job-level params
  * force either flag. Applied per task rather than job-level because the API rejects
  * a task that combines a job-level mode=auto with its own js_render or
- * premium_proxy (REQS004).
+ * premium_proxy (REQS004). A POST task is left alone: Adaptive Stealth Mode may
+ * turn on JavaScript rendering, which a POST cannot use.
  */
 export function withAdaptiveStealth(jobs, jobParams = {}) {
     const forced = (p) => isTruthyFlag(p.js_render) || isTruthyFlag(p.premium_proxy);
     if (forced(jobParams) || jobParams.mode != null)
         return jobs;
     return jobs.map((job) => {
-        const own = { ...(job.zenrows_params ?? {}), ...job };
+        if (isPost(job.method))
+            return job;
+        const own = taskParamsOf(job);
         if (forced(own) || own.mode != null)
             return job;
         return { ...job, mode: "auto" };
@@ -92,38 +235,45 @@ export function withAdaptiveStealth(jobs, jobParams = {}) {
  * The flat per-line options (`js_render`, `premium_proxy`, `proxy_country`,
  * `autoparse`, `mode`, …) plus any nested `zenrows_params` become that task's
  * `zenrows_params`; `jobParams` (from CLI flags) becomes the job-level
- * `zenrows_params`. `url`/`external_id`/`metadata` map straight through.
+ * `zenrows_params`. `url`, `external_id`, `metadata`, `method` and `body` are
+ * task fields and map straight through.
  *
- * The API rejects `proxy_country` without `premium_proxy` (unless mode=auto),
- * so we surface PARAM_PROXY_COUNTRY_REQUIRES_PREMIUM here — before submitting —
- * for the effective (job + task) params, mirroring the manual-mode guard in
- * `protected-fetch.ts::validateAutoManual`.
+ * Checked here, before submitting, on the effective (job + task) params:
+ * boolean params hold true or false; `proxy_country` needs `premium_proxy`
+ * unless mode=auto (PARAM_PROXY_COUNTRY_REQUIRES_PREMIUM, mirroring
+ * `protected-fetch.ts::validateAutoManual`); a POST task does not turn on
+ * `js_render`, `js_instructions` or `json_response`, which the API rejects.
  */
-export function toJobBody(jobs, jobParams = {}) {
-    // No separate job-level check: a job-level proxy_country is valid for each task
-    // in Adaptive Stealth Mode, and the per-task check below sees job ⊕ task params.
+export function toJobBody(jobs, jobParams = {}, fields = {}) {
     const tasks = jobs.map((job, idx) => {
-        const { url, external_id, metadata, zenrows_params } = job;
-        const flat = {};
-        for (const [k, v] of Object.entries(job)) {
-            if (!TASK_RESERVED.has(k))
-                flat[k] = v;
-        }
-        const taskParams = { ...(zenrows_params ?? {}), ...flat };
-        // Validate on the effective (job ⊕ task) params so a job-level premium_proxy
-        // covers a per-task proxy_country, matching how the API merges them.
-        assertProxyCountryPremium({ ...jobParams, ...taskParams }, `line ${idx + 1} (${url})`);
+        const { url, external_id, metadata } = job;
+        const where = `line ${idx + 1} (${url})`;
+        const effective = effectiveParams(job, jobParams);
+        assertBooleanParams(effective, where);
+        assertProxyCountryPremium(effective, where);
         const task = { url };
-        if (external_id !== undefined)
+        if (external_id !== undefined && external_id !== null)
             task.external_id = String(external_id);
-        if (metadata !== undefined)
+        if (metadata !== undefined && metadata !== null)
             task.metadata = metadata;
-        const zp = normalizeParams(taskParams);
+        if (isPost(job.method)) {
+            assertPostParams(effective, where);
+            task.method = "POST";
+            if (job.body !== undefined && job.body !== null)
+                task.body = job.body;
+        }
+        const zp = normalizeParams(taskParamsOf(job));
         if (Object.keys(zp).length)
             task.zenrows_params = zp;
         return task;
     });
     const body = { type: "regular", status: "closed", tasks };
+    if (fields.name)
+        body.name = fields.name;
+    if (fields.external_id)
+        body.external_id = fields.external_id;
+    if (fields.metadata && Object.keys(fields.metadata).length)
+        body.metadata = fields.metadata;
     const jobZp = normalizeParams(jobParams);
     if (Object.keys(jobZp).length)
         body.zenrows_params = jobZp;
@@ -131,14 +281,16 @@ export function toJobBody(jobs, jobParams = {}) {
 }
 /**
  * Coerce a flat options object into the string-valued map the Batch API expects
- * (its docs pass `zenrows_params` values as strings, e.g. `"true"`, `"us"`).
- * Booleans/numbers are stringified; objects are JSON-encoded; nullish is dropped.
+ * (`zenrows_params` values are strings, e.g. `"true"`, `"us"`). Boolean params
+ * are canonicalized to "true"/"false"; other booleans/numbers are stringified;
+ * objects are JSON-encoded; nullish is dropped.
  */
 function normalizeParams(obj) {
     const out = {};
-    for (const [k, v] of Object.entries(obj)) {
-        if (v === undefined || v === null)
+    for (const [k, raw] of Object.entries(obj)) {
+        if (raw === undefined || raw === null)
             continue;
+        const v = BOOLEAN_PARAMS.has(k) ? canonicalBool(raw) : raw;
         if (typeof v === "string")
             out[k] = v;
         else if (typeof v === "boolean" || typeof v === "number")
@@ -153,7 +305,33 @@ function isAutoMode(v) {
     return v === "auto" || v === true;
 }
 function isTruthyFlag(v) {
-    return v === true || v === "true";
+    return canonicalBool(v) === "true";
+}
+/** Throw before submitting if a boolean param holds a value the API rejects. */
+function assertBooleanParams(params, where) {
+    for (const k of BOOLEAN_PARAMS) {
+        const v = params[k];
+        if (v !== undefined && v !== "true" && v !== "false") {
+            throw new ToolkitError({
+                code: "INVALID_USAGE",
+                message: `${k} must be true or false (got ${JSON.stringify(v)}) in ${where}.`,
+                likely_cause: `The Batch API accepts only true or false for ${k}; any other value fails the whole job.`,
+                next_action: `Set ${k} to true or false on that line, then retry.`,
+            });
+        }
+    }
+}
+/** Throw if a POST task would turn on a param the API refuses with POST (method_param_conflict). */
+function assertPostParams(params, where) {
+    const conflict = params.js_render === "true" ? "js_render" : params.json_response === "true" ? "json_response" : params.js_instructions ? "js_instructions" : undefined;
+    if (!conflict)
+        return;
+    throw new ToolkitError({
+        code: "INVALID_USAGE",
+        message: `A POST task cannot use ${conflict}: ${where}.`,
+        likely_cause: "POST tasks run without a browser, so the Batch API rejects js_render, js_instructions and json_response on them (method_param_conflict).",
+        next_action: "Drop that param from the line (or the job-level --js-render flag), or send the task as GET.",
+    });
 }
 /** Throw if proxy_country is set without premium_proxy and outside auto mode. */
 function assertProxyCountryPremium(params, where) {