@graph8/sdk 0.303.0 → 0.357.0

package/blocks/dialer/hooks/use-dispositions.ts

@@ -0,0 +1,29 @@
+"use client";
+
+/**
+ * useDispositions: the call outcomes this org accepts (system set plus its own custom ones).
+ *
+ * SDK operations: GET /voice/dispositions (voice.listVoiceDispositions), read tier.
+ *
+ * `disposition` on a call is an open string, so always offer the list from here rather than a hard-coded enum.
+ */
+import { g8Get } from "@/g8/lib/g8-client";
+import { useG8Query } from "@/g8/hooks/use-g8-query";
+import { dataOf, type DispositionOption } from "../lib/dialer-types";
+
+interface DispositionsResponse {
+  system?: Array<{ key: string; is_connected: boolean }>;
+  custom?: Array<{ key: string; name: string; color?: string; is_connected: boolean }>;
+}
+
+const titleCase = (key: string) => key.replace(/_/g, " ").replace(/^./, (c) => c.toUpperCase());
+
+export function useDispositions() {
+  const q = useG8Query(async (signal) => {
+    const data = dataOf<DispositionsResponse>(await g8Get("/voice/dispositions", undefined, { signal }));
+    const system = (data.system ?? []).map((d): DispositionOption => ({ key: d.key, label: titleCase(d.key), is_connected: d.is_connected, custom: false }));
+    const custom = (data.custom ?? []).map((d): DispositionOption => ({ key: d.key, label: d.name, is_connected: d.is_connected, color: d.color, custom: true }));
+    return [...system, ...custom];
+  }, []);
+  return { ...q, options: q.data ?? [] };
+}

package/blocks/dialer/lib/dialer-types.ts

