Praxa MCP Tools: Reference for All 12 Tool Definitions

PRAXA_MCP_TOOLS is the complete, authoritative list of MCP tools exposed by the Praxa Integration Gateway. You import this array from @praxa/mcp-contracts and register its entries with your MCP host — no manual schema authoring required. Every tool definition includes a name, human-readable description, inputSchema (JSON Schema draft 2020-12), MCP annotations, the gateway operationId, HTTP method and path, a requiredScope for OAuth authorization, and an idempotency field indicating whether the tool mutates state. Each tool object in the array has the following shape:

type PraxaMcpTool = {
  name: string;           // MCP tool name registered with the host
  description: string;    // Shown to the AI model as tool documentation
  inputSchema: object;    // JSON Schema for the tool's input object
  operationId: string;    // Corresponding gateway operation
  method: "GET" | "POST"; // HTTP method used by the gateway
  path: string;           // Gateway path, e.g. /v8/missions/{runId}
  requiredScope: string;  // OAuth scope the token must include
  idempotency: "required" | "safe-read"; // Mutation behaviour
  annotations: {
    readOnlyHint: boolean;
    destructiveHint: boolean;
    idempotentHint: boolean;
    openWorldHint: boolean;
  };
  pathArgument?: string;  // Input field interpolated into the path
};

Tool List

Tool Name	HTTP Method	Path	Required Scope	Idempotency
`aura_submit_intent`	POST	`/v8/intents`	`missions:write`	`required`
`aura_create_mission`	POST	`/v8/missions`	`missions:write`	`required`
`aura_get_mission`	GET	`/v8/missions/{runId}`	`missions:read`	`safe-read`
`aura_signal_mission`	POST	`/v8/missions/{runId}/signals`	`missions:write`	`required`
`aura_cancel_mission`	POST	`/v8/missions/{runId}/cancel`	`missions:write`	`required`
`aura_search_capabilities`	POST	`/v8/capabilities/search`	`capabilities:read`	`safe-read`
`aura_query_memory`	POST	`/v8/memory/query`	`memory:read`	`safe-read`
`aura_get_skill`	GET	`/v8/skills/{skillId}`	`skills:read`	`safe-read`
`aura_get_trace`	GET	`/v8/traces/{traceId}`	`traces:read`	`safe-read`
`aura_list_goals`	GET	`/v8/context-twin/goals`	`context:read`	`safe-read`
`aura_list_world_certificates`	GET	`/v8/world-model/certificates`	`world:read`	`safe-read`
`aura_get_coverage`	GET	`/v8/coverage`	`coverage:read`	`safe-read`

Tools with idempotency: "required" mutate gateway state and must receive one stable idempotencyKey per logical mutation. Reuse that same key when retrying the same mutation; use a different key for a different mutation. Tools with idempotency: "safe-read" are read-only and carry no idempotency requirement. Brief descriptions of what each tool does:

aura_submit_intent — Records natural-language intent for deterministic compilation. It implies no provider action or outcome.
aura_create_mission — Submits a goal to Praxa policy and broker orchestration. Grants no action authority on its own.
aura_get_mission — Reads an authoritative mission projection for a given run ID.
aura_signal_mission — Records a mission signal for policy-controlled handling; does not directly commit a provider effect.
aura_cancel_mission — Requests durable cancellation of a running mission.
aura_search_capabilities — Searches policy-eligible capability manifests before semantic ranking.
aura_query_memory — Queries purpose-filtered memory for the given compartment and purpose.
aura_get_skill — Reads a versioned governed skill and its evidence state.
aura_get_trace — Reads a redacted causal trace.
aura_list_goals — Lists purpose- and compartment-filtered context goals.
aura_list_world_certificates — Lists signed model capability certificates. Certificates grant zero action authority.
aura_get_coverage — Reads reference coverage evidence. Coverage is not a measure of production readiness.

Using `PRAXA_MCP_TOOLS`

Import PRAXA_MCP_TOOLS to iterate all tool definitions, or use praxaMcpTool to retrieve a single tool by name. Both are fully typed in TypeScript.

