@audiofool/moondog 0.3.0-beta.6 → 0.3.0-beta.8

package/src/runtime/pi/reply-language.mjs

@@ -0,0 +1,45 @@
+// The host chooses the language of each reply (src/i18n messageLocale), and the model is told
+// it. Some models still drift, for example into Chinese on a Spanish request. A reply clearly in
+// another language is restated once by the same model, without tools, in the chosen language.
+import { clampThinkingLevel } from "@earendil-works/pi-ai";
+import { LOCALES, messageLocale } from "../../i18n/index.mjs";
+
+const CJK_LOCALES = new Set(["zh", "zh-Hant", "ja", "ko"]);
+const sameFamily = (left, right) => left === right || (left.startsWith("zh") && right.startsWith("zh"));
+
+/** Whether a reply is clearly in another language than the one chosen for it. */
+export function replyInOtherLanguage(text, locale) {
+  if (typeof text !== "string" || !text.trim() || !LOCALES[locale]) return false;
+  // Quoted and bracketed names travel across languages; in a Latin-script reply, so do Chinese
+  // characters (song, album and artist names).
+  const prose = text.replace(/"(?:[^"\\]|\\.)*"|“[^”]*”|«[^»]*»|「[^」]*」|『[^』]*』|《[^》]*》|\*\*[^*]*\*\*/gu, " ");
+  // A Chinese character stands for about one word. Fewer of them than Latin words are names;
+  // more of them are the reply itself.
+  const han = prose.match(/\p{Script=Han}/gu)?.length ?? 0;
+  const latin = prose.match(/\p{Script=Latin}+/gu)?.length ?? 0;
+  const names = !CJK_LOCALES.has(locale) && latin > han;
+  // The reply's own language; words that name a language ("I'll answer in Spanish") are not a request here.
+  const read = messageLocale(names ? prose.replace(/\p{Script=Han}+/gu, " ") : prose, locale, { explicit: false });
+  return !sameFamily(read, locale);
+}
+
+const SYSTEM_PROMPT = "You restate a music assistant's reply in another language. Keep its meaning, facts, tone, line breaks and Markdown. Keep names of songs, albums, artists and devices exactly as written. Return only the restated reply.";
+
+/** The reply restated in the chosen language, or null when it needs none or the call fails. */
+export async function restateInLanguage({ models, model, text, locale, signal, maxTokens = 2_000 }) {
+  if (!replyInOtherLanguage(text, locale) || typeof models?.completeSimple !== "function" || !model) return null;
+  const lightest = clampThinkingLevel(model, "off");
+  try {
+    const message = await models.completeSimple(model, {
+      systemPrompt: SYSTEM_PROMPT,
+      messages: [{ role: "user", content: `Restate this reply in ${LOCALES[locale].name} (${locale}).\n\n${text}`, timestamp: Date.now() }],
+    }, { maxTokens, maxRetries: 0, signal, ...(lightest !== "off" ? { reasoning: lightest } : {}) });
+    // Only a restatement that ended on its own replaces the reply; one cut at the token limit would lose its end.
+    if (!message || message.stopReason !== "stop") return null;
+    const restated = (message.content ?? []).filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+    // A restatement still in the wrong language is no better than the reply it replaces.
+    return restated && !replyInOtherLanguage(restated, locale) ? restated : null;
+  } catch {
+    return null;
+  }
+}

package/src/runtime/pi/tool-arguments.mjs

