@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/prometheus/tools/discovery.d.ts

@@ -0,0 +1,82 @@
+export declare const findSeries: import("ai").Tool<{
+    match: string[];
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+}, any>;
+export declare const labelNames: import("ai").Tool<{
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+    match?: string[] | undefined;
+}, any>;
+export declare const labelValues: import("ai").Tool<{
+    label: string;
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+    match?: string[] | undefined;
+}, any>;
+export declare const searchMetricNames: import("ai").Tool<{
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    search?: string[] | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+    match?: string[] | undefined;
+    includeMetadata?: boolean | undefined;
+    batchSize?: number | undefined;
+    fuzzThreshold?: number | undefined;
+    fuzzAlg?: "subsequence" | "jarowinkler" | undefined;
+    caseSensitive?: boolean | undefined;
+    sortBy?: string | undefined;
+    sortDir?: "asc" | "dsc" | undefined;
+    includeScore?: boolean | undefined;
+}, any>;
+export declare const searchLabelNames: import("ai").Tool<{
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    search?: string[] | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+    match?: string[] | undefined;
+    batchSize?: number | undefined;
+    fuzzThreshold?: number | undefined;
+    fuzzAlg?: "subsequence" | "jarowinkler" | undefined;
+    caseSensitive?: boolean | undefined;
+    sortBy?: string | undefined;
+    sortDir?: "asc" | "dsc" | undefined;
+    includeScore?: boolean | undefined;
+}, any>;
+export declare const searchLabelValues: import("ai").Tool<{
+    label: string;
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    search?: string[] | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+    match?: string[] | undefined;
+    batchSize?: number | undefined;
+    fuzzThreshold?: number | undefined;
+    fuzzAlg?: "subsequence" | "jarowinkler" | undefined;
+    caseSensitive?: boolean | undefined;
+    sortBy?: string | undefined;
+    sortDir?: "asc" | "dsc" | undefined;
+    includeScore?: boolean | undefined;
+}, any>;
+export declare const targetMetadata: import("ai").Tool<{
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    metric?: string | undefined;
+    matchTarget?: string | undefined;
+}, any>;
+export declare const metricMetadata: import("ai").Tool<{
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    metric?: string | undefined;
+    limitPerMetric?: number | undefined;
+}, any>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/toolkits/prometheus/tools/discovery.js

