@nordbyte/nordrelay 0.5.2 → 0.6.0

package/dist/discord-channel-runtime.js

@@ -0,0 +1,133 @@
+import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle, Client, } from "discord.js";
+import { DiscordChannelAdapter, } from "./channel-adapter.js";
+import { discordRateLimiter } from "./discord-rate-limit.js";
+import { redactText } from "./redaction.js";
+const DISCORD_MESSAGE_LIMIT = 2000;
+const DISCORD_SAFE_MESSAGE_LIMIT = 1900;
+export const DISCORD_ACTION_PREFIX = "nr:";
+export class DiscordBotChannelRuntime {
+    client;
+    id = "discord";
+    label = "Discord";
+    capabilities = new DiscordChannelAdapter().capabilities;
+    constructor(client) {
+        this.client = client;
+    }
+    describe() {
+        return new DiscordChannelAdapter().describe();
+    }
+    async sendMessage(context, message) {
+        const channel = await this.resolveChannel(context, message.threadId);
+        const content = discordMessageText(message);
+        const chunks = splitDiscordMessage(content);
+        let first = null;
+        for (const [index, chunk] of chunks.entries()) {
+            const sent = await discordRateLimiter.run(discordBucket(context), "sendMessage", () => channel.send({
+                content: chunk,
+                components: index === chunks.length - 1 ? discordActionRows(message.buttons) : [],
+                allowedMentions: { parse: [] },
+            }));
+            first ??= sent;
+        }
+        return { messageId: first?.id ?? "" };
+    }
+    async editMessage(context, messageId, message) {
+        const channel = await this.resolveChannel(context, message.threadId);
+        const existing = await channel.messages.fetch(messageId).catch(() => null);
+        if (!existing) {
+            await this.sendMessage(context, message);
+            return;
+        }
+        await discordRateLimiter.run(discordBucket(context), "editMessage", () => existing.edit({
+            content: trimDiscordMessage(discordMessageText(message)),
+            components: discordActionRows(message.buttons),
+            allowedMentions: { parse: [] },
+        }));
+    }
+    async sendTyping(context) {
+        const channel = await this.resolveChannel(context);
+        await discordRateLimiter.run(discordBucket(context), "typing", () => channel.sendTyping());
+    }
+    async sendFile(context, file) {
+        const channel = await this.resolveChannel(context, file.threadId);
+        const sent = await discordRateLimiter.run(discordBucket(context), "sendFile", () => channel.send({
+            content: file.caption ? trimDiscordMessage(redactText(file.caption)) : undefined,
+            files: [new AttachmentBuilder(file.localPath, { name: file.name })],
+            allowedMentions: { parse: [] },
+        }));
+        return { messageId: sent.id };
+    }
+    async resolveChannel(context, overrideThreadId) {
+        const id = overrideThreadId ?? context.topicId ?? context.chatId;
+        const channel = await this.client.channels.fetch(id);
+        if (!channel?.isTextBased() || !("send" in channel) || !("messages" in channel)) {
+            throw new Error(`Discord channel is not text-capable: ${id}`);
+        }
+        return channel;
+    }
+}
+function discordBucket(context) {
+    return context.topicId ?? context.chatId;
+}
+export function discordMessageText(message) {
+    return message.fallbackText?.trim() || stripTelegramHtml(message.text).trim() || ".";
+}
+export function discordActionRows(rows) {
+    if (!rows?.length) {
+        return [];
+    }
+    return rows.slice(0, 5).map((row) => new ActionRowBuilder()
+        .addComponents(row.slice(0, 5).map((button) => new ButtonBuilder()
+        .setCustomId(discordActionId(button.action))
+        .setLabel(trimButtonLabel(button.label))
+        .setStyle(ButtonStyle.Secondary)))
+        .toJSON());
+}
+export function discordActionId(action) {
+    const raw = `${DISCORD_ACTION_PREFIX}${action}`;
+    return raw.length <= 100 ? raw : `${DISCORD_ACTION_PREFIX}${action.slice(0, 97 - DISCORD_ACTION_PREFIX.length)}`;
+}
+export function actionFromDiscordCustomId(customId) {
+    return customId.startsWith(DISCORD_ACTION_PREFIX) ? customId.slice(DISCORD_ACTION_PREFIX.length) : null;
+}
+export function splitDiscordMessage(text) {
+    const normalized = text || ".";
+    if (normalized.length <= DISCORD_SAFE_MESSAGE_LIMIT) {
+        return [normalized];
+    }
+    const chunks = [];
+    let remaining = normalized;
+    while (remaining.length > 0) {
+        const slice = remaining.slice(0, DISCORD_SAFE_MESSAGE_LIMIT);
+        const breakAt = Math.max(slice.lastIndexOf("\n"), slice.lastIndexOf(" "));
+        const length = breakAt > 400 ? breakAt : DISCORD_SAFE_MESSAGE_LIMIT;
+        chunks.push(remaining.slice(0, length).trimEnd() || ".");
+        remaining = remaining.slice(length).trimStart();
+    }
+    return chunks;
+}
+export function trimDiscordMessage(text) {
+    return text.length <= DISCORD_MESSAGE_LIMIT ? text : `${text.slice(0, DISCORD_MESSAGE_LIMIT - 1)}…`;
+}
+export function discordMessageOptions(message) {
+    return {
+        content: trimDiscordMessage(discordMessageText(message)),
+        components: discordActionRows(message.buttons),
+        allowedMentions: { parse: [] },
+    };
+}
+function stripTelegramHtml(text) {
+    return text
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|li|pre)>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .replace(/&quot;/g, "\"")
+        .replace(/&#39;/g, "'");
+}
+function trimButtonLabel(label) {
+    const trimmed = label.trim() || "Action";
+    return trimmed.length <= 80 ? trimmed : trimmed.slice(0, 80);
+}

