talon-agent 3.33.4 → 3.34.0

package/src/frontend/native/chat-lifecycle.ts

@@ -0,0 +1,39 @@
+/**
+ * Chat lifecycle — create, rename and delete, each broadcast so every open
+ * client list updates in place.
+ */
+
+import { toClientChat } from "./chat-wire.js";
+import type { ClientChat } from "./protocol.js";
+import type { NativeRuntime } from "./runtime.js";
+import { clearTurnMeta } from "./turn-meta.js";
+
+export function createChat(runtime: NativeRuntime, title?: string): ClientChat {
+  const entry = runtime.chats.create(title);
+  const chat = toClientChat(runtime, entry);
+  runtime.broadcast({ kind: "chat_created", chat });
+  return chat;
+}
+
+export function renameChat(
+  runtime: NativeRuntime,
+  chatId: string,
+  title: string,
+): ClientChat | null {
+  const entry = runtime.chats.rename(chatId, title);
+  if (!entry) return null;
+  const chat = toClientChat(runtime, entry);
+  runtime.broadcast({ kind: "chat_updated", chat });
+  return chat;
+}
+
+export function deleteChat(runtime: NativeRuntime, chatId: string): boolean {
+  const ok = runtime.chats.remove(chatId);
+  if (ok) {
+    clearTurnMeta(chatId);
+    runtime.contextByChat.delete(chatId);
+    runtime.queuedByChat.delete(chatId);
+    runtime.broadcast({ kind: "chat_deleted", chatId });
+  }
+  return ok;
+}

package/src/frontend/native/chat-wire.ts

@@ -0,0 +1,69 @@
+/**
+ * Per-chat wire projection — a registry entry plus its persisted settings,
+ * cached context fill and queued follow-up, as the `ClientChat` clients
+ * render. `chat_updated` is always built from here so every client sees the
+ * same shape.
+ */
+
+import {
+  getChatSettings,
+  getChatModelForBackend,
+} from "../../storage/chat-settings.js";
+import { getBackendIdForChat } from "../../core/engine/backend-controller/index.js";
+import type { ChatEntry } from "./chats.js";
+import type { ClientChat, QueuedMessage } from "./protocol.js";
+import type { NativeRuntime } from "./runtime.js";
+
+/** Project the stored queue entry to its wire shape (text + attachment flag). */
+function toQueued(
+  runtime: NativeRuntime,
+  chatId: string,
+): QueuedMessage | undefined {
+  const q = runtime.queuedByChat.get(chatId);
+  if (!q) return undefined;
+  return { text: q.text, hasAttachment: Boolean(q.attachmentPath) };
+}
+
+export function toClientChat(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+): ClientChat {
+  const settings = getChatSettings(entry.id);
+  let model: string | undefined;
+  let backend: string | undefined;
+  try {
+    // The persisted per-chat setting is the source of truth for what the
+    // user picked; the in-memory binding can lag it (boot-time rebind
+    // still pending or transiently failed). Reporting the binding here
+    // made clients show a chat "reset" to the default backend after a
+    // daemon restart even though the user's choice was intact.
+    backend = settings.backend ?? getBackendIdForChat(entry.id);
+    model = getChatModelForBackend(entry.id, backend);
+  } catch {
+    backend = settings.backend;
+    /* backend pool not ready (early boot) — omit model */
+  }
+  return {
+    id: entry.id,
+    title: entry.title,
+    createdAt: entry.createdAt,
+    lastActive: entry.lastActive,
+    preview: entry.preview,
+    model,
+    backend,
+    effort: settings.effort,
+    pulse: settings.pulse,
+    context: runtime.contextByChat.get(entry.id),
+    queued: toQueued(runtime, entry.id),
+  };
+}
+
+export function broadcastChatUpdated(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+): void {
+  runtime.broadcast({
+    kind: "chat_updated",
+    chat: toClientChat(runtime, entry),
+  });
+}

package/src/frontend/native/context.ts