@@ -0,0 +1,89 @@
+// Weaker models often get a tool call almost right: "play" for "resume", one song where a list is
+// asked for, an empty field, an extra key the tool does not take. The host repairs only mistakes
+// with one clear reading, before Pi validates the call, so the call runs as the model meant it.
+// Anything else is left as it was, and Pi's validation error names the model's own arguments.
+import { validateToolArguments } from "@earendil-works/pi-ai";
+
+const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+function passes(tool, args) {
+  try {
+    validateToolArguments(tool, { name: tool.name, arguments: args });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// A key that is no identifier ("/invoke", "invoke name=\"…\"") is a model's own tool-call markup
+// leaking into the arguments. No tool takes such a key, so it carries no meaning to refuse.
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+
+function withoutEmpty(args) {
+  return Object.fromEntries(Object.entries(args).filter(([key, value]) => IDENTIFIER.test(key) &&
+    value !== null && value !== undefined && !(typeof value === "string" && !value.trim())));
+}
+
+const PLAYER_ACTIONS = new Map([
+  ["play", "resume"], ["start", "resume"], ["continue", "resume"], ["unpause", "resume"], ["playback", "resume"],
+  ["stop", "pause"], ["skip", "next"], ["forward", "next"], ["next_track", "next"],
+  ["back", "previous"], ["prev", "previous"], ["previous_track", "previous"],
+  ["set_volume", "volume"], ["set_shuffle", "shuffle"], ["set_repeat", "repeat"],
+]);
+const PLAYER_SOURCES = ["item_ref_id", "uri", "context_uri", "context_ref_id", "track_refs", "songs", "pending_plan"];
+
+const repairs = {
+  moondog_spotify_player_control(args) {
+    const result = { ...args };
+    if (typeof result.action === "string") {
+      const action = result.action.trim().toLowerCase().replace(/[\s-]+/gu, "_");
+      result.action = PLAYER_ACTIONS.get(action) ?? action;
+    }
+    // One song, or a song given at the top level, is the list of one the tool takes.
+    if (result.songs === undefined && (result.song !== undefined || (typeof result.title === "string" && typeof result.artist === "string"))) {
+      result.songs = result.song ?? { title: result.title, artist: result.artist };
+      delete result.song;
+      delete result.title;
+      delete result.artist;
+    }
+    // A song keeps every field it came with: an extra one ("version": "Live") may be a constraint
+    // the tool cannot honor, and validation must refuse it rather than play another recording.
+    if (isPlainObject(result.songs)) result.songs = [result.songs];
+    if (typeof result.track_refs === "string") result.track_refs = [result.track_refs];
+    // A search's type copied into the play call says nothing the player needs.
+    delete result.type;
+    if (result.action === "volume" && result.percent === undefined && result.volume !== undefined) {
+      result.percent = result.volume;
+      delete result.volume;
+    }
+    if (result.action === undefined && PLAYER_SOURCES.some((key) => result[key] !== undefined)) result.action = "resume";
+    // Only resume plays a source; another action with one leaves the source out.
+    if (result.action && result.action !== "resume") for (const key of PLAYER_SOURCES) delete result[key];
+    return result;
+  },
+  moondog_spotify_search(args) {
+    const types = new Map([["song", "track"], ["songs", "track"], ["tracks", "track"], ["albums", "album"], ["artists", "artist"], ["playlists", "playlist"]]);
+    if (typeof args.type !== "string") return args;
+    const type = args.type.trim().toLowerCase();
+    return { ...args, type: types.get(type) ?? type };
+  },
+};
+
+/** The arguments to validate: the model's own when they pass, or a repair that passes. */
+export function repairToolArguments(tool, args) {
+  let parsed = args;
+  if (typeof parsed === "string") {
+    try { parsed = JSON.parse(parsed); } catch { return args; }
+  }
+  if (!isPlainObject(parsed) || passes(tool, parsed)) return parsed;
+  // An unknown key is never dropped in general: it can carry meaning the tool must refuse, such
+  // as a subject the model may not choose. Only a tool's own repair removes a key it knows is noise.
+  let repaired = withoutEmpty(parsed);
+  repaired = repairs[tool.name]?.(repaired) ?? repaired;
+  return passes(tool, repaired) ? repaired : args;
+}
+
+/** The tool with its repair step; Pi runs prepareArguments before it validates a call. */
+export function withArgumentRepair(tool) {
+  return { ...tool, prepareArguments: (args) => repairToolArguments(tool, args) };
+}

package/src/surfaces/cli/tui.mjs

@@ -125,6 +125,7 @@ const slashCommands = [
   { name: "endpoint", description: N_("Add a model service by its address") },
   { name: "web", description: N_("Look things up on public music sites") },
   { name: "service", description: N_("Choose where Moondog plays music") },
+  { name: "library", description: N_("Your saved songs and playlists") },
   { name: "generation", description: N_("Let Moondog make music on this Mac") },
   { name: "onair", description: N_("Go on air: Moondog keeps making music from your taste") },
   { name: "spotify", description: N_("Connect and control Spotify") },
@@ -250,7 +251,8 @@ export async function runMoondogTui({
   // /onair needs both: the room's own player and music making here.
   const onAirControls = previewControls && typeof generation?.save === "function";
   const commands = slashCommands.filter(({ name }) => (previewControls || !["skip", "stop"].includes(name)) &&
-    (name !== "generation" || typeof generation?.save === "function") && (name !== "onair" || onAirControls));
+    (name !== "generation" || typeof generation?.save === "function") && (name !== "onair" || onAirControls) &&
+    (name !== "library" || application.libraryReady?.() === true));
   const localizedCommands = commands.map(({ name, description }) => ({ name, get description() { return tr.marked(description); } }));
   let activeRuntime = runtime;
   application.startNewSession?.("tui_start");
@@ -317,6 +319,7 @@ export async function runMoondogTui({
   let busy = false;
   // A model chosen or a sign-in made in the window while a turn ran here; it applies once the turn ends.
   let modelChangedElsewhere = false;
+  let modelAskedFor = null;
   // A reply another Moondog window or terminal is writing in this conversation: { id, response, text }.
   let elsewhere = null;
   let watchTimer = null;
@@ -642,6 +645,7 @@ export async function runMoondogTui({
     }
     if (!cleanedUp) tui.requestRender();
     if (!value && modelChangedElsewhere) void followModel();
+    if (!value && modelAskedFor) void applyModelAskedFor();
   };
   const setFooter = (text, color = dim) => {
     if (cleanedUp) return;
@@ -1035,6 +1039,59 @@ export async function runMoondogTui({
     generationFooter(status);
   };
 
+  // /library lists Saved and the listener's folders and playlists, plays one by name, or keeps the song
+  // playing now, in Saved or in a playlist by name (made when there is none). The window shares this library.
+  const manageLibrary = async (args) => {
+    if (!application.libraryReady?.()) throw new Error(tr("The library isn't available here."));
+    const [action, ...rest] = args;
+    const words = rest.join(" ").trim();
+    const nameOf = (playlist) => (playlist.saved ? tr("Saved") : playlist.name);
+    if (!action) {
+      const { folders, playlists } = application.libraryView();
+      const count = (playlist) => tr.n(playlist.count, "{count} song", "{count} songs");
+      const lines = [];
+      const saved = playlists.find((playlist) => playlist.saved);
+      if (saved) lines.push(`- **${nameOf(saved)}** · ${count(saved)}`);
+      const walk = (parentId, depth) => {
+        const nodes = [...folders.filter((folder) => folder.parentId === parentId).map((node) => ["folder", node]),
+          ...playlists.filter((playlist) => !playlist.saved && playlist.folderId === parentId).map((node) => ["playlist", node])]
+          .sort((a, b) => a[1].position - b[1].position);
+        for (const [kind, node] of nodes) {
+          const indent = "  ".repeat(depth);
+          if (kind === "folder") { lines.push(`${indent}- ${node.name}/`); walk(node.id, depth + 1); }
+          else lines.push(`${indent}- **${node.name}** · ${count(node)}`);
+        }
+      };
+      walk(null, 0);
+      addMoondogMessage(`${lines.join("\n")}\n\n${tr("Play one with `/library play <name>`, or keep the song playing now with `/library save`.")}`);
+      return;
+    }
+    if (action === "play") {
+      const [playlist] = application.findLibraryPlaylists(words);
+      if (!playlist || !words) throw new Error(tr("No playlist is called “{name}”.", { name: words }));
+      const played = await application.playLibrary({ playlistId: playlist.id });
+      if (played.state !== "playing") {
+        addMoondogMessage(played.state === "empty" ? tr("{name} has nothing in it yet.", { name: nameOf(playlist) }) : tr("None of its songs could be found."));
+        return;
+      }
+      addMoondogMessage([tr("Playing {name}.", { name: nameOf(playlist) }),
+        played.left_out_made ? tr("Moondog's tracks were left out. They play with Apple Music chosen.") : "",
+        played.not_found ? tr("Some songs couldn't be found.") : ""].filter(Boolean).join(" "));
+      setFooter(tr("Playing {name}.", { name: nameOf(playlist) }), success);
+      return;
+    }
+    if (action === "save") {
+      const target = words ? application.findLibraryPlaylists(words).find((playlist) => playlist.name.toLocaleLowerCase() === words.toLocaleLowerCase() || (playlist.saved && /^saved$/iu.test(words))) : null;
+      const saved = await application.saveToLibrary({ from: "now_playing", ...(target ? { playlistId: target.id } : words ? { playlistName: words } : {}) });
+      const where = saved.playlist.saved ? tr("Saved") : saved.playlist.name;
+      const text = !saved.added ? tr("Already in {name}.", { name: where }) : saved.playlist.saved ? tr("Saved.") : tr("Saved to {name}.", { name: where });
+      addMoondogMessage(text);
+      setFooter(text, success);
+      return;
+    }
+    throw new Error(tr("Use /library, /library play <name>, or /library save [playlist]."));
+  };
+
   const removeLifecycleListeners = () => {
     signalTarget.removeListener("SIGTERM", handleSigterm);
     signalTarget.removeListener("SIGHUP", handleSighup);
@@ -1050,6 +1107,7 @@ export async function runMoondogTui({
     cleanedUp = true;
     clearTimeout(watchTimer);
     stopWatchingModel?.();
+    stopModelSwitch?.();
     stopWatchingFirstRun?.();
     stopWatchingPreviews?.();
     stopWatchingStream?.();
@@ -1332,6 +1390,27 @@ export async function runMoondogTui({
     void refreshFirstRun();
     return nextStatus;
   };
+  // A model the listener asked the agent for in words, switched to as /model does once the reply ends.
+  // The terminal stays busy while it switches, so a message queued during the reply waits for the new model.
+  const applyModelAskedFor = async () => {
+    const selection = modelAskedFor;
+    modelAskedFor = null;
+    if (!selection || cleanedUp || busy) { modelAskedFor ??= selection; return; }
+    setBusy(true);
+    let status = null;
+    try {
+      status = await replaceRuntime(runtimeSelection(selection.provider, selection.model, selection.effort ?? runtimeStatus.effort)).catch(() => null);
+    } finally {
+      setBusy(false);
+    }
+    if (status?.state === "configured") setFooter(tr("Model ready."), success);
+    settleQueue();
+  };
+  const stopModelSwitch = application.modelSwitch?.subscribe?.(({ application: from, selection }) => {
+    if (from !== application) return;
+    modelAskedFor = selection;
+    if (!busy) void applyModelAskedFor();
+  });
   // The window saved another model, or a sign-in that lets this side answer. The terminal's own
   // choices rebuild at once, so their saves find this agent already on them.
   const followModel = async () => {
@@ -2414,6 +2493,8 @@ export async function runMoondogTui({
       application.locale = locale;
       // A chosen language also becomes the conversation's, so the next short reply follows it.
       application.conversationLocale = locale;
+      // A language chosen here ends one the listener asked the agent to keep.
+      application.replyLanguagePin = null;
       await saveLanguage?.(locale);
       const pinned = normalizeLocale(environment.MOONDOG_LANGUAGE);
       transcript.invalidate();
@@ -2473,6 +2554,10 @@ export async function runMoondogTui({
       await manageGeneration(args);
       return;
     }
+    if (command === "library") {
+      await manageLibrary(args);
+      return;
+    }
     if (command === "spotify") {
       await runSpotifyCommand(args);
       return;