agentfences 0.6.0 → 0.8.0

package/dist/precheck.js

@@ -0,0 +1,136 @@
+/**
+ * Budget prechecks: before a model call goes out, work out the most it could cost and refuse it
+ * (FencesStop) if that could take the run past its budget. The amount is held while the call is in
+ * flight, so parallel calls can't overspend together, and released at the next checkpoint, which
+ * records the actual cost. Used by instrument(), which sees each request before it's sent.
+ * Same rules as the Python SDK's precheck.py.
+ */
+import * as control from "./control.js";
+import { FencesStop } from "./errors.js";
+import { costOf, priceOf, readUsage } from "./pricing.js";
+import { breachResult } from "./results.js";
+import { getActiveRun } from "./run.js";
+const DATA_URI = /data:[\w/+.-]+;base64,[A-Za-z0-9+/=\\]+/g;
+const FILE_TOKENS = 2_000; // ponytail: a flat guess per embedded image or file; providers price them by size
+const BYTES_PER_TOKEN = 2; // ponytail: tokenizers average 3-4 bytes a token for English and code; 2 keeps the estimate high
+const DEFAULT_MAX_OUT = 32_768; // for the few models whose output cap isn't in the price table
+const MAX_OUT_PARAMS = ["max_completion_tokens", "max_output_tokens", "max_tokens"];
+/** The output-token cap a request sets, if any. */
+export function maxOut(params) {
+    for (const k of MAX_OUT_PARAMS)
+        if (Number.isInteger(params[k]))
+            return params[k];
+    return null;
+}
+/**
+ * The most a call could cost: its input, estimated high from the request's size, at the dearest
+ * input rate, plus its output cap (or the model's) at the output rate. null for a model with no
+ * known price, which can't be prechecked.
+ */
+export function worstCaseUsd(model, request, outCap = null, n = 1) {
+    const p = typeof model === "string" && model ? priceOf(model) : undefined;
+    if (!p)
+        return null;
+    let text;
+    try {
+        text = JSON.stringify(request, (_k, v) => typeof v === "bigint" ? String(v) : v) ?? "";
+    }
+    catch {
+        text = String(request); // circular: its size is a guess, but the call isn't broken by the check
+    }
+    const files = text.match(DATA_URI)?.length ?? 0;
+    // TextEncoder, not Buffer: edge runtimes have no Buffer
+    const tokensIn = Math.floor(new TextEncoder().encode(text.replace(DATA_URI, "")).length / BYTES_PER_TOKEN) + files * FILE_TOKENS;
+    const tokensOut = (outCap ?? p.max_out ?? DEFAULT_MAX_OUT) * Math.max(n, 1);
+    const rates = p.above !== undefined && p.tier && tokensIn > p.above ? { ...p, ...p.tier } : p;
+    return tokensIn * Math.max(rates.in, rates.cache_write ?? 0) + tokensOut * rates.out;
+}
+/** Hold worst if it fits in what's left of the budget; null if it doesn't. */
+function take(run, worst) {
+    if (Math.round((run.costUsd + run.reservedUsd + worst) * 1e9) / 1e9 > run.budgetUsd)
+        return null;
+    const h = { amount: worst, finished: false };
+    run.holds.push(h);
+    run.reservedUsd += worst;
+    return h;
+}
+function refuse(run, worst, outCap) {
+    if (run.control.stopped) {
+        run.lastBreach = "stopped_by_user";
+        run.control.stopSeen = true;
+        throw new FencesStop(breachResult("stopped_by_user", run));
+    }
+    const room = Math.max(run.budgetUsd - run.costUsd - run.reservedUsd, 0);
+    const result = breachResult("budget_exceeded", run);
+    result.message = `I can't make another model call without risking going over my budget (spent $${run.costUsd.toFixed(4)} ` +
+        `of $${run.budgetUsd.toFixed(4)}; the next call could cost up to $${worst.toFixed(4)}). I've stopped here.`;
+    result.systemPrompt = "The run's budget can't cover another model call. Stop now; don't call any more tools or models.";
+    run.lastBreach = "budget_exceeded"; // the run ends breached even if the agent catches FencesStop and returns
+    console.warn(`agentfences: ${run.agentName}: refused a model call that could cost up to $${worst.toFixed(4)} with ` +
+        `$${room.toFixed(4)} of its budget left.${outCap ? "" : " Setting max_tokens on the call lowers its worst case."}`);
+    throw new FencesStop(result);
+}
+/** The call to check, or null when there's nothing to check (no run, no budget, a model with no known price). */
+export function prepare(model, request, params = {}) {
+    const run = getActiveRun();
+    if (!run || run.budgetUsd === null)
+        return null;
+    const outCap = maxOut(params);
+    const worst = worstCaseUsd(model, request, outCap, Number.isInteger(params.n) ? params.n : 1);
+    return worst === null ? null : { run, worst, outCap };
+}
+/**
+ * Before a model call, without waiting: hold its worst case, or throw FencesStop if it doesn't fit.
+ * Returns "wait" when it doesn't fit but the run waits at a limit (onBreach "hold"): then use holdAsync.
+ */
+export function holdNow(p) {
+    const h = take(p.run, p.worst);
+    if (h)
+        return h;
+    if (control.holds(p.run))
+        return "wait";
+    refuse(p.run, p.worst, p.outCap);
+}
+/** The same, waiting (onBreach "hold") for someone to raise the budget while the call doesn't fit. */
+export async function holdAsync(p) {
+    for (;;) {
+        const h = take(p.run, p.worst);
+        if (h)
+            return h;
+        if (!control.holds(p.run))
+            refuse(p.run, p.worst, p.outCap);
+        control.startHold(p.run, "budget");
+        await control.waitIfPaused(p.run);
+        if (control.endHold(p.run) !== "released")
+            refuse(p.run, p.worst, p.outCap);
+    }
+}
+/**
+ * After the call. A failed call isn't billed, so its hold is released now. Otherwise the hold
+ * shrinks to the response's actual cost (a stream without usage keeps its worst case), and the
+ * next checkpoint, which records that cost, releases it.
+ */
+export function finish(run, h, response, failed = false) {
+    const i = run.holds.indexOf(h); // by identity: parallel calls can hold equal amounts
+    if (i < 0)
+        return;
+    if (failed) {
+        run.holds.splice(i, 1);
+        run.reservedUsd -= h.amount;
+        return;
+    }
+    if (response !== undefined && readUsage(response)) {
+        const actual = costOf(response)[0];
+        run.reservedUsd += actual - h.amount;
+        h.amount = actual;
+    }
+    h.finished = true;
+}
+/** At a checkpoint, which records the actual cost: release the holds of calls that have finished. */
+export function releaseFinished(run) {
+    const done = run.holds.filter((h) => h.finished);
+    if (!done.length)
+        return;
+    run.holds = run.holds.filter((h) => !h.finished);
+    run.reservedUsd -= done.reduce((sum, h) => sum + h.amount, 0);
+}

