agentus 0.0.0-stage → 0.2.0

package/packages/server/src/term.ts

@@ -0,0 +1,201 @@
+// A real (PTY-backed) shell for the workspace panel's Terminal tab.
+//
+// Design notes, since this is the one place the cockpit forks a process that is
+// not an agent:
+//
+//  * **No native dependency, and honest about what that costs.** node-pty is a
+//    build-time native module; this project is deliberately dependency-light, so
+//    the default shell is `$SHELL -i` over ordinary pipes. That runs commands,
+//    streams output, keeps the prompt and `cd` — everything a cockpit panel is
+//    used for — but it is *not* a tty: no job control, no colour, and full-screen
+//    programs (vim, top) will refuse to start. Two ways out, both opt-in:
+//    AGENTUS_TERM_PTY=1 wraps the shell in Python's stdlib `pty.spawn` for a
+//    real terminal, and AGENTUS_TERM_CMD overrides the whole command line.
+//  * **One shell per panel, killed with the socket.** The child lives in the
+//    server's own group and is killed on disconnect, on `term-close`, and in the
+//    process-exit safety net (see installSafetyNet) — an abandoned shell is
+//    exactly the orphan class AC5 exists to prevent.
+//  * **The workspace is the fence.** The shell starts in the slot's workspace,
+//    because that is the directory the operator pointed this slot at. It is not
+//    a sandbox and does not pretend to be: the person running the cockpit already
+//    owns the machine (same trust model as the agent processes).
+import { spawn, type ChildProcess } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+export interface TermSession {
+  id: string;
+  cwd: string;
+  pid: number | null;
+  /** bytes of output kept for a late joiner / a reconnect */
+  buffer: string;
+  child: ChildProcess;
+  subscribers: Set<(chunk: string) => void>;
+  exited: { code: number | null; signal: string | null } | null;
+  /** true when the child has a real tty (see shellCommand). The panel says which it got, because
+   *  a pipe shell and a tty look nothing alike and the operator should not have to guess. */
+  tty: boolean;
+  /** Resize the tty (no-op on a pipe shell). The kernel then SIGWINCHes the child's foreground
+   *  process group, which is what makes a full-screen program redraw at the new width. */
+  resize: (cols: number, rows: number) => void;
+}
+
+const MAX_BUFFER = 256 * 1024;
+
+/** The PTY helper that ships with the server. */
+function ptyHelperPath(): string | null {
+  for (const rel of ["./pty-helper.py", "../src/pty-helper.py"]) {
+    try {
+      const p = fileURLToPath(new URL(rel, import.meta.url));
+      if (fs.existsSync(p)) return p;
+    } catch {
+      /* not this layout */
+    }
+  }
+  return null;
+}
+
+/** How to start the shell.
+ *
+ *  Default is a REAL pty via `pty-helper.py` (python3 stdlib `forkpty`): the shell gets a controlling
+ *  terminal, so prompts, echo, colours, job control and full-screen programs behave. That is the
+ *  whole point of the panel — a terminal emulator in front of a pipe shell is a lie (no prompt lands
+ *  on screen, keystrokes are never echoed, resize means nothing).
+ *
+ *  Escapes: `AGENTUS_TERM_CMD` runs an arbitrary command line instead (pipes), `AGENTUS_TERM_PTY=0`
+ *  forces the old pipe shell, and a machine without python3 degrades to it automatically. Whoever
+ *  gets a pipe shell is told so in the panel rather than being shown a fake terminal. */
+function shellCommand(shell: string): { cmd: string; args: string[]; tty: boolean } {
+  const override = (process.env.AGENTUS_TERM_CMD || "").trim();
+  if (override) {
+    const parts = override.split(/\s+/);
+    return { cmd: parts[0], args: parts.slice(1), tty: false };
+  }
+  if (process.env.AGENTUS_TERM_PTY !== "0") {
+    const helper = ptyHelperPath();
+    if (helper) return { cmd: "python3", args: [helper, shell, "-i"], tty: true };
+  }
+  return { cmd: shell, args: ["-i"], tty: false };
+}
+
+function pickShell(): string {
+  const candidate = process.env.SHELL && fs.existsSync(process.env.SHELL) ? process.env.SHELL : null;
+  if (candidate) return candidate;
+  for (const s of ["/bin/zsh", "/bin/bash", "/bin/sh"]) {
+    if (fs.existsSync(s)) return s;
+  }
+  return "/bin/sh";
+}
+
+export class TermService {
+  #sessions = new Map<string, TermSession>();
+
+  start(cwd: string, size?: { cols: number; rows: number }): TermSession {
+    const shell = pickShell();
+    const { cmd, args, tty } = shellCommand(shell);
+    const cols = Math.max(20, Math.min(size?.cols ?? 80, 1000));
+    const rows = Math.max(5, Math.min(size?.rows ?? 24, 1000));
+    const child = spawn(cmd, args, {
+      cwd: fs.existsSync(cwd) ? cwd : homedir(),
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        PYTHONUNBUFFERED: "1",
+        // Let the shell know a machine is driving, so prompts stay plain.
+        AGENTUS_TERMINAL: "1",
+        // The pty is sized at start because the shell reads its size when it draws the first
+        // prompt — resizing afterwards still works, but a 80x24 flash on every open is not free.
+        AGENTUS_PTY_COLS: String(cols),
+        AGENTUS_PTY_ROWS: String(rows),
+      },
+      // fd 3 is the PTY helper's control channel (resize). A pipe shell has no use for it.
+      stdio: tty ? ["pipe", "pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+      // own process group: the shell (or the pty helper wrapping it) is killed as a group, never
+      // one process at a time (see kill()).
+      detached: true,
+    }) as ChildProcess;
+
+    const ctl = tty ? ((child.stdio[3] ?? null) as NodeJS.WritableStream | null) : null;
+    const session: TermSession = {
+      id: randomUUID(),
+      cwd,
+      pid: child.pid ?? null,
+      buffer: "",
+      child,
+      subscribers: new Set(),
+      exited: null,
+      tty,
+      resize: (c: number, r: number): void => {
+        if (!ctl) return;
+        try {
+          ctl.write(`resize ${Math.max(1, Math.min(c, 1000))} ${Math.max(1, Math.min(r, 1000))}\n`);
+        } catch {
+          /* the helper is gone; the exit event says so */
+        }
+      },
+    };
+    const push = (chunk: string): void => {
+      session.buffer = (session.buffer + chunk).slice(-MAX_BUFFER);
+      for (const fn of session.subscribers) {
+        try {
+          fn(chunk);
+        } catch {
+          /* a dead socket must not break the other listeners */
+        }
+      }
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    // stderr is part of the terminal picture (a missing command prints there). With a pty both
+    // streams are already merged into the pty master, so only stdout carries them — harmless.
+    child.stdout?.on("data", (d: string) => push(d));
+    child.stderr?.on("data", (d: string) => push(d));
+    child.on("exit", (code: number | null, signal: string | null) => {
+      session.exited = { code, signal };
+      push(`\r\n[process exited${code != null ? ` with code ${code}` : ""}${signal ? ` (${signal})` : ""}]\r\n`);
+      this.#sessions.delete(session.id);
+    });
+    child.on("error", (err: Error) => push(`\r\n[cannot start shell: ${err.message}]\r\n`));
+    this.#sessions.set(session.id, session);
+    return session;
+  }
+
+  get(id: string): TermSession | undefined {
+    return this.#sessions.get(id);
+  }
+
+  list(): { id: string; cwd: string; pid: number | null; alive: boolean }[] {
+    return [...this.#sessions.values()].map((s) => ({
+      id: s.id, cwd: s.cwd, pid: s.pid, alive: s.exited === null,
+    }));
+  }
+
+  kill(id: string): boolean {
+    const s = this.#sessions.get(id);
+    if (!s) return false;
+    // The wrapper is `script`; killing the group takes the shell with it.
+    try {
+      if (s.child.pid) process.kill(-s.child.pid, "SIGKILL");
+    } catch {
+      /* no own process group: fall through to the direct kill */
+    }
+    try {
+      s.child.kill("SIGKILL");
+    } catch {
+      /* already gone */
+    }
+    this.#sessions.delete(id);
+    return true;
+  }
+
+  /** Used by the process-exit safety net and on shutdown: no shells outlive us. */
+  killAll(): number {
+    const ids = [...this.#sessions.keys()];
+    for (const id of ids) this.kill(id);
+    return ids.length;
+  }
+}
+
+export const terms = new TermService();

