@klars/agentobs 0.1.0

package/dist/commands/policy.js

@@ -0,0 +1,84 @@
+/**
+ * `agentobs policy` - guardrail management.
+ *
+ * `policy test` matters more than it looks: a user has to be able to predict
+ * what a rule will do before letting it block their agent mid-task. Without a
+ * dry run, the only way to learn a rule is wrong is to have it fire at the
+ * worst moment.
+ */
+import { existsSync } from 'node:fs';
+import { paths } from '../core/paths.js';
+import { contextFromToolInput, evaluate, loadPolicy, writeDefaultPolicy, } from '../core/policy-engine.js';
+export async function policyInit() {
+    const file = paths.policy();
+    const existed = existsSync(file);
+    writeDefaultPolicy();
+    if (existed) {
+        console.log(`Policy file already exists, left unchanged: ${file}`);
+    }
+    else {
+        console.log(`Wrote starter policy: ${file}
+
+It blocks rm -rf and curl-pipe-to-shell, and asks for approval on .env edits
+and force-pushes. Edit it, then check your work:
+
+  agentobs policy check
+  agentobs policy test Bash "rm -rf ./build"`);
+    }
+}
+export async function policyCheck() {
+    const { policy, errors, source } = loadPolicy();
+    if (source === 'none') {
+        console.log(`No policy file at ${paths.policy()}.
+Every tool call is allowed. Run "agentobs policy init" to add guardrails.`);
+        return;
+    }
+    if (errors.length > 0) {
+        console.log(`Problems in ${paths.policy()}:\n`);
+        for (const err of errors)
+            console.log(`  ! ${err}`);
+        console.log(`
+Rules with problems are skipped. AgentObs deliberately fails open - a broken
+policy never blocks your agent - so fix these or those rules will not apply.\n`);
+    }
+    console.log(`Active rules (${policy.rules.length}), first match wins:\n`);
+    for (const [i, rule] of policy.rules.entries()) {
+        const criteria = [
+            rule.match.tool && rule.match.tool !== '*' ? `tool=${rule.match.tool}` : null,
+            rule.match.command_pattern ? `command~"${rule.match.command_pattern}"` : null,
+            rule.match.path_pattern ? `path~"${rule.match.path_pattern}"` : null,
+        ]
+            .filter(Boolean)
+            .join('  ');
+        console.log(`  ${String(i + 1).padStart(2)}. ${rule.decision.toUpperCase().padEnd(15)} ${rule.name}`);
+        console.log(`      ${criteria}`);
+    }
+    console.log(`\n  default: ${policy.default_decision}\n`);
+}
+export async function policyTest(tool, input) {
+    const { policy, errors } = loadPolicy();
+    for (const err of errors)
+        console.log(`  ! ${err}`);
+    // Probe both interpretations: the user types a bare string, and we cannot
+    // know whether they mean a command or a path. Testing it as both is more
+    // useful than making them guess which field name to supply.
+    const asCommand = evaluate(policy, contextFromToolInput(tool, { command: input }));
+    const asPath = evaluate(policy, contextFromToolInput(tool, { file_path: input }));
+    const chosen = asCommand.rule ? asCommand : asPath.rule ? asPath : asCommand;
+    const interpretation = asCommand.rule ? 'command' : asPath.rule ? 'file path' : 'command';
+    console.log(`
+  Tool       ${tool}
+  Input      ${input}
+  Read as    ${interpretation}
+  Decision   ${chosen.decision.toUpperCase()}
+  Rule       ${chosen.rule?.name ?? '(none — default_decision applied)'}`);
+    if (chosen.message)
+        console.log(`  Message    ${chosen.message}`);
+    if (chosen.decision === 'allow') {
+        console.log('\n  This call would be allowed to run.\n');
+    }
+    else {
+        console.log('\n  This call would be BLOCKED before running.\n');
+    }
+}
+//# sourceMappingURL=policy.js.map

package/dist/commands/run.js

