@agentprojectcontext/apx 1.81.0 → 1.89.1

package/src/interfaces/web/src/lib/api/media.ts

@@ -0,0 +1,126 @@
+import { getToken } from "../http";
+import { apiUrl } from "../net";
+import type { MessageMedia } from "../../types/daemon";
+import { t } from "../../i18n";
+
+/**
+ * Authenticated blob URL for an attachment that arrived over a channel.
+ *
+ * The daemon sandboxes /media to ~/.apx/media, so the caller passes the
+ * absolute path recorded on the turn. A blob (rather than a token in the URL)
+ * because <audio>/<img> cannot carry the bearer header, and the token has no
+ * business sitting in a src attribute.
+ */
+export async function fetchMediaUrl(filePath: string): Promise<string> {
+  const token = getToken();
+  const res = await fetch(apiUrl(`/api/media?path=${encodeURIComponent(filePath)}`), {
+    headers: token ? { authorization: `Bearer ${token}` } : {},
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => "");
+    throw new Error(`media ${res.status}: ${detail.slice(0, 160)}`);
+  }
+  return URL.createObjectURL(await res.blob());
+}
+
+/** What the daemon stored for a file the composer is about to send. */
+export interface UploadedMedia {
+  path: string;
+  name: string;
+  mime: string;
+  kind: MessageMedia["kind"];
+  size: number;
+}
+
+/**
+ * What may be attached, and how much of it. Kept in step with the allowlist in
+ * host/daemon/api/media.js — the daemon is the one that enforces it; this copy
+ * exists so a rejected file says so before it is uploaded, and so the file
+ * picker offers the right set in the first place.
+ */
+const ALLOWED_EXT = [
+  ".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic",
+  ".oga", ".ogg", ".opus", ".weba", ".mp3", ".wav", ".m4a", ".aac",
+  ".mp4", ".mov", ".webm",
+  ".pdf", ".txt", ".md", ".csv", ".json", ".log",
+];
+const MAX_UPLOAD = 25 * 1024 * 1024;
+
+export const ATTACH_ACCEPT = ALLOWED_EXT.join(",");
+
+// A pasted screenshot arrives as a File with no useful name (Chrome says
+// "image.png", Safari says nothing at all), so the extension comes from the
+// mime type instead. Without this, Cmd+V dropped the paste on the floor: no
+// extension, no allowlist match.
+const EXT_FOR_MIME: Record<string, string> = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/heic": ".heic",
+  "application/pdf": ".pdf",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+  "text/csv": ".csv",
+  "application/json": ".json",
+  // A recording and a pasted video arrive as a Blob with a type and no name at
+  // all. Opus-in-WebM gets `.weba` so it is stored as audio, not as a video
+  // with no picture; Safari's recorder produces audio/mp4 instead.
+  "audio/webm": ".weba",
+  "audio/ogg": ".ogg",
+  "audio/mp4": ".m4a",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "video/webm": ".webm",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+};
+
+/** The filename to send this file under: its own, or one built from its type. */
+export function attachmentName(file: File): string {
+  const own = (file.name || "").trim();
+  if (own && /\.[a-z0-9]{1,5}$/i.test(own)) return own;
+  const ext = EXT_FOR_MIME[file.type] || "";
+  const stem = own.replace(/[^\w.\- ]+/g, "_") || "pasted";
+  return `${stem}${ext}`;
+}
+
+function extensionOf(name: string): string {
+  const i = name.lastIndexOf(".");
+  return i < 0 ? "" : name.slice(i).toLowerCase();
+}
+
+/** Why this file cannot be sent, or null when it can. */
+export function attachmentRejection(file: File): string | null {
+  const ext = extensionOf(attachmentName(file));
+  if (!ext || !ALLOWED_EXT.includes(ext)) {
+    return t("chat_ui.attach_bad_type", { ext: ext || "?" });
+  }
+  if (file.size > MAX_UPLOAD) {
+    return t("chat_ui.attach_too_big", { mb: String(MAX_UPLOAD / (1024 * 1024)) });
+  }
+  return null;
+}
+
+/**
+ * Store a file under ~/.apx/media so a turn can name it. Raw bytes, not
+ * multipart: one file per request, and the name rides in the query.
+ */
+export async function uploadMedia(file: File): Promise<UploadedMedia> {
+  const rejected = attachmentRejection(file);
+  if (rejected) throw new Error(rejected);
+  const token = getToken();
+  const res = await fetch(apiUrl(`/api/media/upload?name=${encodeURIComponent(attachmentName(file))}`), {
+    method: "POST",
+    headers: {
+      "content-type": "application/octet-stream",
+      ...(token ? { authorization: `Bearer ${token}` } : {}),
+    },
+    body: file,
+  });
+  if (!res.ok) {
+    const detail = await res.json().catch(() => ({}) as { error?: string });
+    throw new Error(detail.error || `upload ${res.status}`);
+  }
+  return res.json();
+}

