talon-agent 3.33.4 → 3.34.1

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

@@ -0,0 +1,72 @@
+/**
+ * `effort:select` — the standalone /effort select menu.
+ */
+
+import type { StringSelectMenuInteraction } from "discord.js";
+import {
+  setChatEffort,
+  type EffortLevel,
+} from "../../../../storage/chat-settings.js";
+import {
+  getBackendIdForChat,
+  resolveChatBackend,
+} from "../../../../core/engine/backend-controller/index.js";
+import {
+  getActiveReasoningLevels,
+  supportsReasoningLevel,
+} from "../../../shared/reasoning-levels.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+async function selectEffort(
+  interaction: StringSelectMenuInteraction,
+  { config, gateway, chatId }: ComponentContext,
+): Promise<void> {
+  const level = interaction.values[0];
+  const be = resolveChatBackend(chatId, gateway?.backend);
+  const beId = getBackendIdForChat(chatId);
+  const reasoning = await getActiveReasoningLevels({
+    chatId,
+    backend: be,
+    backendId: beId,
+    config,
+  });
+  if (reasoning.levels.length === 0) {
+    await interaction.update({
+      content: "No valid reasoning levels found for this model.",
+      components: [],
+    });
+    return;
+  }
+  if (level === "adaptive") setChatEffort(chatId, undefined);
+  else if (supportsReasoningLevel(level, reasoning.levels))
+    setChatEffort(chatId, level as EffortLevel);
+  else {
+    await interaction.update({
+      content: "Invalid reasoning level for this model.",
+      components: [],
+    });
+    return;
+  }
+  try {
+    await interaction.update({
+      content: `**Effort:** ${level}`,
+      components: [],
+    });
+  } catch {
+    /* ignore */
+  }
+}
+
+export async function handleEffortComponent(
+  interaction: ComponentInteraction,
+  context: ComponentContext,
+): Promise<boolean> {
+  if (
+    interaction.customId === "effort:select" &&
+    interaction.isStringSelectMenu()
+  ) {
+    await selectEffort(interaction, context);
+    return true;
+  }
+  return false;
+}

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