@@ -0,0 +1,158 @@
+"use client";
+
+/**
+ * Shapes and helpers for the dialer components.
+ *
+ * The dialer runs in a separate voice service behind the API. Several responses are the voice service's own
+ * JSON, so read them through `dataOf()` and treat every field as optional; the types below list what the
+ * block relies on, not everything the service sends.
+ *
+ * There is NO live event stream in the API (no WebSocket or SSE for sessions or transcripts). State is read by
+ * polling: `GET /dialer/sessions/{id}/queue-stats` is the cheap 5-second poll the graph8 app itself uses as its
+ * fallback, and `GET /dialer/sessions/{id}` carries the live call list.
+ */
+
+export type DialerMode = "power" | "parallel";
+
+/** `batch_status` on queue-stats. */
+export type BatchStatus = "in_flight" | "complete_awaiting_disposition" | "complete_auto_advance_eligible";
+
+export interface QueueStats {
+  session_id: string;
+  /** DRAFT, ACTIVE, PAUSED, COMPLETED (upper or lower case, depending on the route). */
+  status: string;
+  batch_status?: BatchStatus | null;
+  current_batch_id?: string | null;
+  queue_remaining: number;
+  retry_pending?: number;
+  last_terminal_at?: string | null;
+  prewarm_ready?: boolean;
+}
+
+/** One call in the session's live state. `room_name` equals `call_id` and is what dispositions and transcripts key on. */
+export interface LiveCall {
+  call_id: string;
+  room_name?: string;
+  contact_id: string;
+  to_phone?: string;
+  /** dialing, ringing, active, hangup, failed (plus busy / no-answer after a terminal webhook). */
+  status: string;
+  started_at?: string;
+  first_name?: string | null;
+  last_name?: string | null;
+  email?: string | null;
+  title?: string | null;
+  is_voicemail?: boolean;
+  disposition?: string | null;
+}
+
+export interface SessionDetail {
+  session_id: string;
+  status: string;
+  name?: string | null;
+  from_phone?: string | null;
+  dialing_mode?: DialerMode | null;
+  parallel_count?: number | null;
+  list_id?: string | null;
+  list_title?: string | null;
+  current_batch_id?: string | null;
+  counts?: { total: number; total_dialed: number; total_undialed: number; queue_remaining: number } | null;
+  live_state?: { calls?: LiveCall[]; active_calls?: number; completed_calls?: number; voicemail_calls?: number } | null;
+}
+
+export interface QueueRow {
+  contact_id: string;
+  first_name?: string | null;
+  last_name?: string | null;
+  email?: string | null;
+  company?: string | null;
+  title?: string | null;
+  all_phones?: Array<{ field?: string; phone?: string }>;
+  is_next_to_dial?: boolean;
+  blocked_reason?: string | null;
+  callresult?: { disposition?: string | null } | null;
+}
+
+export interface NextBatchResult {
+  session_id: string;
+  current_batch_id: string;
+  conference_name: string;
+  twilio_token?: string;
+  queue_remaining: number;
+  queue_exhausted?: boolean;
+  all_dials_failed?: boolean;
+  error_message?: string | null;
+  batch?: LiveCall[];
+}
+
+export interface DispositionOption {
+  key: string;
+  label: string;
+  is_connected: boolean;
+  color?: string;
+  custom: boolean;
+}
+
+export interface CallSummary {
+  room_name: string;
+  contact_id?: string | null;
+  disposition?: string | null;
+  call_duration?: number | null;
+  created_at?: string | null;
+  from_?: string | null;
+  to?: string | null;
+  has_transcript?: boolean;
+  recording_url?: string | null;
+  summary?: string | null;
+}
+
+export interface TranscriptSegment {
+  speaker?: string | null;
+  content?: string | null;
+  timestamp?: string | null;
+}
+
+export interface DialerNumber {
+  phone_number?: string;
+  number?: string;
+  friendly_name?: string | null;
+  calls_today?: number;
+  daily_limit?: number | null;
+}
+
+/** The `data` member of an envelope, or the object itself when the endpoint returns it bare. */
+export function dataOf<T>(env: unknown): T {
+  const e = env as { data?: unknown } | null;
+  return (e && typeof e === "object" && "data" in e && e.data != null ? e.data : env) as T;
+}
+
+export function contactName(c: { first_name?: string | null; last_name?: string | null; email?: string | null; to_phone?: string }): string {
+  return [c.first_name, c.last_name].filter(Boolean).join(" ") || c.email || c.to_phone || "Unknown contact";
+}
+
+export function normalizeStatus(status: string | null | undefined): string {
+  return String(status ?? "").toLowerCase();
+}
+
+/** A call that is still ringing or connected (a hang-up makes sense). */
+export function isLiveCall(call: Pick<LiveCall, "status">): boolean {
+  return ["dialing", "ringing", "active", "in-progress", "answered"].includes(normalizeStatus(call.status));
+}
+
+/** A call that finished and has no outcome recorded yet. */
+export function needsDisposition(call: LiveCall): boolean {
+  return ["hangup", "completed"].includes(normalizeStatus(call.status)) && !call.disposition && !call.is_voicemail;
+}
+
+export function isSessionOver(status: string | null | undefined): boolean {
+  return ["completed", "stopped", "cancelled"].includes(normalizeStatus(status));
+}
+
+export function formatDuration(seconds: number | null | undefined): string {
+  if (!seconds || seconds < 0) return "0:00";
+  return `${Math.floor(seconds / 60)}:${String(Math.floor(seconds % 60)).padStart(2, "0")}`;
+}
+
+export function firstPhone(row: QueueRow): string {
+  return row.all_phones?.find((p) => p.phone)?.phone ?? "";
+}

package/blocks/dialer/lib/softphone-transport.ts

