talon-agent 3.33.4 → 3.34.1

package/src/frontend/native/media.ts

@@ -0,0 +1,43 @@
+/**
+ * Media handling — the id → path registry the `/media` route serves from,
+ * and the uploads directory client attachments land in.
+ */
+
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { dirs } from "../../util/paths.js";
+import type { NativeRuntime } from "./runtime.js";
+
+/** Register a file for serving and return its short media id. */
+export function registerMedia(
+  runtime: NativeRuntime,
+  filePath: string,
+): string {
+  const id = `m${runtime.nextId().toString(36)}`;
+  runtime.media.set(id, filePath);
+  return id;
+}
+
+/** The relative bridge path a client renders a registered media id from. */
+export function mediaUrl(mediaId: string): string {
+  return `/media?id=${encodeURIComponent(mediaId)}`;
+}
+
+/**
+ * Persist an uploaded attachment to the workspace uploads dir under a safe,
+ * unique name, and return its absolute path (handed to the model to read).
+ */
+export async function saveUpload(
+  runtime: NativeRuntime,
+  filename: string,
+  bytes: Buffer,
+): Promise<string> {
+  await mkdir(dirs.uploads, { recursive: true });
+  const safe = basename(filename).replace(/[^\w.-]+/g, "_") || "upload";
+  const dest = join(
+    dirs.uploads,
+    `${Date.now()}-${runtime.nextId().toString(36)}-${safe}`,
+  );
+  await writeFile(dest, bytes);
+  return dest;
+}

package/src/frontend/native/models.ts