package/dist/pricing.d.ts

@@ -10,6 +10,7 @@ export interface CustomPrice {
     cacheRead?: number;
     cacheWrite?: number;
 }
+/** input and output are required; a missing or invalid price throws here, not at the agent's first step. */
 export declare function setCustomPrices(prices?: Record<string, CustomPrice>): void;
 export declare function priceOf(model: string): PriceEntry | undefined;
 export interface Usage {

package/dist/pricing.js

@@ -5,23 +5,36 @@
 import { PRICES } from "./prices.generated.js";
 import { warnOnce } from "./events.js";
 const custom = {};
+const validPrice = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+/** input and output are required; a missing or invalid price throws here, not at the agent's first step. */
 export function setCustomPrices(prices = {}) {
-    for (const k of Object.keys(custom))
-        delete custom[k];
+    const table = {};
     for (const [model, p] of Object.entries(prices)) {
+        if (!p || typeof p !== "object" || p.input === undefined || p.output === undefined) {
+            throw new TypeError(`init({ prices }): '${model}' needs an input and an output price (USD per 1M tokens)`);
+        }
+        for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+            if (p[key] !== undefined && !validPrice(p[key])) {
+                throw new TypeError(`init({ prices }): '${model}' ${key} must be a number, zero or more, not ${String(p[key])}`);
+            }
+        }
         const e = { in: p.input / 1e6, out: p.output / 1e6 };
         if (p.cacheRead !== undefined)
             e.cache_read = p.cacheRead / 1e6;
         if (p.cacheWrite !== undefined)
             e.cache_write = p.cacheWrite / 1e6;
-        custom[model.toLowerCase()] = e;
+        table[model.toLowerCase()] = e;
     }
+    for (const k of Object.keys(custom))
+        delete custom[k]; // only once every entry is valid
+    Object.assign(custom, table);
 }
 export function priceOf(model) {
     const name = model.toLowerCase().split("/").pop() ?? ""; // "models/gemini-2.5-pro", "openai/gpt-4o"
     const undated = name.replace(/-(\d{4}-\d{2}-\d{2}|\d{8})$/, ""); // "claude-sonnet-4-5-20250929"
     for (const candidate of [name, undated]) {
-        const hit = custom[candidate] ?? PRICES[candidate];
+        // hasOwn: a model named "constructor" mustn't find Object.prototype's
+        const hit = Object.hasOwn(custom, candidate) ? custom[candidate] : Object.hasOwn(PRICES, candidate) ? PRICES[candidate] : undefined;
         if (hit)
             return hit;
     }

package/dist/results.d.ts

@@ -0,0 +1,16 @@
+/** What checkpoint() returns, and the words a breach comes with: for the user, and for the model. */
+import type { Run } from "./run.js";
+export interface CheckpointResult {
+    ok: boolean;
+    breached: boolean;
+    /** "budget_exceeded" | "iteration_limit" | "time_limit" | "token_limit" | "stopped_by_user" | ... (see PROTOCOL.md) */
+    breachType: string | null;
+    /** First-person text, ready to return to the user. */
+    message: string;
+    /** An instruction to give the model so it wraps up. */
+    systemPrompt: string;
+    /** The run's total spend so far. */
+    spentUsd: number;
+}
+export declare function breachResult(type: string, run: Run): CheckpointResult;
+export declare const okResult: (spentUsd?: number) => CheckpointResult;

package/dist/results.js

@@ -0,0 +1,33 @@
+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");
+export 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 };
+}
+export const okResult = (spentUsd = 0) => ({ ok: true, breached: false, breachType: null, message: "", systemPrompt: "", spentUsd });

