deepline 0.3.461 → 0.3.463

package/dist/cli/{chunk-VZBCEA5S.mjs → chunk-RD6IQ2JY.mjs}

@@ -19,16 +19,14 @@ import {
 import {
   describePlayDetail,
   describePlayListItem
-} from "./chunk-EIMG75BT.mjs";
+} from "./chunk-S3A4IXBQ.mjs";
 import {
   ATOMIC_TOOL_EXECUTE_SUPPORTED_HEADER,
   COORDINATOR_INTERNAL_TOKEN_HEADER,
-  HttpClient,
   RETAINED_PIPELINE_RECEIVERS_HEADER,
   RUNTIME_ENVIRONMENT_TOKEN_HEADER,
-  SDK_API_MAJOR,
-  resolveConfig
-} from "./chunk-RY4IVOU3.mjs";
+  SDK_API_MAJOR
+} from "./chunk-I624J4H5.mjs";
 import {
   CustomerDbQueryOutcomeUnknownError
 } from "./chunk-4QF2K7TM.mjs";
@@ -881,11 +879,27 @@ function normalizePlayRuntimeSelection(value) {
     ...sandboxPlacementPolicy ? { sandboxPlacementPolicy } : {}
   };
 }
+function normalizePlayRunRuntimeSelection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  if (record.environment !== "native") {
+    return normalizePlayRuntimeSelection(value);
+  }
+  if (Object.keys(record).some(
+    (key) => key !== "environment" && key !== "sandboxPlacementPolicy"
+  )) {
+    return null;
+  }
+  const sandboxPlacementPolicy = normalizePlayRuntimeSandboxPlacementPolicy(
+    record.sandboxPlacementPolicy
+  );
+  return sandboxPlacementPolicy ? { environment: "native", sandboxPlacementPolicy } : null;
+}
 function normalizePlayRuntimeEnvironment(value) {
   return typeof value === "string" && PLAY_RUNTIME_ENVIRONMENTS.includes(value) ? value : null;
 }
 
