@nopaque/sdk 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -91,7 +91,7 @@ function resolveConfig(opts) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.7.0" : "0.0.0-dev";
+var VERSION = true ? "0.8.0" : "0.0.0-dev";
 
 // src/userAgent.ts
 function composeUserAgent() {
@@ -232,7 +232,7 @@ async function classifyResponse(response) {
     body = null;
   }
   const bodyObj = body && typeof body === "object" ? body : {};
-  const message = typeof bodyObj.error === "string" ? bodyObj.error : `HTTP ${response.status}`;
+  const message = typeof bodyObj.error === "string" ? bodyObj.error : typeof bodyObj.message === "string" ? bodyObj.message : `HTTP ${response.status}`;
   const code = typeof bodyObj.code === "string" ? bodyObj.code : null;
   const details = bodyObj.details ?? null;
   const requestId = response.headers.get("x-request-id");
@@ -1275,6 +1275,176 @@ var SchedulerResource = class extends Resource {
   }
 };
 
+// src/resources/surveys.ts
+var TERMINAL_CAPTURE = /* @__PURE__ */ new Set(["final", "failed"]);
+var DEFAULT_NOT_FOUND_GRACE = 6e4;
+var CAPTURE_GRACE = 6e5;
+var SurveyResultsResource = class extends Resource {
+  /** Paginated list of result summaries, newest first. Transcripts are omitted. */
+  list(params = {}, requestOptions) {
+    return new Paginator({
+      fetchPage: async (p) => {
+        const { nextToken, cursor, ...rest } = p;
+        const raw = await this.transport.request(
+          "GET",
+          "/testing/survey-results",
+          {
+            // `nextToken` first: the Paginator advances by writing it, and a
+            // caller-supplied `cursor` would otherwise pin every page to page one.
+            params: { ...rest, cursor: nextToken ?? cursor },
+            requestOptions
+          }
+        );
+        return {
+          items: raw.results ?? raw.items ?? [],
+          nextToken: raw.nextCursor ?? raw.nextToken ?? null
+        };
+      },
+      params: { ...params }
+    });
+  }
+  /** One page of result summaries. */
+  async listPage(params = {}, requestOptions) {
+    const { nextToken, cursor, ...rest } = params;
+    const raw = await this.transport.request("GET", "/testing/survey-results", {
+      params: { ...rest, cursor: nextToken ?? cursor },
+      requestOptions
+    });
+    return new Page(raw.results ?? raw.items ?? [], raw.nextCursor ?? raw.nextToken ?? null);
+  }
+  /**
+   * One result with its conversation. While the test is live the capture may be
+   * `provisional` and still grow.
+   */
+  async get(runId, requestOptions) {
+    return await this.transport.request("GET", `/testing/survey-results/${runId}`, {
+      requestOptions
+    });
+  }
+};
+var SurveyConfigsResource = class extends Resource {
+  async create(body, requestOptions) {
+    return await this.transport.request("POST", "/testing/survey-test-configs", {
+      body,
+      requestOptions
+    });
+  }
+  /** Every config in the workspace. Not paginated; `mission` and `acceptance` are omitted. */
+  async list(requestOptions) {
+    const raw = await this.transport.request(
+      "GET",
+      "/testing/survey-test-configs",
+      { requestOptions }
+    );
+    return raw.configs ?? [];
+  }
+  async get(configId, requestOptions) {
+    return await this.transport.request("GET", `/testing/survey-test-configs/${configId}`, {
+      requestOptions
+    });
+  }
+  /** PATCH - only the fields passed are sent. `null` clears `description`, `tags` or `voiceId`. */
+  async update(configId, body, requestOptions) {
+    return await this.transport.request("PATCH", `/testing/survey-test-configs/${configId}`, {
+      body,
+      requestOptions
+    });
+  }
+  /** Tests already started from the config are unaffected. */
+  async delete(configId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/survey-test-configs/${configId}`, {
+      requestOptions
+    });
+  }
+};
+var SurveysResource = class extends Resource {
+  results;
+  configs;
+  constructor(transport) {
+    super(transport);
+    this.results = new SurveyResultsResource(transport);
+    this.configs = new SurveyConfigsResource(transport);
+  }
+  /**
+   * Start a survey test. Nothing runs yet: nopaque begins WAITING for a survey
+   * sent from `sender` to the returned `agentE164`, until `expiresAt`.
+   *
+   * Throws `ConflictError` (409) when the workspace has no live survey numbers,
+   * or when every one of them is already running a test against this sender -
+   * the message tells the two apart. `NotFoundError` (404) for an unknown
+   * config. A 503 means the number could not be put into service and nothing
+   * was reserved; it is safe to try again, but this method does not.
+   */
+  async start(params, requestOptions) {
+    const { configId, sender, windowSecs, expectedTurns, maxMessages } = params;
+    const body = {
+      configId,
+      endUserE164: sender,
+      ...windowSecs !== void 0 && { windowSecs },
+      ...expectedTurns !== void 0 && { expectedTurns },
+      ...maxMessages !== void 0 && { maxMessages }
+    };
+    return await this.transport.request("POST", "/testing/survey-runs", { body, requestOptions });
+  }
+  /** Stop a test before its window closes, freeing its number. */
+  async stop(runId, requestOptions) {
+    await this.transport.request("DELETE", `/testing/survey-runs/${runId}`, { requestOptions });
+  }
+  /** Every survey test holding a number, plus how many numbers are free. Not paginated. */
+  async list(requestOptions) {
+    return await this.transport.request("GET", "/testing/survey-runs", { requestOptions });
+  }
+  /**
+   * Poll `results.get(runId)` until the capture is `final` or `failed`, and
+   * return the result either way. A `failed` capture is a RESULT, not an error -
+   * inspect `capture.error`.
+   *
+   * The result row is written asynchronously after `start()`, so a 404 is
+   * treated as "not yet" for `notFoundGrace` and rethrown after that. Throws
+   * `NopaqueTimeoutError` on the deadline; the test itself is NOT stopped.
+   */
+  async waitForResult(runId, opts = {}) {
+    const notFoundGrace = opts.notFoundGrace ?? DEFAULT_NOT_FOUND_GRACE;
+    const started = Date.now();
+    let deadline = started + (opts.timeout ?? notFoundGrace);
+    let deadlineDerived = opts.timeout !== void 0;
+    let step = 0;
+    while (true) {
+      let result;
+      try {
+        result = await this.results.get(runId, opts.requestOptions);
+      } catch (err) {
+        if (!(err instanceof NotFoundError) || Date.now() - started >= notFoundGrace) throw err;
+      }
+      if (result) {
+        if (opts.onUpdate) {
+          try {
+            opts.onUpdate(result);
+          } catch {
+          }
+        }
+        if (TERMINAL_CAPTURE.has(result.capture?.status)) return result;
+        if (!deadlineDerived) {
+          deadline = result.expiresAt * 1e3 + CAPTURE_GRACE;
+          deadlineDerived = true;
+        }
+      }
+      const now = Date.now();
+      if (now >= deadline) {
+        throw new NopaqueTimeoutError(
+          `waitForResult timed out after ${now - started}ms waiting for survey result ${runId}`
+        );
+      }
+      const interval = Math.min(
+        pollIntervalCurve(step, { base: opts.pollInterval, cap: opts.intervalCap }),
+        Math.max(0, deadline - now)
+      );
+      await new Promise((r) => setTimeout(r, interval));
+      step++;
+    }
+  }
+};
+
 // src/resources/sweeps.ts
 var RUN_TERMINAL_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var SweepsResource = class extends Resource {
@@ -1507,6 +1677,7 @@ var Nopaque = class {
   digitalTesting;
   digitalTestConfigs;
   digitalCompliance;
+  surveys;
   transport;
   constructor(options = {}) {
     const config = resolveConfig(options);
@@ -1527,6 +1698,7 @@ var Nopaque = class {
     this.digitalTesting = new DigitalTestingResource(this.transport);
     this.digitalTestConfigs = new DigitalTestConfigsResource(this.transport);
     this.digitalCompliance = new DigitalComplianceResource(this.transport);
+    this.surveys = new SurveysResource(this.transport);
   }
   close() {
   }