package/packages/server/src/title.ts

@@ -0,0 +1,109 @@
+// Session titles.
+//
+// Two sources, in this order of authority:
+//   1. the AGENT — ACP's own `session_info_update` carries `title` ("Agents send this
+//      notification to update session information like title… This allows clients to
+//      display dynamic session names"). Zero cost, no model call in our layer, and it is
+//      the only source that can be right about a conversation we never parse. If an agent
+//      ever uses it, it wins.
+//   2. US — a deterministic derivation, so a new session stops being "Hermes @ tmp" the
+//      moment the operator asks something. hermes-studio/AionUi lineage (AionUi's
+//      `buildAutoTitleFromContent`): first non-empty line of the first user prompt, markdown
+//      furniture stripped, ≤50 chars. No model, instant, works offline.
+//
+// The operator's own rename always outranks both (the store keeps `title` = what is
+// displayed and `auto_title` = the generated name, so a rename is reversible and a
+// generated name never stomps a hand-written one).
+import type { StoredMessage } from "../../shared/src/index.js";
+
+/** Hard cap for a single-line row, in characters (AionUi uses 50). */
+export const TITLE_MAX = 50;
+
+/**
+ * Deterministic title from one blob of text (AionUi's rules, reimplemented):
+ * drop thinking blocks, take the first line that carries words, strip the markdown
+ * furniture that would otherwise lead (`#`, `>`, `-`, `1.`), collapse runs of spaces,
+ * and cap the length. Returns null when nothing usable is left.
+ */
+export function deriveTitle(raw: string | null | undefined): string | null {
+  if (!raw) return null;
+  const withoutThink = raw
+    .replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/gi, " ")
+    .replace(/<think(?:ing)?>[\s\S]*$/i, " ");
+  const lines = withoutThink
+    .replace(/\r/g, "")
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l && l !== "```" && !/^```/.test(l));
+  const first = lines[0] ?? "";
+  const normalized = first
+    .replace(/^[#>*\-\d.\s]+/u, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, TITLE_MAX)
+    .trim();
+  return normalized || null;
+}
+
+/** Title from the FIRST user prompt we stored for a session (the AionUi trigger point). */
+export function titleFromFirstPrompt(msgs: StoredMessage[]): string | null {
+  for (const m of msgs) {
+    if (m.kind !== "user") continue;
+    const t = deriveTitle(userText(m));
+    if (t) return t;
+  }
+  return null;
+}
+
+/** Title from the LATEST user prompt — the cheap reading of "regenerate from the context":
+ *  what the operator is working on NOW, rather than what they said first. */
+export function titleFromLatestPrompt(msgs: StoredMessage[]): string | null {
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    const m = msgs[i];
+    if (m.kind !== "user") continue;
+    const t = deriveTitle(userText(m));
+    if (t) return t;
+  }
+  return null;
+}
+
+/** user rows store `{ text }`; accept a `{content:{text}}` shape too so this keeps working
+ *  whichever way the ingest writes them (export.ts learned that lesson already). */
+function userText(m: StoredMessage): string {
+  const p = (m.payload ?? {}) as {
+    text?: unknown;
+    content?: { text?: unknown } | null;
+  };
+  if (typeof p.text === "string") return p.text;
+  if (p.content && typeof p.content.text === "string") return p.content.text;
+  return "";
+}
+
+/**
+ * The prompt for the agent-driven path. Short on purpose: the answer is one line we paste
+ * into a row, and every extra word is an extra second of latency.
+ */
+export const TITLE_INSTRUCTION =
+  "请为这段对话生成一个会话标题：不超过 12 个字或 6 个英文单词，直接输出标题本身，" +
+  "不要引号、不要句号、不要任何解释或前缀。";
+
+/** Clean whatever the agent answered into a single-line title. Models like to answer with
+ *  quotes, a bullet, "标题：" or a whole sentence; none of that belongs in a rail row. */
+export function cleanAgentTitle(raw: string | null | undefined): string | null {
+  if (!raw) return null;
+  let t = raw.replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/gi, " ");
+  const line = t
+    .replace(/\r/g, "")
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean)
+    .find((l) => !/^```/.test(l)) ?? "";
+  t = line
+    .replace(/^[#>*\-\d.、\s]+/u, "")
+    .replace(/^(会话标题|标题|title)\s*[:：]\s*/i, "")
+    .replace(/^["'“”‘’《【\[]+|["'“”‘’》】\]]+$/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!t) return null;
+  return t.slice(0, TITLE_MAX).trim() || null;
+}

package/packages/server/src/voice.ts

@@ -0,0 +1,251 @@
+// Voice: speech-to-text and text-to-speech.
+//
+// Two layers (unchanged from the first voice pass): the browser can do both directions
+// with zero configuration, and the server adds a provider when the operator configures
+// one. What changed is where the configuration lives: the settings page (settings.ts)
+// owns provider / base URL / key / models / voice / hotwords; env remains a bootstrap.
+//
+// This module is a ROUTER over providers:
+//   "dashscope"  阿里百炼 (dashscope.ts): streaming ASR over its inference WebSocket,
+//                 batch ASR over the OpenAI-compatible chat route, TTS via
+//                 SpeechSynthesizer; fixed + dynamic hotwords ride along.
+//   "openai"     any OpenAI-compatible /audio/speech + /audio/transcriptions endpoint
+//                 (the AGENTUS_TTS_* / AGENTUS_STT_* bootstrap path).
+//   "browser"    no server path (the UI uses speechSynthesis / SpeechRecognition).
+//
+// The server still synthesises or recognises nothing itself: every call forwards to an
+// endpoint the operator owns. That keeps the project's "the UI holds no intelligence"
+// line intact (a voice endpoint is I/O, like the file panel, not an agent).
+import { getSettings, dashscopeUrls } from "./settings.js";
+import { dashscopeAsr, dashscopeTts, DashscopeError } from "./dashscope.js";
+
+export interface VoiceConfig {
+  tts: { baseUrl: string; key: string; model: string; voice: string } | null;
+  stt: { baseUrl: string; key: string; model: string; language: string } | null;
+}
+
+const trimmed = (v: string | undefined): string => String(v ?? "").trim().replace(/\/+$/, "");
+
+/** Env bootstrap for the OpenAI-compatible provider (unchanged semantics: what the
+ *  fake-endpoint tests and openai users hit; the settings page overrides it). */
+export function voiceConfig(env: NodeJS.ProcessEnv = process.env): VoiceConfig {
+  const ttsBase = trimmed(env.AGENTUS_TTS_BASE_URL);
+  const sttBase = trimmed(env.AGENTUS_STT_BASE_URL);
+  return {
+    tts: ttsBase
+      ? {
+          baseUrl: ttsBase,
+          key: String(env.AGENTUS_TTS_API_KEY ?? env.OPENAI_API_KEY ?? ""),
+          model: String(env.AGENTUS_TTS_MODEL || "tts-1"),
+          voice: String(env.AGENTUS_TTS_VOICE || "alloy"),
+        }
+      : null,
+    stt: sttBase
+      ? {
+          baseUrl: sttBase,
+          key: String(env.AGENTUS_STT_API_KEY ?? env.OPENAI_API_KEY ?? ""),
+          model: String(env.AGENTUS_STT_MODEL || "whisper-1"),
+          language: String(env.AGENTUS_STT_LANGUAGE || ""),
+        }
+      : null,
+  };
+}
+
+export type VoiceProvider = "dashscope" | "openai" | "browser";
+
+/** Which provider would answer right now. The settings page wins over env; "dashscope"
+ *  selected but incomplete resolves to "browser" (the UI must not be promised a server
+ *  path that will 501). */
+export function resolveVoice(env: NodeJS.ProcessEnv = process.env): {
+  provider: VoiceProvider;
+  tts: boolean;
+  stt: boolean;
+  openai: VoiceConfig;
+} {
+  const v = getSettings().voice;
+  const openai = voiceConfig(env);
+  if (v.provider === "dashscope") {
+    const ready = Boolean(v.baseUrl && v.apiKey);
+    return { provider: ready ? "dashscope" : "browser", tts: ready, stt: ready, openai };
+  }
+  if (v.provider === "openai") {
+    const has = Boolean(v.baseUrl && v.apiKey);
+    return {
+      provider: has || openai.tts || openai.stt ? "openai" : "browser",
+      tts: has || Boolean(openai.tts),
+      stt: has || Boolean(openai.stt),
+      openai,
+    };
+  }
+  // provider "browser": env bootstrap still counts (a test server or an operator who
+  // prefers env over the page)
+  return { provider: "browser", tts: Boolean(openai.tts), stt: Boolean(openai.stt), openai };
+}
+
+/** What the browser asks before it decides who speaks. */
+export function voiceCapabilities(): Record<string, unknown> {
+  const v = getSettings().voice;
+  const r = resolveVoice();
+  return {
+    provider: r.provider,
+    tts: {
+      server: r.tts,
+      model: r.provider === "dashscope" ? v.ttsModel : (r.openai.tts?.model ?? null),
+      voice: r.provider === "dashscope" ? v.ttsVoice : (r.openai.tts?.voice ?? null),
+    },
+    stt: {
+      server: r.stt,
+      streaming: r.provider === "dashscope" && v.asrStream,
+      model: r.provider === "dashscope" ? v.asrModel : null,
+      batchModel: r.provider === "dashscope" ? v.asrBatchModel : (r.openai.stt?.model ?? null),
+      language: r.openai.stt?.language || null,
+    },
+    hotwords: { fixed: v.hotwords.length, dynamic: v.dynamicHotwords, limit: v.hotwordLimit },
+  };
+}
+
+export class VoiceError extends Error {
+  constructor(message: string, readonly code: "not_configured" | "upstream" | "timeout") {
+    super(message);
+  }
+}
+
+const TIMEOUT_MS = 60_000;
+
+async function withTimeout<T>(label: string, run: (signal: AbortSignal) => Promise<T>): Promise<T> {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), TIMEOUT_MS);
+  try {
+    return await run(ac.signal);
+  } catch (e) {
+    if ((e as Error).name === "AbortError") throw new VoiceError(`${label} timed out after ${TIMEOUT_MS / 1000}s`, "timeout");
+    if (e instanceof VoiceError || e instanceof DashscopeError) throw e;
+    // DNS/connection failure: the operator's endpoint is the problem, not this process —
+    // report it as an upstream error so the UI says what actually happened.
+    throw new VoiceError(`${label}: cannot reach the voice endpoint (${String((e as Error)?.message ?? e)})`, "upstream");
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function wrapDashscope(e: unknown): VoiceError {
+  if (e instanceof DashscopeError) {
+    return new VoiceError(e.message, e.code === "timeout" ? "timeout" : e.code === "not_configured" ? "not_configured" : "upstream");
+  }
+  return new VoiceError(String((e as Error)?.message ?? e), "upstream");
+}
+
+/** Text -> audio bytes, routed. The browser only ever sees bytes: the key and the
+ *  provider's signed result URL stay server-side. */
+export async function synthesize(text: string, opts: { voice?: string; speed?: number } = {}): Promise<{
+  contentType: string;
+  audio: Buffer;
+}> {
+  const v = getSettings().voice;
+  const r = resolveVoice();
+  if (r.provider === "dashscope") return dashscopeTts(text, opts).catch((e) => { throw wrapDashscope(e); });
+  // openai-compatible: settings endpoint+key when complete, else the env bootstrap
+  const fromSettings = v.baseUrl && v.apiKey ? { baseUrl: trimmed(v.baseUrl), key: v.apiKey, model: v.ttsModel || "tts-1", voice: v.ttsVoice } : null;
+  const cfg = fromSettings ?? r.openai.tts;
+  if (!cfg) throw new VoiceError("server TTS is not configured (settings page, or AGENTUS_TTS_BASE_URL)", "not_configured");
+  const res = await withTimeout("tts", (signal) => fetch(`${cfg.baseUrl}/audio/speech`, {
+    method: "POST",
+    signal,
+    headers: { "content-type": "application/json", ...(cfg.key ? { authorization: `Bearer ${cfg.key}` } : {}) },
+    body: JSON.stringify({
+      model: cfg.model,
+      voice: opts.voice || cfg.voice || "alloy",
+      input: text,
+      ...(opts.speed && opts.speed !== 1 ? { speed: opts.speed } : {}),
+    }),
+  }));
+  if (!res.ok) throw new VoiceError(`tts upstream ${res.status}: ${(await res.text().catch(() => "")).slice(0, 400)}`, "upstream");
+  return { contentType: res.headers.get("content-type") ?? "audio/mpeg", audio: Buffer.from(await res.arrayBuffer()) };
+}
+
+/** Audio bytes -> transcript, routed. `sessionId` lets the provider pull context hotwords
+ *  from the transcript it already has (dynamic hotwords). */
+export async function transcribe(
+  audio: Buffer,
+  mime: string,
+  opts: { filename?: string; language?: string; sessionId?: string; contextWords?: string[] } = {},
+): Promise<string> {
+  const v = getSettings().voice;
+  const r = resolveVoice();
+  if (r.provider === "dashscope") {
+    return dashscopeAsr(audio, mime, { contextWords: opts.contextWords ?? hotwordsForRequest(opts.sessionId) })
+      .catch((e) => { throw wrapDashscope(e); });
+  }
+  const fromSettings = v.baseUrl && v.apiKey ? { baseUrl: trimmed(v.baseUrl), key: v.apiKey, model: v.asrBatchModel, language: "" } : null;
+  const cfg = fromSettings ?? r.openai.stt;
+  if (!cfg) throw new VoiceError("server STT is not configured (settings page, or AGENTUS_STT_BASE_URL)", "not_configured");
+  const form = new FormData();
+  const name = opts.filename || `dictation.${mimeToExt(mime)}`;
+  form.append("file", new Blob([new Uint8Array(audio)], { type: mime || "audio/webm" }), name);
+  form.append("model", cfg.model);
+  if (opts.language || cfg.language) form.append("language", opts.language || cfg.language);
+  const res = await withTimeout("stt", (signal) => fetch(`${cfg.baseUrl}/audio/transcriptions`, {
+    method: "POST",
+    signal,
+    headers: cfg.key ? { authorization: `Bearer ${cfg.key}` } : undefined,
+    body: form,
+  }));
+  if (!res.ok) throw new VoiceError(`stt upstream ${res.status}: ${(await res.text().catch(() => "")).slice(0, 400)}`, "upstream");
+  const data = (await res.json()) as { text?: string };
+  return String(data?.text ?? "").trim();
+}
+
+/** Hotword extraction needs the store, which lives outside this module: injected at
+ *  boot (index.ts) so voice.ts stays free of database imports. */
+type HotwordFn = (sessionId?: string) => string[];
+let hotwordsForRequest: HotwordFn = () => [];
+export function setHotwordSource(fn: HotwordFn): void {
+  hotwordsForRequest = fn;
+}
+
+/** The model ids the configured endpoint serves, split into the two lists the settings
+ *  page offers. The operator named two defaults but asked for "其它的也可选", and every
+ *  Bailian tenant advertises a different set — so we ask the endpoint instead of
+ *  hard-coding a catalogue. */
+export async function listVoiceModels(): Promise<{ total: number; asr: string[]; tts: string[] }> {
+  const v = getSettings().voice;
+  const r = resolveVoice();
+  let url = "";
+  let key = "";
+  if (r.provider === "dashscope") {
+    const { compat } = dashscopeUrls(v.baseUrl);
+    url = `${compat}/models`;
+    key = v.apiKey;
+  } else {
+    // the settings page's endpoint first: resolveVoice() falls back to the env bootstrap,
+    // so an operator who typed an endpoint must not be told "not configured" (the page's
+    // "重新读取" button would be a lie).
+    const base = trimmed(v.baseUrl) || r.openai.tts?.baseUrl || r.openai.stt?.baseUrl || "";
+    if (!base) throw new VoiceError("no voice endpoint configured", "not_configured");
+    key = (v.baseUrl && v.apiKey ? v.apiKey : "") || r.openai.tts?.key || r.openai.stt?.key || "";
+    url = `${base}/models`;
+  }
+  const res = await withTimeout("models", (signal) => fetch(url, {
+    signal,
+    headers: key ? { authorization: `Bearer ${key}` } : undefined,
+  }));
+  if (!res.ok) throw new VoiceError(`models upstream ${res.status}: ${(await res.text().catch(() => "")).slice(0, 300)}`, "upstream");
+  const data = (await res.json()) as { data?: { id?: string }[]; models?: { name?: string }[] };
+  const ids = (data.data ?? []).map((m) => String(m.id ?? "")).filter(Boolean);
+  for (const m of data.models ?? []) if (m.name) ids.push(String(m.name));
+  const asr = ids.filter((id) => /asr|speech-recog|recognition|paraformer|sensevoice/i.test(id));
+  const tts = ids.filter((id) => /tts|speech-synth|cosyvoice|sambert/i.test(id));
+  return { total: ids.length, asr, tts };
+}
+
+function mimeToExt(mime: string): string {
+  const m = mime.toLowerCase();
+  if (m.includes("webm")) return "webm";
+  if (m.includes("ogg")) return "ogg";
+  if (m.includes("wav")) return "wav";
+  if (m.includes("mp4") || m.includes("m4a") || m.includes("aac")) return "m4a";
+  if (m.includes("mpeg") || m.includes("mp3")) return "mp3";
+  if (m.includes("flac")) return "flac";
+  if (m.includes("pcm")) return "pcm";
+  return "webm";
+}

package/packages/shared/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@agentus/shared",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  }
+}