lumnisai 0.5.39 → 0.5.41

package/dist/index.cjs

@@ -3435,6 +3435,76 @@ class ResponsesResource {
       throw new ValidationError("excludeUrls must be an array of strings for engagement_expansion");
     }
   }
+  _validateInfluencerEngagementParams(params) {
+    const seedProfiles = this._getParamValue(params, "seedProfiles", "seed_profiles");
+    if (!Array.isArray(seedProfiles) || seedProfiles.some((url) => typeof url !== "string") || !seedProfiles.some((url) => url.trim().length > 0)) {
+      throw new ValidationError(
+        "seedProfiles is required for influencer_engagement and must contain at least one non-empty string"
+      );
+    }
+    const engagementTypes = this._getParamValue(
+      params,
+      "engagementTypes",
+      "engagement_types"
+    );
+    if (engagementTypes !== void 0) {
+      if (!Array.isArray(engagementTypes) || engagementTypes.length === 0)
+        throw new ValidationError("engagementTypes must contain at least one value");
+      const validTypes = ["reactor", "commenter"];
+      for (const type of engagementTypes) {
+        if (!validTypes.includes(type)) {
+          throw new ValidationError(
+            `Invalid engagementTypes value: ${String(type)}. Expected 'reactor' and/or 'commenter'.`
+          );
+        }
+      }
+    }
+    const postsDateRange = this._getParamValue(
+      params,
+      "postsDateRange",
+      "posts_date_range"
+    );
+    if (postsDateRange !== void 0) {
+      const validRanges = [
+        "past-24h",
+        "past-week",
+        "past-month",
+        "past-quarter",
+        "past-6-months",
+        "past-year",
+        "past-2-years",
+        "past-3-years"
+      ];
+      if (!validRanges.includes(postsDateRange))
+        throw new ValidationError(`Invalid postsDateRange value: ${String(postsDateRange)}`);
+    }
+    for (const [camel, snake, maximum] of [
+      ["limit", "limit", 1e3],
+      ["maxReactorsPerPost", "max_reactors_per_post", 5e3],
+      ["maxCommentsPerPost", "max_comments_per_post", 5e3]
+    ]) {
+      const value = this._getParamValue(params, camel, snake);
+      if (value !== void 0 && (!Number.isInteger(value) || value < 1 || value > maximum)) {
+        throw new ValidationError(
+          `${camel} must be an integer between 1 and ${maximum} for influencer_engagement`
+        );
+      }
+    }
+    for (const [camel, snake] of [
+      ["includeReactedPosts", "include_reacted_posts"],
+      ["postsEnableFiltering", "posts_enable_filtering"],
+      ["thoroughEnrichment", "thorough_enrichment"],
+      ["deepValidationUseRelevanceReranker", "deep_validation_use_relevance_reranker"]
+    ]) {
+      const value = this._getParamValue(params, camel, snake);
+      if (value !== void 0 && typeof value !== "boolean")
+        throw new ValidationError(`${camel} must be a boolean for influencer_engagement`);
+    }
+    const excludeUrls = this._getParamValue(params, "excludeUrls", "exclude_urls");
+    if (excludeUrls !== void 0 && (!Array.isArray(excludeUrls) || excludeUrls.some((url) => typeof url !== "string"))) {
+      throw new ValidationError("excludeUrls must be an array of strings for influencer_engagement");
+    }
+  }
   _validateSinceDays(value, agent) {
     if (value === void 0)
       return;
@@ -3480,6 +3550,60 @@ class ResponsesResource {
       );
     }
   }
