@qvac/harness 0.2.12 → 0.3.0

package/dist-lib/index.d.ts

@@ -3,6 +3,7 @@ import ReadyResource from 'ready-resource';
 import { type Agent, type ApproveFn, type AskUserFn, type AttachFn, type CompletionEvent, type FetchAttachmentFn, type Message, type ProgressFn, type RagSearchFn, type ResponseFormat, type ToolDefinition, type ToolExecuteContext } from './lib/capabilities/completion.ts';
 import { type DetectLanguageContext, type DetectedLanguage } from './lib/capabilities/detect-language.ts';
 import { type Capability } from './lib/capabilities/invoke.ts';
+import { type EnhanceMode } from './lib/capabilities/enhance.ts';
 import { type DownloadArgs, type DownloadEventStream } from './lib/capabilities/download.ts';
 import { type EmbedContext } from './lib/capabilities/embed.ts';
 import { type KvCacheDeletionResult } from './lib/capabilities/kv-cache.ts';
@@ -25,6 +26,8 @@ import { type SkillSettingEntry } from './lib/tools/skills/skill-settings.ts';
 export * from './lib/capabilities/completion.ts';
 export { attachmentTurn, loadedSkillsFrom, skillLoadedTurn } from './lib/capabilities/tool-turns.ts';
 export { CAPABILITIES, isCapability, type Capability } from './lib/capabilities/invoke.ts';
+export type { EnhanceMode } from './lib/capabilities/enhance.ts';
+export { EURONANO_LANGUAGES, NMT_FROM_ENGLISH, NMT_TO_ENGLISH, SLM_LANGUAGE_CODES, SLM_LANGUAGE_NAMES, translationPlanFor, type TranslationPlan } from './lib/models/nmt-catalog.ts';
 export type { DetectLanguageContext, DetectedLanguage } from './lib/capabilities/detect-language.ts';
 export * from './lib/capabilities/download.ts';
 export type { EmbedContext } from './lib/capabilities/embed.ts';