@@ -0,0 +1,120 @@
+/**
+ * Component (button + select menu) interaction router.
+ *
+ * Custom ids are namespaced by a `:`-terminated prefix; the table below maps
+ * each prefix to the module that owns it. A handler returns `false` for an
+ * id under its prefix it doesn't recognise (a stale button from an older
+ * panel, a select-menu id arriving from a button), and the router acks
+ * those exactly as it acks a prefix with no handler.
+ *
+ * Custom-id namespace:
+ *   settings:done
+ *   settings:model              (select menu, value=modelId)
+ *   settings:effort:select      (select menu)
+ *   settings:proactive:on|off
+ *   pulse:on | pulse:off | pulse:interval (button → opens modal)
+ *   effort:select               (select menu, standalone /effort)
+ *   model:select                (select menu, standalone /model)
+ *   model:nav:*                 (pager)
+ *   model:backend-select        (select menu)
+ *   metrics:today | metrics:all
+ *   ai:<id>                     (AI-generated buttons — forwarded to agent)
+ */
+
+import { MessageFlags } from "discord.js";
+import type { TalonConfig } from "../../../../util/config.js";
+import type { Gateway } from "../../../../core/engine/gateway.js";
+import { deriveNumericChatId } from "../../../../util/chat-id.js";
+import { logError } from "../../../../util/log.js";
+import {
+  isInteractionAllowed,
+  registerDiscordChat,
+} from "../../handlers/index.js";
+import { forwardToAgent } from "./agent-buttons.js";
+import { handleEffortComponent } from "./effort.js";
+import { handleMetricsComponent } from "./metrics.js";
+import { handleModelComponent } from "./model.js";
+import { handlePulseComponent } from "./pulse.js";
+import { handleSettingsComponent } from "./settings.js";
+import type { ComponentHandlers, ComponentInteraction } from "./types.js";
+
+// Null-prototype so a custom id of "toString:" / "constructor:" / etc.
+// can't resolve an inherited Object.prototype method via `handlers[key]`.
+export const COMPONENT_HANDLERS: ComponentHandlers = Object.assign(
+  Object.create(null),
+  {
+    "settings:": handleSettingsComponent,
+    "pulse:": handlePulseComponent,
+    "effort:": handleEffortComponent,
+    "model:": handleModelComponent,
+    "metrics:": handleMetricsComponent,
+    "ai:": forwardToAgent,
+  } satisfies ComponentHandlers,
+);
+
+/**
+ * The table key for a custom id: its first segment, colon included
+ * (`"settings:done"` → `"settings:"`). An id with no colon keys to `""`,
+ * which no handler claims.
+ */
+export function componentRouteKey(customId: string): string {
+  return customId.slice(0, customId.indexOf(":") + 1);
+}
+
+function chatIdFromInteraction(interaction: ComponentInteraction): {
+  chatId: string;
+  numericChatId: number;
+} {
+  const chatId = interaction.guildId
+    ? `discord_guild_${interaction.guildId}_${interaction.channelId}`
+    : `discord_dm_${interaction.user.id}`;
+  return { chatId, numericChatId: deriveNumericChatId(chatId) };
+}
+
+export async function handleComponentInteraction(
+  interaction: ComponentInteraction,
+  config: TalonConfig,
+  gateway: Gateway,
+): Promise<void> {
+  // Access control
+  const access = isInteractionAllowed(
+    interaction.inGuild(),
+    interaction.user.id,
+    interaction.guildId,
+    interaction.channelId,
+  );
+  if (!access.ok) {
+    await interaction.reply({
+      content: `⚠️ ${access.reason}`,
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  const { chatId, numericChatId } = chatIdFromInteraction(interaction);
+  registerDiscordChat({
+    channelId: interaction.channelId!,
+    guildId: interaction.guildId,
+    userId: interaction.guildId ? null : interaction.user.id,
+    numericChatId,
+    chatId,
+  });
+
+  const customId = interaction.customId;
+  const handler = COMPONENT_HANDLERS[componentRouteKey(customId)];
+  if (
+    handler &&
+    (await handler(interaction, { config, gateway, chatId, numericChatId }))
+  ) {
+    return;
+  }
+
+  // Unknown custom_id — log + silently ack so Discord doesn't show
+  // "Interaction failed". This catches stale buttons from older panels.
+  logError("discord", `Unknown custom_id: ${customId}`);
+  try {
+    await interaction.deferUpdate();
+  } catch {
+    /* ignore */
+  }
+}

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

@@ -0,0 +1,24 @@
+/**
+ * `metrics:today` | `metrics:all` — the /metrics today ↔ all-time toggle.
+ */
+
+import { metricsViewRow, renderMetricsView } from "../../commands/admin.js";
+import type { ComponentInteraction } from "./types.js";
+
+export async function handleMetricsComponent(
+  interaction: ComponentInteraction,
+): Promise<boolean> {
+  const customId = interaction.customId;
+  if (customId !== "metrics:today" && customId !== "metrics:all") return false;
+  const view = customId === "metrics:all" ? "all" : "today";
+  const messages = renderMetricsView(view);
+  try {
+    await interaction.update({
+      content: messages[0]!,
+      components: [metricsViewRow(view).toJSON()],
+    });
+  } catch {
+    /* ignore */
+  }
+  return true;
+}

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

@@ -0,0 +1,93 @@
+/**
+ * `model:nav:*` — the /model pager: page arrows, free-tier toggle, provider
+ * drill, and the backend submenu. Pure navigation: re-renders the same
+ * panel at the requested page without touching the chat's selected model.
+ */
+
+import {
+  buildModelPickerView,
+  buildBackendPickerView,
+  decodeModelNav,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../../model-picker.js";
+import {
+  getBackendIdForChat,
+  resolveChatBackend,
+  listAvailableBackends,
+} from "../../../../core/engine/backend-controller/index.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+export async function handleModelNav(
+  interaction: ComponentInteraction,
+  { config, gateway, chatId }: ComponentContext,
+): Promise<void> {
+  const customId = interaction.customId;
+  // Backend submenu — the one nav action that isn't a re-page.
+  if (customId === `${MODEL_NAV_PREFIX}:backends`) {
+    const view = buildBackendPickerView(
+      listAvailableBackends(config),
+      getBackendIdForChat(chatId),
+    );
+    try {
+      await interaction.update({
+        content: view.content,
+        components: view.components,
+      });
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+
+  const target = decodeModelNav(customId);
+  if (!target) {
+    try {
+      await interaction.deferUpdate();
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+  const be = resolveChatBackend(chatId, gateway?.backend);
+  const beId = getBackendIdForChat(chatId);
+  const { model: current } = await resolveActiveModelForChat(
+    chatId,
+    be,
+    beId,
+    config,
+  );
+  if (!be?.models?.getSettingsPresentation) {
+    try {
+      await interaction.deferUpdate();
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+  const pres = await be.models.getSettingsPresentation(current ?? "", {
+    callbackPrefix: "model:",
+    navCallbackPrefix: MODEL_NAV_PREFIX,
+    pageSize: MODEL_PAGE_SIZE,
+    page: target.page,
+    filter: target.filter,
+    ...(target.provider ? { provider: target.provider } : {}),
+  });
+  const modelInfo = current
+    ? await be.models?.getRawModelInfo?.(current)
+    : undefined;
+  const view = buildModelPickerView(
+    pres,
+    modelInfo?.displayName ?? current ?? "_No model selected_",
+    beId,
+  );
+  try {
+    await interaction.update({
+      content: view.content,
+      components: view.components,
+    });
+  } catch {
+    /* ignore */
+  }
+}

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;
+}