package/src/interfaces/web/src/lib/api/net.ts

@@ -0,0 +1,44 @@
+import { http } from "../http";
+import { rememberEndpoints, type Endpoint } from "../net";
+
+export interface TailscaleInfo {
+  installed: boolean;
+  running: boolean;
+  /** Tailscale's own word for what it is doing: Running, Stopped, NeedsLogin. */
+  state: string | null;
+  ipv4: string | null;
+  hostname: string | null;
+  dnsName: string | null;
+  serving: boolean;
+  serve_url: string | null;
+  serve_error: string | null;
+  error: string | null;
+}
+
+export interface NetEndpoints {
+  port: number;
+  bind: string;
+  shared: boolean;
+  endpoints: Endpoint[];
+  tailscale: TailscaleInfo;
+}
+
+export const Net = {
+  /** Every address this daemon answers at. Reading it also arms the failover:
+   *  the list is cached so a client that loses its address can try the rest. */
+  async endpoints(): Promise<NetEndpoints> {
+    const out = await http.get<NetEndpoints>("/api/net/endpoints");
+    rememberEndpoints(out.endpoints || []);
+    return out;
+  },
+  serve: () =>
+    http.post<{ ok: boolean; serving: boolean; url: string | null; error?: string }>(
+      "/api/net/tailscale/serve",
+    ),
+  unserve: () =>
+    http.del<{ ok: boolean; serving: boolean; url: string | null; error?: string }>(
+      "/api/net/tailscale/serve",
+    ),
+};
+
+export type { Endpoint };

package/src/interfaces/web/src/lib/api/profiles.ts

@@ -43,6 +43,8 @@ export type ProfileCheck = {
   label: string;
   detail: string;
   fix: string | null;
+  /** Set on routine-drift checks: the routine a targeted re-adopt would repair. */
+  routine?: string | null;
 };
 
 export type ProfileDoctor = {
@@ -83,4 +85,14 @@ export const ProfilesApi = {
     ),
   uninstall: (id: string) =>
     http.del<{ ok: true; id: string; source: string }>(`/api/profiles/${encodeURIComponent(id)}`),
+  /**
+   * Force the active profile's routines back to the package, past the skips sync
+   * respects. Pass a routine name to re-adopt just that one; omit it for all.
+   * Discards local edits to the affected routines.
+   */
+  readopt: (routine?: string) =>
+    http.post<{ ok: true; id: string; version: string | null; readopted: string[] }>(
+      "/api/profiles/readopt",
+      routine ? { routine } : {}
+    ),
 };

package/src/interfaces/web/src/lib/api/projects.ts

@@ -21,9 +21,17 @@ export const Projects = {
     put: (id: string, full: Record<string, unknown>) =>
       http.put<{ ok: true; apc_project: Record<string, unknown> }>(`/api/projects/${id}/apc-project`, full),
   },
