talon-agent 3.33.3 → 3.34.0

package/src/core/weaver/weaver.ts

@@ -24,9 +24,11 @@ import type { ContextManager, ExecuteParams, ExecuteResult } from "../types.js";
 import { bus } from "../bus/index.js";
 import { taskTable, type TaskHandle } from "../tasks/index.js";
 import { log, logDebug, logWarn } from "../../util/log.js";
+import { recordSessionTurnPhases } from "../../storage/sessions.js";
+import type { TurnPhase } from "../../storage/session-record.js";
 import { TalonError } from "../errors.js";
 import { Loom } from "./loom.js";
-import { carryTurnEvents } from "./shuttle.js";
+import { carryTurnEvents, startShuttleTiming } from "./shuttle.js";
 import type { Thread, ThreadSnapshot } from "./thread.js";
 import { startTypingLoop } from "./typing-loop.js";
 import { resolveWarp } from "./warp-resolver.js";
@@ -72,7 +74,7 @@ export class Weaver {
     // interrupt the same chat's currently running one.
     const chat = this.deps.getBackend(params.chatId).chat;
     const interrupt = chat?.interruptChatTurn?.bind(chat);
-    const lifecycle = { started: false, killed: false };
+    const lifecycle = { started: false, killed: false, enqueuedAt: Date.now() };
     // Registered before enqueueing so a turn waiting in its chat's FIFO is
     // visible as `queued` in the task table, not invisible until it runs.
     const task = taskTable.enqueue({
@@ -109,7 +111,7 @@ export class Weaver {
     thread: Thread,
     params: ExecuteParams,
     task: TaskHandle,
-    lifecycle: { started: boolean; killed: boolean },
+    lifecycle: { started: boolean; killed: boolean; enqueuedAt: number },
   ): Promise<ExecuteResult> {
     if (lifecycle.killed) {
       // Killed while queued — the turn never reaches the backend. The
@@ -122,7 +124,9 @@ export class Weaver {
     this.activeCount++;
     task.start();
     try {
-      const result = await this.executeInner(thread, params, task);
+      const result = await this.executeInner(thread, params, task, {
+        queueWait: Date.now() - lifecycle.enqueuedAt,
+      });
       const usage = {
         inputTokens: result.inputTokens,
         outputTokens: result.outputTokens,
@@ -162,17 +166,20 @@ export class Weaver {
     thread: Thread,
     params: ExecuteParams,
     task: TaskHandle,
+    phases: Partial<Record<TurnPhase, number>>,
   ): Promise<ExecuteResult> {
     const { context } = this.deps;
     const backend = this.deps.getBackend(params.chatId);
     const reqId = randomBytes(4).toString("hex");
 
+    const warpStartedAt = Date.now();
     const warp = await resolveWarp(this.deps, {
       chatId: params.chatId,
       modelOverride: params.modelOverride,
       source: params.source,
       reqId,
     });
+    phases.warpResolve = Date.now() - warpStartedAt;
     if (!warp.ok) {
       // Refusals are delivered through the same event sink the backend
       // would use for output (as an `assistant_message` event, so the
@@ -246,7 +253,15 @@ export class Weaver {
         isGroup: params.isGroup,
         messageId: params.messageId,
       });
-      const agentResult = await carryTurnEvents(stream, params.onEvent);
+      const timing = startShuttleTiming();
+      const streamStartedAt = Date.now();
+      const agentResult = await carryTurnEvents(stream, params.onEvent, timing);
+      phases.stream = Date.now() - streamStartedAt;
+      phases.delivery = timing.deliveryMs;
+      if (timing.firstEventAt !== undefined) {
+        phases.firstToken = timing.firstEventAt - streamStartedAt;
+      }
+      recordSessionTurnPhases(params.chatId, phases);
 
       // Completion signal — pulse (and any other liveness subscriber) keys
       // off this. Failures throw past it; refusals never get this far.
@@ -261,7 +276,8 @@ export class Weaver {
       logDebug(
         "dispatcher",
         `[${reqId}] completed in ${agentResult?.durationMs ?? 0}ms ` +
-          `(in=${agentResult?.usage.inputTokens ?? 0} out=${agentResult?.usage.outputTokens ?? 0})`,
+          `(in=${agentResult?.usage.inputTokens ?? 0} out=${agentResult?.usage.outputTokens ?? 0}) ` +
+          formatPhases(phases),
       );
 
       return this.toExecuteResult(agentResult, params);
@@ -305,6 +321,21 @@ export class Weaver {
   }
 }
 
+/** `queue=12ms warp=3ms ttft=1840ms stream=6200ms delivery=310ms` */
+function formatPhases(phases: Partial<Record<TurnPhase, number>>): string {
+  const labels: Record<TurnPhase, string> = {
+    queueWait: "queue",
+    warpResolve: "warp",
+    firstToken: "ttft",
+    stream: "stream",
+    delivery: "delivery",
+  };
+  return (Object.keys(labels) as TurnPhase[])
+    .filter((phase) => phases[phase] !== undefined)
+    .map((phase) => `${labels[phase]}=${phases[phase]}ms`)
+    .join(" ");
+}
+
 let weaver: Weaver | null = null;
 
 export function initWeaver(deps: WeaverDeps): Weaver {

package/src/frontend/discord/callbacks/components/agent-buttons.ts

@@ -0,0 +1,82 @@
+/**
+ * `ai:*` — AI-generated buttons (send_message_with_buttons), forwarded to
+ * the agent verbatim with the routing prefix stripped.
+ */
+
+import { execute } from "../../../../core/engine/dispatcher.js";
+import { appendDailyLog } from "../../../../storage/daily-log.js";
+import { logError } from "../../../../util/log.js";
+import {
+  suppressMentions,
+  splitMessage,
+  DISCORD_MAX_TEXT,
+} from "../../formatting.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+export async function forwardToAgent(
+  interaction: ComponentInteraction,
+  { chatId, numericChatId }: ComponentContext,
+): Promise<boolean> {
+  // Acknowledge so Discord doesn't show "interaction failed"
+  try {
+    await interaction.deferUpdate();
+  } catch {
+    /* might already be acked */
+  }
+
+  const sender =
+    interaction.member?.user?.username ?? interaction.user.username ?? "User";
+  const isGroup = interaction.guildId !== null;
+  // Strip the `ai:` prefix so the agent sees the original callback_data it
+  // emitted in send_message_with_buttons, not our routing namespace.
+  const rawId = interaction.customId.startsWith("ai:")
+    ? interaction.customId.slice(3)
+    : interaction.customId;
+  const prompt = `[Button pressed] User clicked component with custom_id: "${rawId}"`;
+  const chatTitle = isGroup
+    ? `${interaction.guild?.name ?? interaction.guildId} #${(interaction.channel as { name?: string } | null)?.name ?? interaction.channelId}`
+    : undefined;
+
+  appendDailyLog(sender, `Button: ${rawId}`, { chatTitle });
+
+  const onTextBlock = async (text: string) => {
+    if (!text.trim()) return;
+    if (!interaction.channel?.isSendable()) return;
+    const chunks = splitMessage(suppressMentions(text), DISCORD_MAX_TEXT);
+    for (const c of chunks) {
+      try {
+        await interaction.channel.send({
+          content: c,
+          allowedMentions: { parse: [] },
+        });
+      } catch (err) {
+        logError(
+          "discord",
+          `forwardToAgent send failed: ${err instanceof Error ? err.message : err}`,
+        );
+      }
+    }
+  };
+
+  try {
+    await execute({
+      chatId,
+      numericChatId,
+      prompt,
+      senderName: sender,
+      isGroup,
+      source: "message",
+      onEvent: async (event) => {
+        if (event.type === "assistant_message") {
+          await onTextBlock(event.text);
+        }
+      },
+    });
+  } catch (err) {
+    logError(
+      "discord",
+      `Component → agent forward failed: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+  return true;
+}

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

@@ -0,0 +1,149 @@
+/**
+ * `model:backend-select` — the /model backend switch.
+ *
+ * Rebinding drops this chat's session (it isn't portable across backends)
+ * but keeps each backend's remembered model pick, so switching back
+ * restores what was selected there before.
+ */
+
+import { type StringSelectMenuInteraction, MessageFlags } from "discord.js";
+import {
+  buildModelPickerView,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../../model-picker.js";
+import { setChatBackend } from "../../../../storage/chat-settings.js";
+import {
+  getBackendIdForChat,
+  resolveChatBackend,
+  listAvailableBackends,
+  rebindChat,
+} from "../../../../core/engine/backend-controller/index.js";
+import { resetSession } from "../../../../storage/sessions.js";
+import { clearHistory } from "../../../../storage/history.js";
+import { resetPulseCheckpoint } from "../../../../core/background/pulse.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import { logError } from "../../../../util/log.js";
+import { safeSlice } from "../../formatting.js";
+import type { ComponentContext } from "./types.js";
+
+export async function handleBackendSelect(
+  interaction: StringSelectMenuInteraction,
+  { config, gateway, chatId }: ComponentContext,
+): Promise<void> {
+  const backendId = interaction.values[0] ?? "";
+  const available = listAvailableBackends(config);
+  if (!available.some((b) => b.id === backendId)) {
+    await interaction.reply({
+      content: "Backend not available.",
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  // Booting a cold backend takes seconds — Kilo and OpenCode spawn a server
+  // and sweep MCP registrations — and Discord drops an interaction that
+  // isn't acknowledged within three. Ack first, edit the panel after.
+  try {
+    await interaction.deferUpdate();
+  } catch {
+    /* already acknowledged */
+  }
+  const fail = async (text: string): Promise<void> => {
+    try {
+      await interaction.followUp({
+        content: text,
+        flags: MessageFlags.Ephemeral,
+      });
+    } catch {
+      /* ignore */
+    }
+  };
+
+  // Resolve the outgoing backend before rebinding — afterwards the chat
+  // already points at the new one and the old instance is unreachable.
+  const previousId = getBackendIdForChat(chatId);
+  const previous = resolveChatBackend(chatId, gateway?.backend);
+  const alreadyThere = previousId === backendId;
+  const result = alreadyThere
+    ? { ok: true as const }
+    : await rebindChat(chatId, backendId, config);
+  if (!result.ok) {
+    await fail(result.error?.slice(0, 200) ?? "Rebind failed.");
+    return;
+  }
+  setChatBackend(chatId, backendId);
+
+  // The pool accepts a backend whose SDK is installed, but the SDK may only
+  // be a client for a CLI that isn't (OpenCode and Kilo spawn `opencode` /
+  // `kilo`). That surfaces here, on the first real call. Reading the
+  // catalog is the cheapest way to find out, and it is needed for the panel
+  // anyway — so treat a throw as "this backend can't serve" and put the
+  // chat back where it was rather than stranding it somewhere unusable.
+  let next = resolveChatBackend(chatId, gateway?.backend);
+  let newModel: string | undefined;
+  let pres;
+  try {
+    newModel =
+      (await resolveActiveModelForChat(chatId, next, backendId, config))
+        .model ?? undefined;
+    if (next?.models?.getSettingsPresentation) {
+      pres = await next.models.getSettingsPresentation(newModel ?? "", {
+        callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
+      });
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logError("discord", `Backend switch to ${backendId} failed`, err);
+    if (!alreadyThere) {
+      await rebindChat(chatId, previousId, config).catch(() => undefined);
+      setChatBackend(chatId, previousId);
+    }
+    await fail(
+      `⚠️ \`${backendId}\` could not start — staying on \`${previousId}\`.\n` +
+        `\`\`\`\n${safeSlice(reason, 300)}\n\`\`\``,
+    );
+    return;
+  }
+
+  // Only now is the switch known to hold. Session state doesn't port across
+  // backends, so it goes — but each backend's remembered model pick stays.
+  // A re-pick of the backend already in use clears nothing: the retry after
+  // a timed-out interaction must not cost the session a second time.
+  if (!alreadyThere) {
+    resetSession(chatId);
+    clearHistory(chatId);
+    resetPulseCheckpoint(chatId);
+    previous?.sessions?.resetChat?.(chatId);
+  }
+
+  next = resolveChatBackend(chatId, gateway?.backend);
+  // Warming is fire-and-forget: it can take seconds on OpenCode/Kilo and
+  // the interaction still has a panel to redraw.
+  if (next && next !== previous) {
+    void Promise.resolve(next.sessions?.warmSession?.(chatId)).catch(
+      () => undefined,
+    );
+  }
+
+  try {
+    await interaction.editReply(
+      pres
+        ? {
+            ...buildModelPickerView(
+              pres,
+              newModel ?? "_No model selected_",
+              backendId,
+            ),
+          }
+        : {
+            content: `**Backend:** \`${backendId}\` · model \`${newModel ?? "none"}\``,
+            components: [],
+          },
+    );
+  } catch {
+    /* ignore */
+  }
+}

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 */
+  }
+}