@qvac/harness 0.2.12 → 0.3.1

package/dist-lib/lib/tools/operations/decoders.js

@@ -0,0 +1,82 @@
+import b4a from 'b4a';
+import { z } from 'zod';
+import { extractPageText } from '../../web-fetch/extract.js';
+import { decodeHtmlEntities } from '../../web-search/html-helpers.js';
+import { ELISION } from '../http-request/truncate-response.js';
+export const DECODER_NAMES = ['gmail-message'];
+const KEPT_HEADERS = ['From', 'To', 'Subject', 'Date', 'Message-ID', 'References'];
+const MAX_TEXT_CHARS = 4000;
+const PartSchema = z.lazy(() => z.object({
+    mimeType: z.string().optional(),
+    filename: z.string().optional(),
+    headers: z.array(z.object({ name: z.string(), value: z.string() })).optional(),
+    body: z.object({ data: z.string().optional() }).optional(),
+    parts: z.array(PartSchema).optional()
+}));
+const MessageSchema = z.object({
+    id: z.string().optional(),
+    threadId: z.string().optional(),
+    labelIds: z.array(z.string()).optional(),
+    snippet: z.string().optional(),
+    payload: PartSchema.optional()
+});
+const gmailMessage = {
+    decode(body) {
+        const parsed = MessageSchema.safeParse(body);
+        if (!parsed.success)
+            return body;
+        const { id, threadId, labelIds, snippet, payload } = parsed.data;
+        return {
+            id,
+            threadId,
+            labelIds,
+            headers: payload && keptHeaders(payload),
+            snippet: snippet && decodeHtmlEntities(snippet),
+            text: payload && capped(textOf(payload))
+        };
+    }
+};
+function keptHeaders(part) {
+    const kept = {};
+    for (const header of part.headers ?? []) {
+        const name = KEPT_HEADERS.find((known) => known.toLowerCase() === header.name.toLowerCase());
+        if (name && !(name in kept))
+            kept[name] = header.value;
+    }
+    return kept;
+}
+function textOf(part) {
+    const plain = leaves(part, 'text/plain');
+    if (plain.length)
+        return plain.join('\n\n');
+    const html = leaves(part, 'text/html')
+        .map((leaf) => extractPageText(leaf).text)
+        .filter((text) => text.length > 0);
+    if (html.length)
+        return html.join('\n\n');
+    return undefined;
+}
+function leaves(part, mimeType) {
+    if (part.parts?.length)
+        return part.parts.flatMap((child) => leaves(child, mimeType));
+    if (part.mimeType?.toLowerCase() !== mimeType || part.filename || !part.body?.data)
+        return [];
+    const text = decodeData(part.body.data);
+    return text ? [text] : [];
+}
+function decodeData(data) {
+    try {
+        return b4a.toString(b4a.from(data, 'base64url'), 'utf8').replace(/\r\n/g, '\n').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function capped(text) {
+    if (text === undefined || text.length <= MAX_TEXT_CHARS)
+        return text;
+    return `${text.slice(0, MAX_TEXT_CHARS)}${ELISION}`;
+}
+export const DECODERS = {
+    'gmail-message': gmailMessage
+};

package/dist-lib/lib/tools/operations/manifest.d.ts

@@ -1,5 +1,12 @@
 import { z } from 'zod';
 import type { ToolParameters } from '../../capabilities/completion.ts';
+declare const ResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    pick: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    decode: z.ZodEnum<{
+        "gmail-message": "gmail-message";
+    }>;
+}, z.core.$strict>]>;
 declare const OperationSchema: z.ZodObject<{
     tool: z.ZodString;
     description: z.ZodString;
@@ -16,6 +23,7 @@ declare const OperationSchema: z.ZodObject<{
             "drive-create-folder": "drive-create-folder";
             "drive-trash": "drive-trash";
             "gmail-draft": "gmail-draft";
+            "gmail-get": "gmail-get";
             "gmail-send": "gmail-send";
             "notion-create-page": "notion-create-page";
             "notion-insert-content": "notion-insert-content";
@@ -43,6 +51,7 @@ declare const OperationSchema: z.ZodObject<{
             "drive-create-folder": "drive-create-folder";
             "drive-trash": "drive-trash";
             "gmail-draft": "gmail-draft";
+            "gmail-get": "gmail-get";
             "gmail-send": "gmail-send";
             "notion-create-page": "notion-create-page";
             "notion-insert-content": "notion-insert-content";
@@ -51,10 +60,15 @@ declare const OperationSchema: z.ZodObject<{
             "sheets-write-values": "sheets-write-values";
         }>;
     }, z.core.$strip>]>;
-    response: z.ZodOptional<z.ZodObject<{
+    response: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         pick: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        decode: z.ZodEnum<{
+            "gmail-message": "gmail-message";
+        }>;
+    }, z.core.$strict>]>>;
 }, z.core.$strip>;
 export type OperationSpec = z.infer<typeof OperationSchema>;
