TypeScript SDK

npm install @nusomi/sdk

import { Nusomi } from "@nusomi/sdk";

const nusomi = new Nusomi({
  apiKey: process.env.NUSOMI_API_KEY,
  baseUrl: "https://api.nusomi.com", // override for self-hosted
  timeout: 30_000,
  fetch: customFetch, // optional; defaults to global fetch
});

nusomi.sessions.*
nusomi.events.*
nusomi.frames.*
nusomi.replay.*
nusomi.recovery.*
nusomi.memory.*
nusomi.exports.*
nusomi.workflows.*
nusomi.webhooks.*

nusomi.sessions.create(input): Promise<Session>
nusomi.sessions.get(id): Promise<Session>
nusomi.sessions.list(filter?): AsyncIterable<Session>
nusomi.sessions.start(id): Promise<Session>
nusomi.sessions.stop(id): Promise<Session>
nusomi.sessions.tag(id, name, data?): Promise<void>
nusomi.sessions.delete(id): Promise<void>

nusomi.events.query(sessionId, filter?): Promise<Event[]>
nusomi.events.stream(sessionId, opts?): AsyncIterable<Event>
nusomi.events.emit(sessionId, type, payload): Promise<void>

nusomi.frames.get(frameId): Promise<Frame>
nusomi.frames.image(frameId): Promise<Blob>
nusomi.frames.list(sessionId, filter?): AsyncIterable<Frame>

nusomi.replay.exact(sessionId, opts?): Promise<Replay>
nusomi.replay.guided(sessionId, opts?): Promise<Replay>
nusomi.replay.partial(sessionId, opts): Promise<Replay>

nusomi.recovery.from(sessionId, opts?): Promise<Replay>

nusomi.memory.paths(filter): Promise<Path[]>
nusomi.memory.outliers(filter): Promise<Session[]>
nusomi.memory.similar(sessionId, opts?): Promise<Session[]>
nusomi.memory.recoveryPoints(filter): Promise<Frame[]>
nusomi.memory.onDrift(workflow, handler): Subscription

nusomi.exports.create(input): Promise<Export>
nusomi.exports.get(id): Promise<Export>
nusomi.exports.list(filter?): AsyncIterable<Export>

nusomi.webhooks.list(): Promise<Webhook[]>
nusomi.webhooks.create(input): Promise<Webhook>
nusomi.webhooks.delete(id): Promise<void>

for await (const s of nusomi.sessions.list({ workflow: "process_invoice" })) {
  console.log(s.id, s.duration_ms);
}

import { NusomiError } from "@nusomi/sdk";

try {
  await nusomi.sessions.create({ workflow: "..." });
} catch (e) {
  if (e instanceof NusomiError) {
    console.error(e.code, e.message, e.requestId);
    if (e.code === "rate_limited") await sleep(e.retryAfterMs);
  }
}

const stream = nusomi.events.stream(sessionId, {
  types: ["click", "validation_error"],
});

for await (const ev of stream) {
  console.log(ev.t_ms, ev.type, ev.payload);
}

stream.close();

import type {
  Session,
  Frame,
  Event,
  ClickEvent,
  Replay,
  Export,
} from "@nusomi/sdk";

function handle(ev: Event) {
  switch (ev.type) {
    case "click":
      console.log(ev.payload.x, ev.payload.y); // typed
      break;
    case "validation_error":
      console.log(ev.payload.field, ev.payload.message);
      break;
  }
}

new Nusomi({
  apiKey: ...,
  logger: {
    debug: (...a) => myLogger.debug(...a),
    info:  (...a) => myLogger.info(...a),
    warn:  (...a) => myLogger.warn(...a),
    error: (...a) => myLogger.error(...a),
  },
});