package/dist/discord-command-surface.js

@@ -0,0 +1,119 @@
+import { permissionForCommand } from "./access-control.js";
+export function parseDiscordMessageCommand(text) {
+    const match = text.match(/^\/([a-zA-Z0-9_-]+)(?:\s+([\s\S]*))?$/);
+    return match?.[1] ? { command: match[1].toLowerCase(), argument: match[2]?.trim() ?? "" } : null;
+}
+export function argumentFromDiscordInteraction(interaction) {
+    if (interaction.commandName === "prompt") {
+        return interaction.options.getString("text") ?? "";
+    }
+    if (interaction.commandName === "queue") {
+        return [interaction.options.getString("action"), interaction.options.getString("id")].filter(Boolean).join(" ");
+    }
+    if (interaction.commandName === "update") {
+        return [interaction.options.getString("target"), interaction.options.getString("agent"), interaction.options.getString("input")].filter(Boolean).join(" ");
+    }
+    return interaction.options.getString("value") ?? interaction.options.getString("query") ?? interaction.options.getString("thread_id") ?? "";
+}
+export function requiredPermissionForDiscordCommand(command, argument) {
+    if (command === "prompt")
+        return "prompt.send";
+    if (command === "queue")
+        return argument.trim() ? "queue.write" : "queue.read";
+    return permissionForCommand(command);
+}
+export function isUnauthenticatedDiscordCommandAllowed(command) {
+    return command === "link";
+}
+export function permissionForDiscordAction(action) {
+    if (action.startsWith("discord_queue_"))
+        return "queue.write";
+    if (action.startsWith("discord_abort:"))
+        return "prompt.abort";
+    if (action.startsWith("discord_pick:"))
+        return "sessions.write";
+    if (action.startsWith("discord_artifact_delete:"))
+        return "files.write";
+    if (action.startsWith("discord_artifact_"))
+        return "files.read";
+    if (action.startsWith("agent-update:"))
+        return "updates.run";
+    return null;
+}
+export function discordCommands() {
+    const textOption = (name = "value", description = "Value", required = false) => ({
+        type: 3,
+        name,
+        description,
+        required,
+    });
+    return [
+        command("start", "Start or inspect the current NordRelay context"),
+        command("help", "Show Discord adapter help"),
+        command("prompt", "Send a prompt to the selected agent", [textOption("text", "Prompt text", true)]),
+        command("agent", "Select or show the active agent", [textOption("value", "Agent id")]),
+        command("auth", "Show selected agent auth status"),
+        command("login", "Start selected agent login"),
+        command("logout", "Sign out of the selected agent"),
+        command("session", "Show the active session"),
+        command("sessions", "Browse recent sessions", [textOption("query", "Search query")]),
+        command("new", "Create a new session", [textOption("value", "Workspace path")]),
+        command("switch", "Switch to a session", [textOption("thread_id", "Thread id", true)]),
+        command("attach", "Attach a session", [textOption("thread_id", "Thread id", true)]),
+        command("handback", "Hand the active session back to the native CLI"),
+        command("model", "Select or show models", [textOption("value", "Model id")]),
+        command("reasoning", "Select reasoning effort", [textOption("value", "Reasoning value")]),
+        command("effort", "Select reasoning effort", [textOption("value", "Reasoning value")]),
+        command("fast", "Toggle fast mode", [textOption("value", "on/off")]),
+        command("launch", "Select launch profile", [textOption("value", "Launch profile id")]),
+        command("launch_profiles", "Select launch profile", [textOption("value", "Launch profile id")]),
+        command("workspaces", "List allowed workspaces"),
+        command("pin", "Pin current or given thread", [textOption("value", "Thread id")]),
+        command("unpin", "Unpin current or given thread", [textOption("value", "Thread id")]),
+        command("pinned", "Show pinned threads"),
+        command("queue", "Show or manage queue", [textOption("action", "pause/resume/clear/run/cancel/top/up/down"), textOption("id", "Queue id")]),
+        command("clearqueue", "Clear queue"),
+        command("cancel", "Cancel queued prompt", [textOption("value", "Queue id", true)]),
+        command("abort", "Abort the active task"),
+        command("stop", "Abort the active task"),
+        command("retry", "Retry the last prompt"),
+        command("sync", "Sync from local agent state"),
+        command("activity", "Show recent activity", [textOption("value", "Limit")]),
+        command("tasks", "Show recent tasks", [textOption("value", "Limit")]),
+        command("progress", "Show current turn progress"),
+        command("audit", "Show recent audit events", [textOption("value", "Limit")]),
+        command("artifacts", "List or send artifacts", [textOption("value", "zip <turn-id>")]),
+        command("logs", "Show logs", [textOption("value", "Target and line count")]),
+        command("version", "Show versions"),
+        command("status", "Show status"),
+        command("health", "Show health"),
+        command("diagnostics", "Show diagnostics"),
+        command("support", "Show support diagnostics"),
+        command("restart", "Restart NordRelay"),
+        command("update", "Update NordRelay or agents", [
+            textOption("target", "jobs, install, log, cancel, input, or agent id"),
+            textOption("agent", "Agent id or job id"),
+            textOption("input", "Text for update input"),
+        ]),
+        command("lock", "Lock this context"),
+        command("unlock", "Unlock this context"),
+        command("locks", "List locks"),
+        command("mirror", "Set mirror mode", [textOption("value", "off/status/final/full")]),
+        command("notify", "Set notification mode", [textOption("value", "off/minimal/all")]),
+        command("voice", "Show or change voice settings", [textOption("value", "transcribe-only on/off")]),
+        command("register_channel", "Enable this Discord channel for NordRelay"),
+        command("link", "Link this Discord account with a NordRelay code", [textOption("value", "Link code", true)]),
+        command("whoami", "Show linked NordRelay user"),
+        command("channels", "Show channel adapters"),
+        command("agents", "Show agent adapters"),
+    ];
+}
+function command(name, description, options = []) {
+    return {
+        name,
+        description,
+        type: 1,
+        dm_permission: true,
+        options,
+    };
+}

