lumnisai 0.1.7 → 0.1.9

package/dist/index.mjs

@@ -1,3 +1,6 @@
+import { Buffer } from 'node:buffer';
+import crypto$1 from 'node:crypto';
+
 const DEFAULT_BASE_URL = "https://api.lumnis.ai";
 const DEFAULT_POLL_INTERVAL_MS = 2e3;
 const LONG_POLL_TIMEOUT_S = 10;
@@ -203,15 +206,33 @@ class IntegrationsResource {
    * Check the status of a specific connection
    */
   async getConnectionStatus(params) {
-    const { userId, appName, provider } = params;
+    const { userId, appName, provider, includeEnabled } = params;
     const queryParams = new URLSearchParams();
     if (provider)
       queryParams.append("provider", provider);
+    if (includeEnabled)
+      queryParams.append("include_enabled", "true");
     const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
     return this.http.get(
       `/integrations/connections/${encodeURIComponent(userId)}/${appName.toUpperCase()}${query}`
     );
   }
+  /**
+   * Check connection status for multiple apps in a single request
+   * Optimized for onboarding flows - checks multiple connections in parallel
+   */
+  async getConnectionsBatch(params) {
+    const requestData = {
+      userId: params.userId,
+      appNames: params.appNames.map((name) => name.toUpperCase()),
+      provider: params.provider || "composio",
+      includeEnabledStatus: params.includeEnabledStatus ?? true
+    };
+    return this.http.post(
+      "/integrations/connections/batch",
+      requestData
+    );
+  }
   /**
    * Get all connections for a user
    */
@@ -387,50 +408,6 @@ class MCPServersResource {
   }
 }
 
-class ModelPreferencesResource {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Get all model preferences for the tenant
-   */
-  async get(includeDefaults = true) {
-    const params = new URLSearchParams();
-    params.append("include_defaults", includeDefaults.toString());
-    return this.http.get(`/model-preferences?${params.toString()}`);
-  }
-  /**
-   * Update multiple model preferences in a single request
-   */
-  async updateBulk(data) {
-    return this.http.put("/model-preferences", data);
-  }
-  /**
-   * Update a specific model type preference
-   */
-  async update(modelType, data) {
-    return this.http.patch(`/model-preferences/${modelType}`, data);
-  }
-  /**
-   * Delete a model preference to revert to system default
-   */
-  async delete(modelType) {
-    await this.http.delete(`/model-preferences/${modelType}`);
-  }
-  /**
-   * Check which models are available based on API key configuration
-   */
-  async checkAvailability(models) {
-    return this.http.post("/model-preferences/check-availability", models);
-  }
-  /**
-   * List all model preferences (alias for get)
-   */
-  async list(params) {
-    return this.get(params?.includeDefaults);
-  }
-}
-
 class LumnisError extends Error {
   code;
   statusCode;
@@ -504,6 +481,319 @@ class SourcesNotAvailableError extends ValidationError {
     this.availableSources = availableSources;
   }
 }