package/dist/run.d.ts

@@ -0,0 +1,79 @@
+/** A run's state, and which run is active in this async context. */
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as control from "./control.js";
+import type * as events from "./events.js";
+/** Every limit is optional; see governed(). */
+export interface Limits {
+    /** Maximum spend for the run in USD. None anywhere: unlimited spend, with a warning. */
+    budgetUsd?: number | null;
+    /** Maximum checkpoints (steps). Default 100. */
+    maxIterations?: number | null;
+    /** Maximum wall-clock time in milliseconds. Default 300000 (5 minutes). */
+    maxDurationMs?: number | null;
+    /** Maximum tokens (input + output). 0 or unset: no limit. */
+    maxTokens?: number | null;
+}
+export declare const DEFAULTS: {
+    maxIterations: number;
+    maxDurationMs: number;
+    maxTokens: number;
+};
+export declare const MAX_EVENTS_PER_RUN = 1000;
+export interface Span {
+    name: string;
+    start_ts: number;
+    end_ts: number;
+    status: "ok" | "error";
+    attributes: Record<string, unknown>;
+}
+/** A model call's budget hold: its worst case, then its actual cost once it finishes. */
+export interface Hold {
+    amount: number;
+    finished: boolean;
+}
+export declare class Run {
+    readonly agentName: string;
+    budgetUsd: number | null;
+    maxIterations: number;
+    maxDurationMs: number;
+    maxTokens: number;
+    readonly context: Record<string, string>;
+    readonly runId: `${string}-${string}-${string}-${string}-${string}`;
+    costUsd: number;
+    iterations: number;
+    tokensUsed: number;
+    readonly startedAt: number;
+    readonly decisions: {
+        timestamp: number;
+        iteration: number;
+        reasoning: string;
+        action: string | null;
+    }[];
+    /** Tool and model calls as OpenTelemetry-shaped spans, newest 1,000 kept. */
+    readonly events: Span[];
+    lastBreach: string | null;
+    exception?: events.ExceptionInfo;
+    warned: boolean;
+    /** Live control from the dashboard (see control.ts). */
+    readonly control: control.Control;
+    /** Held by guarded tools and model calls in flight. */
+    reservedUsd: number;
+    /** Model calls' worst-case costs (see precheck.ts), released at the next checkpoint once they finish. */
+    holds: Hold[];
+    /** "hold": wait at a limit for someone to raise it (see InitOptions.onBreach). */
+    onBreach: "hold" | null;
+    private readonly abort;
+    /**
+     * Aborts when Fences halts the run after a stop it didn't reach a checkpoint for (see
+     * stopGraceS). Pass it to fetch and other cancellable work so a stuck run really stops:
+     *     await fetch(url, { signal: getActiveRun()?.signal });
+     */
+    get signal(): AbortSignal;
+    /** @internal */
+    _abort(reason: unknown): void;
+    constructor(agentName: string, budgetUsd: number | null, maxIterations: number, maxDurationMs: number, maxTokens: number, context: Record<string, string>);
+    get durationMs(): number;
+}
+export declare const store: AsyncLocalStorage<Run>;
+/** The run in progress in this async context, if any. */
+export declare function getActiveRun(): Run | null;

