talon-agent 3.33.4 → 3.34.1

package/src/core/vfs/mounts/files.ts

@@ -20,134 +20,147 @@ import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import type { VfsMount, VfsResult, VfsStat } from "../types.js";
 import { VFS_MAX_READ_BYTES, vfsError, vfsOk } from "../types.js";
 
-export function createFileMount(options: {
+type FileMountOptions = {
   root: string;
   description: string;
   writable: boolean;
-}): VfsMount {
-  const root = resolve(options.root);
+};
 
-  /** Absolute path for `rel`, or undefined when it would escape the root. */
-  function realPath(rel: string): string | undefined {
-    const abs = resolve(root, ...rel.split("/"));
-    const offset = relative(root, abs);
-    if (
-      offset.startsWith(`..${sep}`) ||
-      offset === ".." ||
-      isAbsolute(offset)
-    ) {
-      return undefined;
-    }
-    return abs;
+/** Absolute path for `rel` under `root`, or undefined when it would escape. */
+function realPath(root: string, rel: string): string | undefined {
+  const abs = resolve(root, ...rel.split("/"));
+  const offset = relative(root, abs);
+  if (offset.startsWith(`..${sep}`) || offset === ".." || isAbsolute(offset)) {
+    return undefined;
   }
+  return abs;
+}
 
-  function statAt(rel: string, abs: string): VfsResult<VfsStat> {
-    try {
-      const stats = statSync(abs);
-      const name = rel === "" ? "" : rel.split("/").at(-1)!;
-      return vfsOk({
-        path: rel,
-        name,
-        kind: stats.isDirectory() ? ("dir" as const) : ("file" as const),
-        ...(stats.isFile() ? { size: stats.size } : {}),
-        modifiedAt: Math.floor(stats.mtimeMs),
-        writable: options.writable,
-        osPath: abs,
-      });
-    } catch {
-      return vfsError("not-found");
-    }
+function statAt(
+  rel: string,
+  abs: string,
+  writable: boolean,
+): VfsResult<VfsStat> {
+  try {
+    const stats = statSync(abs);
+    const name = rel === "" ? "" : rel.split("/").at(-1)!;
+    return vfsOk({
+      path: rel,
+      name,
+      kind: stats.isDirectory() ? ("dir" as const) : ("file" as const),
+      ...(stats.isFile() ? { size: stats.size } : {}),
+      modifiedAt: Math.floor(stats.mtimeMs),
+      writable,
+      osPath: abs,
+    });
+  } catch {
+    return vfsError("not-found");
   }
+}
 
-  return {
-    description: options.description,
-    writable: options.writable,
-    osRoot: root,
+function statMount(
+  root: string,
+  writable: boolean,
+  rel: string,
+): VfsResult<VfsStat> {
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  if (rel === "" && !existsSync(abs)) {
+    return vfsOk({ path: "", name: "", kind: "dir", writable, osPath: abs });
+  }
+  return statAt(rel, abs, writable);
+}
 
-    stat(rel) {
-      const abs = realPath(rel);
-      if (!abs) return vfsError("invalid-path");
-      if (rel === "" && !existsSync(abs)) {
-        return vfsOk({
-          path: "",
-          name: "",
-          kind: "dir",
-          writable: options.writable,
-          osPath: abs,
-        });
-      }
-      return statAt(rel, abs);
-    },
+function listMount(
+  root: string,
+  writable: boolean,
+  rel: string,
+): VfsResult<VfsStat[]> {
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  if (rel === "" && !existsSync(abs)) return vfsOk([]);
+  let stats;
+  try {
+    stats = statSync(abs);
+  } catch {
+    return vfsError("not-found");
+  }
+  if (!stats.isDirectory()) return vfsError("not-a-directory");
+  const entries = readdirSync(abs, { withFileTypes: true })
+    .map((entry) => {
+      const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
+      const child = statAt(childRel, resolve(abs, entry.name), writable);
+      return child.ok ? child.value : undefined;
+    })
+    .filter((entry): entry is VfsStat => entry !== undefined)
+    .sort(
+      (a, b) =>
+        Number(a.kind === "file") - Number(b.kind === "file") ||
+        a.name.localeCompare(b.name),
+    );
+  return vfsOk(entries);
+}
 
-    list(rel) {
-      const abs = realPath(rel);
-      if (!abs) return vfsError("invalid-path");
-      if (rel === "" && !existsSync(abs)) return vfsOk([]);
-      let stats;
-      try {
-        stats = statSync(abs);
-      } catch {
-        return vfsError("not-found");
-      }
-      if (!stats.isDirectory()) return vfsError("not-a-directory");
-      const entries = readdirSync(abs, { withFileTypes: true })
-        .map((entry) => {
-          const childRel = rel === "" ? entry.name : `${rel}/${entry.name}`;
-          const child = statAt(childRel, resolve(abs, entry.name));
-          return child.ok ? child.value : undefined;
-        })
-        .filter((entry): entry is VfsStat => entry !== undefined)
-        .sort(
-          (a, b) =>
-            Number(a.kind === "file") - Number(b.kind === "file") ||
-            a.name.localeCompare(b.name),
-        );
-      return vfsOk(entries);
-    },
+function readMount(root: string, rel: string): VfsResult<string> {
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  let stats;
+  try {
+    stats = statSync(abs);
+  } catch {
+    return vfsError("not-found");
+  }
+  if (stats.isDirectory()) return vfsError("is-a-directory");
+  if (stats.size > VFS_MAX_READ_BYTES) {
+    return vfsError(
+      "too-large",
+      `${stats.size} bytes (cap ${VFS_MAX_READ_BYTES}) — on disk at ${abs}`,
+    );
+  }
+  const buffer = readFileSync(abs);
+  if (buffer.includes(0)) {
+    return vfsError("binary-file", "Content contains null bytes");
+  }
+  return vfsOk(buffer.toString("utf-8"));
+}
 
-    read(rel) {
-      const abs = realPath(rel);
-      if (!abs) return vfsError("invalid-path");
-      let stats;
-      try {
-        stats = statSync(abs);
-      } catch {
-        return vfsError("not-found");
-      }
-      if (stats.isDirectory()) return vfsError("is-a-directory");
-      if (stats.size > VFS_MAX_READ_BYTES) {
-        return vfsError(
-          "too-large",
-          `${stats.size} bytes (cap ${VFS_MAX_READ_BYTES}) — on disk at ${abs}`,
-        );
-      }
-      const buffer = readFileSync(abs);
-      if (buffer.includes(0)) {
-        return vfsError("binary-file", "Content contains null bytes");
-      }
-      return vfsOk(buffer.toString("utf-8"));
-    },
+function writeMount(
+  root: string,
+  rel: string,
+  content: string,
+): VfsResult<VfsStat> {
+  if (rel === "") return vfsError("is-a-directory");
+  const abs = realPath(root, rel);
+  if (!abs) return vfsError("invalid-path");
+  if (existsSync(abs) && statSync(abs).isDirectory()) {
+    return vfsError("is-a-directory");
+  }
+  try {
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, content, "utf-8");
+  } catch (err) {
+    return vfsError(
+      "io-error",
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+  return statAt(rel, abs, true);
+}
 
-    ...(options.writable
+export function createFileMount(options: FileMountOptions): VfsMount {
+  const root = resolve(options.root);
+  const { writable } = options;
+  return {
+    description: options.description,
+    writable,
+    osRoot: root,
+    stat: (rel) => statMount(root, writable, rel),
+    list: (rel) => listMount(root, writable, rel),
+    read: (rel) => readMount(root, rel),
+    ...(writable
       ? {
-          write(rel: string, content: string): VfsResult<VfsStat> {
-            if (rel === "") return vfsError("is-a-directory");
-            const abs = realPath(rel);
-            if (!abs) return vfsError("invalid-path");
-            if (existsSync(abs) && statSync(abs).isDirectory()) {
-              return vfsError("is-a-directory");
-            }
-            try {
-              mkdirSync(dirname(abs), { recursive: true });
-              writeFileSync(abs, content, "utf-8");
-            } catch (err) {
-              return vfsError(
-                "io-error",
-                err instanceof Error ? err.message : String(err),
-              );
-            }
-            return statAt(rel, abs);
-          },
+          write: (rel: string, content: string) =>
+            writeMount(root, rel, content),
         }
       : {}),
   };

package/src/core/weaver/shuttle.ts

@@ -26,9 +26,22 @@ import {
   type AgentEvent,
   type AgentResult,
 } from "../agent-runtime/events.js";
+import { recordTurnActivity } from "../../util/watchdog.js";
 
 export type EventSink = (event: AgentEvent) => void | Promise<void>;
 
+/**
+ * Wall-clock the shuttle observes while carrying one stream: when the
+ * first event arrived (`undefined` if the stream ended empty) and how many
+ * ms were spent awaiting the frontend's sink in total.
+ */
+export type ShuttleTiming = {
+  firstEventAt?: number;
+  deliveryMs: number;
+};
+
+export const startShuttleTiming = (): ShuttleTiming => ({ deliveryMs: 0 });
+
 /**
  * Pump the stream to completion. Returns the `completed` event's
  * result (if the backend emitted one); throws `AgentRunError` when the
@@ -37,16 +50,34 @@ export type EventSink = (event: AgentEvent) => void | Promise<void>;
 export async function carryTurnEvents(
   stream: AsyncIterable<AgentEvent>,
   onEvent?: EventSink,
+  timing?: ShuttleTiming,
 ): Promise<AgentResult | undefined> {
   let agentResult: AgentResult | undefined;
+  const sink: EventSink | undefined =
+    onEvent && timing
+      ? async (event) => {
+          const t0 = Date.now();
+          try {
+            await onEvent(event);
+          } finally {
+            timing.deliveryMs += Date.now() - t0;
+          }
+        }
+      : onEvent;
   for await (const event of stream) {
+    // Every backend's events cross this loop exactly once, so this is the
+    // one place the watchdog learns a turn is alive (vs. wedged).
+    recordTurnActivity();
+    if (timing && timing.firstEventAt === undefined) {
+      timing.firstEventAt = Date.now();
+    }
     if (event.type === "completed") {
       agentResult = event.result;
     }
 
     if (event.type === "assistant_message" && event.deliveryAck) {
       try {
-        await onEvent?.(event);
+        await sink?.(event);
         event.deliveryAck.resolve();
       } catch (err) {
         event.deliveryAck.reject(err);
@@ -54,7 +85,7 @@ export async function carryTurnEvents(
       continue;
     }
 
-    await onEvent?.(event);
+    await sink?.(event);
     if (event.type === "error") {
       throw new AgentRunError(event.error);
     }

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