@@ -0,0 +1,182 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { promRequest, toPromError } from './client.js';
+const credsField = z.string().describe('Prometheus credentials JSON with baseUrl and optional username/password or bearerToken');
+const matchField = z.array(z.string()).optional().describe("Series selectors, e.g. ['up', 'process_start_time_seconds{job=\"prometheus\"}']");
+const startField = z.string().optional().describe('Start timestamp, RFC3339 or unix seconds');
+const endField = z.string().optional().describe('End timestamp, RFC3339 or unix seconds');
+const limitField = z.number().int().optional().describe('Max results (0 = disabled)');
+export const findSeries = tool({
+    description: 'Lists time series matching label selectors. Requires at least one match[] selector.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        match: z.array(z.string()).min(1).describe('Series selectors (at least one required)'),
+        start: startField,
+        end: endField,
+        limit: limitField,
+    }),
+    execute: async ({ prometheusCredentials, match, start, end, limit }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/series', {
+                query: { 'match[]': match, start, end, limit },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to find series');
+        }
+    },
+});
+export const labelNames = tool({
+    description: 'Lists label names, optionally scoped to series selectors and a time window.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        match: matchField,
+        start: startField,
+        end: endField,
+        limit: limitField,
+    }),
+    execute: async ({ prometheusCredentials, match, start, end, limit }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/labels', {
+                query: { 'match[]': match, start, end, limit },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to list label names');
+        }
+    },
+});
+export const labelValues = tool({
+    description: 'Lists values for a label name, optionally scoped to series selectors and a time window.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        label: z.string().describe("Label name, e.g. 'job'. Names with '/' need U__ escaping (see docs)."),
+        match: matchField,
+        start: startField,
+        end: endField,
+        limit: limitField,
+    }),
+    execute: async ({ prometheusCredentials, label, match, start, end, limit }) => {
+        try {
+            return await promRequest(prometheusCredentials, `/api/v1/label/${encodeURIComponent(label)}/values`, {
+                query: { 'match[]': match, start, end, limit },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to list label values');
+        }
+    },
+});
+const searchBase = {
+    match: matchField.describe('Series selectors scoping the search'),
+    search: z.array(z.string()).optional().describe('Search strings (OR semantics)'),
+    start: startField,
+    end: endField,
+    limit: z.number().int().optional().describe('Max results (default 100)'),
+    batchSize: z.number().int().optional().describe('Preferred NDJSON batch size (default 100)'),
+    fuzzThreshold: z.number().optional().describe('Fuzzy threshold 0-100'),
+    fuzzAlg: z.enum(['subsequence', 'jarowinkler']).optional().describe('Matching algorithm (default subsequence)'),
+    caseSensitive: z.boolean().optional().describe('Case-sensitive matching'),
+    sortBy: z.string().optional().describe("Sort mode, e.g. 'alpha' or 'score'"),
+    sortDir: z.enum(['asc', 'dsc']).optional().describe('Sort direction (only with sort_by=alpha)'),
+    includeScore: z.boolean().optional().describe('Include relevance score'),
+};
+export const searchMetricNames = tool({
+    description: 'Streams metric-name autocomplete results (NDJSON). Experimental; requires --enable-feature=search-api.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        ...searchBase,
+        includeMetadata: z.boolean().optional().describe('Include metric type/help metadata'),
+    }),
+    execute: async (input) => {
+        try {
+            const { prometheusCredentials, match, search, ...rest } = input;
+            return await promRequest(prometheusCredentials, '/api/v1/search/metric_names', {
+                query: { 'match[]': match, 'search[]': search, ...rest },
+                acceptNdjson: true,
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to search metric names');
+        }
+    },
+});
+export const searchLabelNames = tool({
+    description: 'Streams label-name autocomplete results (NDJSON). Experimental; requires --enable-feature=search-api.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        ...searchBase,
+    }),
+    execute: async (input) => {
+        try {
+            const { prometheusCredentials, match, search, ...rest } = input;
+            return await promRequest(prometheusCredentials, '/api/v1/search/label_names', {
+                query: { 'match[]': match, 'search[]': search, ...rest },
+                acceptNdjson: true,
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to search label names');
+        }
+    },
+});
+export const searchLabelValues = tool({
+    description: 'Streams label-value autocomplete results (NDJSON) for a label. Experimental; requires --enable-feature=search-api.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        label: z.string().describe('Label name whose values to search (required)'),
+        ...searchBase,
+    }),
+    execute: async (input) => {
+        try {
+            const { prometheusCredentials, label, match, search, ...rest } = input;
+            return await promRequest(prometheusCredentials, '/api/v1/search/label_values', {
+                query: { label, 'match[]': match, 'search[]': search, ...rest },
+                acceptNdjson: true,
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to search label values');
+        }
+    },
+});
+export const targetMetadata = tool({
+    description: 'Returns metric metadata scraped from targets (type/help/unit). Experimental; remote-write/OTLP metadata excluded.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        matchTarget: z.string().optional().describe('Target label selectors, e.g. {job="prometheus"} (empty = all)'),
+        metric: z.string().optional().describe('Metric name filter (empty = all)'),
+        limit: z.number().int().optional().describe('Max targets to match'),
+    }),
+    execute: async ({ prometheusCredentials, matchTarget, metric, limit }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/targets/metadata', {
+                query: { match_target: matchTarget, metric, limit },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get target metadata');
+        }
+    },
+});
+export const metricMetadata = tool({
+    description: 'Returns metric metadata (type/help/unit per metric name) without target info. Experimental.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        metric: z.string().optional().describe('Metric name filter (empty = all)'),
+        limit: z.number().int().optional().describe('Max metrics to return'),
+        limitPerMetric: z.number().int().optional().describe('Max metadata entries per metric'),
+    }),
+    execute: async ({ prometheusCredentials, metric, limit, limitPerMetric }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/metadata', {
+                query: { metric, limit, limit_per_metric: limitPerMetric },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get metric metadata');
+        }
+    },
+});
+//# sourceMappingURL=discovery.js.map

package/dist/toolkits/prometheus/tools/index.d.ts

