@hasna/contacts 0.6.29 → 0.6.30

package/dist/index.js

@@ -5290,6 +5290,30 @@ class ApiStore {
   constructor(client) {
     this.client = client;
   }
+  g(path, query) {
+    return this.client.transport.get(path, query ? { query } : undefined);
+  }
+  post(path, body) {
+    return this.client.transport.post(path, body);
+  }
+  patch(path, body) {
+    return this.client.transport.patch(path, body);
+  }
+  del(path, query) {
+    return this.client.transport.del(path, undefined, query ? { query } : undefined);
+  }
+  async gMaybe(path) {
+    try {
+      return await this.client.transport.get(path);
+    } catch (e) {
+      if (e && typeof e === "object" && e.status === 404)
+        return null;
+      throw e;
+    }
+  }
+  enc(id) {
+    return encodeURIComponent(String(id));
+  }
   async createContact(input) {
     const res = await this.client.create("contacts", stripUndefined(input));
     return pick(res, "contact") ?? res;
@@ -5420,74 +5444,74 @@ class ApiStore {
   async removeTagFromCompany() {
     return unavailable("removeTagFromCompany");
   }
-  async createGroup() {
-    return unavailable("createGroup");
+  async createGroup(input) {
+    return pick(await this.post("/groups", input), "group");
   }
-  async getGroup() {
-    return unavailable("getGroup");
+  async getGroup(id) {
+    return pick(await this.gMaybe(`/groups/${this.enc(id)}`), "group") ?? null;
   }
-  async listGroups() {
-    return unavailable("listGroups");
+  async listGroups(projectId) {
+    return pick(await this.g("/groups", projectId ? { project_id: projectId } : undefined), "groups") ?? [];
   }
-  async updateGroup() {
-    return unavailable("updateGroup");
+  async updateGroup(id, input) {
+    return pick(await this.patch(`/groups/${this.enc(id)}`, input), "group");
   }
-  async deleteGroup() {
-    return unavailable("deleteGroup");
+  async deleteGroup(id) {
+    await this.del(`/groups/${this.enc(id)}`);
   }
-  async addContactToGroup() {
-    return unavailable("addContactToGroup");
+  async addContactToGroup(contactId, groupId) {
+    return this.post(`/groups/${this.enc(groupId)}/contacts`, { contact_id: contactId });
   }
-  async removeContactFromGroup() {
-    return unavailable("removeContactFromGroup");
+  async removeContactFromGroup(contactId, groupId) {
+    await this.del(`/groups/${this.enc(groupId)}/contacts/${this.enc(contactId)}`);
   }
-  async listContactsInGroup() {
-    return unavailable("listContactsInGroup");
+  async listContactsInGroup(groupId) {
+    return pick(await this.g(`/groups/${this.enc(groupId)}/contacts`), "contact_ids") ?? [];
   }
-  async listGroupsForContact() {
-    return unavailable("listGroupsForContact");
+  async listGroupsForContact(contactId) {
+    return pick(await this.g(`/groups/for-contact/${this.enc(contactId)}`), "groups") ?? [];
   }
-  async addCompanyToGroup() {
-    return unavailable("addCompanyToGroup");
+  async addCompanyToGroup(companyId, groupId) {
+    return this.post(`/groups/${this.enc(groupId)}/companies`, { company_id: companyId });
   }
-  async removeCompanyFromGroup() {
-    return unavailable("removeCompanyFromGroup");
+  async removeCompanyFromGroup(companyId, groupId) {
+    await this.del(`/groups/${this.enc(groupId)}/companies/${this.enc(companyId)}`);
   }
-  async listCompaniesInGroup() {
-    return unavailable("listCompaniesInGroup");
+  async listCompaniesInGroup(groupId) {
+    return pick(await this.g(`/groups/${this.enc(groupId)}/companies`), "company_ids") ?? [];
   }
-  async listGroupsForCompany() {
-    return unavailable("listGroupsForCompany");
+  async listGroupsForCompany(companyId) {
+    return pick(await this.g(`/groups/for-company/${this.enc(companyId)}`), "groups") ?? [];
   }
-  async createRelationship() {
-    return unavailable("createRelationship");
+  async createRelationship(input) {
+    return pick(await this.post("/relationships", input), "relationship");
   }
-  async listRelationships() {
-    return unavailable("listRelationships");
+  async listRelationships(opts = {}) {
+    return pick(await this.g("/relationships", stripUndefined(opts)), "relationships") ?? [];
   }
-  async deleteRelationship() {
-    return unavailable("deleteRelationship");
+  async deleteRelationship(id) {
+    await this.del(`/relationships/${this.enc(id)}`);
   }
-  async createCompanyRelationship() {
-    return unavailable("createCompanyRelationship");
+  async createCompanyRelationship(input) {
+    return pick(await this.post("/company-relationships", input), "relationship");
   }
-  async listCompanyRelationships() {
-    return unavailable("listCompanyRelationships");
+  async listCompanyRelationships(opts = {}) {
+    return pick(await this.g("/company-relationships", stripUndefined(opts)), "relationships") ?? [];
   }
-  async deleteCompanyRelationship() {
-    return unavailable("deleteCompanyRelationship");
+  async deleteCompanyRelationship(id) {
+    await this.del(`/company-relationships/${this.enc(id)}`);
   }
-  async addNote() {
-    return unavailable("addNote");
+  async addNote(contactId, body, createdBy, companyId) {
+    return pick(await this.post("/notes", { contact_id: contactId, body, created_by: createdBy, company_id: companyId }), "note");
   }
-  async listNotes() {
-    return unavailable("listNotes");
+  async listNotes(contactId) {
+    return pick(await this.g("/notes", { contact_id: contactId }), "notes") ?? [];
   }
-  async listNotesForContactAtCompany() {
-    return unavailable("listNotesForContactAtCompany");
+  async listNotesForContactAtCompany(contactId, companyId) {
+    return pick(await this.g("/notes", { contact_id: contactId, company_id: companyId }), "notes") ?? [];
   }
-  async deleteNote() {
-    return unavailable("deleteNote");
+  async deleteNote(noteId) {
+    await this.del(`/notes/${this.enc(noteId)}`);
   }
   async listActivity() {
     return unavailable("listActivity");
@@ -5502,178 +5526,191 @@ class ApiStore {
     };
   }
   async findEmailDuplicates() {
-    return unavailable("findEmailDuplicates");
+    return pick(await this.g("/email-duplicates"), "duplicates") ?? [];
   }
   async findNameDuplicates() {
-    return unavailable("findNameDuplicates");
+    return pick(await this.g("/name-duplicates"), "duplicates") ?? [];
   }
-  async flushForBackup() {
-    return unavailable("flushForBackup");
-  }
-  async listColdContacts() {
-    return unavailable("listColdContacts");
+  async flushForBackup() {}
+  async listColdContacts(days) {
+    return pick(await this.g("/cold-contacts", { days }), "contacts") ?? [];
   }
-  async findOrCreateContact() {
-    return unavailable("findOrCreateContact");
+  async findOrCreateContact(input) {
+    const emails = (input.emails ?? []).map((e) => e.address).filter(Boolean);
+    for (const addr of emails) {
+      const c = await this.getContactByEmail(addr);
+      if (c)
+        return { contact: c, created: false };
+    }
+    const nameQuery = input.display_name ?? (input.first_name || input.last_name ? `${input.first_name ?? ""} ${input.last_name ?? ""}`.trim() : null);
+    if (nameQuery) {
+      const results = await this.searchContacts(nameQuery);
+      if (results[0])
+        return { contact: results[0], created: false };
+    }
+    return { contact: await this.createContact(input), created: true };
   }
-  async findContactsForContext() {
-    return unavailable("findContactsForContext");
+  async findContactsForContext(topic, limit) {
+    return pick(await this.g("/contacts-for-context", { topic, limit }), "contacts") ?? [];
   }
-  async listContactsNotContactedSince() {
-    return unavailable("listContactsNotContactedSince");
+  async listContactsNotContactedSince(days, limit) {
+    return pick(await this.g("/not-contacted", { days, limit }), "contacts") ?? [];
   }
-  async listFollowupDueContacts() {
-    return unavailable("listFollowupDueContacts");
+  async listFollowupDueContacts(onOrBefore) {
+    return pick(await this.g("/followup-due-contacts", { on_or_before: onOrBefore }), "contacts") ?? [];
   }
-  async logVendorCommunication() {
-    return unavailable("logVendorCommunication");
+  async logVendorCommunication(input) {
+    return pick(await this.post("/vendor-comms", input), "communication");
   }
-  async listVendorCommunications() {
-    return unavailable("listVendorCommunications");
+  async listVendorCommunications(companyId, opts = {}) {
+    return pick(await this.g("/vendor-comms", { company_id: companyId, ...stripUndefined(opts) }), "communications") ?? [];
   }
   async listMissingInvoices() {
-    return unavailable("listMissingInvoices");
+    return pick(await this.g("/vendor-comms/missing-invoices"), "communications") ?? [];
   }
   async listPendingFollowUps() {
-    return unavailable("listPendingFollowUps");
+    return pick(await this.g("/vendor-comms/pending-follow-ups"), "communications") ?? [];
   }
-  async markFollowUpDone() {
-    return unavailable("markFollowUpDone");
+  async markFollowUpDone(id) {
+    return pick(await this.post(`/vendor-comms/${this.enc(id)}/mark-done`), "communication");
   }
-  async createContactTask() {
-    return unavailable("createContactTask");
+  async createContactTask(input) {
+    return pick(await this.post("/tasks", input), "task");
   }
-  async listContactTasks() {
-    return unavailable("listContactTasks");
+  async listContactTasks(opts = {}) {
+    return pick(await this.g("/tasks", stripUndefined(opts)), "tasks") ?? [];
   }
-  async updateContactTask() {
-    return unavailable("updateContactTask");
+  async updateContactTask(id, input) {
+    return pick(await this.patch(`/tasks/${this.enc(id)}`, input), "task");
   }
-  async deleteContactTask() {
-    return unavailable("deleteContactTask");
+  async deleteContactTask(id) {
+    await this.del(`/tasks/${this.enc(id)}`);
   }
   async listOverdueTasks() {
-    return unavailable("listOverdueTasks");
+    return pick(await this.g("/tasks/overdue"), "tasks") ?? [];
   }
   async checkEscalations() {
-    return unavailable("checkEscalations");
+    return pick(await this.g("/tasks/escalations"), "escalations") ?? [];
   }
-  async createApplication() {
-    return unavailable("createApplication");
+  async createApplication(input) {
+    return pick(await this.post("/applications", input), "application");
   }
-  async listApplications() {
-    return unavailable("listApplications");
+  async listApplications(opts = {}) {
+    return pick(await this.g("/applications", stripUndefined(opts)), "applications") ?? [];
   }
-  async updateApplication() {
-    return unavailable("updateApplication");
+  async updateApplication(id, input) {
+    return pick(await this.patch(`/applications/${this.enc(id)}`, input), "application");
   }
   async listFollowUpDueApplications() {
-    return unavailable("listFollowUpDueApplications");
+    return pick(await this.g("/applications/follow-up-due"), "applications") ?? [];
   }
-  async addOrgMember() {
-    return unavailable("addOrgMember");
+  async addOrgMember(input) {
+    return pick(await this.post("/org-members", input), "org_member");
   }
-  async listOrgMembers() {
-    return unavailable("listOrgMembers");
+  async listOrgMembers(companyId) {
+    return pick(await this.g("/org-members", { company_id: companyId }), "org_members") ?? [];
   }
-  async updateOrgMember() {
-    return unavailable("updateOrgMember");
+  async updateOrgMember(id, input) {
+    return pick(await this.patch(`/org-members/${this.enc(id)}`, input), "org_member");
   }
-  async removeOrgMember() {
-    return unavailable("removeOrgMember");
+  async removeOrgMember(id) {
+    await this.del(`/org-members/${this.enc(id)}`);
   }
-  async listOrgMembersForContact() {
-    return unavailable("listOrgMembersForContact");
+  async listOrgMembersForContact(contactId) {
+    return pick(await this.g("/org-members", { contact_id: contactId }), "org_members") ?? [];
   }
-  async createDeal() {
-    return unavailable("createDeal");
+  async createDeal(input) {
+    return pick(await this.post("/deals", input), "deal");
   }
-  async getDeal() {
-    return unavailable("getDeal");
+  async getDeal(id) {
+    return pick(await this.gMaybe(`/deals/${this.enc(id)}`), "deal") ?? null;
   }
-  async listDeals() {
-    return unavailable("listDeals");
+  async listDeals(opts = {}) {
+    return pick(await this.g("/deals", stripUndefined(opts)), "deals") ?? [];
   }
-  async updateDeal() {
-    return unavailable("updateDeal");
+  async updateDeal(id, input) {
+    return pick(await this.patch(`/deals/${this.enc(id)}`, input), "deal") ?? null;
   }
-  async deleteDeal() {
-    return unavailable("deleteDeal");
+  async deleteDeal(id) {
+    await this.del(`/deals/${this.enc(id)}`);
   }
-  async logEvent() {
-    return unavailable("logEvent");
+  async logEvent(input) {
+    return pick(await this.post("/events", input), "event");
   }
-  async listEvents() {
-    return unavailable("listEvents");
+  async listEvents(opts = {}) {
+    return pick(await this.g("/events", stripUndefined(opts)), "events") ?? [];
   }
-  async deleteEvent() {
-    return unavailable("deleteEvent");
+  async deleteEvent(id) {
+    await this.del(`/events/${this.enc(id)}`);
   }
-  async getFieldHistory() {
-    return unavailable("getFieldHistory");
+  async getFieldHistory(contactId, fieldName) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/field-history`, fieldName ? { field_name: fieldName } : undefined), "history") ?? [];
   }
-  async getContactAt() {
-    return unavailable("getContactAt");
+  async getContactAt(contactId, timestamp) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/field-at`, { timestamp }), "fields") ?? {};
   }
-  async addJobEntry() {
-    return unavailable("addJobEntry");
+  async addJobEntry(contactId, input) {
+    return pick(await this.post(`/contacts/${this.enc(contactId)}/job-history`, input), "job");
   }
-  async getJobHistory() {
-    return unavailable("getJobHistory");
+  async getJobHistory(contactId) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/job-history`), "job_history") ?? [];
   }
-  async saveLearning() {
-    return unavailable("saveLearning");
+  async saveLearning(contactId, input) {
+    return pick(await this.post(`/contacts/${this.enc(contactId)}/learnings`, input), "learning");
   }
-  async getLearnings() {
-    return unavailable("getLearnings");
+  async getLearnings(contactId, opts = {}) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/learnings`, stripUndefined(opts)), "learnings") ?? [];
   }
-  async searchLearnings() {
-    return unavailable("searchLearnings");
+  async searchLearnings(query, opts = {}) {
+    return pick(await this.g("/learnings/search", { q: query, ...stripUndefined(opts) }), "learnings") ?? [];
   }
-  async confirmLearning() {
-    return unavailable("confirmLearning");
+  async confirmLearning(learningId) {
+    await this.post(`/learnings/${this.enc(learningId)}/confirm`);
   }
-  async getStaleLearnings() {
-    return unavailable("getStaleLearnings");
+  async getStaleLearnings(daysOld, minConfidence) {
+    return pick(await this.g("/learnings/stale", { days_old: daysOld, min_confidence: minConfidence }), "learnings") ?? [];
   }
   async runLearningMaintenance() {
-    return unavailable("runLearningMaintenance");
+    const r = await this.post("/learnings/maintenance");
+    return { decayed_count: Number(r?.decayed_count ?? 0), potential_contradictions: r?.potential_contradictions ?? [] };
   }
-  async acquireContactLock() {
-    return unavailable("acquireContactLock");
+  async acquireContactLock(contactId, agentName, ttlSeconds, reason, sessionId) {
+    return this.post("/locks", { contact_id: contactId, agent_name: agentName, ttl_seconds: ttlSeconds, reason, session_id: sessionId });
   }
-  async releaseContactLock() {
-    return unavailable("releaseContactLock");
+  async releaseContactLock(contactId, agentName) {
+    const r = await this.del(`/locks/${this.enc(contactId)}`, { agent_name: agentName });
+    return Boolean(r?.released);
   }
-  async checkContactLock() {
-    return unavailable("checkContactLock");
+  async checkContactLock(contactId) {
+    return pick(await this.g(`/locks/${this.enc(contactId)}`), "lock") ?? null;
   }
-  async logAgentActivity() {
-    return unavailable("logAgentActivity");
+  async logAgentActivity(contactId, agentName, action, details, sessionId) {
+    await this.post("/activity", { contact_id: contactId, agent_name: agentName, action, details, session_id: sessionId });
   }
-  async getAgentActivity() {
-    return unavailable("getAgentActivity");
+  async getAgentActivity(contactId, limit) {
+    return pick(await this.g("/activity", { contact_id: contactId, limit }), "activity") ?? [];
   }
-  async computeRelationshipStrength() {
-    return unavailable("computeRelationshipStrength");
+  async computeRelationshipStrength(contactId) {
+    const r = await this.g(`/graph/strength/${this.enc(contactId)}`);
+    return Number(r?.strength ?? 0);
   }
-  async findWarmPath() {
-    return unavailable("findWarmPath");
+  async findWarmPath(fromContactId, toContactId) {
+    return pick(await this.g("/graph/warm-path", { from: fromContactId, to: toContactId }), "path") ?? [];
   }
-  async findConnectionsAtCompany() {
-    return unavailable("findConnectionsAtCompany");
+  async findConnectionsAtCompany(companyId) {
+    return pick(await this.g(`/graph/company/${this.enc(companyId)}`), "connections") ?? [];
   }
   async detectCoolingRelationships() {
-    return unavailable("detectCoolingRelationships");
+    return pick(await this.g("/graph/cooling"), "cooling") ?? [];
   }
-  async resolveContactIdentity() {
-    return unavailable("resolveContactIdentity");
+  async resolveContactIdentity(partial) {
+    return pick(await this.post("/identity/resolve", partial), "matches") ?? [];
   }
-  async addContactIdentity() {
-    return unavailable("addContactIdentity");
+  async addContactIdentity(contactId, system, externalId, externalUrl, confidence = "inferred") {
+    return pick(await this.post("/identity", { contact_id: contactId, system, external_id: externalId, external_url: externalUrl, confidence }), "identity");
   }
-  async getContactIdentities() {
-    return unavailable("getContactIdentities");
+  async getContactIdentities(contactId) {
+    return pick(await this.g("/identity", { contact_id: contactId }), "identities") ?? [];
   }
   async semanticSearch() {
     return unavailable("semanticSearch");
@@ -5684,44 +5721,45 @@ class ApiStore {
   async embedAllContacts() {
     return unavailable("embedAllContacts");
   }
-  async getRelationshipSignals() {
-    return unavailable("getRelationshipSignals");
+  async getRelationshipSignals(contactId) {
+    return pick(await this.g("/signals", { contact_id: contactId }), "signals") ?? [];
   }
   async getGhostContacts() {
-    return unavailable("getGhostContacts");
+    return pick(await this.g("/signals/ghost"), "signals") ?? [];
   }
   async getWarmingContacts() {
-    return unavailable("getWarmingContacts");
+    return pick(await this.g("/signals/warming"), "signals") ?? [];
   }
   async recomputeSignals() {
-    return unavailable("recomputeSignals");
+    const r = await this.post("/signals/recompute");
+    return { updated: Number(r?.updated ?? 0) };
   }
-  async getFreshnessScore() {
-    return unavailable("getFreshnessScore");
+  async getFreshnessScore(contactId) {
+    return pick(await this.g(`/freshness/${this.enc(contactId)}`), "freshness");
   }
-  async getStaleContacts() {
-    return unavailable("getStaleContacts");
+  async getStaleContacts(threshold) {
+    return pick(await this.g("/freshness/stale", { threshold }), "contacts") ?? [];
   }
-  async markFieldVerified() {
-    return unavailable("markFieldVerified");
+  async markFieldVerified(contactId, fieldName, source) {
+    await this.post("/freshness/verify", { contact_id: contactId, field_name: fieldName, source });
   }
-  async addOrgChartEdge() {
-    return unavailable("addOrgChartEdge");
+  async addOrgChartEdge(companyId, contactAId, contactBId, edgeType, inferred = false) {
+    return pick(await this.post("/org-chart", { company_id: companyId, contact_a_id: contactAId, contact_b_id: contactBId, edge_type: edgeType, inferred }), "edge");
   }
-  async listOrgChart() {
-    return unavailable("listOrgChart");
+  async listOrgChart(companyId) {
+    return pick(await this.g("/org-chart", { company_id: companyId }), "edges") ?? [];
   }
-  async setDealContactRole() {
-    return unavailable("setDealContactRole");
+  async setDealContactRole(dealId, contactId, accountRole) {
+    return pick(await this.post(`/deals/${this.enc(dealId)}/roles`, { contact_id: contactId, account_role: accountRole }), "role");
   }
-  async getDealTeam() {
-    return unavailable("getDealTeam");
+  async getDealTeam(dealId) {
+    return pick(await this.g(`/deals/${this.enc(dealId)}/team`), "team") ?? [];
   }
-  async getCoverageGaps() {
-    return unavailable("getCoverageGaps");
+  async getCoverageGaps(companyId) {
+    return pick(await this.g(`/org-chart/coverage/${this.enc(companyId)}`), "coverage");
   }
-  async getRecentContactEvents() {
-    return unavailable("getRecentContactEvents");
+  async getRecentContactEvents(since, eventTypes) {
+    return pick(await this.g("/recent-events", { since, types: eventTypes?.length ? eventTypes.join(",") : undefined }), "events") ?? [];
   }
   async addDocument() {
     return unavailable("addDocument");
@@ -5747,65 +5785,66 @@ class ApiStore {
   async deleteHealthData() {
     return unavailable("deleteHealthData");
   }
-  async createAudience() {
-    return unavailable("createAudience");
+  async createAudience(input) {
+    return pick(await this.post("/audiences", input), "audience");
   }
-  async getAudience() {
-    return unavailable("getAudience");
+  async getAudience(idOrSlug) {
+    return pick(await this.g(`/audiences/${this.enc(idOrSlug)}`), "audience");
   }
   async listAudiences() {
-    return unavailable("listAudiences");
+    return pick(await this.g("/audiences"), "audiences") ?? [];
   }
-  async updateAudience() {
-    return unavailable("updateAudience");
+  async updateAudience(idOrSlug, input) {
+    return pick(await this.patch(`/audiences/${this.enc(idOrSlug)}`, input), "audience");
   }
-  async deleteAudience() {
-    return unavailable("deleteAudience");
+  async deleteAudience(idOrSlug) {
+    await this.del(`/audiences/${this.enc(idOrSlug)}`);
   }
-  async resolveAudience() {
-    return unavailable("resolveAudience");
+  async resolveAudience(idOrSlug, channel) {
+    return pick(await this.g(`/audiences/${this.enc(idOrSlug)}/resolve`, { channel }), "resolution");
   }
-  async setContactConsent() {
-    return unavailable("setContactConsent");
+  async setContactConsent(contactId, channel, status, source) {
+    return pick(await this.post("/consent", { contact_id: contactId, channel, status, source }), "consent");
   }
-  async listContactConsent() {
-    return unavailable("listContactConsent");
+  async listContactConsent(contactId) {
+    return pick(await this.g("/consent", { contact_id: contactId }), "consent") ?? [];
   }
-  async suppressAddress() {
-    return unavailable("suppressAddress");
+  async suppressAddress(input) {
+    return pick(await this.post("/suppressions", input), "suppression");
   }
-  async unsuppressAddress() {
-    return unavailable("unsuppressAddress");
+  async unsuppressAddress(channel, address) {
+    await this.del("/suppressions", { channel, address });
   }
-  async listSuppressions() {
-    return unavailable("listSuppressions");
+  async listSuppressions(opts = {}) {
+    return pick(await this.g("/suppressions", stripUndefined(opts)), "suppressions") ?? [];
   }
   async syncSuppressions() {
     return unavailable("syncSuppressions");
   }
-  async generateBrief() {
-    return unavailable("generateBrief");
+  async generateBrief(contactId) {
+    const r = await this.g(`/contacts/${this.enc(contactId)}/brief-text`);
+    return String(r?.text ?? "");
   }
-  async getContactCard() {
-    return unavailable("getContactCard");
+  async getContactCard(contactId) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/card`), "card");
   }
-  async getContactBrief() {
-    return unavailable("getContactBrief");
+  async getContactBrief(contactId, taskContext) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/brief`, taskContext ? { context: taskContext } : undefined), "brief");
   }
-  async assembleContext() {
-    return unavailable("assembleContext");
+  async assembleContext(contactIds, format) {
+    return pick(await this.post("/assemble-context", { contact_ids: contactIds, format }), "context");
   }
-  async getUpcomingItems() {
-    return unavailable("getUpcomingItems");
+  async getUpcomingItems(days) {
+    return pick(await this.g("/upcoming", { days }), "items") ?? [];
   }
   async getNetworkStats() {
-    return unavailable("getNetworkStats");
+    return pick(await this.g("/network-stats"), "stats");
   }
   async listContactAudit() {
-    return unavailable("listContactAudit");
+    return pick(await this.g("/contact-audit"), "audit") ?? [];
   }
-  async getContactTimeline() {
-    return unavailable("getContactTimeline");
+  async getContactTimeline(contactId, limit) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/timeline`, { limit }), "timeline") ?? [];
   }
   async ingestMeetingParticipants() {
     return unavailable("ingestMeetingParticipants");
@@ -5835,13 +5874,13 @@ class ApiStore {
     return unavailable("lockVault");
   }
   async isVaultInitialized() {
-    return unavailable("isVaultInitialized");
+    return false;
   }
   async isVaultUnlocked() {
-    return unavailable("isVaultUnlocked");
+    return false;
   }
   async vaultStatus() {
-    return unavailable("vaultStatus");
+    return pick(await this.g("/vault-status"), "vault") ?? { initialized: false, unlocked: false, document_count: 0 };
   }
   async saveFeedback() {
     return unavailable("saveFeedback");
@@ -5850,7 +5889,7 @@ class ApiStore {
     return null;
   }
   async listActiveWebhooks() {
-    return unavailable("listActiveWebhooks");
+    return [];
   }
 }
 var cached;