orangeslice 2.1.5 → 2.2.0

package/README.md

@@ -90,8 +90,10 @@ const startups = await services.crunchbase.search({
 ## Service map
 
 - `services.company.linkedin.search/enrich`
+- `services.company.findCareersPage/scrapeCareersPage`
 - `services.crunchbase.search` (returns rows array directly)
 - `services.company.getEmployeesFromLinkedin` (database-only B2B path)
+- `services.ocean.search.companies/people`
 - `services.person.linkedin.search/enrich`
 - `services.web.search/batchSearch`
 - `services.ai.generateObject`
@@ -106,7 +108,7 @@ const startups = await services.crunchbase.search({
 
 All service calls go through `post()` in `src/api.ts`.
 
-- Submit path: `https://enrichly-production.up.railway.app/function`
+- Execute paths: `https://enrichly-production.up.railway.app/execute/*` and `https://enrichly-production.up.railway.app/ctx/*`
 - Pending responses (`pending: true` / `202`) poll batch-service result endpoints.
 - Polling timeout supports long-running workflows (up to 10 minutes).
 - This package now exposes only batch-backed services.

package/dist/careers.d.ts

@@ -0,0 +1,47 @@
+export interface FindCareersPageParams {
+    website?: string;
+    url?: string;
+}
+export interface FindCareersPageResult {
+    inputUrl: string;
+    normalizedWebsiteUrl: string;
+    careerPageUrl: string | null;
+    pageType: "ats" | "official" | "not_found";
+    atsProvider: string | null;
+    detectionMethod: "input-ats" | "homepage-ats-link" | "homepage-careers-link" | "deterministic-candidate" | "candidate-ats-link" | "embedded-ats" | "candidate-redirect" | "ats-unverified" | "not-found";
+    checkedUrls: string[];
+}
+export interface ScrapeCareersPageParams {
+    careersPageUrl?: string;
+    url?: string;
+}
+export interface ScrapeCareersPageJob {
+    id: string;
+    title: string;
+    url: string;
+    applyUrl: string | null;
+    location: string | null;
+    locations: string[];
+    department: string | null;
+    team: string | null;
+    employmentType: string | null;
+    workplaceType: string | null;
+    postedAt: string | null;
+    postedText: string | null;
+    requisitionId: string | null;
+}
+export interface ScrapeCareersPageResult {
+    status: "success" | "unsupported_url" | "unsupported_provider";
+    inputUrl: string;
+    normalizedBoardUrl: string | null;
+    atsProvider: string | null;
+    companyName: string | null;
+    source: "api" | "html" | null;
+    totalJobs: number;
+    jobs: ScrapeCareersPageJob[];
+    checkedUrls: string[];
+    supportedProviders: string[];
+    message: string | null;
+}
+export declare function findCareersPage(params: FindCareersPageParams): Promise<FindCareersPageResult>;
+export declare function scrapeCareersPage(params: ScrapeCareersPageParams): Promise<ScrapeCareersPageResult>;

package/dist/careers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCareersPage = findCareersPage;
+exports.scrapeCareersPage = scrapeCareersPage;
+const api_1 = require("./api");
+async function findCareersPage(params) {
+    return (0, api_1.post)("/execute/find-careers-page", { ...params });
+}
+async function scrapeCareersPage(params) {
+    return (0, api_1.post)("/execute/scrape-careers-page", { ...params });
+}

package/dist/index.d.ts

@@ -1,11 +1,15 @@
 export { configure } from "./api";
 export type { OrangesliceConfig } from "./api";
+export { findCareersPage, scrapeCareersPage } from "./careers";
+export type { FindCareersPageParams, FindCareersPageResult, ScrapeCareersPageParams, ScrapeCareersPageResult, ScrapeCareersPageJob } from "./careers";
 export { ctx } from "./ctx";
 export type { Spreadsheet, SpreadsheetListItem, SqlResult, SqlQueryResult, SqlActionResult, RowsAddResult } from "./ctx";
 export { linkedinSearch } from "./b2b";
 export type { LinkedInSearchParams, LinkedInSearchResponse } from "./b2b";
 export { crunchbaseSearch } from "./crunchbase";
 export type { CrunchbaseSearchParams } from "./crunchbase";
+export { executeOcean, oceanSearchCompanies, oceanSearchPeople, OCEAN_OPERATION_IDS } from "./ocean";
+export type { OceanOperationId, OceanCompaniesFilters, OceanPeopleFilters, OceanCompaniesSearchParams, OceanCompaniesSearchResponse, OceanCompanyResult, OceanCompanyMatch, OceanPeopleSearchParams, OceanPeopleSearchResponse, OceanPersonResult } from "./ocean";
 export { webSearch, webBatchSearch } from "./serp";
 export type { WebSearchQuery, WebSearchResult, WebSearchResponse, BatchWebSearchParams } from "./serp";
 export { generateObject } from "./generateObject";
@@ -25,11 +29,13 @@ export type { PersonLinkedinFindUrlParams, CompanyLinkedinFindUrlParams, PersonC
 import { runApifyActor } from "./apify";
 import { linkedinSearch } from "./b2b";
 import { browserExecute } from "./browser";
+import { findCareersPage, scrapeCareersPage } from "./careers";
 import { crunchbaseSearch } from "./crunchbase";
 import { personLinkedinEnrich, personLinkedinFindUrl, personContactGet, companyLinkedinEnrich, companyLinkedinFindUrl, companyGetEmployeesFromLinkedin, geoParseAddress, builtWithLookupDomain, builtWithRelationships, builtWithSearchByTech } from "./expansion";
 import { scrapeWebsite } from "./firecrawl";
 import { generateObject } from "./generateObject";
 import { googleMapsScrape } from "./googleMaps";
+import { oceanSearchCompanies, oceanSearchPeople } from "./ocean";
 import { webBatchSearch, webSearch } from "./serp";
 export declare const services: {
     crunchbase: {
@@ -42,6 +48,8 @@ export declare const services: {
             search: typeof linkedinSearch;
         };
         getEmployeesFromLinkedin: typeof companyGetEmployeesFromLinkedin;
+        findCareersPage: typeof findCareersPage;
+        scrapeCareersPage: typeof scrapeCareersPage;
     };
     person: {
         linkedin: {
@@ -75,6 +83,12 @@ export declare const services: {
     googleMaps: {
         scrape: typeof googleMapsScrape;
     };
+    ocean: {
+        search: {
+            companies: typeof oceanSearchCompanies;
+            people: typeof oceanSearchPeople;
+        };
+    };
     builtWith: {
         lookupDomain: typeof builtWithLookupDomain;
         relationships: typeof builtWithRelationships;

package/dist/index.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.services = exports.builtWithSearchByTech = exports.builtWithRelationships = exports.builtWithLookupDomain = exports.geoParseAddress = exports.companyGetEmployeesFromLinkedin = exports.companyLinkedinFindUrl = exports.companyLinkedinEnrich = exports.personContactGet = exports.personLinkedinFindUrl = exports.personLinkedinEnrich = exports.PREDICT_LEADS_OPERATION_IDS = exports.predictLeads = exports.executePredictLeads = exports.googleMapsScrape = exports.runApifyActor = exports.browserExecute = exports.scrapeWebsite = exports.generateObject = exports.webBatchSearch = exports.webSearch = exports.crunchbaseSearch = exports.linkedinSearch = exports.ctx = exports.configure = void 0;
+exports.services = exports.builtWithSearchByTech = exports.builtWithRelationships = exports.builtWithLookupDomain = exports.geoParseAddress = exports.companyGetEmployeesFromLinkedin = exports.companyLinkedinFindUrl = exports.companyLinkedinEnrich = exports.personContactGet = exports.personLinkedinFindUrl = exports.personLinkedinEnrich = exports.PREDICT_LEADS_OPERATION_IDS = exports.predictLeads = exports.executePredictLeads = exports.googleMapsScrape = exports.runApifyActor = exports.browserExecute = exports.scrapeWebsite = exports.generateObject = exports.webBatchSearch = exports.webSearch = exports.OCEAN_OPERATION_IDS = exports.oceanSearchPeople = exports.oceanSearchCompanies = exports.executeOcean = exports.crunchbaseSearch = exports.linkedinSearch = exports.ctx = exports.scrapeCareersPage = exports.findCareersPage = exports.configure = void 0;
 var api_1 = require("./api");
 Object.defineProperty(exports, "configure", { enumerable: true, get: function () { return api_1.configure; } });
+var careers_1 = require("./careers");
+Object.defineProperty(exports, "findCareersPage", { enumerable: true, get: function () { return careers_1.findCareersPage; } });
+Object.defineProperty(exports, "scrapeCareersPage", { enumerable: true, get: function () { return careers_1.scrapeCareersPage; } });
 var ctx_1 = require("./ctx");
 Object.defineProperty(exports, "ctx", { enumerable: true, get: function () { return ctx_1.ctx; } });
 var b2b_1 = require("./b2b");
 Object.defineProperty(exports, "linkedinSearch", { enumerable: true, get: function () { return b2b_1.linkedinSearch; } });
 var crunchbase_1 = require("./crunchbase");
 Object.defineProperty(exports, "crunchbaseSearch", { enumerable: true, get: function () { return crunchbase_1.crunchbaseSearch; } });
+var ocean_1 = require("./ocean");
+Object.defineProperty(exports, "executeOcean", { enumerable: true, get: function () { return ocean_1.executeOcean; } });
+Object.defineProperty(exports, "oceanSearchCompanies", { enumerable: true, get: function () { return ocean_1.oceanSearchCompanies; } });
+Object.defineProperty(exports, "oceanSearchPeople", { enumerable: true, get: function () { return ocean_1.oceanSearchPeople; } });
+Object.defineProperty(exports, "OCEAN_OPERATION_IDS", { enumerable: true, get: function () { return ocean_1.OCEAN_OPERATION_IDS; } });
 var serp_1 = require("./serp");
 Object.defineProperty(exports, "webSearch", { enumerable: true, get: function () { return serp_1.webSearch; } });
 Object.defineProperty(exports, "webBatchSearch", { enumerable: true, get: function () { return serp_1.webBatchSearch; } });
@@ -40,11 +48,13 @@ Object.defineProperty(exports, "builtWithSearchByTech", { enumerable: true, get:
 const apify_2 = require("./apify");
 const b2b_2 = require("./b2b");
 const browser_2 = require("./browser");
+const careers_2 = require("./careers");
 const crunchbase_2 = require("./crunchbase");
 const expansion_2 = require("./expansion");
 const firecrawl_2 = require("./firecrawl");
 const generateObject_2 = require("./generateObject");
 const googleMaps_2 = require("./googleMaps");
+const ocean_2 = require("./ocean");
 const predictLeads_2 = require("./predictLeads");
 const serp_2 = require("./serp");
 exports.services = {
@@ -57,7 +67,9 @@ exports.services = {
             enrich: expansion_2.companyLinkedinEnrich,
             search: b2b_2.linkedinSearch
         },
-        getEmployeesFromLinkedin: expansion_2.companyGetEmployeesFromLinkedin
+        getEmployeesFromLinkedin: expansion_2.companyGetEmployeesFromLinkedin,
+        findCareersPage: careers_2.findCareersPage,
+        scrapeCareersPage: careers_2.scrapeCareersPage
     },
     person: {
         linkedin: {
@@ -91,6 +103,12 @@ exports.services = {
     googleMaps: {
         scrape: googleMaps_2.googleMapsScrape
     },
+    ocean: {
+        search: {
+            companies: ocean_2.oceanSearchCompanies,
+            people: ocean_2.oceanSearchPeople
+        }
+    },
     builtWith: {
         lookupDomain: expansion_2.builtWithLookupDomain,
         relationships: expansion_2.builtWithRelationships,

package/dist/ocean.d.ts

@@ -0,0 +1,166 @@
+export declare const OCEAN_OPERATION_IDS: {
+    readonly searchCompanies: "search-companies";
+    readonly searchPeople: "search-people";
+};
+export type OceanOperationId = (typeof OCEAN_OPERATION_IDS)[keyof typeof OCEAN_OPERATION_IDS];
+export interface OceanCompaniesFilters {
+    lookalikeDomains?: string[];
+    minScore?: number;
+    companySizes?: Array<"0-1" | "2-10" | "11-50" | "51-200" | "201-500" | "501-1000" | "1001-5000" | "5001-10000" | "10001+">;
+    countries?: string[];
+    industries?: string[];
+    technologies?: string[];
+    technologyCategories?: string[];
+    keywords?: string[];
+    revenueRanges?: string[];
+    ecommerce?: boolean;
+}
+export interface OceanPeopleFilters {
+    seniorities?: string[];
+    departments?: string[];
+    jobTitleKeywords?: string[];
+    countries?: string[];
+    lookalikePeopleIds?: string[];
+}
+export interface OceanCompaniesSearchParams {
+    companiesFilters?: OceanCompaniesFilters;
+    size?: number;
+    from?: number;
+    searchAfter?: string;
+    includeDomains?: string[];
+    excludeDomains?: string[];
+}
+export interface OceanPhone {
+    country?: string;
+    number: string;
+    primary?: boolean;
+}
+export interface OceanMediaProfile {
+    url?: string;
+    handle?: string;
+    name?: string;
+}
+export interface OceanLocation {
+    primary?: boolean;
+    latitude?: number;
+    longitude?: number;
+    country?: string;
+    locality?: string;
+    region?: string;
+    postalCode?: string;
+    streetAddress?: string;
+    state?: string;
+}
+export interface OceanDepartmentSize {
+    department: string;
+    size: number;
+}
+export interface OceanHeadcountGrowth {
+    threeMonths?: number;
+    threeMonthsPercentage?: number;
+    sixMonths?: number;
+    sixMonthsPercentage?: number;
+    twelveMonths?: number;
+    twelveMonthsPercentage?: number;
+}
+export interface OceanCompanyResult {
+    domain: string;
+    name?: string;
+    legalName?: string;
+    description?: string;
+    countries?: string[];
+    primaryCountry?: string;
+    companySize?: string;
+    industryCategories?: string[];
+    industries?: string[];
+    linkedinIndustry?: string;
+    ecommerce?: boolean;
+    keywords?: string[];
+    employeeCountOcean?: number;
+    employeeCountLinkedin?: number;
+    revenue?: string;
+    yearFounded?: number;
+    emails?: string[];
+    phones?: OceanPhone[];
+    logo?: string;
+    technologies?: string[];
+    technologyCategories?: string[];
+    rootUrl?: string;
+    medias?: Record<string, OceanMediaProfile>;
+    locations?: OceanLocation[];
+    departmentSizes?: OceanDepartmentSize[];
+    headcountGrowth?: OceanHeadcountGrowth;
+    updatedAt?: string;
+}
+export interface OceanCompanyMatch {
+    company: OceanCompanyResult;
+    relevance?: string;
+}
+export interface OceanCompaniesSearchResponse {
+    total: number;
+    searchAfter?: string;
+    companies: OceanCompanyMatch[];
+    redirectMap?: Record<string, string>;
+}
+export interface OceanPersonExperience {
+    dateFrom?: string;
+    dateTo?: string;
+    description?: string;
+    domain?: string;
+    jobTitle?: string;
+}
+export interface OceanContactField {
+    address?: string;
+    status?: string;
+}
+export interface OceanPhoneField {
+    numbers?: string[];
+    status?: string;
+}
+export interface OceanPersonCompanySnapshot {
+    companySize?: string;
+    logo?: string;
+    name?: string;
+}
+export interface OceanPersonResult {
+    id: string;
+    domain?: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    country?: string;
+    state?: string;
+    location?: string;
+    linkedinUrl?: string;
+    seniorities?: string[];
+    departments?: string[];
+    photo?: string;
+    jobTitle?: string;
+    jobTitleEnglish?: string;
+    currentJobDescription?: string;
+    experiences?: OceanPersonExperience[];
+    summary?: string;
+    skills?: string[];
+    phone?: OceanPhoneField;
+    email?: OceanContactField;
+    updatedAt?: string;
+    company?: OceanPersonCompanySnapshot;
+}
+export interface OceanPeopleSearchParams {
+    companiesFilters?: OceanCompaniesFilters;
+    peopleFilters?: OceanPeopleFilters;
+    size?: number;
+    from?: number;
+    searchAfter?: string;
+    enableEmailSearch?: boolean;
+    enablePhoneSearch?: boolean;
+}
+export interface OceanPeopleSearchResponse {
+    total: number;
+    searchAfter?: string;
+    people: OceanPersonResult[];
+    redirectMap?: Record<string, string>;
+}
+export declare function executeOcean<T = unknown>(operationId: OceanOperationId, params?: Record<string, unknown>): Promise<T>;
+export declare function oceanSearchCompanies(params: OceanCompaniesSearchParams): Promise<OceanCompaniesSearchResponse>;
+export declare function oceanSearchPeople(params: OceanPeopleSearchParams): Promise<OceanPeopleSearchResponse>;

package/dist/ocean.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCEAN_OPERATION_IDS = void 0;
+exports.executeOcean = executeOcean;
+exports.oceanSearchCompanies = oceanSearchCompanies;
+exports.oceanSearchPeople = oceanSearchPeople;
+const api_1 = require("./api");
+exports.OCEAN_OPERATION_IDS = {
+    searchCompanies: "search-companies",
+    searchPeople: "search-people"
+};
+async function executeOcean(operationId, params) {
+    return (0, api_1.post)("/execute/oceanio", {
+        operationId,
+        params: params ?? {}
+    });
+}
+async function oceanSearchCompanies(params) {
+    return executeOcean(exports.OCEAN_OPERATION_IDS.searchCompanies, params);
+}
+async function oceanSearchPeople(params) {
+    return executeOcean(exports.OCEAN_OPERATION_IDS.searchPeople, params);
+}

package/docs/data-enrichement/index.md

@@ -5,12 +5,18 @@ description: Patterns for enriching company data, tech stack detection, hiring d
 
 # Data Enrichment
 
-Standard pattern: **Search → Scrape → Extract**
+Standard pattern: **Search/Domain → Scrape → Extract**
 
-1. `web.search` with `site:` to find subpages likely to contain the data
+1. Start with a company `domain` when you already have it, otherwise use `web.search` with `site:` to find relevant pages
 2. `scrape.website` to get page content as markdown
 3. `ai.generateObject` to extract structured fields
 
+For company enrichment/classification, prefer the website over LinkedIn `industry`.
+
+- LinkedIn `industry` is acceptable as lightweight lookup context
+- LinkedIn `industry` is too sparse/generic to be your main enrichment signal
+- Preferred workflow: `domain` -> `scrape.website` -> `ai.generateObject`
+
 ---
 
 ## Example: Does this law firm handle medical malpractice?
@@ -42,6 +48,8 @@ async function checkMedMalPractice(domain: string) {
 
 ---
 
+---
+
 ## When to Use
 
 | Use Search → Scrape → Extract    | Use `browser.execute` instead |

package/docs/integrations/gmail/createDraft.md

@@ -0,0 +1,54 @@
+# createDraft
+
+Create a Gmail draft without sending it yet.
+
+```typescript
+// Create a new draft
+const draft = await integrations.gmail.createDraft({
+   recipient_email: "jane@example.com",
+   subject: "Draft follow-up",
+   body: "Sharing a quick follow-up before I send this."
+});
+
+// Draft a reply in an existing thread
+await integrations.gmail.createDraft({
+   thread_id: "19bf77729bcb3a44",
+   body: "Thanks for the update. I will review this today."
+});
+```
+
+## Input
+
+| Parameter          | Type       | Required | Description                                  |
+| ------------------ | ---------- | -------- | -------------------------------------------- |
+| `recipient_email`  | `string`   | No       | Primary `To` recipient                       |
+| `extra_recipients` | `string[]` | No       | Additional `To` recipients                   |
+| `cc`               | `string[]` | No       | CC recipients                                |
+| `bcc`              | `string[]` | No       | BCC recipients                               |
+| `subject`          | `string`   | No       | Draft subject                                |
+| `body`             | `string`   | No       | Draft body content                           |
+| `message_body`     | `string`   | No       | Alternate body field accepted by some tools  |
+| `is_html`          | `boolean`  | No       | Set to `true` when `body` contains HTML      |
+| `attachment`       | `object`   | No       | Optional attachment payload                  |
+| `thread_id`        | `string`   | No       | Existing thread to draft a reply into        |
+| `from_email`       | `string`   | No       | Optional verified send-as alias              |
+| `user_id`          | `string`   | No       | Gmail user id (`\"me\"` by default)          |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: {
+    id?: string;
+    draft_id?: string;
+    message?: GmailMessage;
+  };
+  error?: string;
+}
+```
+
+## Notes
+
+- Creating a draft is a mutating action and should be used intentionally
+- If you pass `thread_id`, leave `subject` empty to stay in the existing thread

package/docs/integrations/gmail/fetchEmails.md

@@ -0,0 +1,50 @@
+# fetchEmails
+
+Fetch inbox messages or Gmail search results from the connected account.
+
+```typescript
+// Read the current inbox
+const inbox = await integrations.gmail.fetchEmails({
+   query: "in:inbox",
+   max_results: 10
+});
+
+// Search for unread emails from a sender
+const unread = await integrations.gmail.fetchEmails({
+   query: "in:inbox is:unread from:alice@example.com",
+   max_results: 25
+});
+```
+
+## Input
+
+| Parameter             | Type       | Required | Description                                           |
+| --------------------- | ---------- | -------- | ----------------------------------------------------- |
+| `query`               | `string`   | No       | Gmail search query such as `in:inbox is:unread`       |
+| `verbose`             | `boolean`  | No       | Fetch richer message details                          |
+| `ids_only`            | `boolean`  | No       | Only return message/thread identifiers                |
+| `label_ids`           | `string[]` | No       | Filter by Gmail label IDs                             |
+| `page_token`          | `string`   | No       | Pagination token from a previous call                 |
+| `max_results`         | `number`   | No       | Maximum messages to fetch in this page                |
+| `include_payload`     | `boolean`  | No       | Include payload/body data when available              |
+| `include_spam_trash`  | `boolean`  | No       | Include spam and trash                                |
+| `user_id`             | `string`   | No       | Gmail user id (`\"me\"` by default)                   |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: {
+    messages?: GmailMessage[];
+    nextPageToken?: string;
+    resultSizeEstimate?: number;
+  };
+  error?: string;
+}
+```
+
+## Notes
+
+- Results are not guaranteed to be sorted by recency, so sort client-side if order matters
+- For large mailboxes, fetch IDs first and then hydrate specific messages with `fetchMessageByMessageId(...)`

package/docs/integrations/gmail/fetchMessageByMessageId.md

@@ -0,0 +1,36 @@
+# fetchMessageByMessageId
+
+Fetch a single Gmail message by its Gmail API message ID.
+
+```typescript
+const message = await integrations.gmail.fetchMessageByMessageId({
+   message_id: "19b11732c1b578fd",
+   format: "full"
+});
+
+console.log(message.data?.subject);
+console.log(message.data?.threadId);
+```
+
+## Input
+
+| Parameter     | Type                                      | Required | Description                            |
+| ------------- | ----------------------------------------- | -------- | -------------------------------------- |
+| `message_id`  | `string`                                  | Yes      | Gmail API message ID                   |
+| `format`      | `\"minimal\" | \"full\" | \"raw\" | \"metadata\"` | No       | Response format                        |
+| `user_id`     | `string`                                  | No       | Gmail user id (`\"me\"` by default)    |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: GmailMessage;
+  error?: string;
+}
+```
+
+## Notes
+
+- Use real Gmail `message_id` values returned by Gmail list/search actions
+- `format: "full"` is best when you need headers, payload parts, or body data

package/docs/integrations/gmail/fetchMessageByThreadId.md

@@ -0,0 +1,37 @@
+# fetchMessageByThreadId
+
+Fetch all messages belonging to a Gmail thread.
+
+```typescript
+const thread = await integrations.gmail.fetchMessageByThreadId({
+   thread_id: "19bf77729bcb3a44"
+});
+
+for (const message of thread.data?.messages || []) {
+   console.log(message.subject);
+}
+```
+
+## Input
+
+| Parameter    | Type     | Required | Description                         |
+| ------------ | -------- | -------- | ----------------------------------- |
+| `thread_id`  | `string` | Yes      | Gmail API thread ID                 |
+| `user_id`    | `string` | No       | Gmail user id (`\"me\"` by default) |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: {
+    messages?: GmailMessage[];
+  };
+  error?: string;
+}
+```
+
+## Notes
+
+- Message order is not guaranteed, so sort by `internalDate` if you need oldest/newest order
+- Read threads first before calling `replyToThread(...)` so you have the correct `thread_id`

package/docs/integrations/gmail/getProfile.md

@@ -0,0 +1,37 @@
+# getProfile
+
+Read Gmail profile metadata for the connected account.
+
+```typescript
+const profile = await integrations.gmail.getProfile();
+
+console.log(profile.data?.emailAddress);
+console.log(profile.data?.messagesTotal);
+console.log(profile.data?.threadsTotal);
+```
+
+## Input
+
+| Parameter | Type     | Required | Description                         |
+| --------- | -------- | -------- | ----------------------------------- |
+| `user_id` | `string` | No       | Gmail user id (`\"me\"` by default) |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: {
+    emailAddress?: string;
+    messagesTotal?: number;
+    threadsTotal?: number;
+    historyId?: string;
+  };
+  error?: string;
+}
+```
+
+## Notes
+
+- This is a lightweight way to confirm which mailbox is connected
+- Mailbox totals are useful for diagnostics, health checks, and quick account introspection

package/docs/integrations/gmail/index.md

@@ -1,12 +1,29 @@
 ---
-description: Gmail email sending via Google integration
+description: Gmail inbox, drafts, threads, labels, profile, and email sending via Google integration
 ---
 
 # Gmail Integration
 
 Typed functions for Gmail actions powered by Orange Slice Google integrations.
 
-## Email
+## Write Actions
 
 - `integrations.gmail.sendEmail(input)` - Send an email through the connected Gmail account
+- `integrations.gmail.createDraft(input)` - Create a Gmail draft without sending it
+- `integrations.gmail.replyToThread(input)` - Reply inside an existing Gmail thread
 - Heavy rate limit: `sendEmail` is capped at **40 calls/day** per connected Gmail account
+- Mutating Gmail actions should be used intentionally because they require approval
+
+## Read Actions
+
+- `integrations.gmail.fetchEmails(input)` - Read inbox messages or Gmail search results
+- `integrations.gmail.fetchMessageByMessageId(input)` - Fetch one message by Gmail message ID
+- `integrations.gmail.fetchMessageByThreadId(input)` - Fetch all messages in a Gmail thread
+- `integrations.gmail.listLabels(input)` - List Gmail system and custom labels
+- `integrations.gmail.getProfile(input)` - Read Gmail profile metadata such as mailbox counts
+
+## Notes
+
+- Prefer `fetchEmails({ query: "in:inbox", max_results: 10 })` to read the current inbox
+- For large inbox scans, start with smaller `max_results` values or `ids_only: true`
+- Use real `messageId` and `threadId` values returned by Gmail read methods before drilling into a message or thread

package/docs/integrations/gmail/listLabels.md

@@ -0,0 +1,34 @@
+# listLabels
+
+List Gmail system labels and custom labels.
+
+```typescript
+const labels = await integrations.gmail.listLabels();
+
+for (const label of labels.data?.labels || []) {
+   console.log(label.id, label.name);
+}
+```
+
+## Input
+
+| Parameter | Type     | Required | Description                         |
+| --------- | -------- | -------- | ----------------------------------- |
+| `user_id` | `string` | No       | Gmail user id (`\"me\"` by default) |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: {
+    labels?: GmailLabel[];
+  };
+  error?: string;
+}
+```
+
+## Notes
+
+- Use this before any label-based workflow so you work with Gmail label IDs rather than display names
+- System labels and custom labels can both appear in the response

package/docs/integrations/gmail/replyToThread.md

@@ -0,0 +1,51 @@
+# replyToThread
+
+Reply inside an existing Gmail thread.
+
+```typescript
+await integrations.gmail.replyToThread({
+   thread_id: "19bf77729bcb3a44",
+   body: "Thanks for the note. I will get back to you tomorrow."
+});
+
+await integrations.gmail.replyToThread({
+   thread_id: "19bf77729bcb3a44",
+   body: "<p>Reviewed and approved.</p>",
+   is_html: true
+});
+```
+
+## Input
+
+| Parameter          | Type       | Required | Description                                  |
+| ------------------ | ---------- | -------- | -------------------------------------------- |
+| `thread_id`        | `string`   | Yes      | Gmail thread to reply within                 |
+| `body`             | `string`   | No       | Reply body                                   |
+| `message_body`     | `string`   | No       | Alternate body field accepted by some tools  |
+| `subject`          | `string`   | No       | Optional subject override                    |
+| `cc`               | `string[]` | No       | CC recipients                                |
+| `bcc`              | `string[]` | No       | BCC recipients                               |
+| `attachment`       | `object`   | No       | Optional attachment payload                  |
+| `is_html`          | `boolean`  | No       | Set to `true` when `body` contains HTML      |
+| `from_email`       | `string`   | No       | Optional verified send-as alias              |
+| `user_id`          | `string`   | No       | Gmail user id (`\"me\"` by default)          |
+
+## Output
+
+```typescript
+{
+  successful: boolean;
+  data?: {
+    id?: string;
+    messageId?: string;
+    threadId?: string;
+    labelIds?: string[];
+  };
+  error?: string;
+}
+```
+
+## Notes
+
+- This is a mutating action and should be used intentionally
+- Use a real `thread_id` from `fetchEmails(...)` or `fetchMessageByThreadId(...)`

package/docs/integrations/index.md

@@ -242,7 +242,7 @@ See [attio/](./attio/) for all available functions.
 
 ### Gmail
 
-Send emails from connected Google Gmail accounts.
+Read and write emails from connected Google Gmail accounts.
 
 ```typescript
 // Send a plain text email
@@ -260,6 +260,19 @@ await integrations.gmail.sendEmail({
    body: "<h2>Weekly Summary</h2><p>All systems operational.</p>",
    is_html: true
 });
+
+// Read the current inbox
+const inbox = await integrations.gmail.fetchEmails({
+   query: "in:inbox",
+   max_results: 10
+});
+
+// Create a draft without sending it
+await integrations.gmail.createDraft({
+   recipient_email: "john@example.com",
+   subject: "Draft follow-up",
+   body: "This is saved as a draft."
+});
 ```
 
 See [gmail/](./gmail/) for available functions.

package/docs/services/builtWith/index.md

@@ -9,8 +9,8 @@ description: Technographic data enrichment — discover what technologies, frame
 
 | Method          | Description                            | Credits |
 | --------------- | -------------------------------------- | ------- |
-| `lookupDomain`  | Get full technology stack for a domain | 75      |
-| `relationships` | Find related/connected domains         | 75      |
+| `lookupDomain`  | Get full technology stack for a domain | 20      |
+| `relationships` | Find related/connected domains         | 10      |
 | `searchByTech`  | Find companies using a specific tech   | 100     |
 
 ## Use Cases

package/docs/services/company/findCareersPage.md

@@ -0,0 +1,137 @@
+# Find Company Careers Page
+
+Resolve a company's official careers page and, when possible, return the underlying ATS jobs page instead.
+
+This is best when you have a company website or a specific company page and want the canonical place to browse jobs.
+
+## Input Parameters
+
+Provide **one** of:
+
+| Parameter | Type     | Required | Description                                                        |
+| --------- | -------- | -------- | ------------------------------------------------------------------ |
+| `website` | `string` | No       | Company website or page URL, e.g. `stripe.com` or `https://ro.co/` |
+| `url`     | `string` | No       | Alias for `website`                                                |
+
+**Optional:**
+
+| Parameter | Type     | Required | Description                          |
+| --------- | -------- | -------- | ------------------------------------ |
+| `timeout` | `string` | No       | Batch timeout override, e.g. `"30m"` |
+
+## Output
+
+```typescript
+{
+   inputUrl: string;
+   normalizedWebsiteUrl: string;
+   careerPageUrl: string | null;
+   pageType: "ats" | "official" | "not_found";
+   atsProvider: string | null;
+   detectionMethod:
+      | "input-ats"
+      | "homepage-ats-link"
+      | "homepage-careers-link"
+      | "deterministic-candidate"
+      | "candidate-ats-link"
+      | "embedded-ats"
+      | "candidate-redirect"
+      | "ats-unverified"
+      | "not-found";
+   checkedUrls: string[];
+}
+```
+
+## Examples
+
+### Basic Careers Lookup
+
+```typescript
+const result = await services.company.findCareersPage({
+   website: row.website
+});
+
+return result.careerPageUrl;
+```
+
+### Prefer ATS When Available
+
+```typescript
+const result = await services.company.findCareersPage({
+   website: "https://plaid.com"
+});
+
+return {
+   url: result.careerPageUrl,
+   type: result.pageType,
+   ats: result.atsProvider
+};
+```
+
+### Handle Not Found
+
+```typescript
+const result = await services.company.findCareersPage({
+   website: row.website
+});
+
+if (result.pageType === "not_found") {
+   return null;
+}
+
+return result.careerPageUrl;
+```
+
+### Debug Why a Result Was Chosen
+
+```typescript
+const result = await services.company.findCareersPage({
+   website: row.website
+});
+
+return {
+   careerPageUrl: result.careerPageUrl,
+   pageType: result.pageType,
+   atsProvider: result.atsProvider,
+   detectionMethod: result.detectionMethod,
+   checkedUrls: result.checkedUrls
+};
+```
+
+## What It Detects
+
+- Official careers pages like `https://company.com/careers`
+- Careers subdomains like `https://careers.company.com/`
+- ATS boards when discoverable from the company site
+- Embedded/wrapped ATS pages when the company site hosts the jobs UI directly
+
+Common ATS providers currently recognized include:
+
+- `ashby`
+- `greenhouse`
+- `lever`
+- `workday`
+- `icims`
+- `gem`
+- `kula`
+- `breezy`
+- `bamboohr`
+- `rippling`
+- `personio`
+- `phenom`
+- `smartrecruiters`
+- `successfactors`
+- `jobvite`
+- `recruitee`
+- `teamtailor`
+- `indeed`
+- `bestjobs`
+- `ejobs`
+
+## Key Rules
+
+1. **Pass the company website when possible** - homepage/company URLs usually produce the best canonical result.
+2. **ATS is preferred over generic careers pages** - if the company site clearly points to an ATS board, that board is returned.
+3. **Deep location/provider pages can still work** - the resolver attempts to collapse some subdomains and detail pages back to the parent organization's careers site.
+4. **`pageType: "official"` is still a success** - many enterprises host jobs on branded careers portals instead of a third-party ATS URL.
+5. **Use `checkedUrls` for debugging** - when a result looks wrong or missing, inspect the visited candidates.

package/docs/services/company/findCareersPage.ts

@@ -0,0 +1,37 @@
+interface FindCareersPageResult {
+  /** The original website or URL input */
+  inputUrl: string;
+  /** Canonical homepage/base URL used during discovery */
+  normalizedWebsiteUrl: string;
+  /** Best careers page URL found, or null when none was found */
+  careerPageUrl: string | null;
+  /** Whether the result points to an ATS board, an official careers page, or nothing */
+  pageType: "ats" | "official" | "not_found";
+  /** ATS provider when pageType is "ats" */
+  atsProvider: string | null;
+  /** How the page was discovered */
+  detectionMethod:
+    | "input-ats"
+    | "homepage-ats-link"
+    | "homepage-careers-link"
+    | "deterministic-candidate"
+    | "candidate-ats-link"
+    | "embedded-ats"
+    | "candidate-redirect"
+    | "ats-unverified"
+    | "not-found";
+  /** URLs checked while searching */
+  checkedUrls: string[];
+}
+
+/**
+ * Find the best careers page for a company website.
+ * Accepts a homepage URL/domain and returns either a canonical ATS board URL
+ * or an official careers page on the company site.
+ */
+type findCareersPage = (params: {
+    /** Company website or homepage URL */
+    website?: string;
+    /** Alias for website. Provide website or url. */
+    url?: string;
+  }) => Promise<FindCareersPageResult>;

package/docs/services/company/linkedin/enrich.md

@@ -56,7 +56,15 @@ interface B2BCompany {
 }
 ```
 
-> Note: company industry coverage in the LinkedIn B2B DB can be sparse. `industry` and `industries` may be `null`, generic, or missing even when the company record exists, so do not rely on them as the only company classification signal.
+> Important: LinkedIn company `industry` / `industries` coverage in the B2B DB is very sparse and often too weak for enrichment. These fields may be `null`, generic, stale, or missing even when the company record exists. Treat them as lookup metadata only, not as a high-confidence classification source for enrichment workflows.
+>
+> Preferred pattern for enrichment/classification:
+>
+> 1. Start from the company `domain` when available
+> 2. `services.scrape.website(...)` the company site or a relevant subpage
+> 3. `services.ai.generateObject(...)` to classify the company from the scraped content
+>
+> Use LinkedIn enrich primarily for fast lookup fields like company identity, URL, headcount, location, and description. Do **not** build industry enrichment pipelines that depend mainly on LinkedIn `industry`.
 
 ### Extended (`extended: true`) - `B2BCompanyExtended`
 
@@ -282,6 +290,44 @@ return {
 };
 ```
 
+### Classify Industry from Domain, Not LinkedIn
+
+If your goal is enrichment or categorization, prefer the company website over LinkedIn `industry`:
+
+```typescript
+const company = await services.company.linkedin.enrich({
+   domain: row.domain
+});
+
+const { markdown } = await services.scrape.website({
+   url: `https://${row.domain}`
+});
+
+const { object } = await services.ai.generateObject({
+   prompt: `
+Classify this company based on its website content.
+
+Do not rely on LinkedIn industry because it is sparse and often too generic.
+Use LinkedIn only as lightweight context for identity verification.
+
+Domain: ${row.domain}
+LinkedIn name: ${company?.name ?? "unknown"}
+LinkedIn description: ${company?.description ?? "unknown"}
+
+Website content:
+${markdown}
+   `,
+   schema: z.object({
+      industry: z.string().nullable(),
+      subindustry: z.string().nullable(),
+      businessModel: z.string().nullable(),
+      confidence: z.enum(["low", "medium", "high"])
+   })
+});
+
+return object;
+```
+
 ### Handle Missing Companies
 
 ```typescript

package/docs/services/company/scrapeCareersPage.md

@@ -0,0 +1,150 @@
+# Scrape ATS Careers Page
+
+Extract a standardized list of jobs from a supported **official ATS-hosted** careers page without using a browser when possible.
+
+This is best when you already have an ATS careers page URL, or when you first resolved one with `services.company.findCareersPage` and now want the actual jobs.
+
+## Input Parameters
+
+Provide **one** of:
+
+| Parameter        | Type     | Required | Description                                                                                     |
+| ---------------- | -------- | -------- | ----------------------------------------------------------------------------------------------- |
+| `careersPageUrl` | `string` | No       | Official ATS board URL or ATS job/detail URL, e.g. `https://job-boards.greenhouse.io/anthropic` |
+| `url`            | `string` | No       | Alias for `careersPageUrl`                                                                      |
+
+**Optional:**
+
+| Parameter | Type     | Required | Description                          |
+| --------- | -------- | -------- | ------------------------------------ |
+| `timeout` | `string` | No       | Batch timeout override, e.g. `"30m"` |
+
+## Output
+
+```typescript
+{
+   status: "success" | "unsupported_url" | "unsupported_provider";
+   inputUrl: string;
+   normalizedBoardUrl: string | null;
+   atsProvider: string | null;
+   companyName: string | null;
+   source: "api" | "html" | null;
+   totalJobs: number;
+   jobs: Array<{
+      id: string;
+      title: string;
+      url: string;
+      applyUrl: string | null;
+      location: string | null;
+      locations: string[];
+      department: string | null;
+      team: string | null;
+      employmentType: string | null;
+      workplaceType: string | null;
+      postedAt: string | null;
+      postedText: string | null;
+      requisitionId: string | null;
+   }>;
+   checkedUrls: string[];
+   supportedProviders: string[];
+   message: string | null;
+}
+```
+
+## Examples
+
+### Scrape Jobs From a Known ATS Board
+
+```typescript
+const result = await services.company.scrapeCareersPage({
+   careersPageUrl: "https://job-boards.greenhouse.io/anthropic"
+});
+
+return result.jobs;
+```
+
+### Resolve Then Scrape
+
+```typescript
+const careers = await services.company.findCareersPage({
+   website: row.website
+});
+
+if (!careers.careerPageUrl || careers.pageType !== "ats") {
+   return [];
+}
+
+const jobs = await services.company.scrapeCareersPage({
+   careersPageUrl: careers.careerPageUrl
+});
+
+return jobs.jobs;
+```
+
+### Return Lightweight Job Summaries
+
+```typescript
+const result = await services.company.scrapeCareersPage({
+   careersPageUrl: row.careers_page
+});
+
+return result.jobs.map((job) => ({
+   title: job.title,
+   location: job.location,
+   department: job.department,
+   url: job.url
+}));
+```
+
+### Handle Unsupported Providers Gracefully
+
+```typescript
+const result = await services.company.scrapeCareersPage({
+   careersPageUrl: row.careers_page
+});
+
+if (result.status !== "success") {
+   return {
+      status: result.status,
+      provider: result.atsProvider,
+      message: result.message
+   };
+}
+
+return result.totalJobs;
+```
+
+### Pass a Job Detail URL
+
+```typescript
+const result = await services.company.scrapeCareersPage({
+   careersPageUrl: "https://jobs.lever.co/mistral/2a357282-9d44-4b41-a249-c75ffe878ce2"
+});
+
+return {
+   board: result.normalizedBoardUrl,
+   jobs: result.totalJobs
+};
+```
+
+## Supported Providers
+
+Current browser-free implementations:
+
+- `ashby`
+- `breezy`
+- `greenhouse`
+- `lever`
+- `recruitee`
+- `rippling`
+- `smartrecruiters`
+- `workable`
+- `workday`
+
+## Key Rules
+
+1. **Use this for official ATS pages** - this endpoint is not meant for generic `company.com/careers` pages unless they are clearly hosted by a supported ATS.
+2. **Prefer resolving first when starting from a company website** - use `services.company.findCareersPage` to find the canonical ATS URL, then pass that into this scraper.
+3. **Job/detail URLs are okay** - supported ATS detail URLs are normalized back to the board before scraping.
+4. **Treat `unsupported_provider` as expected** - it means the input was a recognized ATS, but this scraper does not implement that provider yet.
+5. **Use `checkedUrls` for debugging** - when counts or mappings look off, inspect the URLs that were actually queried.

package/docs/services/index.md

@@ -1,7 +1,7 @@
 - **ai**: AI helpers (summaries, classifications, scoring).
 - **apify**: Run any of 10,000+ Apify actors for web scraping, social media, e-commerce, and more.
 - **browser**: Kernel browser automation - spin up cloud browsers, execute Playwright code, take screenshots. **Use this for scraping structured lists of repeated data** (e.g., product listings, search results, table rows) where you know the DOM structure. Also ideal for **intercepting network requests** to discover underlying APIs, then paginate those APIs directly in your code (faster & cheaper than clicking through pages). Perfect for JS-heavy sites that don't work with simple HTTP scraping.
-- **company**: company data (getting employees at the company, getting company data, getting open jobs).
+- **company**: company data (getting employees at the company, finding careers pages, getting company data, getting open jobs).
 - **crunchbase**: SQL search over the lean Crunchbase company table (`public.crunchbase_scraper_lean`) for startup prospecting.
 - **person**: finding a persons linkedin url, enriching it from linkedin, contact info, and searching for specific people / groups on linkedin
 - **geo**: parsing address

package/docs/services/person/linkedin/findUrl.md

@@ -1,4 +1,4 @@
-/\*_ Credits: 2 for the name + company search path, or 50 when reverse-email lookup is used. Charged only if a valid URL is returned. _/
+/\*_ Credits: 2 for the search path, or 50 when reverse-email lookup is used. Charged only if a valid URL is returned. _/
 
 /\*\*
 
@@ -15,6 +15,6 @@
   keyword?: string;
   /\*_ Location string (e.g., city, state, country) to narrow search results _/
   location?: string;
-  /\*_ Email address. If provided, the service tries name + company search first when possible, then falls back to reverse-email lookup. _/
+  /\*_ Email address. For work emails, the service may infer the name from the email, try search with that + the email domain, validate the result against B2B current-company domain data, then fall back to reverse-email lookup. _/
   email?: string;
   }) => Promise<string | undefined>;

package/docs/services/web/search.md

@@ -67,6 +67,22 @@ Web search returns URLs based on keywords, **not confirmed matches**. Scrape the
 
 ---
 
+## Company Subpage Discovery Rule
+
+To find pages on a company's own website, **never search Google by company name**. Always start from the verified domain and dork with `site:` plus `inurl:` hints.
+
+```ts
+await services.web.search({ query: "site:stripe.com inurl:team OR inurl:about OR inurl:careers" });
+```
+
+Never do this for subpage discovery:
+
+```ts
+await services.web.search({ query: '"Stripe" careers' });
+```
+
+---
+
 ## Parallel Query Permutations
 
 Always run multiple query variations for better coverage.
@@ -87,17 +103,17 @@ const allResults = await services.web.batchSearch({
 const uniqueLinks = [...new Set(allResults.flatMap((r) => r.results.map((x) => x.link)))];
 ```
 
-| Use Case       | Permutation Ideas                                        |
-| -------------- | -------------------------------------------------------- |
-| Person search  | Full name, initials, nicknames, with/without middle name |
-| Company search | Full name, abbreviations, domain, Inc/LLC variations     |
-| Title search   | CEO/Founder/Chief, VP/Director, formal/informal titles   |
+| Use Case       | Permutation Ideas                                                           |
+| -------------- | --------------------------------------------------------------------------- |
+| Person search  | Full name, initials, nicknames, with/without middle name                    |
+| Company search | Prefer verified domain first; use name variants only for off-site discovery |
+| Title search   | CEO/Founder/Chief, VP/Director, formal/informal titles                      |
 
 ---
 
 ## Google Dorking
 
-Use `site:` and `inurl:` to target specific platforms.
+Use `site:` and `inurl:` to target specific platforms and verified company domains.
 
 | Platform           | Dork                        | Example                                      |
 | ------------------ | --------------------------- | -------------------------------------------- |
@@ -107,20 +123,19 @@ Use `site:` and `inurl:` to target specific platforms.
 | Reddit             | `site:reddit.com`           | `site:reddit.com/r/sales "cold email"`       |
 
 ```ts
-// Find company employees with multiple dork variations
-const company = "Stripe";
+// Find company subpages from a verified domain
+const domain = "stripe.com";
 const queries = [
-   `"${company}" site:linkedin.com/in`,
-   `"${company}" CEO OR Founder site:linkedin.com/in`,
-   `"${company}" VP OR Director site:linkedin.com/in`,
-   `"${company}" Engineer site:linkedin.com/in`,
-   `stripe.com site:linkedin.com/in`
+   `site:${domain} inurl:team OR inurl:about OR inurl:leadership`,
+   `site:${domain} inurl:careers OR inurl:jobs`,
+   `site:${domain} inurl:blog OR inurl:news OR inurl:press`,
+   `site:${domain} inurl:contact OR inurl:locations`
 ];
 
 const results = await services.web.batchSearch({
    queries: queries.map((query) => ({ query }))
 });
-const profiles = [...new Set(results.flatMap((r) => r.results.map((x) => x.link)))];
+const subpages = [...new Set(results.flatMap((r) => r.results.map((x) => x.link)))];
 ```
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orangeslice",
-  "version": "2.1.5",
+  "version": "2.2.0",
   "description": "B2B LinkedIn database prospector - 1.15B profiles, 85M companies",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",