SDK Reference

import { Deepline } from 'deepline';

const ctx = await Deepline.connect();
const job = await ctx.play('prebuilt/person-linkedin-to-email').run({
  linkedin_url: 'https://www.linkedin.com/in/example-person/',
});
console.log(JSON.stringify(await job.get(), null, 2));

import deepline from 'deepline';

export const config = {
  description: 'Look up company',
  compatibility: { authoringContract: 'explicit-freshness' },
};

export default async function ({ domain }: { domain: string }) {
  const result = await deepline.tools.execute({
    id: 'company_lookup',
    tool: 'test_rate_limit',
    input: { key: domain },
    description: 'Check that the company lookup path can run for this domain.',
    staleAfterSeconds: 0,
  });

  return { domain, lookupStatus: result.status };
}

import deepline, { ProviderTransientError } from 'deepline';

export const config = {
  compatibility: { authoringContract: 'explicit-freshness' },
};

export default async function ({
  firstName,
  lastName,
  domain,
}: {
  firstName: string;
  lastName: string;
  domain: string;
}) {
  try {
    const primary = await deepline.tools.execute({
      id: 'primary_email',
      tool: 'hunter_email_finder',
      input: { first_name: firstName, last_name: lastName, domain },
      description: 'Try the primary email provider.',
      staleAfterSeconds: 0,
    });
    return { email: primary.extractedValues.email?.get() ?? null };
  } catch (error) {
    if (!(error instanceof ProviderTransientError)) throw error;
  }

  const fallback = await deepline.tools.execute({
    id: 'fallback_email',
    tool: 'leadmagic_email_finder',
    input: {
      first_name: firstName,
      last_name: lastName,
      domain,
      company_domain: domain,
    },
    description: 'Try the fallback email provider.',
    staleAfterSeconds: 0,
  });
  return { email: fallback.extractedValues.email?.get() ?? null };
}

import deepline from 'deepline';

type Account = {
  record_id: string;
};

export const config = {
  description: 'Refresh Attio account records on the scheduled cadence.',
  cron: {
    schedule: '0 9 * * *',
    timezone: 'America/New_York',
    input: { accounts: [], refreshExisting: true },
  },
  billing: { maxCreditsPerRun: 25 },
};

export default async function ({
  accounts,
}: {
  accounts: Account[];
  refreshExisting?: boolean;
}) {
  const rows = await deepline
    .dataset('account_refresh', accounts)
    .withColumn('company_record', (account) =>
      deepline.tools.execute({
        id: 'company_record',
        tool: 'attio_get_record',
        input: { object: 'companies', record_id: account.record_id },
        description: 'Read the Attio company record for this account.',
        staleAfterSeconds: 86_400,
      }),
    )
    .run({
      key: 'record_id',
      description: 'Read Attio company records, reusing results for one day.',
    });

  return { rows };
}

import deepline from 'deepline';

export const config = {
  description: 'Enrich inbound leads',
  compatibility: { authoringContract: 'explicit-freshness' },
  webhook: {
    auth: {
      type: 'standard-webhooks',
      headerFamily: 'standard',
      signingSecrets: ['INBOUND_RELAY_WEBHOOK_SECRET'],
      toleranceSeconds: 300,
    },
  },
};

export default async function (lead: {
  email: string;
  company_domain?: string;
  source?: string;
}) {
  const domain = lead.company_domain ?? lead.email.split('@')[1] ?? '';
  const company = await deepline.tools.execute({
    id: 'company_context',
    tool: 'test_rate_limit',
    input: { key: domain },
    description: 'Add company context before routing the inbound lead.',
    staleAfterSeconds: 0,
  });

  return {
    email: lead.email,
    domain,
    source: lead.source ?? 'webhook',
    company_status: company.status,
  };
}

import deepline from 'deepline';

export default async function (input: { domain: string }) {
  const company = await deepline.tools.execute({
    id: 'company',
    tool: 'company_lookup',
    input: { domain: input.domain },
    description: 'Look up the company.',
    staleAfterSeconds: 0,
  });
  return { company };
}

deepline plays run lookup.play.ts --input '{"domain":"stripe.com"}'
deepline plays run -e 'deepline.log("hello"); return { ok: true };'

withColumn<Name extends string, Value>( name: Name, resolver: ColumnResolver<OutputRow, Value>, ): DatasetBuilder< InputRow, OutputRow & Record<Name, Value> >;

withColumn<Name extends string, Value>( name: Name, definition: DatasetColumnDefinition< OutputRow, Value > & { readonly runIf: ( row: OutputRow, index: number, ) => boolean | Promise<boolean>; }, ): DatasetBuilder< InputRow, OutputRow & Record<Name, Value | null> >;

withColumn<Name extends string, Value>( name: Name, definition: DatasetColumnDefinition< OutputRow, Value >, ): DatasetBuilder< InputRow, OutputRow & Record<Name, Value> >;

withColumn<Name extends string, Value>( name: Name, resolver: StepResolver<OutputRow, Value> | RunnableStepProgram<unknown, Value>, options: StepOptions<OutputRow, Value>, ): DatasetBuilder< InputRow, OutputRow & Record<Name, Value | null> >;

run( options?: DatasetRunOptions<InputRow>, ): Promise<PlayDataset<OutputRow>>;