toad-eye 1.1.0 → 2.1.0

package/dist/alerts/grafana.js

@@ -0,0 +1,19 @@
+export async function postGrafanaAnnotation(grafanaUrl, alert, apiKey) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (apiKey)
+        headers["Authorization"] = `Bearer ${apiKey}`;
+    const res = await fetch(`${grafanaUrl}/api/annotations`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            time: Date.now(),
+            tags: ["toad-eye", "alert", alert.name],
+            text: `🚨 ${alert.name}: ${alert.value.toFixed(4)} > ${alert.threshold}`,
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`Grafana annotation failed: ${res.status} ${res.statusText}`);
+    }
+}

package/dist/alerts/index.d.ts

@@ -0,0 +1,5 @@
+export { AlertManager } from "./manager.js";
+export { parseCondition } from "./conditions.js";
+export type { AlertsConfig, AlertRule, AlertChannelConfig, FiredAlert, } from "./types.js";
+import { AlertManager } from "./manager.js";
+export declare function startAlertsFromFile(configPath: string): AlertManager;

package/dist/alerts/index.js

@@ -0,0 +1,12 @@
+export { AlertManager } from "./manager.js";
+export { parseCondition } from "./conditions.js";
+import { readFileSync } from "node:fs";
+import yaml from "yaml";
+import { AlertManager } from "./manager.js";
+export function startAlertsFromFile(configPath) {
+    const raw = readFileSync(configPath, "utf-8");
+    const config = yaml.parse(raw);
+    const manager = new AlertManager(config);
+    manager.start();
+    return manager;
+}

package/dist/alerts/manager.d.ts

@@ -0,0 +1,13 @@
+import type { AlertsConfig } from "./types.js";
+export declare class AlertManager {
+    private readonly config;
+    private readonly cooldowns;
+    private intervalId;
+    constructor(config: AlertsConfig);
+    start(): void;
+    stop(): void;
+    private isInCooldown;
+    private evaluate;
+    private fireChannels;
+    private postAnnotation;
+}

package/dist/alerts/manager.js