package/dist/run.js

@@ -0,0 +1,56 @@
+/** A run's state, and which run is active in this async context. */
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import * as control from "./control.js";
+export 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();
+    /** Held by guarded tools and model calls in flight. */
+    reservedUsd = 0;
+    /** Model calls' worst-case costs (see precheck.ts), released at the next checkpoint once they finish. */
+    holds = [];
+    /** "hold": wait at a limit for someone to raise it (see InitOptions.onBreach). */
+    onBreach = null;
+    abort = new AbortController();
+    /**
+     * Aborts when Fences halts the run after a stop it didn't reach a checkpoint for (see
+     * stopGraceS). Pass it to fetch and other cancellable work so a stuck run really stops:
+     *     await fetch(url, { signal: getActiveRun()?.signal });
+     */
+    get signal() { return this.abort.signal; }
+    /** @internal */
+    _abort(reason) { this.abort.abort(reason); }
+    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; }
+}
+export const store = new AsyncLocalStorage();
+/** The run in progress in this async context, if any. */
+export function getActiveRun() {
+    return store.getStore() ?? null;
+}

package/dist/tools.d.ts

@@ -1,5 +1,8 @@
+import { type Run } from "./core.js";
 /** `{"query":"cats","limit":5}`: the arguments as compact JSON (one object argument on its own), capped. */
 export declare function argsSummary(args: unknown[]): string;