-  // Project-level memory (.apc/memory.md). Per-agent memory lives in Agents.memory.
+  // Project-level memory. Two files: `memory` is the curated `.apc/memory.md`
+  // that git carries and only a person writes; `memory.local` is
+  // `~/.apx/projects/<id>/memory.md`, never committed, and is the one the
+  // `remember` tool appends to. Per-agent memory lives in Agents.memory.
   memory: {
     get: (id: string) => http.get<{ body: string; path: string }>(`/api/projects/${id}/memory`),
     put: (id: string, body: string) => http.put<{ ok: boolean; bytes: number }>(`/api/projects/${id}/memory`, { body }),
+    local: {
+      get: (id: string) => http.get<{ body: string; path: string }>(`/api/projects/${id}/memory/local`),
+      put: (id: string, body: string) =>
+        http.put<{ ok: boolean; bytes: number }>(`/api/projects/${id}/memory/local`, { body }),
+    },
   },
 };

package/src/interfaces/web/src/lib/api/routines.ts

@@ -1,10 +1,18 @@
 import { http } from "../http";
-import type { RoutineEntry } from "../../types/daemon";
+import type { LiveRoutineRun, RoutineEntry, RoutineRun } from "../../types/daemon";
 
 export const Routines = {
   list:    (pid: string) => http.get<RoutineEntry[]>(`/api/projects/${pid}/routines`),
   get:     (pid: string, name: string) => http.get<RoutineEntry>(`/api/projects/${pid}/routines/${name}`),
   run:     (pid: string, name: string) => http.post<unknown>(`/api/projects/${pid}/routines/${name}/run`),
+  // The runs it has already made — only real runs; a "routine updated" ledger
+  // row is not one, and the daemon is what knows the difference.
+  runs:    (pid: string, name: string) =>
+    http.get<RoutineRun[]>(`/api/projects/${pid}/routines/${encodeURIComponent(name)}/runs`),
+  // The run in flight, if any: what survives a refresh, and what a second
+  // device sees when this one pressed Play.
+  activeRun: (pid: string, name: string) =>
+    http.get<{ run: LiveRoutineRun | null }>(`/api/projects/${pid}/routines/${encodeURIComponent(name)}/run`),
   enable:  (pid: string, name: string) => http.post<unknown>(`/api/projects/${pid}/routines/${name}/enable`),
   disable: (pid: string, name: string) => http.post<unknown>(`/api/projects/${pid}/routines/${name}/disable`),
   upsert:  (pid: string, body: Partial<RoutineEntry>) =>

package/src/interfaces/web/src/lib/api/sessions.ts

@@ -11,7 +11,25 @@ export interface SessionRow {
   match?: "title" | "content";
 }
 
+// One session, read on demand: the working directory and last prompt cost a
+// file read (or a subprocess, for OpenCode) that the list can't pay per row.
+export interface SessionDetail {
+  engine: string;
+  id: string;
+  title: string;
+  last_prompt: string | null;
+  cwd: string | null;
+  path: string | null;
+  mtime: number;
+  /** The command that re-enters this session, or null if the engine can't. */
+  resume_command: string | null;
+}
+
 export const Sessions = {
+  detail: (id: string, engine?: string) =>
+    http.get<SessionDetail>(
+      `/api/sessions/${encodeURIComponent(id)}${engine ? `?engine=${encodeURIComponent(engine)}` : ""}`,
+    ),
   // Cross-engine sessions (apx · claude · codex), newest first — full set.
   global: (engine?: string) =>
     http

package/src/interfaces/web/src/lib/api/skills.ts

@@ -1,10 +1,15 @@
 import { http } from "../http";
 
 export type SkillSource = "builtin" | "global" | "project" | string;
+export type SkillOrigin = "apx" | "global" | "project" | "claude" | "cursor" | "codex" | "agents" | string;
 
 export type SkillEntry = {
   slug: string;
   source: SkillSource;
+  /** Host that owns the files (claude, cursor, …) when APX only holds a link. */
+  origin?: SkillOrigin | null;
+  origin_path?: string | null;
+  file?: string;
   description: string;
   /** Effective enabled state for the requested scope. */
   enabled?: boolean;
@@ -24,6 +29,9 @@ export type SkillsList = {
 export interface SkillDetail {
   slug: string;
   source: SkillSource;
+  origin?: SkillOrigin | null;
+  origin_path?: string | null;
+  file_path?: string | null;
   description: string;
   frontmatter: Record<string, string>;
   body: string;

package/src/interfaces/web/src/lib/api/super_agent.ts

@@ -9,6 +9,9 @@ export interface SuperAgentSendBody {
   // channels/*.md block. "web" = big chat (full tools), "web_sidebar" = quick
   // chat (lightweight). Omitted → daemon defaults to "api".
   channel?: "web" | "web_sidebar";
+  /** Files this turn carries, as paths the daemon stored (POST /media/upload).
+   *  It re-resolves each one inside ~/.apx/media before reading it. */
+  attachments?: { path: string; name?: string }[];
 }
 
 export const SuperAgent = {

package/src/interfaces/web/src/lib/api/tasks.ts

@@ -1,5 +1,12 @@
 import { http, unwrapPage } from "../http";
-import type { TaskEntry, TaskStatus } from "../../types/daemon";
+import type { TaskEntry } from "../../types/daemon";
+import type { BoardColumn } from "../../components/tasks/columns";
+
+/** What a project shows, plus the global vocabulary it may pick from. */
+export interface ProjectColumns {
+  columns: BoardColumn[];
+  catalog: BoardColumn[];
+}
 
 export interface GlobalTaskEntry extends TaskEntry {
   project_id: number;
@@ -12,7 +19,8 @@ export interface TaskSummary {
   dropped: number;
   overdue: number;
   total: number;
-  status: Record<TaskStatus, number>;
+  /** Keyed by whatever columns are in use, not only the four built-ins. */
+  status: Record<string, number>;
 }
 
 export const Tasks = {
@@ -23,23 +31,55 @@ export const Tasks = {
     http.get<unknown>(`/api/tasks?state=${state}`).then((b) => unwrapPage<GlobalTaskEntry>(b).items),
   // Server-paginated variants: one project (listPage) or all projects
   // (globalPage). Each returns the requested window plus the full total.
-  listPage: (pid: string, { state, limit, offset }: { state: TaskEntry["state"] | "all"; limit: number; offset: number }) =>
-    http.get<unknown>(`/api/projects/${pid}/tasks?state=${state}&limit=${limit}&offset=${offset}`).then((b) => unwrapPage<TaskEntry>(b)),
-  globalPage: ({ state, limit, offset, status }: { state: TaskEntry["state"] | "all"; limit: number; offset: number; status?: TaskStatus | "" }) =>
+  listPage: (pid: string, { state, limit, offset, status }: { state: TaskEntry["state"] | "all"; limit: number; offset: number; status?: string }) =>
+    http
+      .get<unknown>(
+        `/api/projects/${pid}/tasks?state=${state}&limit=${limit}&offset=${offset}` + (status ? `&status=${status}` : ""),
+      )
+      .then((b) => unwrapPage<TaskEntry>(b)),
+  globalPage: ({ state, limit, offset, status }: { state: TaskEntry["state"] | "all"; limit: number; offset: number; status?: string }) =>
     http
       .get<unknown>(
         `/api/tasks?state=${state}&limit=${limit}&offset=${offset}` + (status ? `&status=${status}` : ""),
       )
       .then((b) => unwrapPage<GlobalTaskEntry>(b)),
   get:    (pid: string, id: string) => http.get<TaskEntry>(`/api/projects/${pid}/tasks/${id}`),
+  /** Children of one task. `parent: ""` asks for top-level tasks only. */
+  subtasks: (pid: string, parent: string) =>
+    http
+      .get<unknown>(`/api/projects/${pid}/tasks?state=all&parent=${encodeURIComponent(parent)}`)
+      .then((b) => unwrapPage<TaskEntry>(b).items),
+  /**
+   * Add a comment. `summoned` names the agents an @mention pulled in — their
+   * replies land in the thread AFTER this resolves, so the caller re-fetches
+   * rather than waiting (a real QA run takes as long as the QA takes).
+   */
+  comment: (pid: string, id: string, text: string) =>
+    http.post<{ task: TaskEntry; summoned: string[] }>(
+      `/api/projects/${pid}/tasks/${id}/comments`, { text },
+    ),
   add:    (pid: string, body: Partial<TaskEntry>) =>
     http.post<TaskEntry>(`/api/projects/${pid}/tasks`, body),
   patch:  (pid: string, id: string, patch: Partial<TaskEntry>) =>
     http.patch<TaskEntry>(`/api/projects/${pid}/tasks/${id}`, { patch }),
-  status: (pid: string, id: string, status: TaskStatus) =>
+  status: (pid: string, id: string, status: string) =>
     http.post<TaskEntry>(`/api/projects/${pid}/tasks/${id}/status`, { status }),
   done:   (pid: string, id: string) => http.post<TaskEntry>(`/api/projects/${pid}/tasks/${id}/done`),
   drop:   (pid: string, id: string) => http.post<TaskEntry>(`/api/projects/${pid}/tasks/${id}/drop`),
   reopen: (pid: string, id: string) => http.post<TaskEntry>(`/api/projects/${pid}/tasks/${id}/reopen`),
   summary: (pid: string) => http.get<TaskSummary>(`/api/projects/${pid}/tasks-summary`),
+
+  /**
+   * Board columns. The catalog is GLOBAL — renaming "in review" renames it for
+   * every project, which is what keeps a column name meaning one thing. What a
+   * project shows is a subset of it.
+   */
+  columns: {
+    catalog:     () => http.get<{ columns: BoardColumn[] }>(`/api/tasks/columns`),
+    saveCatalog: (columns: BoardColumn[]) =>
+      http.put<{ columns: BoardColumn[] }>(`/api/tasks/columns`, { columns }),
+    forProject:  (pid: string) => http.get<ProjectColumns>(`/api/projects/${pid}/tasks/columns`),
+    saveForProject: (pid: string, ids: string[]) =>
+      http.put<ProjectColumns>(`/api/projects/${pid}/tasks/columns`, { columns: ids }),
+  },
 };

package/src/interfaces/web/src/lib/api/tools.ts

@@ -5,6 +5,8 @@ export interface ToolInfo {
   description?: string;
   category?: string;
   endpoint?: string;
+  /** Part of the safe default set a new agent is created with. */
+  default_for_agents?: boolean;
 }
 
 export const Tools = {

package/src/interfaces/web/src/lib/api/transcribe.ts

@@ -0,0 +1,31 @@
+import { getToken } from "../http";
+import { apiUrl } from "../net";
+
+/**
+ * Words for a voice note.
+ *
+ * A model cannot listen to an audio file — the recording rides along as the
+ * attachment (so the bubble plays it back) and this is the text half of the
+ * same turn, exactly as it works when a voice note arrives over Telegram.
+ * Runs on whatever STT provider the daemon is configured for.
+ */
+export async function transcribeAudio(file: File): Promise<string> {
+  const token = getToken();
+  const ext = (file.name.split(".").pop() || "webm").toLowerCase();
+  // `.weba` is our own spelling for audio-only WebM; the transcriber wants the
+  // container's real name, which ffmpeg knows as "webm".
+  const format = ext === "weba" ? "webm" : ext;
+  const res = await fetch(apiUrl("/api/transcribe/chunk"), {
+    method: "POST",
+    headers: {
+      "content-type": "application/octet-stream",
+      "x-audio-format": format,
+      "x-language": "auto",
+      ...(token ? { authorization: `Bearer ${token}` } : {}),
+    },
+    body: file,
+  });
+  const out = (await res.json().catch(() => ({}))) as { ok?: boolean; text?: string; error?: string };
+  if (!res.ok || out?.ok === false) throw new Error(out?.error || `transcribe ${res.status}`);
+  return String(out?.text || "").trim();
+}

package/src/interfaces/web/src/lib/api/turns.ts

@@ -0,0 +1,20 @@
+import { http } from "../http";
+
+// Stopping a turn that is already running.
+//
+// Closing the NDJSON stream does NOT stop the run — that is deliberate, it is
+// what lets a refresh or a second tab catch up on a turn in progress. So
+// cancelling has to be asked for out loud. Address the turn the way you already
+// address its thread: a project agent by conversation, Roby by channel (its
+// thread IS the channel), a group room by channel + thread_id — one project runs
+// many rooms at once, so the channel alone does not say which one to stop.
+//
+// `aborted: false` is not a failure — the turn may simply have finished a moment
+// before the request landed. A caller interrupting in order to send should carry
+// on and send either way.
+export const Turns = {
+  abort: (
+    pid: string | number,
+    target: { conversation_id?: string; channel?: string; thread_id?: string },
+  ) => http.post<{ ok: boolean; aborted: boolean }>(`/api/projects/${pid}/turns/abort`, target),
+};

package/src/interfaces/web/src/lib/api/voice.ts

@@ -1,4 +1,5 @@
 import { http, getToken } from "../http";
+import { apiUrl } from "../net";
 
 // Voice / TTS / STT client. Talks to the daemon's /voice, /tts and /transcribe
 // surfaces (see src/host/daemon/api/{voice,tts,transcribe}.js + the engine
@@ -103,7 +104,12 @@ export interface CustomTtsConfig {
   base_url: string;     // OpenAI-compatible endpoint (required)
   api_key?: string;
   model?: string;
-  voice?: string;
+  // How the server is asked to speak. Not additive — QVox reads clone, then
+  // voice, then style, and the first one set decides the timbre and accent.
+  language?: string;    // "Spanish" | "English" | … ("auto" = server default)
+  voice?: string;       // a named preset speaker on the server
+  clone?: string;       // path (on the SERVER) to a reference recording
+  ref_text?: string;    // what that recording says — makes cloning faster
   format?: string;
   style?: string;       // base voice / instruct
   temperature?: number;
@@ -111,6 +117,45 @@ export interface CustomTtsConfig {
   enabled?: boolean;
 }
 
+/**
+ * Languages a Qwen3-TTS/QVox endpoint understands, read off the model's own
+ * `codec_language_id` map. Sent verbatim as the `language` field; anything
+ * outside the map is silently ignored by the model, which is exactly how a
+ * Spanish reply ends up with English phonetics.
+ */
+export const QVOX_LANGUAGES = [
+  "Spanish", "English", "Portuguese", "Italian", "French", "German",
+  "Russian", "Chinese", "Japanese", "Korean",
+] as const;
+
+/** GET /tts/voices — the speakers a self-hosted endpoint reports. */
+export type TtsVoicesResponse = {
+  voices: string[];
+  /** Per-voice metadata, when the endpoint publishes any. `native` means the
+   *  voice was recorded in the language the endpoint is currently speaking. */
+  details?: Record<string, { lang?: string; native?: boolean }>;
+  /** The language the endpoint speaks, for engines that serve one at a time. */
+  language?: string;
+  /** That language as an ISO code, to compare against a voice's own. */
+  lang?: string;
+  configured?: boolean;
+  reachable?: boolean;
+};
+
+/**
+ * Label for a voice in a picker: the name, plus the language it was recorded in
+ * when that differs from what the engine speaks. A foreign voice still works —
+ * it is the only way to get a male voice out of a Spanish model whose one native
+ * speaker is female — but it is a choice, and the bare name hides it.
+ */
+export function voiceLabel(name: string, list?: TtsVoicesResponse): string {
+  const lang = list?.details?.[name]?.lang;
+  if (!lang) return name;
+  // "alba · en → es" reads as what it is: an English voice coming out of the
+  // Spanish model. "lola · es" is simply itself.
+  return list?.lang && list.lang !== lang ? `${name} · ${lang} → ${list.lang}` : `${name} · ${lang}`;
+}
+
 export interface VoiceTtsConfig {
   provider?: string;    // "auto" | engine id (single-mode default)
   mode?: TtsMode;       // "chain" | "single"
@@ -178,6 +223,15 @@ export interface SttModelsResponse {
   models: SttModelEntry[];
 }
 
+/** GET /tts/reachable — live probe of the self-hosted voice endpoint. */
+export type TtsReachableResponse = {
+  configured: boolean;      // a self-hosted endpoint is set up at all
+  provider?: string;        // e.g. "custom:qvox"
+  base_url?: string;
+  reachable?: boolean;      // it answered
+  ms?: number;
+};
+
 /** One STT engine entry as reported by GET /transcribe/providers. */
 export interface SttProviderEntry {
   id: string;             // "local" | "openai" | "custom"
@@ -220,7 +274,7 @@ export const TTS_PROVIDER_ORDER: TtsProviderId[] = ["piper", "elevenlabs", "open
  */
 export async function fetchTtsAudioUrl(audioPath: string): Promise<string> {
   const token = getToken();
-  const res = await fetch(`/api/voice/tts?path=${encodeURIComponent(audioPath)}`, {
+  const res = await fetch(apiUrl(`/api/voice/tts?path=${encodeURIComponent(audioPath)}`), {
     headers: token ? { authorization: `Bearer ${token}` } : {},
   });
   if (!res.ok) {
@@ -235,6 +289,22 @@ export const Voice = {
   /** List TTS engines + availability + the configured default provider. */
   providers: () => http.get<TtsProvidersResponse>("/api/tts/providers"),
 
+  /**
+   * Whether the local voice server is answering right now. Separate from
+   * `providers()` on purpose: the `available` flag there is a config probe —
+   * a custom endpoint counts as available for having a base_url — so it never
+   * moves when the server goes down.
+   */
+  reachable: () => http.get<TtsReachableResponse>("/api/tts/reachable"),
+
+  /**
+   * The speakers a custom endpoint offers. Resolved daemon-side from the
+   * STORED base_url, so a provider still being typed into the form answers
+   * with an empty list and the field stays free text.
+   */
+  voices: (provider: string) =>
+    http.get<TtsVoicesResponse>(`/api/tts/voices?provider=${encodeURIComponent(provider)}`),
+
   /** Detected hardware + the recommended local STT backend (Metal/CUDA/CPU). */
   sttHardware: () => http.get<SttHardwareResponse>("/api/transcribe/hardware"),
 

package/src/interfaces/web/src/lib/api.ts

@@ -6,6 +6,7 @@ export * from "./api/health";
 export * from "./api/projects";
 export * from "./api/agents";
 export * from "./api/conversations";
+export * from "./api/groups";
 export * from "./api/routines";
 export * from "./api/tasks";
 export * from "./api/mcps";
@@ -19,6 +20,7 @@ export * from "./api/engines";
 export * from "./api/admin";
 export * from "./api/identity";
 export * from "./api/super_agent";
+export * from "./api/turns";
 export * from "./api/filesystem";
 export * from "./api/voice";
 export * from "./api/deck";
@@ -27,6 +29,7 @@ export * from "./api/artifacts";
 export * from "./api/skills";
 export * from "./api/organization";
 export * from "./api/projectFiles";
+export * from "./api/net";
 
 // Re-export the daemon types so older imports of "../lib/api" still work.
 export type {