+  _validateSalesNavigatorRequest(request) {
+    const directParams = request.specializedAgentParams;
+    const directUrl = directParams ? this._getParamValue(directParams, "salesNavigatorUrl", "sales_navigator_url") : void 0;
+    const requestOptions = request.options;
+    const nestedParams = requestOptions ? this._getParamValue(
+      requestOptions,
+      "specializedAgentParams",
+      "specialized_agent_params"
+    ) : void 0;
+    const nestedUrl = this._isPlainObject(nestedParams) ? this._getParamValue(nestedParams, "salesNavigatorUrl", "sales_navigator_url") : void 0;
+    const optionsUrl = requestOptions ? this._getParamValue(requestOptions, "salesNavigatorUrl", "sales_navigator_url") : void 0;
+    const salesNavigatorUrl = directUrl ?? nestedUrl ?? optionsUrl;
+    if (salesNavigatorUrl === void 0 || salesNavigatorUrl === null)
+      return;
+    if (typeof salesNavigatorUrl !== "string" || salesNavigatorUrl.length > 8192 || !salesNavigatorUrl.trim()) {
+      throw new ValidationError(
+        "salesNavigatorUrl must be a non-empty string no longer than 8192 characters"
+      );
+    }
+    if ([...salesNavigatorUrl].some((character) => character.charCodeAt(0) < 32) || salesNavigatorUrl.includes("\\")) {
+      throw new ValidationError("salesNavigatorUrl contains unsafe characters");
+    }
+    let parsed;
+    try {
+      parsed = new URL(salesNavigatorUrl);
+    } catch {
+      throw new ValidationError("salesNavigatorUrl is malformed");
+    }
+    const authorityMatch = salesNavigatorUrl.match(/^[a-z][a-z\d+.-]*:\/\/([^/?#]*)/i);
+    const rawAuthority = authorityMatch?.[1];
+    if (parsed.protocol !== "https:")
+      throw new ValidationError("salesNavigatorUrl must use https");
+    if (parsed.hostname !== "www.linkedin.com")
+      throw new ValidationError("salesNavigatorUrl must use www.linkedin.com");
+    if (parsed.username || parsed.password || parsed.port || rawAuthority?.toLowerCase() !== "www.linkedin.com") {
+      throw new ValidationError("salesNavigatorUrl cannot contain credentials or a custom port");
+    }
+    if (parsed.hash)
+      throw new ValidationError("salesNavigatorUrl cannot contain a fragment");
+    const rawSuffix = authorityMatch ? salesNavigatorUrl.slice(authorityMatch[0].length) : "";
+    const rawPath = rawSuffix.split(/[?#]/, 1)[0];
+    if (rawPath === "/sales/search/company") {
+      throw new ValidationError(
+        "Company Sales Navigator searches are not supported yet; use a people search or people list URL"
+      );
+    }
+    if (rawPath !== "/sales/search/people" && !/^\/sales\/lists\/people\/\d+$/.test(rawPath)) {
+      throw new ValidationError(
+        "salesNavigatorUrl must be a Sales Navigator people-search or people-list URL"
+      );
+    }
+    if (typeof request.userId !== "string" || !request.userId.trim())
+      throw new ValidationError("userId is required when salesNavigatorUrl is provided");
+  }
   _validateCriteriaParams(params, specializedAgent) {
     if (!params)
       return;
@@ -3595,6 +3719,8 @@ class ResponsesResource {
       this._validateContentIntelligenceParams(rawParams);
     if (specializedAgent === "engagement_expansion")
       this._validateEngagementExpansionParams(rawParams);
+    if (specializedAgent === "influencer_engagement")
+      this._validateInfluencerEngagementParams(rawParams);
     if (specializedAgent === "company_intelligence")
       this._validateCompanyIntelligenceParams(rawParams);
     if (specializedAgent === "person_intelligence")
@@ -3640,6 +3766,7 @@ class ResponsesResource {
       for (const file of request.files)
         this._validateFileReference(file.uri);
     }
+    this._validateSalesNavigatorRequest(request);
     if (request.specializedAgentParams)
       this._validateCriteriaParams(request.specializedAgentParams, request.specializedAgent);
     return this.http.post("/responses", request);
@@ -3775,10 +3902,13 @@ class ResponsesResource {
    * @param options.excludeCrmContacts - Exclude people in the acting user's synced CRM ledger; @default true
    * @param options.crmExclusionOwners - Granted owner ledgers to exclude against (user id or email)
    * @param options.crmNameCompanyMatch - Also exclude by exact name+company; @default true
+   * @param options.salesNavigatorUrl - Sales Navigator people-search or people-list URL to use as the only discovery source
+   * @param options.userId - Acting user whose owned Sales Navigator connection should be used; required with `salesNavigatorUrl`
    * @param options.searchJobSignal - CrustData job-listing signal search (decision makers at hiring companies); true | false | 'auto'
    * @param options.deepVerify - Web verification for org/location/third-party criteria: 'auto' (default), 'always', or 'off'
    * @param options.deepValidationUseRelevanceReranker - SLM relevance reranker for surfaced candidates (ranking-only); @default true
    * @param options.deepValidationBackfillBelowCriteria - Pad with criteria-failed candidates when under count; @default true
+   * @param options.enrichEngagementHistory - Add recent LinkedIn engagement evidence before validation; forced off for Sales Navigator V1
    * @param options.deepSearchCriteriaModel - Override criteria decomposition model (e.g. 'openai:gpt-5.4')
    * @returns Response with structured_response containing:
    *   - candidates: Validated and scored candidates
@@ -3790,6 +3920,8 @@ class ResponsesResource {
       messages: [{ role: "user", content: query }],
       specializedAgent: "deep_people_search"
     };
+    if (options?.userId !== void 0)
+      request.userId = options.userId;
     const params = {
       deepValidationUseRelevanceReranker: options?.deepValidationUseRelevanceReranker ?? true,
       deepValidationBackfillBelowCriteria: options?.deepValidationBackfillBelowCriteria ?? true
@@ -3823,6 +3955,8 @@ class ResponsesResource {
         params.crmExclusionOwners = options.crmExclusionOwners;
       if (options.crmNameCompanyMatch !== void 0)
         params.crmNameCompanyMatch = options.crmNameCompanyMatch;
+      if (options.salesNavigatorUrl !== void 0)
+        params.salesNavigatorUrl = options.salesNavigatorUrl;
       if (options.searchProfiles !== void 0)
         params.searchProfiles = options.searchProfiles;
       if (options.searchPosts !== void 0)
@@ -3857,8 +3991,22 @@ class ResponsesResource {
         params.searchJobSignal = options.searchJobSignal;
       if (options.deepVerify !== void 0)
         params.deepVerify = options.deepVerify;
+      if (options.enrichEngagementHistory !== void 0)
+        params.enrichEngagementHistory = options.enrichEngagementHistory;
       if (options.deepSearchCriteriaModel)
         params.deepSearchCriteriaModel = options.deepSearchCriteriaModel;
+      if (options.salesNavigatorUrl !== void 0) {
+        params.searchProfiles = false;
+        params.searchPosts = false;
+        params.searchConnections = false;
+        params.searchJobSignal = false;
+        params.includeEngagementInScore = false;
+        params.postsEnableEnrichment = false;
+        params.postsEnableFiltering = false;
+        params.deepValidationUseRelevanceReranker = false;
+        params.deepValidationBackfillBelowCriteria = false;
+        params.enrichEngagementHistory = false;
+      }
     }
     request.specializedAgentParams = params;
     return this.create(request);
@@ -3995,6 +4143,52 @@ class ResponsesResource {
       specializedAgentParams: params
     });
   }
+  /**
+   * Score people who react to or comment on posts connected to named LinkedIn profiles.
+   *
+   * The backend reads posts each seed authored within the requested window and can
+   * optionally include posts they reacted to. It selects posts relevant to the
+   * persona prompt, then runs their engagers through the deep people-search scoring
+   * chain. Seed profiles are always excluded from delivered candidates.
+   *
+   * @param query - Persona prompt used to select posts and score discovered people.
+   * @param options - Seed profiles plus optional window, extraction, and cost controls.
+   * @returns Response; poll with `get()` and read `structuredResponse` as
+   *   {@link InfluencerEngagementOutput}.
+   */
+  async influencerEngagement(query, options) {
+    if (!query.trim())
+      throw new ValidationError("influencerEngagement requires a non-empty persona query");
+    const params = {
+      seedProfiles: options.seedProfiles
+    };
+    if (options.includeReactedPosts !== void 0)
+      params.includeReactedPosts = options.includeReactedPosts;
+    if (options.postsDateRange !== void 0)
+      params.postsDateRange = options.postsDateRange;
+    if (options.engagementTypes !== void 0)
+      params.engagementTypes = options.engagementTypes;
+    if (options.postsEnableFiltering !== void 0)
+      params.postsEnableFiltering = options.postsEnableFiltering;
+    if (options.thoroughEnrichment !== void 0)
+      params.thoroughEnrichment = options.thoroughEnrichment;
+    if (options.deepValidationUseRelevanceReranker !== void 0) {
+      params.deepValidationUseRelevanceReranker = options.deepValidationUseRelevanceReranker;
+    }
+    if (options.maxReactorsPerPost !== void 0)
+      params.maxReactorsPerPost = options.maxReactorsPerPost;
+    if (options.maxCommentsPerPost !== void 0)
+      params.maxCommentsPerPost = options.maxCommentsPerPost;
+    if (options.excludeUrls !== void 0)
+      params.excludeUrls = options.excludeUrls;
+    if (options.limit !== void 0)
+      params.limit = options.limit;
+    return this.create({
+      messages: [{ role: "user", content: query }],
+      specializedAgent: "influencer_engagement",
+      specializedAgentParams: params
+    });
+  }
   /**
    * Score people who reacted to or commented on competitor LinkedIn posts.
    *