PraxaClient SDK Reference — Methods, Options, and Examples

import { PraxaClient } from "@praxa/sdk";

const client = new PraxaClient({
  baseUrl: process.env.PRAXA_BASE_URL!,
  accessToken: async () => acquireShortLivedPraxaToken(),
});

createMission(
  input: CreateMissionRequest,
  idempotencyKey: string,
  signal?: AbortSignal,
): Promise<MissionProjection>

import { PraxaClient } from "@praxa/sdk";
import type { CreateMissionRequest } from "@praxa/sdk";

const input: CreateMissionRequest = {
  goalSpec: { task: "Prepare the weekly review" },
  resourceBudget: {
    maximumSteps: 12,
    maximumToolCalls: 8,
    maximumElapsedMs: 120_000,
    maximumParallelism: 2,
  },
};

const mission = await client.createMission(input, crypto.randomUUID());
console.log(mission.runId, mission.status); // e.g. "run_abc123" "running"

getMission(
  runId: string,
  signal?: AbortSignal,
): Promise<MissionProjection>

const mission = await client.getMission("run_abc123");
console.log(mission.status); // "running" | "waiting" | "succeeded" | "failed" | "cancelled"

missionEvents(
  runId: string,
  opts?: { lastEventId?: string; signal?: AbortSignal },
): AsyncGenerator<AuraSseEvent>

for await (const event of client.missionEvents(mission.runId)) {
  console.log(event.id, event.event, event.data);
}

signalMission(
  runId: string,
  signalName: string,
  payload: JsonValue,
  idempotencyKey: string,
  signal?: AbortSignal,
): Promise<JsonObject>

await client.signalMission(
  mission.runId,
  "user.approval",
  { approved: true, reviewedBy: "alice" },
  crypto.randomUUID(),
);

cancelMission(
  runId: string,
  reason: string,
  idempotencyKey: string,
  signal?: AbortSignal,
): Promise<JsonObject>

await client.cancelMission(
  mission.runId,
  "User requested early termination",
  crypto.randomUUID(),
);

searchCapabilities(
  requirement: CapabilityRequirement,
  signal?: AbortSignal,
): Promise<readonly JsonObject[]>

import type { CapabilityRequirement } from "@praxa/sdk";

const requirement: CapabilityRequirement = {
  actionFamily: "document.summarize",
  purpose: "Condense weekly status reports",
  targetType: "text/markdown",
};

const capabilities = await client.searchCapabilities(requirement);
for (const cap of capabilities) {
  console.log(cap["capabilityId"], cap["healthState"]);
}

queryMemory(
  query: MemoryQuery,
  signal?: AbortSignal,
): Promise<JsonObject>

import type { MemoryQuery } from "@praxa/sdk";

const query: MemoryQuery = {
  classes: ["document", "note"],
  compartment: "project-alpha",
  purpose: "Retrieve prior research for a status report",
  queryText: "weekly review findings Q3",
  limit: 10,
  maxContextTokens: 2048,
};

const results = await client.queryMemory(query);

listGoals(
  signal?: AbortSignal,
): Promise<readonly JsonObject[]>

const goals = await client.listGoals();
goals.forEach((goal) => console.log(goal));

listWorldModelCertificates(
  signal?: AbortSignal,
): Promise<readonly JsonObject[]>

const certs = await client.listWorldModelCertificates();
console.log(`${certs.length} certificate(s) registered`);

getSkill(
  skillId: string,
  signal?: AbortSignal,
): Promise<JsonObject>

const skill = await client.getSkill("skill_summarize_v2");
console.log(skill);

getTrace(
  traceId: string,
  signal?: AbortSignal,
): Promise<JsonObject>

const trace = await client.getTrace("trace_xyz789");
console.log(trace);

getReferenceCoverage(
  signal?: AbortSignal,
): Promise<JsonObject>

const coverage = await client.getReferenceCoverage();
console.log(coverage);

// Custom retry configuration
const client = new PraxaClient({
  baseUrl: process.env.PRAXA_BASE_URL!,
  accessToken: () => getToken(),
  maximumAttempts: 4,     // up to 4 total attempts
  retryBaseDelayMs: 200,  // 200ms, 400ms, 800ms between retries
});