@qvac/harness 0.2.12 → 0.3.1

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';
@@ -41,7 +44,7 @@ export { requiredSettings, settingEnvName, type SkillSettingEntry, type SkillSet
 export type { ToolCatalogEntry } from './lib/tools/catalog.ts';
 export { TOOLSETS, toolsetEnabled, type Toolset } from './lib/tools/toolsets.ts';
 export { markCredentialRejected, markCredentialValid, recordCredentialHealth, resetAllCredentialHealth, resetCredentialHealth } from './lib/tools/skills/credential-health.ts';
-export type { InstallStep, SkillOAuthConfig, SkillRequires, SkillSetup, SkillSetupField, SkillSetupRoute } from './lib/tools/skills/manifest.ts';
+export type { InstallStep, SkillOAuthConfig, SkillOAuthVerify, SkillOAuthVerifyRule, SkillRequires, SkillSetup, SkillSetupField, SkillSetupRoute } from './lib/tools/skills/manifest.ts';
 export { readSetup as normalizeSkillSetup } from './lib/tools/skills/manifest-parse.ts';
 export type { CredentialRecord, CredentialStoreValue } from './lib/tools/skills/auth-resolver.ts';
 export { isAvailableState, SKILL_STATE, type SkillState } from './lib/tools/skills/skill-state.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

@@ -139,6 +139,9 @@ export interface ToolExecuteContext {
     toolOps?: ReadonlyMap<string, readonly CliValidator[]> | undefined;
     runBudget?: RunBudget | undefined;
     reportBackend?: ((use: RunBackendUse) => void) | undefined;
+    uncappedResponse?: boolean | undefined;
+    sandboxMode?: boolean | undefined;
+    toolNames?: readonly string[] | undefined;
 }
 export interface RunBackendUse {
     tool: string;
@@ -222,6 +225,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/completion.js

@@ -19,6 +19,7 @@ import { annotateLastUserTime, skillsPromptSection, systemPromptParts } from '..
 import { isMetadataMethod } from '../tools/mcp/utils.js';
 import { unquoteArg } from '../tools/model-args.js';
 import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from './tool-names.js';
+import { mainFileRequested, skillFileArg, skillFileStem } from '../tools/skill.js';
 import { promptUsageParts, usageBreakdown } from './usage-breakdown.js';
 import { collectToolGrants, enabledTools, isSelected, skillIsActive, skillsAreSelected } from './tool-selection.js';
 import { guardToolCall } from '../tools/outbound-guard.js';
@@ -709,6 +710,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             ? { ...resolvedGenerationParams, ...generationParamsOverride }
             : resolvedGenerationParams;
         const loadedThisTurn = new Set();
+        const loadedFilesThisTurn = new Set();
+        const fileKey = (skill, file) => `${skill}\0${skillFileStem(file)}`;
         let skillIcon = null;
         const skillEmoji = (name) => skillCatalog.find((entry) => entry.name === name)?.emoji ?? null;
         const nudgedSkills = new Set();
@@ -1004,13 +1007,20 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     toolOps: grantedOps,
                     fsRoots,
                     fsWriteRoots: writableRoots,
-                    reportBackend: (use) => stats.backends.push(use)
+                    reportBackend: (use) => stats.backends.push(use),
+                    sandboxMode: agent?.sandboxMode === true,
+                    toolNames: enabled.map((tool) => tool.name)
                 };
                 const skillCall = call.name === SKILL_TOOL_NAME;
                 const effect = tool?.effect(args, callCtx) ?? (skillCall ? 'read' : undefined);
                 const resource = tool?.resource?.(args) ?? null;
                 const skillName = unquoteArg(args?.name ?? args?.skill_name ?? args?.skill);
-                const skillReloaded = tool?.name === SKILL_TOOL_NAME && !args?.file && loadedThisTurn.has(skillName);
+                const askedFile = skillFileArg(args);
+                const mainRequested = mainFileRequested(skillName, askedFile);
+                const skillReloaded = tool?.name === SKILL_TOOL_NAME &&
+                    (mainRequested
+                        ? loadedThisTurn.has(skillName)
+                        : loadedFilesThisTurn.has(fileKey(skillName, unquoteArg(askedFile))));
                 const silent = searchCapped || skillReloaded || priorFailure !== undefined;
                 const display = silent
                     ? undefined
@@ -1034,9 +1044,10 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     execution = terminalCall(priorFailure.result, priorFailure.outcome, { executed: false });
                 }
                 else if (skillReloaded) {
+                    const loadedWhat = mainRequested ? skillName : `${skillName} ${unquoteArg(askedFile)}`;
                     execution = terminalCall({
                         name: skillName,
-                        content: `${skillName} is already loaded. Follow the instructions you were given and do not load it again.`
+                        content: `${loadedWhat} is already loaded. Follow the instructions you were given and do not load it again.`
                     }, { kind: 'guidance', message: `${skillName} is already loaded.` }, { executed: false });
                 }
                 else if (skillBlocked) {
@@ -1105,9 +1116,10 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                         files.add(output.file);
                         loadedSkillFiles.set(skillName, files);
                     }
-                    else {
+                    if (mainRequested)
                         loadedThisTurn.add(skillName);
-                    }
+                    else
+                        loadedFilesThisTurn.add(fileKey(skillName, unquoteArg(askedFile)));
                     skillIcon = skillEmoji(skillName) ?? skillIcon;
                 }
                 if (!activity &&

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/helpers/tool-call-markup.js

@@ -1,7 +1,7 @@
 const FUNCTION_OPEN = '<function=';
 const FUNCTION_CLOSE = '</function>';
-const RESPONSE_OPEN = '<tool_response>';
-const RESPONSE_CLOSE = '</tool_response>';
+const TOOL_RESPONSE = { open: '<tool_response>', close: '</tool_response>' };
+const TOOL_CALL = { open: '<tool_call>', close: '</tool_call>' };
 const PARAMETER_OPEN = '<parameter=';
 const PARAMETER_CLOSE = '</parameter>';
 const MAX_NAME_LENGTH = 64;
@@ -66,26 +66,34 @@ export function stripToolCallMarkup(text) {
     out += text.slice(cursor);
     const dangling = danglingIndex(out);
     const withoutCalls = dangling === -1 ? out : out.slice(0, dangling);
-    return stripToolResponseBlocks(withoutCalls)
+    const withoutSpans = stripSpans(stripToolResponseBlocks(withoutCalls), TOOL_CALL);
+    return withoutSpans
         .replace(/<\/?(tool_call|tool_response)>/gi, '')
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
-export function stripToolResponseBlocks(text) {
+function stripSpans(text, span) {
+    const hay = text.replace(/[A-Z]/g, lowerAscii);
     let out = '';
     let cursor = 0;
     for (;;) {
-        const start = text.indexOf(RESPONSE_OPEN, cursor);
+        const start = hay.indexOf(span.open, cursor);
         if (start === -1)
             break;
         out += text.slice(cursor, start);
-        const end = text.indexOf(RESPONSE_CLOSE, start + RESPONSE_OPEN.length);
+        const end = hay.indexOf(span.close, start + span.open.length);
         if (end === -1)
             return out;
-        cursor = end + RESPONSE_CLOSE.length;
+        cursor = end + span.close.length;
     }
     return out + text.slice(cursor);
 }
+function lowerAscii(char) {
+    return char.toLowerCase();
+}
+export function stripToolResponseBlocks(text) {
+    return stripSpans(text, TOOL_RESPONSE);
+}
 function danglingIndex(text) {
     let cursor = 0;
     for (;;) {

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;
+};