@@ -0,0 +1,221 @@
+/**
+ * Per-chat model, backend and effort selection — the pickers behind the
+ * companion app's model sheet. The persisted per-chat setting is always
+ * consulted before the live pool binding (see `toClientChat` for why).
+ */
+
+import {
+  getChatSettings,
+  setChatEffort,
+  setChatModelForBackend,
+  getChatModelForBackend,
+  setChatBackend,
+  EFFORT_LEVELS,
+  type EffortLevel,
+} from "../../storage/chat-settings.js";
+import {
+  getBackendForChat,
+  getBackendIdForChat,
+  getPooledBackend,
+  acquireBackendInstance,
+  listAvailableBackends,
+  rebindChat,
+} from "../../core/engine/backend-controller/index.js";
+import { getActiveReasoningLevels } from "../shared/reasoning-levels.js";
+import { broadcastChatUpdated } from "./chat-wire.js";
+import { emitSystem } from "./emit.js";
+import type { BackendOption, ModelOption } from "./protocol.js";
+import { wipeChatConversation } from "./reset.js";
+import type { NativeRuntime } from "./runtime.js";
+import { broadcastStatus } from "./status.js";
+
+export async function listModels(
+  runtime: NativeRuntime,
+  chatId?: string,
+): Promise<{ active: string; models: ModelOption[] }> {
+  const { config } = runtime;
+  // Resolve the chat's *own* backend so the model list tracks whatever
+  // backend the chat is currently bound to (fixes the list staying on the
+  // previous backend's models after a switch). Fall back to the global
+  // default backend when there's no chat / the pool isn't ready yet.
+  let backendId: string = config.backend;
+  let active = config.model;
+  if (chatId) {
+    try {
+      // Persisted setting first — see toClientChat.
+      backendId =
+        getChatSettings(chatId).backend ?? getBackendIdForChat(chatId);
+      active = getChatModelForBackend(chatId, backendId) ?? config.model;
+    } catch {
+      /* pool not ready — keep global defaults */
+    }
+  }
+
+  // Pull the models dynamically from the gateway for that backend. Prefer
+  // an already-pooled instance of the *resolved* backend (the persisted
+  // choice — the chat's live binding can lag it after a failed boot-time
+  // rebind, and listing the live binding's catalog here showed the wrong
+  // backend's models); otherwise boot the backend transiently to read its
+  // catalog, then release it so we never leak an instance — mirroring the
+  // shared `list_models` action.
+  let instance:
+    | Awaited<ReturnType<typeof acquireBackendInstance>>["backend"]
+    | null
+    | undefined = getPooledBackend(backendId);
+  let release: (() => Promise<void>) | null = null;
+  if (!instance) {
+    try {
+      const acquired = await acquireBackendInstance(backendId);
+      instance = acquired.backend;
+      release = acquired.release;
+    } catch {
+      return { active, models: [] };
+    }
+  }
+
+  try {
+    const catalog = instance.models;
+    if (!catalog?.listModels) return { active, models: [] };
+    const { models } = await catalog.listModels("all");
+    const options: ModelOption[] = models
+      .filter((m) => m.selectable)
+      .map((m) => ({
+        id: m.id,
+        displayName: m.displayName,
+        provider: m.provider,
+        reasoning:
+          Boolean(m.supportedReasoningLevels?.length) || Boolean(m.reasoning),
+      }));
+    return { active, models: options };
+  } catch {
+    return { active, models: [] };
+  } finally {
+    if (release) await release();
+  }
+}
+
+export function setModel(
+  runtime: NativeRuntime,
+  chatId: string,
+  model: string,
+): void {
+  const entry = runtime.chats.get(chatId);
+  if (!entry) return;
+  // Persisted setting first — see toClientChat. Writing the pick under the
+  // live binding's key would attach it to the wrong backend whenever the
+  // boot-time rebind to the persisted backend is still pending.
+  const backendId =
+    getChatSettings(chatId).backend ?? getBackendIdForChat(chatId);
+  setChatModelForBackend(chatId, backendId, model.trim() || undefined);
+  broadcastChatUpdated(runtime, entry);
+}
+
+export function listBackends(
+  runtime: NativeRuntime,
+  chatId: string,
+): { active: string; backends: BackendOption[] } {
+  const { config } = runtime;
+  const backends = listAvailableBackends(config);
+  let active: string = config.backend;
+  try {
+    if (chatId) {
+      // Persisted setting first — see toClientChat.
+      active = getChatSettings(chatId).backend ?? getBackendIdForChat(chatId);
+    }
+  } catch {
+    /* pool not ready — report the global default backend */
+  }
+  return { active, backends };
+}
+
+/**
+ * Switch a chat to another backend. Mirrors the Telegram `/model` backend
+ * submenu: verify the target is enabled, rebind the chat's pool holder, pin
+ * the override, and drop the previous backend's per-chat session state
+ * (sessions aren't portable across backends). Per-backend model picks are
+ * kept, so switching back restores the prior model automatically.
+ */
+export async function setBackend(
+  runtime: NativeRuntime,
+  chatId: string,
+  backend: string,
+): Promise<{ ok: boolean; error?: string }> {
+  const { config } = runtime;
+  const entry = runtime.chats.get(chatId);
+  if (!entry) return { ok: false, error: "No such chat" };
+  const target = backend.trim();
+  const available = listAvailableBackends(config);
+  if (!available.some((b) => b.id === target)) {
+    return { ok: false, error: "Backend not available" };
+  }
+  const persisted = getChatSettings(chatId).backend;
+  if (getBackendIdForChat(chatId) === target) {
+    // Already live on the target — just make sure the choice is persisted.
+    if (persisted !== target && target !== config.backend) {
+      setChatBackend(chatId, target);
+      broadcastChatUpdated(runtime, entry);
+    }
+    return { ok: true };
+  }
+
+  const result = await rebindChat(chatId, target, config);
+  if (!result.ok) {
+    return { ok: false, error: result.error ?? "Rebind failed" };
+  }
+
+  // Re-selecting the backend this chat is already persisted to is a
+  // RE-ATTACH (e.g. the boot-time rebind failed transiently and the user —
+  // or a client retry — picks it again). The conversation belongs to that
+  // backend; resetting the session and wiping history here destroyed real
+  // conversations and surfaced as a phantom "backend reset" in clients.
+  if (persisted === target) {
+    broadcastChatUpdated(runtime, entry);
+    broadcastStatus(runtime);
+    return { ok: true };
+  }
+
+  setChatBackend(chatId, target);
+  wipeChatConversation(runtime, chatId);
+  emitSystem(
+    runtime,
+    entry,
+    `Switched to ${target} — starting a fresh conversation.`,
+  );
+  broadcastChatUpdated(runtime, entry);
+  broadcastStatus(runtime);
+  return { ok: true };
+}
+
+export function setEffort(
+  runtime: NativeRuntime,
+  chatId: string,
+  effort: string,
+): void {
+  const entry = runtime.chats.get(chatId);
+  if (!entry) return;
+  const level = EFFORT_LEVELS.includes(effort as EffortLevel)
+    ? (effort as EffortLevel)
+    : undefined;
+  setChatEffort(chatId, level);
+  broadcastChatUpdated(runtime, entry);
+}
+
+export async function effortLevels(
+  runtime: NativeRuntime,
+  chatId: string,
+): Promise<{ active: string; levels: string[] }> {
+  try {
+    const backend = getBackendForChat(chatId);
+    const backendId = getBackendIdForChat(chatId);
+    const { levels } = await getActiveReasoningLevels({
+      chatId,
+      backend,
+      backendId,
+      config: runtime.config,
+    });
+    const active = getChatSettings(chatId).effort ?? "adaptive";
+    return { active, levels };
+  } catch {
+    return { active: "adaptive", levels: [] };
+  }
+}

