@qvac/harness 0.2.10 → 0.3.0

package/dist-lib/index.d.ts

@@ -1,6 +1,9 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 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';
@@ -22,6 +25,10 @@ import type { ResolvedSkillCatalogEntry } from './lib/tools/skills/catalog.ts';
 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';
 export type { SpeakContext, SpeakResult, SpeakStreamContext, TranscribeContext } from './lib/capabilities/voice.ts';
@@ -37,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, SkillRequires, SkillSetup, SkillSetupField, SkillSetupRoute } from './lib/tools/skills/manifest.ts';
+export type { InstallStep, SkillOAuthConfig, 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';
@@ -106,6 +113,16 @@ export interface CompletionContext {
     askUser?: AskUserFn;
     signal?: BareAbortSignal;
 }
+export interface InvokeContext {
+    capability: Capability;
+    args: Record<string, unknown>;
+    enhance?: EnhanceMode;
+    agent?: Agent;
+    attach?: AttachFn;
+    fetchAttachment?: FetchAttachmentFn;
+    progress?: ProgressFn;
+    signal?: BareAbortSignal;
+}
 export declare class Harness extends ReadyResource {
     private _tools;
     private _sdk;
@@ -144,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;
@@ -197,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;
@@ -224,6 +246,7 @@ export declare class Harness extends ReadyResource {
     private _defaultVoiceSrc;
     private _voiceJob;
     transcribe({ model, audio, signal }: TranscribeContext): Promise<string>;
+    detectLanguage(context: DetectLanguageContext): DetectedLanguage[];
     speak({ model, text, signal }: SpeakContext): Promise<SpeakResult>;
     speakStream({ model, text, signal }: SpeakStreamContext): AsyncIterable<SpeakResult>;
     list(options?: ListModelsOptions): Promise<ModelInfo[]>;
@@ -240,7 +263,9 @@ export declare class Harness extends ReadyResource {
         agent?: Agent;
         signal?: BareAbortSignal;
     }): Promise<void>;
+    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

@@ -5,7 +5,13 @@ import ReadyResource from 'ready-resource';
 import { probeGpuStats } from './lib/hardware/gpu-probe.js';
 import { probeCapabilityProfile } from './lib/hardware/capability-probe.js';
 import { closePythonWorker } from './lib/tools/exec/adapters/python/worker/client.js';
-import { completion } from './lib/capabilities/completion.js';
+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';
@@ -17,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';
@@ -45,6 +51,8 @@ import { isDeviceSharedCredentialKey, scopeKey } from './lib/tools/skills/scope-
 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';
@@ -116,7 +124,10 @@ export class Harness extends ReadyResource {
     _diffusionSdk;
     _imageRuntime;
     _musicSdk;
+    _translationSdk;
     _musicRuntime;
+    _translationRuntime;
+    _capabilityTools;
     _capability = null;
     _capabilityInflight = null;
     _modelFaults = new Map();
@@ -201,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
@@ -220,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);
@@ -513,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;
@@ -645,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')
@@ -809,6 +853,9 @@ export class Harness extends ReadyResource {
             return transcribeOnce(sdk, id, pcm ? buildWavBuffer(pcm) : audio);
         });
     }
+    detectLanguage(context) {
+        return detectLanguage(context);
+    }
     async speak({ model, text, signal }) {
         const samples = await this._voiceJob(this._ttsModels, 'tts', model, signal, (sdk, id) => speakOnce(sdk, id, text));
         return { audio: packSamples(samples), sampleRate: SUPERTONIC_SAMPLE_RATE };
@@ -943,6 +990,32 @@ export class Harness extends ReadyResource {
             releaseModel(pool, key);
         }
     }