package/dist/discord-rate-limit.js

@@ -0,0 +1,141 @@
+const DEFAULT_OPTIONS = {
+    minIntervalMs: 250,
+    editMinIntervalMs: 1_500,
+    typingMinIntervalMs: 4_500,
+    maxRetries: 5,
+};
+export class DiscordRateLimiter {
+    options;
+    buckets = new Map();
+    queued = 0;
+    running = 0;
+    completed = 0;
+    failed = 0;
+    retries = 0;
+    rateLimitHits = 0;
+    lastRateLimitAt;
+    lastRetryAfterSeconds;
+    constructor(options = DEFAULT_OPTIONS) {
+        this.options = options;
+    }
+    configure(options) {
+        this.options = { ...this.options, ...options };
+    }
+    async run(bucket, method, operation) {
+        const normalizedBucket = `${method}:${bucket}`;
+        const state = this.getBucket(normalizedBucket);
+        this.queued += 1;
+        let releasePrevious;
+        const previous = state.chain;
+        state.chain = new Promise((resolve) => {
+            releasePrevious = resolve;
+        });
+        await previous.catch(() => { });
+        this.queued = Math.max(0, this.queued - 1);
+        this.running += 1;
+        try {
+            await this.waitForBucket(state, method);
+            const result = await this.runWithRetries(operation);
+            this.completed += 1;
+            state.lastRunAtMs = Date.now();
+            state.queuedUntilMs = Math.max(state.queuedUntilMs, state.lastRunAtMs + this.intervalForMethod(method));
+            return result;
+        }
+        catch (error) {
+            this.failed += 1;
+            throw error;
+        }
+        finally {
+            this.running = Math.max(0, this.running - 1);
+            releasePrevious();
+        }
+    }
+    getMetrics() {
+        return {
+            queued: this.queued,
+            running: this.running,
+            completed: this.completed,
+            failed: this.failed,
+            retries: this.retries,
+            rateLimitHits: this.rateLimitHits,
+            lastRateLimitAt: this.lastRateLimitAt,
+            lastRetryAfterSeconds: this.lastRetryAfterSeconds,
+            buckets: [...this.buckets.entries()]
+                .filter(([, state]) => state.queuedUntilMs > Date.now() || state.lastRunAtMs > 0)
+                .slice(0, 12)
+                .map(([bucket, state]) => ({
+                bucket,
+                queuedUntilMs: state.queuedUntilMs,
+                lastRunAtMs: state.lastRunAtMs,
+            })),
+        };
+    }
+    getBucket(bucket) {
+        let state = this.buckets.get(bucket);
+        if (!state) {
+            state = {
+                chain: Promise.resolve(),
+                queuedUntilMs: 0,
+                lastRunAtMs: 0,
+            };
+            this.buckets.set(bucket, state);
+        }
+        return state;
+    }
+    async waitForBucket(state, method) {
+        const interval = this.intervalForMethod(method);
+        const now = Date.now();
+        const earliest = Math.max(state.queuedUntilMs, state.lastRunAtMs + interval);
+        if (earliest > now) {
+            await delay(earliest - now);
+        }
+    }
+    async runWithRetries(operation) {
+        let attempt = 0;
+        while (true) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                const retryAfterSeconds = getRetryAfterSeconds(error);
+                if (retryAfterSeconds === undefined || attempt >= this.options.maxRetries) {
+                    throw error;
+                }
+                attempt += 1;
+                this.retries += 1;
+                this.rateLimitHits += 1;
+                this.lastRateLimitAt = new Date().toISOString();
+                this.lastRetryAfterSeconds = retryAfterSeconds;
+                await delay((retryAfterSeconds * 1000) + 250);
+            }
+        }
+    }
+    intervalForMethod(method) {
+        if (method.startsWith("edit"))
+            return this.options.editMinIntervalMs;
+        if (method.startsWith("typing"))
+            return this.options.typingMinIntervalMs;
+        return this.options.minIntervalMs;
+    }
+}
+export const discordRateLimiter = new DiscordRateLimiter();
+export function getDiscordRateLimitMetrics() {
+    return discordRateLimiter.getMetrics();
+}
+function getRetryAfterSeconds(error) {
+    const candidate = error;
+    const direct = candidate.retryAfter ?? candidate.rawError?.retry_after ?? candidate.data?.retry_after;
+    if (typeof direct === "number" && Number.isFinite(direct)) {
+        return Math.max(1, direct > 100 ? direct / 1000 : direct);
+    }
+    const text = typeof candidate.message === "string" ? candidate.message : "";
+    const match = text.match(/retry[_ -]?after["':\s]+(\d+(?:\.\d+)?)/i);
+    if (!match) {
+        return undefined;
+    }
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? Math.max(1, parsed) : undefined;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { webhookCallback } from "grammy";
 import { agentLabel } from "./agent.js";
 import { createBot, registerCommands } from "./bot.js";
+import { createDiscordBridge } from "./discord-bot.js";
 import { checkAuthStatus } from "./codex-auth.js";
 import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
 import { checkClaudeCodeAuthStatus } from "./claude-code-auth.js";
@@ -23,6 +24,7 @@ import { SessionRegistry } from "./session-registry.js";
 import { UserStore } from "./user-management.js";
 let registry;
 let bot;
+let discordBridge;
 let webhookServer;
 let runtimeConfig;
 try {
@@ -31,8 +33,12 @@ try {
     configureRedaction(config.telegramRedactPatterns);
     installConsoleLogger(config.logFormat);
     registry = new SessionRegistry(config);
-    bot = createBot(config, registry);
-    await registerCommands(bot);
+    if (config.telegramEnabled) {
+        bot = createBot(config, registry);
+        await registerCommands(bot);
+    }
+    discordBridge = createDiscordBridge(config, registry);
+    await discordBridge?.start();
     console.log("NordRelay running");
     const userStore = new UserStore();
     if (userStore.hasAdminUser()) {
@@ -74,14 +80,15 @@ try {
             console.warn("Warning: Default launch profile uses danger-full-access.");
         }
     }
-    console.log("Session mode: per Telegram context");
-    console.log(`Telegram transport: ${config.telegramTransport}`);
+    console.log("Session mode: per chat context");
+    console.log(`Telegram: ${config.telegramEnabled ? config.telegramTransport : "disabled"}`);
+    console.log(`Discord: ${config.discordEnabled ? "enabled" : "disabled"}`);
     await writeConnectorState({
         status: "ready",
         pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,
         appPid: process.pid,
         workspace: config.workspace,
-        sessionMode: "per Telegram context",
+        sessionMode: "per chat context",
         authenticated: authStatus.authenticated,
         authMethod: authStatus.method,
         codexCli: describeCodexCli(codexCli),
@@ -91,6 +98,7 @@ try {
         claudeCodeCli: describeClaudeCodeCli(claudeCodeCli),
         openClawGateway: config.openClawGatewayUrl,
         telegramTransport: config.telegramTransport,
+        discordEnabled: config.discordEnabled,
     });
 }
 catch (error) {
@@ -137,6 +145,9 @@ const shutdown = (signal) => {
     console.log(`Received ${signal}, shutting down NordRelay...`);
     if (bot && runtimeConfig?.telegramTransport !== "webhook")
         bot.stop();
+    void discordBridge?.stop().catch((error) => {
+        console.warn("Failed to stop Discord bridge:", error instanceof Error ? error.message : String(error));
+    });
     webhookServer?.close();
     setTimeout(() => {
         registry?.disposeAll();

package/dist/job-store.js

@@ -0,0 +1,127 @@
+import { createDocumentStore } from "./state-backend.js";
+const DEFAULT_MAX_JOBS = 1000;
+export class UnifiedJobStore {
+    maxJobs;
+    store;
+    constructor(workspace, backend = "json", maxJobs = DEFAULT_MAX_JOBS) {
+        this.maxJobs = maxJobs;
+        this.store = createDocumentStore({
+            workspace,
+            backend,
+            fileName: "unified-jobs.json",
+            sqliteKey: "unified-jobs",
+        });
+    }
+    list(limit = 200) {
+        return this.readPayload().jobs
+            .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
+            .slice(0, Math.max(1, Math.min(this.maxJobs, limit)));
+    }
+    get(id) {
+        return this.readPayload().jobs.find((job) => job.id === id) ?? null;
+    }
+    upsert(job) {
+        const payload = this.readPayload();
+        const normalized = normalizeJob(job);
+        const index = payload.jobs.findIndex((candidate) => candidate.id === normalized.id);
+        if (index >= 0) {
+            payload.jobs[index] = {
+                ...payload.jobs[index],
+                ...normalized,
+            };
+        }
+        else {
+            payload.jobs.push(normalized);
+        }
+        payload.jobs = trimJobs(payload.jobs, this.maxJobs);
+        this.store.write(payload);
+        return normalized;
+    }
+    upsertMany(jobs) {
+        if (jobs.length === 0) {
+            return this.list();
+        }
+        const payload = this.readPayload();
+        const byId = new Map(payload.jobs.map((job) => [job.id, job]));
+        for (const job of jobs) {
+            const normalized = normalizeJob(job);
+            byId.set(normalized.id, {
+                ...byId.get(normalized.id),
+                ...normalized,
+            });
+        }
+        payload.jobs = trimJobs([...byId.values()], this.maxJobs);
+        this.store.write(payload);
+        return payload.jobs;
+    }
+    patch(id, patch) {
+        const payload = this.readPayload();
+        const index = payload.jobs.findIndex((job) => job.id === id);
+        if (index < 0) {
+            return null;
+        }
+        payload.jobs[index] = normalizeJob({
+            ...payload.jobs[index],
+            ...patch,
+            id,
+            updatedAt: patch.updatedAt ?? new Date().toISOString(),
+        });
+        this.store.write(payload);
+        return payload.jobs[index];
+    }
+    remove(id) {
+        const payload = this.readPayload();
+        const next = payload.jobs.filter((job) => job.id !== id);
+        if (next.length === payload.jobs.length) {
+            return false;
+        }
+        payload.jobs = next;
+        this.store.write(payload);
+        return true;
+    }
+    readPayload() {
+        const payload = this.store.read();
+        if (!payload || payload.version !== 1 || !Array.isArray(payload.jobs)) {
+            return { version: 1, jobs: [] };
+        }
+        return {
+            version: 1,
+            jobs: trimJobs(payload.jobs.filter(isUnifiedJobDto).map(normalizeJob), this.maxJobs),
+        };
+    }
+}
+function trimJobs(jobs, maxJobs) {
+    return jobs
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
+        .slice(0, maxJobs);
+}
+function normalizeJob(job) {
+    return {
+        ...job,
+        startedAt: validDateString(job.startedAt) ?? new Date().toISOString(),
+        updatedAt: validDateString(job.updatedAt) ?? new Date().toISOString(),
+        finishedAt: validDateString(job.finishedAt),
+        canCancel: Boolean(job.canCancel),
+        canRetry: Boolean(job.canRetry),
+        canReadLog: Boolean(job.canReadLog),
+    };
+}
+function validDateString(value) {
+    if (!value) {
+        return undefined;
+    }
+    return Number.isFinite(Date.parse(value)) ? value : undefined;
+}
+function isUnifiedJobDto(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === "string" &&
+        typeof candidate.kind === "string" &&
+        typeof candidate.title === "string" &&
+        typeof candidate.status === "string" &&
+        typeof candidate.source === "string" &&
+        typeof candidate.startedAt === "string" &&
+        typeof candidate.updatedAt === "string";
+}

package/dist/metrics.js

@@ -0,0 +1,41 @@
+import { getDiscordRateLimitMetrics } from "./discord-rate-limit.js";
+import { getTelegramRateLimitMetrics } from "./telegram-rate-limit.js";
+export function buildRuntimeMetrics(input) {
+    const completedPromptDurations = input.activity
+        .filter((event) => event.category === "prompt" && event.status === "completed" && typeof event.durationMs === "number")
+        .map((event) => event.durationMs);
+    return {
+        generatedAt: new Date().toISOString(),
+        queue: {
+            length: input.queueLength,
+            paused: input.queuePaused,
+        },
+        turns: {
+            active: input.activeTurnCount,
+            completed: countActivity(input.activity, "completed"),
+            failed: countActivity(input.activity, "failed"),
+            aborted: countActivity(input.activity, "aborted"),
+            averageDurationMs: completedPromptDurations.length
+                ? Math.round(completedPromptDurations.reduce((sum, value) => sum + value, 0) / completedPromptDurations.length)
+                : null,
+        },
+        jobs: {
+            total: input.jobs.length,
+            queued: countJobs(input.jobs, "queued"),
+            running: countJobs(input.jobs, "running"),
+            completed: countJobs(input.jobs, "completed"),
+            failed: countJobs(input.jobs, "failed"),
+            aborted: countJobs(input.jobs, "aborted"),
+        },
+        adapters: {
+            telegram: getTelegramRateLimitMetrics(),
+            discord: getDiscordRateLimitMetrics(),
+        },
+    };
+}
+function countJobs(jobs, status) {
+    return jobs.filter((job) => job.status === status).length;
+}
+function countActivity(events, status) {
+    return events.filter((event) => event.category === "prompt" && event.status === status).length;
+}