package/src/frontend/native/queue.ts

@@ -0,0 +1,47 @@
+/**
+ * Queued follow-up bookkeeping — the one message a chat holds while a turn
+ * is running. Every mutation is synced to clients as a `chat_updated`.
+ */
+
+import { broadcastChatUpdated } from "./chat-wire.js";
+import type { ChatEntry } from "./chats.js";
+import type { NativeRuntime, QueuedEntry } from "./runtime.js";
+
+/**
+ * Set (or replace) a chat's queued follow-up and sync it to every client via
+ * chat_updated. Empty text with no attachment clears the queue.
+ */
+export function setQueued(
+  runtime: NativeRuntime,
+  chatId: string,
+  next: QueuedEntry,
+): void {
+  const entry = runtime.chats.get(chatId);
+  if (!entry) return;
+  const text = next.text.trim();
+  if (!text && !next.attachmentPath) {
+    if (!runtime.queuedByChat.delete(chatId)) return;
+  } else {
+    runtime.queuedByChat.set(chatId, {
+      text,
+      imagePath: next.imagePath,
+      attachmentPath: next.attachmentPath,
+    });
+  }
+  broadcastChatUpdated(runtime, entry);
+}
+
+/**
+ * Remove and return a chat's queued follow-up (syncing the now-empty queue
+ * to clients), or undefined when nothing was queued.
+ */
+export function takeQueued(
+  runtime: NativeRuntime,
+  entry: ChatEntry,
+): QueuedEntry | undefined {
+  const queued = runtime.queuedByChat.get(entry.id);
+  if (!queued) return undefined;
+  runtime.queuedByChat.delete(entry.id);
+  broadcastChatUpdated(runtime, entry);
+  return queued;
+}

package/src/frontend/native/reset.ts

@@ -0,0 +1,50 @@
+/**
+ * Chat reset — drop a chat's conversation (session, history, turn meta,
+ * cached readouts, pulse checkpoint) while keeping the chat itself.
+ */
+
+import { resetSession } from "../../storage/sessions.js";
+import { clearHistory } from "../../storage/history.js";
+import { resetPulseCheckpoint } from "../../core/background/pulse.js";
+import { getBackendForChat } from "../../core/engine/backend-controller/index.js";
+import { broadcastChatUpdated } from "./chat-wire.js";
+import { emitSystem } from "./emit.js";
+import type { NativeRuntime } from "./runtime.js";
+import { clearTurnMeta } from "./turn-meta.js";
+
+/**
+ * Forget everything the conversation accumulated. Shared by the explicit
+ * reset and a backend switch (sessions aren't portable across backends).
+ */
+export function wipeChatConversation(
+  runtime: NativeRuntime,
+  chatId: string,
+): void {
+  resetSession(chatId);
+  clearHistory(chatId);
+  clearTurnMeta(chatId);
+  runtime.contextByChat.delete(chatId);
+  runtime.queuedByChat.delete(chatId);
+  resetPulseCheckpoint(chatId);
+}
+
+export function resetChat(runtime: NativeRuntime, chatId: string): boolean {
+  const entry = runtime.chats.get(chatId);
+  if (!entry) return false;
+  // Full reset, matching /reset on the other frontends: session,
+  // history (the app re-fetches its transcript from us), pulse
+  // checkpoint, and any in-process backend memory. Warm the fresh
+  // session in the background — the bridge handler is sync.
+  wipeChatConversation(runtime, chatId);
+  let backend = null;
+  try {
+    backend = getBackendForChat(chatId);
+  } catch {
+    // No pool binding — nothing to wipe or warm.
+  }
+  backend?.sessions?.resetChat?.(chatId);
+  void backend?.sessions?.warmSession?.(chatId)?.catch(() => {});
+  emitSystem(runtime, entry, "Session reset — starting a fresh conversation.");
+  broadcastChatUpdated(runtime, entry);
+  return true;
+}

