TypeScript SDK

const history = await session.history();
const image = history.messages
  .flatMap((message) => [...message.blocks])
  .find((block) => block.blockType === "image");
const payload = image?.blobId ? await client.getBlob(image.blobId) : undefined;

import {
  LiveChannel,
  MeerkatClient,
  isLiveWebrtcBootstrap,
} from "@rkat/sdk";

async function runLiveWebrtc(
  completedOfferSdp: string,
  installRemoteAnswer: (answerSdp: string) => Promise<void>,
  imageDataBase64: string,
): Promise<void> {
  const client = new MeerkatClient();
  await client.connect({ liveWebrtc: true });

  const session = await client.createSession("Open a live channel", {
    model: "gpt-realtime-2",
    provider: "openai",
  });
  const channel = LiveChannel.session(client, session.id, {
    turningMode: "explicit_commit",
    transport: "webrtc",
    seedMaxChars: 24_000,
  });

  const openResult = await channel.open();
  if (!isLiveWebrtcBootstrap(openResult.transport)) {
    throw new Error("server did not return the requested WebRTC bootstrap");
  }
  const answered = await client.liveWebrtcAnswer({
    channel_id: openResult.channel_id,
    token: openResult.transport.token,
    offer_sdp: completedOfferSdp,
  });
  await installRemoteAnswer(answered.answer_sdp);
  await channel.sendInputImage(
    "turn-42-diagram",
    "image/png",
    imageDataBase64,
  );
  // Promise resolution is queue acceptance. Wait for user_content_committed
  // carrying "turn-42-diagram" before treating the image as durable context.
  await channel.sendInputText("hello");
  await channel.commitInput("text");
  await channel.close();
  await client.close();
}

new MeerkatClient(rkatPath?: string)

async connect(options?: ConnectOptions): Promise<this>

export interface ConnectOptions {
  realmId?: string;
  instanceId?: string;
  realmBackend?: "jsonl" | "memory" | "sqlite";
  isolated?: boolean;
  stateRoot?: string;
  contextRoot?: string;
  userConfigRoot?: string;
  liveWs?: boolean;
  liveWebrtc?: boolean;
  liveToolTimeoutMs?: number;
}

async createSession(
  prompt: string | ContentBlock[],
  options?: SessionOptions,
): Promise<Session>

const session = await client.createSession("Summarise this project", {
  model: "claude-sonnet-4-6",
  systemPrompt: "You are a senior engineer.",
  maxTokens: 4096,
});

console.log(session.text);
console.log(session.usage.inputTokens);

createSessionStreaming(
  prompt: string | ContentBlock[],
  options?: SessionOptions,
): EventStream

import { isTextDelta } from "@rkat/sdk";

const stream = client.createSessionStreaming("Explain async/await in TypeScript");

for await (const event of stream) {
  if (isTextDelta(event)) {
    process.stdout.write(event.delta);
  }
}

console.log("\nTokens used:", stream.result.usage.outputTokens);

interface SessionOptions {
  injectedContext?: readonly ContentInput[];
  transientTurnContext?: string;
  model?: string;
  provider?: string;
  authBinding?: WireAuthBindingRef;
  systemPrompt?: string | { action: "disable" };
  maxTokens?: number;
  outputSchema?: Record<string, unknown>;
  structuredOutputRetries?: number;
  hooksOverride?: Record<string, unknown>;
  enableBuiltins?: boolean;
  enableShell?: boolean;
  enableMemory?: boolean;
  enableSchedule?: boolean;
  enableWorkGraph?: boolean;
  enableMob?: boolean;
  enableWebSearch?: boolean;
  toolFilter?: WireToolFilter;
  keepAlive?: boolean;
  commsName?: string;
  peerMeta?: Record<string, unknown>;
  budgetLimits?: Record<string, unknown>;
  providerParams?: Record<string, unknown>;
  preloadSkills?: SkillRef[];
  skillRefs?: SkillRef[];
  labels?: Record<string, string>;
  additionalInstructions?: string[];
  appContext?: unknown;
  shellEnv?: Record<string, string>;
  externalTools?: Record<string, unknown>[];
}

session.id    // stable UUID string
session.ref   // optional human-readable reference (string | undefined)

