Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

6.5 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

// Which tool panels a model gets. Free of JSX so the node test runner can load it.

import type { AudioConvertCaps } from "@/features/chat/types/api";
import type { AudioOptionSpec } from "../audio-options";
import {
  type NativeAudioInstructionsKind,
  nativeAudioInstructionsKind,
} from "../audio-page-policy";
import { isMusicGenerationModel } from "../catalog";
import { parseMusicCapabilities } from "../music/music-types";
import type { AudioWorkflowId } from "../workflows";
import type {
  AnyAudioToolPanel,
  AudioModelContext,
  AudioReferenceTextMode,
  AudioRunPatch,
  AudioToolPanel,
  CoreInputs,
} from "./types";

export function instructionsKindFor(
  ctx: AudioModelContext,
): NativeAudioInstructionsKind | null {
  return ctx.musicGeneration
    ? "music"
    : nativeAudioInstructionsKind(ctx.audioType);
}

/** Only a loaded music model without studio modes (native MiniMax) keeps the old description. */
export function legacyMusicDescription(ctx: AudioModelContext): boolean {
  return ctx.audioMusic !== true && isMusicGenerationModel(null, ctx.audioType);
}

export function panelApplies(
  panel: Pick<AudioToolPanel<unknown>, "workflows" | "families" | "appliesTo">,
  workflow: AudioWorkflowId,
  ctx: AudioModelContext,
): boolean {
  if (!panel.workflows.includes(workflow)) return false;
  return panel.appliesTo
    ? panel.appliesTo(ctx)
    : panel.families.includes(ctx.audioFamily ?? "");
}

export function claimedOptionNames(
  panels: readonly Pick<AudioToolPanel<unknown>, "claims">[],
): Set<string> {
  return new Set(panels.flatMap((panel) => panel.claims));
}

const REFERENCE_TEXT_MODES: ReadonlySet<string> = new Set([
  "required",
  "optional",
  "unused",
]);

export function audioModelContextFor(
  status: {
    audio_type?: string | null;
    audio_family?: string | null;
    audio_workflows?: readonly string[] | null;
    audio_required_inputs?: readonly string[] | null;
    audio_request_inputs?: readonly string[] | null;
    audio_reference_text?: string | null;
    audio_convert?: AudioConvertCaps | null;
    audio_music?: unknown;
    audio_clone?: unknown;
  } | null,
  page: {
    musicGeneration: boolean;
    cudaMusicGeneration: boolean;
    musicNeedsDescription: boolean;
  },
): AudioModelContext {
  const referenceText = status?.audio_reference_text;
  const clone = status?.audio_clone;
  return {
    audioType: status?.audio_type ?? null,
    audioFamily: status?.audio_family ?? null,
    musicGeneration: page.musicGeneration,
    cudaMusicGeneration: page.cudaMusicGeneration,
    musicNeedsDescription: page.musicNeedsDescription,
    audioWorkflows: Array.isArray(status?.audio_workflows)
      ? status.audio_workflows
      : [],
    requiredInputs: Array.isArray(status?.audio_required_inputs)
      ? status.audio_required_inputs
      : [],
    referenceTextMode:
      typeof referenceText === "string" &&
      REFERENCE_TEXT_MODES.has(referenceText)
        ? (referenceText as AudioReferenceTextMode)
        : null,
    requestInputs: Array.isArray(status?.audio_request_inputs)
      ? status.audio_request_inputs
      : null,
    audioMusic: parseMusicCapabilities(status?.audio_music) !== null,
    convert: convertCapsOf(status?.audio_convert),
    cloneDescription: isPlainObject(clone) && clone.description === true,
  };
}

/** Whether the model reads one of these request inputs; unknown (null) counts as yes. */
export function readsRequestInput(
  ctx: Pick<AudioModelContext, "requestInputs">,
  ...names: string[]
): boolean {
  return (
    ctx.requestInputs == null ||
    names.some((name) => ctx.requestInputs?.includes(name))
  );
}

function convertCapsOf(value: unknown): AudioConvertCaps | null {
  if (!isPlainObject(value)) return null;
  const caps = value as Partial<AudioConvertCaps>;
  const modes = Array.isArray(caps.modes)
    ? caps.modes.filter((mode) => mode === "speech" || mode === "singing")
    : [];
  if (modes.length === 0) return null;
  return {
    modes,
    target: caps.target === "builtin" ? "builtin" : "audio",
    builtin_voices: Array.isArray(caps.builtin_voices)
      ? caps.builtin_voices.filter(
          (voice) =>
            isPlainObject(voice) &&
            typeof voice.id === "string" &&
            typeof voice.label === "string",
        )
      : [],
    pitch: isPlainObject(caps.pitch) ? caps.pitch : {},
    style: caps.style === true,
    route_reloads: caps.route_reloads === true,
    source_max_seconds:
      typeof caps.source_max_seconds === "number" && caps.source_max_seconds > 0
        ? caps.source_max_seconds
        : 300,
  };
}

export function toolValueKey(
  model: string | null | undefined,
  workflow: AudioWorkflowId,
  panelId: string,
): string {
  return `${model ?? ""}:${workflow}:${panelId}`;
}

const isPlainObject = (value: unknown): value is Record<string, unknown> =>
  typeof value === "object" && value !== null && !Array.isArray(value);

// Kept value over defaults, so a value saved by an older build still has every field.
export function panelValue<V>(
  panel: Pick<AudioToolPanel<V>, "id" | "initial">,
  values: Readonly<Record<string, unknown>>,
  specs: AudioOptionSpec[],
): V {
  const initial = panel.initial(specs);
  const stored = values[panel.id];
  if (stored === undefined) return initial;
  if (isPlainObject(initial) && isPlainObject(stored)) {
    return { ...initial, ...stored } as V;
  }
  return stored as V;
}

export function collectToolRequest(
  panels: readonly AnyAudioToolPanel[],
  values: Readonly<Record<string, unknown>>,
  core: CoreInputs,
  ctx: AudioModelContext,
  specs: AudioOptionSpec[] = [],
): { patch: AudioRunPatch; error: string | null } {
  const patch: AudioRunPatch = {};
  let error: string | null = null;
  for (const panel of panels) {
    const value = panelValue(panel, values, specs);
    error ??= panel.validate?.(value, core, ctx) ?? null;
    const part = panel.toRequest(value, ctx);
    if (part.options) patch.options = { ...patch.options, ...part.options };
    if (part.inputs) patch.inputs = { ...patch.inputs, ...part.inputs };
    if (part.convert) patch.convert = { ...patch.convert, ...part.convert };
    for (const key of [
      "instructions",
      "language",
      "route",
      "text",
      "speed",
      "referenceTextMode",
    ] as const) {
      if (part[key] !== undefined) {
        (patch as Record<string, unknown>)[key] = part[key];
      }
    }
  }
  return { patch, error };
}