agentfences 0.0.0-stage → 0.4.0

package/dist/core.js

@@ -0,0 +1,362 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { FencesClient } from "./client.js";
+import * as control from "./control.js";
+import { AgentQuarantined, FencesStop } from "./errors.js";
+import * as events from "./events.js";
+import { costOf, setCustomPrices } from "./pricing.js";
+const SUMMARY = "I'll summarize what I found so far.";
+const WRAP_UP = "Stop your current task immediately and summarize what you have found or completed so far.";
+const money = (x) => `$${x.toFixed(4)}`;
+const count = (n) => n.toLocaleString("en-US");
+function breachResult(type, run) {
+    const spent = run.costUsd, limit = run.budgetUsd ?? 0;
+    const text = {
+        budget_exceeded: [`I've reached my budget limit (spent ${money(spent)} of ${money(limit)}). ${SUMMARY}`,
+            `You have reached your budget limit (${money(spent)} of ${money(limit)} spent). Stop your current task immediately ` +
+                "and provide a clear summary of what you have found or completed so far. Tell the user you stopped due to budget and what you accomplished."],
+        iteration_limit: [`I've reached my iteration limit (${run.iterations} steps). ${SUMMARY}`,
+            `You have reached your iteration limit (${run.iterations} steps). ${WRAP_UP} Tell the user you stopped due to the iteration limit.`],
+        time_limit: [`I've reached my time limit (${run.durationMs}ms). ${SUMMARY}`,
+            `You have reached your time limit. ${WRAP_UP} Tell the user you stopped due to the time limit.`],
+        token_limit: [`I've reached my token limit (${count(run.tokensUsed)} tokens). ${SUMMARY}`,
+            `You have reached your token limit (${count(run.tokensUsed)} tokens used). ${WRAP_UP} Tell the user you stopped due to the token limit.`],
+        stopped_by_user: [`I was stopped from the Fences dashboard. ${SUMMARY}`,
+            `A person stopped this run from the Fences dashboard. ${WRAP_UP} Tell the user you were stopped by an operator.`],
+        key_daily_budget: [`My daily spending cap has been reached. ${SUMMARY}`,
+            `Your daily spending cap, across all of your runs, has been reached. ${WRAP_UP} Tell the user you stopped because the daily cap was reached.`],
+        key_monthly_budget: [`My monthly spending cap has been reached. ${SUMMARY}`,
+            `Your monthly spending cap, across all of your runs, has been reached. ${WRAP_UP} Tell the user you stopped because the monthly cap was reached.`],
+        fences_unreachable: [`I can't reach Fences to confirm I'm within my limits, so I'm stopping to be safe. ${SUMMARY}`,
+            `Your governance service can't be reached and you are configured to stop when that happens. ${WRAP_UP}`],
+        paused: [`I was paused from the Fences dashboard and not resumed in time. ${SUMMARY}`,
+            `A person paused this run from the Fences dashboard and it was not resumed in time. Stop your current task and summarize ` +
+                "what you have found or completed so far. Tell the user the run was paused by an operator."],
+    };
+    const [message, systemPrompt] = text[type] ??
+        ["Governance limit reached.", "A governance limit has been reached. Summarize what you have done so far."];
+    return { ok: false, breached: true, breachType: type, message, systemPrompt, spentUsd: run.costUsd };
+}
+const okResult = (spentUsd = 0) => ({ ok: true, breached: false, breachType: null, message: "", systemPrompt: "", spentUsd });
+const DEFAULTS = { maxIterations: 100, maxDurationMs: 300_000, maxTokens: 0 };
+export const MAX_EVENTS_PER_RUN = 1000;
+export class Run {
+    agentName;
+    budgetUsd;
+    maxIterations;
+    maxDurationMs;
+    maxTokens;
+    context;
+    runId = randomUUID();
+    costUsd = 0;
+    iterations = 0;
+    tokensUsed = 0;
+    startedAt = Date.now();
+    decisions = [];
+    /** Tool and model calls as OpenTelemetry-shaped spans, newest 1,000 kept. */
+    events = [];
+    lastBreach = null;
+    exception;
+    warned = false;
+    /** Live control from the dashboard (see control.ts). */
+    control = control.newControl();
+    constructor(agentName, budgetUsd, maxIterations, maxDurationMs, maxTokens, context) {
+        this.agentName = agentName;
+        this.budgetUsd = budgetUsd;
+        this.maxIterations = maxIterations;
+        this.maxDurationMs = maxDurationMs;
+        this.maxTokens = maxTokens;
+        this.context = context;
+    }
+    get durationMs() { return Date.now() - this.startedAt; }
+}
+const store = new AsyncLocalStorage();
+/** The run in progress in this async context, if any. */
+export function getActiveRun() {
+    return store.getStore() ?? null;
+}
+let client = null;
+let localOnly = false;
+let failClosed = false;
+/** Call once at startup, before any governed function runs. */
+export function init(options = {}) {
+    setCustomPrices(options.prices);
+    events.configure(options.environment, options.release, options.redact);
+    localOnly = !!options.localOnly;
+    failClosed = !!options.failClosed;
+    if (localOnly) {
+        client = null;
+    }
+    else if (!options.apiKey) {
+        throw new Error("apiKey is required unless localOnly is set. Use init({ localOnly: true }) for local usage.");
+    }
+    else {
+        client = new FencesClient(options.apiKey, options.endpoint ?? "http://localhost:8000");
+    }
+    control.configure(client, options.heartbeatS ?? 15, options.pauseTimeoutS ?? 3600);
+}
+/** @internal For tests: point the SDK at a fake server client. */
+export function _setClient(c) { client = c; control.configure(c, 15, 3600); }
+function requireInit() {
+    if (!localOnly && !client) {
+        throw new Error("Call agentfences.init() before using Fences. For local usage: init({ localOnly: true })");
+    }
+}
+function warnUnreachable(run, err) {
+    if (run.warned)
+        return;
+    run.warned = true;
+    console.warn(`agentfences: Fences backend unreachable for run ${run.runId} (${err}); enforcing limits locally`);
+}
+// ── governed ──────────────────────────────────────────────────────────────────
+/**
+ * Make each call of fn a governed run with these limits:
+ *
+ *     const research = governed(async (q: string) => { ... }, { budgetUsd: 0.5, maxIterations: 20 });
+ *
+ * Every limit is optional. On Fences Cloud, a limit left out comes from the agent's page in
+ * the dashboard. The run is named after the function (or `name`). checkpoint() never throws:
+ * a crossed limit comes back as a breached result, so the agent can wrap up gracefully.
+ */
+export function governed(fn, options = {}) {
+    const name = options.name ?? (fn.name || "agent");
+    return async (...args) => {
+        requireInit();
+        const run = await startRun(name, options);
+        control.register(run);
+        let error, failed = false;
+        try {
+            return await store.run(run, () => fn(...args));
+        }
+        catch (e) {
+            [error, failed] = [e, true];
+            throw e;
+        }
+        finally {
+            await endRun(run, ...outcome(run, failed, error));
+        }
+    };
+}
+function outcome(run, failed, error) {
+    if (!failed)
+        return [run.lastBreach ? "breached" : "success", null];
+    if (error instanceof FencesStop)
+        return ["breached", null]; // a framework integration halted the agent
+    run.exception = events.exceptionInfo(error);
+    const e = run.exception;
+    return ["error", e.message ? `${e.type}: ${e.message}` : e.type];
+}
+const LIMIT_KEYS = { budget_usd: "budgetUsd", max_iterations: "maxIterations", max_duration_ms: "maxDurationMs", max_tokens: "maxTokens" };
+async function startRun(agentName, limits) {
+    const run = new Run(agentName, limits.budgetUsd ?? null, limits.maxIterations ?? DEFAULTS.maxIterations, limits.maxDurationMs ?? DEFAULTS.maxDurationMs, limits.maxTokens ?? DEFAULTS.maxTokens, events.currentContext());
+    if (!client) {
+        if (run.budgetUsd === null)
+            noBudget(agentName, "Set one with governed(fn, { budgetUsd: ... }).");
+        return run;
+    }
+    // The run must start even if redaction drops its context: limits depend on it
+    const sent = Object.keys(run.context).length
+        ? events.redact({ type: "run_start", agent_name: agentName, context: { ...run.context } }) : null;
+    // Limits left out in code go as null: the server fills them from the agent's dashboard settings
+    const body = { run_id: run.runId, agent_name: agentName, budget_usd: limits.budgetUsd ?? null,
+        max_iterations: limits.maxIterations ?? null, max_duration_ms: limits.maxDurationMs ?? null, max_tokens: limits.maxTokens ?? null };
+    if (sent?.context)
+        body.context = sent.context;
+    const resp = await client.startRun(body);
+    if (resp.quarantined)
+        throw new AgentQuarantined(agentName, resp.detail);
+    // The server caps limits at the agent's ceilings: enforce the same numbers if it becomes unreachable later
+    for (const [wire, field] of Object.entries(LIMIT_KEYS)) {
+        const v = resp.limits?.[wire];
+        if (typeof v === "number" || (wire === "budget_usd" && v === null))
+            run[field] = v; // eslint-disable-line @typescript-eslint/no-explicit-any
+    }
+    for (const n of resp.notices ?? []) {
+        events.warnOnce(`${agentName}:${n.code}`, `${n.message ?? ""}${n.url ? ` ${n.url}` : ""}`);
+    }
+    if (!("limits" in resp) && run.budgetUsd === null && !resp.network_error) {
+        noBudget(agentName, "Set one on its page in the Fences dashboard.");
+    }
+    if (resp.network_error)
+        warnUnreachable(run, resp.network_error);
+    return run;
+}
+function noBudget(agentName, how) {
+    events.warnOnce(`${agentName}:no_budget`, `${agentName} has no budget, so its spend isn't capped. ${how}`);
+}
+async function endRun(run, status, error) {
+    control.unregister(run);
+    if (!client)
+        return;
+    // The run must end even if redaction drops its error details
+    const sent = error ? events.redact({ type: "run_end", status, error, exception: run.exception }) : null;
+    const body = { status, error: sent?.error ?? null };
+    if (sent?.exception)
+        body.exception = sent.exception;
+    await client.endRun(run.runId, body);
+}
+/**
+ * Record one step, then check every limit. Pass the model's response and Fences works out
+ * the cost from its model and token usage:
+ *
+ *     const response = await openai.chat.completions.create({ ... });
+ *     const result = await checkpoint(response);
+ *     if (result.breached) return result.message;
+ *
+ * Without a response: checkpoint(null, { costDeltaUsd: 0.02, tokensUsed: 450 }).
+ * Never throws for a breach. Outside a governed run it does nothing.
+ */
+export async function checkpoint(response, extra = {}) {
+    const run = getActiveRun();
+    if (!run)
+        return okResult();
+    if (typeof response === "number") {
+        throw new TypeError("checkpoint() takes the model's response first; pass a cost as checkpoint(null, { costDeltaUsd })");
+    }
+    const [cost, tokens] = response === undefined || response === null ? [0, 0] : costOf(response);
+    const stepCost = cost + (extra.costDeltaUsd ?? 0), stepTokens = tokens + (extra.tokensUsed ?? 0);
+    run.costUsd += stepCost;
+    run.tokensUsed += stepTokens;
+    run.iterations += 1;
+    const resp = client ? await client.checkpoint(run.runId, {
+        cost_delta_usd: stepCost, tokens_used: stepTokens, iterations: run.iterations, duration_ms: run.durationMs
+    }) : null;
+    const result = decide(run, resp);
+    if (run.control.paused && !result.breached) { // paused from the dashboard: wait here until resumed
+        await control.waitIfPaused(run);
+        return finalResult(run);
+    }
+    return result;
+}
+function localBreach(run) {
+    // Limits trip only once exceeded, same rule as the server; round away float drift (0.02*5 != 0.10)
+    if (run.budgetUsd !== null && Math.round(run.costUsd * 1e9) / 1e9 > run.budgetUsd)
+        return "budget_exceeded";
+    if (run.iterations > run.maxIterations)
+        return "iteration_limit";
+    if (run.durationMs > run.maxDurationMs)
+        return "time_limit";
+    if (run.maxTokens > 0 && run.tokensUsed > run.maxTokens)
+        return "token_limit";
+    return null;
+}
+function decide(run, resp) {
+    if (!resp || resp.network_error) {
+        if (resp) {
+            warnUnreachable(run, resp.network_error);
+            if (failClosed) {
+                run.lastBreach = "fences_unreachable";
+                return breachResult(run.lastBreach, run);
+            }
+        }
+        run.lastBreach = localBreach(run);
+    }
+    else {
+        control.apply(run, resp.commands);
+        // The server is authoritative: adopt its totals and (on a breach) its current limits
+        run.costUsd = resp.spent_usd ?? run.costUsd;
+        run.iterations = resp.iterations ?? run.iterations;
+        run.tokensUsed = resp.tokens_used ?? run.tokensUsed;
+        for (const [wire, field] of Object.entries(LIMIT_KEYS)) {
+            if (wire in resp)
+                run[field] = resp[wire]; // eslint-disable-line @typescript-eslint/no-explicit-any
+        }
+        // A fresh breach, or a 409 because the run is still fenced from an earlier one
+        run.lastBreach = resp.ok ? null : (resp.breach ?? run.lastBreach ?? "limit_reached");
+    }
+    return finalResult(run);
+}
+function finalResult(run) {
+    if (run.control.stopped)
+        run.lastBreach = "stopped_by_user"; // a stop from the dashboard sticks, whatever a later reply says
+    else if (run.control.pauseExpired)
+        run.lastBreach = "paused";
+    return run.lastBreach ? breachResult(run.lastBreach, run) : okResult(run.costUsd);
+}
+// ── Decision trail and spans ──────────────────────────────────────────────────
+const SPAN_BATCH = 50;
+const outbox = [];
+let draining = null;
+let spansSupported = true;
+function enqueue(item) {
+    outbox.push(item);
+    draining ??= drain().finally(() => { draining = null; });
+}
+/** Decisions and spans go to the server in the background, in order; consecutive spans of a run go together. */
+async function drain() {
+    while (outbox.length) {
+        const item = outbox.shift();
+        const c = client;
+        if (!c)
+            continue;
+        try {
+            if (item.kind === "decision") {
+                await c.logDecision(item.runId, item.body);
+                continue;
+            }
+            const batch = [item.span];
+            while (outbox[0]?.kind === "span" && outbox[0].runId === item.runId && batch.length < SPAN_BATCH) {
+                batch.push(outbox.shift().span);
+            }
+            if (spansSupported && (await c.logSpans(item.runId, batch)).unsupported) {
+                spansSupported = false;
+                console.warn("agentfences: this Fences server doesn't accept tool and model call spans yet; " +
+                    "they're kept on the run locally but not sent");
+            }
+        }
+        catch { /* never let delivery break the agent */ }
+    }
+}
+/** Wait up to timeoutMs for queued decisions and spans to reach the server. Call before a serverless handler returns. */
+export async function flush(timeoutMs = 5000) {
+    if (!draining)
+        return;
+    await Promise.race([draining, new Promise((r) => setTimeout(r, timeoutMs).unref())]);
+}
+/** Record the agent's reasoning at this step. Does nothing outside a governed run. */
+export function logDecision(reasoning, action = null) {
+    const run = getActiveRun();
+    if (!run)
+        return;
+    run.decisions.push({ timestamp: Date.now() / 1000, iteration: run.iterations, reasoning, action });
+    if (!client)
+        return;
+    const sent = events.redact({ type: "decision", reasoning, action });
+    if (sent && typeof sent.reasoning === "string" && sent.reasoning) {
+        enqueue({ kind: "decision", runId: run.runId,
+            body: { iteration: run.iterations, reasoning: sent.reasoning, action: sent.action ?? null } });
+    }
+}
+/**
+ * Add a tool or model call to the active run as an OpenTelemetry-shaped span (GenAI
+ * semantic conventions): kept on the run, and sent through the redact hook in cloud mode.
+ */
+export function recordSpan(name, elapsedMs, attributes, error) {
+    const run = getActiveRun();
+    if (!run)
+        return;
+    const end = Date.now() / 1000;
+    const attrs = {};
+    for (const [k, v] of Object.entries(attributes))
+        if (v !== null && v !== undefined)
+            attrs[k] = v;
+    attrs["fences.iteration"] = run.iterations;
+    if (error !== undefined) {
+        attrs["error.type"] = events.errorType(error);
+        attrs["fences.error.message"] = events.errorText(error);
+        const status = error?.status; // the OpenAI and Anthropic JS SDKs put the HTTP status here
+        if (typeof status === "number")
+            attrs["http.response.status_code"] = status;
+    }
+    const span = { name, start_ts: end - elapsedMs / 1000, end_ts: end, status: error === undefined ? "ok" : "error", attributes: attrs };
+    run.events.push(span);
+    if (run.events.length > MAX_EVENTS_PER_RUN)
+        run.events.shift(); // a runaway agent can't eat memory
+    if (!client || !spansSupported)
+        return;
+    const sent = events.redact({ type: "span", ...span });
+    if (sent) {
+        const { type: _, ...redacted } = sent; // the type key is for the redact hook only
+        enqueue({ kind: "span", runId: run.runId, span: redacted });
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+import type { CheckpointResult } from "./core.js";
+export declare class FencesError extends Error {
+    constructor(message: string);
+}
+/** The Fences server rejected the API key. Thrown so a bad key is noticed, not silently ignored. */
+export declare class FencesAuthError extends FencesError {
+}
+/** A governed function was called for an agent quarantined in the dashboard. No agent code ran. */
+export declare class AgentQuarantined extends FencesError {
+    readonly agentName: string;
+    constructor(agentName: string, detail?: string);
+}
+/**
+ * Thrown by framework integrations when a limit is crossed, because a framework callback
+ * can't hand a result back to the agent. Carries the same fields as a breached CheckpointResult.
+ */
+export declare class FencesStop extends FencesError {
+    readonly result: CheckpointResult;
+    readonly breachType: string | null;
+    readonly systemPrompt: string;
+    constructor(result: CheckpointResult);
+}

package/dist/errors.js

@@ -0,0 +1,33 @@
+export class FencesError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+    }
+}
+/** The Fences server rejected the API key. Thrown so a bad key is noticed, not silently ignored. */
+export class FencesAuthError extends FencesError {
+}
+/** A governed function was called for an agent quarantined in the dashboard. No agent code ran. */
+export class AgentQuarantined extends FencesError {
+    agentName;
+    constructor(agentName, detail) {
+        super(`Agent '${agentName}' is quarantined in Fences, so this run was not started` +
+            (detail && detail !== "quarantined" ? `: ${detail}` : ""));
+        this.agentName = agentName;
+    }
+}
+/**
+ * Thrown by framework integrations when a limit is crossed, because a framework callback
+ * can't hand a result back to the agent. Carries the same fields as a breached CheckpointResult.
+ */
+export class FencesStop extends FencesError {
+    result;
+    breachType;
+    systemPrompt;
+    constructor(result) {
+        super(result.message);
+        this.result = result;
+        this.breachType = result.breachType;
+        this.systemPrompt = result.systemPrompt;
+    }
+}