session.text            // assistant text from the last turn
session.usage           // RunResult usage: the session-cumulative token total
session.turns           // number of LLM turns in the last run
session.toolCalls       // number of tool calls in the last run
session.structuredOutput // structured output from the last run (unknown | undefined)
session.lastResult      // the full RunResult object

async turn(
  prompt: string | ContentBlock[],
  options?: {
    injectedContext?: readonly ContentInput[];
    transientTurnContext?: string;
    skillRefs?: SkillRef[];
    turnToolOverlay?: TurnToolOverlay;
    additionalInstructions?: string[];
    keepAlive?: boolean;
    model?: string;
    provider?: string;
    selfHostedServerId?: string;
    maxTokens?: number;
    systemPrompt?: string;
    outputSchema?: Record<string, unknown>;
    structuredOutputRetries?: number;
    providerParams?: Record<string, unknown>;
  },
): Promise<RunResult>

const result = await session.turn("Now explain the second point in more detail");
console.log(result.text);

stream(
  prompt: string | ContentBlock[],
  options?: {
    injectedContext?: readonly ContentInput[];
    transientTurnContext?: string;
    skillRefs?: SkillRef[];
    turnToolOverlay?: TurnToolOverlay;
    additionalInstructions?: string[];
    keepAlive?: boolean;
    model?: string;
    provider?: string;
    selfHostedServerId?: string;
    maxTokens?: number;
    systemPrompt?: string;
    outputSchema?: Record<string, unknown>;
    structuredOutputRetries?: number;
    providerParams?: Record<string, unknown>;
  },
): EventStream

import { isTextDelta } from "@rkat/sdk";

for await (const event of session.stream("Elaborate on point three")) {
  if (isTextDelta(event)) {
    process.stdout.write(event.delta);
  }
}
// session.text is now updated

async interrupt(): Promise<void>

async archive(): Promise<void>

async invokeSkill(skillRef: SkillRef, prompt: string): Promise<RunResult>

const matches = (await client.listSkills()).filter(
  (entry) => entry.is_active && entry.key.skill_name === "code-review",
);
const [skill] = matches;
if (!skill || matches.length !== 1) {
  throw new Error("Expected one active code-review skill; select a source UUID if ambiguous.");
}
const result = await session.invokeSkill(
  { sourceUuid: skill.key.source_uuid, skillName: skill.key.skill_name },
  "Review this function for safety issues",
);

async send(command: CommsCommand): Promise<CommsSendReceipt>
async peers(): Promise<PeerDirectoryEntry[]>

const matches = (await session.peers()).filter(
  (peer) => peer.name === "agent-b" && peer.sendable_kinds.includes("peer_message"),
);
const [peer] = matches;
if (!peer || matches.length !== 1) {
  throw new Error("Expected one sendable agent-b peer; select a peer_id if ambiguous.");
}
await session.send({
  kind: "peer_message",
  to: peer.peer_id,
  body: "Hello!",
  handling_mode: "queue",
});

async subscribeEvents(): Promise<EventSubscription<AgentEventEnvelope>>

const sub = await session.subscribeEvents();
for await (const envelope of sub) {
  console.log(envelope.payload.type, envelope.seq);
}
await sub.close();

// Read all capabilities
console.log(client.capabilities);
// [{ id: "sessions", description: "...", status: "Available" }, ...]

// Check a single capability
if (client.hasCapability("comms")) {
  const matches = (await session.peers()).filter(
    (peer) => peer.name === "agent-b" && peer.sendable_kinds.includes("peer_message"),
  );
  const [peer] = matches;
  if (!peer || matches.length !== 1) {
    throw new Error("Expected one sendable agent-b peer; select a peer_id if ambiguous.");
  }
  await session.send({
    kind: "peer_message",
    to: peer.peer_id,
    body: "Hi",
    handling_mode: "queue",
  });
}

// Assert and throw if unavailable
client.requireCapability("skills");  // throws CapabilityUnavailableError if not available

const config = await client.getConfig();
const modelUpdate = await client.patchConfig(
  { agent: { model: "claude-opus-4-8" } },
  { expectedGeneration: config.generation },
);
const updated = await client.patchConfig(
  { max_tokens: 8192 },
  { expectedGeneration: modelUpdate.generation },
);
console.log(updated.config);