@@ -0,0 +1,16 @@
+/**
+ * `agentobs run -- <command...>` - process-wrap adapter entrypoint.
+ */
+import { runWrapped } from '../adapters/process-wrap.js';
+export async function run(command, opts = {}) {
+    if (command.length === 0) {
+        console.error('Nothing to run. Usage: agentobs run -- <command> [args...]');
+        process.exitCode = 2;
+        return;
+    }
+    const code = await runWrapped(command, { agentName: opts.agent });
+    // Pass the wrapped process's exit code straight through, so wrapping a
+    // command inside a script or CI job never changes whether it "passed".
+    process.exitCode = code;
+}
+//# sourceMappingURL=run.js.map

package/dist/commands/stats.js

@@ -0,0 +1,49 @@
+/**
+ * `agentobs stats` - terminal summary.
+ */
+import { openDb } from '../core/db.js';
+import { getSummary, getToolsBreakdown } from '../core/queries.js';
+function toRange(opts) {
+    if (opts.today)
+        return 'today';
+    const v = opts.since;
+    return v === 'today' || v === '7d' || v === '30d' || v === 'all' ? v : '7d';
+}
+const money = (v) => (v === null ? '—' : `$${v.toFixed(4)}`);
+export async function stats(opts) {
+    const db = openDb();
+    const range = toRange(opts);
+    const summary = getSummary(db, range);
+    const tools = getToolsBreakdown(db, range);
+    if (opts.json) {
+        console.log(JSON.stringify({ summary, tools }, null, 2));
+        return;
+    }
+    console.log(`
+AgentObs · ${range}
+
+  Cost           ${money(summary.total_cost_usd)}
+  Tool calls     ${summary.tool_calls}
+  Sessions       ${summary.sessions}
+  Errors         ${summary.errors} (${(summary.error_rate * 100).toFixed(1)}%)
+  Blocked        ${summary.blocked}
+  Tokens         ${summary.tokens_in.toLocaleString()} in / ${summary.tokens_out.toLocaleString()} out`);
+    // State plainly when the cost total is incomplete rather than letting a
+    // partial number read as the whole spend.
+    if (summary.uncosted_calls > 0) {
+        console.log(`\n  Note: ${summary.uncosted_calls} call(s) have no price for their model.\n        Add it to ~/.agentobs/pricing.json to include them in the total.`);
+    }
+    if (tools.length > 0) {
+        console.log('\n  Tool                 Calls   Errors      Cost');
+        console.log('  ' + '-'.repeat(46));
+        for (const t of tools.slice(0, 12)) {
+            const name = t.tool_name.slice(0, 18).padEnd(18);
+            const calls = String(t.calls).padStart(7);
+            const errors = String(t.errors).padStart(8);
+            const cost = money(t.cost_usd).padStart(10);
+            console.log(`  ${name} ${calls} ${errors} ${cost}`);
+        }
+    }
+    console.log('');
+}
+//# sourceMappingURL=stats.js.map

package/dist/commands/watch.js

@@ -0,0 +1,20 @@
+/**
+ * `agentobs watch <file>` - JSONL adapter entrypoint.
+ */
+import { watchJsonl } from '../adapters/jsonl-watcher.js';
+export async function watch(file, opts = {}) {
+    let seen = 0;
+    console.log(`Watching ${file} (agent: ${opts.agent ?? 'generic'}) — Ctrl-C to stop.`);
+    await watchJsonl(file, {
+        agentName: opts.agent,
+        follow: opts.follow !== false,
+        onEvent: () => {
+            seen += 1;
+            // Rewrite one line rather than scrolling: this runs in the foreground
+            // for the length of a session.
+            process.stdout.write(`\r  ${seen} event(s) ingested`);
+        },
+    });
+    process.stdout.write('\n');
+}
+//# sourceMappingURL=watch.js.map

package/dist/core/db.js

