@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/plugins/speech/speech-runtime.js

@@ -0,0 +1,212 @@
+import { errorMessage } from '../../lib/guards.js';
+import { AbortedError, raceAbort } from '../../lib/helpers/race-abort.js';
+import { retryMemo } from '../../lib/helpers/retry-memo.js';
+import { hlog } from '../../lib/log.js';
+import { residentSrc } from '../../lib/models/model-catalog.js';
+import { pushQueue } from '../../lib/queue.js';
+import { pcmForTranscription } from './audio-resample.js';
+import { defaultTts, dialogueScript, engineOf, isDialogue, loadConfig } from './speech-engine.js';
+import { createVoiceLane } from './voice-lane.js';
+import { speakOnce, speakStreamOnce, transcribeOnce, transcribeStreaming } from './voice.js';
+import { buildWavBuffer } from './wav-encode.js';
+const TRANSCRIBE_STREAM_MIN_BYTES = 16_000 * 2 * 60;
+const TRANSCRIPTION_MODEL_LABEL = 'transcription model';
+const BUSY_MESSAGE = 'the chat model is busy; try speaking again once the current reply finishes';
+function voiceSdk(models) {
+    return retryMemo(async () => {
+        const sdk = await models.sdk();
+        const [{ ttsPlugin }, { parakeetPlugin }, { registerPlugin }] = await Promise.all([
+            import('@qvac/sdk/onnx-tts/plugin'),
+            import('@qvac/sdk/parakeet-transcription/plugin'),
+            import('@qvac/sdk/plugins')
+        ]);
+        for (const [name, plugin] of [
+            ['tts', ttsPlugin],
+            ['parakeet', parakeetPlugin]
+        ]) {
+            try {
+                registerPlugin(plugin);
+            }
+            catch (err) {
+                hlog('plugin registration skipped', { plugin: name, err: errorMessage(err) });
+            }
+        }
+        return sdk;
+    });
+}
+async function transcribeClip(sdk, modelId, { audio, signal }) {
+    const pcm = await pcmForTranscription(audio);
+    if (signal?.aborted) {
+        throw new AbortedError();
+    }
+    if (pcm && pcm.length >= TRANSCRIBE_STREAM_MIN_BYTES) {
+        return transcribeStreaming(sdk, pcm, { modelId, signal });
+    }
+    return transcribeOnce(sdk, modelId, pcm ? buildWavBuffer(pcm) : audio);
+}
+export class SpeechRuntime {
+    _models;
+    _options;
+    _loadSdk;
+    _tts;
+    _transcription;
+    _lane = createVoiceLane();
+    constructor(models, options = {}) {
+        this._models = models;
+        this._options = options;
+        this._loadSdk = voiceSdk(models);
+        this._tts = {
+            addon: 'tts',
+            pool: models.registerPool({
+                addon: 'tts',
+                modelType: 'tts-ggml',
+                modelConfigFor: (modelSrc) => loadConfig(options, modelSrc),
+                needsRoom: (src) => this._needsRoom(src),
+                sdk: this._loadSdk
+            })
+        };
+        this._transcription = {
+            addon: 'parakeet',
+            pool: models.registerPool({
+                addon: 'parakeet',
+                modelType: 'parakeet-transcription',
+                modelConfig: { useGPU: models.transcriptionDevice !== 'cpu' },
+                openclCache: true,
+                label: TRANSCRIPTION_MODEL_LABEL,
+                sdk: this._loadSdk
+            })
+        };
+    }
+    defaultModel(profile) {
+        return defaultTts(this._options, profile);
+    }
+    transcribe(context) {
+        return this._voiceJob(this._transcription, context, (sdk, modelId) => transcribeClip(sdk, modelId, context));
+    }
+    unloadIdle() {
+        return this._tts.pool.evictIdle((src) => this._needsRoom(src));
+    }
+    speak(context) {
+        const src = residentSrc(context.model, 'tts');
+        const engine = engineOf(this._options, src);
+        const script = isDialogue(this._options, src)
+            ? dialogueScript(this._options, context.text)
+            : context.text;
+        return this._voiceJob(this._tts, { ...context, model: src }, (sdk, modelId) => speakOnce(sdk, script, { modelId, engine }));
+    }
+    async *speakStream({ model, text, signal }) {
+        const src = residentSrc(model, 'tts');
+        if (isDialogue(this._options, src)) {
+            throw new Error('a dialogue speaks whole: MOSS-TTSD cannot stream text fragment by fragment');
+        }
+        const engine = engineOf(this._options, src);
+        await this._makeRoom(src, signal);
+        const chunks = pushQueue();
+        const { held, releaseWork } = this._open(this._tts, src);
+        let sdk = null;
+        let modelId = null;
+        const cancel = () => {
+            if (sdk && modelId) {
+                void sdk.cancel({ modelId, operation: 'inference' }).catch(noop);
+            }
+        };
+        signal?.addEventListener('abort', cancel, { once: true });
+        const job = this._lane(async () => {
+            try {
+                modelId = (await held.load()).modelId;
+                sdk = await this._loadSdk();
+                if (signal?.aborted) {
+                    return;
+                }
+                for await (const chunk of speakStreamOnce(sdk, text, { modelId, engine })) {
+                    chunks.push(chunk);
+                }
+            }
+            finally {
+                chunks.end();
+            }
+        });
+        let settled = false;
+        try {
+            yield* chunks;
+            await job;
+            settled = true;
+        }
+        finally {
+            signal?.removeEventListener('abort', cancel);
+            if (!settled) {
+                cancel();
+            }
+            void job
+                .catch(noop)
+                .finally(() => {
+                try {
+                    held.release();
+                }
+                finally {
+                    releaseWork();
+                }
+            })
+                .catch(noop);
+        }
+    }
+    _needsRoom(src) {
+        return engineOf(this._options, src) === 'moss';
+    }
+    async _makeRoom(src, signal) {
+        if (this._needsRoom(src) && !this._tts.pool.resident(src)) {
+            await this._models.makeRoom(signal, BUSY_MESSAGE);
+        }
+    }
+    _open({ pool, addon }, model) {
+        const releaseWork = this._models.enterWork();
+        try {
+            return { held: pool.open(residentSrc(model, addon)), releaseWork };
+        }
+        catch (error) {
+            releaseWork();
+            throw error;
+        }
+    }
+    async _voiceJob(voice, { model, signal }, run) {
+        if (voice === this._tts) {
+            await this._makeRoom(model, signal);
+        }
+        const { held, releaseWork } = this._open(voice, model);
+        let job = null;
+        let releaseAfter = null;
+        let sdk = null;
+        let modelId = null;
+        try {
+            modelId = (await raceAbort(held.load(), signal)).modelId;
+            sdk = await this._loadSdk();
+            const boundSdk = sdk;
+            const boundId = modelId;
+            job = this._lane(() => run(boundSdk, boundId));
+            return await raceAbort(job, signal);
+        }
+        catch (err) {
+            if (err instanceof AbortedError) {
+                if (sdk && modelId) {
+                    void sdk.cancel({ modelId, operation: 'inference' }).catch(noop);
+                }
+                releaseAfter = job ?? held.peek();
+            }
+            throw err;
+        }
+        finally {
+            if (releaseAfter) {
+                void releaseAfter.then(held.release, held.release).finally(releaseWork).catch(noop);
+            }
+            else {
+                try {
+                    held.release();
+                }
+                finally {
+                    releaseWork();
+                }
+            }
+        }
+    }
+}
+function noop() { }