package/src/frontend/native/routes/chats.ts

@@ -0,0 +1,115 @@
+import type { RouteHost } from "./host.js";
+import type { BridgeRoutes } from "./table.js";
+import { asPositiveInt, asString, deviceIdParam } from "./params.js";
+
+const MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+
+export function chatRoutes(
+  host: RouteHost,
+): Pick<
+  BridgeRoutes,
+  | "GET /events"
+  | "GET /chats"
+  | "POST /chats"
+  | "POST /chats/rename"
+  | "POST /chats/delete"
+  | "POST /chats/reset"
+  | "POST /chats/interrupt"
+  | "POST /chats/pulse"
+  | "POST /queue"
+  | "GET /history"
+  | "GET /search"
+  | "POST /send"
+  | "POST /upload"
+  | "GET /media"
+> {
+  const { json, readJson, handlers: h } = host;
+  return {
+    // ── Chats ──────────────────────────────────────────────────────────
+
+    // A mesh client names itself here so device-addressed events reach
+    // it alone (see sendToDevice); UI clients simply omit it.
+    "GET /events": ({ res, url }) => host.openStream(res, deviceIdParam(url)),
+    "GET /chats": ({ res }) => json(res, 200, { chats: h.listChats() }),
+    "POST /chats": async ({ req, res }) => {
+      const body = await readJson(req);
+      json(res, 200, { chat: h.createChat(asString(body.title)) });
+    },
+    "POST /chats/rename": async ({ req, res }) => {
+      const body = await readJson(req);
+      const chat = h.renameChat(
+        asString(body.chatId) ?? "",
+        asString(body.title) ?? "",
+      );
+      return chat
+        ? json(res, 200, { chat })
+        : json(res, 404, { ok: false, error: "No such chat" });
+    },
+    "POST /chats/delete": async ({ req, res }) => {
+      const body = await readJson(req);
+      json(res, 200, { ok: h.deleteChat(asString(body.chatId) ?? "") });
+    },
+    "POST /chats/reset": async ({ req, res }) => {
+      const body = await readJson(req);
+      json(res, 200, { ok: h.resetChat(asString(body.chatId) ?? "") });
+    },
+    "POST /chats/interrupt": async ({ req, res }) => {
+      const body = await readJson(req);
+      const ok = await h.interruptTurn(asString(body.chatId) ?? "");
+      json(res, 200, { ok });
+    },
+    "POST /chats/pulse": async ({ req, res }) => {
+      const body = await readJson(req);
+      h.setPulse(asString(body.chatId) ?? "", body.on === true);
+      json(res, 200, { ok: true });
+    },
+    "POST /queue": async ({ req, res }) => {
+      const body = await readJson(req);
+      h.queueMessage(asString(body.chatId) ?? "", asString(body.text) ?? "");
+      json(res, 200, { ok: true });
+    },
+    "GET /history": ({ res, url }) => {
+      const id = url.searchParams.get("chatId") ?? "";
+      const before = asPositiveInt(url.searchParams.get("before"));
+      const limit = asPositiveInt(url.searchParams.get("limit"));
+      json(res, 200, {
+        chatId: id,
+        messages: h.history(id, { before, limit }),
+      });
+    },
+    "GET /search": ({ res, url }) => {
+      const q = (url.searchParams.get("q") ?? "").trim();
+      if (!q) return json(res, 400, { ok: false, error: "q required" });
+      const chatId = url.searchParams.get("chatId") ?? undefined;
+      json(res, 200, { results: h.search(q, chatId) });
+    },
+    "POST /send": async ({ req, res }) => {
+      const body = await readJson(req);
+      const id = asString(body.chatId) ?? "";
+      const text = asString(body.text) ?? "";
+      const imagePath = asString(body.imagePath);
+      const attachmentPath = asString(body.attachmentPath);
+      // Text may be empty when an image is attached; require one or the
+      // other.
+      if (!id || (!text.trim() && !attachmentPath))
+        return json(res, 400, {
+          ok: false,
+          error: "chatId and text (or an attachment) required",
+        });
+      h.send(id, text, { imagePath, attachmentPath });
+      json(res, 202, { ok: true });
+    },
+    "POST /upload": async ({ req, res, url }) => {
+      const filename = url.searchParams.get("filename") ?? "upload";
+      const contentType =
+        req.headers["content-type"] ?? "application/octet-stream";
+      const bytes = await host.readRaw(req, MAX_UPLOAD_BYTES);
+      if (!bytes.length)
+        return json(res, 400, { ok: false, error: "Empty upload" });
+      const result = await h.upload(filename, contentType, bytes);
+      json(res, 200, { ok: true, ...result });
+    },
+    "GET /media": ({ res, url }) =>
+      host.serveMedia(res, url.searchParams.get("id") ?? ""),
+  };
+}

