@agent-native/core 0.145.4 → 0.145.6

package/corpus/templates/analytics/server/lib/dashboard-folders-store.ts

@@ -0,0 +1,168 @@
+import { recordChange } from "@agent-native/core/server";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { desc, eq } from "drizzle-orm";
+
+import { getDb, schema } from "../db/index.js";
+import { type DashboardRecord, getDashboard } from "./dashboards-store.js";
+
+export type DashboardFolderScope = "personal" | "shared";
+
+export interface DashboardFolderContext {
+  email: string;
+  orgId: string | null;
+}
+
+export interface DashboardFolderRecord {
+  id: string;
+  name: string;
+  scope: DashboardFolderScope;
+  ownerEmail: string;
+  orgId: string | null;
+  visibility: "private" | "org" | "public";
+  createdAt: string;
+  updatedAt: string;
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function toFolder(row: any): DashboardFolderRecord {
+  return {
+    id: row.id,
+    name: row.name,
+    scope: row.scope,
+    ownerEmail: row.ownerEmail,
+    orgId: row.orgId ?? null,
+    visibility: row.visibility,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export async function listDashboardFolders(
+  ctx: DashboardFolderContext,
+): Promise<DashboardFolderRecord[]> {
+  const rows = await (getDb() as any)
+    .select()
+    .from(schema.dashboardFolders)
+    .where(
+      accessFilter(schema.dashboardFolders, schema.dashboardFolderShares, {
+        userEmail: ctx.email,
+        orgId: ctx.orgId ?? undefined,
+      }),
+    )
+    .orderBy(desc(schema.dashboardFolders.updatedAt));
+  return rows.map(toFolder);
+}
+
+export async function createDashboardFolder(
+  name: string,
+  scope: DashboardFolderScope,
+  ctx: DashboardFolderContext,
+): Promise<DashboardFolderRecord> {
+  const trimmedName = name.trim();
+  if (!trimmedName) throw new Error("folder name is required");
+  if (scope === "shared" && !ctx.orgId) {
+    throw new Error("an active organization is required for shared folders");
+  }
+  const id = crypto.randomUUID();
+  const now = nowIso();
+  const folderOrgId = scope === "shared" ? ctx.orgId : null;
+  await (getDb() as any).insert(schema.dashboardFolders).values({
+    id,
+    name: trimmedName,
+    scope,
+    createdAt: now,
+    updatedAt: now,
+    ownerEmail: ctx.email,
+    orgId: folderOrgId,
+    visibility: scope === "shared" ? "org" : "private",
+  });
+  recordChange({
+    source: "dashboard-folders",
+    type: "change",
+    key: id,
+    ...(scope === "shared" && ctx.orgId
+      ? { orgId: ctx.orgId }
+      : { owner: ctx.email }),
+  });
+  return {
+    id,
+    name: trimmedName,
+    scope,
+    ownerEmail: ctx.email,
+    orgId: folderOrgId,
+    visibility: scope === "shared" ? "org" : "private",
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+async function getFolder(
+  id: string,
+  ctx: DashboardFolderContext,
+): Promise<DashboardFolderRecord> {
+  await assertAccess("dashboard-folder", id, "viewer", {
+    userEmail: ctx.email,
+    orgId: ctx.orgId ?? undefined,
+  });
+  const [row] = await (getDb() as any)
+    .select()
+    .from(schema.dashboardFolders)
+    .where(eq(schema.dashboardFolders.id, id))
+    .limit(1);
+  if (!row) throw new Error("dashboard folder not found");
+  return toFolder(row);
+}
+
+export async function assignDashboardToFolder(
+  dashboardId: string,
+  folderId: string | null,
+  ctx: DashboardFolderContext,
+): Promise<DashboardRecord> {
+  const dashboard = await getDashboard(dashboardId, ctx);
+  if (!dashboard) throw new Error("dashboard not found or inaccessible");
+  await assertAccess("dashboard", dashboardId, "editor", {
+    userEmail: ctx.email,
+    orgId: ctx.orgId ?? undefined,
+  });
+
+  if (folderId) {
+    const folder = await getFolder(folderId, ctx);
+    if (folder.scope === "personal") {
+      if (
+        dashboard.visibility !== "private" ||
+        dashboard.ownerEmail.toLowerCase() !== ctx.email.toLowerCase()
+      ) {
+        throw new Error("personal folders require an owned private dashboard");
+      }
+    } else if (
+      dashboard.visibility !== "org" ||
+      !ctx.orgId ||
+      dashboard.orgId !== ctx.orgId ||
+      folder.orgId !== ctx.orgId
+    ) {
+      throw new Error("shared folders require an org-visible dashboard");
+    }
+  }
+
+  await (getDb() as any)
+    .update(schema.dashboards)
+    .set({ folderId, updatedAt: nowIso(), updatedBy: ctx.email })
+    .where(eq(schema.dashboards.id, dashboardId));
+  recordChange({
+    source: "dashboards",
+    type: "change",
+    key: dashboardId,
+    ...((dashboard.visibility === "org" && dashboard.orgId
+      ? { orgId: dashboard.orgId }
+      : { owner: dashboard.ownerEmail }) as {
+      owner?: string;
+      orgId?: string;
+    }),
+  });
+  const updated = await getDashboard(dashboardId, ctx);
+  if (!updated) throw new Error("dashboard disappeared after folder update");
+  return updated;
+}

package/corpus/templates/analytics/server/lib/dashboard-panel-query.ts

@@ -1,6 +1,9 @@
 import type { CredentialContext } from "@agent-native/core/credentials";
 import { resolveCredential } from "@agent-native/core/credentials";
-import { runDataProgram } from "@agent-native/core/data-programs";
+import {
+  getInitializedDataProgramsAppId,
+  runDataProgram,
+} from "@agent-native/core/data-programs";
 import type { MissingKeyResponse } from "@agent-native/core/server";
 
 import { getUserSegmentation, queryEvents } from "./amplitude";
@@ -12,6 +15,7 @@ import {
   runPrometheusPanel,
   serializePanelDescriptorInput,
 } from "./prometheus";
+import { ANALYTICS_APP_ID } from "./provider-credentials";
 
 export const DASHBOARD_PANEL_SOURCES = [
   "bigquery",
@@ -25,8 +29,6 @@ export const DASHBOARD_PANEL_SOURCES = [
 
 export type DashboardPanelSource = (typeof DASHBOARD_PANEL_SOURCES)[number];
 
-const ANALYTICS_DATA_PROGRAM_APP_ID = "analytics";
-
 export interface DashboardPanelQueryResult {
   rows: Record<string, unknown>[];
   schema: { name: string; type: string }[];
@@ -360,7 +362,10 @@ async function runProgramPanel(
   const descriptor = parseProgramDescriptor(raw);
   const result = await runDataProgram({
     programId: descriptor.programId,
-    appId: ANALYTICS_DATA_PROGRAM_APP_ID,
+    // Use the same app scope that registered the agent's data-program actions.
+    // Standalone template dev can derive that scope from the runtime package
+    // even when APP_NAME is not explicitly set.
+    appId: getInitializedDataProgramsAppId() ?? ANALYTICS_APP_ID,
     params: descriptor.params,
     ctx: { userEmail: ctx.userEmail, orgId: ctx.orgId ?? null },
     triggeredBy: "panel_view",

package/corpus/templates/analytics/server/lib/dashboards-store.ts

@@ -28,7 +28,7 @@ import {
   resolveAccess,
   type ShareRole,
 } from "@agent-native/core/sharing";
-import { and, desc, eq, isNotNull, isNull, sql } from "drizzle-orm";
+import { and, desc, eq, inArray, isNotNull, isNull, sql } from "drizzle-orm";
 
 import { getDb, schema } from "../db/index.js";
 
@@ -62,10 +62,12 @@ export interface DashboardSummaryRecord {
   id: string;
   kind: DashboardKind;
   name: string;
+  description: string | null;
   configName: string | null;
   catalogTemplateId: string | null;
   demoId: string | null;
   parentId: string | null;
+  folderId: string | null;
   ownerEmail: string;
   orgId: string | null;
   visibility: "private" | "org" | "public";
@@ -76,6 +78,17 @@ export interface DashboardSummaryRecord {
   hiddenBy: string | null;
 }
 
+/** Hydrated dashboard row for catalog ranking only. */
+export interface DashboardCatalogRecord {
+  id: string;
+  kind: DashboardKind;
+  title: string;
+  description: string | null;
+  config: Record<string, unknown>;
+}
+
+const MAX_CATALOG_DASHBOARD_HYDRATION = 24;
+
 export interface DashboardRevisionRecord {
   id: string;
   dashboardId: string;
@@ -281,6 +294,13 @@ function rowToDashboardRevision(row: any): DashboardRevisionRecord {
   };
 }
 
+function configDescriptionFromValue(
+  value: Record<string, unknown>,
+): string | null {
+  const description = value["description"];
+  return typeof description === "string" ? description : null;
+}
+
 function configFromSettings(data: Record<string, unknown>): {
   title: string;
   config: Record<string, unknown>;
@@ -564,6 +584,11 @@ export async function listDashboardSummaries(
     : sql<
         string | null
       >`json_extract(${schema.dashboards.config}, '$.parentId')`;
+  const description = isPostgres()
+    ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'description')`
+    : sql<
+        string | null
+      >`json_extract(${schema.dashboards.config}, '$.description')`;
   const configName = isPostgres()
     ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'name')`
     : sql<string | null>`json_extract(${schema.dashboards.config}, '$.name')`;
@@ -586,10 +611,12 @@ export async function listDashboardSummaries(
       id: schema.dashboards.id,
       kind: schema.dashboards.kind,
       name: schema.dashboards.title,
+      description,
       ...(includeCatalogMetadata
         ? { configName, catalogTemplateId, demoId }
         : {}),
       parentId,
+      folderId: schema.dashboards.folderId,
       ownerEmail: schema.dashboards.ownerEmail,
       orgId: schema.dashboards.orgId,
       visibility: schema.dashboards.visibility,
@@ -603,11 +630,13 @@ export async function listDashboardSummaries(
     .where(where);
   const out: DashboardSummaryRecord[] = rows.map((row: any) => ({
     ...row,
+    description: typeof row.description === "string" ? row.description : null,
     configName: typeof row.configName === "string" ? row.configName : null,
     catalogTemplateId:
       typeof row.catalogTemplateId === "string" ? row.catalogTemplateId : null,
     demoId: typeof row.demoId === "string" ? row.demoId : null,
     parentId: typeof row.parentId === "string" ? row.parentId : null,
+    folderId: typeof row.folderId === "string" ? row.folderId : null,
     orgId: row.orgId ?? null,
     archivedAt: row.archivedAt ?? null,
     hiddenAt: row.hiddenAt ?? null,
@@ -656,8 +685,10 @@ export async function listDashboardSummaries(
         id,
         kind,
         name: title,
+        description: configDescriptionFromValue(config),
         ...catalogMetadata,
         parentId: typeof config.parentId === "string" ? config.parentId : null,
+        folderId: null,
         ownerEmail: ctx.email,
         orgId,
         visibility,
@@ -676,6 +707,90 @@ export async function listDashboardSummaries(
   return out;
 }
 
+/**
+ * Hydrate a bounded set of dashboard ids for catalog ranking.
+ *
+ * This is the catalog-specific path: it reads only the id, kind, title,
+ * description, and config needed for ranking, and only for explicit ids that
+ * were already shortlisted from the metadata path.
+ */
+export async function loadDashboardCatalogDashboards(
+  ctx: AccessCtx,
+  ids: readonly string[],
+  dbOverride?: any,
+): Promise<DashboardCatalogRecord[]> {
+  const db = (dbOverride ?? getDb()) as any;
+  const uniqueIds = [
+    ...new Set(ids.map((id) => id.trim()).filter(Boolean)),
+  ].slice(0, MAX_CATALOG_DASHBOARD_HYDRATION);
+  if (!uniqueIds.length) return [];
+
+  const description = isPostgres()
+    ? sql<string | null>`(${schema.dashboards.config}::jsonb ->> 'description')`
+    : sql<
+        string | null
+      >`json_extract(${schema.dashboards.config}, '$.description')`;
+  const archived = isNull(schema.dashboards.archivedAt);
+  const visible = isNull(schema.dashboards.hiddenAt);
+  const where = and(
+    accessFilter(schema.dashboards, schema.dashboardShares, {
+      userEmail: ctx.email,
+      orgId: ctx.orgId ?? undefined,
+    }),
+    inArray(schema.dashboards.id, uniqueIds),
+    archived,
+    visible,
+  );
+
+  // guard:allow-heavy-dashboard-list-read - bounded explicit ids shortlisted from metadata
+  const sqlRows = await db
+    .select({
+      id: schema.dashboards.id,
+      kind: schema.dashboards.kind,
+      title: schema.dashboards.title,
+      description,
+      config: schema.dashboards.config,
+    })
+    .from(schema.dashboards)
+    .where(where);
+
+  const byId = new Map<string, DashboardCatalogRecord>(
+    sqlRows.map((row: any) => {
+      const catalogRow: DashboardCatalogRecord = {
+        id: row.id,
+        kind: row.kind,
+        title: row.title,
+        description:
+          typeof row.description === "string" ? row.description : null,
+        config:
+          typeof row.config === "string" ? JSON.parse(row.config) : row.config,
+      };
+      return [row.id, catalogRow];
+    }),
+  );
+
+  const out: DashboardCatalogRecord[] = [];
+  for (const id of uniqueIds) {
+    const row = byId.get(id);
+    if (row) {
+      out.push(row);
+      continue;
+    }
+
+    const legacy = await findLegacyDashboard(id, ctx);
+    if (!legacy) continue;
+    const { title, config } = configFromSettings(legacy.data);
+    out.push({
+      id,
+      kind: legacy.kind,
+      title,
+      description: configDescriptionFromValue(config),
+      config,
+    });
+  }
+  return out;
+}
+
 /**
  * Reject a name that would collide with another dashboard visible to the
  * caller. Archived and hidden dashboards are intentionally excluded because

package/corpus/templates/analytics/server/lib/first-party-analytics-rollups.ts

@@ -2,10 +2,7 @@ import { isPostgres } from "@agent-native/core/db";
 import { sql } from "@agent-native/core/db/schema";
 
 import { getDb, schema } from "../db/index.js";
-import {
-  FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY,
-  FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_SQL,
-} from "./analytics-rollup-lock.js";
+import { FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY } from "./analytics-rollup-lock.js";
 
 /**
  * The normalized subset emitted by first-party analytics ingest. Keeping this
@@ -151,10 +148,9 @@ export async function upsertFirstPartyAnalyticsRollups(
       // snapshot. Holding it through ingest's rollup increment prevents the
       // backfill's monotonic upsert from losing a concurrently committed
       // event.
-      await tx.execute({
-        sql: FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_SQL,
-        args: [FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY],
-      });
+      await tx.execute(
+        sql`SELECT pg_advisory_xact_lock(hashtextextended(${FIRST_PARTY_ANALYTICS_ROLLUP_LOCK_KEY}, 0::bigint))`,
+      );
     }
     const dailyRows = [...dailyRollups.values()];
     await tx

package/corpus/templates/analytics/server/lib/gong.ts

@@ -1,19 +1,14 @@
 // Gong sales call intelligence API helper
 // Fetches calls, transcripts, and users
 
-import { resolveCredential } from "./credentials";
-import {
-  requireRequestCredentialContext,
-  scopedCredentialCacheKey,
-} from "./credentials-context";
+import { scopedCredentialCacheKey } from "./credentials-context";
 import {
   DEFAULT_GONG_CALL_LIMIT,
   limitGongCalls,
   normalizeGongCallLimit,
 } from "./gong-limits";
-import { resolveAnalyticsGongCredentials } from "./provider-credentials";
+import { executeProviderApiRequest } from "./provider-api";
 
-const DEFAULT_API_BASE = "https://api.gong.io/v2";
 const MAX_GONG_SEARCH_PAGES = 50;
 const MAX_GONG_CALL_LIST_PAGES = 50;
 const MAX_GONG_EXHAUSTIVE_RECORDS = 500;
@@ -24,38 +19,101 @@ const cache = new Map<string, { data: unknown; ts: number }>();
 const CACHE_TTL_MS = 10 * 60 * 1000;
 const MAX_CACHE = 120;
 
-async function getAuthHeader(): Promise<string> {
-  const ctx = requireRequestCredentialContext("GONG_ACCESS_KEY");
-  const credentials = await resolveAnalyticsGongCredentials({ ctx });
-  if (!credentials)
-    throw new Error("GONG_ACCESS_KEY and GONG_ACCESS_SECRET not configured");
-  return `Basic ${Buffer.from(
-    `${credentials.accessKey}:${credentials.accessSecret}`,
-  ).toString("base64")}`;
-}
-
-async function getApiBase(): Promise<string> {
-  const ctx = requireRequestCredentialContext("GONG_ACCESS_KEY");
-  const configured = await resolveCredential("GONG_API_BASE", ctx);
-  return (configured || DEFAULT_API_BASE).replace(/\/+$/, "");
-}
-
 export interface GongRequestOptions {
   signal?: AbortSignal;
   deadlineAt?: number;
 }
 
-function requestSignal(options?: GongRequestOptions): AbortSignal {
-  const remainingMs = options?.deadlineAt
+function requestTimeoutMs(options?: GongRequestOptions): number {
+  return options?.deadlineAt
     ? Math.max(
         1,
         Math.min(GONG_API_REQUEST_TIMEOUT_MS, options.deadlineAt - Date.now()),
       )
     : GONG_API_REQUEST_TIMEOUT_MS;
-  const timeoutSignal = AbortSignal.timeout(remainingMs);
-  return options?.signal
-    ? AbortSignal.any([options.signal, timeoutSignal])
-    : timeoutSignal;
+}
+
+interface GongProviderResponse {
+  response: {
+    ok: boolean;
+    status: number;
+    headers?: Record<string, string>;
+    json?: unknown;
+    text?: string;
+  };
+}
+
+function splitGongPath(path: string): {
+  path: string;
+  query?: Record<string, string>;
+} {
+  const separator = path.indexOf("?");
+  if (separator < 0) return { path };
+  const query = Object.fromEntries(
+    new URLSearchParams(path.slice(separator + 1)).entries(),
+  );
+  return {
+    path: path.slice(0, separator),
+    ...(Object.keys(query).length > 0 ? { query } : {}),
+  };
+}
+
+function responseHeader(
+  headers: Record<string, string> | undefined,
+  name: string,
+): string | undefined {
+  const lowerName = name.toLowerCase();
+  return Object.entries(headers ?? {}).find(
+    ([key]) => key.toLowerCase() === lowerName,
+  )?.[1];
+}
+
+function responseDetail(response: GongProviderResponse["response"]): string {
+  if (typeof response.text === "string" && response.text.trim()) {
+    return response.text.replace(/\s+/g, " ").trim().slice(0, 2_000);
+  }
+  if (response.json !== undefined) {
+    return JSON.stringify(response.json).slice(0, 2_000);
+  }
+  return "";
+}
+
+function gongApiError(response: GongProviderResponse["response"]): Error {
+  const requestId =
+    responseHeader(response.headers, "x-request-id") ??
+    responseHeader(response.headers, "request-id");
+  const retryAfter = responseHeader(response.headers, "retry-after");
+  const metadata = [
+    requestId ? `requestId ${requestId}` : "",
+    response.status === 429 && retryAfter ? `retry-after ${retryAfter}` : "",
+  ]
+    .filter(Boolean)
+    .join(", ");
+  const detail = responseDetail(response);
+  return new Error(
+    `Gong API error ${response.status}${metadata ? ` (${metadata})` : ""}${detail ? `: ${detail}` : ""}`,
+  );
+}
+
+async function executeGongRequest<T>(options: {
+  method: "GET" | "POST";
+  path: string;
+  body?: unknown;
+  requestOptions?: GongRequestOptions;
+}): Promise<T> {
+  const request = splitGongPath(options.path);
+  const result = (await executeProviderApiRequest({
+    provider: "gong",
+    method: options.method,
+    path: request.path,
+    ...(request.query ? { query: request.query } : {}),
+    ...(options.body !== undefined ? { body: options.body } : {}),
+    timeoutMs: requestTimeoutMs(options.requestOptions),
+    signal: options.requestOptions?.signal,
+  })) as GongProviderResponse;
+
+  if (!result.response.ok) throw gongApiError(result.response);
+  return result.response.json as T;
 }
 
 async function apiGet<T>(
@@ -69,21 +127,12 @@ async function apiGet<T>(
     return cached.data as T;
   }
 
-  const res = await fetch(`${await getApiBase()}${path}`, {
-    headers: {
-      Authorization: await getAuthHeader(),
-      "Content-Type": "application/json",
-    },
-    signal: requestSignal(options),
+  const data = await executeGongRequest<T>({
+    method: "GET",
+    path,
+    requestOptions: options,
   });
 
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Gong API error ${res.status}: ${text}`);
-  }
-
-  const data = await res.json();
-
   if (cache.size >= MAX_CACHE) {
     const oldest = cache.keys().next().value;
     if (oldest) cache.delete(oldest);
@@ -108,23 +157,13 @@ async function apiPost<T>(
     return cached.data as T;
   }
 
-  const res = await fetch(`${await getApiBase()}${path}`, {
+  const data = await executeGongRequest<T>({
     method: "POST",
-    headers: {
-      Authorization: await getAuthHeader(),
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(body),
-    signal: requestSignal(options),
+    path,
+    body,
+    requestOptions: options,
   });
 
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Gong API error ${res.status}: ${text}`);
-  }
-
-  const data = await res.json();
-
   if (cache.size >= MAX_CACHE) {
     const oldest = cache.keys().next().value;
     if (oldest) cache.delete(oldest);
@@ -298,29 +337,9 @@ export async function getCall(
   return data.calls?.[0] ?? null;
 }
 
-export async function getCallDetail(
-  callId: string,
-  options?: GongRequestOptions,
-): Promise<GongCallDetail | null> {
-  const body = {
-    filter: { callIds: [callId] },
-    contentSelector: {
-      exposedFields: {
-        parties: true,
-        content: { brief: true, keyPoints: true, outline: true },
-      },
-    },
-  };
-  const data = await apiPost<{ calls?: any[] }>(
-    "/calls/extensive",
-    body,
-    `detail:${callId}`,
-    options,
-  );
-  const call = data.calls?.[0];
-  if (!call) return null;
+function normalizeCallDetail(call: any, fallbackId: string): GongCallDetail {
   return {
-    id: call.metaData?.id ?? callId,
+    id: call.metaData?.id ?? fallbackId,
     title: call.metaData?.title || "Untitled",
     url: call.metaData?.url || "",
     started: call.metaData?.started || "",
@@ -340,6 +359,48 @@ export async function getCallDetail(
   };
 }
 
+export async function getCallDetails(
+  callIds: string[],
+  options?: GongRequestOptions,
+): Promise<GongCallDetail[]> {
+  const ids = Array.from(
+    new Set(
+      callIds
+        .map((id) => (typeof id === "string" ? id.trim() : ""))
+        .filter(Boolean),
+    ),
+  );
+  if (!ids.length) return [];
+
+  const body = {
+    filter: { callIds: ids },
+    contentSelector: {
+      exposedFields: {
+        parties: true,
+        content: { brief: true, keyPoints: true, outline: true },
+      },
+    },
+  };
+  const data = await apiPost<{ calls?: any[] }>(
+    "/calls/extensive",
+    body,
+    `details:${ids.join(",")}`,
+    options,
+  );
+  return (data.calls ?? []).map((call, index) =>
+    normalizeCallDetail(call, ids[index] ?? ""),
+  );
+}
+
+export async function getCallDetail(
+  callId: string,
+  options?: GongRequestOptions,
+): Promise<GongCallDetail | null> {
+  const details = await getCallDetails([callId], options);
+  const detail = details[0];
+  return detail === undefined ? null : detail;
+}
+
 export async function getCallTranscripts(
   callIds: string[],
   options?: GongRequestOptions,