Developer Platform

Build agents.
Ship in hours.

A TypeScript SDK, REST API, and CLI scaffold tool for embedding enterprise AI agents into any stack. Run an agent in 3 lines of code.

npm install @eclips/sdk
API ReferenceGet API Key
20SDK methods
22API endpoints
3Webhook events
0SDK dependencies
Quickstart

From zero to a running agent in 4 steps.

bash
npm install @eclips/sdk
create-eclips-app

Scaffold a full project in seconds.

One command generates a production-ready project with three template options: an Express API with webhook handling, a Next.js dashboard with live polling, or a minimal Node.js script to test the API.

express-apiExpress server + HMAC webhook verification
nextjs-dashboardApp Router dashboard with realtime polling
agent-onlySingle TypeScript file, fastest to test
bash
npx create-eclips-app

No install needed. Requires Node.js ≥ 18.

Webhooks

Real-time events. HMAC-verified.

Pass a webhook_url when you start a run and eClips POSTs the result when it finishes. Every POST carries an X-eClips-Signature (HMAC-SHA256) so you know it's genuine.

typescript
import crypto from 'crypto';
import { EClipsClient } from '@eclips/sdk';

const client = new EClipsClient({ apiKey: process.env.ECLIPS_API_KEY! });

// Register a webhook — the signing secret is returned ONCE. Store it.
const { secret } = await client.createWebhook(
  'https://your-app.com/webhooks/eclips',
  ['run.completed', 'run.failed', 'run.triage_required'],
);

// Verify the request came from eClips
function verifySignature(rawBody: string, secret: string, sig: string) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return `sha256=${expected}` === sig;
}

// Express handler
app.post('/webhooks/eclips', express.raw({ type: '*/*' }), (req, res) => {
  const sig = req.headers['x-eclips-signature'] as string;
  if (!verifySignature(req.body.toString(), process.env.WEBHOOK_SECRET!, sig)) {
    return res.status(401).send('Unauthorized');
  }

  const event = JSON.parse(req.body.toString());

  switch (event.event) {
    case 'run.completed':
      console.log('Run finished:', event.run_id, event.data.output);
      break;
    case 'run.failed':
      console.error('Run failed:', event.run_id, event.data.error);
      break;
    case 'run.triage_required':
      // Notify Slack, email the team, etc.
      break;
  }

  res.json({ ok: true });
});

Delivered events

run.completed

Agent finished successfully

run.failed

Agent run encountered an error

run.triage_required

Agent needs human review

Batch processing

Run an agent over thousands of rows.

Submit many inputs in a single call with createBatch, then poll for progress — no orchestration loop to write yourself.

One call, many rows

POST /v1/batches with an array of inputs for the same agent

Progress counts

getBatch returns completed / total so you can show a progress bar

Cancellable

cancelBatch stops an in-flight batch at any time

Listable

listBatches returns the batch history for your org

typescript
// Run the same agent over many rows in one call
const batch = await client.createBatch('ap_specialist', [
  { invoice_id: 'INV-1001' },
  { invoice_id: 'INV-1002' },
  { invoice_id: 'INV-1003' },
]);

// Poll for progress, or cancel if needed
const status = await client.getBatch(batch.id);
console.log(status.completed, '/', status.total);
SDK Reference

Every method, at a glance.

Full TypeScript types included. See the complete API reference for parameter schemas, error codes, and rate limits.

client.run()Runs

Trigger an agent run, returns run_id immediately

client.runAndWait()Runs

Trigger + poll until terminal

client.waitForRun()Runs

Poll an existing run until terminal

client.getRun()Runs

Fetch a single run by id

client.listRuns()Runs

Run history ({ data, total, limit, offset })

client.listTriage()Triage

Pending human-in-the-loop items

client.approveTriage()Triage

Approve and continue the blocked run

client.rejectTriage()Triage

Reject an item with an optional reason

client.createWebhook()Webhooks

Register a URL + events; returns the secret once

client.listWebhooks()Webhooks

List registered webhook endpoints

client.deleteWebhook()Webhooks

Delete a webhook by id

client.listWorkflows()Workflows

List workflows for your org

client.triggerWorkflow()Workflows

Run a workflow with optional input

client.listWorkflowRuns()Workflows

List runs for a workflow

client.createBatch()Batch

Run an agent over many rows at once

client.getBatch()Batch

Fetch a batch with progress counts

client.listBatches()Batch

List batches for your org

client.cancelBatch()Batch

Cancel an in-flight batch

Full API Reference

Error handling

Every error is a typed class. Catch exactly what you need.

typescript
import {
  EClipsClient,
  AuthenticationError,
  RateLimitError,
  ValidationError,
  NotFoundError,
  TimeoutError,
} from '@eclips/sdk';

try {
  const result = await client.runAndWait('ap_specialist', task);
} catch (err) {
  if (err instanceof AuthenticationError) {
    // Invalid or missing API key
  } else if (err instanceof RateLimitError) {
    // err.retryAfter — seconds to wait
    await sleep(err.retryAfter ?? 60);
  } else if (err instanceof TimeoutError) {
    // Agent exceeded timeout — err.runId is still valid
    // Poll client.getRun(err.runId) to check progress
  } else if (err instanceof NotFoundError) {
    // Run, triage item, or webhook not found
  }
}
Ready when you are

Your Business,
On Autopilot.

From project management to quality systems to security — we build intelligent platforms that simulate, automate, and transform how your operations run.

30 minutes · No pitch deck · Live product walkthrough