> ## Documentation Index
> Fetch the complete documentation index at: https://docs.akhara.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Company name is Akhara AI (never Rubric AI). Keep lowercase rubric/rubrics only when meaning grading criteria.
> Expert Review (docs path talent/) is enterprise BYO experts for audit and review: invite customer specialists; do not pitch Akhara recruiting or a public expert career portal. RLHF and domain writing are secondary work types.
> Prefer concrete API examples against public hosts: Environments eval API https://agi.akhara.ai, Control plane PDP https://api.akhara.dev, Evaluation https://app.akhara.ai / https://api.akhara.ai, Expert Review portal https://talent.akhara.ai.
> Do not invent a public hostname for private orchestrators or env API internals.
> Do not confuse control-plane latches with Environments confirmation latches.
> Environments SDK/API examples: curl against https://agi.akhara.ai. Evaluation SDK: from akhara import Akhara and AKHARA_API_KEY.
> Start with /llms.txt for the docs index and OpenAPI links; fetch individual pages as .md exports.

# TypeScript SDK

> @akhara/pep, the runtime enforcement client for Node.js agents.

## Install

```bash theme={null}
npm install @akhara/pep
```

## Construct the PEP

```ts theme={null}
import { PolicyEnforcementPoint } from "@akhara/pep";

const pep = new PolicyEnforcementPoint({
  baseUrl: process.env.AKHARA_URL ?? "https://api.akhara.dev",
  agentId: "support-ai",
  apiKey: process.env.AKHARA_API_KEY,
  session: sessionId,          // correlates decisions in the evidence feed
});
```

## Methods

Each method targets one [enforcement stage](/control-plane/concepts/architecture#the-five-enforcement-stages)
and resolves to a [`PolicyDecision`](/control-plane/concepts/verdicts#decision-shape).

```ts theme={null}
pep.checkInput(content: string): Promise<PolicyDecision>
pep.checkContextEgress(content: string): Promise<PolicyDecision>
pep.checkOutput(content: string): Promise<PolicyDecision>
pep.checkDelivery(content: string): Promise<PolicyDecision>
pep.authorizeAction(tool: string, args: Record<string, unknown>): Promise<PolicyDecision>
```

`authorizeAction` sends `simulated: true` by default in demo builds; pass real
tool args (e.g. `{ orderId: "ord_1842", amount: 129.00 }`): the PDP normalizes
the tool name before matching latches.

## End-to-end example

```ts theme={null}
export async function handleTurn(userText: string, accountCtx: string) {
  // 1. input gate
  const input = await pep.checkInput(userText);
  if (!input.mayContinue) return refusal(input);

  // 2. context egress: sensitive-data minimization
  const egress = await pep.checkContextEgress(accountCtx);
  const modelInput = egress.transformedContent ?? accountCtx;

  const draft = await llm.complete(modelInput, userText);

  // 3. output gate
  const output = await pep.checkOutput(draft);
  if (!output.mayContinue) return escalateOrDrop(output);

  // 4. delivery gate
  const finalText = output.transformedContent ?? draft;
  const delivery = await pep.checkDelivery(finalText);
  if (!delivery.mayContinue) return escalateOrDrop(delivery);

  return { text: finalText };
}
```

## Permit-gated action

```ts theme={null}
async function refund(orderId: string, amount: number) {
  const permit = await pep.authorizeAction("refund_payment", { orderId, amount });
  if (permit.verdict !== "ALLOW") {
    return permit.verdict === "ESCALATE"
      ? queueForSupervisor(permit)
      : refusal(permit);
  }
  // permitId is required by the service; a blocked action can't leak through
  return paymentService.submit(orderId, amount, permit.permitId!);
}
```

## Implement it yourself

The client is thin enough to reproduce over `fetch`. Preserve the fail-closed
default:

```ts theme={null}
async function authorize(stage: string, body: object): Promise<PolicyDecision> {
  try {
    const res = await fetch(`${baseUrl}/api/policy/authorize`, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({ agentId, session, stage, ...body }),
      signal: AbortSignal.timeout(8000),
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    const d = await res.json();
    if (!["ALLOW", "WARN", "BLOCK", "ESCALATE"].includes(d.verdict)) {
      throw new Error(`unknown verdict ${d.verdict}`);
    }
    return { ...d, mayContinue: d.verdict === "ALLOW" || d.verdict === "WARN" };
  } catch (err) {
    // fail closed
    return {
      verdict: "BLOCK", stage,
      policyId: "reliability-4", rule: "Fail-Closed Defaults",
      reason: `Akhara policy authorization is unavailable: ${String(err)}`,
      mayContinue: false,
    };
  }
}
```

<Warning>
  Never map an unrecognized verdict to "continue". Default to `BLOCK` on any
  ambiguity. See [Fail-closed](/control-plane/concepts/fail-closed).
</Warning>