@audiofool/moondog 0.3.0-beta.1 → 0.3.0-beta.11

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/command-completions.mjs

@@ -24,6 +24,14 @@ const serviceChoices = choices([
   ["apple_music", N_("30-second previews, played here")],
   ["netease", N_("Whole songs through ncm-cli")],
 ]);
+const generationChoices = choices([["on", N_("Make music on this Mac with Stable Audio 3")], ["off", N_("Stop making music here")]]);
+const generationSetupChoices = choices([
+  ["download", N_("Download a Stable Audio 3 model from Stability AI")],
+  ["use", N_("Make music with a downloaded model")],
+  ["remove", N_("Delete a downloaded model from this Mac")],
+  ["cancel", N_("Stop the download")],
+]);
+const sa3ModelChoices = choices([["medium", N_("Medium: best sound, about 5.2 GB")], ["small", N_("Small Music: faster, lighter, about 1.7 GB")]]);
 const webChoices = choices([
   ["search", N_("Search public music sites")],
   ["read", N_("Read a public page")],
@@ -78,6 +86,7 @@ export function withCommandCompletions(commands, {
   providers = () => [],
   models = () => [],
   authProviderIds = [],
+  generationSetup = false,
   tr,
 } = {}) {
   if (tr) translate = tr;
@@ -93,7 +102,12 @@ export function withCommandCompletions(commands, {
     art: { argumentHint: "[braille|ascii|off|auto]", choices: firstArgument(artChoices) },
     motion: { argumentHint: "[on|off]", choices: firstArgument(motionChoices) },
     service: { argumentHint: "[spotify|apple_music|netease]", choices: firstArgument(serviceChoices) },
-    generation: { argumentHint: "[on [folder]|off]", choices: firstArgument(choices([["on", N_("Make music on this Mac with Stable Audio 3")], ["off", N_("Stop making music here")]])) },
+    // With the core's setup, /generation also downloads, uses and removes Moondog's own models.
+    generation: generationSetup ? {
+      argumentHint: "[on [folder]|off|download|use|remove|cancel]",
+      choices: (previous) => previous.length === 0 ? [...generationChoices, ...generationSetupChoices]
+        : previous.length === 1 && ["download", "use", "remove"].includes(previous[0]) ? sa3ModelChoices : [],
+    } : { argumentHint: "[on [folder]|off]", choices: firstArgument(generationChoices) },
     lyrics: { argumentHint: "[sync]", choices: firstArgument(choices([["sync", N_("Check profile songs for lyrics")]])) },
     web: { argumentHint: "search <query> | read <url> | status", choices: firstArgument(webChoices) },
     spotify: {

package/src/surfaces/cli/model-roles-command.mjs

@@ -0,0 +1,60 @@
+import { MODEL_ROLES, WEB_SERVICES } from "../../runtime/pi/model-roles.mjs";
+
+// /model roles, /model vision and /model web: the terminal's side of Settings' Auxiliary models.
+// The chat model stays /model <provider> <model>.
+export const MODEL_ROLE_WORDS = Object.freeze({ roles: null, vision: "vision", web: "web_search", audio: "audio" });
+
+const titles = { chat: "Chat", vision: "Vision", web_search: "Web search", audio: "Audio" };
+const usage = "Usage: /model roles, /model vision auto|<provider> <model>, or /model web auto|deepseek|brave|codex.";
+
+const modelName = (choice) => `${choice.name ?? choice.model} (${choice.providerName ?? choice.provider})`;
+
+function describe(role) {
+  if (role.state !== "enabled") return "not available yet; its place is kept for a later Moondog";
+  if (role.id === "chat") return role.choice ? modelName(role.choice) : "none chosen; /model picks one";
+  if (role.kind === "service") {
+    const service = (id) => role.services?.find((entry) => entry.id === id || entry.provider === id);
+    if (role.choice) {
+      const chosen = service(role.choice.service);
+      return `${chosen?.name ?? role.choice.service}${chosen && !chosen.ready ? " (not set up; falls back to the next service)" : ""}`;
+    }
+    const used = service(role.search);
+    return used?.ready ? `auto, now ${used.name}` : "auto, but no service is set up; /web status says how";
+  }
+  if (role.choice) return modelName(role.choice);
+  return role.auto ? `auto, now ${modelName(role.auto)}` : "auto, but the chat model can't see images";
+}
+
+export function formatModelRoles(roles) {
+  const lines = roles.map((role) => `- ${titles[role.id] ?? role.id}: ${describe(role)}`);
+  return `# Chat and auxiliary models\n\n${lines.join("\n")}\n\n` +
+    "`/model vision <provider> <model>` gives images a model of their own, and `/model vision auto` gives them back to the chat model when it can see.\n" +
+    "`/model web deepseek|brave|codex` picks the web search service, and `/model web auto` takes the first one set up.";
+}
+
+export async function runModelRolesCommand({ args = [], modelSettings, webResearch } = {}) {
+  if (!modelSettings?.roles) throw new Error("Model roles aren't available when Moondog is started this way.");
+  const [word, ...rest] = args;
+  const roleId = MODEL_ROLE_WORDS[String(word ?? "").toLowerCase()];
+  const show = async () => formatModelRoles(await modelSettings.roles({ web: await webResearch?.services?.().catch(() => null) ?? null }));
+  if (roleId === null) {
+    if (rest.length) throw new Error(usage);
+    return show();
+  }
+  if (roleId === undefined) throw new Error(usage);
+  const role = MODEL_ROLES.find((entry) => entry.id === roleId);
+  if (role.state !== "enabled") return `${titles[roleId]} isn't available yet. Its place is kept, so a later Moondog can add it.`;
+  if (!rest.length) return show();
+  let choice;
+  if (rest.length === 1 && rest[0].toLowerCase() === "auto") choice = null;
+  else if (role.kind === "service") {
+    if (rest.length !== 1 || !WEB_SERVICES.includes(rest[0].toLowerCase())) throw new Error(usage);
+    choice = { service: rest[0].toLowerCase() };
+  } else {
+    if (rest.length !== 2) throw new Error(usage);
+    choice = { provider: rest[0], model: rest[1] };
+  }
+  await modelSettings.setRole(roleId, choice);
+  if (roleId === "web_search") await webResearch?.refresh?.();
+  return show();
+}