package/dist/events.d.ts

@@ -0,0 +1,38 @@
+export declare const MAX_CONTEXT_KEYS = 32;
+export declare const MAX_CONTEXT_VALUE = 256;
+export declare const MAX_MESSAGE = 1000;
+export declare const MAX_FRAMES = 15;
+export type Event = {
+    type: string;
+    [key: string]: unknown;
+};
+export type RedactHook = (event: Event) => Event | null | undefined;
+/** Log a warning once per key per process. */
+export declare function warnOnce(key: string, message: string): void;
+export declare function configure(environment?: string, release?: string, redact?: RedactHook): void;
+/**
+ * Tag every run started inside fn, e.g. with the end user or session it serves:
+ *
+ *     await context({ user_id: "u_123", session_id: "s_9" }, () => supportAgent(question))
+ *
+ * Calls nest; inner values win. Values are stored as strings (up to 256 characters,
+ * 32 keys); null and undefined leave a key out.
+ */
+export declare function context<T>(values: Record<string, unknown>, fn: () => T): T;
+export declare function currentContext(): Record<string, string>;
+/** `Type: message`, or just the type when there's no message. */
+export declare function errorText(e: unknown): string;
+export declare function errorType(e: unknown): string;
+export interface ExceptionInfo {
+    type: string;
+    message: string;
+    stack: string[];
+}
+/** Type, message and the last frames of the stack (innermost last), for the run's error report. */
+export declare function exceptionInfo(e: unknown): ExceptionInfo;
+/**
+ * Pass an outgoing event through the user's redact hook. Returns the event to send, or
+ * null to drop it. If the hook throws or returns something else, the event is dropped:
+ * never send unredacted data, and never crash the agent.
+ */
+export declare function redact(event: Event): Event | null;

