talon-agent 3.33.4 → 3.34.1

package/src/frontend/native/tool-result.ts

@@ -0,0 +1,48 @@
+/**
+ * Tool-result summarisation — the bounded, readable string the app shows in
+ * its expanded tool view (and the turn-meta sidecar persists).
+ */
+
+/** Best-effort JSON stringify that never throws (circular refs → String()). */
+function safeJson(value: unknown): string {
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
+/**
+ * Reduce a tool's raw result to a readable, bounded string for the app's
+ * expanded tool view. MCP results are typically
+ * `{ content: [{ type: "text", text }] }`, so pull the text parts out; fall
+ * back to pretty JSON for anything else. Truncated so a huge file read or
+ * search dump can't bloat the wire payload or the history sidecar.
+ */
+export function summarizeToolResult(result: unknown): string | undefined {
+  if (result == null) return undefined;
+  let text: string;
+  if (typeof result === "string") {
+    text = result;
+  } else {
+    const content = (result as { content?: unknown }).content;
+    if (Array.isArray(content)) {
+      const parts = content
+        .map((c) =>
+          c &&
+          typeof c === "object" &&
+          typeof (c as { text?: unknown }).text === "string"
+            ? (c as { text: string }).text
+            : "",
+        )
+        .filter((s) => s.length > 0);
+      text = parts.length > 0 ? parts.join("\n") : safeJson(result);
+    } else {
+      text = safeJson(result);
+    }
+  }
+  text = text.trim();
+  if (!text) return undefined;
+  const MAX = 4000;
+  return text.length > MAX ? `${text.slice(0, MAX)}\n… (truncated)` : text;
+}

package/src/frontend/native/turn.ts

@@ -0,0 +1,341 @@
+/**
+ * A user turn — drive `dispatcher.execute()` and forward the canonical
+ * `AgentEvent` stream to clients as Bridge events: reasoning + tool activity
+ * stream live, while the persisted reply arrives via the gateway action
+ * handler (tool-only backends) or the trailing-prose fallback (text-mode
+ * backends) — mirroring the terminal renderer's delivery semantics.
+ */
+
+import type { ExecuteResult } from "../../core/types.js";
+import type { AgentEvent } from "../../core/agent-runtime/events.js";
+import { execute } from "../../core/engine/dispatcher.js";
+import { toolInputToRecord } from "../../core/agent-runtime/events.js";
+import { getBackendForChat } from "../../core/engine/backend-controller/index.js";
+import { isDeliveryTool } from "../../core/tools/index.js";
+import { recordTurnMeta } from "./turn-meta.js";
+import type { ChatEntry } from "./chats.js";
+import { refreshContext } from "./context.js";
+import { emitAssistant, emitUser } from "./emit.js";
+import type { BridgeEvent } from "./protocol.js";
+import { takeQueued } from "./queue.js";
+import type { LiveToolEntry, NativeRuntime } from "./runtime.js";
+import { summarizeToolResult } from "./tool-result.js";
+
+/** The tool calls of one running turn, in call order. */
+type TurnTools = Map<string, LiveToolEntry>;
+
+export type StartTurnOptions = { imagePath?: string; attachmentPath?: string };
+
+/** True when a turn is currently running for a chat (used to decide queue). */
+export function isBusy(runtime: NativeRuntime, chatId: string): boolean {
+  return runtime.liveTurns.has(chatId);
+}
+
+/**
+ * Events that reconstruct every in-progress turn for a freshly-connected
+ * client: a turn_start (so the live turn renders), a typing indicator, and
+ * each tool's call — plus its result when it has already finished. Replayed
+ * right after `hello` so a reconnect mid-turn shows the full tool timeline
+ * immediately rather than only the tools that happen to fire afterwards.
+ */
+export function liveTurnEvents(runtime: NativeRuntime): BridgeEvent[] {
+  const events: BridgeEvent[] = [];
+  for (const [chatId, tools] of runtime.liveTurns) {
+    events.push({ kind: "turn_start", chatId });
+    events.push({ kind: "typing", chatId, on: true });
+    for (const { call, done } of tools.values()) {
+      events.push({
+        kind: "tool",
+        chatId,
+        id: call.id,
+        name: call.name,
+        phase: "call",
+        ...(call.input ? { input: call.input } : {}),
+      });
+      if (done) {
+        events.push({
+          kind: "tool",
+          chatId,
+          id: call.id,
+          name: call.name,
+          phase: "result",
+          ...(call.error ? { error: call.error } : {}),
+          ...(call.output ? { output: call.output } : {}),
+        });
+      }
+    }
+  }
+  return events;
+}
+
+/**
+ * Safety net: any tool the backend announced but never resolved (a crash can
+ * eat a tool_result; callback backends historically never emitted one —
+ * handler-to-events now pairs each tool_call with an immediate synthetic
+ * result) gets a synthetic result at turn end — a spinner the app opened on
+ * phase:"call" must always see a phase:"result".
+ */
+function flushOpenTools(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  turnTools: TurnTools,
+): void {
+  for (const [id, live] of turnTools) {
+    if (live.done) continue;
+    live.done = true;
+    live.call.durationMs = Date.now() - live.startedAt;
+    runtime.broadcast({
+      kind: "tool",
+      chatId: entry.id,
+      id,
+      name: live.call.name,
+      phase: "result",
+    });
+  }
+}
+
+/** Forward one agent event to clients, recording tool activity as it goes. */
+function forwardAgentEvent(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  turnTools: TurnTools,
+  event: AgentEvent,
+): void {
+  switch (event.type) {
+    case "reasoning":
+      if (event.text)
+        runtime.broadcast({
+          kind: "reasoning",
+          chatId: entry.id,
+          text: event.text,
+        });
+      break;
+    case "text_delta":
+      runtime.broadcast({ kind: "delta", chatId: entry.id, text: event.text });
+      break;
+    case "tool_call": {
+      // Delivery plumbing (end_turn / send_message / react) never
+      // enters the tool timeline — its effect arrives as the
+      // `message`/reaction itself. Skipping here keeps the live
+      // stream, the mid-turn replay to late joiners, and the
+      // persisted turn meta consistent from one choke point.
+      if (isDeliveryTool(event.name)) break;
+      const input = toolInputToRecord(event.name, event.input);
+      turnTools.set(event.id, {
+        call: { id: event.id, name: event.name, input },
+        startedAt: Date.now(),
+      });
+      runtime.broadcast({
+        kind: "tool",
+        chatId: entry.id,
+        id: event.id,
+        name: event.name,
+        phase: "call",
+        input,
+      });
+      break;
+    }
+    case "tool_result": {
+      if (isDeliveryTool(event.name)) break;
+      const output = summarizeToolResult(event.result);
+      const live = turnTools.get(event.id);
+      if (live) {
+        live.done = true;
+        live.call.durationMs = Date.now() - live.startedAt;
+        if (event.error) live.call.error = event.error;
+        if (output) live.call.output = output;
+      }
+      runtime.broadcast({
+        kind: "tool",
+        chatId: entry.id,
+        id: event.id,
+        name: event.name,
+        phase: "result",
+        ...(event.error ? { error: event.error } : {}),
+        ...(output ? { output } : {}),
+      });
+      break;
+    }
+    case "error":
+      runtime.broadcast({
+        kind: "error",
+        chatId: entry.id,
+        message: event.error.message,
+      });
+      break;
+  }
+}
+
+/** Settle a completed turn: deliver trailing prose, persist meta, close it. */
+function finishTurn(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  turnTools: TurnTools,
+  result: ExecuteResult,
+): void {
+  // Trailing-prose fallback: text-mode backends (kilo/opencode/codex)
+  // deliver the reply as plain text rather than a bridge send. When no
+  // delivery tool fired this turn, surface result.text as the message —
+  // exactly what the terminal renderer does.
+  let delivered = result.bridgeMessageCount;
+  if (delivered === 0 && result.text.trim()) {
+    emitAssistant(runtime, entry, result.text.trim());
+    delivered = 1;
+  }
+
+  // Resolve open tool spinners BEFORE persisting turn meta, so the
+  // synthetic durations land in the recorded timeline too.
+  flushOpenTools(runtime, entry, turnTools);
+
+  // Persist what this turn did against its final assistant message, so
+  // reloaded history keeps the tool timeline + stats footer. Only when
+  // the turn actually delivered — otherwise the "last assistant id"
+  // belongs to a previous turn and the meta would land on the wrong row.
+  if (delivered > 0) {
+    const msgId = runtime.lastAssistantId.get(entry.id);
+    if (msgId) {
+      const tools = [...turnTools.values()].map((t) => t.call);
+      recordTurnMeta(entry.id, msgId, {
+        durationMs: result.durationMs,
+        tokensIn: result.inputTokens,
+        tokensOut: result.outputTokens,
+        ...(tools.length ? { tools } : {}),
+      });
+    }
+  }
+
+  runtime.broadcast({ kind: "typing", chatId: entry.id, on: false });
+  runtime.broadcast({
+    kind: "turn_end",
+    chatId: entry.id,
+    delivered,
+    durationMs: result.durationMs,
+    usage: { input: result.inputTokens, output: result.outputTokens },
+  });
+
+  // Refresh the live context-window readout now the turn's usage has
+  // settled, and push it to clients via chat_updated. Best-effort — a
+  // failure here must never surface as a turn error.
+  void refreshContext(runtime, entry).catch(() => {});
+}
+
+/** Close a turn that threw: flush spinners, surface the error, end it. */
+function failTurn(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  turnTools: TurnTools,
+  err: unknown,
+  start: number,
+): void {
+  flushOpenTools(runtime, entry, turnTools);
+  runtime.broadcast({ kind: "typing", chatId: entry.id, on: false });
+  runtime.broadcast({
+    kind: "error",
+    chatId: entry.id,
+    message: err instanceof Error ? err.message : String(err),
+  });
+  runtime.broadcast({
+    kind: "turn_end",
+    chatId: entry.id,
+    delivered: 0,
+    durationMs: Date.now() - start,
+  });
+}
+
+async function runTurn(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  text: string,
+  messageId: number,
+  attachmentPath?: string,
+): Promise<void> {
+  const start = Date.now();
+  // Tool calls observed during this turn, in call order — recorded into the
+  // turn-meta sidecar at turn_end so history can replay the timeline. Also
+  // registered in `liveTurns` so a client connecting mid-turn can be replayed
+  // the activity so far (cleared in the `finally`).
+  const turnTools: TurnTools = new Map();
+  runtime.liveTurns.set(entry.id, turnTools);
+  // Point the model at an attached image so it can read the file itself.
+  const prompt = attachmentPath
+    ? `${text ? `${text}\n\n` : ""}[Attached image: ${attachmentPath}]`
+    : text;
+  try {
+    const result = await execute({
+      chatId: entry.id,
+      numericChatId: entry.numericId,
+      prompt,
+      senderName: "User",
+      isGroup: false,
+      // Give the model the user message's id so `[msg_id:N]` is present and
+      // react/reply/edit target the user's message — not the bot's.
+      messageId,
+      source: "message",
+      onEvent: async (event) =>
+        forwardAgentEvent(runtime, entry, turnTools, event),
+    });
+    finishTurn(runtime, entry, turnTools, result);
+  } catch (err) {
+    failTurn(runtime, entry, turnTools, err, start);
+  } finally {
+    // The turn is over (delivered or errored) — stop replaying it to new
+    // clients. Any late tool spinner has already been flushed above.
+    runtime.liveTurns.delete(entry.id);
+    // Flush a queued follow-up as a fresh turn: "once it's done it will
+    // send". Deferred so we don't re-enter runTurn inside its own finally.
+    const queued = takeQueued(runtime, entry);
+    if (queued) {
+      setImmediate(() =>
+        startTurn(runtime, entry, queued.text, {
+          imagePath: queued.imagePath,
+          attachmentPath: queued.attachmentPath,
+        }),
+      );
+    }
+  }
+}
+
+/** Emit the user message, open the turn, and drive it. Shared by the /send
+ *  handler and the queued-follow-up flush. */
+export function startTurn(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  text: string,
+  options?: StartTurnOptions,
+): void {
+  const messageId = emitUser(
+    runtime,
+    entry,
+    text,
+    options?.imagePath,
+    options?.attachmentPath,
+  );
+  runtime.broadcast({ kind: "turn_start", chatId: entry.id });
+  runtime.broadcast({ kind: "typing", chatId: entry.id, on: true });
+  void runTurn(runtime, entry, text, messageId, options?.attachmentPath);
+}
+
+/** Best-effort interrupt of a chat's in-flight turn. `true` if one was
+ *  running and got signalled. */
+export async function interruptTurn(
+  runtime: NativeRuntime,
+  chatId: string,
+): Promise<boolean> {
+  const entry = runtime.chats.get(chatId);
+  if (!entry) return false;
+  // Only meaningful while a turn is actually running.
+  if (!isBusy(runtime, chatId)) return false;
+  let backend = null;
+  try {
+    backend = getBackendForChat(chatId);
+  } catch {
+    return false;
+  }
+  const interrupt = backend?.chat?.interruptChatTurn;
+  if (!interrupt) return false;
+  try {
+    return await interrupt(chatId);
+  } catch {
+    return false;
+  }
+}

package/src/frontend/telegram/admin.ts

@@ -7,7 +7,8 @@ import { readFileSync } from "node:fs";
 import type { TalonConfig } from "../../util/config.js";
 import { files, dirs } from "../../util/paths.js";
 import { tailFile } from "../../util/tail-file.js";
-import { escapeHtml } from "./formatting.js";
+import { escapeHtml, splitMessage } from "./formatting.js";
+import { TELEGRAM_MAX_TEXT } from "./actions/types.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
 import { clearHistory } from "../../storage/history.js";
 import { todayLogDate } from "../../storage/daily-log.js";
@@ -22,6 +23,72 @@ import { getPulseStatus } from "../../core/background/pulse.js";
 import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";
 import { formatDuration, formatModelLabel } from "./helpers/index.js";
 
+/**
+ * Reply with an HTML listing, split across messages when it outgrows
+ * Telegram's 4096-char cap. The per-item listings below (chats, cron,
+ * pulse) scale with the daemon's chat count, and a single oversized
+ * `ctx.reply` fails the whole command with 400 "message is too long".
+ * Entries are `\n\n`-separated and each carries balanced tags, so the
+ * paragraph-first splitter never cuts through markup.
+ */
+async function replyHtmlChunked(ctx: Context, text: string): Promise<void> {
+  for (const chunk of splitMessage(text, TELEGRAM_MAX_TEXT)) {
+    await ctx.reply(chunk, { parse_mode: "HTML" });
+  }
+}
+
+/** `/admin chats` — every active session, newest first, titled via getChat. */
+async function replyActiveChats(
+  ctx: Context,
+  bot: Bot,
+  config: TalonConfig,
+): Promise<void> {
+  const sessions = getAllSessions();
+  if (sessions.length === 0) {
+    await ctx.reply("No active sessions.");
+    return;
+  }
+  sessions.sort((a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0));
+
+  const titles = new Map<string, string>();
+  await Promise.all(
+    sessions.map(async (s) => {
+      try {
+        const id = parseInt(s.chatId, 10);
+        if (isNaN(id)) return;
+        const chat = await bot.api.getChat(id);
+        titles.set(
+          s.chatId,
+          "title" in chat
+            ? (chat.title ?? "DM")
+            : "first_name" in chat
+              ? (chat.first_name ?? "DM")
+              : "DM",
+        );
+      } catch {
+        /* inaccessible */
+      }
+    }),
+  );
+
+  const lines = sessions.map((s) => {
+    const age = s.info.lastActive
+      ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
+      : "?";
+    const title = titles.get(s.chatId) ?? s.chatId;
+    const model = formatModelLabel(
+      getChatSettings(s.chatId).model ?? config.model,
+    );
+    // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
+    // it gets the same escaping the title already had.
+    return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
+  });
+  await replyHtmlChunked(
+    ctx,
+    `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
+  );
+}
+
 export async function handleAdminCommand(
   ctx: Context,
   bot: Bot,
@@ -32,52 +99,7 @@ export async function handleAdminCommand(
 
   switch (subcommand) {
     case "chats": {
-      const sessions = getAllSessions();
-      if (sessions.length === 0) {
-        await ctx.reply("No active sessions.");
-        return;
-      }
-      sessions.sort(
-        (a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0),
-      );
-
-      const titles = new Map<string, string>();
-      await Promise.all(
-        sessions.map(async (s) => {
-          try {
-            const id = parseInt(s.chatId, 10);
-            if (isNaN(id)) return;
-            const chat = await bot.api.getChat(id);
-            titles.set(
-              s.chatId,
-              "title" in chat
-                ? (chat.title ?? "DM")
-                : "first_name" in chat
-                  ? (chat.first_name ?? "DM")
-                  : "DM",
-            );
-          } catch {
-            /* inaccessible */
-          }
-        }),
-      );
-
-      const lines = sessions.map((s) => {
-        const age = s.info.lastActive
-          ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
-          : "?";
-        const title = titles.get(s.chatId) ?? s.chatId;
-        const model = formatModelLabel(
-          getChatSettings(s.chatId).model ?? config.model,
-        );
-        // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
-        // it gets the same escaping the title already had.
-        return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
-      });
-      await ctx.reply(
-        `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
-      );
+      await replyActiveChats(ctx, bot, config);
       return;
     }
 
@@ -189,9 +211,9 @@ export async function handleAdminCommand(
           : "?";
         return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${escapeHtml(describeSchedule(j))}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
       });