@@ -0,0 +1,79 @@
+/**
+ * SQLite access layer.
+ *
+ * Uses node:sqlite (built into Node >=22.5) rather than better-sqlite3 on
+ * purpose: better-sqlite3 is a native addon with no prebuilt binary for
+ * current Node releases, so installing it demands a C++ toolchain (Visual
+ * Studio on Windows). For a tool whose pitch is "npx agentobs init and
+ * you're running", a compiler in the install path is disqualifying. The
+ * built-in module has the same synchronous, prepared-statement API.
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+import { ensureHome, paths } from './paths.js';
+let cached = null;
+function schemaSql() {
+    // schema.sql sits next to this file in both src/ (dev) and dist/ (built),
+    // copied by scripts/copy-assets.mjs.
+    const here = dirname(fileURLToPath(import.meta.url));
+    return readFileSync(join(here, 'schema.sql'), 'utf8');
+}
+/**
+ * Opens (and migrates) the local database, memoised per process.
+ *
+ * The hook adapter runs this on every single tool call the agent makes, so
+ * the whole path has to stay well under the ~50ms budget - hence WAL, the
+ * memoised handle, and NORMAL synchronous mode.
+ */
+export function openDb(file) {
+    if (cached)
+        return cached;
+    ensureHome();
+    const db = new DatabaseSync(file ?? paths.db());
+    // WAL lets the dashboard read while a hook writes, instead of the two
+    // blocking each other - the single most important setting here, since a
+    // reader holding a lock would stall the agent's tool call.
+    db.exec('PRAGMA journal_mode = WAL');
+    // NORMAL trades a fsync per commit for speed. On a crash the worst case is
+    // losing the last few observability rows, which is an acceptable loss for
+    // a monitoring tool and not worth taxing every tool call to prevent.
+    db.exec('PRAGMA synchronous = NORMAL');
+    db.exec('PRAGMA foreign_keys = ON');
+    db.exec('PRAGMA busy_timeout = 5000');
+    db.exec(schemaSql());
+    ensureDeviceId(db);
+    cached = db;
+    return db;
+}
+/** Closes the memoised handle. Chiefly for tests and clean process exit. */
+export function closeDb() {
+    if (cached) {
+        cached.close();
+        cached = null;
+    }
+}
+export function getMeta(db, key) {
+    const row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
+    return row?.value ?? null;
+}
+export function setMeta(db, key, value) {
+    db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, value);
+}
+/**
+ * This machine's stable identifier, minted once on first run. Used to
+ * attribute sessions to a device in the team view without ever sending a
+ * hostname or anything else personally identifying.
+ */
+export function ensureDeviceId(db) {
+    const existing = getMeta(db, 'device_id');
+    if (existing)
+        return existing;
+    const id = randomUUID();
+    setMeta(db, 'device_id', id);
+    return id;
+}
+export { randomUUID as newId };
+//# sourceMappingURL=db.js.map

package/dist/core/paths.js