package/dist-lib/{lib/capabilities → plugins/speech}/speech-text.d.ts

@@ -4,3 +4,4 @@ export interface SpeechText {
     dropped: string[];
 }
 export declare function normalizeForSpeech(text: string, lang?: SpeechLang): SpeechText;
+export declare function normalizeForMoss(text: string, lang?: SpeechLang): SpeechText;

package/dist-lib/{lib/capabilities → plugins/speech}/speech-text.js

@@ -2,8 +2,15 @@ import { ascii } from 'asenion';
 import { CURRENCY_CODES, SPEECH_LEXICON } from './speech-lexicon.js';
 const EMOJI_MODIFIERS = /[\uFE0E\uFE0F\u200D\u{1F3FB}-\u{1F3FF}]/gu;
 const UNSPEAKABLE = /[^\nA-Za-z0-9 .,;:!?'"()\u002D_]/gu;
+const MOSS_UNSPEAKABLE = /\p{Extended_Pictographic}/gu;
+const MOSS_DIRECTION = /(\[(?:pause[^\]]*|S\d)\]|(?<![\w/])\/[^/\s]+\/(?![\w/]))/;
 export function normalizeForSpeech(text, lang = 'en') {
-    return filterUnspeakable(toSpokenText(text, lang));
+    return filterUnspeakable(toSpokenText(text, lang), UNSPEAKABLE);
+}
+export function normalizeForMoss(text, lang = 'en') {
+    const parts = stripMarkup(foldWhitespace(text)).split(MOSS_DIRECTION);
+    const spoken = parts.map((part, index) => index % 2 ? part : verbalize(part.normalize('NFKC').replace(EMOJI_MODIFIERS, ''), lang));
+    return filterUnspeakable(spoken.join(''), MOSS_UNSPEAKABLE);
 }
 function toSpokenText(text, lang) {
     const folded = stripMarkup(foldWhitespace(text)).normalize('NFKC').replace(EMOJI_MODIFIERS, '');
@@ -63,9 +70,9 @@ function currencyName(code, lang, { singular = false } = {}) {
     return name;
 }
 const CURRENCY_NAMES = new Map();
-function filterUnspeakable(text) {
+function filterUnspeakable(text, unspeakable) {
     const dropped = [];
-    const kept = text.replace(UNSPEAKABLE, (char) => {
+    const kept = text.replace(unspeakable, (char) => {
         dropped.push(char);
         return '';
     });

package/dist-lib/plugins/speech/voice-lane.d.ts

@@ -0,0 +1,2 @@
+export type VoiceLane = <T>(job: () => Promise<T>) => Promise<T>;
+export declare function createVoiceLane(): VoiceLane;

package/dist-lib/plugins/speech/voice-lane.js

@@ -0,0 +1,9 @@
+export function createVoiceLane() {
+    let tail = Promise.resolve();
+    return (job) => {
+        const run = tail.then(job);
+        tail = run.catch(noop);
+        return run;
+    };
+}
+function noop() { }

package/dist-lib/plugins/speech/voice.d.ts

@@ -0,0 +1,17 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { SpeakResult, VoiceSdk } from '../../lib/contract/speech.ts';
+import type { TtsEngine } from './speech-engine.ts';
+export declare function transcribeOnce(sdk: VoiceSdk, modelId: string, audio: Buffer): Promise<string>;
+export interface TranscribeStreamingOptions {
+    modelId: string;
+    signal?: BareAbortSignal | undefined;
+}
+export declare function transcribeStreaming(sdk: VoiceSdk, pcm: Uint8Array, { modelId, signal }: TranscribeStreamingOptions): Promise<string>;
+export interface SpeakOptions {
+    modelId: string;
+    engine?: TtsEngine;
+}
+export declare function speakStreamOnce(sdk: VoiceSdk, text: AsyncIterable<string>, { modelId, engine }: SpeakOptions): AsyncGenerator<SpeakResult>;
+export declare function speakable(text: string, engine?: TtsEngine): string;
+export declare function speakOnce(sdk: VoiceSdk, text: string, { modelId, engine }: SpeakOptions): Promise<SpeakResult>;
+export declare function packSamples(samples: number[]): Buffer;

package/dist-lib/{lib/capabilities → plugins/speech}/voice.js

@@ -1,17 +1,13 @@
 import b4a from 'b4a';
-import { errorMessage } from '../guards.js';
-import { AbortedError } from '../helpers/race-abort.js';
-import { hlog } from '../log.js';
-import { normalizeForSpeech } from './speech-text.js';
-export const SUPERTONIC_SAMPLE_RATE = 44100;
-export function createVoiceLane() {
-    let tail = Promise.resolve();
-    return (job) => {
-        const run = tail.then(job);
-        tail = run.catch(noop);
-        return run;
-    };
-}
+import { errorMessage } from '../../lib/guards.js';
+import { AbortedError } from '../../lib/helpers/race-abort.js';
+import { hlog } from '../../lib/log.js';
+import { normalizeForMoss, normalizeForSpeech } from './speech-text.js';
+const NATIVE_SAMPLE_RATE = { supertonic: 44100, moss: 24000 };
+const NORMALIZE = {
+    supertonic: normalizeForSpeech,
+    moss: normalizeForMoss
+};
 const TRANSCRIBE_SAMPLE_RATE = 16000;
 const TRANSCRIBE_CHUNK_BYTES = TRANSCRIBE_SAMPLE_RATE * 2;
 const PARAKEET_STREAMING = { emitPartials: false, chunkMs: 5000 };
@@ -106,7 +102,7 @@ export async function transcribeStreaming(sdk, pcm, { modelId, signal }) {
         signal?.removeEventListener('abort', onAbort);
     }
 }
-export async function* speakStreamOnce(sdk, modelId, text) {
+export async function* speakStreamOnce(sdk, text, { modelId, engine = 'supertonic' }) {
     const session = await sdk.textToSpeechStream({
         modelId,
         inputType: 'text',
@@ -117,7 +113,7 @@ export async function* speakStreamOnce(sdk, modelId, text) {
     const pump = (async () => {
         try {
             for await (const fragment of text) {
-                wrotePronounceable = writeSpeakable(session, fragment) || wrotePronounceable;
+                wrotePronounceable = writeSpeakable(session, fragment, engine) || wrotePronounceable;
             }
             session.end();
         }
@@ -132,7 +128,10 @@ export async function* speakStreamOnce(sdk, modelId, text) {
         for await (const frame of session) {
             if (frame.buffer.length) {
                 yieldedAudio = true;
-                yield { audio: packSamples(frame.buffer), sampleRate: SUPERTONIC_SAMPLE_RATE };
+                yield {
+                    audio: packSamples(frame.buffer),
+                    sampleRate: frame.sampleRate ?? NATIVE_SAMPLE_RATE[engine]
+                };
             }
         }
         await pump;
@@ -157,25 +156,25 @@ function destroyQuietly(session) {
     }
     catch { }
 }
-function writeSpeakable(session, fragment) {
-    const spoken = speakable(fragment);
-    if (!/[A-Za-z0-9]/.test(spoken)) {
+function writeSpeakable(session, fragment, engine) {
+    const spoken = speakable(fragment, engine);
+    if (!/[\p{L}\p{N}]/u.test(spoken)) {
         return false;
     }
     session.write(b4a.from(/^\s/.test(fragment) ? ` ${spoken}` : spoken, 'utf8'));
     return true;
 }
-export function speakable(text) {
-    const { text: spoken, dropped } = normalizeForSpeech(text);
+export function speakable(text, engine = 'supertonic') {
+    const { text: spoken, dropped } = NORMALIZE[engine](text);
     if (dropped.length) {
         hlog('tts dropped unspeakable characters', { chars: [...new Set(dropped)].join('') });
     }
     return spoken;
 }
-export async function speakOnce(sdk, modelId, text) {
-    const spoken = speakable(text);
+export async function speakOnce(sdk, text, { modelId, engine = 'supertonic' }) {
+    const spoken = speakable(text, engine);
     if (!spoken) {
-        return [];
+        return { audio: packSamples([]), sampleRate: NATIVE_SAMPLE_RATE[engine] };
     }
     const result = sdk.textToSpeech({ modelId, text: spoken, inputType: 'text', stream: true });
     const samples = [];
@@ -185,7 +184,10 @@ export async function speakOnce(sdk, modelId, text) {
     if (!(await result.done)) {
         throw new Error('tts synthesis did not complete');
     }
-    return samples;
+    return {
+        audio: packSamples(samples),
+        sampleRate: (await result.sampleRate) ?? NATIVE_SAMPLE_RATE[engine]
+    };
 }
 export function packSamples(samples) {
     const bytes = b4a.alloc(samples.length * 4);

package/dist-lib/plugins/translation/index.d.ts

@@ -0,0 +1,22 @@
+import type { HarnessPlugin, PluginContext, PluginSetup } from '../../lib/plugins/index.ts';
+import { type TranslationPlan, type TranslationRefusal } from './nmt-catalog.ts';
+export type { TranslationPlan, TranslationRefusal } from './nmt-catalog.ts';
+export declare class TranslationPlugin implements HarnessPlugin {
+    static readonly NMT_TO_ENGLISH: readonly string[];
+    static readonly NMT_FROM_ENGLISH: readonly string[];
+    static readonly EURONANO_LANGUAGES: readonly string[];
+    static readonly SLM_LANGUAGE_CODES: readonly string[];
+    static readonly SLM_LANGUAGE_NAMES: readonly {
+        code: string;
+        name: string;
+    }[];
+    static planFor(from: string, to: string): TranslationPlan | TranslationRefusal;
+    readonly name = "translation";
+    readonly api = 1;
+    readonly needs: string[];
+    readonly addons: {
+        translation: () => Promise<typeof import("@qvac/sdk/nmtcpp-translation/plugin")>;
+        'translation-nmtcpp': () => Promise<typeof import("@qvac/translation-nmtcpp/addonLogging")>;
+    };
+    setup(ctx: PluginContext): PluginSetup;
+}

package/dist-lib/plugins/translation/index.js

@@ -0,0 +1,63 @@
+import { cleanAnswer } from '../../lib/helpers/clean-answer.js';
+import { raceAbort } from '../../lib/helpers/race-abort.js';
+import { retryMemo } from '../../lib/helpers/retry-memo.js';
+import { PluginRegistry } from '../../lib/plugins/index.js';
+import { EURONANO_LANGUAGES, NMT_FROM_ENGLISH, NMT_TO_ENGLISH, SLM_LANGUAGE_CODES, SLM_LANGUAGE_NAMES, translationPlanFor } from './nmt-catalog.js';
+import { createTranslateTool, createTranslationRuntime } from './translate.js';
+function nmtSdk(models) {
+    return retryMemo(async () => {
+        const sdk = await models.sdk();
+        const [{ nmtPlugin }, { registerPlugin }] = await Promise.all([
+            import('@qvac/sdk/nmtcpp-translation/plugin'),
+            import('@qvac/sdk/plugins')
+        ]);
+        try {
+            registerPlugin(nmtPlugin);
+        }
+        catch { }
+        return sdk;
+    });
+}
+function slmTranslate(models) {
+    return async (model, { text, from, to }, signal) => {
+        const { modelId, release } = await models.completionModel(model, signal);
+        try {
+            const sdk = (await models.sdk());
+            const answer = await raceAbort(sdk.translate({ modelId, text, from, to, stream: false, modelType: 'llm' }).text, signal);
+            return cleanAnswer(answer, text);
+        }
+        finally {
+            release();
+        }
+    };
+}
+export class TranslationPlugin {
+    static NMT_TO_ENGLISH = NMT_TO_ENGLISH;
+    static NMT_FROM_ENGLISH = NMT_FROM_ENGLISH;
+    static EURONANO_LANGUAGES = EURONANO_LANGUAGES;
+    static SLM_LANGUAGE_CODES = SLM_LANGUAGE_CODES;
+    static SLM_LANGUAGE_NAMES = SLM_LANGUAGE_NAMES;
+    static planFor(from, to) {
+        return translationPlanFor(from, to);
+    }
+    name = 'translation';
+    api = PluginRegistry.API_VERSION;
+    needs = ['models'];
+    addons = {
+        translation: () => import('@qvac/sdk/nmtcpp-translation/plugin'),
+        'translation-nmtcpp': () => import('@qvac/translation-nmtcpp/addonLogging')
+    };
+    setup(ctx) {
+        const models = ctx.service('models');
+        const runtime = createTranslationRuntime({
+            loads: models,
+            loadSdk: nmtSdk(models),
+            onProgress: (model, progress) => models.emit(models.progressState(model, progress))
+        });
+        return {
+            capabilities: [createTranslateTool(runtime, { slm: slmTranslate(models) })],
+            unload: () => runtime.unload(),
+            unloadIdle: () => runtime.unloadIdle()
+        };
+    }
+}

package/dist-lib/{lib/models → plugins/translation}/nmt-catalog.d.ts

@@ -2,7 +2,6 @@ export declare const ENGLISH = "en";
 export declare const NMT_TO_ENGLISH: readonly string[];
 export declare const NMT_FROM_ENGLISH: readonly string[];
 export declare const SLM_MODEL = "TranslatePsy-AfriSLM-0.8B-Q4_K_M-imat";
-export declare function isTranslationModel(model: string): boolean;
 export declare const EURONANO_LANGUAGES: readonly string[];
 export declare const SLM_LANGUAGE_CODES: readonly string[];
 export declare function languageLabel(code: string): string | undefined;

package/dist-lib/{lib/models → plugins/translation}/nmt-catalog.js

@@ -75,9 +75,6 @@ const SLM_LANGUAGES = [
     { iso: 'zu', flores: 'zul_Latn', name: 'Zulu' }
 ];
 export const SLM_MODEL = 'TranslatePsy-AfriSLM-0.8B-Q4_K_M-imat';
-export function isTranslationModel(model) {
-    return /(^|[/\\])TranslatePsy-/.test(model);
-}
 const EURONANO = 'https://huggingface.co/qvac/TranslatePsy-EuroNano/resolve/main';
 const EURONANO_SIZE = 'Base';
 export const EURONANO_LANGUAGES = [

package/dist-lib/{lib/tools → plugins/translation}/translate.d.ts

@@ -1,9 +1,9 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { ToolDefinition } from '../capabilities/completion.ts';
-import type { ModelSrc } from '../models/context.ts';
-import { type NmtPlan } from '../models/nmt-catalog.ts';
-import { type LoadTracker, type TrackedLoad } from '../models/model-pool.ts';
-import { type ModelRegistrySdk } from '../models/model-source.ts';
+import type { ToolDefinition } from '../../lib/contract/index.ts';
+import type { ModelHost, TrackedLoad } from '../../lib/contract/models.ts';
+import type { ModelSrc } from '../../lib/models/context.ts';
+import { type ModelRegistrySdk } from '../../lib/models/model-source.ts';
+import { type NmtPlan } from './nmt-catalog.ts';
 interface BergamotConfig {
     engine: 'Bergamot';
     from: string;
@@ -32,6 +32,13 @@ export type TranslationSdk = ModelRegistrySdk & {
         text: string;
         stream: false;
         modelType: 'nmt';
+    } | {
+        modelId: string;
+        text: string;
+        from: string;
+        to: string;
+        stream: false;
+        modelType: 'llm';
     }): {
         text: Promise<string>;
     };
@@ -40,7 +47,7 @@ export declare const TRANSLATION_LOAD_STALL_MS: number;
 export declare const TRANSLATION_LOAD_STALL_ERROR = "translation model download stalled";
 export interface TranslationRuntimeOptions {
     loadSdk: () => Promise<TranslationSdk>;
-    loads?: LoadTracker;
+    loads?: Pick<ModelHost, 'track'>;
     onProgress?: (model: string, progress: Record<string, unknown>) => void;
     stallMs?: number;
 }
@@ -50,6 +57,7 @@ export interface TranslationRuntime {
         modelId: string;
     }>;
     unload: () => Promise<void>;
+    unloadIdle: () => Promise<void>;
     enter: (signal?: BareAbortSignal) => Promise<void>;
     exit: () => void;
 }

package/dist-lib/{lib/tools → plugins/translation}/translate.js

@@ -1,11 +1,10 @@
 import ScopeLock from 'scope-lock';
 import { getLangName } from '@qvac/langdetect-text';
-import { detectLanguage, UNDETERMINED } from '../capabilities/detect-language.js';
-import { AbortedError, raceAbort } from '../helpers/race-abort.js';
-import { ENGLISH, NMT_FROM_ENGLISH, NMT_TO_ENGLISH, languageLabel, SLM_LANGUAGE_CODES, sameLanguage, translationPlanFor } from '../models/nmt-catalog.js';
-import { createLoadStall } from '../helpers/load-stall.js';
-import { createLoadTracker } from '../models/model-pool.js';
-import { resolveModelSrc } from '../models/model-source.js';
+import { detectLanguage, UNDETERMINED } from '../../lib/capabilities/detect-language.js';
+import { createLoadStall } from '../../lib/helpers/load-stall.js';
+import { AbortedError, raceAbort } from '../../lib/helpers/race-abort.js';
+import { resolveModelSrc } from '../../lib/models/model-source.js';
+import { ENGLISH, NMT_FROM_ENGLISH, NMT_TO_ENGLISH, languageLabel, SLM_LANGUAGE_CODES, sameLanguage, translationPlanFor } from './nmt-catalog.js';
 export const TRANSLATION_LOAD_STALL_MS = 15 * 60_000;
 export const TRANSLATION_LOAD_STALL_ERROR = 'translation model download stalled';
 function packName(plan) {
@@ -26,9 +25,10 @@ function bergamotConfig(plan) {
     }
     return config;
 }
-export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(), onProgress, stallMs = TRANSLATION_LOAD_STALL_MS }) {
+export function createTranslationRuntime({ loadSdk, loads = { track: (pending) => pending }, onProgress, stallMs = TRANSLATION_LOAD_STALL_MS }) {
     let loading = null;
     let residentFingerprint = null;
+    let inFlight = 0;
     const lock = new ScopeLock();
     const turn = new ScopeLock();
     const loadPack = async (sdk, plan) => {
@@ -113,17 +113,23 @@ export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(),
             return raceAbort(loading, signal);
         },
         unload,
+        unloadIdle: () => (inFlight > 0 ? Promise.resolve() : unload()),
         enter: async (signal) => {
+            inFlight++;
             const pending = turn.lock();
             try {
                 await raceAbort(pending, signal);
             }
             catch (err) {
+                inFlight--;
                 void pending.then(() => turn.unlock());
                 throw err;
             }
         },
-        exit: () => turn.unlock()
+        exit: () => {
+            inFlight--;
+            turn.unlock();
+        }
     };
 }
 export function stripLanguageLabel(text, ...codes) {

package/dist-lib/plugins/walkie-talkie/crew.d.ts

@@ -0,0 +1,27 @@
+import type { TargetResult, TargetUsage } from '../../lib/agent/index.ts';
+import type { ToolDefinition, ToolExecuteContext } from '../../lib/contract/index.ts';
+import type { AgentInfo } from './wire.ts';
+export type Attachments = Record<string, Buffer>;
+export interface Outgoing {
+    text: string;
+    attachments?: Attachments;
+}
+export interface Reply {
+    status: TargetResult['status'];
+    text: string;
+    attachments?: Attachments;
+    usage?: TargetUsage;
+}
+export interface CrewOptions {
+    attach?: (ctx: ToolExecuteContext | undefined) => Promise<Attachments>;
+    receive?: (reply: Reply, from: string, ctx: ToolExecuteContext | undefined) => Promise<string | null>;
+}
+export interface Crew {
+    tools: ToolDefinition[];
+    stop(): void;
+}
+export interface Roster {
+    agents(): AgentInfo[];
+    send(to: string, outgoing: Outgoing, signal: AbortSignal): Promise<Reply>;
+}
+export declare function crew(roster: Roster, { attach, receive }?: CrewOptions): Crew;