package/dist/events.js

@@ -0,0 +1,102 @@
+/**
+ * What a run carries besides numbers: its context (environment, release, user, session),
+ * the error that ended it, and the redact hook every outgoing event passes through.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+export const MAX_CONTEXT_KEYS = 32;
+export const MAX_CONTEXT_VALUE = 256;
+export const MAX_MESSAGE = 1000;
+export const MAX_FRAMES = 15;
+const processContext = {}; // environment / release, from init()
+const contextStore = new AsyncLocalStorage();
+let redactHook;
+let redactFailed = false;
+const warned = new Set();
+/** Log a warning once per key per process. */
+export function warnOnce(key, message) {
+    if (warned.has(key))
+        return;
+    warned.add(key);
+    console.warn(`agentfences: ${message}`);
+}
+export function configure(environment, release, redact) {
+    for (const k of Object.keys(processContext))
+        delete processContext[k];
+    if (environment)
+        processContext.environment = environment.slice(0, MAX_CONTEXT_VALUE);
+    if (release)
+        processContext.release = release.slice(0, MAX_CONTEXT_VALUE);
+    redactHook = redact;
+    redactFailed = false;
+}
+/**
+ * Tag every run started inside fn, e.g. with the end user or session it serves:
+ *
+ *     await context({ user_id: "u_123", session_id: "s_9" }, () => supportAgent(question))
+ *
+ * Calls nest; inner values win. Values are stored as strings (up to 256 characters,
+ * 32 keys); null and undefined leave a key out.
+ */
+export function context(values, fn) {
+    const merged = { ...(contextStore.getStore() ?? {}) };
+    for (const [k, v] of Object.entries(values)) {
+        if (v !== null && v !== undefined)
+            merged[k] = String(v).slice(0, MAX_CONTEXT_VALUE);
+    }
+    if (Object.keys(merged).length > MAX_CONTEXT_KEYS) {
+        throw new RangeError(`agentfences.context() takes at most ${MAX_CONTEXT_KEYS} keys`);
+    }
+    return contextStore.run(merged, fn);
+}
+export function currentContext() {
+    return { ...processContext, ...(contextStore.getStore() ?? {}) };
+}
+/** `Type: message`, or just the type when there's no message. */
+export function errorText(e) {
+    const type = errorType(e);
+    const message = e instanceof Error ? e.message : e === undefined ? "" : String(e);
+    return (message ? `${type}: ${message}` : type).slice(0, MAX_MESSAGE);
+}
+export function errorType(e) {
+    if (e instanceof Error)
+        return e.name && e.name !== "Error" ? e.name : e.constructor.name;
+    return typeof e;
+}
+/** Type, message and the last frames of the stack (innermost last), for the run's error report. */
+export function exceptionInfo(e) {
+    const frames = e instanceof Error && e.stack
+        ? e.stack.split("\n").slice(1).map((l) => l.trim()).filter((l) => l.startsWith("at ")).map((l) => {
+            const m = l.match(/^at (?:(.+?) \()?(.+?):(\d+):\d+\)?$/); // "at fn (file:line:col)" or "at file:line:col"
+            return m ? `${m[2]}:${m[3]} in ${m[1] ?? "<anonymous>"}` : l.slice(3);
+        })
+        : [];
+    return {
+        type: errorType(e),
+        message: (e instanceof Error ? e.message : String(e)).slice(0, MAX_MESSAGE),
+        stack: frames.reverse().slice(-MAX_FRAMES),
+    };
+}
+/**
+ * Pass an outgoing event through the user's redact hook. Returns the event to send, or
+ * null to drop it. If the hook throws or returns something else, the event is dropped:
+ * never send unredacted data, and never crash the agent.
+ */
+export function redact(event) {
+    if (!redactHook)
+        return event;
+    try {
+        const out = redactHook(structuredClone(event));
+        if (out === null || out === undefined)
+            return null;
+        if (typeof out !== "object" || Array.isArray(out))
+            throw new TypeError(`returned ${typeof out}, not an object or null`);
+        return out;
+    }
+    catch (e) {
+        if (!redactFailed) {
+            redactFailed = true;
+            console.warn(`agentfences: redact hook failed (${errorText(e)}); dropping events it fails on`);
+        }
+        return null;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { init, governed, checkpoint, logDecision, flush, getActiveRun, Run } from "./core.js";
+export type { CheckpointResult, InitOptions, Limits, Extra, Span } from "./core.js";
+export { context } from "./events.js";
+export type { RedactHook, Event } from "./events.js";
+export { tool } from "./tools.js";
+export { requestApproval } from "./control.js";
+export type { Approval } from "./control.js";
+export { priceOf } from "./pricing.js";
+export type { CustomPrice } from "./pricing.js";
+export { FencesError, FencesAuthError, AgentQuarantined, FencesStop } from "./errors.js";
+export { VERSION } from "./version.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { init, governed, checkpoint, logDecision, flush, getActiveRun, Run } from "./core.js";
+export { context } from "./events.js";
+export { tool } from "./tools.js";
+export { requestApproval } from "./control.js";
+export { priceOf } from "./pricing.js";
+export { FencesError, FencesAuthError, AgentQuarantined, FencesStop } from "./errors.js";
+export { VERSION } from "./version.js";

package/dist/prices.generated.d.ts

@@ -0,0 +1,11 @@
+export declare const PRICES: Record<string, PriceEntry>;
+export interface Rates {
+    in: number;
+    out: number;
+    cache_read?: number;
+    cache_write?: number;
+}
+export interface PriceEntry extends Rates {
+    above?: number;
+    tier?: Rates;
+}