@@ -0,0 +1,30 @@
+/**
+ * Filesystem layout for the AgentObs home directory.
+ *
+ * Everything lives under one directory so uninstalling is `rm -rf ~/.agentobs`
+ * and backing up is copying it. AGENTOBS_HOME overrides the location, which
+ * both the test suite and CI rely on to avoid touching a developer's real data.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync } from 'node:fs';
+export function agentobsHome() {
+    return process.env.AGENTOBS_HOME || join(homedir(), '.agentobs');
+}
+export const paths = {
+    home: agentobsHome,
+    db: () => join(agentobsHome(), 'agentobs.db'),
+    pricing: () => join(agentobsHome(), 'pricing.json'),
+    policy: () => join(agentobsHome(), 'policy.json'),
+    auth: () => join(agentobsHome(), 'auth.json'),
+    logs: () => join(agentobsHome(), 'logs'),
+    hookLog: () => join(agentobsHome(), 'logs', 'hook.log'),
+};
+/** Creates the home directory tree if absent. Safe to call repeatedly. */
+export function ensureHome() {
+    const home = agentobsHome();
+    mkdirSync(home, { recursive: true });
+    mkdirSync(paths.logs(), { recursive: true });
+    return home;
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/policy-engine.js

@@ -0,0 +1,246 @@
+/**
+ * Guardrail policy engine.
+ *
+ * Evaluates a proposed tool call against ~/.agentobs/policy.json and returns
+ * a decision the PreToolUse hook enforces. Two properties matter more than
+ * features here:
+ *
+ *  1. Fail open, loudly. A malformed policy file must never wedge the user's
+ *     agent - a broken guardrail that blocks all work is worse than no
+ *     guardrail. Parse errors degrade to default-allow and are reported.
+ *  2. Predictable matching. Users must be able to reason about what a rule
+ *     will do before it fires, which is what `agentobs policy test` is for.
+ *     First matching rule wins, in file order.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { paths } from './paths.js';
+export const DEFAULT_POLICY = {
+    rules: [
+        {
+            name: 'no-recursive-force-delete',
+            match: { tool: 'Bash', command_pattern: '*rm -rf*' },
+            decision: 'block',
+            message: 'Recursive force-delete is blocked by AgentObs policy.',
+        },
+        {
+            name: 'protect-env-files',
+            match: { tool: '*', path_pattern: '**/.env*' },
+            decision: 'needs_approval',
+            message: 'Editing .env files needs a human decision - they hold credentials.',
+        },
+        {
+            name: 'no-force-push',
+            match: { tool: 'Bash', command_pattern: '*git push*--force*' },
+            decision: 'needs_approval',
+            message: 'Force-push rewrites shared history.',
+        },
+        {
+            name: 'no-curl-pipe-shell',
+            match: { tool: 'Bash', command_pattern: '*curl*|*sh*' },
+            decision: 'block',
+            message: 'Piping a downloaded script straight into a shell is blocked.',
+        },
+    ],
+    default_decision: 'allow',
+};
+/**
+ * Loads and validates the policy file.
+ *
+ * Returns errors rather than throwing: the caller is usually a hook running
+ * inside the user's agent, where an exception would surface as an agent
+ * failure rather than a policy problem.
+ */
+export function loadPolicy(file) {
+    const target = file ?? paths.policy();
+    if (!existsSync(target)) {
+        // No policy configured is a legitimate state - observability without
+        // enforcement is Phase A's whole product.
+        return { policy: { rules: [], default_decision: 'allow' }, errors: [], source: 'none' };
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(target, 'utf8'));
+    }
+    catch (err) {
+        return {
+            policy: { rules: [], default_decision: 'allow' },
+            errors: [`policy.json is not valid JSON: ${err.message}`],
+            source: 'default',
+        };
+    }
+    const errors = [];
+    const parsed = raw;
+    const rules = [];
+    if (!Array.isArray(parsed.rules)) {
+        errors.push('policy.json must have a "rules" array');
+    }
+    else {
+        parsed.rules.forEach((rule, i) => {
+            const where = rule?.name ? `rule "${rule.name}"` : `rule #${i + 1}`;
+            if (!rule || typeof rule !== 'object') {
+                errors.push(`${where} is not an object`);
+                return;
+            }
+            if (!rule.match || typeof rule.match !== 'object') {
+                errors.push(`${where} is missing a "match" object`);
+                return;
+            }
+            if (!isDecision(rule.decision)) {
+                errors.push(`${where} has an invalid decision "${rule.decision}" (allow|block|needs_approval)`);
+                return;
+            }
+            if (!rule.match.tool && !rule.match.command_pattern && !rule.match.path_pattern) {
+                // A rule matching on nothing would fire on every call - almost
+                // certainly a typo, and a destructive one if the decision is block.
+                errors.push(`${where} has no match criteria; it would match every tool call`);
+                return;
+            }
+            rules.push({ ...rule, name: rule.name ?? `rule-${i + 1}` });
+        });
+    }
+    const fallback = isDecision(parsed.default_decision) ? parsed.default_decision : 'allow';
+    if (parsed.default_decision !== undefined && !isDecision(parsed.default_decision)) {
+        errors.push(`invalid default_decision "${parsed.default_decision}", using "allow"`);
+    }
+    return {
+        policy: { rules, default_decision: fallback },
+        errors,
+        source: errors.length && rules.length === 0 ? 'default' : 'file',
+    };
+}
+function isDecision(value) {
+    return value === 'allow' || value === 'block' || value === 'needs_approval';
+}
+export function writeDefaultPolicy(file) {
+    const target = file ?? paths.policy();
+    if (!existsSync(target)) {
+        writeFileSync(target, `${JSON.stringify(DEFAULT_POLICY, null, 2)}\n`, 'utf8');
+    }
+    return target;
+}
+/**
+ * Sentinel standing in for `**` between the two star-replacement passes.
+ * NUL is used because it cannot legitimately appear in a policy pattern -
+ * a printable placeholder (a space, say) would collide with patterns that
+ * contain it, such as `*rm -rf*`.
+ */
+const DOUBLE_STAR = '\u0000';
+/**
+ * Minimal glob matcher, hand-rolled rather than pulling in a glob dependency:
+ * this runs on the hot path of every tool call and the pattern surface is tiny.
+ *
+ * The regex is anchored, so a pattern must match the whole string. An
+ * unanchored `rm -rf` would otherwise fire on `confirm -rfx`.
+ *
+ * `mode` decides what a bare `*` means, and getting it wrong is a security
+ * bug in both directions:
+ *
+ *  - 'path'    - `*` stays within one segment, `**` crosses them. The normal
+ *                glob contract users expect from a pattern like `**\/.env*`.
+ *  - 'command' - `*` crosses `/` freely. A shell command is not a path; under
+ *                path semantics `*rm -rf*` fails to match `rm -rf /` purely
+ *                because the argument contains a slash, silently letting
+ *                through the exact command the rule exists to stop.
+ */
+export function globMatch(pattern, value, mode = 'path') {
+    // A leading `**/` must also match a bare filename at the root: the whole
+    // point of `**\/.env*` is protecting `.env`, and that file most often sits
+    // in the working directory with no directory prefix at all. Standard glob
+    // implementations make this prefix optional for the same reason.
+    const optionalLeadingDirs = mode === 'path' && pattern.startsWith('**/');
+    const body = optionalLeadingDirs ? pattern.slice(3) : pattern;
+    const escaped = body.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    const singleStar = mode === 'command' ? '.*' : '[^/]*';
+    const rx = escaped
+        .split('**')
+        .join(DOUBLE_STAR)
+        .split('*')
+        .join(singleStar)
+        .split(DOUBLE_STAR)
+        .join('.*')
+        .split('?')
+        .join('.');
+    const prefix = optionalLeadingDirs ? '(?:.*/)?' : '';
+    return new RegExp(`^${prefix}${rx}$`, 'i').test(value);
+}
+/**
+ * Evaluates a tool call. First matching rule wins, in file order, so a user
+ * can put a narrow allow above a broad block and have it behave the way
+ * reading top-to-bottom suggests.
+ */
+export function evaluate(policy, ctx) {
+    for (const rule of policy.rules) {
+        if (matches(rule.match, ctx)) {
+            return {
+                decision: rule.decision,
+                rule,
+                message: rule.message ?? defaultMessage(rule),
+            };
+        }
+    }
+    return { decision: policy.default_decision, rule: null, message: null };
+}
+function matches(match, ctx) {
+    if (match.tool && match.tool !== '*') {
+        if (match.tool.toLowerCase() !== ctx.tool.toLowerCase())
+            return false;
+    }
+    if (match.command_pattern) {
+        const command = ctx.command ?? extractString(ctx.raw);
+        if (!command || !globMatch(match.command_pattern, command, 'command'))
+            return false;
+    }
+    if (match.path_pattern) {
+        const path = ctx.path ?? extractString(ctx.raw);
+        if (!path)
+            return false;
+        // Compare with forward slashes so one pattern works on Windows too - a
+        // rule written as **\/.env* must not silently miss C:\repo\.env.
+        if (!globMatch(match.path_pattern, path.replace(/\\/g, '/')))
+            return false;
+    }
+    return true;
+}
+/** Best-effort string view of an arbitrary tool input, for pattern matching. */
+function extractString(raw) {
+    if (raw == null)
+        return null;
+    if (typeof raw === 'string')
+        return raw;
+    try {
+        return JSON.stringify(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultMessage(rule) {
+    return rule.decision === 'block'
+        ? `Blocked by AgentObs policy rule "${rule.name}".`
+        : `Rule "${rule.name}" requires approval before this can run.`;
+}
+/**
+ * Pulls the command/path out of a tool input payload.
+ *
+ * Agents name these fields inconsistently (command vs cmd, file_path vs path
+ * vs filename), so we check the known aliases rather than assuming one shape:
+ * a missed field means a guardrail silently fails to match.
+ */
+export function contextFromToolInput(tool, input) {
+    const obj = (input && typeof input === 'object' ? input : {});
+    const pick = (...keys) => {
+        for (const key of keys) {
+            const val = obj[key];
+            if (typeof val === 'string' && val.length > 0)
+                return val;
+        }
+        return null;
+    };
+    return {
+        tool,
+        command: pick('command', 'cmd', 'script', 'shell_command'),
+        path: pick('file_path', 'path', 'filename', 'notebook_path', 'target_file'),
+        raw: input,
+    };
+}
+//# sourceMappingURL=policy-engine.js.map

package/dist/core/pricing.js

@@ -0,0 +1,100 @@
+/**
+ * Token -> USD conversion.
+ *
+ * Hard rule: an unknown model yields `null`, never a guess. A fabricated
+ * cost is worse than a blank one - a user who spots one wrong number stops
+ * trusting every number, and cost accuracy is the product's core claim.
+ * Unknown models are surfaced in the dashboard as "-" with a hint to add
+ * them to pricing.json.
+ *
+ * Prices are per million tokens, matching how vendors publish them, and live
+ * in an editable ~/.agentobs/pricing.json so a price change never requires a
+ * new release.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { paths } from './paths.js';
+/**
+ * Seed table written by `agentobs init`. Verify against current vendor
+ * pricing pages before a release - these are a starting point the user is
+ * expected to edit, not an authoritative source.
+ */
+export const DEFAULT_PRICING = {
+    _comment: 'Prices in USD per 1,000,000 tokens. Edit freely - AgentObs reads this file at runtime. A model missing here shows cost as blank rather than a guess.',
+    updated: '2026-08-29',
+    models: {
+        'claude-opus-4': { input_per_mtok: 15, output_per_mtok: 75 },
+        'claude-sonnet-4': { input_per_mtok: 3, output_per_mtok: 15 },
+        'claude-haiku-4-5': { input_per_mtok: 1, output_per_mtok: 5 },
+        'claude-3-5-haiku': { input_per_mtok: 0.8, output_per_mtok: 4 },
+        'gpt-4o': { input_per_mtok: 2.5, output_per_mtok: 10 },
+        'gpt-4o-mini': { input_per_mtok: 0.15, output_per_mtok: 0.6 },
+    },
+};
+let cache = null;
+export function loadPricing(force = false) {
+    if (cache && !force)
+        return cache;
+    const file = paths.pricing();
+    if (!existsSync(file)) {
+        cache = DEFAULT_PRICING;
+        return cache;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        // A malformed hand-edited file must not take the whole CLI down; fall
+        // back to defaults and let cost show blank rather than crashing a hook.
+        cache = parsed?.models ? parsed : DEFAULT_PRICING;
+    }
+    catch {
+        cache = DEFAULT_PRICING;
+    }
+    return cache;
+}
+export function writeDefaultPricing() {
+    const file = paths.pricing();
+    if (!existsSync(file)) {
+        writeFileSync(file, `${JSON.stringify(DEFAULT_PRICING, null, 2)}\n`, 'utf8');
+    }
+    return file;
+}
+/**
+ * Resolves a reported model id to a price entry.
+ *
+ * Vendors append dated suffixes (`claude-sonnet-4-20250514`) and platforms
+ * add prefixes (`us.anthropic.claude-...`), so an exact-match-only lookup
+ * would blank out cost for nearly every real session. Matching the longest
+ * configured key contained in the id handles both, and longest-first avoids
+ * a short key shadowing a more specific one.
+ */
+export function findModelPrice(model) {
+    if (!model)
+        return null;
+    const table = loadPricing();
+    const id = model.toLowerCase();
+    if (table.models[model])
+        return table.models[model];
+    const keys = Object.keys(table.models).sort((a, b) => b.length - a.length);
+    for (const key of keys) {
+        if (id.includes(key.toLowerCase()))
+            return table.models[key];
+    }
+    return null;
+}
+/**
+ * Cost for a call, or `null` when the model is unknown - never a guess.
+ */
+export function computeCost(model, tokensIn, tokensOut) {
+    const price = findModelPrice(model);
+    if (!price)
+        return null;
+    const inTok = tokensIn ?? 0;
+    const outTok = tokensOut ?? 0;
+    if (inTok === 0 && outTok === 0)
+        return 0;
+    return (inTok / 1_000_000) * price.input_per_mtok + (outTok / 1_000_000) * price.output_per_mtok;
+}
+/** Test seam: drops the memoised table so a rewritten file is picked up. */
+export function __resetPricingCache() {
+    cache = null;
+}
+//# sourceMappingURL=pricing.js.map