talon-agent 3.33.4 → 3.34.0

package/src/frontend/discord/callbacks/components/model-select.ts

@@ -0,0 +1,118 @@
+/**
+ * `model:select` — the /model select menu (separate from settings).
+ */
+
+import { type StringSelectMenuInteraction, MessageFlags } from "discord.js";
+import {
+  buildModelPickerView,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../../model-picker.js";
+import {
+  setChatModelForBackend,
+  setChatBackend,
+} from "../../../../storage/chat-settings.js";
+import { resolveModelId as resolveModelName } from "../../../../core/models/catalog.js";
+import {
+  getBackendIdForChat,
+  resolveChatBackend,
+} from "../../../../core/engine/backend-controller/index.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import type { ComponentContext } from "./types.js";
+
+export async function handleModelSelect(
+  interaction: StringSelectMenuInteraction,
+  { config, gateway, chatId }: ComponentContext,
+): Promise<void> {
+  const value = interaction.values[0];
+  // Resolve and snapshot against the per-chat backend — never the
+  // global default — so this works in channels with a backend
+  // override pinned (e.g. switched to openai-agents to use
+  // OpenRouter models).
+  const be = resolveChatBackend(chatId, gateway?.backend);
+  const beId = getBackendIdForChat(chatId);
+
+  // In the provider view the select carries chips, not models — picking
+  // one drills into that provider rather than choosing anything.
+  if (value?.startsWith("provider:") && be?.models?.getSettingsPresentation) {
+    const providerId = value.slice("provider:".length);
+    const { model: activeNow } = await resolveActiveModelForChat(
+      chatId,
+      be,
+      beId,
+      config,
+    );
+    const pres = await be.models.getSettingsPresentation(activeNow ?? "", {
+      callbackPrefix: "model:",
+      navCallbackPrefix: MODEL_NAV_PREFIX,
+      pageSize: MODEL_PAGE_SIZE,
+      provider: providerId,
+    });
+    const view = buildModelPickerView(
+      pres,
+      activeNow ?? "_No model selected_",
+      beId,
+    );
+    try {
+      await interaction.update({
+        content: view.content,
+        components: view.components,
+      });
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+
+  if (value === "reset") {
+    // Clear THIS backend's slot only — other backends stay intact.
+    setChatModelForBackend(chatId, beId, undefined);
+  } else if (be?.models?.resolveModelInfo) {
+    const resolution = await be.models?.resolveModelInfo(value);
+    if (resolution.kind === "exact" && resolution.model.selectable) {
+      setChatModelForBackend(chatId, beId, resolution.storedValue);
+      setChatBackend(chatId, beId);
+    } else {
+      await interaction.reply({
+        content: "Model unavailable.",
+        flags: MessageFlags.Ephemeral,
+      });
+      return;
+    }
+  } else {
+    setChatModelForBackend(chatId, beId, resolveModelName(value));
+    setChatBackend(chatId, beId);
+  }
+
+  // Resolve display through the active-model helper so the panel
+  // matches what queries will actually run. Null surfaces as
+  // "No model selected".
+  const { model: resolvedCurrent } = await resolveActiveModelForChat(
+    chatId,
+    be,
+    beId,
+    config,
+  );
+  if (be?.models?.getSettingsPresentation) {
+    const current = resolvedCurrent ?? "";
+    const pres = await be.models?.getSettingsPresentation(current, {
+      callbackPrefix: "model:",
+      navCallbackPrefix: MODEL_NAV_PREFIX,
+      pageSize: MODEL_PAGE_SIZE,
+    });
+    const modelInfo = resolvedCurrent
+      ? await be.models?.getRawModelInfo?.(resolvedCurrent)
+      : undefined;
+    const displayName =
+      modelInfo?.displayName ?? resolvedCurrent ?? "_No model selected_";
+    const view = buildModelPickerView(pres, displayName, beId);
+    try {
+      await interaction.update({
+        content: view.content,
+        components: view.components,
+      });
+    } catch {
+      /* ignore */
+    }
+  }
+}

package/src/frontend/discord/callbacks/components/model.ts

@@ -0,0 +1,33 @@
+/**
+ * `model:*` — the /model panel, three ids under one prefix:
+ *
+ *   model:select           (select menu → model-select.ts)
+ *   model:nav:*            (pager buttons → model-nav.ts)
+ *   model:backend-select   (select menu → backend-select.ts)
+ */
+
+import { MODEL_NAV_PREFIX } from "../../model-picker.js";
+import { handleBackendSelect } from "./backend-select.js";
+import { handleModelNav } from "./model-nav.js";
+import { handleModelSelect } from "./model-select.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+export async function handleModelComponent(
+  interaction: ComponentInteraction,
+  context: ComponentContext,
+): Promise<boolean> {
+  const customId = interaction.customId;
+  if (customId === "model:select" && interaction.isStringSelectMenu()) {
+    await handleModelSelect(interaction, context);
+    return true;
+  }
+  if (customId.startsWith(`${MODEL_NAV_PREFIX}:`)) {
+    await handleModelNav(interaction, context);
+    return true;
+  }
+  if (customId === "model:backend-select" && interaction.isStringSelectMenu()) {
+    await handleBackendSelect(interaction, context);
+    return true;
+  }
+  return false;
+}

package/src/frontend/discord/callbacks/components/pulse.ts

@@ -0,0 +1,93 @@
+/**
+ * `pulse:*` — the standalone /pulse panel.
+ *
+ *   pulse:interval   (button → opens the interval modal)
+ *   pulse:on | pulse:off
+ */
+
+import {
+  type ButtonInteraction,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle,
+} from "discord.js";
+import {
+  registerChat,
+  disablePulse,
+  enablePulse,
+  isPulseEnabled,
+} from "../../../../core/background/pulse.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+// ── /pulse "Set interval…" button → opens modal ───────────────────────
+async function openIntervalModal(
+  interaction: ButtonInteraction,
+): Promise<void> {
+  const modal = new ModalBuilder()
+    .setCustomId("modal:pulse-interval")
+    .setTitle("Pulse interval");
+  const input = new TextInputBuilder()
+    .setCustomId("interval")
+    .setLabel("How often (min 5m)")
+    .setPlaceholder("30m, 2h, 90m, 1d…")
+    .setStyle(TextInputStyle.Short)
+    .setMinLength(2)
+    .setMaxLength(16)
+    .setRequired(true);
+  modal.addComponents(
+    new ActionRowBuilder<TextInputBuilder>().addComponents(input),
+  );
+  await interaction.showModal(modal);
+}
+
+// ── Standalone /pulse on|off buttons ──────────────────────────────────────
+async function togglePulse(
+  interaction: ComponentInteraction,
+  chatId: string,
+): Promise<void> {
+  const val = interaction.customId.slice(6);
+  if (val === "on") {
+    enablePulse(chatId);
+    registerChat(chatId);
+  } else if (val === "off") {
+    disablePulse(chatId);
+  }
+  const enabled = isPulseEnabled(chatId);
+  const row = new ActionRowBuilder<ButtonBuilder>().addComponents(
+    new ButtonBuilder()
+      .setCustomId("pulse:on")
+      .setLabel(enabled ? "✓ On" : "On")
+      .setStyle(enabled ? ButtonStyle.Success : ButtonStyle.Secondary),
+    new ButtonBuilder()
+      .setCustomId("pulse:off")
+      .setLabel(!enabled ? "✓ Off" : "Off")
+      .setStyle(ButtonStyle.Secondary),
+  );
+  try {
+    await (interaction as ButtonInteraction).update({
+      content: [
+        `**🔔 Pulse:** ${enabled ? "on" : "off"}`,
+        "",
+        "Reads along every few minutes and jumps in when there's something to add.",
+      ].join("\n"),
+      components: [row],
+    });
+  } catch {
+    /* ignore */
+  }
+}
+
+export async function handlePulseComponent(
+  interaction: ComponentInteraction,
+  { chatId }: ComponentContext,
+): Promise<boolean> {
+  if (interaction.customId === "pulse:interval" && interaction.isButton()) {
+    await openIntervalModal(interaction);
+    return true;
+  }
+  await togglePulse(interaction, chatId);
+  return true;
+}

package/src/frontend/discord/callbacks/components/settings.ts

@@ -0,0 +1,243 @@
+/**
+ * `settings:*` — the /settings panel. Every callback updates the original
+ * message in place (Discord supports update() on the interaction).
+ *
+ *   settings:done
+ *   settings:model              (select menu, value=modelId)
+ *   settings:effort:select      (select menu)
+ *   settings:proactive:on|off
+ */
+
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  StringSelectMenuBuilder,
+  MessageFlags,
+} from "discord.js";
+import type { TalonConfig } from "../../../../util/config.js";
+import type { Gateway } from "../../../../core/engine/gateway.js";
+import {
+  getChatSettings,
+  setChatModelForBackend,
+  setChatBackend,
+  setChatEffort,
+  type EffortLevel,
+} from "../../../../storage/chat-settings.js";
+import { resolveModelId as resolveModelName } from "../../../../core/models/catalog.js";
+import {
+  registerChat,
+  disablePulse,
+  enablePulse,
+  isPulseEnabled,
+} from "../../../../core/background/pulse.js";
+import { renderSettingsText, EFFORT_DESCRIPTIONS } from "../../helpers.js";
+import {
+  getBackendIdForChat,
+  resolveChatBackend,
+} from "../../../../core/engine/backend-controller/index.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import {
+  displayReasoningEffort,
+  getActiveReasoningLevels,
+  supportsReasoningLevel,
+} from "../../../shared/reasoning-levels.js";
+import { logError } from "../../../../util/log.js";
+import { safeSlice } from "../../formatting.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+export async function handleSettingsComponent(
+  interaction: ComponentInteraction,
+  { config, gateway, chatId }: ComponentContext,
+): Promise<boolean> {
+  const parts = interaction.customId.split(":");
+  const category = parts[1];
+
+  if (category === "done") {
+    try {
+      await interaction.update({ components: [], content: "Done." });
+    } catch {
+      /* ignore */
+    }
+    return true;
+  }
+
+  if (category === "model" && interaction.isStringSelectMenu()) {
+    const value = interaction.values[0];
+    const settingsBe = resolveChatBackend(chatId, gateway?.backend);
+    const settingsBeId = getBackendIdForChat(chatId);
+    if (value === "reset") {
+      // Clear THIS backend's slot only — other backends' picks stay.
+      setChatModelForBackend(chatId, settingsBeId, undefined);
+    } else if (settingsBe?.models?.resolveModelInfo) {
+      const resolution = await settingsBe.models?.resolveModelInfo(value);
+      if (resolution.kind !== "exact" || !resolution.model.selectable) {
+        await interaction.reply({
+          content: `Model unavailable.`,
+          flags: MessageFlags.Ephemeral,
+        });
+        return true;
+      }
+      setChatModelForBackend(chatId, settingsBeId, resolution.storedValue);
+      setChatBackend(chatId, settingsBeId);
+    } else {
+      setChatModelForBackend(chatId, settingsBeId, resolveModelName(value));
+      setChatBackend(chatId, settingsBeId);
+    }
+    await refreshSettingsPanel(interaction, config, gateway, chatId);
+    return true;
+  }
+
+  if (category === "effort" && interaction.isStringSelectMenu()) {
+    // settings:effort:select — current shape (emitted by handleSettings +
+    // refreshSettingsPanel).
+    const level = interaction.values[0];
+    const settingsBe = resolveChatBackend(chatId, gateway?.backend);
+    const settingsBeId = getBackendIdForChat(chatId);
+    const reasoning = await getActiveReasoningLevels({
+      chatId,
+      backend: settingsBe,
+      backendId: settingsBeId,
+      config,
+    });
+    if (level === "adaptive") {
+      setChatEffort(chatId, undefined);
+    } else if (supportsReasoningLevel(level, reasoning.levels)) {
+      setChatEffort(chatId, level as EffortLevel);
+    } else {
+      await interaction.reply({
+        content: "No valid reasoning level for this model.",
+        flags: MessageFlags.Ephemeral,
+      });
+      return true;
+    }
+    await refreshSettingsPanel(interaction, config, gateway, chatId);
+    return true;
+  }
+
+  if (category === "proactive") {
+    const value = parts[2] ?? "";
+    if (value === "on") {
+      enablePulse(chatId);
+      registerChat(chatId);
+    } else {
+      disablePulse(chatId);
+    }
+    await refreshSettingsPanel(interaction, config, gateway, chatId);
+    return true;
+  }
+
+  return false;
+}
+
+async function refreshSettingsPanel(
+  interaction: ComponentInteraction,
+  config: TalonConfig,
+  gateway: Gateway,
+  chatId: string,
+): Promise<void> {
+  const chatSets = getChatSettings(chatId);
+  const settingsBe = resolveChatBackend(chatId, gateway?.backend);
+  const settingsBeId = getBackendIdForChat(chatId);
+  // Match the Telegram path — resolve via the 5-step chain so the
+  // panel's "Model:" line stays coherent on backend-overridden
+  // chats and surfaces "No model selected" when applicable.
+  const { model: resolvedActive } = await resolveActiveModelForChat(
+    chatId,
+    settingsBe,
+    settingsBeId,
+    config,
+  );
+  const activeModel = resolvedActive ?? "No model selected";
+  const pulseOn = isPulseEnabled(chatId);
+  const reasoning = await getActiveReasoningLevels({
+    chatId,
+    backend: settingsBe,
+    backendId: settingsBeId,
+    config,
+  });
+  const effortName = displayReasoningEffort(chatSets.effort, reasoning.levels);
+
+  let modelDetails: Array<string> | undefined;
+  let modelButtons: Array<{ text: string; callback_data: string }> | undefined;
+  // `settingsBe` already resolved above for the activeModel lookup —
+  // reuse it instead of re-resolving (it points at the per-chat
+  // backend, override-aware).
+  if (settingsBe?.models?.getSettingsPresentation) {
+    const presModelId = resolvedActive ?? "";
+    const pres = await settingsBe.models?.getSettingsPresentation(presModelId);
+    modelDetails = pres.modelDetails;
+    modelButtons = pres.modelButtons;
+  }
+
+  const components: ActionRowBuilder<
+    StringSelectMenuBuilder | ButtonBuilder
+  >[] = [];
+
+  if (modelButtons?.length) {
+    const menu = new StringSelectMenuBuilder()
+      .setCustomId("settings:model")
+      .setPlaceholder("Select a model")
+      .addOptions(
+        modelButtons.slice(0, 25).map((b) => ({
+          label: safeSlice(b.text.replace(/^✓ /, ""), 100),
+          value: safeSlice(
+            b.callback_data.replace(/^settings:model:/, ""),
+            100,
+          ),
+          default: b.text.startsWith("✓"),
+        })),
+      );
+    components.push(
+      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(menu),
+    );
+  }
+
+  if (reasoning.levels.length > 0) {
+    const effortMenu = new StringSelectMenuBuilder()
+      .setCustomId("settings:effort:select")
+      .setPlaceholder(`Effort: ${effortName}`)
+      .addOptions(
+        [...reasoning.levels, "adaptive"].map((v) => ({
+          label: v,
+          value: v,
+          description: EFFORT_DESCRIPTIONS[v],
+          default: effortName === v,
+        })),
+      );
+    components.push(
+      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(effortMenu),
+    );
+  }
+
+  components.push(
+    new ActionRowBuilder<ButtonBuilder>().addComponents(
+      new ButtonBuilder()
+        .setCustomId(`settings:proactive:${pulseOn ? "off" : "on"}`)
+        .setLabel(pulseOn ? "Pulse: ON" : "Pulse: OFF")
+        .setStyle(pulseOn ? ButtonStyle.Success : ButtonStyle.Secondary),
+      new ButtonBuilder()
+        .setCustomId("settings:done")
+        .setLabel("Done")
+        .setStyle(ButtonStyle.Secondary),
+    ),
+  );
+
+  try {
+    await interaction.update({
+      content: renderSettingsText(
+        activeModel,
+        effortName,
+        pulseOn,
+        chatSets.pulseIntervalMs,
+        modelDetails,
+      ),
+      components,
+    });
+  } catch (err) {
+    logError(
+      "discord",
+      `Failed to refresh settings panel: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}

package/src/frontend/discord/callbacks/components/types.ts

@@ -0,0 +1,34 @@
+/**
+ * Component-handler types.
+ *
+ * The router (index.ts) keys `ComponentHandlers` by the custom-id prefix —
+ * the first `:`-terminated segment (`settings:`, `pulse:`, `model:`, …).
+ * A handler owns everything under its prefix and returns `false` for an id
+ * it doesn't recognise, so the router can ack it the way it acks an id with
+ * no handler at all (stale buttons from older panels).
+ */
+
+import type {
+  ButtonInteraction,
+  StringSelectMenuInteraction,
+} from "discord.js";
+import type { TalonConfig } from "../../../../util/config.js";
+import type { Gateway } from "../../../../core/engine/gateway.js";
+
+export type ComponentInteraction =
+  ButtonInteraction | StringSelectMenuInteraction;
+
+export interface ComponentContext {
+  config: TalonConfig;
+  gateway: Gateway;
+  /** Talon chat id (`discord_guild_…` / `discord_dm_…`), already registered. */
+  chatId: string;
+  numericChatId: number;
+}
+
+type ComponentHandler = (
+  interaction: ComponentInteraction,
+  context: ComponentContext,
+) => Promise<boolean>;
+
+export type ComponentHandlers = Record<string, ComponentHandler>;

package/src/frontend/discord/callbacks/index.ts

@@ -2,13 +2,13 @@
  * Discord interaction callbacks — components, modals, and autocomplete.
  *
  * Mirrors src/frontend/telegram/callbacks. Split by interaction kind:
- *   - shared       — ComponentInteraction type + chatIdFromInteraction
- *   - components   — button + select-menu handler (settings/pulse/effort/model
- *                    + ai: forwarding), refreshSettingsPanel, forwardToAgent
+ *   - components/  — button + select-menu router, a dispatch table keyed by
+ *                    custom-id prefix with one handler module per prefix
+ *                    (settings/pulse/effort/model/metrics + ai: forwarding)
  *   - modals       — modal submissions (pulse interval)
  *   - autocomplete — /model name autocomplete with a cached model list
  */
 
-export { handleComponentInteraction } from "./components.js";
+export { handleComponentInteraction } from "./components/index.js";
 export { handleModalSubmit } from "./modals.js";
 export { handleAutocomplete } from "./autocomplete.js";

package/src/frontend/discord/connection.ts

@@ -0,0 +1,36 @@
+/**
+ * Client connection lifecycle — login (blocking until READY) and the
+ * shutdown sequence that takes the gateway down with the client.
+ */
+
+import { Events } from "discord.js";
+import { once } from "node:events";
+import { log, logError } from "../../util/log.js";
+import type { DiscordRuntime } from "./runtime.js";
+
+export async function connect(runtime: DiscordRuntime): Promise<void> {
+  const { client, discord: dc } = runtime;
+  await client.login(dc.botToken);
+  // Wait for the WebSocket READY event before returning — login() resolves
+  // after HTTP IDENTIFY but client.user / client.guilds.cache are empty
+  // until READY fires. Anything called after start() can then safely read
+  // gateway state.
+  if (!client.isReady()) {
+    await once(client, Events.ClientReady);
+  }
+}
+
+export async function disconnect(runtime: DiscordRuntime): Promise<void> {
+  try {
+    await runtime.client.destroy();
+    log("shutdown", "Discord client disconnected");
+  } catch (err) {
+    logError("shutdown", "Discord stop error", err);
+  }
+  try {
+    await runtime.gateway.stop();
+    log("shutdown", "Gateway stopped");
+  } catch (err) {
+    logError("shutdown", "Gateway stop error", err);
+  }
+}

package/src/frontend/discord/diagnostics.ts

@@ -0,0 +1,62 @@
+/**
+ * Client diagnostics — the error/warn/disconnect/rate-limit listeners that
+ * only log. discord.js handles reconnects and retries itself; these exist
+ * so a silent failure mode (a fatal close code, an approaching IP ban) is
+ * visible in the daemon log.
+ */
+
+import { type Client, Events } from "discord.js";
+import { logError, logWarn } from "../../util/log.js";
+
+function shardDisconnectLabel(code: number | undefined): string {
+  return code === 4004
+    ? "AUTHENTICATION_FAILED — bot token invalid/revoked"
+    : code === 4013
+      ? "INVALID_INTENTS — declared intent doesn't exist"
+      : code === 4014
+        ? "DISALLOWED_INTENTS — privileged intent (GuildMembers/MessageContent/Presence) not enabled in Developer Portal"
+        : `code=${code}`;
+}
+
+export function bindClientDiagnostics(client: Client): void {
+  client.on("error", (err) => {
+    logError("discord", "Client error", err);
+  });
+  client.on("warn", (msg) => {
+    logWarn("discord", msg);
+  });
+
+  // Surface gateway close codes — discord.js auto-reconnects on most, but
+  // 4004 (auth failed), 4013 (invalid intents), 4014 (disallowed intents)
+  // are terminal: the bot will hang silent in IDENTIFY without an alert.
+  client.on(Events.ShardDisconnect, (event, shardId) => {
+    const code = event?.code;
+    const reason = event?.reason || "(no reason)";
+    const fatal = code === 4004 || code === 4013 || code === 4014;
+    const label = shardDisconnectLabel(code);
+    if (fatal) {
+      logError(
+        "discord",
+        `Shard ${shardId} disconnected fatally: ${label} (${reason})`,
+      );
+    } else {
+      logWarn("discord", `Shard ${shardId} disconnected: ${label} (${reason})`);
+    }
+  });
+
+  // Rate-limit / invalid-request observability. discord.js handles retries
+  // automatically; we just want logs so we know when we're flirting with
+  // the Cloudflare 10k-invalid-requests/10min cap.
+  client.rest.on("rateLimited", (info) => {
+    logWarn(
+      "discord",
+      `Rate-limited ${info.method} ${info.route} — wait ${info.timeToReset}ms (global=${info.global})`,
+    );
+  });
+  client.rest.on("invalidRequestWarning", (info) => {
+    logError(
+      "discord",
+      `Invalid-request warning: ${info.count} bad requests in last ${info.remainingTime}ms — approaching IP ban threshold`,
+    );
+  });
+}