+class MessagingAPIError extends LumnisError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "MessagingAPIError";
+  }
+}
+class MessagingNotFoundError extends MessagingAPIError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 404 });
+    this.name = "MessagingNotFoundError";
+  }
+}
+class MessagingValidationError extends MessagingAPIError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 400 });
+    this.name = "MessagingValidationError";
+  }
+}
+class MessagingSendError extends MessagingAPIError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 400 });
+    this.name = "MessagingSendError";
+  }
+}
+class MessagingConnectionError extends MessagingAPIError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 400 });
+    this.name = "MessagingConnectionError";
+  }
+}
+
+class MessagingResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Sync conversations from connected providers for specific prospects.
+   * Prospects list is REQUIRED.
+   */
+  async syncConversations(userId, request) {
+    if (!request.prospects || request.prospects.length === 0) {
+      throw new MessagingValidationError("prospects array is required and must not be empty", { code: "VALIDATION_ERROR" });
+    }
+    for (const prospect of request.prospects) {
+      const hasIdentifier = prospect.email || prospect.linkedinUrl || prospect.providerId;
+      if (!hasIdentifier) {
+        throw new MessagingValidationError("Each prospect must have at least one identifier (email, linkedinUrl, or providerId)", { code: "VALIDATION_ERROR" });
+      }
+    }
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/sync?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Sync conversation for a single prospect on-demand.
+   * Use when viewing a prospect's detail page.
+   */
+  async syncProspect(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/sync/prospect?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Get sync job status
+   */
+  async getSyncStatus(jobId) {
+    return this.http.get(`/messaging/sync/${encodeURIComponent(jobId)}`);
+  }
+  /**
+   * List conversations with filtering
+   */
+  async listConversations(userId, params) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    if (params?.status)
+      queryParams.append("status", params.status);
+    if (params?.channel)
+      queryParams.append("channel", params.channel);
+    if (params?.projectId)
+      queryParams.append("project_id", params.projectId);
+    if (params?.networkDistance)
+      queryParams.append("network_distance", params.networkDistance);
+    if (params?.limit !== void 0)
+      queryParams.append("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      queryParams.append("offset", String(params.offset));
+    return this.http.get(
+      `/messaging/conversations?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Get all conversations for a project
+   */
+  async listConversationsByProject(projectId, userId, params) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    if (params?.limit !== void 0)
+      queryParams.append("limit", String(params.limit));
+    if (params?.offset !== void 0)
+      queryParams.append("offset", String(params.offset));
+    return this.http.get(
+      `/messaging/conversations/by-project/${encodeURIComponent(projectId)}?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Get conversation with messages
+   */
+  async getConversation(conversationId, userId, params) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    if (params?.fetchLive !== void 0)
+      queryParams.append("fetch_live", String(params.fetchLive));
+    return this.http.get(
+      `/messaging/conversations/${encodeURIComponent(conversationId)}?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Send a message (creates new conversation or adds to existing)
+   */
+  async sendMessage(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/send?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Reply to an existing conversation
+   */
+  async replyToConversation(conversationId, userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/conversations/${encodeURIComponent(conversationId)}/reply?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Get all email threads with a specific person
+   */
+  async getEmailThreads(emailAddress, userId, params) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    if (params?.limit !== void 0)
+      queryParams.append("limit", String(params.limit));
+    return this.http.get(
+      `/messaging/email-threads/${encodeURIComponent(emailAddress)}?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Check if user is connected to a prospect on LinkedIn
+   */
+  async checkLinkedInConnection(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/linkedin/check-connection?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Batch check connection status for multiple prospects
+   */
+  async batchCheckLinkedInConnections(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/linkedin/check-connections/batch?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Smart LinkedIn outreach with automatic method selection
+   */
+  async sendLinkedInOutreach(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/linkedin/send?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Get InMail credit information.
+   * By default returns cached data. Set forceRefresh=true to fetch real-time data from Unipile API.
+   */
+  async getLinkedInCredits(userId, options) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    if (options?.forceRefresh) {
+      queryParams.append("force_refresh", "true");
+    }
+    return this.http.get(
+      `/messaging/linkedin/credits?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Force refresh InMail credits from Unipile API.
+   * Fetches real-time credit balance from provider and updates cache.
+   */
+  async refreshLinkedInCredits(userId) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/linkedin/refresh-credits?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Update LinkedIn subscription type and credits
+   */
+  async updateLinkedInSubscription(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.put(
+      `/messaging/linkedin/subscription?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Create a single draft message
+   */
+  async createDraft(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/drafts?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Create drafts for multiple prospects with AI generation
+   */
+  async createBatchDrafts(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/drafts/batch?${queryParams.toString()}`,
+      request
+    );
+  }
+  /**
+   * Approve and send a single draft
+   */
+  async sendDraft(draftId, userId) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/drafts/${encodeURIComponent(draftId)}/send?${queryParams.toString()}`
+    );
+  }
+  /**
+   * Send multiple drafts with rate limiting
+   */
+  async sendBatchDrafts(userId, request) {
+    const queryParams = new URLSearchParams();
+    queryParams.append("user_id", userId);
+    return this.http.post(
+      `/messaging/drafts/batch/send?${queryParams.toString()}`,
+      request
+    );
+  }
+}
+
+class ModelPreferencesResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all model preferences for the tenant
+   */
+  async get(includeDefaults = true) {
+    const params = new URLSearchParams();
+    params.append("include_defaults", includeDefaults.toString());
+    return this.http.get(`/model-preferences?${params.toString()}`);
+  }
+  /**
+   * Update multiple model preferences in a single request
+   */
+  async updateBulk(data) {
+    return this.http.put("/model-preferences", data);
+  }
+  /**
+   * Update a specific model type preference
+   */
+  async update(modelType, data) {
+    return this.http.patch(`/model-preferences/${modelType}`, data);
+  }
+  /**
+   * Delete a model preference to revert to system default
+   */
+  async delete(modelType) {
+    await this.http.delete(`/model-preferences/${modelType}`);
+  }
+  /**
+   * Check which models are available based on API key configuration
+   */
+  async checkAvailability(models) {
+    return this.http.post("/model-preferences/check-availability", models);
+  }
+  /**
+   * List all model preferences (alias for get)
+   */
+  async list(params) {
+    return this.get(params?.includeDefaults);
+  }
+}
 
 var PeopleDataSource = /* @__PURE__ */ ((PeopleDataSource2) => {
   PeopleDataSource2["PDL"] = "PDL";
@@ -705,6 +995,35 @@ class ResponsesResource {
       queryParams.progress_id = options.progressId;
     return this.http.get(`/responses/${responseId}/feedback`, { params: queryParams });
   }
+  /**
+   * Perform a quick people search using the specialized quick_people_search agent
+   * @param query - Natural language search query (e.g., "Find engineers at Google in SF")
+   * @param options - Optional search parameters
+   * @param options.limit - Maximum number of results (1-100, default: 20)
+   * @param options.dataSources - Specific data sources to use: ["PDL", "CORESIGNAL", "CRUST_DATA"]
+   * @returns Response with structured_response containing:
+   *   - candidates: List of person results
+   *   - totalFound: Total unique candidates found
+   *   - appliedFilters: Extracted search filters
+   *   - executionTimeMs: Search duration
+   *   - dataSourcesUsed: Which sources were queried
+   */
+  async quickPeopleSearch(query, options) {
+    const request = {
+      messages: [{ role: "user", content: query }],
+      specializedAgent: "quick_people_search"
+    };
+    if (options) {
+      const params = {};
+      if (options.limit !== void 0)
+        params.limit = options.limit;
+      if (options.dataSources)
+        params.dataSources = options.dataSources;
+      if (Object.keys(params).length > 0)
+        request.specializedAgentParams = params;
+    }
+    return this.create(request);
+  }
 }
 
 class SkillsResource {
@@ -939,12 +1258,20 @@ class UsersResource {
   }
 }
 
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUUID(s) {
+  return UUID_PATTERN.test(s);
+}
 function toCamel(s) {
+  if (isUUID(s))
+    return s;
   return s.replace(/([-_][a-z])/gi, ($1) => {
     return $1.toUpperCase().replace("-", "").replace("_", "");
   });
 }
 function toSnake(s) {
+  if (isUUID(s))
+    return s;
   return s.replace(/[A-Z]/g, (letter, index) => {
     return index === 0 ? letter.toLowerCase() : `_${letter.toLowerCase()}`;
   });
@@ -1117,6 +1444,7 @@ class LumnisClient {
   mcpServers;
   skills;
   people;
+  messaging;
   _scopedUserId;
   _defaultScope;
   constructor(options = {}) {
@@ -1148,6 +1476,7 @@ class LumnisClient {
     this.mcpServers = new MCPServersResource(this.http);
     this.skills = new SkillsResource(this.http);
     this.people = new PeopleResource(this.http);
+    this.messaging = new MessagingResource(this.http);
   }
   forUser(userId) {
     return new LumnisClient({
@@ -1327,8 +1656,28 @@ class LumnisClient {
   async initiateConnection(params) {
     return this.integrations.initiateConnection(params);
   }
-  async getConnectionStatus(userId, appName, provider) {
-    return this.integrations.getConnectionStatus({ userId, appName, provider });
+  async getConnectionStatus(userId, appName, providerOrOptions) {
+    if (typeof providerOrOptions === "string") {
+      return this.integrations.getConnectionStatus({
+        userId,
+        appName,
+        provider: providerOrOptions
+      });
+    }
+    return this.integrations.getConnectionStatus({
+      userId,
+      appName,
+      provider: providerOrOptions?.provider,
+      includeEnabled: providerOrOptions?.includeEnabled
+    });
+  }
+  async getConnectionsBatch(params) {
+    return this.integrations.getConnectionsBatch({
+      userId: params.userId,
+      appNames: params.appNames,
+      provider: params.provider,
+      includeEnabledStatus: params.includeEnabledStatus
+    });
   }
   async listConnections(userId, params) {
     return this.integrations.listConnections(userId, params);
@@ -1433,6 +1782,76 @@ var ProviderType = /* @__PURE__ */ ((ProviderType2) => {
   return ProviderType2;
 })(ProviderType || {});
 
+var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
+  ChannelType2["GMAIL"] = "gmail";
+  ChannelType2["OUTLOOK"] = "outlook";
+  ChannelType2["LINKEDIN"] = "linkedin";
+  return ChannelType2;
+})(ChannelType || {});
+var OutreachMethod = /* @__PURE__ */ ((OutreachMethod2) => {
+  OutreachMethod2["CONNECTION_REQUEST"] = "connection_request";
+  OutreachMethod2["DIRECT_MESSAGE"] = "direct_message";
+  OutreachMethod2["INMAIL"] = "inmail";
+  OutreachMethod2["INMAIL_ESCALATION"] = "inmail_escalation";
+  OutreachMethod2["EMAIL"] = "email";
+  return OutreachMethod2;
+})(OutreachMethod || {});
+var ConversationStatus = /* @__PURE__ */ ((ConversationStatus2) => {
+  ConversationStatus2["ACTIVE"] = "active";
+  ConversationStatus2["NEEDS_RESPONSE"] = "needs_response";
+  ConversationStatus2["WAITING"] = "waiting";
+  ConversationStatus2["BOOKED"] = "booked";
+  ConversationStatus2["CLOSED"] = "closed";
+  return ConversationStatus2;
+})(ConversationStatus || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["MESSAGE"] = "message";
+  MessageType2["CONNECTION_REQUEST"] = "connection_request";
+  MessageType2["CONNECTION_ACCEPTED"] = "connection_accepted";
+  MessageType2["INMAIL"] = "inmail";
+  return MessageType2;
+})(MessageType || {});
+var DraftStatus = /* @__PURE__ */ ((DraftStatus2) => {
+  DraftStatus2["PENDING_REVIEW"] = "pending_review";
+  DraftStatus2["APPROVED"] = "approved";
+  DraftStatus2["SCHEDULED"] = "scheduled";
+  DraftStatus2["SENDING"] = "sending";
+  DraftStatus2["SENT"] = "sent";
+  DraftStatus2["FAILED"] = "failed";
+  DraftStatus2["DISCARDED"] = "discarded";
+  return DraftStatus2;
+})(DraftStatus || {});
+var SyncJobStatus = /* @__PURE__ */ ((SyncJobStatus2) => {
+  SyncJobStatus2["QUEUED"] = "queued";
+  SyncJobStatus2["IN_PROGRESS"] = "in_progress";
+  SyncJobStatus2["COMPLETED"] = "completed";
+  SyncJobStatus2["FAILED"] = "failed";
+  return SyncJobStatus2;
+})(SyncJobStatus || {});
+var QueueItemStatus = /* @__PURE__ */ ((QueueItemStatus2) => {
+  QueueItemStatus2["QUEUED"] = "queued";
+  QueueItemStatus2["PROCESSING"] = "processing";
+  QueueItemStatus2["COMPLETED"] = "completed";
+  QueueItemStatus2["FAILED"] = "failed";
+  QueueItemStatus2["CANCELLED"] = "cancelled";
+  return QueueItemStatus2;
+})(QueueItemStatus || {});
+var LinkedInSubscriptionType = /* @__PURE__ */ ((LinkedInSubscriptionType2) => {
+  LinkedInSubscriptionType2["BASIC"] = "basic";
+  LinkedInSubscriptionType2["PREMIUM"] = "premium";
+  LinkedInSubscriptionType2["SALES_NAVIGATOR"] = "sales_navigator";
+  LinkedInSubscriptionType2["RECRUITER_LITE"] = "recruiter_lite";
+  LinkedInSubscriptionType2["RECRUITER_CORPORATE"] = "recruiter_corporate";
+  return LinkedInSubscriptionType2;
+})(LinkedInSubscriptionType || {});
+var NetworkDistance = /* @__PURE__ */ ((NetworkDistance2) => {
+  NetworkDistance2["FIRST_DEGREE"] = "FIRST_DEGREE";
+  NetworkDistance2["SECOND_DEGREE"] = "SECOND_DEGREE";
+  NetworkDistance2["THIRD_DEGREE"] = "THIRD_DEGREE";
+  NetworkDistance2["OUT_OF_NETWORK"] = "OUT_OF_NETWORK";
+  return NetworkDistance2;
+})(NetworkDistance || {});
+
 function displayProgress(update, indent = "	") {
   if (update.state === "tool_update") {
     if (update.toolCalls && update.toolCalls.length > 0) {
@@ -1528,4 +1947,18 @@ class ProgressTracker {
   }
 }
 
-export { AuthenticationError, InternalServerError, LocalFileNotSupportedError, LumnisClient, LumnisError, NoDataSourcesError, NotFoundError, PeopleDataSource, ProgressTracker, ProviderType, RateLimitError, SourcesNotAvailableError, ValidationError, LumnisClient as default, displayProgress, formatProgressEntry };
+function verifyWebhookSignature(payload, signature, secret) {
+  if (!signature || !secret) {
+    return false;
+  }
+  const expectedSignature = crypto$1.createHmac("sha256", secret).update(payload).digest("hex");
+  if (signature.length !== expectedSignature.length) {
+    return false;
+  }
+  return crypto$1.timingSafeEqual(
+    Buffer.from(signature),
+    Buffer.from(expectedSignature)
+  );
+}
+
+export { AuthenticationError, ChannelType, ConversationStatus, DraftStatus, InternalServerError, LinkedInSubscriptionType, LocalFileNotSupportedError, LumnisClient, LumnisError, MessageType, MessagingAPIError, MessagingConnectionError, MessagingNotFoundError, MessagingSendError, MessagingValidationError, NetworkDistance, NoDataSourcesError, NotFoundError, OutreachMethod, PeopleDataSource, ProgressTracker, ProviderType, QueueItemStatus, RateLimitError, SourcesNotAvailableError, SyncJobStatus, ValidationError, LumnisClient as default, displayProgress, formatProgressEntry, verifyWebhookSignature };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lumnisai",
   "type": "module",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Official Node.js SDK for the Lumnis AI API",
   "author": "Lumnis AI",
   "license": "MIT",