lumnisai 0.5.20 → 0.5.22

package/dist/index.cjs

@@ -663,6 +663,21 @@ class CampaignsResource {
       `/campaigns/${encodeURIComponent(campaignId)}/prospects/${encodeURIComponent(prospectId)}`
     );
   }
+  /**
+   * Transfer prospects from this campaign into another campaign owned by
+   * the same user. Omit prospectIds to transfer every prospect.
+   *
+   * In-flight actions are cancelled and the prospect is re-evaluated under
+   * the target campaign's playbook; its action history and email threads
+   * follow it. Prospects already present in the target are skipped and
+   * reported with a reason.
+   */
+  async transferProspects(campaignId, request) {
+    return this.http.post(
+      `/campaigns/${encodeURIComponent(campaignId)}/prospects/transfer`,
+      request
+    );
+  }
   /**
    * Remove a prospect from a campaign.
    */
@@ -3044,6 +3059,75 @@ class ResponsesResource {
     if (!Array.isArray(validationOnlyCriteria))
       throw new ValidationError("criteria_classification missing or invalid validation_only_criteria");
   }
+  _validateCompetitorPostEngagementParams(params) {
+    const company = this._getParamValue(params, "company", "company");
+    const competitors = this._getParamValue(params, "competitors", "competitors");
+    const engagementTypes = this._getParamValue(
+      params,
+      "engagementTypes",
+      "engagement_types"
+    );
+    const hasCompany = typeof company === "string" && company.trim().length > 0;
+    const hasCompetitors = Array.isArray(competitors) && competitors.length > 0;
+    if (hasCompany === hasCompetitors) {
+      throw new ValidationError(
+        "Provide exactly one of `company` or `competitors` for competitor_post_engagement."
+      );
+    }
+    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 limit = this._getParamValue(params, "limit", "limit");
+    if (limit !== void 0 && (limit < 1 || limit > 1e3)) {
+      throw new ValidationError("limit must be between 1 and 1000 for competitor_post_engagement");
+    }
+    const maxCompetitors = this._getParamValue(params, "maxCompetitors", "max_competitors");
+    if (maxCompetitors !== void 0 && (maxCompetitors < 1 || maxCompetitors > 50)) {
+      throw new ValidationError("maxCompetitors must be between 1 and 50");
+    }
+    const maxExecsPerTarget = this._getParamValue(
+      params,
+      "maxExecsPerTarget",
+      "max_execs_per_target"
+    );
+    if (maxExecsPerTarget !== void 0 && (maxExecsPerTarget < 1 || maxExecsPerTarget > 20)) {
+      throw new ValidationError("maxExecsPerTarget must be between 1 and 20");
+    }
+    const maxPostsPerTarget = this._getParamValue(
+      params,
+      "maxPostsPerTarget",
+      "max_posts_per_target"
+    );
+    if (maxPostsPerTarget !== void 0 && (maxPostsPerTarget < 1 || maxPostsPerTarget > 20)) {
+      throw new ValidationError("maxPostsPerTarget must be between 1 and 20");
+    }
+    const maxReactorsPerPost = this._getParamValue(
+      params,
+      "maxReactorsPerPost",
+      "max_reactors_per_post"
+    );
+    if (maxReactorsPerPost !== void 0 && (maxReactorsPerPost < 1 || maxReactorsPerPost > 5e3)) {
+      throw new ValidationError("maxReactorsPerPost must be between 1 and 5000");
+    }
+    const maxCommentsPerPost = this._getParamValue(
+      params,
+      "maxCommentsPerPost",
+      "max_comments_per_post"
+    );
+    if (maxCommentsPerPost !== void 0 && (maxCommentsPerPost < 1 || maxCommentsPerPost > 100)) {
+      throw new ValidationError("maxCommentsPerPost must be between 1 and 100");
+    }
+  }
   _validateCriteriaParams(params, specializedAgent) {
     if (!params)
       return;
@@ -3142,6 +3226,8 @@ class ResponsesResource {
         );
       }
     }
+    if (specializedAgent === "competitor_post_engagement")
+      this._validateCompetitorPostEngagementParams(rawParams);
   }
   _validateFileReference(uri) {
     if (uri.startsWith("artifact_"))
@@ -3411,6 +3497,72 @@ class ResponsesResource {
     }
     return this.create(request);
   }
+  /**
+   * Score people who reacted to or commented on competitor LinkedIn posts.
+   *
+   * **Discovery mode** — pass `company`: ReAct discovers competitors (Exa +
+   * optional Firecrawl + Fiber validation), engagement-ranks them, extracts
+   * engagers from top posts, scores against the persona prompt.
+   *
+   * **Explicit mode** — pass `competitors`: skips discovery, uses your list.
+   *
+   * Requires `FIBER_API_KEY` + `CRUSTDATA_API_KEY`. `FIRECRAWL_API_KEY` is
+   * optional but improves discovery quality on ambiguous domains.
+   *
+   * @param query - Persona prompt in messages (e.g. "VP Sales at mid-market SaaS…")
+   * @param options - Exactly one of `company` or `competitors` is required
+   * @returns Response; poll with `get()` then read `structuredResponse` as
+   *   {@link CompetitorPostEngagementOutput}. See `src/types/competitor-post-engagement.ts`
+   *   for the full agent reference (pipeline, API keys, engagementData shape, costs).
+   */
+  async competitorPostEngagement(query, options) {
+    const hasCompany = typeof options.company === "string" && options.company.trim().length > 0;
+    const hasCompetitors = Array.isArray(options.competitors) && options.competitors.length > 0;
+    if (hasCompany === hasCompetitors) {
+      throw new ValidationError(
+        "Provide exactly one of `company` or `competitors` for competitorPostEngagement."
+      );
+    }
+    const request = {
+      messages: [{ role: "user", content: query }],
+      specializedAgent: "competitor_post_engagement"
+    };
+    const params = {};
+    if (options.company)
+      params.company = options.company;
+    if (options.competitors)
+      params.competitors = options.competitors;
+    if (options.companyContext)
+      params.companyContext = options.companyContext;
+    if (options.companyExamples)
+      params.companyExamples = options.companyExamples;
+    if (options.limit !== void 0)
+      params.limit = options.limit;
+    if (options.postsDateRange)
+      params.postsDateRange = options.postsDateRange;
+    if (options.engagementTypes)
+      params.engagementTypes = options.engagementTypes;
+    if (options.includeCompanyPosts !== void 0)
+      params.includeCompanyPosts = options.includeCompanyPosts;
+    if (options.includeExecPosts !== void 0)
+      params.includeExecPosts = options.includeExecPosts;
+    if (options.excludeCompetitorEmployees !== void 0)
+      params.excludeCompetitorEmployees = options.excludeCompetitorEmployees;
+    if (options.execTitles)
+      params.execTitles = options.execTitles;
+    if (options.maxCompetitors !== void 0)
+      params.maxCompetitors = options.maxCompetitors;
+    if (options.maxExecsPerTarget !== void 0)
+      params.maxExecsPerTarget = options.maxExecsPerTarget;
+    if (options.maxPostsPerTarget !== void 0)
+      params.maxPostsPerTarget = options.maxPostsPerTarget;
+    if (options.maxReactorsPerPost !== void 0)
+      params.maxReactorsPerPost = options.maxReactorsPerPost;
+    if (options.maxCommentsPerPost !== void 0)
+      params.maxCommentsPerPost = options.maxCommentsPerPost;
+    request.specializedAgentParams = params;
+    return this.create(request);
+  }
 }
 
 class SequencesResource {