import { PRAXA_MCP_TOOLS, praxaMcpTool } from "@praxa/mcp-contracts";

// Iterate all tools — useful when registering with an MCP host
for (const tool of PRAXA_MCP_TOOLS) {
  console.log(tool.name, tool.requiredScope);
}

// Look up a specific tool
const createTool = praxaMcpTool("aura_create_mission");
console.log(createTool?.inputSchema);

A typical MCP server registration loop looks like this:

import { PRAXA_MCP_TOOLS, MCP_SERVER_NAME, MCP_SERVER_VERSION } from "@praxa/mcp-contracts";

// Framework-neutral pseudocode: adapt raw JSON Schema to your MCP host API.
const server = createMcpServerAdapter({
  name: MCP_SERVER_NAME,
  version: MCP_SERVER_VERSION,
});

for (const tool of PRAXA_MCP_TOOLS) {
  server.registerJsonSchemaTool({
    name: tool.name,
    description: tool.description,
    inputSchema: tool.inputSchema,
    annotations: tool.annotations,
  });
}

This loop is deliberately framework-neutral. MCP server libraries differ in how they accept raw JSON Schema; use the library’s documented schema adapter rather than assuming this pseudocode is a drop-in API.

Tool Name Convention

PRAXA_MCP_TOOLS, PraxaMcpTool, and praxaMcpTool are Praxa-branded TypeScript aliases. For backward-compatible protocol stability, every actual tool name remains prefixed with aura_, and the lookup helper expects that exact wire name. Do not rewrite the aura_* values when registering tools.

JSON-RPC Types

@praxa/mcp-contracts also exports TypeScript types for the JSON-RPC 2.0 message layer that MCP uses as its transport:

import type { JsonRpcRequest, JsonRpcResponse, JsonRpcId } from "@praxa/mcp-contracts";

function handleMessage(message: JsonRpcRequest): JsonRpcResponse {
  return {
    jsonrpc: "2.0",
    id: message.id ?? null,
    result: { /* ... */ },
  };
}

Use these types when building the request/response handling layer of your own MCP server implementation on top of these contracts.

Choose the smallest tool set

Read-only incident review
Governed mission creation
Purpose-filtered context

Enable aura_get_mission, aura_get_trace, aura_get_skill, and aura_get_coverage. Require the answer to cite returned run, trace, skill, and coverage identifiers. Keep every mutation disabled.

Enable aura_search_capabilities, aura_submit_intent, aura_create_mission, and aura_get_mission. Require host approval and one stable idempotency key for each mutation.

Enable aura_query_memory and optionally aura_list_goals. Derive the allowed compartment and purpose in trusted application code; never let the model broaden them.

Map tool failures correctly

Return invalid model-correctable arguments as a bounded tool error so the host can repair them. Stop immediately on missing auth, wrong scope, foreign tenant, revocation, or destructive-action denial. For an ambiguous mutation timeout, reconcile with exact replay or authoritative mission readback before allowing a new call.

Any tool with idempotency: "required" — aura_submit_intent, aura_create_mission, aura_signal_mission, and aura_cancel_mission — must receive a 16–128 character idempotencyKey matching ^[A-Za-z0-9][A-Za-z0-9._:-]{15,127}$. Create one key per logical mutation and reuse it for retries of that same mutation. A UUID v4 is a valid choice, but it is not the only accepted form. Never reuse a key for a different mutation.

See MCP use cases for workflow patterns and security and testing for the release matrix.

Integrate

Secure and operate

Praxa MCP Tools: Reference for All 12 Tool Definitions

Tool List

Using `PRAXA_MCP_TOOLS`

Tool Name Convention

JSON-RPC Types

Choose the smallest tool set

Map tool failures correctly

​Tool List

​Using PRAXA_MCP_TOOLS

​Tool Name Convention

​JSON-RPC Types

​Choose the smallest tool set

​Map tool failures correctly

Tool List

Using `PRAXA_MCP_TOOLS`

Tool Name Convention

JSON-RPC Types

Choose the smallest tool set

Map tool failures correctly