dsh-her 0.1.0 → 0.2.0

package/lib/types/dsh/api.d.ts

@@ -14,6 +14,8 @@ import type { ReportLine } from './import-status.ts';
 import type { LookProject, WorkshopCard } from '../core/workshop.ts';
 import type { ProjectStatus } from './workshop.ts';
 import type { InstallState } from './body-install.ts';
+import type { MingStatus } from '../voice/ming.ts';
+import type { MingSettings, OwnVoice } from '../voice/ming-voices.ts';
 export declare const API_BASE = "/api/dsh-her";
 export interface StateView {
     platform: string;
@@ -25,7 +27,7 @@ export interface StateView {
         effort?: string;
         chosen: boolean;
     } | null;
-    /** status: listening (local recognition); speaking: her cloud voice. */
+    /** status: listening (local recognition); speaking: the service of her voice; ming: the local Ming voice and her own voices. */
     voice: {
         status: string;
         speaking: {
@@ -35,6 +37,11 @@ export interface StateView {
         };
         id: string;
         speed: number;
+        ming: MingStatus & {
+            installed: boolean;
+            settings: MingSettings;
+            own: OwnVoice[];
+        };
     };
     body: {
         connected: boolean;
@@ -73,6 +80,11 @@ export interface StateView {
         text: string;
         at: number;
     };
+    /** Her last reply failed with no words (the model had no key, no quota …): why, and what to do. */
+    problem?: {
+        text: string;
+        at: number;
+    };
     memory: {
         facts: Fact[];
         episodes: Episode[];
@@ -105,6 +117,30 @@ export interface ApiRuntime {
         format: 'wav' | 'mp3';
         durationMs: number;
     }>;
+    /** The local Ming voice: install (progress shows in the state), uninstall, start again after errors, settings. */
+    mingInstall(): void;
+    mingUninstall(): void;
+    mingRestart(): Promise<void>;
+    mingSettings(patch: Partial<MingSettings>): void;
+    /** Three takes of a voice from its description, each kept as a draft to listen to. */
+    mingDesign(description: string): Promise<Array<{
+        id: string;
+        audio: string;
+        durationMs: number;
+    }>>;
+    /** A recording to clone (base64, its file name for the format): a draft, with what it says as recognized. */
+    mingClone(audio: string, name: string): Promise<{
+        id: string;
+        audio: string;
+        durationMs: number;
+        text: string;
+    }>;
+    /** Keep a draft as one of her voices (a clone needs consent and the recording's words). */
+    mingKeep(draft: string, name: string, change: {
+        text?: string;
+        consent?: boolean;
+    }): OwnVoice;
+    mingRemove(id: string): void;
     startBody(): string;
     /** Download and install the body app (or a newer one); progress shows in the state. */
     installBody(): void;

package/lib/types/dsh/plugin.d.ts

@@ -31,4 +31,6 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { HerConfig } from './config.ts';
+/** What to tell you when her model failed: the likely fix, in plain words. */
+export declare function explainModelError(message: string, model: string): string;
 export declare function apply(ctx: Context, config: HerConfig): void;

package/lib/types/voice/ming-model.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The Ming voice's model: mlx-community/Ming-3.0-tts-0.5B-8bit (MIT, from
+ * inclusionAI's Ming-3.0-tts-0.5B), pinned to one revision. A copy of the
+ * same files is on dsh-her's GitHub release `ming-model-1`, which is tried
+ * first (Hugging Face is slow or blocked in some places); each file is
+ * checked against its size and SHA-256 whichever source it came from.
+ */
+export declare const MING_MODEL: {
+    readonly repo: "mlx-community/Ming-3.0-tts-0.5B-8bit";
+    readonly revision: "d0d1da6f627e4b3f20cc2db6ba4aee86d45343ad";
+    readonly sources: readonly ["https://github.com/AIcivilization/dsh-her/releases/download/ming-model-1/", "https://huggingface.co/mlx-community/Ming-3.0-tts-0.5B-8bit/resolve/d0d1da6f627e4b3f20cc2db6ba4aee86d45343ad/"];
+    readonly files: readonly [{
+        readonly name: "LICENSE";
+        readonly size: 1067;
+        readonly sha256: "2872f1918dfc04fdeb7f5d66d8d1b773594c9375e7c8f7bda39780bb97ad4fba";
+    }, {
+        readonly name: "README.md";
+        readonly size: 4360;
+        readonly sha256: "0af63591f3ab08d8e057330477928692ce8a4234618aacd4f2a0095c5d50bda9";
+    }, {
+        readonly name: "added_tokens.json";
+        readonly size: 1785;
+        readonly sha256: "34394b1e16d7da2db16618bd43a0f970902ade0075480bcd812fe62d559ec319";
+    }, {
+        readonly name: "campplus.safetensors";
+        readonly size: 27699096;
+        readonly sha256: "a479586bd8f8f96cdb414eaa2fa07c6cd54d6d1636562e2d75a0211cb3b0a6fd";
+    }, {
+        readonly name: "config.json";
+        readonly size: 6087;
+        readonly sha256: "8ea3e685a870fd1a535d3b4a4c975fc20c4fca56e67acdef06fe40004064c73b";
+    }, {
+        readonly name: "merges.txt";
+        readonly size: 1671853;
+        readonly sha256: "8831e4f1a044471340f7c0a83d7bd71306a5b867e95fd870f74d0c5308a904d5";
+    }, {
+        readonly name: "model.safetensors";
+        readonly size: 1573366591;
+        readonly sha256: "e88a4b53cb5b705703e961389f3d7f0e8b72c240b4dad796bf9961cc018971fc";
+    }, {
+        readonly name: "model.safetensors.index.json";
+        readonly size: 201850;
+        readonly sha256: "f59991abebed1a4f798a9488568af496d925e6eea507450aa8051a06f475a2ce";
+    }, {
+        readonly name: "special_tokens_map.json";
+        readonly size: 2726;
+        readonly sha256: "2c2ec51b9da5db654ac20de8310350d0c9c1a65918ae0181b80dacd2919b4fc3";
+    }, {
+        readonly name: "tokenizer.json";
+        readonly size: 11431389;
+        readonly sha256: "87d54ca3b44ea2f822ba39a0a45cb1b61644bd6606d9d3536dea75367bffb06d";
+    }, {
+        readonly name: "tokenizer_config.json";
+        readonly size: 16260;
+        readonly sha256: "12d6162c815edef24f8606e65b60d43fe0d92b0a4e150a0db8fa01c523aaf36a";
+    }, {
+        readonly name: "vocab.json";
+        readonly size: 2776833;
+        readonly sha256: "ca10d7e9fb3ed18575dd1e277a2579c16d108e32f27439684afa0e10b1440910";
+    }];
+};
+export declare const MING_MODEL_BYTES: number;

package/lib/types/voice/ming-voices.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Her own Ming voices (docs/Ming本地声音设计.md §4), in `<home>/voices/ming/`:
+ * `<id>.wav` (the reference recording) and `<id>.json`. Ming says every
+ * sentence in such a voice by cloning that recording.
+ *
+ * - designed: made from a description. The same description gives a
+ *   slightly different voice every time, so a few candidates are made, one is
+ *   kept, and from then on she clones it;
+ * - cloned: from a recording you add, only with your word that it is your
+ *   own voice or that you may use it. It never leaves this computer.
+ *
+ * Candidates not kept yet wait in `drafts/` and are cleared after a day.
+ * The voice settings (quality, moods, idle minutes) are in `settings.json`.
+ */
+export interface OwnVoice {
+    id: string;
+    name: string;
+    kind: 'design' | 'clone';
+    /** What the recording says (Ming needs it to clone). */
+    text: string;
+    /** A designed voice: the description it was made from. */
+    description?: string;
+    createdAt: string;
+}
+export interface MingSettings {
+    /** quality: 10 steps (about 2.9 s for 25 characters on an M1 Pro); speed: 5 steps (about 1.7 s). */
+    quality: 'quality' | 'speed';
+    /** Her moods change the voice. */
+    moods: boolean;
+    /** Minutes without a sentence before Ming stops to free its memory; 0: never. Unset: by the Mac's memory. */
+    idleMinutes?: number;
+}
+export declare const DEFAULT_MING_SETTINGS: MingSettings;
+export declare const MING_STEPS: Record<MingSettings['quality'], number>;
+/** A clone reference: long enough to carry the voice, short enough to keep each sentence quick. */
+export declare const CLONE_MIN_S = 3;
+export declare const CLONE_MAX_S = 15;
+interface Draft {
+    kind: OwnVoice['kind'];
+    text: string;
+    description?: string;
+}
+export declare class OwnVoices {
+    private readonly dir;
+    constructor(dir: string);
+    list(): OwnVoice[];
+    /** The recording Ming clones for a voice. */
+    ref(id: string): {
+        wav: string;
+        text: string;
+    } | undefined;
+    /** Keep a candidate for a while (until it is kept, or a day). */
+    addDraft(wav: Uint8Array, draft: Draft): string;
+    /** Keep a candidate as one of her voices. A clone needs your consent and what the recording says. */
+    keep(draftId: string, name: string, change?: {
+        text?: string;
+        consent?: boolean;
+    }): OwnVoice;
+    remove(id: string): void;
+    settings(): MingSettings;
+    saveSettings(patch: Partial<MingSettings>): MingSettings;
+}
+/**
+ * A recording you add, made ready to clone: converted by macOS's afconvert
+ * (wav, m4a from Voice Memos, mp3, aiff …) to 44.1 kHz mono, quiet start and
+ * end cut off, at most CLONE_MAX_S. Also at 16 kHz, to recognize what it says.
+ */
+export declare function prepareRecording(bytes: Uint8Array, name: string): Promise<{
+    wav: Uint8Array;
+    pcm16k: Uint8Array;
+    seconds: number;
+}>;
+/** Cut quiet 10 ms frames off both ends, keeping 0.1 s around the speech. */
+export declare function trimSilence(samples: Int16Array, rate: number): Int16Array;
+export {};

package/lib/types/voice/ming.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Ming-3.0-tts on this computer (docs/Ming本地声音设计.md): offline, free,
+ * with moods, and voices of your own. Apple chips with macOS 14+ only (MLX).
+ *
+ * - Install (on request, from the "她" page): uv (voice/uv.ts) builds a
+ *   Python 3.12 environment in `<home>/ming/env` and installs mlx-audio from
+ *   python/ming-requirements.txt, every package pinned with its hash; the
+ *   model (voice/ming-model.ts) is downloaded into `<home>/ming/model`, each
+ *   file checked against its size and SHA-256. An interrupted download goes
+ *   on where it stopped. Deleting `<home>/ming` uninstalls it.
+ * - Run: python/ming_worker.py, one process that keeps the model loaded
+ *   (about 2 GB of memory); sentences go to it one at a time. It starts with
+ *   the first sentence (or when you start talking, `warm`), and stops after
+ *   some minutes without a sentence to give the memory back.
+ * - A worker that dies is started again with the next sentence; one that dies
+ *   twice within five minutes is left stopped (`failed`) until `restart`.
+ */
+export type MingState = 'unsupported' | 'absent' | 'installing' | 'stopped' | 'loading' | 'ready' | 'failed';
+export interface MingStatus {
+    state: MingState;
+    /** While installing: what is being done, and bytes of the model so far. */
+    step?: string;
+    done?: number;
+    total?: number;
+    error?: string;
+}
+export interface MingRequest {
+    text: string;
+    /** A built-in voice (灵风信_高兴 …), a recording to clone, or a description to design a voice from. */
+    voice?: string;
+    ref?: {
+        wav: string;
+        text: string;
+    };
+    design?: string;
+    emotion?: string;
+    speed?: string;
+    steps: number;
+    seed?: number;
+}
+export interface MingAudio {
+    /** WAV, 16-bit mono. */
+    audio: Uint8Array;
+    durationMs: number;
+    ms: number;
+}
+type Logger = {
+    info(message: string): void;
+    warn(message: string): void;
+};
+/** Why Ming cannot run here, or undefined when it can: Apple chips and macOS 14 (Darwin 23) or later. */
+export declare function mingUnsupported(platform?: string, arch?: string, darwin?: string): string | undefined;
+/** Minutes without a sentence before the worker stops: 10 on a Mac with 16 GB or less, else 30. */
+export declare const defaultIdleMinutes: (memory?: number) => number;
+export declare class MingVoice {
+    private readonly root;
+    private readonly uvHome;
+    private readonly logger;
+    private state;
+    private worker;
+    private starting;
+    private installing;
+    private readonly pending;
+    private queue;
+    private nextId;
+    private lastUse;
+    private crashes;
+    private stderr;
+    private idleMinutes;
+    private readonly idleTimer;
+    /** `root`: `<home>/ming`; `uvHome`: `<home>/uv`, shared with the Edge voice. `idleMinutes` 0: never stop. */
+    constructor(root: string, uvHome: string, logger: Logger, idleMinutes?: number);
+    get status(): MingStatus;
+    get installed(): boolean;
+    setIdleMinutes(minutes: number): void;
+    private get python();
+    private get modelDir();
+    /** Install everything (once; a second call joins the first). Progress shows in `status`. */
+    install(): Promise<void>;
+    private doInstall;
+    /** Every model file, checked; files already checked (listed in `.verified`) are kept. */
+    private downloadModel;
+    /** Stop and delete everything (about 2 GB). */
+    uninstall(): void;
+    /** You started talking: have the model loaded by the time she answers. */
+    warm(): void;
+    /** After `failed`: forget the crashes and start again. */
+    restart(): Promise<void>;
+    /** One sentence. Sentences are said one at a time, in the order asked. */
+    synthesize(request: MingRequest): Promise<MingAudio>;
+    stop(): void;
+    /** Stop for good (the plugin is unloading). */
+    close(): void;
+    private speakNow;
+    private ensure;
+    private start;
+    private send;
+    private onReply;
+    private onExit;
+    private failPending;
+    private stopWhenIdle;
+}
+export {};

package/lib/types/voice/speech-queue.d.ts

@@ -36,8 +36,10 @@ export declare class SpeechQueue {
     private readonly sent;
     private readonly synth;
     private readonly out;
-    constructor(synth: (text: string) => Promise<Synthesized | undefined>, out: SpeechOut);
-    say(uid: string, seq: number, text: string, cues?: Cue[]): void;
+    /** `synth` gets what to say and the sentence's cues (its emotion colours the voice). */
+    constructor(synth: (text: string, cues: Cue[]) => Promise<Synthesized | undefined>, out: SpeechOut);
+    /** `spoken`: what to say when it differs from the subtitle `text` (sound markers for Ming). */
+    say(uid: string, seq: number, text: string, cues?: Cue[], spoken?: string): void;
     end(uid: string): void;
     cancel(uid: string): void;
     /** Sentences of a reply that went out, in order. */

package/lib/types/voice/uv.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Running Python tools without asking the computer for a Python: uv
+ * (https://github.com/astral-sh/uv), one pinned, checksummed download kept
+ * in `<home>/uv`, fetches a Python of its own into the same folder and builds
+ * virtual environments with it. No dialogs, nothing system-wide. Used by the
+ * Edge voice (when the computer has no usable Python) and the Ming voice.
+ */
+export declare function run(cmd: string, args: string[], timeout: number, env?: NodeJS.ProcessEnv): Promise<string>;
+/** What uv needs to keep its Python and downloads inside `uvHome`. */
+export declare function uvEnv(uvHome: string): NodeJS.ProcessEnv;
+/** The uv binary in `uvHome`, downloaded and checked the first time. */
+export declare function installUv(uvHome: string): Promise<string>;

package/lib/types/voice/voice.d.ts

@@ -5,8 +5,9 @@
  *   process, engine.ts). Its model is downloaded in the background on first
  *   use; until then she only reads what you type.
  * - Speaking: the service of the voice she uses (core/voices.ts): Microsoft
- *   Edge voices through the edge-tts tool (edge.ts, the default), or Alibaba
- *   Cloud Model Studio CosyVoice (cosyvoice.ts). When the service cannot
+ *   Edge voices through the edge-tts tool (edge.ts, the default), Alibaba
+ *   Cloud Model Studio CosyVoice (cosyvoice.ts), or Ming on this computer
+ *   (ming.ts; built-in voices or her own, with her moods). When the service cannot
  *   speak (tool not installed yet, no key, no quota, offline), a sentence goes
  *   out without audio and shows as text; a key added later is picked up
  *   without restarting.
@@ -14,6 +15,9 @@
  *   answers start at once.
  */
 import { type VoiceService } from '../core/index.ts';
+import type { Cue } from '../protocol/index.ts';
+import type { MingVoice } from './ming.ts';
+import { type OwnVoices } from './ming-voices.ts';
 import type { Synthesized } from './speech-queue.ts';
 export interface VoiceConfig {
     /** false: she only writes (text only). */
@@ -40,12 +44,16 @@ export declare class Voice {
     private keyCheckedAt;
     private readonly cloud;
     private readonly edge;
+    private readonly ming;
     private readonly cache;
     private readonly modelsDir;
     private config;
     private readonly logger;
-    /** `edgeDir`: where dsh-her installs its own edge-tts if none is found. */
-    constructor(modelsDir: string, edgeDir: string, config: VoiceConfig, logger: Logger);
+    /** `edgeDir`: where dsh-her installs its own edge-tts if none is found. `ming`: the local Ming voice and her own voices. */
+    constructor(modelsDir: string, edgeDir: string, config: VoiceConfig, logger: Logger, ming?: {
+        voice: MingVoice;
+        own: OwnVoices;
+    });
     /** Listening. */
     get status(): VoiceStatus;
     get speaking(): {
@@ -61,8 +69,8 @@ export declare class Voice {
     setVoice(voice: string, speed: number): void;
     /** One sentence in a given voice, for trying voices; not cached. Throws with a message for the page. */
     preview(text: string, voice: string, speed: number): Promise<Synthesized>;
-    /** Her sentence as audio, or undefined when she cannot speak right now (it shows as text). */
-    synthesize(text: string): Promise<Synthesized | undefined>;
+    /** Her sentence as audio, or undefined when she cannot speak right now (it shows as text). Its emotion colours a Ming voice. */
+    synthesize(text: string, cues?: Cue[]): Promise<Synthesized | undefined>;
     /** What you said, from 16-bit mono PCM. Empty when nothing was understood. */
     recognize(pcm16: Uint8Array, sampleRate: number): Promise<{
         text: string;

package/lib/voice/edge.js

@@ -19,26 +19,16 @@
  * measured on 2026-10-29); the speech queue synthesizes ahead to hide it.
  * Needs the internet; not an official Microsoft API, so it may stop working.
  */
-import { execFile } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { readFile, rm } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { installUv, run, uvEnv } from "./uv.js";
 /** audio-24khz-48kbitrate-mono-mp3: constant bitrate, so bytes give the duration. */
 const MP3_BYTES_PER_MS = 48_000 / 8 / 1000;
 const SPEAK_TIMEOUT_MS = 20_000;
 const win = process.platform === 'win32';
-function run(cmd, args, timeout, env) {
-    return new Promise((resolve, reject) => {
-        execFile(cmd, args, { timeout, maxBuffer: 8 << 20, ...(env === undefined ? {} : { env: { ...process.env, ...env } }) }, (error, stdout, stderr) => {
-            if (error !== null)
-                reject(new Error(String(stderr || error.message).trim().split('\n').slice(-2).join(' ')));
-            else
-                resolve(String(stdout));
-        });
-    });
-}
 const venvBin = (root, name) => join(root, win ? 'Scripts' : 'bin', win ? `${name}.exe` : name);
 /** `--rate` for a speed factor: 1.2 → "+20%". */
 export function edgeRate(speed) {
@@ -122,7 +112,7 @@ export class EdgeVoice {
                 // No Python here: uv brings one of its own, kept next to edge-tts.
                 const uvHome = join(dirname(this.ownDir), 'uv');
                 const uv = await installUv(uvHome);
-                const env = { UV_PYTHON_INSTALL_DIR: join(uvHome, 'python'), UV_CACHE_DIR: join(uvHome, 'cache'), UV_NO_CONFIG: '1' };
+                const env = uvEnv(uvHome);
                 if (!existsSync(venvPython))
                     await run(uv, ['venv', '--quiet', '--python', '3.12', this.ownDir], 600_000, env);
                 await run(uv, ['pip', 'install', '--quiet', '--python', venvPython, '--upgrade', 'edge-tts'], 300_000, env);
@@ -163,37 +153,3 @@ async function findPython() {
     }
     return undefined;
 }
-/** uv, pinned: version and the SHA-256 of each download (from the release's .sha256 files). */
-const UV_VERSION = '0.11.26';
-const UV_ASSETS = {
-    'darwin-arm64': { file: 'uv-aarch64-apple-darwin.tar.gz', sha256: '8f7fbf1708399b921857bce71e1d60f0d3ccf52a30caebc1c1a2f175dce13ab6' },
-    'darwin-x64': { file: 'uv-x86_64-apple-darwin.tar.gz', sha256: '922b460202707dd5f4ccacbadbe7f6a546cc46e82a99bf50ca99a7977a78eddd' },
-    'win32-x64': { file: 'uv-x86_64-pc-windows-msvc.zip', sha256: '4e1278ede866be6c0bf32d2f466cc6de7a9fb399ecf20c9ce2d186e52424be47' },
-};
-/** The uv binary in `uvHome`, downloaded and checked the first time. */
-async function installUv(uvHome) {
-    const key = `${process.platform}-${process.arch}`;
-    const asset = UV_ASSETS[key];
-    if (asset === undefined)
-        throw new Error(`这台电脑（${key}）没有 Python，也没有现成的办法自动装：请先装 Python 3`);
-    const dir = join(uvHome, UV_VERSION);
-    const found = [join(dir, 'uv'), join(dir, 'uv.exe'), join(dir, asset.file.replace(/\.(tar\.gz|zip)$/, ''), 'uv')].find(p => existsSync(p));
-    if (found !== undefined)
-        return found;
-    const res = await fetch(`https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${asset.file}`, { redirect: 'follow', signal: AbortSignal.timeout(300_000) });
-    if (!res.ok)
-        throw new Error(`下载 uv 失败（${res.status}）`);
-    const bytes = Buffer.from(await res.arrayBuffer());
-    if (createHash('sha256').update(bytes).digest('hex') !== asset.sha256)
-        throw new Error('下载的 uv 校验不对，没有使用');
-    await mkdir(dir, { recursive: true });
-    const archive = join(dir, asset.file);
-    await writeFile(archive, bytes);
-    // tar reads both the .tar.gz and (Windows 10+) the .zip.
-    await run('tar', ['-xf', archive, '-C', dir], 120_000);
-    await rm(archive, { force: true });
-    const uv = [join(dir, 'uv'), join(dir, 'uv.exe'), join(dir, asset.file.replace(/\.(tar\.gz|zip)$/, ''), 'uv')].find(p => existsSync(p));
-    if (uv === undefined)
-        throw new Error('uv 解压后找不到');
-    return uv;
-}

package/lib/voice/ming-model.js

@@ -0,0 +1,30 @@
+/**
+ * The Ming voice's model: mlx-community/Ming-3.0-tts-0.5B-8bit (MIT, from
+ * inclusionAI's Ming-3.0-tts-0.5B), pinned to one revision. A copy of the
+ * same files is on dsh-her's GitHub release `ming-model-1`, which is tried
+ * first (Hugging Face is slow or blocked in some places); each file is
+ * checked against its size and SHA-256 whichever source it came from.
+ */
+export const MING_MODEL = {
+    repo: 'mlx-community/Ming-3.0-tts-0.5B-8bit',
+    revision: 'd0d1da6f627e4b3f20cc2db6ba4aee86d45343ad',
+    sources: [
+        'https://github.com/AIcivilization/dsh-her/releases/download/ming-model-1/',
+        'https://huggingface.co/mlx-community/Ming-3.0-tts-0.5B-8bit/resolve/d0d1da6f627e4b3f20cc2db6ba4aee86d45343ad/',
+    ],
+    files: [
+        { name: 'LICENSE', size: 1067, sha256: '2872f1918dfc04fdeb7f5d66d8d1b773594c9375e7c8f7bda39780bb97ad4fba' },
+        { name: 'README.md', size: 4360, sha256: '0af63591f3ab08d8e057330477928692ce8a4234618aacd4f2a0095c5d50bda9' },
+        { name: 'added_tokens.json', size: 1785, sha256: '34394b1e16d7da2db16618bd43a0f970902ade0075480bcd812fe62d559ec319' },
+        { name: 'campplus.safetensors', size: 27699096, sha256: 'a479586bd8f8f96cdb414eaa2fa07c6cd54d6d1636562e2d75a0211cb3b0a6fd' },
+        { name: 'config.json', size: 6087, sha256: '8ea3e685a870fd1a535d3b4a4c975fc20c4fca56e67acdef06fe40004064c73b' },
+        { name: 'merges.txt', size: 1671853, sha256: '8831e4f1a044471340f7c0a83d7bd71306a5b867e95fd870f74d0c5308a904d5' },
+        { name: 'model.safetensors', size: 1573366591, sha256: 'e88a4b53cb5b705703e961389f3d7f0e8b72c240b4dad796bf9961cc018971fc' },
+        { name: 'model.safetensors.index.json', size: 201850, sha256: 'f59991abebed1a4f798a9488568af496d925e6eea507450aa8051a06f475a2ce' },
+        { name: 'special_tokens_map.json', size: 2726, sha256: '2c2ec51b9da5db654ac20de8310350d0c9c1a65918ae0181b80dacd2919b4fc3' },
+        { name: 'tokenizer.json', size: 11431389, sha256: '87d54ca3b44ea2f822ba39a0a45cb1b61644bd6606d9d3536dea75367bffb06d' },
+        { name: 'tokenizer_config.json', size: 16260, sha256: '12d6162c815edef24f8606e65b60d43fe0d92b0a4e150a0db8fa01c523aaf36a' },
+        { name: 'vocab.json', size: 2776833, sha256: 'ca10d7e9fb3ed18575dd1e277a2579c16d108e32f27439684afa0e10b1440910' },
+    ],
+};
+export const MING_MODEL_BYTES = MING_MODEL.files.reduce((sum, f) => sum + f.size, 0);