@@ -0,0 +1,16 @@
+import { cleanTombstones, deleteSeries, reloadConfig, shutdownServer, snapshot } from './admin.js';
+import { findSeries, labelNames, labelValues, metricMetadata, searchLabelNames, searchLabelValues, searchMetricNames, targetMetadata } from './discovery.js';
+import { formatQuery, instantQuery, parseQuery, queryExemplars, rangeQuery } from './query.js';
+import { alertmanagers, alerts, rules, scrapePools, targetRelabelSteps, targets } from './targets.js';
+import { federate, healthy, listNotifications, liveNotifications, ready, statusBuildInfo, statusConfig, statusFlags, statusRuntimeInfo, statusSelfMetrics, statusTsdb, statusTsdbBlocks, statusWalReplay } from './status.js';
+export { instantQuery, rangeQuery, formatQuery, parseQuery, queryExemplars, findSeries, labelNames, labelValues, searchMetricNames, searchLabelNames, searchLabelValues, targetMetadata, metricMetadata, scrapePools, targets, targetRelabelSteps, rules, alerts, alertmanagers, statusConfig, statusFlags, statusRuntimeInfo, statusBuildInfo, statusTsdb, statusTsdbBlocks, statusWalReplay, statusSelfMetrics, healthy, ready, federate, deleteSeries, cleanTombstones, snapshot, reloadConfig, shutdownServer, listNotifications, liveNotifications, };
+declare const auth: "prometheusCredentials";
+type Scope = 'read' | 'write' | 'delete';
+export declare const prometheusTools: {
+    name: string;
+    description: string;
+    tool: any;
+    requiredAuth: typeof auth;
+    scope: Scope;
+}[];
+//# sourceMappingURL=index.d.ts.map