+/** Record an async tool call; cost is null for an unguarded call, else a function giving its amount. */
+export declare function callAsync<R>(run: Run, name: string, summary: string, cost: (() => number) | null, needsApproval: boolean, call: () => Promise<R>): Promise<R>;
 interface ToolFields<A extends unknown[]> {
     name?: string;
     /** Reject with a TimeoutError if the call takes longer. JS can't stop the tool's code; pass run.signal to its fetches. */

package/dist/tools.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
+import * as approvals from "./approvals.js";
 import * as control from "./control.js";
-import { _client, getActiveRun, localBreach } from "./core.js";
+import { _client, checkAmount, getActiveRun, localBreach } from "./core.js";
 import { ToolBlocked } from "./errors.js";
 import * as events from "./events.js";
 import { MAX_ARGS, recordToolCall } from "./spans.js";
@@ -23,13 +24,14 @@ function block(run, name, reason, breach = null) {
 }
 const fits = (run, amount) => run.budgetUsd === null || Math.round((run.costUsd + run.reservedUsd + amount) * 1e9) / 1e9 <= run.budgetUsd;
 async function approve(run, name, summary, amount) {
-    const answer = await control.requestApproval(`${name}(${summary})`, { amountUsd: amount || undefined });
+    const answer = await approvals.requestApproval(`${name}(${summary})`, { amountUsd: amount || undefined });
     if (!answer.granted)
         block(run, name, answer.note ? `not approved: ${answer.note}` : "not approved");
     return answer.approvalId;
 }
 /** Check a guarded call and reserve its amount; returns the guard id, or throws ToolBlocked. */
 async function open(run, name, summary, amount, needsApproval) {
+    checkAmount(amount, `${name}'s costUsd`); // a NaN or negative amount would let calls past the budget
     if (run.control.quarantined)
         block(run, name, "the agent is quarantined in Fences"); // now, not when the quarantine's pause ends
     if (run.control.paused)
@@ -91,8 +93,9 @@ async function check(run, client, name, summary, amount, call) {
             control.unsupported("guard", "guarded tools", "they are blocked");
             block(run, name, "this Fences server doesn't support guarded tools");
         }
-        if (resp.network_error || !("allow" in resp))
-            block(run, name, "couldn't reach Fences to check this call"); // no answer: fail closed
+        if (resp.network_error || !("allow" in resp)) { // no answer: fail closed
+            block(run, name, resp.status === 401 || resp.status === 403 ? "Fences rejected the API key" : "couldn't reach Fences to check this call");
+        }
         block(run, name, resp.reason ?? "not allowed", resp.breach ?? null);
     }
     catch (e) {
@@ -108,6 +111,28 @@ async function settle(run, guardId, amount, error, failed) {
     run.costUsd += charged;
     await _client()?.guard(run.runId, { guard_id: guardId, phase: "settle", outcome, cost_usd: charged });
 }
+/** Record an async tool call; cost is null for an unguarded call, else a function giving its amount. */
+export async function callAsync(run, name, summary, cost, needsApproval, call) {
+    const started = performance.now();
+    let gate = null;
+    try {
+        if (cost) {
+            const amount = cost();
+            gate = [await open(run, name, summary, amount, needsApproval), amount];
+        }
+        const out = await call();
+        recordToolCall(name, summary, started);
+        if (gate)
+            await settle(run, ...gate, undefined, false);
+        return out;
+    }
+    catch (e) {
+        recordToolCall(name, summary, started, e);
+        if (gate)
+            await settle(run, ...gate, e, true);
+        throw e;
+    }
+}
 function timed(p, timeoutS, name) {
     if (timeoutS === undefined)
         return p;
@@ -125,25 +150,8 @@ export function tool(fn, options = {}) {
             const run = getActiveRun();
             if (!run)
                 return timed(Promise.resolve().then(() => fn(...args)), options.timeoutS, name);
-            const summary = argsSummary(args), started = performance.now();
-            let gate = null;
-            try {
-                if (guarded) {
-                    const c = options.costUsd, amount = Number((typeof c === "function" ? c(...args) : c) ?? 0);
-                    gate = [await open(run, name, summary, amount, !!options.approve), amount];
-                }
-                const out = await timed(Promise.resolve().then(() => fn(...args)), options.timeoutS, name);
-                recordToolCall(name, summary, started);
-                if (gate)
-                    await settle(run, ...gate, undefined, false);
-                return out;
-            }
-            catch (e) {
-                recordToolCall(name, summary, started, e);
-                if (gate)
-                    await settle(run, ...gate, e, true);
-                throw e;
-            }
+            const c = options.costUsd;
+            return callAsync(run, name, argsSummary(args), guarded ? () => (typeof c === "function" ? c(...args) : c) ?? 0 : null, !!options.approve, () => timed(Promise.resolve().then(() => fn(...args)), options.timeoutS, name));
         };
     }
     return (...args) => {

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The one place the version lives; sent to Fences on every request. Keep in step with package.json. */
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.8.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The one place the version lives; sent to Fences on every request. Keep in step with package.json. */
-export const VERSION = "0.6.0";
+export const VERSION = "0.8.0";

package/package.json

@@ -1,24 +1,46 @@
 {
   "name": "agentfences",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "On-call for AI agents: limits your agents can't raise, cost tracking, a decision trail, and a stop button",
   "license": "MIT",
   "author": "Bhavik Sardar",
   "homepage": "https://github.com/bhaviksardar/fences",
-  "repository": { "type": "git", "url": "git+https://github.com/bhaviksardar/fences.git", "directory": "sdk-js" },
-  "keywords": ["ai", "agents", "governance", "llm", "budget", "on-call"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bhaviksardar/fences.git",
+    "directory": "sdk-js"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "governance",
+    "llm",
+    "budget",
+    "on-call"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "exports": { ".": { "types": "./dist/index.d.ts", "default": "./dist/index.js" } },
-  "files": ["dist"],
-  "engines": { "node": ">=18" },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
     "build": "node scripts/prices.mjs && tsc",
     "test": "npm run build && node --test test/*.test.mjs"
   },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.135.0",
     "@types/node": "^22.0.0",
+    "openai": "^7.36.0",
     "typescript": "^5.6.0"
   }
 }