@@ -113,6 +116,7 @@ export interface CompletionContext {
 export interface InvokeContext {
     capability: Capability;
     args: Record<string, unknown>;
+    enhance?: EnhanceMode;
     agent?: Agent;
     attach?: AttachFn;
     fetchAttachment?: FetchAttachmentFn;
@@ -157,7 +161,10 @@ export declare class Harness extends ReadyResource {
     private _diffusionSdk;
     private _imageRuntime;
     private _musicSdk;
+    private _translationSdk;
     private _musicRuntime;
+    private _translationRuntime;
+    private _capabilityTools;
     private _capability;
     private _capabilityInflight;
     private readonly _modelFaults;
@@ -210,6 +217,8 @@ export declare class Harness extends ReadyResource {
     private _loadedModels;
     private _loadPluginSdk;
     private _loadDiffusionSdk;
+    private _slmTranslate;
+    private _loadTranslationSdk;
     private _loadMusicSdk;
     private _deviceConfig;
     private _createPool;
@@ -254,8 +263,9 @@ export declare class Harness extends ReadyResource {
         agent?: Agent;
         signal?: BareAbortSignal;
     }): Promise<void>;
-    invoke({ capability, args, agent, attach, fetchAttachment, progress, signal }: InvokeContext): AsyncGenerator<CompletionEvent>;
+    invoke({ capability, args, enhance, agent, attach, fetchAttachment, progress, signal }: InvokeContext): AsyncGenerator<CompletionEvent>;
     completion({ model, agent, messages, cacheKey, thinkingDefault, toolConfigs, generationParams, responseFormat, captureInferenceCalls, grantedDirs, grantedDrives, driveOp, grantedWriteDirs, approve, attach, fetchAttachment, ragSearch, progress, askUser, signal }: CompletionContext): AsyncGenerator<CompletionEvent>;
+    private _residentEnhancer;
     private _makeRoomForCompletion;
     private _evictWedgedModel;
     private _evictAfterLeases;

package/dist-lib/index.js

@@ -8,6 +8,10 @@ import { closePythonWorker } from './lib/tools/exec/adapters/python/worker/clien
 import { completion, imageSettingsFrom } from './lib/capabilities/completion.js';
 import { detectLanguage } from './lib/capabilities/detect-language.js';
 import { invoke } from './lib/capabilities/invoke.js';
+import { expandImagePrompt } from './lib/capabilities/enhance.js';
+import { cleanAnswer } from './lib/helpers/clean-answer.js';
+import { isTranslationModel } from './lib/models/nmt-catalog.js';
+import { createTranslateTool, createTranslationRuntime } from './lib/tools/translate.js';
 import { download } from './lib/capabilities/download.js';
 import { createEmbedLane } from './lib/capabilities/embed.js';
 import { deleteAllKvCaches, deleteKvCacheKey } from './lib/capabilities/kv-cache.js';
@@ -19,7 +23,7 @@ import { AbortedError, raceAbort } from './lib/helpers/race-abort.js';
 import { audioGenDownloadMetadata, customProjectionMap, defaultProjectionMap, defaultTtsFor, defaultVoiceModel, diffusionDownloadMetadata, infraModelsFor, modelNameToCapabilityProfile, musicModelSet, setCustomModels } from './lib/models/model-catalog.js';
 import { createModelStatusCache, invalidateModelStatusCache, listModels } from './lib/models/model-list.js';
 import { deleteModelFiles, summarizeDelete } from './lib/models/model-delete.js';
-import { createEmbedPool, createLoadTracker, createModelPool, createVoicePool, awaitModelCapacity, evictIdle, evictModelWithin, isResident, leaseCount, loadedModels, modelKey, releaseModel, resolveLoadOptions, progressState } from './lib/models/model-pool.js';
+import { createEmbedPool, createLoadTracker, createModelPool, createVoicePool, awaitModelCapacity, evictIdle, evictModelWithin, isResident, leaseResidentModel, leaseCount, loadedModels, modelKey, releaseModel, resolveLoadOptions, progressState } from './lib/models/model-pool.js';
 import { resolveMainGpu } from './lib/models/gpu-selection.js';
 import { openclCacheDir } from './lib/models/opencl-cache.js';
 import { assertEmbedDevice, createEmbedConfig } from './lib/models/embed-config.js';
@@ -48,6 +52,7 @@ import { settingsScopeKey } from './lib/tools/skills/skill-settings.js';
 export * from './lib/capabilities/completion.js';
 export { attachmentTurn, loadedSkillsFrom, skillLoadedTurn } from './lib/capabilities/tool-turns.js';
 export { CAPABILITIES, isCapability } from './lib/capabilities/invoke.js';
+export { EURONANO_LANGUAGES, NMT_FROM_ENGLISH, NMT_TO_ENGLISH, SLM_LANGUAGE_CODES, SLM_LANGUAGE_NAMES, translationPlanFor } from './lib/models/nmt-catalog.js';
 export * from './lib/capabilities/download.js';
 export * from './lib/models/model-catalog.js';
 export * from './lib/models/model-list.js';
@@ -119,7 +124,10 @@ export class Harness extends ReadyResource {
     _diffusionSdk;
     _imageRuntime;
     _musicSdk;
+    _translationSdk;
     _musicRuntime;
+    _translationRuntime;
+    _capabilityTools;
     _capability = null;
     _capabilityInflight = null;
     _modelFaults = new Map();
@@ -204,6 +212,16 @@ export class Harness extends ReadyResource {
                 }
             })
             : null;
+        this._translationRuntime = createTranslationRuntime({
+            loads: this._loads,
+            loadSdk: () => this._loadTranslationSdk(),
+            onProgress: (model, progress) => this.emit('model', progressState(model, progress))
+        });
+        this._capabilityTools = [
+            createTranslateTool(this._translationRuntime, {
+                slm: (...args) => this._slmTranslate(...args)
+            })
+        ];
         this._tools = [
             ...tools,
             ...(this._imageRuntime
@@ -223,6 +241,7 @@ export class Harness extends ReadyResource {
         this._platform = platform;
         this._diffusionSdk = null;
         this._musicSdk = null;
+        this._translationSdk = null;
     }
     async _open() {
         installResolutionDetector(import.meta);
@@ -516,6 +535,27 @@ export class Harness extends ReadyResource {
             this._diffusionSdk = sdk;
         }, () => import('@qvac/sdk/sdcpp-generation/plugin').then((m) => m.diffusionPlugin));
     }
+    async _slmTranslate(model, { text, from, to }, signal) {
+        const loadOpts = resolveLoadOptions({}, this._deviceConfig());
+        const key = modelKey(model, loadOpts);
+        const pool = this._models;
+        if (!isResident(pool, key))
+            await this._makeRoomForCompletion(signal);
+        try {
+            const { modelId } = await raceAbort(pool.open(key, model, loadOpts).load(), signal);
+            const sdk = await this._sdk.load();
+            const answer = await raceAbort(sdk.translate({ modelId, text, from, to, stream: false, modelType: 'llm' }).text, signal);
+            return cleanAnswer(answer, text);
+        }
+        finally {
+            releaseModel(pool, key);
+        }
+    }
+    _loadTranslationSdk() {
+        return this._loadPluginSdk(() => this._translationSdk, (sdk) => {
+            this._translationSdk = sdk;
+        }, () => import('@qvac/sdk/nmtcpp-translation/plugin').then((m) => m.nmtPlugin));
+    }
     _loadMusicSdk() {
         return this._loadPluginSdk(() => this._musicSdk, (sdk) => {
             this._musicSdk = sdk;
@@ -648,7 +688,8 @@ export class Harness extends ReadyResource {
             this._ttsModels.destroy(),
             this._transcriptionModels.destroy(),
             this._imageRuntime?.unload(),
-            this._musicRuntime?.unload()
+            this._musicRuntime?.unload(),
+            this._translationRuntime.unload()
         ]);
         for (const outcome of released) {
             if (outcome.status !== 'rejected')
@@ -949,17 +990,19 @@ export class Harness extends ReadyResource {
             releaseModel(pool, key);
         }
     }
-    async *invoke({ capability, args, agent, attach, fetchAttachment, progress, signal }) {
+    async *invoke({ capability, args, enhance, agent, attach, fetchAttachment, progress, signal }) {
         if (!this.opened)
             await this.ready();
         if (this.suspended)
             return yield { type: 'aborted' };
-        hlog('invoke start', { capability });
+        hlog('invoke start', { capability, enhance });
         try {
             yield* invoke({
                 capability,
                 args,
-                tools: this._tools,
+                enhance,
+                enhancer: this._residentEnhancer(),
+                tools: [...this._tools, ...this._capabilityTools],
                 ctx: {
                     image: imageSettingsFrom(agent),
                     attach,
@@ -1089,6 +1132,24 @@ export class Harness extends ReadyResource {
             void this._musicRuntime?.unloadIdle().catch(noop);
         }
     }
+    _residentEnhancer() {
+        return async (prompt, signal) => {
+            const lease = await leaseResidentModel(this._models, (model) => !isTranslationModel(model));
+            if (!lease)
+                return null;
+            try {
+                const sdk = await this._sdk.load();
+                return await expandImagePrompt(sdk, lease.modelId, lease.model, prompt, signal);
+            }
+            catch (err) {
+                hlog('enhance failed', { err: err instanceof Error ? err.message : String(err) });
+                return null;
+            }
+            finally {
+                lease.release();
+            }
+        };
+    }
     async _makeRoomForCompletion(signal, deadlineMs = MODEL_ROOM_WAIT_MS) {
         const roomed = await awaitModelCapacity(this._models, this._completionModelCap, deadlineMs, 250, signal);
         if (!roomed) {

package/dist-lib/lib/capabilities/completion.d.ts

@@ -222,6 +222,8 @@ export type MetricsEvent = {
     ctxSize?: number | undefined;
     backends?: RunBackendUse[] | undefined;
     usage?: UsageBreakdown | undefined;
+    route?: 'direct' | 'enhanced' | undefined;
+    routeModel?: string | undefined;
     stopReason?: string | undefined;
 };
 export interface InferenceCall {

package/dist-lib/lib/capabilities/enhance.d.ts

@@ -0,0 +1,10 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { CompletionSdk } from './completion.ts';
+export type EnhanceMode = 'never' | 'auto';
+export interface EnhanceResult {
+    text: string;
+    model: string;
+    totalTokens?: number;
+}
+export type Enhancer = (prompt: string, signal?: BareAbortSignal) => Promise<EnhanceResult | null>;
+export declare function expandImagePrompt(sdk: CompletionSdk, modelId: string, model: string, prompt: string, signal?: BareAbortSignal): Promise<EnhanceResult | null>;

package/dist-lib/lib/capabilities/enhance.js

@@ -0,0 +1,29 @@
+import { cleanAnswer } from '../helpers/clean-answer.js';
+import { raceAbort } from '../helpers/race-abort.js';
+const SYSTEM = "Rewrite the user's description as a single vivid prompt for an image generator. " +
+    'Answer with the prompt alone: no preamble, no quotes, no explanation.';
+const MAX_PROMPT_CHARS = 400;
+export async function expandImagePrompt(sdk, modelId, model, prompt, signal) {
+    const run = sdk.completion({
+        modelId,
+        history: [
+            { role: 'system', content: SYSTEM },
+            { role: 'user', content: prompt }
+        ],
+        stream: true,
+        generationParams: { temp: 0.7, reasoning_budget: 0 }
+    });
+    let final;
+    try {
+        final = await raceAbort(run.final, signal);
+    }
+    catch (err) {
+        if (run.requestId)
+            void sdk.cancel?.({ requestId: run.requestId }).catch(() => { });
+        throw err;
+    }
+    const text = cleanAnswer(final.contentText).slice(0, MAX_PROMPT_CHARS);
+    if (!text)
+        return null;
+    return { text, model, totalTokens: final.stats?.generatedTokens };
+}

package/dist-lib/lib/capabilities/invoke.d.ts

@@ -1,6 +1,13 @@
 import type { CompletionEvent, ToolDefinition, ToolExecuteContext } from './completion.ts';
+import type { EnhanceMode, Enhancer } from './enhance.ts';
 declare const CAPABILITY_TOOLS: {
-    readonly image: 'generate_image';
+    readonly image: {
+        readonly tool: 'generate_image';
+        readonly enhances: 'prompt';
+    };
+    readonly translate: {
+        readonly tool: 'translate';
+    };
 };
 export type Capability = keyof typeof CAPABILITY_TOOLS;
 export declare const CAPABILITIES: Capability[];
@@ -10,6 +17,8 @@ export interface InvokeOptions {
     args: Record<string, unknown>;
     tools: readonly ToolDefinition[];
     ctx: ToolExecuteContext;
+    enhance?: EnhanceMode;
+    enhancer?: Enhancer;
 }
-export declare function invoke({ capability, args, tools, ctx }: InvokeOptions): AsyncGenerator<CompletionEvent>;
+export declare function invoke({ capability, args, tools, ctx, enhance, enhancer }: InvokeOptions): AsyncGenerator<CompletionEvent>;
 export {};

package/dist-lib/lib/capabilities/invoke.js

@@ -1,25 +1,43 @@
 import { AbortedError } from '../helpers/race-abort.js';
 const CAPABILITY_TOOLS = {
-    image: 'generate_image'
+    image: { tool: 'generate_image', enhances: 'prompt' },
+    translate: { tool: 'translate' }
 };
 export const CAPABILITIES = Object.keys(CAPABILITY_TOOLS);
 export function isCapability(name) {
     return name in CAPABILITY_TOOLS;
 }
-export async function* invoke({ capability, args, tools, ctx }) {
-    const name = CAPABILITY_TOOLS[capability];
-    const tool = tools.find((candidate) => candidate.name === name);
+export async function* invoke({ capability, args, tools, ctx, enhance = 'never', enhancer }) {
+    const entry = CAPABILITY_TOOLS[capability];
+    const tool = tools.find((candidate) => candidate.name === entry.tool);
     if (!tool) {
         yield { type: 'error', message: `${capability} is not available on this device` };
         return;
     }
     const startedAt = Date.now();
-    yield { type: 'tool-call', name, args, effect: tool.effect(args, ctx) };
+    const field = 'enhances' in entry ? entry.enhances : null;
+    let routeModel;
+    let totalTokens = 0;
+    let called = args;
+    if (enhance === 'auto' && field && enhancer) {
+        const source = called[field];
+        if (typeof source === 'string' && source) {
+            const enhanced = await enhancer(source, ctx.signal);
+            if (enhanced) {
+                called = { ...called, [field]: enhanced.text };
+                routeModel = enhanced.model;
+                totalTokens = enhanced.totalTokens ?? 0;
+            }
+        }
+    }
+    if (ctx.signal?.aborted)
+        return yield { type: 'aborted' };
+    yield { type: 'tool-call', name: entry.tool, args: called, effect: tool.effect(called, ctx) };
     try {
-        const result = await tool.execute(args, ctx);
+        const result = await tool.execute(called, ctx);
         if (ctx.signal?.aborted)
             return yield { type: 'aborted' };
-        yield { type: 'tool-result', name, result };
+        yield { type: 'tool-result', name: entry.tool, result };
     }
     catch (err) {
         if (err instanceof AbortedError || ctx.signal?.aborted) {
@@ -29,5 +47,11 @@ export async function* invoke({ capability, args, tools, ctx }) {
         yield { type: 'error', message: err instanceof Error ? err.message : String(err) };
         return;
     }
-    yield { type: 'metrics', totalTokens: 0, durationMs: Date.now() - startedAt };
+    yield {
+        type: 'metrics',
+        totalTokens,
+        durationMs: Date.now() - startedAt,
+        route: routeModel ? 'enhanced' : 'direct',
+        routeModel
+    };
 }

package/dist-lib/lib/connect.js

@@ -117,6 +117,7 @@ export class RemoteHarness extends EventEmitter {
             type: 'invoke',
             capability: context.capability,
             arguments: context.args,
+            enhance: context.enhance,
             agent: knobs(agent)
         }, {
             model: '',

package/dist-lib/lib/contract-types.d.ts

@@ -71,6 +71,7 @@ export interface CompletionContext {
 export interface InvokeContext {
     capability: string;
     args: Record<string, unknown>;
+    enhance?: 'never' | 'auto';
     agent?: AgentKnobs;
     attach?: AttachFn;
     fetchAttachment?: FetchAttachmentFn;

package/dist-lib/lib/helpers/clean-answer.d.ts

@@ -0,0 +1 @@
+export declare function cleanAnswer(raw: string, source?: string): string;

package/dist-lib/lib/helpers/clean-answer.js

@@ -0,0 +1,16 @@
+import { unwrap } from 'asenion';
+import { firstMarker, markers, truncateAt } from 'asenion/guards';
+const LEAKS = [
+    ...markers.controlTokens,
+    ...markers.turnEnd,
+    ...markers.thinking,
+    ...markers.toolMarkup,
+    ...markers.scaffold
+];
+const THINKING_CLOSE = markers.thinking.filter((marker) => marker.startsWith('</'));
+export function cleanAnswer(raw, source = '') {
+    const close = firstMarker(raw, THINKING_CLOSE);
+    const body = close ? raw.slice(close.index + close.marker.length) : raw;
+    const text = truncateAt(body, LEAKS).trim();
+    return unwrap(source) === source ? unwrap(text) : text;
+}

package/dist-lib/lib/helpers/load-stall.d.ts

@@ -0,0 +1,6 @@
+export interface LoadStall {
+    bump: () => void;
+    clear: () => void;
+    promise: Promise<never>;
+}
+export declare function createLoadStall(ms: number, message: string): LoadStall;

package/dist-lib/lib/helpers/load-stall.js

@@ -0,0 +1,24 @@
+export function createLoadStall(ms, message) {
+    let timer = null;
+    let rejectStall = null;
+    const promise = new Promise((_, reject) => {
+        rejectStall = reject;
+    });
+    const arm = () => {
+        if (timer !== null)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            rejectStall?.(new Error(message));
+        }, ms);
+    };
+    arm();
+    return {
+        bump: arm,
+        clear: () => {
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = null;
+        },
+        promise
+    };
+}

package/dist-lib/lib/models/model-pool.d.ts

@@ -69,6 +69,12 @@ export interface LoadedModel {
 type PoolLike = ReturnType<typeof createModelPool>;
 export declare function releaseModel(pool: PoolLike, key: string): void;
 export declare function loadedModels(pool: PoolLike): LoadedModel[];
+export interface ResidentLease {
+    model: string;
+    modelId: string;
+    release: () => void;
+}
+export declare function leaseResidentModel(pool: PoolLike, wanted?: (model: string) => boolean): Promise<ResidentLease | null>;
 export declare function isResident(pool: PoolLike, key: string): boolean;
 export declare function leaseCount(pool: PoolLike, key: string): number;
 export declare function evictIdle(pool: PoolLike): Promise<void>;

package/dist-lib/lib/models/model-pool.js

@@ -91,6 +91,18 @@ export function loadedModels(pool) {
     }
     return out;
 }
+export async function leaseResidentModel(pool, wanted = () => true) {
+    for (const entry of pool.resources.values()) {
+        const key = entry.id;
+        const pending = entry.value.peek();
+        if (!pending || entry.value.loading || !wanted(key.split('\0')[0]))
+            continue;
+        pool.open(key);
+        const loaded = await pending;
+        return { model: loaded.model, modelId: loaded.modelId, release: () => releaseModel(pool, key) };
+    }
+    return null;
+}
 export function isResident(pool, key) {
     const handle = entryOf(pool, key)?.value;
     return handle !== undefined && handle.peek() !== null;

package/dist-lib/lib/models/nmt-catalog.d.ts

@@ -0,0 +1,34 @@
+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;
+export declare const SLM_LANGUAGE_NAMES: ReadonlyArray<{
+    code: string;
+    name: string;
+}>;
+export declare function slmLanguage(code: string): string | undefined;
+export interface NmtPlan {
+    route: 'nmt';
+    from: string;
+    to: string;
+    model: string;
+    pivot?: string;
+    srcVocab?: string;
+    dstVocab?: string;
+    tag?: string;
+}
+export interface SlmPlan {
+    route: 'slm';
+    from: string;
+    to: string;
+    model: string;
+}
+export type TranslationPlan = NmtPlan | SlmPlan;
+export declare function sameLanguage(from: string, to: string): boolean;
+export declare function translationPlanFor(requestedFrom: string, requestedTo: string): TranslationPlan | {
+    error: string;
+};

package/dist-lib/lib/models/nmt-catalog.js

@@ -0,0 +1,166 @@
+export const ENGLISH = 'en';
+const TO_ENGLISH = [
+    'ar',
+    'az',
+    'be',
+    'bg',
+    'bn',
+    'bs',
+    'ca',
+    'cs',
+    'da',
+    'de',
+    'el',
+    'es',
+    'et',
+    'fa',
+    'fi',
+    'fr',
+    'gu',
+    'he',
+    'hi',
+    'hr',
+    'hu',
+    'id',
+    'is',
+    'it',
+    'ja',
+    'kn',
+    'ko',
+    'lt',
+    'lv',
+    'ml',
+    'ms',
+    'mt',
+    'nb',
+    'nl',
+    'nn',
+    'no',
+    'pl',
+    'pt',
+    'ro',
+    'ru',
+    'sk',
+    'sl',
+    'sq',
+    'sr',
+    'sv',
+    'ta',
+    'te',
+    'th',
+    'tr',
+    'uk',
+    'vi',
+    'zh'
+];
+const FROM_ENGLISH = TO_ENGLISH.filter((code) => !['be', 'mt', 'nn'].includes(code));
+export const NMT_TO_ENGLISH = TO_ENGLISH;
+export const NMT_FROM_ENGLISH = FROM_ENGLISH;
+const SLM_LANGUAGES = [
+    { iso: 'af', flores: 'afr_Latn', name: 'Afrikaans' },
+    { iso: 'am', flores: 'amh_Ethi', name: 'Amharic' },
+    { iso: 'ha', flores: 'hau_Latn', name: 'Hausa' },
+    { iso: 'ig', flores: 'ibo_Latn', name: 'Igbo' },
+    { iso: 'rw', flores: 'kin_Latn', name: 'Kinyarwanda' },
+    { iso: 'mg', flores: 'plt_Latn', name: 'Malagasy' },
+    { iso: 'ny', flores: 'nya_Latn', name: 'Nyanja' },
+    { iso: 'om', flores: 'gaz_Latn', name: 'Oromo' },
+    { iso: 'sn', flores: 'sna_Latn', name: 'Shona' },
+    { iso: 'so', flores: 'som_Latn', name: 'Somali' },
+    { iso: 'st', flores: 'sot_Latn', name: 'Southern Sotho' },
+    { iso: 'sw', flores: 'swh_Latn', name: 'Swahili' },
+    { iso: 'tn', flores: 'tsn_Latn', name: 'Tswana' },
+    { iso: 'xh', flores: 'xho_Latn', name: 'Xhosa' },
+    { iso: 'yo', flores: 'yor_Latn', name: 'Yoruba' },
+    { 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 = [
+    'cs',
+    'de',
+    'es',
+    'fi',
+    'fr',
+    'it',
+    'nl',
+    'pt',
+    'sv'
+];
+function euroNanoPack(direction) {
+    const dir = `${EURONANO}/${direction}/${EURONANO_SIZE}/intgemm`;
+    return { model: `${dir}/model.intgemm.alphas.bin`, vocab: `${dir}/vocab.spm` };
+}
+export const SLM_LANGUAGE_CODES = SLM_LANGUAGES.map((entry) => entry.iso);
+export function languageLabel(code) {
+    const wanted = code.toLowerCase();
+    return SLM_LANGUAGES.find((entry) => entry.flores.toLowerCase() === wanted || entry.iso === wanted)?.name;
+}
+export const SLM_LANGUAGE_NAMES = SLM_LANGUAGES.map(({ iso, name }) => ({ code: iso, name }));
+export function slmLanguage(code) {
+    const wanted = code.toLowerCase();
+    return SLM_LANGUAGES.find((entry) => entry.flores.toLowerCase() === wanted || entry.iso === wanted)?.flores;
+}
+const modelFilter = (pair) => `model.${pair}.intgemm`;
+export function sameLanguage(from, to) {
+    return canonical(from) === canonical(to);
+}
+function canonical(code) {
+    return slmLanguage(code) ?? code.toLowerCase();
+}
+export function translationPlanFor(requestedFrom, requestedTo) {
+    const from = requestedFrom.toLowerCase();
+    const to = requestedTo.toLowerCase();
+    if (sameLanguage(from, to))
+        return { error: `${from} is already the target language` };
+    const slmFrom = slmLanguage(from);
+    const slmTo = slmLanguage(to);
+    if (slmFrom || slmTo) {
+        return { route: 'slm', from: slmFrom ?? from, to: slmTo ?? to, model: SLM_MODEL };
+    }
+    if (to === ENGLISH && EURONANO_LANGUAGES.includes(from)) {
+        const pack = euroNanoPack('xx-en');
+        return {
+            route: 'nmt',
+            from,
+            to,
+            model: pack.model,
+            srcVocab: pack.vocab,
+            dstVocab: pack.vocab
+        };
+    }
+    if (from === ENGLISH && EURONANO_LANGUAGES.includes(to)) {
+        const pack = euroNanoPack('en-xx');
+        return {
+            route: 'nmt',
+            from,
+            to,
+            model: pack.model,
+            srcVocab: pack.vocab,
+            dstVocab: pack.vocab,
+            tag: `##${to.toUpperCase()}`
+        };
+    }
+    if (to === ENGLISH) {
+        if (!TO_ENGLISH.includes(from))
+            return { error: `cannot translate from ${from}` };
+        return { route: 'nmt', from, to, model: modelFilter(`${from}${ENGLISH}`) };
+    }
+    if (!FROM_ENGLISH.includes(to))
+        return { error: `cannot translate to ${to}` };
+    if (from === ENGLISH)
+        return { route: 'nmt', from, to, model: modelFilter(`${ENGLISH}${to}`) };
+    if (!TO_ENGLISH.includes(from))
+        return { error: `cannot translate from ${from}` };
+    return {
+        route: 'nmt',
+        from,
+        to,
+        model: modelFilter(`${from}${ENGLISH}`),
+        pivot: modelFilter(`${ENGLISH}${to}`)
+    };
+}

package/dist-lib/lib/serve.js

@@ -296,6 +296,7 @@ function runFrame(harness, frame, context) {
     return harness.invoke({
         capability,
         args: frame.arguments ?? {},
+        enhance: frame.enhance === 'auto' ? 'auto' : 'never',
         agent: frame.agent ?? undefined,
         attach: context.attach,
         fetchAttachment: context.fetchAttachment,