@sphoro/bugcatch-web-sdk 0.13.1 → 0.14.0

package/src/updates.js

@@ -297,32 +297,51 @@ export async function callAvailableForProject({ apiBase, apiKey, projectId }) {
 }
 
 /**
- * Which kind of call this project can take: 'agent', 'live', or null for none.
+ * Which kind of call this project can take: 'live', or null for none.
  *
  * The same round trip as above, answering the question that actually matters.
- * A deployment offers one or the other and never both — a sphoro.voice agent has
- * exactly one mode, and it is either a model that answers or a rendezvous that
- * rings the team. Asking only "can it call" is what drew a triage button on a
- * deployment whose agent had been switched to person-to-person: pressing it filed
- * the report and then failed the call, so the reporter got a ticket they had not
- * asked for and nobody's dashboard rang.
+ * Asking only "can it call" is what drew a call button on a deployment that did
+ * not have one: pressing it filed the report and then failed the call, so the
+ * reporter got a ticket they had not asked for and nobody's dashboard rang.
  *
- * Null for every failure, and for an older API that answers without `kind` but
- * says it is available — that deployment is on the agent, because live calling
- * did not exist before the field did.
+ * There is one kind of call now — the team's dashboards ring and a colleague
+ * picks up — so this has one non-null answer. The shape is kept because callers
+ * are written against it and because a deployment answering something else is a
+ * deployment this SDK must not place a call on.
  */
 export async function callKindForProject({ apiBase, apiKey, projectId }) {
+  const kinds = await callKindsForProject({ apiBase, apiKey, projectId });
+  return kinds.live ? 'live' : null;
+}
+
+/**
+ * Which kinds of call this project can take, as booleans.
+ *
+ * `agent` is always false and is still here because the API still sends it: it
+ * was a triage agent that answered instantly instead of a person, and it is
+ * gone. Reading it rather than dropping it keeps this honest about what the
+ * response actually said.
+ *
+ * An older API answers `available` and a bare `kind` with no `kinds` object.
+ * Anything that is not 'live' there is a kind this SDK can no longer place, so
+ * it reads as no call at all rather than as a call that would fail on connect.
+ */
+export async function callKindsForProject({ apiBase, apiKey, projectId }) {
+  const none = { agent: false, live: false };
   try {
     const res = await fetch(
       `${apiBase}/ingest/calls?projectId=${encodeURIComponent(projectId)}`,
       { headers: { 'X-BugCatch-Key': apiKey } },
     );
-    if (!res.ok) return null;
+    if (!res.ok) return none;
     const body = await res.json();
-    if (!body?.available) return null;
-    return body.kind === 'live' || body.kind === 'agent' ? body.kind : 'agent';
+    if (!body?.available) return none;
+    if (body.kinds && typeof body.kinds === 'object') {
+      return { agent: false, live: Boolean(body.kinds.live) };
+    }
+    return { agent: false, live: body.kind === 'live' };
   } catch {
-    return null;
+    return none;
   }
 }
 
@@ -369,7 +388,7 @@ export async function reportByCall({ apiBase, apiKey, token, payload }) {
 }
 
 /**
- * Whether this report can be talked through with the triage agent.
+ * Whether this report can be talked through with a person on the team.
  *
  * Asked before anything is rendered, so a button never appears on a deployment
  * with no sphoro.voice configured, on a workspace that has not switched calling
@@ -377,65 +396,6 @@ export async function reportByCall({ apiBase, apiKey, token, payload }) {
  * failure too: a call is an extra, and an extra that cannot be offered quietly
  * is better than an error about a feature nobody asked for.
  */
-export async function callAvailable({ apiBase, bugId }) {
-  const token = readToken();
-  if (!token) return false;
-
-  try {
-    const res = await fetch(
-      `${apiBase}/ingest/watch/reports/${encodeURIComponent(bugId)}/voice-call`,
-      { headers: { Authorization: `Bearer ${token}` } },
-    );
-    if (!res.ok) return false;
-    const body = await res.json();
-    return Boolean(body?.offered);
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Ask for a call, and get back the socket to hold it on.
- *
- * The response carries a URL with a short-lived credential in it and nothing
- * else — no key ever reaches this page. Which is also why the URL is passed
- * straight to the caller and never logged or stored.
- */
-export async function requestCall({ apiBase, bugId }) {
-  const token = readToken();
-  if (!token) throw new Error('[BugCatch] nothing filed from this browser yet.');
-
-  const res = await fetch(
-    `${apiBase}/ingest/watch/reports/${encodeURIComponent(bugId)}/voice-call`,
-    { method: 'POST', headers: { Authorization: `Bearer ${token}` } },
-  );
-
-  if (res.status === 401) {
-    clearToken();
-    throw new Error('[BugCatch] this browser can no longer prove it filed that report.');
-  }
-  if (!res.ok) {
-    // The API's own message is the one worth showing: "you have already talked
-    // this report through" is something the reader can act on, and a status
-    // code is not.
-    let detail = '';
-    try {
-      const problem = await res.json();
-      detail = Array.isArray(problem.message) ? problem.message.join(', ') : problem.message || '';
-    } catch { /* non-JSON error */ }
-    throw new Error(detail || `[BugCatch] the call could not be started (HTTP ${res.status}).`);
-  }
-  return res.json();
-}
-
-/**
- * Whether this report can be talked through with a *person*.
- *
- * A separate question from `callAvailable` and separately switched on, so the
- * widget cannot infer either answer from the other: a workspace may run the
- * triage agent, or a live line to its team, or both, or neither — and neither
- * is the common case.
- */
 export async function liveCallAvailable({ apiBase, bugId }) {
   const token = readToken();
   if (!token) return false;
@@ -1060,3 +1020,14 @@ async function readJoinError(res) {
   } catch { /* non-JSON error */ }
   return `Could not add you to this issue (HTTP ${res.status})`;
 }
+
+export async function verifyFix({ apiBase, bugId, ...feedback }) {
+  const token = readToken();
+  if (!token) throw new Error('This browser cannot access that report.');
+  const res = await fetch(`${apiBase}/ingest/watch/reports/${encodeURIComponent(bugId)}/verification`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }, body: JSON.stringify(feedback),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.message || 'Could not record feedback. Please refresh and try again.');
+  return data;
+}