TypeScript SDK

npm install @rkat/mobkit-sdk

import { MobKit, memory } from "@rkat/mobkit-sdk";

const rt = await MobKit.builder()
  .mob("config/mob.toml")
  .memory(memory.localJson())
  .persistentState(".mobkit/state")
  .consoleConfig("config/console.toml")
  .gateway("./target/debug/rpc_gateway")
  .build();

const handle = rt.mobHandle();
const status = await handle.status();
console.log("Running:", status.running);

const results = await handle.memoryQuery({
  entity: "identity:ops",
  topic: "deployment",
  store: "knowledge_graph",
});

const evaluation = await handle.schedulingEvaluate([
  {
    schedule_id: "daily-report",
    interval: "0 9 * * *",
    timezone: "Europe/Stockholm",
    jitter_ms: 0,
    enabled: true,
  },
], Date.now());

interface ModuleConfig {
  id: string;
  command: string;
  args: string[];
  restart_policy: "never" | "on_failure" | "always";
}

interface EventEnvelope<T> {
  event_id: string;
  source: string;
  timestamp_ms: number;
  event: T;
}

interface UnifiedEvent {
  kind: "agent" | "module";
  agentId?: string;
  eventType?: string;
  module?: string;
  payload?: unknown;
}

interface ScheduleDefinition {
  schedule_id: string;
  interval: string;
  timezone: string;
  jitter_ms: number;
  enabled: boolean;
}

// ESM
import { MobKit } from "@rkat/mobkit-sdk";

// CommonJS
const { MobKit } = require("@rkat/mobkit-sdk");

import { isRpcError, isMobEventsStaleError } from "@rkat/mobkit-sdk";

try {
  await handle.queryMobEvents({ afterSeq: cursor });
} catch (err) {
  if (isMobEventsStaleError(err)) {
    // err.afterCursor, err.latestCursor available
  } else if (isRpcError(err)) {
    console.error(`RPC ${err.method} failed: ${err.code}`);
  } else {
    throw err;
  }
}

import {
  MobEventsStaleError,
  MOB_EVENTS_STALE_CURSOR_CODE,
} from "@rkat/mobkit-sdk";

const events = await handle.queryMobEvents({
  eventTypes: ["flow_started", "flow_completed"],
  mobId: "home",
});
for (const e of events) {
  console.log(e.cursor, e.kind, e.runId, e.data);
}

// MobStructuralEvent.cursor is the meerkat ledger cursor — durable
// across mobkit restarts on persistent_state builds. Resume by
// passing the highest-seen cursor as afterSeq.
try {
  const more = await handle.queryMobEvents({ afterSeq: lastCursor });
} catch (err) {
  if (err instanceof MobEventsStaleError) {
    // Rewind to err.latestCursor and reconnect.
  }
}

// Flow runs with the full ledger projection
const runs = await handle.listRuns(); // or handle.listRuns("flow-id")
for (const run of runs) {
  console.log(run.runId, run.status, run.stepLedger.length);
}

// Create a draft from the blank template, validate, export
const draft = await handle.mobpackCreate({ template: "blank", name: "support-bot" });
const document = draft.row.document;

const validation = await handle.mobpackValidate(document);
console.log(validation.ok, validation.displayRows.length);

const pack = await handle.mobpackExport(document);
const archive = Buffer.from(pack.contentBase64, "base64"); // pack.filename, pack.mediaType

import { createJsonRpcHttpTransport } from "@rkat/mobkit-sdk";

const transport = createJsonRpcHttpTransport(endpoint, {
  timeoutMs: 5_000,
});