package/src/frontend/native/routes/daemon.ts

@@ -0,0 +1,70 @@
+import type { RouteHost } from "./host.js";
+import type { BridgeRoutes } from "./table.js";
+import { isLogLevel } from "../protocol.js";
+import { asPositiveInt, asString } from "./params.js";
+
+export function daemonRoutes(
+  host: RouteHost,
+): Pick<
+  BridgeRoutes,
+  | "GET /logs"
+  | "GET /plugins"
+  | "POST /plugins/toggle"
+  | "GET /skills"
+  | "POST /skills/toggle"
+  | "GET /config"
+  | "POST /config"
+  | "POST /control"
+> {
+  const { json, readJson, handlers: h } = host;
+  return {
+    // ── Daemon ─────────────────────────────────────────────────────────
+
+    "GET /logs": ({ res, url }) => {
+      const lines = Math.min(
+        asPositiveInt(url.searchParams.get("lines")) ?? 200,
+        1000,
+      );
+      const level = url.searchParams.get("level") ?? "";
+      const component = url.searchParams.get("component") ?? undefined;
+      json(res, 200, {
+        entries: h.logs({
+          lines,
+          minLevel: isLogLevel(level) ? level : undefined,
+          component,
+        }),
+      });
+    },
+    "GET /plugins": ({ res }) => json(res, 200, { plugins: h.listPlugins() }),
+    "POST /plugins/toggle": async ({ req, res }) => {
+      const body = await readJson(req);
+      // Always 200: ok/error is an application result the client renders
+      // (mirrors /backend).
+      const result = await h.setPluginEnabled(
+        asString(body.name) ?? "",
+        body.enabled === true,
+      );
+      json(res, 200, result);
+    },
+    "GET /skills": ({ res }) => json(res, 200, { skills: h.listSkills() }),
+    "POST /skills/toggle": async ({ req, res }) => {
+      const body = await readJson(req);
+      json(
+        res,
+        200,
+        h.setSkillEnabled(asString(body.name) ?? "", body.enabled === true),
+      );
+    },
+    "GET /config": ({ res }) => json(res, 200, h.getConfig()),
+    "POST /config": async ({ req, res }) => {
+      const body = await readJson(req);
+      json(res, 200, h.setConfig(body));
+    },
+    "POST /control": async ({ req, res }) => {
+      const body = await readJson(req);
+      // Always 200: ok/message is an application result the client
+      // renders (mirrors /backend).
+      json(res, 200, await h.control(asString(body.action) ?? ""));
+    },
+  };
+}