@agent-native/core 0.108.0 → 0.109.0

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

@@ -404,7 +404,7 @@ export function matchesGongCallQuery(call: GongCall, query: string): boolean {
 
 function isExternalCall(call: GongCall): boolean {
   const scope = (call as Record<string, unknown>).scope;
-  return typeof scope !== "string" || scope === "External";
+  return typeof scope !== "string" || scope.toLowerCase() === "external";
 }
 
 function partyMatchesQuery(
@@ -437,11 +437,6 @@ function partyMatchesQuery(
   );
 }
 
-const extensivePartyCache = new Map<
-  string,
-  { name: string; emailAddress?: string; affiliation?: string }[]
->();
-
 export interface GongCallSearchResult {
   calls: Array<GongCall & { matchedQueries?: string[] }>;
   limit: number;
@@ -487,6 +482,38 @@ function addMatchedQuery(
   });
 }
 
+function normalizeExtensiveCall(value: unknown): GongCall | null {
+  if (!value || typeof value !== "object") return null;
+  const record = value as Record<string, unknown>;
+  const metadata =
+    record.metaData && typeof record.metaData === "object"
+      ? (record.metaData as Record<string, unknown>)
+      : record;
+  const id = typeof metadata.id === "string" ? metadata.id : "";
+  const started = typeof metadata.started === "string" ? metadata.started : "";
+  if (!id || !started) return null;
+  const parties = Array.isArray(record.parties)
+    ? record.parties.map((party) => {
+        const item = party as Record<string, unknown>;
+        return {
+          name: typeof item.name === "string" ? item.name : "",
+          ...(typeof item.emailAddress === "string"
+            ? { emailAddress: item.emailAddress }
+            : {}),
+          ...(typeof item.affiliation === "string"
+            ? { affiliation: item.affiliation }
+            : {}),
+        };
+      })
+    : [];
+  return {
+    ...metadata,
+    id,
+    started,
+    parties,
+  };
+}
+
 export async function searchCallsForQueries(
   queries: string[],
   days = 90,
@@ -515,75 +542,36 @@ export async function searchCallsForQueries(
   let searchedCallCount = 0;
   let cursor: string | undefined;
   do {
-    const params = new URLSearchParams({ fromDateTime });
-    if (options.toDateTime) params.set("toDateTime", options.toDateTime);
-    if (cursor) params.set("cursor", cursor);
-    const data = await apiGet<{
-      calls?: GongCall[];
+    const data = await apiPost<{
+      calls?: unknown[];
       records?: { cursor?: string; totalRecords?: number };
-    }>(`/calls?${params.toString()}`);
-    const calls = (data.calls ?? []).filter(isExternalCall);
+    }>("/calls/extensive", {
+      filter: {
+        fromDateTime,
+        ...(options.toDateTime ? { toDateTime: options.toDateTime } : {}),
+      },
+      contentSelector: { exposedFields: { parties: true } },
+      ...(cursor ? { cursor } : {}),
+    });
+    const calls = (data.calls ?? [])
+      .map(normalizeExtensiveCall)
+      .filter((call): call is GongCall => Boolean(call))
+      .filter(isExternalCall);
     searchedCallCount += calls.length;
     cursor = data.records?.cursor;
 
-    const remainingForExtensive: GongCall[] = [];
     for (const call of calls) {
-      let matched = false;
+      const parties = call.parties ?? [];
       for (const query of normalizedQueries) {
-        if (matchesGongCallQuery(call, query)) {
-          addMatchedQuery(matches, call, query, call.parties);
-          matched = true;
+        const titleMatches = matchesGongCallQuery(
+          { ...call, parties: [] },
+          query,
+        );
+        if (titleMatches || partyMatchesQuery(parties, query)) {
+          addMatchedQuery(matches, call, query, parties);
         }
       }
-      if (!matched) {
-        remainingForExtensive.push(call);
-      }
-    }
-
-    for (let i = 0; i < remainingForExtensive.length; i += 100) {
       if (!options.exhaustive && matches.size >= normalizedLimit) break;
-      const batch = remainingForExtensive.slice(i, i + 100);
-      const uncached = batch.filter(
-        (call) => !extensivePartyCache.has(call.id),
-      );
-      if (uncached.length) {
-        try {
-          const data = await apiPost<{ calls?: any[] }>(
-            "/calls/extensive",
-            {
-              filter: { callIds: uncached.map((call) => call.id) },
-              contentSelector: { exposedFields: { parties: true } },
-            },
-            `extensive-parties-batch:${uncached.map((call) => call.id).join(",")}`,
-          );
-          for (const call of data.calls ?? []) {
-            const id = call.metaData?.id;
-            if (!id) continue;
-            extensivePartyCache.set(
-              id,
-              (call.parties ?? []).map((party: any) => ({
-                name: party.name ?? "",
-                emailAddress: party.emailAddress ?? undefined,
-                affiliation: party.affiliation ?? undefined,
-              })),
-            );
-          }
-        } catch {
-          // Title matches already cover the obvious path. If extensive lookup
-          // fails, return those instead of failing the entire account search.
-        }
-      }
-
-      for (const call of batch) {
-        if (!options.exhaustive && matches.size >= normalizedLimit) break;
-        const parties = extensivePartyCache.get(call.id) ?? [];
-        if (!parties.length) continue;
-        for (const query of normalizedQueries) {
-          if (partyMatchesQuery(parties, query)) {
-            addMatchedQuery(matches, call, query, parties);
-          }
-        }
-      }
     }
   } while (cursor && (options.exhaustive || matches.size < normalizedLimit));
 

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

@@ -8,6 +8,22 @@ import {
 } from "./provider-credentials";
 
 const API_BASE = "https://api.hubapi.com";
+const HUBSPOT_SEARCH_MIN_INTERVAL_MS = 200;
+
+let hubspotSearchSchedule = Promise.resolve();
+let nextHubSpotSearchAt = 0;
+
+async function waitForHubSpotSearchSlot(): Promise<void> {
+  const scheduled = hubspotSearchSchedule.then(async () => {
+    const delay = Math.max(0, nextHubSpotSearchAt - Date.now());
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    nextHubSpotSearchAt = Date.now() + HUBSPOT_SEARCH_MIN_INTERVAL_MS;
+  });
+  hubspotSearchSchedule = scheduled.catch(() => undefined);
+  await scheduled;
+}
 
 // In-memory cache
 const cache = new Map<string, { data: unknown; ts: number }>();
@@ -89,6 +105,10 @@ async function apiPost<T>(
     return cached.data as T;
   }
 
+  if (path.endsWith("/search")) {
+    await waitForHubSpotSearchSlot();
+  }
+
   const res = await hubspotFetch(`${API_BASE}${path}`, {
     method: "POST",
     headers: {
@@ -164,6 +184,18 @@ export interface Deal {
   };
 }
 
+export interface HubSpotSearchFilter {
+  propertyName: string;
+  operator: string;
+  value?: string;
+  values?: string[];
+  highValue?: string;
+}
+
+export interface HubSpotSearchFilterGroup {
+  filters: HubSpotSearchFilter[];
+}
+
 export interface HubSpotOwner {
   id: string;
   email?: string;
@@ -398,6 +430,7 @@ async function resolveObjectProperties(
 export async function searchHubSpotObjects(options: {
   objectType: HubSpotObjectType;
   query?: string;
+  filterGroups?: HubSpotSearchFilterGroup[];
   properties?: string[];
   limit?: number;
   after?: string;
@@ -408,19 +441,23 @@ export async function searchHubSpotObjects(options: {
   properties: string[];
 }> {
   const objectType = options.objectType;
-  const limit = Math.max(1, Math.min(100, options.limit ?? 25));
+  const limit = Math.max(1, Math.min(200, options.limit ?? 25));
   const query = options.query?.trim();
+  const filterGroups = options.filterGroups?.filter(
+    (group) => group.filters.length > 0,
+  );
   const properties = await resolveObjectProperties(
     objectType,
     options.properties ?? [],
   );
 
-  if (query) {
+  if (query || filterGroups?.length) {
     const body: Record<string, unknown> = {
-      query,
       limit,
       properties,
     };
+    if (query) body.query = query;
+    if (filterGroups?.length) body.filterGroups = filterGroups;
     if (options.after) body.after = options.after;
     const data = await apiPost<HubSpotObjectListResponse>(
       `/crm/v3/objects/${objectType}/search`,

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

@@ -7,7 +7,12 @@ import { resolveAnalyticsProviderCredential } from "./provider-credentials";
 
 const NOTION_API = "https://api.notion.com/v1";
 const NOTION_VERSION = "2022-06-28";
-const CONTENT_DB_ID = "db4ae46c822443ba96e51a6a352e0fbe";
+const CONTENT_DATABASE_REQUIRED_PROPERTIES = [
+  "Topic",
+  "Status",
+  "Publish Date",
+] as const;
+const MAX_DATABASE_DISCOVERY_PAGES = 10;
 
 // Cache for Notion data (refreshed less frequently)
 const contentCalendarCache = new Map<
@@ -15,6 +20,10 @@ const contentCalendarCache = new Map<
   { entries: ContentCalendarEntry[]; ts: number }
 >();
 const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+const contentDatabaseCache = new Map<
+  string,
+  { databaseId: string; ts: number }
+>();
 
 // Page block cache
 const pageCache = new Map<string, { data: NotionPageData; ts: number }>();
@@ -116,6 +125,66 @@ function extractProp(props: any, name: string): string {
   }
 }
 
+async function resolveContentDatabaseId(
+  requestedDatabaseId?: string,
+): Promise<string> {
+  const requested = requestedDatabaseId?.trim();
+  if (requested) return requested;
+
+  const scope = credentialCacheScope("NOTION_API_KEY");
+  const cached = contentDatabaseCache.get(scope);
+  if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
+    return cached.databaseId;
+  }
+
+  const candidates: Array<{ id: string; score: number }> = [];
+  let startCursor: string | undefined;
+  for (let page = 0; page < MAX_DATABASE_DISCOVERY_PAGES; page += 1) {
+    const result = (await notionPost("/search", {
+      filter: { property: "object", value: "database" },
+      page_size: 100,
+      ...(startCursor ? { start_cursor: startCursor } : {}),
+    })) as any;
+
+    for (const database of result.results ?? []) {
+      const properties = database.properties ?? {};
+      if (
+        !CONTENT_DATABASE_REQUIRED_PROPERTIES.every(
+          (name) => name in properties,
+        )
+      ) {
+        continue;
+      }
+      const title = richTextToString(database.title ?? []).toLowerCase();
+      const titleScore = /content/.test(title) ? 2 : 0;
+      const calendarScore = /calendar/.test(title) ? 1 : 0;
+      candidates.push({ id: database.id, score: titleScore + calendarScore });
+    }
+
+    startCursor = result.next_cursor ?? undefined;
+    if (!result.has_more || !startCursor) break;
+  }
+
+  candidates.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+  const best = candidates[0];
+  if (!best) {
+    throw new Error(
+      "No accessible Notion database has the required Topic, Status, and Publish Date properties. Pass databaseId explicitly or share the content calendar database with the integration.",
+    );
+  }
+  if (candidates[1]?.score === best.score) {
+    throw new Error(
+      "Multiple Notion databases match the content calendar schema. Pass databaseId explicitly to choose one.",
+    );
+  }
+
+  contentDatabaseCache.set(scope, {
+    databaseId: best.id,
+    ts: Date.now(),
+  });
+  return best.id;
+}
+
 export interface ContentCalendarEntry {
   id: string;
   title: string;
@@ -135,8 +204,11 @@ export interface ContentCalendarEntry {
 }
 
 // Fetch all content calendar entries, paginating through results
-export async function getContentCalendar(): Promise<ContentCalendarEntry[]> {
-  const calendarCacheKey = credentialCacheScope("NOTION_API_KEY");
+export async function getContentCalendar(
+  requestedDatabaseId?: string,
+): Promise<ContentCalendarEntry[]> {
+  const databaseId = await resolveContentDatabaseId(requestedDatabaseId);
+  const calendarCacheKey = `${credentialCacheScope("NOTION_API_KEY")}:${databaseId}`;
   const cached = contentCalendarCache.get(calendarCacheKey);
   if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
     return cached.entries;
@@ -151,7 +223,7 @@ export async function getContentCalendar(): Promise<ContentCalendarEntry[]> {
     if (startCursor) body.start_cursor = startCursor;
 
     const result = (await notionPost(
-      `/databases/${CONTENT_DB_ID}/query`,
+      `/databases/${encodeURIComponent(databaseId)}/query`,
       body,
     )) as any;
 
@@ -290,10 +362,13 @@ export async function getNotionPage(pageId: string): Promise<NotionPageData> {
   return data;
 }
 
-export async function getContentCalendarSchema(): Promise<
-  { name: string; type: string }[]
-> {
-  const db = (await notionGet(`/databases/${CONTENT_DB_ID}`)) as any;
+export async function getContentCalendarSchema(
+  requestedDatabaseId?: string,
+): Promise<{ name: string; type: string }[]> {
+  const databaseId = await resolveContentDatabaseId(requestedDatabaseId);
+  const db = (await notionGet(
+    `/databases/${encodeURIComponent(databaseId)}`,
+  )) as any;
   const props = db.properties ?? {};
   return Object.entries(props).map(([name, def]: [string, any]) => ({
     name,

package/corpus/templates/analytics/server/lib/real-data-actions.ts

@@ -29,6 +29,7 @@ export const DATA_QUERY_ACTIONS = new Set([
   "match-error-issues",
   "gcloud",
   "gong-calls",
+  "gong-native-insights",
   "grafana",
   "hubspot-deals",
   "hubspot-metrics",
@@ -799,6 +800,9 @@ function actionEvidenceTextForSourceRecords(result: {
       transcripts: record.transcripts,
     });
   }
+  if (normalizedName === "gong-native-insights") {
+    return "";
+  }
   if (normalizedName === "run-code") {
     return content;
   }