@@ -0,0 +1,87 @@
+import { evaluateCondition } from "./conditions.js";
+import { sendToChannel } from "./channels.js";
+import { postGrafanaAnnotation } from "./grafana.js";
+const DEFAULT_PROMETHEUS_URL = "http://localhost:9090";
+const DEFAULT_GRAFANA_URL = "http://localhost:3100";
+const DEFAULT_EVAL_INTERVAL_SECONDS = 60;
+const DEFAULT_COOLDOWN_MINUTES = 30;
+export class AlertManager {
+    config;
+    cooldowns = new Map();
+    intervalId;
+    constructor(config) {
+        this.config = config;
+    }
+    start() {
+        const intervalMs = (this.config.evalIntervalSeconds ?? DEFAULT_EVAL_INTERVAL_SECONDS) * 1000;
+        this.intervalId = setInterval(() => void this.evaluate(), intervalMs);
+        void this.evaluate();
+        console.log(`[toad-eye alerts] Started — ${this.config.alerts.length} rule(s), eval every ${intervalMs / 1000}s`);
+    }
+    stop() {
+        if (this.intervalId !== undefined) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+    isInCooldown(rule) {
+        const lastFired = this.cooldowns.get(rule.name);
+        if (lastFired === undefined)
+            return false;
+        const cooldownMs = (rule.cooldown ??
+            this.config.cooldownMinutes ??
+            DEFAULT_COOLDOWN_MINUTES) *
+            60 *
+            1000;
+        return Date.now() - lastFired < cooldownMs;
+    }
+    async evaluate() {
+        const prometheusUrl = this.config.prometheusUrl ?? DEFAULT_PROMETHEUS_URL;
+        const grafanaUrl = this.config.grafanaUrl ?? DEFAULT_GRAFANA_URL;
+        for (const rule of this.config.alerts) {
+            if (this.isInCooldown(rule))
+                continue;
+            const result = await evaluateCondition(prometheusUrl, rule);
+            if (!result?.triggered)
+                continue;
+            this.cooldowns.set(rule.name, Date.now());
+            const firedAlert = {
+                rule,
+                value: result.value,
+                threshold: result.threshold,
+                topModels: result.topModels,
+                firedAt: new Date(),
+            };
+            console.log(`[toad-eye alerts] 🚨 "${rule.name}" fired — value=${result.value.toFixed(4)}, threshold=${result.threshold}`);
+            await Promise.allSettled([
+                this.fireChannels(firedAlert),
+                this.postAnnotation(grafanaUrl, firedAlert.rule.name, firedAlert.value, firedAlert.threshold),
+            ]);
+        }
+    }
+    async fireChannels(alert) {
+        const channels = this.config.channels ?? {};
+        for (const channelName of alert.rule.channels) {
+            const channelConfig = channels[channelName];
+            if (!channelConfig) {
+                console.warn(`[toad-eye alerts] Channel "${channelName}" not configured, skipping`);
+                continue;
+            }
+            try {
+                await sendToChannel(channelConfig, alert);
+                console.log(`[toad-eye alerts] ✓ Sent to channel "${channelName}"`);
+            }
+            catch (err) {
+                console.error(`[toad-eye alerts] ✗ Failed to send to channel "${channelName}":`, err);
+            }
+        }
+    }
+    async postAnnotation(grafanaUrl, name, value, threshold) {
+        try {
+            await postGrafanaAnnotation(grafanaUrl, { name, value, threshold }, this.config.grafanaApiKey);
+        }
+        catch (err) {
+            console.error(`[toad-eye alerts] Failed to post Grafana annotation:`, err);
+        }
+    }
+}

package/dist/alerts/types.d.ts

@@ -0,0 +1,46 @@
+export type AlertChannelConfig = {
+    readonly type: "telegram";
+    readonly token: string;
+    readonly chatId: string;
+} | {
+    readonly type: "slack_webhook";
+    readonly url: string;
+} | {
+    readonly type: "webhook";
+    readonly url: string;
+    readonly headers?: Record<string, string> | undefined;
+} | {
+    readonly type: "email";
+    readonly host: string;
+    readonly port: number;
+    readonly user: string;
+    readonly password: string;
+    readonly from: string;
+    readonly to: string | readonly string[];
+};
+export interface AlertRule {
+    readonly name: string;
+    readonly metric: string;
+    readonly condition: string;
+    readonly channels: readonly string[];
+    readonly cooldown?: number | undefined;
+}
+export interface AlertsConfig {
+    readonly prometheusUrl?: string | undefined;
+    readonly grafanaUrl?: string | undefined;
+    readonly grafanaApiKey?: string | undefined;
+    readonly evalIntervalSeconds?: number | undefined;
+    readonly cooldownMinutes?: number | undefined;
+    readonly channels?: Record<string, AlertChannelConfig> | undefined;
+    readonly alerts: readonly AlertRule[];
+}
+export interface FiredAlert {
+    readonly rule: AlertRule;
+    readonly value: number;
+    readonly threshold: number;
+    readonly topModels: ReadonlyArray<{
+        model: string;
+        value: number;
+    }>;
+    readonly firedAt: Date;
+}

package/dist/alerts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/budget/error.d.ts

@@ -0,0 +1,10 @@
+import type { BudgetExceededInfo } from "./types.js";
+/** Thrown when onBudgetExceeded is 'block' and a budget limit is hit. */
+export declare class ToadBudgetExceededError extends Error {
+    readonly budget: BudgetExceededInfo["budget"];
+    readonly limit: number;
+    readonly current: number;
+    readonly model?: string | undefined;
+    readonly userId?: string | undefined;
+    constructor(info: BudgetExceededInfo);
+}

package/dist/budget/error.js

@@ -0,0 +1,22 @@
+/** Thrown when onBudgetExceeded is 'block' and a budget limit is hit. */
+export class ToadBudgetExceededError extends Error {
+    budget;
+    limit;
+    current;
+    model;
+    userId;
+    constructor(info) {
+        const target = info.budget === "perModel"
+            ? ` for model ${info.model}`
+            : info.budget === "perUser"
+                ? ` for user ${info.userId}`
+                : "";
+        super(`toad-eye: ${info.budget} budget exceeded${target} — limit $${info.limit}, current $${info.current.toFixed(2)}`);
+        this.name = "ToadBudgetExceededError";
+        this.budget = info.budget;
+        this.limit = info.limit;
+        this.current = info.current;
+        this.model = info.model;
+        this.userId = info.userId;
+    }
+}

package/dist/budget/index.d.ts

@@ -0,0 +1,3 @@
+export { BudgetTracker } from "./tracker.js";
+export { ToadBudgetExceededError } from "./error.js";
+export type { BudgetConfig, BudgetExceededMode, BudgetExceededInfo, BudgetState, DowngradeCallback, } from "./types.js";

package/dist/budget/index.js

@@ -0,0 +1,2 @@
+export { BudgetTracker } from "./tracker.js";
+export { ToadBudgetExceededError } from "./error.js";

package/dist/budget/tracker.d.ts

@@ -0,0 +1,35 @@
+import type { BudgetConfig, BudgetExceededMode, BudgetState, BudgetExceededInfo, DowngradeCallback } from "./types.js";
+export declare class BudgetTracker {
+    private readonly config;
+    private readonly mode;
+    private readonly downgrade?;
+    private state;
+    constructor(config: BudgetConfig, mode: BudgetExceededMode, downgrade?: DowngradeCallback);
+    /** Reset counters if the day has changed. */
+    private resetIfNewDay;
+    /**
+     * Check budget BEFORE making an LLM call.
+     * Returns modified provider/model if downgrade mode triggers,
+     * throws ToadBudgetExceededError if block mode triggers,
+     * returns null if no action needed.
+     */
+    checkBefore(provider: string, model: string, userId?: string): {
+        provider: string;
+        model: string;
+    } | null;
+    /** Record cost AFTER a successful LLM call. Returns exceeded info if budget was just crossed. */
+    recordCost(cost: number, model: string, userId?: string): BudgetExceededInfo | null;
+    /** Find which budget (if any) is exceeded. */
+    private findExceeded;
+    /** Get current budget usage as percentage (0-100+). */
+    getUsagePercent(): number;
+    /** Get current state snapshot (for persistence or debugging). */
+    getState(): Readonly<BudgetState>;
+    /** Restore state from persistence (e.g., on startup). */
+    restoreState(saved: {
+        date: string;
+        totalCost: number;
+        perUser: Record<string, number>;
+        perModel: Record<string, number>;
+    }): void;
+}

package/dist/budget/tracker.js

@@ -0,0 +1,121 @@
+import { ToadBudgetExceededError } from "./error.js";
+function todayUTC() {
+    return new Date().toISOString().slice(0, 10);
+}
+export class BudgetTracker {
+    config;
+    mode;
+    downgrade;
+    state;
+    constructor(config, mode, downgrade) {
+        this.config = config;
+        this.mode = mode;
+        this.downgrade = downgrade;
+        this.state = {
+            date: todayUTC(),
+            totalCost: 0,
+            perUser: new Map(),
+            perModel: new Map(),
+        };
+    }
+    /** Reset counters if the day has changed. */
+    resetIfNewDay() {
+        const today = todayUTC();
+        if (this.state.date !== today) {
+            this.state = {
+                date: today,
+                totalCost: 0,
+                perUser: new Map(),
+                perModel: new Map(),
+            };
+        }
+    }
+    /**
+     * Check budget BEFORE making an LLM call.
+     * Returns modified provider/model if downgrade mode triggers,
+     * throws ToadBudgetExceededError if block mode triggers,
+     * returns null if no action needed.
+     */
+    checkBefore(provider, model, userId) {
+        this.resetIfNewDay();
+        const exceeded = this.findExceeded(model, userId);
+        if (!exceeded)
+            return null;
+        if (this.mode === "block") {
+            throw new ToadBudgetExceededError(exceeded);
+        }
+        if (this.mode === "downgrade" && this.downgrade) {
+            return this.downgrade({ provider, model });
+        }
+        // 'warn' mode — continue, warning emitted after call
+        return null;
+    }
+    /** Record cost AFTER a successful LLM call. Returns exceeded info if budget was just crossed. */
+    recordCost(cost, model, userId) {
+        this.resetIfNewDay();
+        this.state.totalCost += cost;
+        this.state.perModel.set(model, (this.state.perModel.get(model) ?? 0) + cost);
+        if (userId) {
+            this.state.perUser.set(userId, (this.state.perUser.get(userId) ?? 0) + cost);
+        }
+        return this.findExceeded(model, userId);
+    }
+    /** Find which budget (if any) is exceeded. */
+    findExceeded(model, userId) {
+        if (this.config.daily !== undefined &&
+            this.state.totalCost >= this.config.daily) {
+            return {
+                budget: "daily",
+                limit: this.config.daily,
+                current: this.state.totalCost,
+            };
+        }
+        const modelLimit = this.config.perModel?.[model];
+        if (modelLimit !== undefined) {
+            const modelCost = this.state.perModel.get(model) ?? 0;
+            if (modelCost >= modelLimit) {
+                return {
+                    budget: "perModel",
+                    limit: modelLimit,
+                    current: modelCost,
+                    model,
+                };
+            }
+        }
+        if (this.config.perUser !== undefined && userId) {
+            const userCost = this.state.perUser.get(userId) ?? 0;
+            if (userCost >= this.config.perUser) {
+                return {
+                    budget: "perUser",
+                    limit: this.config.perUser,
+                    current: userCost,
+                    userId,
+                };
+            }
+        }
+        return null;
+    }
+    /** Get current budget usage as percentage (0-100+). */
+    getUsagePercent() {
+        if (this.config.daily === undefined || this.config.daily === 0)
+            return 0;
+        this.resetIfNewDay();
+        return (this.state.totalCost / this.config.daily) * 100;
+    }
+    /** Get current state snapshot (for persistence or debugging). */
+    getState() {
+        this.resetIfNewDay();
+        return this.state;
+    }
+    /** Restore state from persistence (e.g., on startup). */
+    restoreState(saved) {
+        if (saved.date !== todayUTC())
+            return; // stale state, ignore
+        this.state = {
+            date: saved.date,
+            totalCost: saved.totalCost,
+            perUser: new Map(Object.entries(saved.perUser)),
+            perModel: new Map(Object.entries(saved.perModel)),
+        };
+    }
+}

package/dist/budget/types.d.ts

@@ -0,0 +1,34 @@
+/** Budget configuration for initObservability(). */
+export interface BudgetConfig {
+    /** Max daily spend in USD for the entire application. */
+    readonly daily?: number | undefined;
+    /** Max daily spend in USD per user. Requires userId in traceLLMCall attributes. */
+    readonly perUser?: number | undefined;
+    /** Max daily spend in USD per model. */
+    readonly perModel?: Readonly<Record<string, number>> | undefined;
+}
+/** What happens when a budget is exceeded. */
+export type BudgetExceededMode = "warn" | "block" | "downgrade";
+/** Callback for 'downgrade' mode — receives original input, returns modified input. */
+export type DowngradeCallback = (original: {
+    readonly provider: string;
+    readonly model: string;
+}) => {
+    readonly provider: string;
+    readonly model: string;
+};
+/** Internal state tracking daily spend. */
+export interface BudgetState {
+    date: string;
+    totalCost: number;
+    perUser: Map<string, number>;
+    perModel: Map<string, number>;
+}
+/** Info about which budget was exceeded. */
+export interface BudgetExceededInfo {
+    readonly budget: "daily" | "perUser" | "perModel";
+    readonly limit: number;
+    readonly current: number;
+    readonly model?: string | undefined;
+    readonly userId?: string | undefined;
+}

package/dist/budget/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -1,9 +1,16 @@
 #!/usr/bin/env node
-import { execSync } from "node:child_process";
-import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { initObservability, traceLLMCall, shutdown, calculateCost, } from "./index.js";
 const INFRA_DIR = "infra/toad-eye";
+const DEMO_DELAY_MIN_MS = 200;
+const DEMO_DELAY_MAX_MS = 2000;
+const DEMO_ERROR_RATE = 0.1;
+const DEMO_TICK_INTERVAL_MS = 2000;
+const DEMO_TOKEN_INPUT_RANGE = [50, 500];
+const DEMO_TOKEN_OUTPUT_RANGE = [20, 300];
 const SERVICES = [
     { name: "Grafana", url: "http://localhost:3100", login: "admin / admin" },
     { name: "Jaeger UI", url: "http://localhost:16686" },
@@ -18,6 +25,14 @@ function getTemplatesDir() {
 function getComposeFile() {
     return join(process.cwd(), INFRA_DIR, "docker-compose.yml");
 }
+function requireInfra(message = `Run \`npx toad-eye init\` first.`) {
+    const composeFile = getComposeFile();
+    if (!existsSync(composeFile)) {
+        console.error(`\u274c ${INFRA_DIR}/ not found. ${message}`);
+        process.exit(1);
+    }
+    return composeFile;
+}
 function init() {
     const dest = join(process.cwd(), INFRA_DIR);
     if (existsSync(dest)) {
@@ -38,32 +53,20 @@ function init() {
     console.log("  npx toad-eye status  Check running services");
 }
 function up() {
-    const composeFile = getComposeFile();
-    if (!existsSync(composeFile)) {
-        console.error(`\u274c ${INFRA_DIR}/ not found. Run \`npx toad-eye init\` first.`);
-        process.exit(1);
-    }
+    const composeFile = requireInfra();
     console.log("\u{1f438} Starting observability stack...");
     execSync(`docker compose -f ${composeFile} up -d`, { stdio: "inherit" });
     console.log();
     status();
 }
 function down() {
-    const composeFile = getComposeFile();
-    if (!existsSync(composeFile)) {
-        console.error(`\u274c ${INFRA_DIR}/ not found. Nothing to stop.`);
-        process.exit(1);
-    }
+    const composeFile = requireInfra("Nothing to stop.");
     console.log("\u{1f44b} Stopping observability stack...");
     execSync(`docker compose -f ${composeFile} down`, { stdio: "inherit" });
     console.log("\u2705 Stack stopped.");
 }
 function status() {
-    const composeFile = getComposeFile();
-    if (!existsSync(composeFile)) {
-        console.error(`\u274c ${INFRA_DIR}/ not found. Run \`npx toad-eye init\` first.`);
-        process.exit(1);
-    }
+    const composeFile = requireInfra();
     try {
         const output = execSync(`docker compose -f ${composeFile} ps --format json`, {
             encoding: "utf-8",
@@ -84,6 +87,104 @@ function status() {
         console.log("Could not check container status. Is Docker running?");
     }
 }
+const DEMO_MODELS = [
+    { provider: "anthropic", model: "claude-sonnet-4-20250514" },
+    { provider: "gemini", model: "gemini-2.5-flash" },
+    { provider: "openai", model: "gpt-4o" },
+];
+function randomBetween(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+const DEMO_PROMPTS = [
+    "Explain quantum computing",
+    "Write a haiku about frogs",
+    "What is the capital of Uruguay?",
+    "How does TCP work?",
+    "Translate hello to Japanese",
+];
+function pickRandom(arr) {
+    return arr[randomBetween(0, arr.length - 1)];
+}
+async function simulateLLMCall(provider, model, prompt) {
+    await new Promise((r) => setTimeout(r, randomBetween(DEMO_DELAY_MIN_MS, DEMO_DELAY_MAX_MS)));
+    if (Math.random() < DEMO_ERROR_RATE) {
+        throw new Error(`${provider} API error: rate limit exceeded`);
+    }
+    const inputTokens = randomBetween(...DEMO_TOKEN_INPUT_RANGE);
+    const outputTokens = randomBetween(...DEMO_TOKEN_OUTPUT_RANGE);
+    return {
+        completion: `Mock response for: "${prompt}"`,
+        inputTokens,
+        outputTokens,
+        cost: calculateCost(model, inputTokens, outputTokens),
+    };
+}
+async function demo() {
+    requireInfra();
+    initObservability({
+        serviceName: "toad-eye-demo",
+        endpoint: "http://localhost:4318",
+    });
+    console.log("\u{1f438}\u{1f441}\u{fe0f} toad-eye demo — sending mock LLM traffic");
+    console.log("    Press Ctrl+C to stop\n");
+    process.on("SIGINT", async () => {
+        console.log("\n\u{1f44b} Shutting down...");
+        await shutdown();
+        process.exit(0);
+    });
+    const tick = async () => {
+        const { provider, model } = pickRandom(DEMO_MODELS);
+        const prompt = pickRandom(DEMO_PROMPTS);
+        try {
+            await traceLLMCall({ provider, model, prompt, temperature: 0.7 }, () => simulateLLMCall(provider, model, prompt));
+            console.log(`  \u2705 [${provider}/${model}] ${prompt}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  \u274c [${provider}/${model}] ${msg}`);
+        }
+    };
+    const run = () => {
+        tick().then(() => setTimeout(run, DEMO_TICK_INTERVAL_MS));
+    };
+    run();
+}
+async function exportTraceCommand() {
+    const traceId = process.argv[3];
+    if (!traceId) {
+        console.error("✗ Usage: npx toad-eye export-trace <trace_id> [--output dir] [--jaeger-url url]");
+        process.exit(1);
+    }
+    const args = process.argv.slice(4);
+    let outputDir = process.cwd();
+    let jaegerUrl;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--output" && args[i + 1]) {
+            outputDir = resolve(args[i + 1]);
+            i++;
+        }
+        else if (args[i] === "--jaeger-url" && args[i + 1]) {
+            jaegerUrl = args[i + 1];
+            i++;
+        }
+    }
+    const { exportTrace } = await import("./export.js");
+    try {
+        const yaml = await exportTrace(traceId, { jaegerUrl });
+        const filename = `trace-${traceId.slice(0, 8)}.eval.yaml`;
+        const filepath = join(outputDir, filename);
+        if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+        }
+        writeFileSync(filepath, yaml, "utf-8");
+        console.log(`✅ Exported trace ${traceId} → ${filepath}`);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`✗ ${msg}`);
+        process.exit(1);
+    }
+}
 function help() {
     console.log(`
 \u{1f438} toad-eye CLI — observability stack for LLM services
@@ -93,7 +194,9 @@ Commands:
   up       Start the stack (OTel Collector + Prometheus + Jaeger + Grafana)
   down     Stop the stack
   status   Show running services and URLs
-  help     Show this message
+  demo           Send mock LLM traffic to see data in Grafana
+  export-trace   Export a Jaeger trace to toad-eval YAML
+  help           Show this message
 `);
 }
 const command = process.argv[2];
@@ -110,6 +213,12 @@ switch (command) {
     case "status":
         status();
         break;
+    case "demo":
+        demo();
+        break;
+    case "export-trace":
+        exportTraceCommand();
+        break;
     case "help":
     case "--help":
     case "-h":

package/dist/core/metrics.d.ts

@@ -0,0 +1,14 @@
+export declare function initMetrics(): void;
+export declare function recordRequestDuration(ms: number, provider: string, model: string, attrs?: Record<string, string>): void;
+export declare function recordRequestCost(usd: number, provider: string, model: string, attrs?: Record<string, string>): void;
+export declare function recordTokens(count: number, provider: string, model: string, attrs?: Record<string, string>): void;
+export declare function recordRequest(provider: string, model: string, attrs?: Record<string, string>): void;
+export declare function recordError(provider: string, model: string, attrs?: Record<string, string>): void;
+export declare function recordAgentSteps(stepCount: number): void;
+export declare function recordAgentToolUsage(toolName: string): void;
+export declare function recordGuardEvaluation(ruleName: string): void;
+export declare function recordGuardWouldBlock(ruleName: string): void;
+export declare function recordSemanticDrift(drift: number, provider: string, model: string): void;
+export declare function recordBudgetExceeded(budgetType: string): void;
+export declare function recordBudgetBlocked(budgetType: string): void;
+export declare function recordBudgetDowngraded(budgetType: string): void;