-      await ctx.reply(
+      await replyHtmlChunked(
+        ctx,
         `<b>Cron Jobs (${jobs.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
       );
       return;
     }
@@ -217,9 +239,10 @@ export async function handleAdminCommand(
           return `${p.enabled ? "\u2713" : "\u2717"} ${escapeHtml(title)}`;
         }),
       );
-      await ctx.reply(`<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"), {
-        parse_mode: "HTML",
-      });
+      await replyHtmlChunked(
+        ctx,
+        `<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"),
+      );
       return;
     }
 

package/src/frontend/whatsapp/access.ts

@@ -0,0 +1,67 @@
+/**
+ * Access gates — the allow-lists are the entire permission model. DMs
+ * match `allowedJids` (see identity.ts); groups go through `groupPolicy`
+ * and, in mention mode, must address the bot.
+ */
+
+import type { WAMessage } from "baileys";
+import { logWarn } from "../../util/log.js";
+import { bareId } from "./identity.js";
+import type { WhatsAppRuntime } from "./runtime.js";
+
+/**
+ * How long a group's membership answer is trusted. Group metadata costs a
+ * round-trip, and the `with-allowed-user` policy would otherwise pay it on
+ * every inbound message; memberships change on the order of days.
+ */
+const GROUP_POLICY_CACHE_MS = 10 * 60_000;
+
+/**
+ * May the bot act in this group? `allowedGroups` is always honoured;
+ * beyond it the policy decides, and "with-allowed-user" asks WhatsApp
+ * who is in the group (cached — see GROUP_POLICY_CACHE_MS).
+ */
+export async function isGroupAllowed(
+  runtime: WhatsAppRuntime,
+  jid: string,
+): Promise<boolean> {
+  if (runtime.allowedGroups.has(bareId(jid))) return true;
+  if (runtime.settings.groupPolicy === "listed") return false;
+  if (runtime.settings.groupPolicy === "all") return true;
+
+  const cached = runtime.groupAllowCache.get(jid);
+  if (cached && Date.now() - cached.at < GROUP_POLICY_CACHE_MS) {
+    return cached.allowed;
+  }
+  let allowed = false;
+  try {
+    const meta = await runtime.sock!.groupMetadata(jid);
+    // A participant is listed by whichever form the group uses, so
+    // check every id WhatsApp gives us for them.
+    allowed = meta.participants.some((p) =>
+      [p.id, p.lid, p.phoneNumber]
+        .filter((id): id is string => Boolean(id))
+        .some((id) => runtime.allowedDms.has(bareId(id))),
+    );
+  } catch (err) {
+    // A metadata failure must not silently open the group up.
+    logWarn(
+      "whatsapp",
+      `Group policy check failed for ${jid}: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+  runtime.groupAllowCache.set(jid, { allowed, at: Date.now() });
+  return allowed;
+}
+
+/** Is this group message addressed to us — @mentioned or quoting us? */
+export function isAddressedToSelf(
+  selfIds: readonly string[],
+  msg: WAMessage,
+): boolean {
+  if (selfIds.length === 0) return false;
+  const ctx = msg.message?.extendedTextMessage?.contextInfo;
+  const isSelf = (j: string): boolean => selfIds.includes(bareId(j));
+  if ((ctx?.mentionedJid ?? []).some(isSelf)) return true;
+  return Boolean(ctx?.participant && isSelf(ctx.participant));
+}