Node.js SDK

import { PredevAPI } from 'predev-api';

const client = new PredevAPI({ apiKey: process.env.PREDEV_API_KEY! });
const job = await client.fastSpecAsync({
  input: 'Build a team task manager with projects and assignees.',
  currentContext: 'Use TypeScript and preserve organization-scoped access.',
});
console.log('Save this ID:', job.specId);
const deadline = Date.now() + 600_000;

async function waitForSpec() {
  while (Date.now() < deadline) {
    const spec = await client.getSpecStatus(job.specId);
    if (spec.status === 'completed') return spec;
    if (spec.status === 'failed') {
      throw new Error(spec.errorMessage ?? 'Specification failed');
    }
    await new Promise(resolve => setTimeout(resolve, 5_000));
  }
  throw new Error('Polling deadline reached; retrieve the saved spec ID later.');
}

const spec = await waitForSpec();
console.log(spec.codingAgentSpecMarkdown);

const page = await client.findSpecs({ query: 'report|export', status: 'completed' });
for (const summary of page.specs) {
  console.log(summary._id, summary.input);
}
const balance = await client.getCreditsBalance();
console.log(balance.creditsRemaining);

import { readFile } from 'node:fs/promises';

const bytes = await readFile('requirements.pdf');
const upload = await client.fastSpecAsync({
  input: 'Create an implementation plan from these requirements.',
  file: new Blob([new Uint8Array(bytes)], { type: 'application/pdf' }),
  docURLs: ['https://www.postgresql.org/docs/current/'],
});
console.log(upload.specId);

const tasks = [{
  url: 'https://example.com',
  instruction: 'Extract the main page heading.',
  output: {
    type: 'object',
    properties: { heading: { type: 'string' } },
    required: ['heading'],
  },
}];
const browserJob = await client.browserAgent(tasks, { async: true });
console.log('Save this run ID:', browserJob.id);
const runDeadline = Date.now() + 600_000;

async function waitForRun() {
  while (Date.now() < runDeadline) {
    const run = await client.getBrowserAgent(browserJob.id);
    if (run.status === 'completed' || run.status === 'failed') return run;
    await new Promise(resolve => setTimeout(resolve, 5_000));
  }
  throw new Error('Polling deadline reached; retrieve the saved run later.');
}

const run = await waitForRun();
for (const task of run.results) {
  if (task?.status === 'SUCCESS') console.log(task.data);
  else console.error(task?.error ?? 'No successful result');
}

let sawDone = false;
for await (const message of client.browserAgent(tasks, { stream: true })) {
  if (message.event === 'task_event') {
    console.log(message.data.taskIndex, message.data.type);
  } else if (message.event === 'done') {
    sawDone = true;
    console.log(message.data.status, message.data.totalCreditsUsed);
  }
}
if (!sawDone) throw new Error('The stream ended before a final result arrived.');

const queue = await client.browserAgentStatus();
console.log(queue.total, queue.cap);

const runs = await client.listBrowserAgents({ limit: 20, status: 'completed' });
for (const summary of runs.batches) console.log(summary.id, summary.totalCreditsUsed);

const evidence = await client.getBrowserAgent(browserJob.id, { includeEvents: true });
console.log(evidence.status);

import {
  AuthenticationError,
  InsufficientCreditsError,
  PredevAPIError,
  QueueFullError,
  RateLimitError,
} from 'predev-api';

try {
  await client.listSpecs({ limit: 20 });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Check the API key and account access.');
  } else if (error instanceof RateLimitError) {
    console.error('Back off before retrying.');
  } else if (error instanceof PredevAPIError) {
    console.error(error.message);
  } else {
    throw error;
  }
}

try {
  await client.browserAgent(tasks, { async: true });
} catch (error) {
  if (error instanceof InsufficientCreditsError) {
    console.error(error.message, error.actionUrl);
  } else if (error instanceof QueueFullError) {
    console.error('Wait for tasks to finish before submitting more work.');
  } else if (error instanceof PredevAPIError) {
    console.error(error.message);
  } else {
    throw error;
  }
}