package/dist/toolkits/prometheus/tools/index.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { cleanTombstones, deleteSeries, reloadConfig, shutdownServer, snapshot } from './admin.js';
+import { findSeries, labelNames, labelValues, metricMetadata, searchLabelNames, searchLabelValues, searchMetricNames, targetMetadata, } from './discovery.js';
+import { formatQuery, instantQuery, parseQuery, queryExemplars, rangeQuery } from './query.js';
+import { alertmanagers, alerts, rules, scrapePools, targetRelabelSteps, targets, } from './targets.js';
+import { federate, healthy, listNotifications, liveNotifications, ready, statusBuildInfo, statusConfig, statusFlags, statusRuntimeInfo, statusSelfMetrics, statusTsdb, statusTsdbBlocks, statusWalReplay, } from './status.js';
+export { instantQuery, rangeQuery, formatQuery, parseQuery, queryExemplars, findSeries, labelNames, labelValues, searchMetricNames, searchLabelNames, searchLabelValues, targetMetadata, metricMetadata, scrapePools, targets, targetRelabelSteps, rules, alerts, alertmanagers, statusConfig, statusFlags, statusRuntimeInfo, statusBuildInfo, statusTsdb, statusTsdbBlocks, statusWalReplay, statusSelfMetrics, healthy, ready, federate, deleteSeries, cleanTombstones, snapshot, reloadConfig, shutdownServer, listNotifications, liveNotifications, };
+const auth = 'prometheusCredentials';
+function entry(name, description, toolRef, scope) {
+    return { name, description, tool: toolRef, requiredAuth: auth, scope };
+}
+export const prometheusTools = [
+    entry('prometheusInstantQuery', 'Evaluates a PromQL expression at one instant.', instantQuery, 'read'),
+    entry('prometheusRangeQuery', 'Evaluates a PromQL expression over a time range.', rangeQuery, 'read'),
+    entry('prometheusFormatQuery', 'Prettifies a PromQL expression.', formatQuery, 'read'),
+    entry('prometheusParseQuery', 'Parses PromQL into a JSON AST (experimental).', parseQuery, 'read'),
+    entry('prometheusQueryExemplars', 'Returns exemplars for a query over a range (experimental).', queryExemplars, 'read'),
+    entry('prometheusFindSeries', 'Lists series matching label selectors.', findSeries, 'read'),
+    entry('prometheusLabelNames', 'Lists label names, optionally scoped.', labelNames, 'read'),
+    entry('prometheusLabelValues', 'Lists values for a label name.', labelValues, 'read'),
+    entry('prometheusSearchMetricNames', 'Streams metric-name autocomplete (NDJSON, experimental).', searchMetricNames, 'read'),
+    entry('prometheusSearchLabelNames', 'Streams label-name autocomplete (NDJSON, experimental).', searchLabelNames, 'read'),
+    entry('prometheusSearchLabelValues', 'Streams label-value autocomplete (NDJSON, experimental).', searchLabelValues, 'read'),
+    entry('prometheusTargetMetadata', 'Returns metric metadata scraped from targets (experimental).', targetMetadata, 'read'),
+    entry('prometheusMetricMetadata', 'Returns metric metadata without target info (experimental).', metricMetadata, 'read'),
+    entry('prometheusScrapePools', 'Lists configured scrape pool names.', scrapePools, 'read'),
+    entry('prometheusTargets', 'Returns scrape target discovery state.', targets, 'read'),
+    entry('prometheusTargetRelabelSteps', 'Shows relabeling steps for a target label set (experimental).', targetRelabelSteps, 'read'),
+    entry('prometheusRules', 'Lists alerting/recording rules with active alerts.', rules, 'read'),
+    entry('prometheusAlerts', 'Lists all active alerts.', alerts, 'read'),
+    entry('prometheusAlertmanagers', 'Returns Alertmanager discovery state.', alertmanagers, 'read'),
+    entry('prometheusStatusConfig', 'Returns the loaded server config as YAML.', statusConfig, 'read'),
+    entry('prometheusStatusFlags', 'Returns server startup flag values.', statusFlags, 'read'),
+    entry('prometheusStatusRuntimeInfo', 'Returns runtime info (uptime, series, retention).', statusRuntimeInfo, 'read'),
+    entry('prometheusStatusBuildInfo', 'Returns build info (version, revision).', statusBuildInfo, 'read'),
+    entry('prometheusStatusTsdb', 'Returns TSDB cardinality stats.', statusTsdb, 'read'),
+    entry('prometheusStatusTsdbBlocks', 'Lists loaded TSDB blocks (experimental).', statusTsdbBlocks, 'read'),
+    entry('prometheusStatusWalReplay', 'Returns WAL replay progress.', statusWalReplay, 'read'),
+    entry('prometheusStatusSelfMetrics', 'Returns internal metrics as JSON (experimental).', statusSelfMetrics, 'read'),
+    entry('prometheusHealthy', 'Liveness check (/-/healthy).', healthy, 'read'),
+    entry('prometheusReady', 'Readiness check (/-/ready).', ready, 'read'),
+    entry('prometheusFederate', 'Federation endpoint returning series in exposition format.', federate, 'read'),
+    entry('prometheusDeleteSeries', 'Deletes series via tombstones (admin API flag required).', deleteSeries, 'delete'),
+    entry('prometheusCleanTombstones', 'Purges tombstoned data from disk (admin API flag required).', cleanTombstones, 'delete'),
+    entry('prometheusSnapshot', 'Creates a TSDB snapshot for backups (admin API flag required).', snapshot, 'write'),
+    entry('prometheusListNotifications', 'Lists current UI notifications.', listNotifications, 'read'),
+    entry('prometheusLiveNotifications', 'Collects live UI notifications over SSE, time-boxed.', liveNotifications, 'read'),
+    entry('prometheusReloadConfig', 'Reloads config and rule files (lifecycle flag required).', reloadConfig, 'write'),
+    entry('prometheusShutdownServer', 'Graceful server shutdown (lifecycle flag required).', shutdownServer, 'delete'),
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/prometheus/tools/query.d.ts

@@ -0,0 +1,33 @@
+export declare const instantQuery: import("ai").Tool<{
+    query: string;
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    timeout?: string | undefined;
+    time?: string | undefined;
+    stats?: string | undefined;
+}, any>;
+export declare const rangeQuery: import("ai").Tool<{
+    query: string;
+    start: string;
+    end: string;
+    step: string;
+    prometheusCredentials: string;
+    limit?: number | undefined;
+    timeout?: string | undefined;
+    stats?: string | undefined;
+}, any>;
+export declare const formatQuery: import("ai").Tool<{
+    query: string;
+    prometheusCredentials: string;
+}, any>;
+export declare const parseQuery: import("ai").Tool<{
+    query: string;
+    prometheusCredentials: string;
+}, any>;
+export declare const queryExemplars: import("ai").Tool<{
+    query: string;
+    start: string;
+    end: string;
+    prometheusCredentials: string;
+}, any>;
+//# sourceMappingURL=query.d.ts.map

package/dist/toolkits/prometheus/tools/query.js

@@ -0,0 +1,101 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { promRequest, toPromError } from './client.js';
+const credsField = z.string().describe('Prometheus credentials JSON with baseUrl and optional username/password or bearerToken');
+const timeField = z.string().optional().describe('RFC3339 or unix timestamp in seconds (decimals allowed)');
+const timeoutField = z.string().optional().describe('Evaluation timeout, e.g. 30s (capped by server -query.timeout)');
+export const instantQuery = tool({
+    description: 'Evaluates a PromQL expression at a single instant. Returns vector/scalar/string result.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        query: z.string().describe("PromQL expression, e.g. 'up' or 'sum(rate(http_requests_total[5m]))'"),
+        time: timeField.describe('Evaluation timestamp (default: server time)'),
+        timeout: timeoutField,
+        limit: z.number().int().optional().describe('Max returned series (0 = disabled)'),
+        stats: z.string().optional().describe("Query stats: 'true' or 'all'"),
+    }),
+    execute: async ({ prometheusCredentials, query, time, timeout, limit, stats }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/query', {
+                query: { query, time, timeout, limit, stats },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to run instant query');
+        }
+    },
+});
+export const rangeQuery = tool({
+    description: 'Evaluates a PromQL expression over a time range. Returns a matrix (values per step).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        query: z.string().describe("PromQL expression, e.g. 'up'"),
+        start: z.string().describe('Range start, RFC3339 or unix timestamp (inclusive)'),
+        end: z.string().describe('Range end, RFC3339 or unix timestamp (inclusive)'),
+        step: z.string().describe('Resolution, e.g. 15s, 1m, or float seconds'),
+        timeout: timeoutField,
+        limit: z.number().int().optional().describe('Max returned series (0 = disabled)'),
+        stats: z.string().optional().describe("Query stats: 'true' or 'all'"),
+    }),
+    execute: async ({ prometheusCredentials, query, start, end, step, timeout, limit, stats }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/query_range', {
+                query: { query, start, end, step, timeout, limit, stats },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to run range query');
+        }
+    },
+});
+export const formatQuery = tool({
+    description: 'Prettifies a PromQL expression (comments are removed). Use to normalize queries before storing or comparing.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        query: z.string().describe("PromQL expression, e.g. 'foo/bar'"),
+    }),
+    execute: async ({ prometheusCredentials, query }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/format_query', { query: { query } });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to format query');
+        }
+    },
+});
+export const parseQuery = tool({
+    description: 'Parses a PromQL expression into a JSON AST. Experimental endpoint (primarily for the web UI); format may change.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        query: z.string().describe('PromQL expression to parse'),
+    }),
+    execute: async ({ prometheusCredentials, query }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/parse_query', { query: { query } });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to parse query');
+        }
+    },
+});
+export const queryExemplars = tool({
+    description: 'Returns exemplars (e.g. trace IDs) for a PromQL query over a time range. Experimental; may change.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        query: z.string().describe('PromQL expression, e.g. test_exemplar_metric_total'),
+        start: z.string().describe('Range start, RFC3339 or unix timestamp'),
+        end: z.string().describe('Range end, RFC3339 or unix timestamp'),
+    }),
+    execute: async ({ prometheusCredentials, query, start, end }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/query_exemplars', {
+                query: { query, start, end },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to query exemplars');
+        }
+    },
+});
+//# sourceMappingURL=query.js.map

package/dist/toolkits/prometheus/tools/status.d.ts

@@ -0,0 +1,66 @@
+export declare const statusConfig: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const statusFlags: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const statusRuntimeInfo: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const statusBuildInfo: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const statusTsdb: import("ai").Tool<{
+    prometheusCredentials: string;
+    limit?: number | undefined;
+}, any>;
+export declare const statusTsdbBlocks: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const statusWalReplay: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const statusSelfMetrics: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const healthy: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const ready: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const federate: import("ai").Tool<{
+    match: string[];
+    prometheusCredentials: string;
+}, any>;
+export declare const listNotifications: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const liveNotifications: import("ai").Tool<{
+    prometheusCredentials: string;
+    durationSeconds?: number | undefined;
+}, {
+    error: string;
+    details: any;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+} | {
+    error: string;
+    status: number;
+    events?: undefined;
+    truncated?: undefined;
+} | {
+    events: unknown[];
+    error?: undefined;
+    status?: undefined;
+    truncated?: undefined;
+} | {
+    events: unknown[];
+    truncated: boolean;
+    error?: undefined;
+    status?: undefined;
+}>;
+//# sourceMappingURL=status.d.ts.map