firecrawl 4.35.0 → 4.37.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   require_package
-} from "./chunk-666CR5HH.js";
+} from "./chunk-LFX7WDGT.js";
 
 // src/v2/utils/httpClient.ts
 import axios from "axios";
@@ -48,6 +48,11 @@ var HttpClient = class {
   getApiKey() {
     return this.apiKey;
   }
+  /** The client-wide default request timeout, for callers that need to
+   * extend a specific request beyond it (e.g. scrape auto-resume). */
+  getTimeoutMs() {
+    return this.instance.defaults.timeout ?? 3e5;
+  }
   async request(config) {
     const version = getVersion();
     config.headers = {
@@ -428,26 +433,60 @@ function isRetryableError(err) {
 }
 
 // src/v2/methods/scrape.ts
-async function scrape(http, url, options) {
+var RESUME_MAX_ATTEMPTS = 5;
+var RESUME_MAX_TOTAL_WAIT_MS = 20 * 60 * 1e3;
+var RESUME_MIN_DELAY_MS = 5 * 1e3;
+var RESUME_MAX_DELAY_MS = 10 * 60 * 1e3;
+function processingContinuesDelayMs(err) {
+  const response = err?.isAxiosError ? err.response : void 0;
+  if (!response || response.status !== 408) return void 0;
+  const body = response.data;
+  if (body?.code !== "SCRAPE_TIMEOUT" || body?.details?.state !== "processing_continues") {
+    return void 0;
+  }
+  const headerSeconds = Number(response.headers?.["retry-after"]);
+  const seconds = typeof body.details.retryAfterSeconds === "number" && Number.isFinite(body.details.retryAfterSeconds) ? body.details.retryAfterSeconds : Number.isFinite(headerSeconds) ? headerSeconds : 60;
+  return Math.min(RESUME_MAX_DELAY_MS, Math.max(RESUME_MIN_DELAY_MS, seconds * 1e3));
+}
+async function scrape(http, url, options, deps = {}) {
+  const sleep = deps.sleepImpl ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   if (!url || !url.trim()) {
     throw new Error("URL cannot be empty");
   }
   if (options) ensureValidScrapeOptions(options);
+  const { autoResume, ...requestOptions } = options ?? {};
   const payload = { url: url.trim() };
-  if (options) Object.assign(payload, options);
-  try {
-    const res = await http.post(
-      "/v2/scrape",
-      payload,
-      typeof options?.timeout === "number" ? { timeoutMs: options.timeout + 5e3 } : {}
-    );
-    if (res.status !== 200 || !res.data?.success) {
-      throwForBadResponse(res, "scrape");
+  Object.assign(payload, requestOptions);
+  const requestTimeout = autoResume === false ? typeof options?.timeout === "number" ? { timeoutMs: options.timeout + 5e3 } : {} : {
+    timeoutMs: Math.max(
+      typeof options?.timeout === "number" ? options.timeout : 3e5,
+      typeof http.getTimeoutMs === "function" ? http.getTimeoutMs() : 0
+    ) + 3e4
+  };
+  let resumes = 0;
+  let resumeWaitedMs = 0;
+  while (true) {
+    try {
+      const res = await http.post(
+        "/v2/scrape",
+        payload,
+        requestTimeout
+      );
+      if (res.status !== 200 || !res.data?.success) {
+        throwForBadResponse(res, "scrape");
+      }
+      return res.data.data || {};
+    } catch (err) {
+      const delayMs = autoResume !== false ? processingContinuesDelayMs(err) : void 0;
+      if (delayMs !== void 0 && resumes < RESUME_MAX_ATTEMPTS && resumeWaitedMs + delayMs <= RESUME_MAX_TOTAL_WAIT_MS) {
+        resumes += 1;
+        resumeWaitedMs += delayMs;
+        await sleep(delayMs);
+        continue;
+      }
+      if (err?.isAxiosError) return normalizeAxiosError(err, "scrape");
+      throw err;
     }
-    return res.data.data || {};
-  } catch (err) {
-    if (err?.isAxiosError) return normalizeAxiosError(err, "scrape");
-    throw err;
   }
 }
 async function interact(http, jobId, args) {
@@ -1195,6 +1234,7 @@ function prepareAgentPayload(args) {
   if (args.maxCredits !== null && args.maxCredits !== void 0) body.maxCredits = args.maxCredits;
   if (args.strictConstrainToURLs !== null && args.strictConstrainToURLs !== void 0) body.strictConstrainToURLs = args.strictConstrainToURLs;
   if (args.model !== null && args.model !== void 0) body.model = args.model;
+  if (args.effort !== null && args.effort !== void 0) body.effort = args.effort;
   if (args.webhook != null) body.webhook = args.webhook;
   if (args.threatProtection != null)
     body.threatProtection = args.threatProtection;
@@ -1238,6 +1278,27 @@ async function agent(http, args) {
   if (!jobId) return started;
   return waitAgent(http, jobId, args.pollInterval ?? 2, args.timeout);
 }
+async function getAgentTrace(http, jobId, options) {
+  try {
+    const query = options?.liveView ? "?liveView=true" : "";
+    const res = await http.get(`/v2/agent/${jobId}/trace${query}`);
+    if (res.status !== 200) throwForBadResponse(res, "agent trace");
+    return res.data;
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "agent trace");
+    throw err;
+  }
+}
+async function getAgentSnapshot(http, jobId, snapshotId) {
+  try {
+    const res = await http.get(`/v2/agent/${jobId}/snapshots/${snapshotId}`);
+    if (res.status !== 200) throwForBadResponse(res, "agent snapshot");
+    return res.data;
+  } catch (err) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "agent snapshot");
+    throw err;
+  }
+}
 async function cancelAgent(http, jobId) {
   try {
     const res = await http.delete(`/v2/agent/${jobId}`);
@@ -2239,6 +2300,22 @@ var FirecrawlClient = class {
   async cancelAgent(jobId) {
     return cancelAgent(this.http, jobId);
   }
+  /**
+   * Get the execution trace of an agent job (spark-2 runs only).
+   * @param jobId Agent job id.
+   * @param options.liveView Also include currently active browser sessions with live view URLs.
+   */
+  async getAgentTrace(jobId, options) {
+    return getAgentTrace(this.http, jobId, options);
+  }
+  /**
+   * Get the full content of an artifact snapshot referenced by a trace event.
+   * @param jobId Agent job id.
+   * @param snapshotId Snapshot id from an artifact.updated trace event.
+   */
+  async getAgentSnapshot(jobId, snapshotId) {
+    return getAgentSnapshot(this.http, jobId, snapshotId);
+  }
   // Browser
   /**
    * Create a new browser session.
@@ -2381,7 +2458,7 @@ var FirecrawlApp = class {
       if (typeof process !== "undefined" && process.env && process.env.npm_package_version) {
         return process.env.npm_package_version;
       }
-      const packageJson = await import("./package-ZOVFJE7Z.js");
+      const packageJson = await import("./package-SHMK2LJE.js");
       return packageJson.default.version;
     } catch (error) {
       const isTest = typeof process !== "undefined" && (process.env.JEST_WORKER_ID != null || false);

package/dist/{package-ZOVFJE7Z.js → package-SHMK2LJE.js}

@@ -1,4 +1,4 @@
 import {
   require_package
-} from "./chunk-666CR5HH.js";
+} from "./chunk-LFX7WDGT.js";
 export default require_package();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firecrawl",
-  "version": "4.35.0",
+  "version": "4.37.0",
   "description": "JavaScript SDK for the Firecrawl API: web scraping, crawling, web search, and scientific literature search over a research paper index of PubMed, bioRxiv, medRxiv and arXiv abstracts",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/__tests__/unit/v2/agent-effort-trace.unit.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  startAgent,
+  getAgentTrace,
+  getAgentSnapshot,
+} from "../../../v2/methods/agent";
+import type { AgentTraceEvent } from "../../../v2/types";
+
+describe("v2.agent unit", () => {
+  test("startAgent forwards effort in request payload", async () => {
+    const post = jest.fn().mockResolvedValue({
+      status: 200,
+      data: { success: true, id: "agent-job" },
+    });
+
+    await startAgent({ post } as any, {
+      prompt: "Find the pricing",
+      effort: "high",
+    });
+
+    expect(post).toHaveBeenCalledWith("/v2/agent", {
+      prompt: "Find the pricing",
+      effort: "high",
+    });
+  });
+
+  test("startAgent omits effort when unset", async () => {
+    const post = jest.fn().mockResolvedValue({
+      status: 200,
+      data: { success: true, id: "agent-job" },
+    });
+
+    await startAgent({ post } as any, { prompt: "Find the pricing" });
+
+    expect(post).toHaveBeenCalledWith("/v2/agent", {
+      prompt: "Find the pricing",
+    });
+  });
+
+  test("getAgentTrace hits the trace endpoint and returns typed events", async () => {
+    const runStarted: AgentTraceEvent = {
+      schemaVersion: 1,
+      eventId: "018f3c5e-0000-7000-8000-000000000000",
+      runId: "018f3c5e-0000-7000-8000-000000000001",
+      occurredAt: "2026-08-26T12:00:00+00:00",
+      producerSequence: 1,
+      agent: {
+        id: "018f3c5e-0000-7000-8000-000000000002",
+        role: "orchestrator",
+        name: "main",
+      },
+      type: "run.started",
+    };
+    const artifactUpdated: AgentTraceEvent = {
+      schemaVersion: 1,
+      eventId: "018f3c5e-0000-7000-8000-000000000010",
+      runId: "018f3c5e-0000-7000-8000-000000000001",
+      occurredAt: "2026-08-26T12:00:01+00:00",
+      producerSequence: 2,
+      agent: {
+        id: "018f3c5e-0000-7000-8000-000000000002",
+        role: "orchestrator",
+        name: "main",
+      },
+      type: "artifact.updated",
+      artifact: {
+        kind: "json",
+        artifactId: "result",
+        snapshotId: "018f3c5e-0000-7000-8000-000000000003",
+        change: "partial",
+      },
+    };
+    const get = jest.fn().mockResolvedValue({
+      status: 200,
+      data: {
+        success: true,
+        id: "agent-job",
+        events: [runStarted, artifactUpdated],
+        creditsUsed: 5,
+      },
+    });
+
+    const trace = await getAgentTrace({ get } as any, "agent-job");
+
+    expect(get).toHaveBeenCalledWith("/v2/agent/agent-job/trace");
+    expect(trace.events).toHaveLength(2);
+    expect(trace.events![0].type).toBe("run.started");
+    expect(trace.events![1].type).toBe("artifact.updated");
+    if (trace.events![1].type === "artifact.updated") {
+      expect(trace.events![1].artifact.snapshotId).toBe(
+        "018f3c5e-0000-7000-8000-000000000003",
+      );
+    }
+    expect(trace.creditsUsed).toBe(5);
+  });
+
+  test("getAgentTrace appends liveView query param when requested", async () => {
+    const get = jest.fn().mockResolvedValue({
+      status: 200,
+      data: {
+        success: true,
+        id: "agent-job",
+        events: [],
+        creditsUsed: 0,
+        activeBrowserSessions: [
+          {
+            id: "sess-1",
+            liveViewUrl: "https://browser.example.com/sess-1",
+            viewport: { width: 1280, height: 720 },
+          },
+        ],
+      },
+    });
+
+    const trace = await getAgentTrace({ get } as any, "agent-job", {
+      liveView: true,
+    });
+
+    expect(get).toHaveBeenCalledWith("/v2/agent/agent-job/trace?liveView=true");
+    expect(trace.activeBrowserSessions).toHaveLength(1);
+    expect(trace.activeBrowserSessions![0].viewport.width).toBe(1280);
+  });
+
+  test("getAgentSnapshot hits the snapshot endpoint", async () => {
+    const get = jest.fn().mockResolvedValue({
+      status: 200,
+      data: {
+        success: true,
+        id: "agent-job",
+        snapshotId: "snap-1",
+        snapshot: '{"price": 42}',
+      },
+    });
+
+    const snapshot = await getAgentSnapshot({ get } as any, "agent-job", "snap-1");
+
+    expect(get).toHaveBeenCalledWith("/v2/agent/agent-job/snapshots/snap-1");
+    expect(snapshot.snapshot).toBe('{"price": 42}');
+  });
+});

package/src/__tests__/unit/v2/scrapeAutoResume.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  processingContinuesDelayMs,
+  scrape,
+} from "../../../v2/methods/scrape";
+
+const DOC = { markdown: "# big doc" };
+
+function processingContinues408(retryAfterSeconds = 10) {
+  return {
+    isAxiosError: true,
+    response: {
+      status: 408,
+      headers: { "retry-after": String(retryAfterSeconds) },
+      data: {
+        success: false,
+        code: "SCRAPE_TIMEOUT",
+        error: "Request timed out, but this 700-page PDF is still being processed on our side.",
+        details: {
+          state: "processing_continues",
+          documentPages: 700,
+          jobStatus: "running",
+          estimatedRemainingSeconds: retryAfterSeconds,
+          retryAfterSeconds,
+        },
+      },
+    },
+  };
+}
+
+describe("v2.scrape auto-resume", () => {
+  test("resumes after processing_continues and returns the finished document", async () => {
+    const post = jest
+      .fn()
+      .mockRejectedValueOnce(processingContinues408(10))
+      .mockResolvedValueOnce({ status: 200, data: { success: true, data: DOC } });
+    const sleeps: number[] = [];
+    const sleepImpl = async (ms: number) => {
+      sleeps.push(ms);
+    };
+
+    const doc = await scrape({ post } as any, "https://example.com/big.pdf", undefined, {
+      sleepImpl,
+    });
+
+    expect(doc).toEqual(DOC);
+    expect(post).toHaveBeenCalledTimes(2);
+    expect(sleeps).toEqual([10_000]);
+  });
+
+  test("autoResume: false surfaces the timeout immediately and never sleeps", async () => {
+    const post = jest.fn().mockRejectedValueOnce(processingContinues408());
+    const sleepImpl = jest.fn();
+
+    await expect(
+      scrape({ post } as any, "https://example.com/big.pdf", { autoResume: false }, {
+        sleepImpl: sleepImpl as any,
+      }),
+    ).rejects.toBeDefined();
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(sleepImpl).not.toHaveBeenCalled();
+  });
+
+  test("autoResume never enters the wire payload", async () => {
+    const post = jest
+      .fn()
+      .mockResolvedValueOnce({ status: 200, data: { success: true, data: DOC } });
+    await scrape({ post } as any, "https://example.com/x", { autoResume: true });
+    const payload = post.mock.calls[0][1];
+    expect(payload).toEqual({ url: "https://example.com/x" });
+  });
+
+  test("gives up after the attempt bound and surfaces the error", async () => {
+    const post = jest.fn().mockRejectedValue(processingContinues408(10));
+    const sleepImpl = jest.fn().mockResolvedValue(undefined);
+
+    await expect(
+      scrape({ post } as any, "https://example.com/big.pdf", undefined, {
+        sleepImpl: sleepImpl as any,
+      }),
+    ).rejects.toBeDefined();
+    // 1 initial + 5 resumes.
+    expect(post).toHaveBeenCalledTimes(6);
+    expect(sleepImpl).toHaveBeenCalledTimes(5);
+  });
+
+  test("plain timeouts without the processing signal do not resume", async () => {
+    const post = jest.fn().mockRejectedValueOnce({
+      isAxiosError: true,
+      response: {
+        status: 408,
+        headers: {},
+        data: { success: false, code: "SCRAPE_TIMEOUT", error: "Request timed out" },
+      },
+    });
+    const sleepImpl = jest.fn();
+
+    await expect(
+      scrape({ post } as any, "https://example.com/slow", undefined, {
+        sleepImpl: sleepImpl as any,
+      }),
+    ).rejects.toBeDefined();
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(sleepImpl).not.toHaveBeenCalled();
+  });
+
+  test("request timeout: opt-out keeps legacy behavior, resume adds the cushion", async () => {
+    const ok = { status: 200, data: { success: true, data: DOC } };
+    // Opt-out, no explicit timeout → no per-request override at all.
+    const post1 = jest.fn().mockResolvedValueOnce(ok);
+    await scrape({ post: post1 } as any, "https://example.com/x", { autoResume: false });
+    expect(post1.mock.calls[0][2]).toEqual({});
+    // Opt-out with explicit timeout → the pre-existing +5s.
+    const post2 = jest.fn().mockResolvedValueOnce(ok);
+    await scrape({ post: post2 } as any, "https://example.com/x", {
+      autoResume: false,
+      timeout: 10_000,
+    });
+    expect(post2.mock.calls[0][2]).toEqual({ timeoutMs: 15_000 });
+    // Resume enabled → cushion over the server wall, respecting a larger
+    // configured client default as the floor.
+    const post3 = jest.fn().mockResolvedValueOnce(ok);
+    await scrape(
+      { post: post3, getTimeoutMs: () => 600_000 } as any,
+      "https://example.com/x",
+    );
+    expect(post3.mock.calls[0][2]).toEqual({ timeoutMs: 630_000 });
+    // Resume enabled, no client getter → server wall default + cushion.
+    const post4 = jest.fn().mockResolvedValueOnce(ok);
+    await scrape({ post: post4 } as any, "https://example.com/x", { timeout: 900_000 });
+    expect(post4.mock.calls[0][2]).toEqual({ timeoutMs: 930_000 });
+  });
+
+  test("processingContinuesDelayMs clamps and falls back sensibly", () => {
+    expect(processingContinuesDelayMs(processingContinues408(1))).toBe(5_000);
+    expect(processingContinuesDelayMs(processingContinues408(3_600))).toBe(600_000);
+    // No payload field → Retry-After header.
+    const headerOnly = processingContinues408(0);
+    delete (headerOnly.response.data.details as any).retryAfterSeconds;
+    headerOnly.response.headers["retry-after"] = "90";
+    expect(processingContinuesDelayMs(headerOnly)).toBe(90_000);
+    expect(processingContinuesDelayMs(new Error("net"))).toBeUndefined();
+    expect(processingContinuesDelayMs(undefined)).toBeUndefined();
+  });
+});

package/src/v1/index.ts

@@ -181,6 +181,7 @@ export interface ScrapeParams<LLMSchema extends zt.ZodSchema = any, ActionsSchem
     prompt?: string;
     schema?: LLMSchema;
     systemPrompt?: string;
+    checkPromptInjection?: boolean;
   }
   changeTrackingOptions?: {
     prompt?: string;

package/src/v2/client.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from "./utils/httpClient";
 import {
-  scrape,
+  scrape, type ScrapeCallOptions,
   interact as interactMethod,
   stopInteraction as stopInteractionMethod,
 } from "./methods/scrape";
@@ -26,7 +26,7 @@ import {
   batchScrape as batchWaiter,
 } from "./methods/batch";
 import { startExtract, getExtractStatus, extract as extractWaiter } from "./methods/extract";
-import { startAgent, getAgentStatus, cancelAgent, agent as agentWaiter } from "./methods/agent";
+import { startAgent, getAgentStatus, getAgentTrace, getAgentSnapshot, cancelAgent, agent as agentWaiter } from "./methods/agent";
 import {
   browser as browserMethod,
   browserExecute,
@@ -68,6 +68,8 @@ import type {
   ExtractResponse,
   AgentResponse,
   AgentStatusResponse,
+  AgentTraceResponse,
+  AgentSnapshotResponse,
   CrawlOptions,
   BatchScrapeOptions,
   PaginationConfig,
@@ -168,8 +170,8 @@ export class FirecrawlClient {
     url: string,
     options: Opts
   ): Promise<Omit<Document, "json"> & { json?: InferredJsonFromOptions<Opts> }>;
-  async scrape(url: string, options?: ScrapeOptions): Promise<Document>;
-  async scrape(url: string, options?: ScrapeOptions): Promise<Document> {
+  async scrape(url: string, options?: ScrapeCallOptions): Promise<Document>;
+  async scrape(url: string, options?: ScrapeCallOptions): Promise<Document> {
     return scrape(this.http, url, options);
   }
   /**
@@ -535,6 +537,22 @@ export class FirecrawlClient {
   async cancelAgent(jobId: string): Promise<boolean> {
     return cancelAgent(this.http, jobId);
   }
+  /**
+   * Get the execution trace of an agent job (spark-2 runs only).
+   * @param jobId Agent job id.
+   * @param options.liveView Also include currently active browser sessions with live view URLs.
+   */
+  async getAgentTrace(jobId: string, options?: { liveView?: boolean }): Promise<AgentTraceResponse> {
+    return getAgentTrace(this.http, jobId, options);
+  }
+  /**
+   * Get the full content of an artifact snapshot referenced by a trace event.
+   * @param jobId Agent job id.
+   * @param snapshotId Snapshot id from an artifact.updated trace event.
+   */
+  async getAgentSnapshot(jobId: string, snapshotId: string): Promise<AgentSnapshotResponse> {
+    return getAgentSnapshot(this.http, jobId, snapshotId);
+  }
 
   // Browser
   /**

package/src/v2/methods/agent.ts

@@ -1,4 +1,4 @@
-import { type AgentResponse, type AgentStatusResponse, type AgentWebhookConfig, type AuditMetadata, type ThreatProtectionOptions } from "../types";
+import { type AgentEffort, type AgentResponse, type AgentSnapshotResponse, type AgentStatusResponse, type AgentTraceResponse, type AgentWebhookConfig, type AuditMetadata, type ThreatProtectionOptions } from "../types";
 import { HttpClient } from "../utils/httpClient";
 import { normalizeAxiosError, throwForBadResponse } from "../utils/errorHandler";
 import { isZodSchema, zodSchemaToJsonSchema } from "../../utils/zodSchemaToJson";
@@ -13,6 +13,7 @@ function prepareAgentPayload(args: {
   maxCredits?: number;
   strictConstrainToURLs?: boolean;
   model?: "spark-1-pro" | "spark-1-mini" | "spark-2";
+  effort?: AgentEffort;
   webhook?: string | AgentWebhookConfig;
   threatProtection?: ThreatProtectionOptions;
   auditMetadata?: AuditMetadata;
@@ -28,6 +29,7 @@ function prepareAgentPayload(args: {
   if (args.maxCredits !== null && args.maxCredits !== undefined) body.maxCredits = args.maxCredits;
   if (args.strictConstrainToURLs !== null && args.strictConstrainToURLs !== undefined) body.strictConstrainToURLs = args.strictConstrainToURLs;
   if (args.model !== null && args.model !== undefined) body.model = args.model;
+  if (args.effort !== null && args.effort !== undefined) body.effort = args.effort;
   if (args.webhook != null) body.webhook = args.webhook;
   if (args.threatProtection != null)
     body.threatProtection = args.threatProtection;
@@ -84,6 +86,37 @@ export async function agent(
   return waitAgent(http, jobId, args.pollInterval ?? 2, args.timeout);
 }
 
+export async function getAgentTrace(
+  http: HttpClient,
+  jobId: string,
+  options?: { liveView?: boolean }
+): Promise<AgentTraceResponse> {
+  try {
+    const query = options?.liveView ? "?liveView=true" : "";
+    const res = await http.get<AgentTraceResponse>(`/v2/agent/${jobId}/trace${query}`);
+    if (res.status !== 200) throwForBadResponse(res, "agent trace");
+    return res.data;
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "agent trace");
+    throw err;
+  }
+}
+
+export async function getAgentSnapshot(
+  http: HttpClient,
+  jobId: string,
+  snapshotId: string
+): Promise<AgentSnapshotResponse> {
+  try {
+    const res = await http.get<AgentSnapshotResponse>(`/v2/agent/${jobId}/snapshots/${snapshotId}`);
+    if (res.status !== 200) throwForBadResponse(res, "agent snapshot");
+    return res.data;
+  } catch (err: any) {
+    if (err?.isAxiosError) return normalizeAxiosError(err, "agent snapshot");
+    throw err;
+  }
+}
+
 export async function cancelAgent(http: HttpClient, jobId: string): Promise<boolean> {
   try {
     const res = await http.delete<{ success: boolean }>(`/v2/agent/${jobId}`);