@@ -0,0 +1,67 @@
+"use client";
+
+/**
+ * The seam between the Softphone component and a browser voice client.
+ *
+ * graph8's dialer places calls from the server (the voice service dials your prospects into a conference);
+ * the rep's browser only has to JOIN that conference with audio. The API gives you a short-lived softphone
+ * credential (`GET /dialer/sessions/token`) and the conference name (`POST /dialer/sessions/{id}/next-batch`),
+ * but it has no live event stream and ships no audio client. So the audio client is yours to choose, behind
+ * this interface. `twilio-transport.ts` implements it with `@twilio/voice-sdk` (an optional peer: install it
+ * only if you use that adapter). Write your own adapter for another vendor and pass it as `transport`.
+ */
+
+export interface SoftphoneCredentials {
+  token: string;
+  /** The identity the credential was minted for. */
+  identity?: string;
+}
+
+export type SoftphoneEvent =
+  | { type: "registered" }
+  | { type: "unregistered" }
+  | { type: "incoming" }
+  | { type: "connected" }
+  | { type: "disconnected" }
+  | { type: "muted"; muted: boolean }
+  | { type: "token-expiring" }
+  | { type: "error"; message: string };
+
+export interface SoftphoneTransport {
+  /** Create the client and register it with the credential. Resolves once the rep can receive audio. */
+  connect(credentials: SoftphoneCredentials): Promise<void>;
+  /** Join a dialer conference (the `conference_name` from next-batch). Optional: a transport may auto-answer instead. */
+  joinConference?(conferenceName: string, options?: { callId?: string; muted?: boolean }): Promise<void>;
+  /** Answer an incoming leg. */
+  accept?(): void;
+  mute(muted: boolean): void;
+  /** Leave the current call but keep the client registered. */
+  hangup(): void;
+  /** Tear everything down. */
+  disconnect(): Promise<void> | void;
+  /** Swap in a fresh credential before the old one expires. */
+  updateToken?(token: string): void;
+  /** Listen to client events. Returns an unsubscribe function. */
+  subscribe(listener: (event: SoftphoneEvent) => void): () => void;
+}
+
+/** A transport that does nothing; useful for a read-only preview and in tests. */
+export function createNoopTransport(): SoftphoneTransport {
+  const listeners = new Set<(event: SoftphoneEvent) => void>();
+  const emit = (event: SoftphoneEvent) => listeners.forEach((l) => l(event));
+  return {
+    async connect() {
+      emit({ type: "registered" });
+    },
+    async joinConference() {
+      emit({ type: "connected" });
+    },
+    mute: (muted) => emit({ type: "muted", muted }),
+    hangup: () => emit({ type: "disconnected" }),
+    disconnect: () => emit({ type: "unregistered" }),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}

package/blocks/dialer/lib/twilio-transport.ts

@@ -0,0 +1,74 @@
+"use client";
+
+/**
+ * Twilio adapter for the Softphone: implements SoftphoneTransport with `@twilio/voice-sdk`.
+ *
+ * Needs the optional peer `npm i @twilio/voice-sdk`. graph8's dialer runs on Twilio conferences: the voice
+ * service dials prospects into a conference and the rep's browser joins it through `device.connect` with the
+ * parameters below. The Device is created once and reused for every batch.
+ *
+ * Usage: `<Softphone transport={createTwilioTransport()} ... />` (create it once, outside render, or in useMemo).
+ */
+import { Call, Device } from "@twilio/voice-sdk";
+import type { SoftphoneCredentials, SoftphoneEvent, SoftphoneTransport } from "./softphone-transport";
+
+export function createTwilioTransport(): SoftphoneTransport {
+  let device: Device | null = null;
+  let call: Call | null = null;
+  const listeners = new Set<(event: SoftphoneEvent) => void>();
+  const emit = (event: SoftphoneEvent) => listeners.forEach((l) => l(event));
+
+  const watch = (c: Call) => {
+    call = c;
+    c.on("accept", () => emit({ type: "connected" }));
+    c.on("disconnect", () => {
+      call = null;
+      emit({ type: "disconnected" });
+    });
+    c.on("cancel", () => {
+      call = null;
+      emit({ type: "disconnected" });
+    });
+    c.on("mute", (muted: boolean) => emit({ type: "muted", muted }));
+    c.on("error", (e: { message?: string }) => emit({ type: "error", message: e?.message ?? "Call error" }));
+  };
+
+  return {
+    async connect({ token }: SoftphoneCredentials) {
+      await device?.destroy();
+      const next = new Device(token, { codecPreferences: [Call.Codec.Opus, Call.Codec.PCMU] });
+      device = next;
+      next.on("registered", () => emit({ type: "registered" }));
+      next.on("unregistered", () => emit({ type: "unregistered" }));
+      next.on("tokenWillExpire", () => emit({ type: "token-expiring" }));
+      next.on("error", (e: { message?: string }) => emit({ type: "error", message: e?.message ?? "Device error" }));
+      next.on("incoming", (incoming: Call) => {
+        emit({ type: "incoming" });
+        watch(incoming);
+        incoming.accept();
+      });
+      await next.register();
+    },
+    async joinConference(conferenceName, options) {
+      if (!device) throw new Error("Softphone is not connected");
+      const joined = await device.connect({
+        params: { conference_name: conferenceName, call_id: options?.callId ?? "", muted: options?.muted ? "true" : "false" },
+      });
+      watch(joined);
+    },
+    accept: () => call?.accept(),
+    mute: (muted) => call?.mute(muted),
+    hangup: () => call?.disconnect(),
+    async disconnect() {
+      call?.disconnect();
+      await device?.destroy();
+      device = null;
+      call = null;
+    },
+    updateToken: (token) => device?.updateToken(token),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}

package/blocks/dialer/recipes/01-create-session-and-dial.ts

@@ -0,0 +1,39 @@
+/**
+ * @title Create a dialing session, dial one batch, and poll it
+ * @when An agent running a calling block for a rep. Creating the DRAFT is safe (dials nobody). `next-batch` CALLS
+ * REAL PEOPLE and reserves credits: have a human approve before step 2. The API has no event stream, so progress
+ * is read by polling queue-stats (every 5 seconds is what the graph8 app does).
+ */
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+
+const listId = process.argv[2];
+const repUserId = process.argv[3]; // an organisation key has no user of its own: name the rep these calls belong to
+if (!listId || !repUserId) throw new Error("usage: tsx 01-create-session-and-dial.ts <list id> <rep user id>");
+
+// 1. WRITE, dials nobody. Voice reuses a live session for the same list rather than making a second one.
+const draft = (await g8.api.dialer.createSessionDraft({
+  body: { user_id: repUserId, list_id: listId, dialing_mode: "power", parallel_count: 1, name: "Outbound calls" },
+})) as { data?: { session_id?: string } };
+const sessionId = draft.data?.session_id;
+if (!sessionId) throw new Error("graph8 returned no session id");
+
+// 2. EXTERNAL: dials the next contact(s). `previous_batch_id` is null for the first batch, then the
+//    `current_batch_id` from queue-stats (it makes a retried request idempotent).
+const batch = (await g8.api.dialer.dialNextBatch({
+  path: { session_id: sessionId },
+  body: { previous_batch_id: null, dialing_mode: "power", parallel_count: 1 },
+})) as { data?: { conference_name?: string; queue_remaining?: number; all_dials_failed?: boolean; error_message?: string } };
+if (batch.data?.all_dials_failed) throw new Error(batch.data.error_message ?? "Every call failed; the session was paused");
+console.log("conference", batch.data?.conference_name, "left in queue", batch.data?.queue_remaining);
+
+// 3. Poll until the batch finishes. batch_status: in_flight | complete_awaiting_disposition | complete_auto_advance_eligible.
+for (let i = 0; i < 60; i++) {
+  const stats = (await g8.api.dialer.readQueueStats({ path: { session_id: sessionId } })) as {
+    data?: { status?: string; batch_status?: string | null };
+  };
+  console.log(stats.data?.status, stats.data?.batch_status);
+  if (stats.data?.batch_status !== "in_flight") break;
+  await new Promise((r) => setTimeout(r, 5000));
+}

package/blocks/dialer/recipes/02-disposition-calls.ts

@@ -0,0 +1,26 @@
+/**
+ * @title Record outcomes for a session's finished calls
+ * @when After a batch completes (batch_status "complete_awaiting_disposition"). Dispositions are an open string:
+ * read the org's accepted list first (system set plus custom). Tier `write`: it contacts nobody.
+ */
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+
+const sessionId = process.argv[2];
+if (!sessionId) throw new Error("usage: tsx 02-disposition-calls.ts <session id>");
+
+const accepted = await g8.api.voice.listVoiceDispositions();
+const keys = new Set([...(accepted.data.system ?? []), ...(accepted.data.custom ?? [])].map((d) => d.key));
+console.log("accepted dispositions:", [...keys].join(", "));
+
+const calls = await g8.api.voice.listCallsForContact({ query: { parallel_session_id: sessionId, limit: 100 } });
+for (const call of calls.data.calls ?? []) {
+  if (call.disposition) continue;
+  // Decide from the facts you have; here a very short call is treated as no answer. Never invent an outcome for a
+  // call you cannot judge: leave it for the rep.
+  const guess = (call.call_duration ?? 0) < 8 && keys.has("no_answer") ? "no_answer" : null;
+  if (!guess) continue;
+  await g8.api.dialer.setCallDisposition({ path: { livekit_room_name: call.room_name }, body: { disposition: guess } });
+  console.log(call.room_name, "->", guess);
+}

package/blocks/dialer/recipes/03-review-a-call.ts

@@ -0,0 +1,23 @@
+/**
+ * @title Pull a call's transcript, AI grade, and the rep's recent performance
+ * @when Coaching or QA. All read-only. `room_name` is the call id. Grading returns "pending" until computed and
+ * the transcript has status "empty" until it is flushed; retry later instead of treating either as an error.
+ */
+import { g8 } from "@graph8/sdk";
+
+g8.init({ apiKey: process.env.G8_API_KEY! });
+
+const roomName = process.argv[2];
+const repEmail = process.argv[3];
+if (!roomName) throw new Error("usage: tsx 03-review-a-call.ts <room name> [rep email]");
+
+const transcript = await g8.api.voice.getCallTranscript({ path: { room_name: roomName } });
+console.log(transcript.data.status, transcript.data.summary);
+for (const s of transcript.data.transcript ?? []) console.log(`${s.speaker}: ${s.content}`);
+
+const grading = await g8.api.voice.getCallGrading({ path: { room_name: roomName } });
+console.log("grading", JSON.stringify(grading.data));
+
+// Team or personal numbers for the period (defaults to today); a manager passes sdr_email.
+const performance = await g8.api.dialerAnalytics.getDialerPerformance({ query: repEmail ? { sdr_email: repEmail } : {} });
+console.log("performance", JSON.stringify(performance.data));

package/blocks/enrichment/README.md

@@ -0,0 +1,105 @@
+# enrichment
+
+Fill in what you do not know about your contacts: look up one person or company, verify an email, enrich many
+contacts of a list in one job, and manage the provider pipelines behind it. Builds on `crm`.
+
+Install: `npx @graph8/sdk add enrichment` (installs `foundation`, `crm` and `lists` first).
+
+## What you get
+
+| Component | Use it for | Props |
+|---|---|---|
+| `EnrichButton` | Look up one person/company; optionally apply the found fields to the record | `kind`, `lookup`, `record`, `onResult`, `onApplied` |
+| `EmailVerifyBadge` | Status chip (Unverified / Valid / Risky / Invalid) with a Verify action | `email`, `initialStatus`, `onVerified`, `readOnly` |
+| `BulkEnrichPanel` | Fill work email / phones for many contacts of a list: preflight, estimate, job, progress | `listId`, `contactIds`, `defaultProviders`, `onDone` |
+| `WaterfallConfig` | Saved pipelines of a list and a form to create one | `listId`, `onChanged` |
+
+`BulkEnrichPanel` with no props is a complete page (choose a list, tick contacts, enrich), so it can be mounted as a
+route as is; give it `listId` and `contactIds` to embed it. For that reason this block depends on `lists`.
+
+Hook `useProviders()`; helpers in `lib/enrichment-types.ts` (`estimateCredits`, `isJobTerminal`, the price constants).
+
+## Cost, in plain numbers (all billable steps are confirmed)
+
+| Action | Cost | Confirmed with |
+|---|---|---|
+| Person or company lookup | 2 credits, **only if a match is found** (a miss is free) | `ConfirmSpendDialog` (billable) showing 2 credits |
+| Email verification | 1 credit | `ConfirmSpendDialog` (billable) |
+| Bulk enrichment | quoted by the preflight (`max_total_credits`, the most it can charge); flat 2 credits per record when the preflight cannot price it. Providers on your own key cost 0 | `ConfirmSpendDialog` (billable) with that estimate |
+| Create a waterfall pipeline | creating does not run it; running spends per the providers used | `ConfirmSpendDialog` |
+
+There is **no balance read** in the API. Every number shown is an estimate of what a run can cost, never a check that
+you can afford it; an under-funded run fails with 402.
+
+## The flow, with the ids that pass between steps
+
+1. Contacts must be on a list: `list_id` (from the `lists` block) and `contact_ids` (from a `ContactTable` selection).
+   Masked search results have no ids and cannot be enriched: save them to a list first (`search` block).
+2. `POST /enrichment/preflight { list_id, contact_ids, mode: "waterfall", providers, target_field }` (free) ->
+   `contact_count`, `not_in_list`, `missing_credentials`, `warnings`, `credits_per_record`, `max_total_credits`.
+3. The person confirms the estimate. `POST /enrichment/enrich { contact_ids, list_id, fields_config: { work_email: [providers] } }`
+   -> 202 `{ job_id }`.
+4. Poll `GET /enrichment/jobs/{job_id}` (`useJobPoll`, backoff; there is no stream and no completion webhook) until
+   `status` is `completed`, `failed` or `cancelled`. It reports `completed/total`, `successful_enrichments`, `failed_enrichments`,
+   `total_credits_used`. If nothing was enriched, `?include_provider_errors=true` explains why (usually a missing provider key).
+5. `POST /enrichment/jobs/{job_id}/cancel` stops a running job; records already done keep their data and charge.
+
+```tsx
+"use client";
+import { BulkEnrichPanel } from "@/components/g8/enrichment/bulk-enrich-panel";
+import { ContactTable } from "@/components/g8/crm/contact-table";
+
+export function EnrichList({ listId }: { listId: number }) {
+  return (
+    <ContactTable listId={listId} selectable
+      renderBulkActions={({ ids }) => <span className="w-[28rem]"><BulkEnrichPanel listId={listId} contactIds={ids} /></span>} />
+  );
+}
+```
+
+(`add` flattens `components/` into `components/g8/enrichment/`; adjust the alias to your app.)
+
+Single record: `<EnrichButton kind="person" lookup={{ email: contact.work_email }} record={contact} />` inside
+`ContactDetail renderActions`. A locked (`"***"`) email is never sent to the API.
+
+## Prerequisites (a human must do these)
+
+- `provider-keys` (api): providers that graph8 does not fund need the workspace's own key, saved in graph8 settings
+  (no API for it). The preflight reports `missing_credentials`; those steps are skipped.
+- `credits` (api): the workspace needs credits for graph8-funded providers.
+- `proxy-allowlist` (app): `allowedPrefixes` includes `enrichment` (and `contacts`, `companies` for Apply).
+- `crm-installed` (app).
+
+## Defaults the agent can use without asking
+
+| Decision | Default |
+|---|---|
+| Providers a bulk run tries | `prospeo`, `dropcontact` (the API default), kept to those in the catalog |
+| Field to fill | work email |
+| Apply a lookup to the record | never automatically; the person ticks fields |
+
+Ask the person: who may spend credits (decide it in the proxy's `authorize`).
+
+## Recipes
+
+| File | Does |
+|---|---|
+| `recipes/lookup-and-verify.ts` | One person/company lookup and an email check |
+| `recipes/bulk-enrich-and-poll.ts` | Preflight quote, start, poll with backoff, read provider errors |
+| `recipes/waterfall-pipeline.ts` | Provider readiness, create and list pipelines |
+
+## Operations
+
+| Operation | Method and path | Tier | Used by |
+|---|---|---|---|
+| lookupPerson / lookupCompany | POST /enrichment/lookup/person, /company | billable | EnrichButton |
+| verifyEmail | POST /enrichment/verify-email | billable | EmailVerifyBadge |
+| preflightEnrichment | POST /enrichment/preflight | read | BulkEnrichPanel |
+| startEnrichment | POST /enrichment/enrich | billable | BulkEnrichPanel |
+| getEnrichmentJob | GET /enrichment/jobs/{job_id} | read | BulkEnrichPanel |
+| cancelEnrichmentJob | POST /enrichment/jobs/{job_id}/cancel | write | BulkEnrichPanel |
+| listEnrichmentProviders | GET /enrichment/providers | read | BulkEnrichPanel, WaterfallConfig |
+| listWaterfallConfigs | GET /enrichment/waterfall/configs | read | WaterfallConfig |
+| createDefaultWaterfallConfig | POST /enrichment/waterfall/configs | billable | WaterfallConfig |
+| deleteWaterfallConfig | DELETE /enrichment/waterfall/configs/{column_id} | destructive | WaterfallConfig |
+| updateContact / updateCompany | PATCH /contacts/{id}, /companies/{id} | write | EnrichButton (Apply) |