+export type OperationResponse = z.infer<typeof ResponseSchema>;
 export declare function parseOperationsManifest(json: string): OperationSpec[] | null;
 export {};

package/dist-lib/lib/tools/operations/manifest.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { BUILDER_NAMES } from './builders.js';
+import { DECODER_NAMES } from './decoders.js';
 const ParameterType = z.enum(['string', 'number', 'boolean', 'object', 'integer', 'array', 'null']);
 const ParameterSchema = z.lazy(() => z.object({
     type: z.union([ParameterType, z.array(ParameterType).min(1)]),
@@ -29,12 +30,16 @@ const McpRequestSchema = z.object({
     builder: z.enum(BUILDER_NAMES)
 });
 const RequestSchema = z.union([McpRequestSchema, HttpRequestSchema]);
+const ResponseSchema = z.union([
+    z.strictObject({ pick: z.array(z.string().min(1)).min(1) }),
+    z.strictObject({ decode: z.enum(DECODER_NAMES) })
+]);
 const OperationSchema = z.object({
     tool: z.string().min(1),
     description: z.string().min(1),
     parameters: ParametersSchema,
     request: RequestSchema,
-    response: z.object({ pick: z.array(z.string().min(1)).min(1) }).optional()
+    response: ResponseSchema.optional()
 });
 const ManifestSchema = z.object({ operations: z.array(OperationSchema) });
 export function parseOperationsManifest(json) {

package/dist-lib/lib/tools/skill.d.ts

@@ -1,6 +1,9 @@
 import type { ToolDefinition } from '../capabilities/completion.ts';
 import { type CredentialStoreFn } from './skills/auth-resolver.ts';
 export type ReadSkillFn = (name: string, file: string) => Promise<string> | string;
+export declare function mainFileRequested(name: string, file: unknown): boolean;
+export declare function skillFileArg(args: Record<string, unknown> | null | undefined): unknown;
+export declare function skillFileStem(file: string): string;
 export interface SkillToolOptions {
     skillsDir?: string;
     overlayDir?: string | null;

package/dist-lib/lib/tools/skill.js

@@ -10,6 +10,25 @@ import { parseToolGrant } from './skills/tool-grants.js';
 import { shellEscapeArg } from './exec/shell-argv.js';
 import { isObsidianVaultPath, OBSIDIAN_SKILL_NAME, OBSIDIAN_VAULT_PATH_CREDENTIAL_KEY } from './skills/obsidian-readiness.js';
 const MAIN_FILE = 'SKILL.md';
+const NO_FILE = /^(?:none|null|undefined|main)$/i;
+export function mainFileRequested(name, file) {
+    if (file === undefined || file === null)
+        return true;
+    const asked = unquoteArg(file).toLowerCase();
+    return (asked === '' ||
+        NO_FILE.test(asked) ||
+        asked === name.toLowerCase() ||
+        asked === MAIN_FILE.toLowerCase());
+}
+export function skillFileArg(args) {
+    return args?.file ?? args?.path ?? args?.filename;
+}
+export function skillFileStem(file) {
+    return file
+        .toLowerCase()
+        .replace(/^references\//, '')
+        .replace(/\.md$/, '');
+}
 function resolveSkillDir(root, name) {
     if (!root)
         return null;
@@ -47,6 +66,10 @@ async function listSkillFiles(drives, name) {
     }
     return [...files].sort();
 }
+function nearestFile(wanted, available) {
+    const matches = available.filter((file) => skillFileStem(file) === skillFileStem(wanted));
+    return matches.length === 1 ? matches[0] : null;
+}
 async function vaultModeNote(name, credentialStore, ctx) {
     if (name !== OBSIDIAN_SKILL_NAME || !credentialStore)
         return null;
@@ -107,13 +130,13 @@ export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDi
         autoApprove: true,
         async execute(args, ctx) {
             const name = unquoteArg(args.name ?? args.skill_name ?? args.skill);
-            const fileArg = args.file ?? args.path ?? args.filename;
-            const file = fileArg === undefined || fileArg === null ? MAIN_FILE : unquoteArg(fileArg);
+            const fileArg = skillFileArg(args);
+            const file = mainFileRequested(name, fileArg) ? MAIN_FILE : unquoteArg(fileArg);
             if (file.startsWith('/') || file.includes('\\') || file.split('/').includes('..')) {
                 return { error: `file not found in skill ${name}: ${file}` };
             }
-            try {
-                const { raw, root } = await resolveSkill(name, file === '' ? MAIN_FILE : file);
+            const load = async (target) => {
+                const { raw, root } = await resolveSkill(name, target);
                 const { body, meta } = parseSkillFrontMatter(raw);
                 const dir = resolveSkillDir(root, name);
                 const content = dir ? body.replaceAll('{{SKILL_DIR}}', shellEscapeArg(dir)) : body;
@@ -123,14 +146,24 @@ export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDi
                 ].filter(Boolean);
                 return {
                     name,
-                    file: file === MAIN_FILE || file === '' ? undefined : file,
+                    file: target === MAIN_FILE ? undefined : target,
                     content: notes.length ? [content.trim(), ...notes].join('\n\n') : content
                 };
+            };
+            try {
+                return await load(file);
             }
             catch {
                 if (file === MAIN_FILE)
                     return { error: `skill not found: ${name}` };
                 const available = await listSkillFiles([overlayDrive, baseDrive], name);
+                const near = nearestFile(file, available);
+                if (near !== null) {
+                    try {
+                        return await load(near);
+                    }
+                    catch { }
+                }
                 const rest = available.length
                     ? ` — files this skill has: ${available.join(', ')}`
                     : '. This skill has no other files; you already have its full instructions — act now.';

package/dist-lib/lib/tools/skills/manifest-parse.js

@@ -223,6 +223,46 @@ function readAuthParams(v) {
     const out = Object.fromEntries(Object.entries(record).filter(([key]) => !OAUTH_RESERVED_PARAMS.has(key)));
     return Object.keys(out).length > 0 ? out : undefined;
 }
+const OAUTH_ERROR_CODE = /^[a-z0-9_]+$/;
+function siteOf(url) {
+    return new URL(url).hostname.split('.').slice(-2).join('.');
+}
+function readVerifyRule(v) {
+    if (!isObj(v) || typeof v.error !== 'string' || !OAUTH_ERROR_CODE.test(v.error))
+        return undefined;
+    const status = Array.isArray(v.status)
+        ? v.status.filter((s) => Number.isInteger(s) && s >= 100 && s < 600)
+        : [];
+    const field = typeof v.field === 'string' && v.field.length > 0 ? v.field : undefined;
+    if (status.length === 0 && !field)
+        return undefined;
+    return {
+        error: v.error,
+        ...(status.length > 0 ? { status } : {}),
+        ...(field ? { field } : {}),
+        ...(field && typeof v.notEqual === 'string' ? { notEqual: v.notEqual } : {})
+    };
+}
+function readVerify(v, tokenUrl) {
+    if (!isObj(v))
+        return undefined;
+    const url = httpsUrl(v.url);
+    if (!url || siteOf(url) !== siteOf(tokenUrl))
+        return undefined;
+    if (v.method !== undefined && v.method !== null && v.method !== 'GET' && v.method !== 'POST') {
+        return undefined;
+    }
+    const reject = Array.isArray(v.reject) ? v.reject.flatMap((r) => readVerifyRule(r) ?? []) : [];
+    if (reject.length === 0)
+        return undefined;
+    const body = typeof v.body === 'string' ? v.body : isObj(v.body) ? JSON.stringify(v.body) : undefined;
+    return {
+        url,
+        ...(v.method === 'GET' || v.method === 'POST' ? { method: v.method } : {}),
+        ...(body !== undefined ? { body } : {}),
+        reject
+    };
+}
 function readOAuth(v) {
     if (!isObj(v))
         return undefined;
@@ -240,6 +280,7 @@ function readOAuth(v) {
         return undefined;
     const extraAuthParams = readAuthParams(v.extraAuthParams);
     const registrationEndpoint = httpsUrl(v.registrationEndpoint);
+    const verify = readVerify(v.verify, tokenUrl);
     return {
         stateKey: v.stateKey,
         authUrl,
@@ -249,7 +290,8 @@ function readOAuth(v) {
         ...(extraAuthParams ? { extraAuthParams } : {}),
         ...(registrationEndpoint ? { registrationEndpoint } : {}),
         ...(isPort(v.port) ? { port: v.port } : {}),
-        ...(typeof v.sharedIosSession === 'boolean' ? { sharedIosSession: v.sharedIosSession } : {})
+        ...(typeof v.sharedIosSession === 'boolean' ? { sharedIosSession: v.sharedIosSession } : {}),
+        ...(verify ? { verify } : {})
     };
 }
 export function toWireSetup(setup) {

package/dist-lib/lib/tools/skills/manifest.d.ts

@@ -39,6 +39,19 @@ export interface SkillOAuthConfig {
     readonly registrationEndpoint?: string;
     readonly port?: number;
     readonly sharedIosSession?: boolean;
+    readonly verify?: SkillOAuthVerify;
+}
+export interface SkillOAuthVerify {
+    readonly url: string;
+    readonly method?: 'GET' | 'POST';
+    readonly body?: string;
+    readonly reject: readonly SkillOAuthVerifyRule[];
+}
+export interface SkillOAuthVerifyRule {
+    readonly error: string;
+    readonly status?: readonly number[];
+    readonly field?: string;
+    readonly notEqual?: string;
 }
 export interface SkillSetupRoute {
     readonly kind: 'oauth' | 'token' | 'install' | 'picker' | 'instructions';

package/dist-lib/lib/tools/translate.d.ts

@@ -0,0 +1,78 @@
+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';
+interface BergamotConfig {
+    engine: 'Bergamot';
+    from: string;
+    to: string;
+    pivotModel?: {
+        modelSrc: ModelSrc;
+    };
+    srcVocabSrc?: string;
+    dstVocabSrc?: string;
+}
+export type TranslationSdk = ModelRegistrySdk & {
+    loadModel(params: {
+        modelSrc: ModelSrc;
+        modelType: 'nmtcpp-translation';
+        modelConfig: BergamotConfig;
+        onProgress?: (progress: Record<string, unknown>) => void;
+    }): TrackedLoad;
+    unloadModel(params: {
+        modelId: string;
+    }): Promise<unknown>;
+    cancel?(params: {
+        requestId: string;
+    }): Promise<void>;
+    translate(params: {
+        modelId: string;
+        text: string;
+        stream: false;
+        modelType: 'nmt';
+    }): {
+        text: Promise<string>;
+    };
+};
+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;
+    onProgress?: (model: string, progress: Record<string, unknown>) => void;
+    stallMs?: number;
+}
+export interface TranslationRuntime {
+    loadSdk: () => Promise<TranslationSdk>;
+    ensureLoaded: (sdk: TranslationSdk, plan: NmtPlan, signal?: BareAbortSignal) => Promise<{
+        modelId: string;
+    }>;
+    unload: () => Promise<void>;
+    enter: (signal?: BareAbortSignal) => Promise<void>;
+    exit: () => void;
+}
+export declare function createTranslationRuntime({ loadSdk, loads, onProgress, stallMs }: TranslationRuntimeOptions): TranslationRuntime;
+export type SlmTranslateFn = (model: string, params: {
+    text: string;
+    from: string;
+    to: string;
+}, signal?: BareAbortSignal) => Promise<string>;
+export declare function stripLanguageLabel(text: string, ...codes: string[]): string;
+export interface TranslateArgs {
+    text: string;
+    to: string;
+    from?: string;
+}
+export declare function parseTranslateArgs(args: Record<string, unknown>): TranslateArgs | {
+    error: string;
+};
+export declare function sourceLanguage(text: string, from?: string): string | {
+    error: string;
+};
+export interface TranslateToolOptions {
+    slm?: SlmTranslateFn;
+}
+export declare function createTranslateTool(runtime: TranslationRuntime, { slm }?: TranslateToolOptions): ToolDefinition;
+export {};

package/dist-lib/lib/tools/translate.js

@@ -0,0 +1,228 @@
+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';
+export const TRANSLATION_LOAD_STALL_MS = 15 * 60_000;
+export const TRANSLATION_LOAD_STALL_ERROR = 'translation model download stalled';
+function packName(plan) {
+    const pair = plan.model.match(/model\.([a-z]+)\.intgemm/)?.[1];
+    if (pair)
+        return `Bergamot ${pair}`;
+    return plan.model.includes('/en-xx/') ? 'EuroNano en-xx' : 'EuroNano xx-en';
+}
+const fingerprintOf = (plan) => `${plan.model}|${plan.pivot ?? ''}`;
+function bergamotConfig(plan) {
+    const config = { engine: 'Bergamot', from: plan.from, to: plan.to };
+    if (plan.srcVocab)
+        config.srcVocabSrc = plan.srcVocab;
+    if (plan.dstVocab)
+        config.dstVocabSrc = plan.dstVocab;
+    return config;
+}
+export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(), onProgress, stallMs = TRANSLATION_LOAD_STALL_MS }) {
+    let loading = null;
+    let residentFingerprint = null;
+    const lock = new ScopeLock();
+    const turn = new ScopeLock();
+    const loadPack = async (sdk, plan) => {
+        const modelSrc = await resolveModelSrc(sdk, plan.model, 'nmt');
+        const modelConfig = bergamotConfig(plan);
+        if (plan.pivot) {
+            modelConfig.pivotModel = { modelSrc: await resolveModelSrc(sdk, plan.pivot, 'nmt') };
+        }
+        const name = packName(plan);
+        const stall = createLoadStall(stallMs, TRANSLATION_LOAD_STALL_ERROR);
+        onProgress?.(name, {});
+        const pending = sdk.loadModel({
+            modelSrc,
+            modelType: 'nmtcpp-translation',
+            modelConfig,
+            onProgress: (progress) => {
+                stall.bump();
+                onProgress?.(name, progress);
+            }
+        });
+        try {
+            const modelId = await Promise.race([loads.track(pending), stall.promise]);
+            return { modelId };
+        }
+        catch (err) {
+            if (err instanceof Error &&
+                err.message === TRANSLATION_LOAD_STALL_ERROR &&
+                pending.requestId) {
+                void sdk.cancel?.({ requestId: pending.requestId }).catch(() => { });
+            }
+            throw err;
+        }
+        finally {
+            stall.clear();
+        }
+    };
+    const doUnload = async () => {
+        const pending = loading;
+        if (!pending) {
+            residentFingerprint = null;
+            return;
+        }
+        const loaded = await pending.catch(() => null);
+        if (!loaded) {
+            loading = null;
+            residentFingerprint = null;
+            return;
+        }
+        const sdk = await loadSdk();
+        await sdk.unloadModel({ modelId: loaded.modelId });
+        loading = null;
+        residentFingerprint = null;
+    };
+    const unload = async () => {
+        await lock.lock();
+        try {
+            await doUnload();
+        }
+        finally {
+            lock.unlock();
+        }
+    };
+    return {
+        loadSdk,
+        ensureLoaded: async (sdk, plan, signal) => {
+            const fingerprint = fingerprintOf(plan);
+            await lock.lock();
+            try {
+                if (loading && residentFingerprint !== fingerprint)
+                    await doUnload();
+                residentFingerprint = fingerprint;
+                loading ??= loadPack(sdk, plan).catch((err) => {
+                    loading = null;
+                    residentFingerprint = null;
+                    throw err;
+                });
+            }
+            finally {
+                lock.unlock();
+            }
+            return raceAbort(loading, signal);
+        },
+        unload,
+        enter: async (signal) => {
+            const pending = turn.lock();
+            try {
+                await raceAbort(pending, signal);
+            }
+            catch (err) {
+                void pending.then(() => turn.unlock());
+                throw err;
+            }
+        },
+        exit: () => turn.unlock()
+    };
+}
+export function stripLanguageLabel(text, ...codes) {
+    const at = text.indexOf(':');
+    if (at === -1)
+        return text;
+    const head = text.slice(0, at).trim();
+    const labels = codes.map((code) => languageLabel(code) ?? getLangName(code));
+    return labels.includes(head) ? text.slice(at + 1).trim() : text;
+}
+export function parseTranslateArgs(args) {
+    const text = typeof args.text === 'string' ? args.text.trim() : '';
+    if (!text)
+        return { error: 'text must be a non-empty string' };
+    const to = typeof args.to === 'string' ? args.to.trim() : '';
+    if (!to)
+        return { error: 'to must be a language code' };
+    const from = typeof args.from === 'string' ? args.from.trim() : undefined;
+    return { text, to, from };
+}
+export function sourceLanguage(text, from) {
+    if (from)
+        return from;
+    const [{ code }] = detectLanguage({ text });
+    if (code === UNDETERMINED)
+        return { error: NEEDS_SOURCE };
+    return code;
+}
+const NEEDS_SOURCE = 'could not detect the source language; pass `from` explicitly';
+export function createTranslateTool(runtime, { slm } = {}) {
+    return {
+        name: 'translate',
+        toolset: null,
+        description: 'Translate text between languages using the local neural translation models. ' +
+            `\`to\` and \`from\` are ISO 639-1 codes. Translating into ${ENGLISH} supports ` +
+            `${NMT_TO_ENGLISH.length} languages and out of it ${NMT_FROM_ENGLISH.length}; a pair ` +
+            'with English on neither side is translated through English, except between the ' +
+            'languages below. ' +
+            `${SLM_LANGUAGE_CODES.length} further languages, mostly African, may also be named by ` +
+            'their FLORES-200 code and always need an explicit `from`, which the detector cannot ' +
+            'name. Elsewhere `from` is detected from the text when omitted; pass it when known.',
+        parameters: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'The text to translate' },
+                to: {
+                    type: 'string',
+                    description: 'Target language as an ISO 639-1 code, e.g. `es`, or a FLORES-200 code'
+                },
+                from: {
+                    type: 'string',
+                    description: 'Source language as an ISO 639-1 or FLORES-200 code; detected from the text when omitted'
+                }
+            },
+            required: ['text', 'to']
+        },
+        effect: () => 'read',
+        resource: (args) => ({ kind: 'translation', label: String(args.to ?? '') }),
+        execute: async (args, ctx) => {
+            const parsed = parseTranslateArgs(args);
+            if ('error' in parsed)
+                return parsed;
+            const from = sourceLanguage(parsed.text, parsed.from);
+            if (typeof from === 'object')
+                return from;
+            if (sameLanguage(from, parsed.to)) {
+                return { text: parsed.text, from, to: parsed.to, engine: 'none' };
+            }
+            const plan = translationPlanFor(from, parsed.to);
+            if ('error' in plan)
+                return plan;
+            if (plan.route === 'slm' && !slm) {
+                return { error: `this device cannot translate ${from} to ${parsed.to}` };
+            }
+            let entered = false;
+            try {
+                await runtime.enter(ctx?.signal);
+                entered = true;
+                if (plan.route === 'slm') {
+                    const text = await slm(plan.model, { text: parsed.text, from: plan.from, to: plan.to }, ctx?.signal);
+                    return {
+                        text: stripLanguageLabel(text, plan.from, plan.to),
+                        from,
+                        to: parsed.to,
+                        engine: 'slm',
+                        model: plan.model
+                    };
+                }
+                const sdk = await runtime.loadSdk();
+                const { modelId } = await runtime.ensureLoaded(sdk, plan, ctx?.signal);
+                const source = plan.tag ? `${plan.tag} ${parsed.text}` : parsed.text;
+                const text = await raceAbort(sdk.translate({ modelId, text: source, stream: false, modelType: 'nmt' }).text, ctx?.signal);
+                return { text, from, to: parsed.to, engine: 'nmt', pivoted: Boolean(plan.pivot) };
+            }
+            catch (err) {
+                if (err instanceof AbortedError)
+                    return { error: 'translation canceled' };
+                throw err;
+            }
+            finally {
+                if (entered)
+                    runtime.exit();
+            }
+        }
+    };
+}

package/dist-lib/schema/harness.js

@@ -112,7 +112,8 @@ export function registerHarnessTypes(ns) {
             { name: 'grantedWriteDirs', type: 'string', array: true },
             { name: 'captureInferenceCalls', type: 'bool' },
             { name: 'capability', type: 'string' },
-            { name: 'arguments', type: 'json' }
+            { name: 'arguments', type: 'json' },
+            { name: 'enhance', type: 'string' }
         ]
     });
     ns.register({
@@ -644,6 +645,24 @@ export function registerHarnessTypes(ns) {
             { name: 'value', type: 'string', required: true }
         ]
     });
+    ns.register({
+        name: 'skill-oauth-verify-rule',
+        fields: [
+            { name: 'error', type: 'string', required: true },
+            { name: 'status', type: 'uint', array: true },
+            { name: 'field', type: 'string' },
+            { name: 'notEqual', type: 'string' }
+        ]
+    });
+    ns.register({
+        name: 'skill-oauth-verify',
+        fields: [
+            { name: 'url', type: 'string', required: true },
+            { name: 'method', type: 'string' },
+            { name: 'body', type: 'string' },
+            { name: 'reject', type: '@harness/skill-oauth-verify-rule', array: true }
+        ]
+    });
     ns.register({
         name: 'skill-oauth-config',
         fields: [
@@ -655,7 +674,8 @@ export function registerHarnessTypes(ns) {
             { name: 'extraAuthParams', type: '@harness/skill-oauth-param', array: true },
             { name: 'registrationEndpoint', type: 'string' },
             { name: 'port', type: 'uint' },
-            { name: 'sharedIosSession', type: 'bool' }
+            { name: 'sharedIosSession', type: 'bool' },
+            { name: 'verify', type: '@harness/skill-oauth-verify' }
         ]
     });
 }