@@ -0,0 +1,106 @@
+/**
+ * Context-window readout — compute a chat's fill from its session usage,
+ * cache it on the runtime, and push changes to clients.
+ */
+
+import { getSessionInfo } from "../../storage/sessions.js";
+import { buildContextDisplay } from "../shared/status-context.js";
+import { resolveActiveModelForChat } from "../../core/models/active-model.js";
+import {
+  getBackendForChat,
+  getBackendIdForChat,
+} from "../../core/engine/backend-controller/index.js";
+import { broadcastChatUpdated } from "./chat-wire.js";
+import type { ChatEntry } from "./chats.js";
+import type { ContextInfo } from "./protocol.js";
+import type { NativeRuntime } from "./runtime.js";
+
+type ContextOptions = { resolveModel?: boolean };
+
+/**
+ * Compute the current context-window fill for a chat from its session
+ * usage, reusing the same `buildContextDisplay` the terminal/Discord
+ * `/status` line uses. When the session's usage doesn't carry a window
+ * size yet (fresh session), fall back to the resolved model's window so
+ * the readout still lands. Returns undefined when nothing is known — the
+ * clients hide the indicator rather than render a bogus 0%.
+ */
+async function computeContext(
+  runtime: NativeRuntime,
+  chatId: string,
+  options?: ContextOptions,
+): Promise<ContextInfo | undefined> {
+  try {
+    const info = getSessionInfo(chatId);
+    const u = info.usage;
+    let ctxMax = u.contextWindow;
+    // The model fallback touches the backend pool, which is fine for one
+    // chat the user just opened and wrong for every chat at boot — the
+    // startup warm asks for the cheap path and lets anything it can't
+    // resolve fill in when that chat is next opened.
+    if (!ctxMax && options?.resolveModel !== false) {
+      try {
+        const backend = getBackendForChat(chatId);
+        const backendId = getBackendIdForChat(chatId);
+        const { ref } = await resolveActiveModelForChat(
+          chatId,
+          backend,
+          backendId,
+          runtime.config,
+        );
+        if (ref?.contextWindow) ctxMax = ref.contextWindow;
+      } catch {
+        /* backend pool not ready — leave max unknown */
+      }
+    }
+    const ctx = buildContextDisplay({
+      contextTokens: u.contextTokens,
+      lastPromptTokens: u.lastPromptTokens,
+      contextWindow: ctxMax,
+    });
+    if (!ctx.known && ctx.max === 0) return undefined;
+    return {
+      known: ctx.known,
+      used: ctx.used,
+      max: ctx.max,
+      pct: ctx.pct,
+      warn: ctx.warn,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Recompute a chat's context fill and, if it changed, push it to clients. */
+export async function refreshContext(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  options?: ContextOptions,
+): Promise<void> {
+  const next = await computeContext(runtime, entry.id, options);
+  if (!next) return;
+  const prev = runtime.contextByChat.get(entry.id);
+  if (prev && prev.used === next.used && prev.max === next.max) return;
+  runtime.contextByChat.set(entry.id, next);
+  broadcastChatUpdated(runtime, entry);
+}
+
+/**
+ * Fill the context cache for chats restored at startup.
+ *
+ * The readout is served from an in-memory map that was only ever written at
+ * turn end, so after a restart every existing chat reported no context at
+ * all — the header chip vanished until that chat ran another turn, which
+ * read as "context usage doesn't save". The numbers themselves are
+ * persisted with the session; only the cache was cold. This re-reads them
+ * for the most recently active chats (bounded, and on the cheap path that
+ * never touches the backend pool); anything it skips or can't resolve is
+ * filled in the moment the chat is opened.
+ */
+const CONTEXT_WARM_LIMIT = 40;
+
+export async function warmContextCache(runtime: NativeRuntime): Promise<void> {
+  for (const entry of runtime.chats.list().slice(0, CONTEXT_WARM_LIMIT)) {
+    await refreshContext(runtime, entry, { resolveModel: false });
+  }
+}

package/src/frontend/native/control.ts

@@ -0,0 +1,78 @@
+/**
+ * Daemon control — the restart / dream actions the app fires from Settings.
+ */
+
+import { dirname, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { isBunRuntime } from "../../util/runtime.js";
+import { logError } from "../../util/log.js";
+import { PKG_ROOT } from "../../cli/context.js";
+import { forceDream } from "../../core/background/dream.js";
+
+/**
+ * Restart the daemon by spawning a detached `talon restart` — the same
+ * command a human runs. It must be an independent, detached process: the
+ * restart stops *this* process, so doing it in-process would kill us before
+ * the successor is spawned. The child outlives us, tears the daemon down,
+ * and brings a fresh one up. Mirrors `core/daemon/control.ts`'s own
+ * source-vs-compiled-binary spawn recipe.
+ */
+function spawnDaemonRestart(): void {
+  const isBunBinary =
+    (process.argv[1] ?? "").includes("~BUN") ||
+    (process.argv[1] ?? "").includes("$bunfs");
+  const cmd = process.execPath;
+  const args = isBunBinary
+    ? ["restart"]
+    : isBunRuntime()
+      ? [resolve(PKG_ROOT, "src", "cli.ts"), "restart"]
+      : [
+          resolve(PKG_ROOT, "node_modules", "tsx", "dist", "cli.mjs"),
+          resolve(PKG_ROOT, "src", "cli.ts"),
+          "restart",
+        ];
+  const cwd = isBunBinary ? dirname(process.execPath) : PKG_ROOT;
+  const child = spawn(cmd, args, {
+    cwd,
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env },
+    windowsHide: true,
+  });
+  child.unref();
+}
+
+/**
+ * Daemon-level control actions the app fires from Settings. Kept minimal and
+ * explicit — each maps to a well-understood operation the CLI already
+ * exposes, so there's no new privileged surface beyond "what a local admin
+ * could already do".
+ */
+export async function control(
+  action: string,
+): Promise<{ ok: boolean; message: string }> {
+  switch (action) {
+    case "restart":
+      spawnDaemonRestart();
+      return {
+        ok: true,
+        message: "Restarting Talon — back online in a few seconds.",
+      };
+    case "dream":
+      // Fire-and-forget: a dream run can take a while; the app just needs
+      // to know it started. forceDream throws if one is already running.
+      try {
+        void forceDream().catch((err) =>
+          logError("native", "Manual dream run failed", err),
+        );
+        return { ok: true, message: "Dream started — consolidating memory." };
+      } catch (err) {
+        return {
+          ok: false,
+          message: err instanceof Error ? err.message : String(err),
+        };
+      }
+    default:
+      return { ok: false, message: `Unknown control action: ${action}` };
+  }
+}

package/src/frontend/native/emit.ts

@@ -0,0 +1,167 @@
+/**
+ * Outbound message helpers — persist a message to history (where it should
+ * persist), touch the chat, and broadcast it to every client.
+ */
+
+import { pushMessage } from "../../storage/history.js";
+import { extractSessionName } from "../../util/session-name.js";
+import { broadcastChatUpdated } from "./chat-wire.js";
+import { DEFAULT_CHAT_TITLE, type ChatEntry } from "./chats.js";
+import { mediaUrl, registerMedia } from "./media.js";
+import {
+  BOT_SENDER_ID,
+  USER_SENDER_ID,
+  type ClientButton,
+  type ClientMessage,
+} from "./protocol.js";
+import type { NativeRuntime } from "./runtime.js";
+
+/**
+ * Name a chat from its first user message — instantly and for free.
+ *
+ * The title is a trimmed slice of the first message (no model call), so it
+ * lands the moment the user hits send instead of staying "New chat" until
+ * the turn finishes and a restart re-hydrates the persisted name. Only fires
+ * while the chat still carries the placeholder title, so a user's manual
+ * rename is never clobbered. Callers broadcast `chat_updated` afterwards, so
+ * the change propagates to every connected client live.
+ */
+function maybeAutoTitle(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  text: string,
+): void {
+  if (entry.title && entry.title !== DEFAULT_CHAT_TITLE) return;
+  const title = extractSessionName(text);
+  if (title) runtime.chats.rename(entry.id, title);
+}
+
+export function emitAssistant(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  text: string,
+  buttons?: ClientButton[][],
+): number {
+  const id = runtime.nextId();
+  const ts = Date.now();
+  const message: ClientMessage = {
+    id: String(id),
+    chatId: entry.id,
+    role: "assistant",
+    text,
+    ts,
+    ...(buttons ? { buttons } : {}),
+  };
+  pushMessage(entry.id, {
+    msgId: id,
+    senderId: BOT_SENDER_ID,
+    senderName: runtime.botName,
+    text,
+    timestamp: ts,
+  });
+  runtime.chats.touch(entry.id, text);
+  runtime.lastAssistantId.set(entry.id, String(id));
+  runtime.broadcast({ kind: "message", chatId: entry.id, message });
+  broadcastChatUpdated(runtime, entry);
+  return id;
+}
+
+/** Persist + broadcast an assistant photo message (image + optional caption). */
+export function emitPhoto(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  filePath: string,
+  caption?: string,
+): number {
+  const id = runtime.nextId();
+  const ts = Date.now();
+  const text = caption?.trim() ?? "";
+  const mediaId = registerMedia(runtime, filePath);
+  const message: ClientMessage = {
+    id: String(id),
+    chatId: entry.id,
+    role: "assistant",
+    text,
+    ts,
+    imagePath: mediaUrl(mediaId),
+  };
+  // Persist the image reference so it re-renders when history reloads (the
+  // filePath is re-registered into the media map on read). The caption is
+  // stored as plain text; the `photo` mediaType carries the image marker.
+  pushMessage(entry.id, {
+    msgId: id,
+    senderId: BOT_SENDER_ID,
+    senderName: runtime.botName,
+    text,
+    timestamp: ts,
+    mediaType: "photo",
+    filePath,
+  });
+  runtime.chats.touch(entry.id, text || "[photo]");
+  runtime.lastAssistantId.set(entry.id, String(id));
+  runtime.broadcast({ kind: "message", chatId: entry.id, message });
+  broadcastChatUpdated(runtime, entry);
+  return id;
+}
+
+/** Persist + broadcast a user message; returns its numeric id so the turn
+ *  hands the model that same id (as `[msg_id:N]`) to react/reply to.
+ *  An optional imagePath renders an attached image inline. */
+export function emitUser(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  text: string,
+  imagePath?: string,
+  attachmentPath?: string,
+): number {
+  const id = runtime.nextId();
+  const ts = Date.now();
+  const message: ClientMessage = {
+    id: String(id),
+    chatId: entry.id,
+    role: "user",
+    text,
+    ts,
+    ...(imagePath ? { imagePath } : {}),
+  };
+  // For an attached image, persist the on-disk path + a `photo` mediaType so
+  // it re-renders on history reload (rehydrated in the `history` handler)
+  // instead of vanishing to a text-only placeholder. Caption stays as text.
+  pushMessage(entry.id, {
+    msgId: id,
+    senderId: USER_SENDER_ID,
+    senderName: "User",
+    text,
+    timestamp: ts,
+    ...(imagePath
+      ? {
+          mediaType: "photo" as const,
+          ...(attachmentPath ? { filePath: attachmentPath } : {}),
+        }
+      : {}),
+  });
+  runtime.chats.touch(entry.id, imagePath ? text || "[photo]" : text);
+  maybeAutoTitle(runtime, entry, text);
+  runtime.broadcast({ kind: "message", chatId: entry.id, message });
+  broadcastChatUpdated(runtime, entry);
+  return id;
+}
+
+/** Transient, non-persisted notice (e.g. "session reset"). */
+export function emitSystem(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+  text: string,
+): void {
+  runtime.broadcast({
+    kind: "message",
+    chatId: entry.id,
+    message: {
+      id: `sys-${runtime.nextId()}`,
+      chatId: entry.id,
+      role: "system",
+      text,
+      ts: Date.now(),
+    },
+  });
+}

package/src/frontend/native/empty-chat-sweep.ts

@@ -0,0 +1,50 @@
+/**
+ * Empty-chat sweeper.
+ *
+ * "New chat" creates a real chat on the daemon the instant it's tapped, so
+ * opening one and backing out of it leaves an empty row in every client's
+ * list forever. The app deletes an untouched chat as soon as you leave it,
+ * which covers the normal case immediately; this is the backstop for the
+ * ones no client got to clean up — the app was killed, the network dropped,
+ * or the chat was created by something that never came back.
+ *
+ * Deliberately conservative: only chats that never carried a single message
+ * (see ChatEntry.used, which a reset does NOT clear), only after an hour,
+ * never one with a turn running or a message queued, and never one whose
+ * history says otherwise. Deleting via the same path every client uses
+ * means the removal is broadcast, so open lists update in place.
+ */
+
+import { log, logError } from "../../util/log.js";
+import { getRecentHistory } from "../../storage/history.js";
+import { deleteChat } from "./chat-lifecycle.js";
+import type { NativeRuntime } from "./runtime.js";
+import { isBusy } from "./turn.js";
+
+const EMPTY_CHAT_MIN_AGE_MS = 60 * 60_000;
+const EMPTY_CHAT_SWEEP_INTERVAL_MS = 30 * 60_000;
+
+function sweepEmptyChats(runtime: NativeRuntime): void {
+  for (const entry of runtime.chats.unused(EMPTY_CHAT_MIN_AGE_MS)) {
+    if (isBusy(runtime, entry.id) || runtime.queuedByChat.has(entry.id))
+      continue;
+    if (getRecentHistory(entry.id, 1).length > 0) continue;
+    if (deleteChat(runtime, entry.id)) {
+      log("native", `Swept empty chat ${entry.id}`);
+    }
+  }
+}
+
+/** Run the sweep on its interval; returns the function that stops it. */
+export function startEmptyChatSweep(runtime: NativeRuntime): () => void {
+  const timer = setInterval(() => {
+    try {
+      sweepEmptyChats(runtime);
+    } catch (err) {
+      logError("native", "Empty-chat sweep failed", err);
+    }
+  }, EMPTY_CHAT_SWEEP_INTERVAL_MS);
+  // Housekeeping must never be the reason the process stays alive.
+  timer.unref?.();
+  return () => clearInterval(timer);
+}

package/src/frontend/native/handlers.ts

@@ -0,0 +1,121 @@
+/**
+ * Bridge server handlers — the table that binds the transport's routes
+ * (server.ts) to the runtime modules. Each entry is a one-line delegation;
+ * anything with logic of its own lives in the module named for it.
+ */
+
+import { files } from "../../util/paths.js";
+import { setChatPulse } from "../../storage/chat-settings.js";
+import { getPooledBackend } from "../../core/engine/backend-controller/index.js";
+import { createChat, deleteChat, renameChat } from "./chat-lifecycle.js";
+import { broadcastChatUpdated, toClientChat } from "./chat-wire.js";
+import { control } from "./control.js";
+import {
+  pluginItems,
+  skillItems,
+  togglePlugin,
+  toggleSkill,
+} from "./extensions.js";
+import { historyPage, searchHistory } from "./history.js";
+import { readLogEntries } from "./logs.js";
+import { mediaUrl, registerMedia, saveUpload } from "./media.js";
+import {
+  effortLevels,
+  listBackends,
+  listModels,
+  setBackend,
+  setEffort,
+  setModel,
+} from "./models.js";
+import { setQueued } from "./queue.js";
+import { resetChat } from "./reset.js";
+import type { NativeRuntime } from "./runtime.js";
+import type { BridgeServerHandlers } from "./server.js";
+import { configSnapshot, applyConfigUpdate } from "./settings.js";
+import { bridgeStatus, broadcastStatus } from "./status.js";
+import { interruptTurn, isBusy, liveTurnEvents, startTurn } from "./turn.js";
+
+export function buildBridgeHandlers(
+  runtime: NativeRuntime,
+): BridgeServerHandlers {
+  const { chats, config, mesh } = runtime;
+  return {
+    status: () => bridgeStatus(runtime),
+    listChats: () => chats.list().map((entry) => toClientChat(runtime, entry)),
+    createChat: (title) => createChat(runtime, title),
+    renameChat: (id, title) => renameChat(runtime, id, title),
+    deleteChat: (id) => deleteChat(runtime, id),
+    history: (id, opts) => historyPage(runtime, id, opts),
+    search: (query, chatId) => searchHistory(runtime, query, chatId),
+    send: (id, text, opts) => {
+      const entry = chats.get(id) ?? chats.ensure(id);
+      // A turn is already running for this chat — don't interrupt it. Park the
+      // message as the single queued follow-up (synced to every client); it
+      // auto-sends when the running turn ends. `isBusy` reads `liveTurns`,
+      // which `runTurn` sets synchronously, so even a rapid second /send from
+      // any client is caught here rather than starting a concurrent turn.
+      if (isBusy(runtime, entry.id)) {
+        setQueued(runtime, entry.id, {
+          text,
+          imagePath: opts?.imagePath,
+          attachmentPath: opts?.attachmentPath,
+        });
+        return;
+      }
+      startTurn(runtime, entry, text, opts);
+    },
+    queueMessage: (id, text) => {
+      // Edit/replace the queued follow-up (text-only). Empty clears it.
+      const entry = chats.get(id);
+      if (entry) setQueued(runtime, entry.id, { text });
+    },
+    upload: async (filename, _contentType, bytes) => {
+      const path = await saveUpload(runtime, filename, bytes);
+      return { imagePath: mediaUrl(registerMedia(runtime, path)), path };
+    },
+    listModels: (chatId) => listModels(runtime, chatId),
+    setModel: (id, model) => setModel(runtime, id, model),
+    listBackends: (id) => listBackends(runtime, id),
+    setBackend: (id, backend) => setBackend(runtime, id, backend),
+    setEffort: (id, effort) => setEffort(runtime, id, effort),
+    effortLevels: (id) => effortLevels(runtime, id),
+    interruptTurn: (id) => interruptTurn(runtime, id),
+    resetChat: (id) => resetChat(runtime, id),
+    setPulse: (id, on) => {
+      const entry = chats.get(id);
+      if (!entry) return;
+      setChatPulse(id, on);
+      broadcastChatUpdated(runtime, entry);
+    },
+    getConfig: () => configSnapshot(config),
+    setConfig: (update) => {
+      const snap = applyConfigUpdate(config, update);
+      broadcastStatus(runtime);
+      return snap;
+    },
+    listPlugins: () => pluginItems(config),
+    setPluginEnabled: (name, enabled) =>
+      togglePlugin(config, getPooledBackend(config.backend), name, enabled),
+    listSkills: () => skillItems(),
+    setSkillEnabled: (name, enabled) =>
+      toggleSkill(config, getPooledBackend(config.backend), name, enabled),
+    control,
+    logs: ({ lines, minLevel, component }) =>
+      readLogEntries(files.log, { limit: lines, minLevel, component }),
+    liveTurnEvents: () => liveTurnEvents(runtime),
+    mediaPath: (id) => runtime.media.get(id) ?? null,
+    // Mesh routes are thin transport shims over the shared core service —
+    // storeLocation wakes any pending fresh-fix waiters inside the service.
+    registerDevice: (body) => mesh.register(body),
+    storeLocation: (body) => mesh.storeLocation(body),
+    listDevices: () => mesh.list(),
+    completeCommand: (body) => mesh.completeCommand(body),
+    acceptFileUpload: (token, body, fromDeviceId) =>
+      mesh.acceptFileUpload(token, body, fromDeviceId),
+    openFileDownload: (token, fromDeviceId) =>
+      mesh.openFileDownload(token, fromDeviceId),
+    openCompanionPair: (token, format) => mesh.openCompanionPair(token, format),
+    openNodeInstall: (token) => mesh.openNodeInstall(token),
+    openNodeBinary: (token) => mesh.openNodeBinary(token),
+  };
+}