@jxgame2020/dsh-token-quota 0.1.26 → 0.1.27

package/lib/index.js

@@ -27,7 +27,7 @@ const TOKEN_QUOTA_EXCEEDED_CODE = "TOKEN_QUOTA_EXCEEDED";
 const TOKEN_QUOTA_DEFAULT_MUSIC = {
 	enabled: false,
 	volume: .5,
-	style: "major",
+	style: "pentatonic",
 	onlyCurrentSession: true
 };
 /** Build the stable per-model key shared by the counter, settings, and snapshot. */
@@ -478,7 +478,15 @@ var TokenQuotaService = class TokenQuotaService extends Service {
 				});
 				this.musicClients.add(res);
 				res.write(": token-quota music stream\n\n");
+				const hb = setInterval(() => {
+					try {
+						res.write("event: hb\ndata: 1\n\n");
+					} catch {
+						clearInterval(hb);
+					}
+				}, 5e3);
 				req.on("close", () => {
+					clearInterval(hb);
 					this.musicClients.delete(res);
 				});
 			}
@@ -507,7 +515,7 @@ var TokenQuotaService = class TokenQuotaService extends Service {
 		return this.upgradeCheck;
 	}
 	async doRefreshUpgrade() {
-		const current = "0.1.26";
+		const current = "0.1.27";
 		let latest;
 		try {
 			const response = await fetch(REGISTRY_LATEST_URL, {

package/lib/types/client/index.js

@@ -43,6 +43,11 @@ export function apply(ctx) {
     // output is driven simultaneously.
     const music = new TokenQuotaMusic();
     const sse = new EventSource('/token-quota/events');
+    // Host heartbeat every 5s: proves the stream is alive while the model
+    // thinks (no actions flow then). If it stops, the engine's watchdog fades
+    // the piece out instead of droning forever.
+    sse.addEventListener('hb', () => { music.markStreamActivity(); });
+    sse.addEventListener('open', () => { music.markStreamActivity(); });
     sse.addEventListener('action', (event) => {
         let action;
         try {
@@ -65,7 +70,7 @@ export function apply(ctx) {
     const musicDefaults = (raw) => ({
         enabled: raw?.enabled ?? false,
         volume: raw?.volume ?? 0.5,
-        style: raw?.style ?? 'major',
+        style: raw?.style ?? 'pentatonic',
         onlyCurrentSession: raw?.onlyCurrentSession ?? true,
     });
     const keyOf = (selection) => {

package/lib/types/client/locales.js

@@ -72,7 +72,7 @@ export const zh = {
     musicStyle: '风格',
     musicStyleMajor: '大调',
     musicStyleMinor: '小调',
-    musicStylePentatonic: '五声',
+    musicStylePentatonic: '古风',
     musicOnlyCurrentSessionLabel: '只播当前会话',
     musicOnlyCurrentSessionHint: '开启后仅当前窗口的会话有音乐，后台子任务静音；关闭则所有会话都参与作曲',
     checkUpdatesNow: '立即检查',
@@ -148,7 +148,7 @@ export const en = {
     musicStyle: 'Style',
     musicStyleMajor: 'Major',
     musicStyleMinor: 'Minor',
-    musicStylePentatonic: 'Pentatonic',
+    musicStylePentatonic: 'Gufeng',
     musicOnlyCurrentSessionLabel: 'Current session only',
     musicOnlyCurrentSessionHint: 'When on, only the visible session drives the soundtrack (background tasks stay silent); when off, every session contributes.',
     checkUpdatesNow: 'Check now',

package/lib/types/client/music.d.ts

@@ -1,28 +1,30 @@
 /**
- * Live-composed ambient soundtrack driven by host actions (turns, steps,
- * tool calls, etc.). Three layers:
+ * 古风 live-composed soundtrack driven by host actions.
  *
- *  - **Pad**: a sustained three-note chord (triangle waves) that fades in when
- *    a request starts and crossfades to the next chord on every step.
- *  - **Bass**: one long root note per beat (lower octave), keeps the pulse.
- *  - **Melody**: an eighth-note scale line that dances inside the current
- *    chord — always in key, never a wrong note.
+ * Design: when a request starts the engine composes a *piece* — a guzheng-like
+ * plucked-string voice over a soft open-fifth drone (Web Audio synthesis; the
+ * MIDI output is switched to the Koto program so hardware synths match). The
+ * piece plays phrase after phrase so it never goes quiet while the model
+ * thinks or streams. Incoming events steer the piece instead of interrupting
+ * it: a step change glides the drone to the next mode centre and inserts a
+ * fast 过门 (fill); tool calls get a high plink; the ending gets a flute-like
+ * breath note and a descending glissando.
  *
- * Outputs through Web Audio (built-in synthesis) by default, and also sends
- * MIDI NoteOn/NoteOff to the first available MIDI output when one is detected
- * (both play simultaneously when MIDI is present — use the panel volume for
- * overall level, the MIDI output has its own gain on the receiver).
+ * Anti-runaway guards (the "endless drone" / hanging-MIDI-note problem):
+ *  - the host sends an SSE heartbeat every 5s; if it stops arriving the whole
+ *    engine fades out (a dead stream means no stop event will ever come),
+ *  - every MIDI NoteOn is registered and swept; `stopAll` also sends
+ *    All Notes Off (CC 123),
+ *  - Web Audio ramps never target zero exponentially and every oscillator is
+ *    explicitly stopped.
  *
  * @module @jxgame2020/dsh-token-quota/music
  */
 import type { TokenQuotaMusicAction, TokenQuotaMusicStyle } from '../types.ts';
 /**
- * Live-composed music engine driven by host actions.
- *
- * The engine is idle until `ensureStarted()` is called from a user gesture
- * (the panel switch), and only produces sound while `enabled` is true AND a
- * request is in flight (pad + bass + melody are gated by `startPad` /
- * `stopPad`).
+ * Live-composed gufeng engine. Idle until `ensureStarted()` runs inside a
+ * user gesture; silent while `enabled` is false; the piece runs only between
+ * `request/header` (start) and `assistant/message` / `turn/end` (stop).
  */
 export declare class TokenQuotaMusic {
     private audio;
@@ -31,49 +33,66 @@ export declare class TokenQuotaMusic {
     private enabled;
     private volume;
     private style;
-    private chordIndex;
-    private stepCount;
-    private toolCount;
-    private padOscs;
-    private padGain;
-    private padTarget;
-    private padActive;
-    private beatTimer;
-    private beatIndex;
-    private melodyDirection;
-    private melodyDegree;
-    private currentRoot;
-    private currentQuality;
-    /** Base MIDI note of the key. C4 = middle C. */
+    private playing;
+    private tonicIndex;
+    private phraseIndex;
+    private phraseTimer;
+    private droneOscs;
+    private droneGain;
+    private droneFilter;
+    private droneActive;
+    private lastStreamActivity;
+    private watchdogTimer;
+    private readonly activeMidiNotes;
+    /** Base MIDI note of the tonic. C4 = middle C. */
     private static readonly BASE_MIDI;
-    /** Beat length in ms — eighth note = beat / 2. */
+    /** Beat length in ms — the phrase rhythm is measured in these. */
     private static readonly BEAT_MS;
+    /** Stop everything if the SSE stream goes silent this long. */
+    private static readonly STREAM_TIMEOUT_MS;
     /** True once the audio context has been started (needs a user gesture). */
     get started(): boolean;
     /**
-     * Start the audio context and try to find a MIDI output.
-     * Must be called inside a user gesture (the panel switch click) so the
-     * AudioContext can resume. Safe to call multiple times.
+     * Start the audio context and probe for a MIDI output (once). Must be
+     * called inside a user gesture so the AudioContext can resume.
      */
     ensureStarted(): Promise<boolean>;
     setEnabled(value: boolean): void;
     setVolume(value: number): void;
     setStyle(value: TokenQuotaMusicStyle): void;
-    /** Handle one incoming host action and turn it into sound. */
+    /** Feed the engine one SSE activity timestamp (action or heartbeat). */
+    markStreamActivity(): void;
+    /** Handle one incoming host action and steer the piece. */
     onAction(action: TokenQuotaMusicAction): void;
-    /** Start the pad from silence, fading in to the target level. */
-    private startPad;
-    /** Smoothly morph the pad to a new root + quality. */
-    private crossfadePad;
-    /** Fade the pad to silence, then stop the oscillators. */
-    private stopPad;
-    /** Start the per-beat clock that drives bass and melody. */
-    private startBeatClock;
-    private stopBeatClock;
+    /** Start a new piece: drone + ascending glissando + phrase chain. */
+    private startPiece;
+    /** Play one phrase, then chain into the next after a one-beat rest. */
+    private playPhrase;
+    /** Insert a 过门 fill: pause the chain, play the run, resume after. */
+    private insertFill;
+    /** Stop the melody chain (drone keeps fading naturally). */
+    private stopMelody;
+    /** Stop the whole piece; `final` adds the closing cadence gestures. */
+    private stopPiece;
+    /** Hard stop everything (master switch off / teardown). */
     private stopAll;
-    /** Play one note: Web Audio + MIDI simultaneously when available. */
-    private playNote;
-    /** Play a three-note chord plus a bass octave below. */
-    private playChord;
+    /** Start the sustained open fifth (root + fifth below octave root). */
+    private startDrone;
+    /** Glide the drone to a new tonic (mode rotation). */
+    private glideDrone;
+    /** Fade the drone out and stop its oscillators. */
+    private fadeDrone;
+    /**
+     * Guzheng-like pluck: two slightly detuned oscillators through a sweeping
+     * lowpass, fast attack and a long exponential decay (notes overlap, which
+     * keeps the piece continuous instead of choppy).
+     */
+    private pluck;
+    /** Dizi-like breath note: sine with vibrato and a soft envelope. */
+    private breath;
+    /** Send one MIDI note with a registered NoteOff (anti hanging note). */
+    private midiNote;
+    /** Silence every registered note and send All Notes Off. */
+    private allMidiOff;
 }
 //# sourceMappingURL=music.d.ts.map