EVE + Generic TypeScript (Supported)

Compatibility: SUPPORTED — the generic TypeScript client is the validated integration surface for Node and the browser verifier. It governs tool calls via hosted mode and ships a browser-safe offline evidence verifier. The TypeScript SDK never signs and holds no secrets.

Use the generic TypeScript client when you control the tool call site in a Node service and can route the call through governance before the side effect.

What you get

• Deterministic policy decision (ALLOW / BLOCK / MODIFY) before the tool executes, computed by deterministic policy code with no LLM in the decision path.
• Offline, independent evidence verification in Node or the browser — verify a signed record without trusting the EVE server (ECDSA P-384 public key required for asymmetric verification).
• Fail-closed behavior: a service error results in BLOCK, never a silent permissive fallback.

Install

The package eve-ai-governance (version 0.3.1, ESM, Node >= 18) is published on npm (npm install eve-ai-governance). It is an offline verification library — its exports are verifier functions such as verifyDecisionCertificate, verifyChain, verifyBundle, and verifyHmac. There is no enforcement client; enforce from Node via the REST API:

import { verifyDecisionCertificate } from "eve-ai-governance";

Enforcement runs over the hosted service via the REST API (embedded in-process governance is Python/service-only). The npm package itself performs no enforcement — it only verifies signed evidence offline.

Govern a tool call

// eve-ai-governance is verification-only; enforce from Node via the REST API.
const res = await fetch("https://api.eveaicore.com/v1/decisions/evaluate", {
  method: "POST",
  headers: { Authorization: "Bearer eve_sk_...", "Content-Type": "application/json" },
  body: JSON.stringify({
    request_id: "req-001", tenant_id: "org_123",
    proposed_action: { type: "issue_refund", account_id: "acct_1042", amount_cents: 5000 },
    model_output: { decision: "approve", confidence: 0.85 },
    context: {},
    policy_set: "refunds_v1",
  }),
});
const { decision, risk } = await res.json();

if (decision.status === "BLOCKED") {
  // the underlying tool is not called
  console.log(`BLOCKED (risk ${risk.level})`);
} else {
  await issueRefund({ accountId: "acct_1042", amountCents: 5000 });
}

Verify the evidence

import { verifyDecisionRecord } from "eve-ai-governance";

// Offline-verify a signed decision record (e.g. the signed_governance
// record from a hosted governed decision).
const report = await verifyDecisionRecord(signedRecord);
if (!report.valid) throw new Error("evidence rejected");

Verification confirms integrity, signature, and schema. It proves the record is authentic and unaltered — not that the decision was correct.

Readiness

• Generic TypeScript package eve-ai-governance 0.3.1: SUPPORTED for its verifier surface (offline evidence verification; enforcement is via the REST API); the SDK core is RELEASE CANDIDATE WITH EXCLUSIONS.
• Offline / cross-language evidence verification: SUPPORTED per the claims registry.
• CoreGuard deterministic evaluation: PILOT_READY.

Limitations

• ESM only; Node >= 18.
• Embedded mode is unsupported in TypeScript (SDK_TS_EMBEDDED_UNSUPPORTED); embedded governance is the Python service. The TS client never signs and holds no secrets.
• Hosted mode requires a reachable endpoint.
• The client governs the call site you route through it; a direct call to the underlying tool that bypasses the client is not intercepted. Server-side, use a gateway/sidecar or a restricted tool registry so tools are only reachable through the governed path.
• Independent verification requires the ECDSA P-384 public key; the HMAC fallback is symmetric and not independently verifiable. Verification attests authenticity, not decision correctness.