+    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, enhance });
+        try {
+            yield* invoke({
+                capability,
+                args,
+                enhance,
+                enhancer: this._residentEnhancer(),
+                tools: [...this._tools, ...this._capabilityTools],
+                ctx: {
+                    image: imageSettingsFrom(agent),
+                    attach,
+                    fetchAttachment,
+                    progress,
+                    signal
+                }
+            });
+        }
+        finally {
+            hlog('invoke end', { capability });
+        }
+    }
     async *completion({ model, agent, messages, cacheKey, thinkingDefault, toolConfigs, generationParams, responseFormat, captureInferenceCalls, grantedDirs, grantedDrives, driveOp, grantedWriteDirs, approve, attach, fetchAttachment, ragSearch, progress, askUser, signal }) {
         await this.ready();
         if (this.suspended)
@@ -1059,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/detect-language.d.ts

@@ -0,0 +1,11 @@
+export interface DetectedLanguage {
+    code: string;
+    language: string;
+    probability?: number;
+}
+export interface DetectLanguageContext {
+    text: string;
+    topK?: number;
+}
+export declare const UNDETERMINED = "und";
+export declare function detectLanguage({ text, topK }: DetectLanguageContext): DetectedLanguage[];

package/dist-lib/lib/capabilities/detect-language.js

@@ -0,0 +1,13 @@
+import { detectMultiple, detectOne } from '@qvac/langdetect-text';
+export const UNDETERMINED = 'und';
+export function detectLanguage({ text, topK }) {
+    if (!topK || topK === 1) {
+        const { code, language } = detectOne(text);
+        return [{ code, language }];
+    }
+    return detectMultiple(text, topK).map(({ code, language, probability }) => ({
+        code,
+        language,
+        probability
+    }));
+}

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

@@ -0,0 +1,24 @@
+import type { CompletionEvent, ToolDefinition, ToolExecuteContext } from './completion.ts';
+import type { EnhanceMode, Enhancer } from './enhance.ts';
+declare const CAPABILITY_TOOLS: {
+    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[];
+export declare function isCapability(name: string): name is Capability;
+export interface InvokeOptions {
+    capability: Capability;
+    args: Record<string, unknown>;
+    tools: readonly ToolDefinition[];
+    ctx: ToolExecuteContext;
+    enhance?: EnhanceMode;
+    enhancer?: Enhancer;
+}
+export declare function invoke({ capability, args, tools, ctx, enhance, enhancer }: InvokeOptions): AsyncGenerator<CompletionEvent>;
+export {};

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

@@ -0,0 +1,57 @@
+import { AbortedError } from '../helpers/race-abort.js';
+const CAPABILITY_TOOLS = {
+    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, 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();
+    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(called, ctx);
+        if (ctx.signal?.aborted)
+            return yield { type: 'aborted' };
+        yield { type: 'tool-result', name: entry.tool, result };
+    }
+    catch (err) {
+        if (err instanceof AbortedError || ctx.signal?.aborted) {
+            yield { type: 'aborted' };
+            return;
+        }
+        yield { type: 'error', message: err instanceof Error ? err.message : String(err) };
+        return;
+    }
+    yield {
+        type: 'metrics',
+        totalTokens,
+        durationMs: Date.now() - startedAt,
+        route: routeModel ? 'enhanced' : 'direct',
+        routeModel
+    };
+}

package/dist-lib/lib/connect.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter from 'events';
 import { type Transport } from './rpc-session.ts';
 import { type KvCacheDeletionResult } from './capabilities/kv-cache.ts';
-import type { CapabilityInfo, CompletionContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, WarmModelContext } from './contract-types.ts';
+import type { CapabilityInfo, CompletionContext, DetectedLanguage, DetectLanguageContext, DownloadContext, EmbedContext, HarnessContract, HarnessDiagnostics, HarnessEvent, HarnessInfo, InvokeContext, ListModelsOptions, ModelInfo, ResolvedSkillCatalogEntry, SpeakContext, SpeakResult, SpeakStreamContext, ToolCatalogEntry, TranscribeContext, WarmModelContext } from './contract-types.ts';
 import { type EmbedDevice } from './models/embed-config.ts';
 import type { DeleteModelSummary } from './models/model-delete.ts';
 import type { ManagedSkill, SkillFileContent } from './tools/skills/overlay-crud.ts';
@@ -20,9 +20,12 @@ export declare class RemoteHarness extends EventEmitter implements HarnessContra
     private _ensure;
     private _open;
     completion(context: CompletionContext): AsyncIterable<HarnessEvent>;
+    invoke(context: InvokeContext): AsyncIterable<HarnessEvent>;
+    private _run;
     download(context: DownloadContext): AsyncIterable<HarnessEvent>;
     embed(context: EmbedContext): Promise<number[][]>;
     transcribe(context: TranscribeContext): Promise<string>;
+    detectLanguage(context: DetectLanguageContext): Promise<DetectedLanguage[]>;
     speak(context: SpeakContext): Promise<SpeakResult>;
     speakStream(context: SpeakStreamContext): AsyncIterable<SpeakResult>;
     getEmbeddingDevice(): Promise<EmbedDevice>;

package/dist-lib/lib/connect.js

@@ -91,6 +91,45 @@ export class RemoteHarness extends EventEmitter {
         return session;
     }
     async *completion(context) {
+        yield* this._run({
+            type: 'start',
+            model: context.model,
+            agent: knobs(context.agent),
+            cacheKey: context.cacheKey,
+            thinkingDefault: context.thinkingDefault,
+            generationParams: context.generationParams,
+            responseFormat: context.responseFormat,
+            captureInferenceCalls: context.captureInferenceCalls,
+            messages: context.messages.map(({ role, content, attachments }) => ({
+                role,
+                content,
+                attachments: attachments?.map(({ path: file }) => ({ path: file }))
+            })),
+            toolConfigs: context.toolConfigs,
+            grantedDirs: context.grantedDirs,
+            grantedDrives: context.grantedDrives,
+            grantedWriteDirs: context.grantedWriteDirs
+        }, context);
+    }
+    async *invoke(context) {
+        const agent = context.agent ?? {};
+        yield* this._run({
+            type: 'invoke',
+            capability: context.capability,
+            arguments: context.args,
+            enhance: context.enhance,
+            agent: knobs(agent)
+        }, {
+            model: '',
+            agent,
+            messages: [],
+            attach: context.attach,
+            fetchAttachment: context.fetchAttachment,
+            progress: context.progress,
+            signal: context.signal
+        });
+    }
+    async *_run(open, context) {
         const { client } = await this._ensure();
         let duplex = null;
         let emittedAborted = false;
@@ -104,32 +143,14 @@ export class RemoteHarness extends EventEmitter {
         const onAbort = () => duplex?.destroy();
         try {
             duplex = client.completion();
-            duplex.write({
-                type: 'start',
-                model: context.model,
-                agent: knobs(context.agent),
-                cacheKey: context.cacheKey,
-                thinkingDefault: context.thinkingDefault,
-                generationParams: context.generationParams,
-                responseFormat: context.responseFormat,
-                captureInferenceCalls: context.captureInferenceCalls,
-                messages: context.messages.map(({ role, content, attachments }) => ({
-                    role,
-                    content,
-                    attachments: attachments?.map(({ path: file }) => ({ path: file }))
-                })),
-                toolConfigs: context.toolConfigs,
-                grantedDirs: context.grantedDirs,
-                grantedDrives: context.grantedDrives,
-                grantedWriteDirs: context.grantedWriteDirs
-            });
+            duplex.write(open);
             if (context.signal?.aborted) {
                 duplex.destroy();
                 yield { type: 'aborted' };
                 return;
             }
             context.signal?.addEventListener?.('abort', onAbort, { once: true });
-            hlog('client wire open', { model: context.model });
+            hlog('client wire open', { model: context.model, capability: open.capability });
             for await (const event of frames(duplex)) {
                 received++;
                 if (event.type !== 'content' && event.type !== 'thinking') {
@@ -288,7 +309,7 @@ export class RemoteHarness extends EventEmitter {
             throw died(`harness died mid-run: ${err.message}`);
         }
         finally {
-            hlog('client completion end', { received, aborted: Boolean(context.signal?.aborted) });
+            hlog('client run end', { received, aborted: Boolean(context.signal?.aborted) });
             context.signal?.removeEventListener?.('abort', onAbort);
             duplex?.destroy();
             closed = true;
@@ -350,6 +371,14 @@ export class RemoteHarness extends EventEmitter {
         const response = await abortable(client.transcribe({ model: context.model, audio: context.audio }), context.signal);
         return response.text;
     }
+    async detectLanguage(context) {
+        const { client } = await this._ensure();
+        const response = await client.detectLanguage({
+            text: context.text,
+            topK: context.topK
+        });
+        return response.languages.map(({ code, language, probability }) => probability ? { code, language, probability } : { code, language });
+    }
     async speak(context) {
         const { client } = await this._ensure();
         const response = await abortable(client.speak({ model: context.model, text: context.text }), context.signal);

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

@@ -68,6 +68,25 @@ export interface CompletionContext {
         removeEventListener?: (type: 'abort', fn: () => void) => void;
     };
 }
+export interface InvokeContext {
+    capability: string;
+    args: Record<string, unknown>;
+    enhance?: 'never' | 'auto';
+    agent?: AgentKnobs;
+    attach?: AttachFn;
+    fetchAttachment?: FetchAttachmentFn;
+    progress?: ProgressFn;
+    signal?: CompletionContext['signal'];
+}
+export interface DetectLanguageContext {
+    text: string;
+    topK?: number;
+}
+export interface DetectedLanguage {
+    code: string;
+    language: string;
+    probability?: number;
+}
 export interface HarnessEvent {
     type: string;
     text?: string;
@@ -146,10 +165,12 @@ export interface CapabilityInfo {
 }
 export interface HarnessContract {
     completion(context: CompletionContext): AsyncIterable<HarnessEvent>;
+    invoke?(context: InvokeContext): AsyncIterable<HarnessEvent>;
     download?(context: DownloadContext): AsyncIterable<HarnessEvent>;
     describe?(): Promise<HarnessInfo | null> | HarnessInfo;
     embed?(context: EmbedContext): Promise<number[][]>;
     transcribe?(context: TranscribeContext): Promise<string>;
+    detectLanguage?(context: DetectLanguageContext): DetectedLanguage[] | Promise<DetectedLanguage[]>;
     speak?(context: SpeakContext): Promise<SpeakResult>;
     speakStream?(context: SpeakStreamContext): AsyncIterable<SpeakResult>;
     getEmbeddingDevice?(): EmbedDevice | Promise<EmbedDevice>;

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/hooks/built-in/sandbox.js

@@ -1,3 +1,4 @@
+import { planVendoredInstall } from '../../tools/exec/adapters/python/wheels.js';
 import { bareBin, firstCommandToken } from '../../tools/exec/scope.js';
 const NETWORK_BINS = new Set([
     'curl',
@@ -32,7 +33,8 @@ export class SandboxHook {
             return;
         if (!ctx.sandboxMode || ctx.toolName !== 'exec')
             return;
-        if (Array.isArray(ctx.args.packages) && ctx.args.packages.length) {
+        const packages = ctx.args.packages;
+        if (Array.isArray(packages) && packages.length && !planVendoredInstall(packages.map(String))) {
             return { error: 'sandbox mode: installing packages reaches the network', guidance: true };
         }
         const bin = bareBin(firstCommandToken(String(ctx.args.command ?? '')).replace(/^.*[/\\]/, ''));