-// src/plays/client.ts
+// src/plays/client-core.ts
 function normalizePlayRunIntegrationMode(value) {
   if (value === "live" || value === "eval_stub" || value === "fixture") {
     return value;
@@ -899,10 +913,10 @@ function resolvePlayRunIntegrationMode(request, env) {
 }
 function resolvePlayRunRuntimeSelection(request, env) {
   if (request.runtime !== void 0) {
-    const runtime = normalizePlayRuntimeSelection(request.runtime);
+    const runtime = normalizePlayRunRuntimeSelection(request.runtime);
     if (!runtime) {
       throw new DeeplineError(
-        'runtime must be { environment: "preview", namespace, backend?: "daytona" | "modal", sandboxPlacementPolicy?: "policy_name@1" } with namespace matching ^[a-z][a-z0-9-]{0,30}$.',
+        'runtime must be { environment: "preview", namespace, backend?: "daytona" | "modal", sandboxPlacementPolicy?: "policy_name@1" } with namespace matching ^[a-z][a-z0-9-]{0,30}$, or { environment: "native", sandboxPlacementPolicy: "policy_name@1" }.',
         void 0,
         "INVALID_RUNTIME_SELECTION"
       );
@@ -935,10 +949,23 @@ function resolvePlayRunRuntimeSelection(request, env) {
     }
     return void 0;
   }
+  if (configured === "native") {
+    const sandboxPlacementPolicy = normalizePlayRuntimeSandboxPlacementPolicy(
+      configuredPlacementPolicy
+    );
+    if (configuredNamespace || !sandboxPlacementPolicy) {
+      throw new DeeplineError(
+        "DEEPLINE_RUNTIME_ENVIRONMENT=native requires DEEPLINE_RUNTIME_SANDBOX_PLACEMENT_POLICY (such as modal_only@1) and no DEEPLINE_RUNTIME_NAMESPACE.",
+        void 0,
+        "INVALID_RUNTIME_ENVIRONMENT"
+      );
+    }
+    return { environment: "native", sandboxPlacementPolicy };
+  }
   const environment = normalizePlayRuntimeEnvironment(configured);
   if (!environment) {
     throw new DeeplineError(
-      `DEEPLINE_RUNTIME_ENVIRONMENT supports only explicit preview selection. Received "${configured}". Omit it to use the app-native runtime.`,
+      `DEEPLINE_RUNTIME_ENVIRONMENT must be preview or native. Received "${configured}". Omit it to use the app-native runtime.`,
       void 0,
       "INVALID_RUNTIME_ENVIRONMENT"
     );
@@ -988,7 +1015,7 @@ function resolveStartPlayRunRequest(request, env) {
   return { request: resolved, runtime };
 }
 function runtimeSelectionHeaders(runtime, env) {
-  if (!runtime) return void 0;
+  if (!runtime || runtime.environment === "native") return void 0;
   const token = env.DEEPLINE_RUNTIME_ENVIRONMENT_TOKEN?.trim();
   if (!token) {
     throw new DeeplineError(
@@ -1136,13 +1163,6 @@ var PlayClient = class {
     );
   }
 };
-function createPlayClient(options) {
-  const config = resolveConfig(options);
-  return new PlayClient(
-    new HttpClient(config),
-    config.environment ?? process.env
-  );
-}
 
 // ../product-notifications/contract.ts
 var PRODUCT_NOTIFICATION_EVENT_CATALOG = [
@@ -2447,10 +2467,12 @@ var RUNTIME_RECEIPT_OUTPUT_MAX_BYTES = 10 * 1024 * 1024;
 var RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES = 32 * 1024 * 1024;
 var RUNTIME_RECEIPT_CONTROL_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
 var RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES = 16 * 1024 * 1024;
+var RUNTIME_SHEET_START_TARGET_BODY_BYTES = 12 * 1024 * 1024;
 var RUNTIME_RECEIPT_GATEWAY_BATCH_MAX_BYTES = 12 * 1024 * 1024;
 var RUNTIME_RECEIPT_WRITER_TARGET_BATCH_BYTES = 8 * 1024 * 1024;
 var RUNNER_POST_TERMINAL_DIAGNOSTIC_MAX_BYTES = 64 * 1024;
 var JSON_SIZE_LIMIT_REACHED = Symbol("JSON_SIZE_LIMIT_REACHED");
+var OMIT_JSON_OUTPUT_VALUE = Symbol("OMIT_JSON_OUTPUT_VALUE");
 
 // ../play-runtime/docflow-node-io.ts
 var utf8Encoder = new TextEncoder();
@@ -3068,7 +3090,7 @@ async function* watchRunEvents(options) {
   }
 }
 
-// src/client.ts
+// src/client-core.ts
 function invalidToolDiscoveryResponse() {
   return new DeeplineError(
     "The server returned an invalid tool discovery response.",
@@ -3390,48 +3412,48 @@ var DeeplineClient = class _DeeplineClient {
    * @param options - Optional overrides for API key, base URL, timeout, and retries.
    * @throws {@link ConfigError} if no API key can be resolved from any source.
    */
-  constructor(options) {
-    this.config = resolveConfig(options);
+  constructor(config, http, explicitTimeout) {
+    this.config = config;
     this.environment = this.config.environment ?? process.env;
-    this.http = new HttpClient(this.config);
+    this.http = http;
     this.playClient = new PlayClient(this.http, this.environment);
     this.toolCalls = new ToolCalls(
       this.http,
       this.config.timeout,
-      options?.timeout
+      explicitTimeout
     );
     this.runs = {
-      getReceipts: (runId, options2) => this.getRunReceipts(runId, options2),
-      get: (runId, options2) => this.getRunStatus(runId, options2),
-      children: (parentRunId, options2) => this.getRunChildren(parentRunId, options2),
+      getReceipts: (runId, options) => this.getRunReceipts(runId, options),
+      get: (runId, options) => this.getRunStatus(runId, options),
+      children: (parentRunId, options) => this.getRunChildren(parentRunId, options),
       status: (runId) => this.getRunLifecycleStatus(runId),
-      list: (options2) => this.listRuns(options2),
-      listPage: (options2) => this.listRunsPage(options2),
-      history: (options2) => this.getRunsHistory(options2),
-      watch: (runId, options2) => this.watchRunToTerminal(runId, options2),
-      tail: (runId, options2) => this.tailRun(runId, options2),
+      list: (options) => this.listRuns(options),
+      listPage: (options) => this.listRunsPage(options),
+      history: (options) => this.getRunsHistory(options),
+      watch: (runId, options) => this.watchRunToTerminal(runId, options),
+      tail: (runId, options) => this.tailRun(runId, options),
       logs: Object.assign(
-        (runId, options2) => this.getRunLogs(runId, options2),
+        (runId, options) => this.getRunLogs(runId, options),
         {
-          query: (runId, options2) => this.queryRunLogs(runId, options2),
+          query: (runId, options) => this.queryRunLogs(runId, options),
           count: (runId, criteria) => this.countRunLogs(runId, criteria),
-          summarize: (runId, options2) => this.summarizeRunLogs(runId, options2),
-          fields: (options2) => this.getRunEventFields("logs", options2)
+          summarize: (runId, options) => this.summarizeRunLogs(runId, options),
+          fields: (options) => this.getRunEventFields("logs", options)
         }
       ),
       events: {
-        list: (options2) => this.listRunEvents(options2),
+        list: (options) => this.listRunEvents(options),
         count: (criteria) => this.countRunEvents(criteria),
-        summarize: (options2) => this.summarizeRunEvents(options2),
-        fields: (options2) => this.getRunEventFields("events", options2)
+        summarize: (options) => this.summarizeRunEvents(options),
+        fields: (options) => this.getRunEventFields("events", options)
       },
-      searchEvents: (options2) => this.searchRunEvents(options2),
+      searchEvents: (options) => this.searchRunEvents(options),
       input: (runId) => this.getRunInput(runId),
-      rerun: (runId, options2) => this.rerun(runId, options2),
+      rerun: (runId, options) => this.rerun(runId, options),
       exportDatasetRows: (input) => this.getPlaySheetRows(input),
       rowHistory: (input) => this.getPlayRunRowHistory(input),
-      stop: (runId, options2) => this.stopRun(runId, options2),
-      stopAll: ((options2) => this.stopAllRuns(options2))
+      stop: (runId, options) => this.stopRun(runId, options),
+      stopAll: ((options) => this.stopAllRuns(options))
     };
     this.db = {
       query: (input) => this.queryDb(input),
@@ -3440,98 +3462,99 @@ var DeeplineClient = class _DeeplineClient {
     this.billing = {
       quote: (input) => this.http.post("/api/v2/billing/quote", input),
       entitlements: () => this.http.get("/api/v2/billing/entitlements"),
-      topUp: (options2) => this.topUpBillingBalance(options2),
-      topUpWithReceipt: (options2) => this.topUpBillingBalanceWithReceipt(options2),
+      topUp: (options) => this.topUpBillingBalance(options),
+      topUpWithReceipt: (options) => this.topUpBillingBalanceWithReceipt(options),
       plans: () => this.getBillingPlans(),
       subscription: {
         status: () => this.getBillingSubscriptionStatus(),
-        cancel: (options2) => this.cancelBillingSubscription(options2)
+        cancel: (options) => this.cancelBillingSubscription(options)
       },
       invoices: {
-        list: (options2) => this.listBillingInvoices(options2)
+        list: (options) => this.listBillingInvoices(options)
       },
       usageEvent: (requestId) => this.getBillingUsageEvent(requestId),
-      usage: (options2) => this.getBillingUsage(options2),
+      usageEvents: (options) => this.getBillingUsageEvents(options),
+      usage: (options) => this.getBillingUsage(options),
       targetPlans: () => this.getTargetBillingPlans(),
       targetStatus: () => this.getTargetBillingStatus(),
       autoRecharge: {
         get: () => this.getTargetAutoRecharge(),
-        trigger: (options2) => this.http.post(
+        trigger: (options) => this.http.post(
           "/api/v2/billing/auto-recharge/trigger",
           {},
           {
             "Idempotency-Key": requireBillingIdempotencyKey(
-              options2?.idempotencyKey ?? globalThis.crypto.randomUUID()
+              options?.idempotencyKey ?? globalThis.crypto.randomUUID()
             )
           }
         ),
-        update: (options2) => this.updateTargetAutoRecharge(options2)
+        update: (options) => this.updateTargetAutoRecharge(options)
       },
-      purchaseCredits: (options2) => this.purchaseTargetBillingCredits(options2),
-      recoverCreditPurchase: (options2) => this.recoverTargetBillingCreditPurchase(options2),
-      transitionPlan: (options2) => this.transitionTargetBillingPlan(options2),
-      portalSession: (options2) => this.createTargetBillingPortalSession(options2)
+      purchaseCredits: (options) => this.purchaseTargetBillingCredits(options),
+      recoverCreditPurchase: (options) => this.recoverTargetBillingCreditPurchase(options),
+      transitionPlan: (options) => this.transitionTargetBillingPlan(options),
+      portalSession: (options) => this.createTargetBillingPortalSession(options)
     };
     this.workspaces = {
-      create: (options2) => this.createWorkspace(options2)
+      create: (options) => this.createWorkspace(options)
     };
     this.monitors = {
       status: () => this.getMonitorsAccess(),
-      available: (toolIdOrOptions, options2) => this.getMonitorsAvailable(toolIdOrOptions, options2),
+      available: (toolIdOrOptions, options) => this.getMonitorsAvailable(toolIdOrOptions, options),
       check: (definition) => this.checkMonitor(definition),
-      preview: (definition, options2) => this.previewMonitor(definition, options2),
-      deploy: (definition, options2) => this.deployMonitor(definition, options2),
-      sync: (definition, options2) => options2?.dryRun ? this.deployMonitor(definition, { dryRun: true }) : this.syncScalarMonitor(definition, options2),
-      list: (options2) => this.listMonitors(options2),
+      preview: (definition, options) => this.previewMonitor(definition, options),
+      deploy: (definition, options) => this.deployMonitor(definition, options),
+      sync: (definition, options) => options?.dryRun ? this.deployMonitor(definition, { dryRun: true }) : this.syncScalarMonitor(definition, options),
+      list: (options) => this.listMonitors(options),
       get: (key) => this.getMonitor(key),
-      test: (key, payload, options2) => this.testMonitorWebhook(key, payload, options2),
+      test: (key, payload, options) => this.testMonitorWebhook(key, payload, options),
       validate: (key) => this.validateMonitor(key),
       dependents: (key) => this.getMonitorDependents(key),
       update: (key, patch) => this.updateMonitor(key, patch),
-      delete: (key, options2) => this.deleteMonitor(key, options2),
-      reactivate: (key, options2) => this.reactivateMonitor(key, options2),
-      start: (key, options2) => options2?.dryRun ? this.submitMonitorBatch({
+      delete: (key, options) => this.deleteMonitor(key, options),
+      reactivate: (key, options) => this.reactivateMonitor(key, options),
+      start: (key, options) => options?.dryRun ? this.submitMonitorBatch({
         kind: "reactivate",
         scope: { kind: "keys", monitorKeys: [key] },
         dryRun: true,
-        idempotencyKey: options2.idempotencyKey ?? this.monitorJobIdempotencyKey(`start-${key}`)
-      }) : this.submitScalarMonitorLifecycle(key, "start", options2),
-      stop: (key, options2) => options2?.dryRun ? this.submitMonitorBatch({
+        idempotencyKey: options.idempotencyKey ?? this.monitorJobIdempotencyKey(`start-${key}`)
+      }) : this.submitScalarMonitorLifecycle(key, "start", options),
+      stop: (key, options) => options?.dryRun ? this.submitMonitorBatch({
         kind: "deactivate",
         scope: { kind: "keys", monitorKeys: [key] },
         dryRun: true,
-        idempotencyKey: options2.idempotencyKey ?? this.monitorJobIdempotencyKey(`stop-${key}`)
-      }) : this.submitScalarMonitorLifecycle(key, "stop", options2),
-      audit: (options2) => this.auditMonitors(options2),
-      repair: (options2) => this.repairMonitors(options2),
-      health: (options2) => this.readMonitorsHealth(options2),
+        idempotencyKey: options.idempotencyKey ?? this.monitorJobIdempotencyKey(`stop-${key}`)
+      }) : this.submitScalarMonitorLifecycle(key, "stop", options),
+      audit: (options) => this.auditMonitors(options),
+      repair: (options) => this.repairMonitors(options),
+      health: (options) => this.readMonitorsHealth(options),
       batch: {
-        deploy: (definitions, options2) => this.deployMonitorBatch(definitions, options2),
-        submit: (options2) => this.submitMonitorBatch(options2),
-        get: (operationId, options2) => this.getMonitorBatch(operationId, options2)
+        deploy: (definitions, options) => this.deployMonitorBatch(definitions, options),
+        submit: (options) => this.submitMonitorBatch(options),
+        get: (operationId, options) => this.getMonitorBatch(operationId, options)
       },
       batches: {
-        sync: (batchId, definitions, options2) => this.syncNamedMonitorBatch(batchId, definitions, options2),
-        start: (batchId, options2) => this.startNamedMonitorBatch(batchId, options2),
-        stop: (batchId, options2) => this.stopNamedMonitorBatch(batchId, options2),
+        sync: (batchId, definitions, options) => this.syncNamedMonitorBatch(batchId, definitions, options),
+        start: (batchId, options) => this.startNamedMonitorBatch(batchId, options),
+        stop: (batchId, options) => this.stopNamedMonitorBatch(batchId, options),
         get: (batchId) => this.getNamedMonitorBatch(batchId)
       },
       jobs: {
         get: (jobId) => this.getMonitorJob(jobId),
-        logs: (jobId, options2) => this.getMonitorJobLogs(jobId, options2),
+        logs: (jobId, options) => this.getMonitorJobLogs(jobId, options),
         cancel: (jobId) => this.cancelMonitorJob(jobId),
-        wait: (jobId, options2) => this.waitForMonitorJob(jobId, options2)
+        wait: (jobId, options) => this.waitForMonitorJob(jobId, options)
       },
       fleets: {
-        deploy: (definitionOrId, options2) => this.syncMonitorFleet(definitionOrId, options2),
-        sync: (definitionOrId, options2) => this.syncMonitorFleet(definitionOrId, options2),
-        get: (fleetId, options2) => fleetId === void 0 ? this.listMonitorFleets() : this.getMonitorFleet(fleetId, options2),
+        deploy: (definitionOrId, options) => this.syncMonitorFleet(definitionOrId, options),
+        sync: (definitionOrId, options) => this.syncMonitorFleet(definitionOrId, options),
+        get: (fleetId, options) => fleetId === void 0 ? this.listMonitorFleets() : this.getMonitorFleet(fleetId, options),
         list: () => this.listMonitorFleets(),
-        deactivate: (fleetId, options2) => this.deactivateMonitorFleet(fleetId, options2),
-        reactivate: (fleetId, options2) => this.reactivateMonitorFleet(fleetId, options2),
-        start: (fleetId, options2) => this.reactivateMonitorFleet(fleetId, options2),
-        stop: (fleetId, options2) => this.deactivateMonitorFleet(fleetId, options2),
-        waitForConvergence: (fleetId, options2) => this.waitForMonitorFleetConvergence(fleetId, options2)
+        deactivate: (fleetId, options) => this.deactivateMonitorFleet(fleetId, options),
+        reactivate: (fleetId, options) => this.reactivateMonitorFleet(fleetId, options),
+        start: (fleetId, options) => this.reactivateMonitorFleet(fleetId, options),
+        stop: (fleetId, options) => this.deactivateMonitorFleet(fleetId, options),
+        waitForConvergence: (fleetId, options) => this.waitForMonitorFleetConvergence(fleetId, options)
       }
     };
   }
@@ -3542,6 +3565,68 @@ var DeeplineClient = class _DeeplineClient {
   // ——————————————————————————————————————————————————————————
   // Secrets
   // ——————————————————————————————————————————————————————————
+  /** List this workspace's hosted pages, newest update first. */
+  async listPages(input) {
+    const params = new URLSearchParams();
+    if (input?.cursor) params.set("cursor", input.cursor);
+    if (input?.limit) params.set("limit", String(input.limit));
+    const query = params.size > 0 ? `?${params}` : "";
+    return await this.http.get(`/api/v2/pages${query}`);
+  }
+  /** Read one hosted page's metadata. */
+  async getPage(name) {
+    return await this.http.get(
+      `/api/v2/pages/${encodeURIComponent(name)}`
+    );
+  }
+  /** Replace a page's whole content. `public` says who the write is for. */
+  async writePage(name, input) {
+    return await this.http.put(
+      `/api/v2/pages/${encodeURIComponent(name)}`,
+      {
+        public: input.public,
+        content_base64: input.contentBase64,
+        content_type: input.contentType,
+        description: input.description
+      }
+    );
+  }
+  /** Delete a page, its content, and its links. Safe to repeat. */
+  async deletePage(name) {
+    return await this.http.delete(
+      `/api/v2/pages/${encodeURIComponent(name)}`
+    );
+  }
+  /** The explicit way to change who can see an existing page. */
+  async setPageVisibility(name, isPublic) {
+    return await this.http.post(
+      `/api/v2/pages/${encodeURIComponent(name)}/visibility`,
+      { public: isPublic }
+    );
+  }
+  /** List a page's links. Their URLs cannot be shown again. */
+  async listPageLinks(name) {
+    return await this.http.get(
+      `/api/v2/pages/${encodeURIComponent(name)}/links`
+    );
+  }
+  /** The returned URL is shown once. Either expiry or `permanent` is required. */
+  async createPageLink(name, input) {
+    return await this.http.post(
+      `/api/v2/pages/${encodeURIComponent(name)}/links`,
+      {
+        expires_in_seconds: input.expiresInSeconds,
+        permanent: input.permanent,
+        label: input.label
+      }
+    );
+  }
+  /** Stop a link working. Safe to repeat. */
+  async revokePageLink(name, linkId) {
+    return await this.http.delete(
+      `/api/v2/pages/${encodeURIComponent(name)}/links/${encodeURIComponent(linkId)}`
+    );
+  }
   /** List secret metadata visible to the current workspace. */
   async listSecrets() {
     const response = await this.http.get(
@@ -3832,8 +3917,8 @@ var DeeplineClient = class _DeeplineClient {
    *
    * These interfaces share the run contract and return a workflow or run ID:
    *
-   * - `deepline plays run`.
-   * - Repository scripts such as `bun run deepline -- plays run`.
+   * - `deepline run`.
+   * - Repository scripts such as `bun run deepline -- run`.
    * - SDK context calls such as `Deepline.connect().play(name).run()`.
    * - Direct `POST /api/v2/plays/run` calls.
    *
@@ -4093,7 +4178,7 @@ var DeeplineClient = class _DeeplineClient {
    * This method wraps {@link registerPlayArtifact} and {@link startPlayRun}.
    * Packaging wrappers use this method for file-based Plays.
    * Pass the returned ID to {@link getPlayStatus}.
-   * The method returns the same durable `{ result }` object that the CLI prints after `plays run` completes.
+   * The method returns the same durable `{ result }` object that `deepline run` saves when it completes.
    *
    * @param code - Fallback source string. Pass the bundled artifact in `options.artifact`.
    * @param csvPath - Path to the input CSV file, or `null`.
@@ -4212,7 +4297,7 @@ var DeeplineClient = class _DeeplineClient {
    * Get the current status of a play execution.
    *
    * Internal/advanced primitive. Public callers should usually prefer
-   * {@link runPlay}, {@link PlayJob.get}, or `deepline plays run`.
+   * {@link runPlay}, {@link PlayJob.get}, or `deepline run`.
    *
    * @param workflowId - Play-run id from {@link startPlayRun}
    * @returns Current status with progress logs and partial results
@@ -4986,6 +5071,9 @@ var DeeplineClient = class _DeeplineClient {
     if (input.rowMode === "all" || input.rowMode === "live") {
       params.set("rowMode", input.rowMode);
     }
+    if (input.summary === "counts") {
+      params.set("summary", "counts");
+    }
     const result = await this.http.get(
       `/api/v2/plays/${encodeURIComponent(input.playName)}/sheet?${params.toString()}`,
       { signal: input.signal }
@@ -5851,6 +5939,49 @@ var DeeplineClient = class _DeeplineClient {
     }
     return event;
   }
+  /**
+   * Read one authenticated raw usage-event page. This history is not a final
+   * charge or settlement oracle. Empty pages may still carry a continuation.
+   */
+  async getBillingUsageEvents(options = {}) {
+    const invalid = (message) => {
+      throw new DeeplineError(
+        message,
+        void 0,
+        "INVALID_USAGE_EVENTS_OPTIONS"
+      );
+    };
+    if ("offset" in options) {
+      invalid(
+        "Usage events do not support offset; use the preceding next_cursor."
+      );
+    }
+    const params = new URLSearchParams();
+    if (options.limit !== void 0) {
+      if (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 500) {
+        invalid("Usage events limit must be an integer from 1 to 500.");
+      }
+      params.set("limit", String(options.limit));
+    }
+    for (const [name, value] of [
+      ["cursor", options.cursor],
+      ["run_id", options.runId]
+    ]) {
+      if (value !== void 0) {
+        if (typeof value !== "string" || !value || value !== value.trim()) {
+          invalid(
+            `Usage events ${name} must be a non-empty string without surrounding whitespace.`
+          );
+        }
+        params.set(name, value);
+      }
+    }
+    const query = params.toString();
+    const querySuffix = query ? `?${query}` : "";
+    return this.http.get(
+      `/api/v2/usage/events${querySuffix}`
+    );
+  }
   /**
    * Read Deepline credits billed to each run and whether charges are still settling.
    * The response never shows provider spend. The dashboard runs grid uses the same read.
@@ -6767,7 +6898,7 @@ export {
   planCustomerDbQuery,
   validateExecutionIdempotencyKey,
   normalizePlayStatus,
-  createPlayClient,
+  PlayClient,
   PRODUCT_NOTIFICATION_EVENT_CATALOG,
   resolveLegacySlackNotification,
   RUN_EVENT_SEARCH_KIND_VALUES,