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 { definePlay } from 'deepline';

type Input = {
  domain: string;
};

type Output = {
  domain: string;
  lookupStatus: string;
};

export default definePlay(
  'docs-company-lookup',
  async (ctx, input: Input): Promise<Output> => {
    const result = await ctx.tools.execute({
      id: 'company_lookup',
      tool: 'test_rate_limit',
      input: {
        key: input.domain,
      },
      description:
        'Check that the company lookup path can run for this domain.',
      staleAfterSeconds: 0,
    });
    return {
      domain: input.domain,
      lookupStatus: result.status,
    };
  },
  {
    description: 'Look up company',
    compatibility: { authoringContract: 'explicit-freshness' },
  },
);

import { definePlay, ProviderTransientError } from 'deepline';

type Input = {
  firstName: string;
  lastName: string;
  domain: string;
};

export default definePlay(
  'docs-provider-fallback',
  async (ctx, input: Input) => {
    try {
      const primary = await ctx.tools.execute({
        id: 'primary_email',
        tool: 'hunter_email_finder',
        input: {
          first_name: input.firstName,
          last_name: input.lastName,
          domain: input.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 ctx.tools.execute({
      id: 'fallback_email',
      tool: 'leadmagic_email_finder',
      input: {
        first_name: input.firstName,
        last_name: input.lastName,
        domain: input.domain,
        company_domain: input.domain,
      },
      description: 'Try the fallback email provider.',
      staleAfterSeconds: 0,
    });
    return { email: fallback.extractedValues.email?.get() ?? null };
  },
  {
    compatibility: { authoringContract: 'explicit-freshness' },
    description:
      'Find an email with one safe provider-failure fallback and loud terminal errors.',
  },
);

import { definePlay } from 'deepline';

type Account = {
  record_id: string;
};

export default definePlay(
  'docs-nightly-account-refresh',
  async (ctx, input: { accounts: Account[]; refreshExisting?: boolean }) => {
    const rows = await ctx
      .dataset('account_refresh', input.accounts)
      .withColumn('company_record', (account, rowCtx) =>
        rowCtx.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 };
  },
  {
    description: 'Refresh Attio account records on the scheduled cadence.',
    cron: {
      schedule: '0 9 * * *',
      timezone: 'America/New_York',
      input: { accounts: [], refreshExisting: true },
    },
    billing: {
      maxCreditsPerRun: 25,
    },
  },
);

import { definePlay } from 'deepline';

type InboundLead = {
  email: string;
  company_domain?: string;
  source?: string;
};

export default definePlay(
  'docs-inbound-lead-webhook',
  async (ctx, input: InboundLead) => {
    const domain = input.company_domain ?? input.email.split('@')[1] ?? '';
    const company = await ctx.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: input.email,
      domain,
      source: input.source ?? 'webhook',
      company_status: company.status,
    };
  },
  {
    description: 'Enrich inbound leads',
    compatibility: { authoringContract: 'explicit-freshness' },
    webhook: {
      auth: {
        type: 'standard-webhooks',
        headerFamily: 'standard',
        signingSecrets: ['INBOUND_RELAY_WEBHOOK_SECRET'],
        toleranceSeconds: 300,
      },
    },
  },
);

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>>;