@qvac/harness 0.4.0 → 0.5.0

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

@@ -19,18 +19,36 @@ export function supportsPlatform(entry, platform) {
 }
 export function isModelCompatible(entry, activeProfile) {
     const required = entry.minCapabilityProfile;
-    if (!required || activeProfile === undefined || !isCapabilityProfile(required))
+    if (!required || activeProfile === undefined || !isCapabilityProfile(required)) {
         return true;
+    }
     return meetsMinCapabilityProfile(activeProfile, required);
 }
+function slotHealth(slot, { records, isRejected }) {
+    let bad = false;
+    for (const key of slot) {
+        const record = records.get(key);
+        const expired = !!record && isCredentialExpired(record);
+        if (record && !isRejected(key) && !expired) {
+            return 'healthy';
+        }
+        if (isRejected(key) || expired) {
+            bad = true;
+        }
+    }
+    return bad ? 'bad' : 'missing';
+}
 export async function resolveSkillState(entry, inputs = {}) {
     try {
-        if (!supportsPlatform(entry, inputs.platform))
+        if (!supportsPlatform(entry, inputs.platform)) {
             return SKILL_STATE.unsupported;
-        if (isStub(entry))
+        }
+        if (isStub(entry)) {
             return SKILL_STATE.disabled;
-        if (!isModelCompatible(entry, inputs.activeProfile))
+        }
+        if (!isModelCompatible(entry, inputs.activeProfile)) {
             return SKILL_STATE.incompatibleModel;
+        }
         const bins = entry.requires?.bins ?? [];
         if (entry.name === OBSIDIAN_SKILL_NAME) {
             const vault = inputs.credentialStore
@@ -39,10 +57,12 @@ export async function resolveSkillState(entry, inputs = {}) {
                     skills: [entry.name]
                 }))
                 : null;
-            if (vault && isObsidianVaultPath(vault.token))
+            if (vault && isObsidianVaultPath(vault.token)) {
                 return SKILL_STATE.ready;
-            if (isSandboxedWorkbenchInstall())
+            }
+            if (isSandboxedWorkbenchInstall()) {
                 return SKILL_STATE.needsSetup;
+            }
         }
         let missing = bins.length > 0 ? missingBins(bins, inputs.platform, inputs.binOnPath) : [];
         if (entry.name === OBSIDIAN_SKILL_NAME) {
@@ -52,8 +72,9 @@ export async function resolveSkillState(entry, inputs = {}) {
                 obsidianInstallState(inputs.platform, inputs.obsidianProbe) === 'installed') {
                 missing = missing.filter((bin) => bin !== 'obsidian');
             }
-            if (missing.length === 0 && cli === 'disabled')
+            if (missing.length === 0 && cli === 'disabled') {
                 return SKILL_STATE.needsSetup;
+            }
         }
         if (missing.length > 0) {
             return SKILL_STATE.needsSetup;
@@ -67,18 +88,22 @@ export async function resolveSkillState(entry, inputs = {}) {
             const settings = inputs.settingsStore
                 ? await inputs.settingsStore(entry.name, inputs.agentId)
                 : {};
-            if (required.some((key) => !settings[key]))
+            if (required.some((key) => !settings[key])) {
                 return SKILL_STATE.needsSetup;
+            }
         }
         const slots = credentialSlots(entry);
-        if (slots.length === 0)
+        if (slots.length === 0) {
             return SKILL_STATE.ready;
-        const isRejected = inputs.rejected
-            ? (key) => inputs.rejected.has(key)
+        }
+        const { rejected } = inputs;
+        const isRejected = rejected
+            ? (key) => rejected.has(key)
             : (key) => isCredentialRejected(key, inputs.agentId, entry.name);
         const store = inputs.credentialStore;
-        if (!store)
+        if (!store) {
             return SKILL_STATE.needsSetup;
+        }
         const records = new Map(await Promise.all([...new Set(slots.flat())].map(async (key) => [
             key,
             credentialRecord(await store(key, { agentId: inputs.agentId, skills: [entry.name] }))
@@ -86,29 +111,23 @@ export async function resolveSkillState(entry, inputs = {}) {
         let disconnected = false;
         let needsSetup = false;
         for (const slot of slots) {
-            let healthy = false;
-            let bad = false;
-            for (const key of slot) {
-                const record = records.get(key);
-                const expired = !!record && isCredentialExpired(record);
-                if (record && !isRejected(key) && !expired) {
-                    healthy = true;
-                    break;
-                }
-                if (isRejected(key) || expired)
-                    bad = true;
-            }
-            if (healthy)
+            const health = slotHealth(slot, { records, isRejected });
+            if (health === 'healthy') {
                 continue;
-            if (bad)
+            }
+            if (health === 'bad') {
                 disconnected = true;
-            else
+            }
+            else {
                 needsSetup = true;
+            }
         }
-        if (disconnected)
+        if (disconnected) {
             return SKILL_STATE.disconnected;
-        if (needsSetup)
+        }
+        if (needsSetup) {
             return SKILL_STATE.needsSetup;
+        }
         return SKILL_STATE.ready;
     }
     catch {

package/dist-lib/lib/tools/skills/tool-grants.js

@@ -2,13 +2,16 @@ const GRANT_RE = /^([\w-]+)\((.*)\)$/;
 export function parseToolGrant(entry) {
     const trimmed = entry.trim();
     const match = GRANT_RE.exec(trimmed);
-    if (!match)
+    if (!match) {
         return { name: trimmed, scope: null };
+    }
     const name = match[1] ?? '';
     const scope = (match[2] ?? '').trim();
-    if (!name)
+    if (!name) {
         return { name: trimmed, scope: null };
-    if (!scope)
+    }
+    if (!scope) {
         return { name, scope: null };
+    }
     return { name, scope };
 }

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

@@ -11,8 +11,9 @@ export function asToolset(value) {
 }
 export const NETWORK_TOOLSETS = ['web-search', 'http-request', 'mcp-call'];
 export function permittedTools(tools, disabled) {
-    if (!disabled?.length)
+    if (!disabled?.length) {
         return [...tools];
+    }
     const off = new Set(disabled);
     return tools.filter((tool) => !tool.toolset || !off.has(tool.toolset));
 }

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

@@ -65,12 +65,11 @@ export interface TranslateArgs {
     to: string;
     from?: string;
 }
-export declare function parseTranslateArgs(args: Record<string, unknown>): TranslateArgs | {
+export interface TranslateError {
     error: string;
-};
-export declare function sourceLanguage(text: string, from?: string): string | {
-    error: string;
-};
+}
+export declare function parseTranslateArgs(args: Record<string, unknown>): TranslateArgs | TranslateError;
+export declare function sourceLanguage(text: string, from?: string): string | TranslateError;
 export interface TranslateToolOptions {
     slm?: SlmTranslateFn;
 }

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

@@ -10,17 +10,20 @@ 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)
+    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)
+    if (plan.srcVocab) {
         config.srcVocabSrc = plan.srcVocab;
-    if (plan.dstVocab)
+    }
+    if (plan.dstVocab) {
         config.dstVocabSrc = plan.dstVocab;
+    }
     return config;
 }
 export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(), onProgress, stallMs = TRANSLATION_LOAD_STALL_MS }) {
@@ -54,7 +57,7 @@ export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(),
             if (err instanceof Error &&
                 err.message === TRANSLATION_LOAD_STALL_ERROR &&
                 pending.requestId) {
-                void sdk.cancel?.({ requestId: pending.requestId }).catch(() => { });
+                void sdk.cancel?.({ requestId: pending.requestId }).catch(noop);
             }
             throw err;
         }
@@ -94,8 +97,9 @@ export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(),
             const fingerprint = fingerprintOf(plan);
             await lock.lock();
             try {
-                if (loading && residentFingerprint !== fingerprint)
+                if (loading && residentFingerprint !== fingerprint) {
                     await doUnload();
+                }
                 residentFingerprint = fingerprint;
                 loading ??= loadPack(sdk, plan).catch((err) => {
                     loading = null;
@@ -124,19 +128,22 @@ export function createTranslationRuntime({ loadSdk, loads = createLoadTracker(),
 }
 export function stripLanguageLabel(text, ...codes) {
     const at = text.indexOf(':');
-    if (at === -1)
+    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)
+    if (!text) {
         return { error: 'text must be a non-empty string' };
+    }
     const to = typeof args.to === 'string' ? args.to.trim() : '';
-    if (!to)
+    if (!to) {
         return { error: 'to must be a language code' };
+    }
     const from = typeof args.from === 'string' ? args.from.trim() : undefined;
     return { text, to, from };
 }
@@ -144,8 +151,9 @@ export function sourceLanguage(text, from) {
     if (from)
         return from;
     const [{ code }] = detectLanguage({ text });
-    if (code === UNDETERMINED)
+    if (code === UNDETERMINED) {
         return { error: NEEDS_SOURCE };
+    }
     return code;
 }
 const NEEDS_SOURCE = 'could not detect the source language; pass `from` explicitly';
@@ -180,17 +188,20 @@ export function createTranslateTool(runtime, { slm } = {}) {
         resource: (args) => ({ kind: 'translation', label: String(args.to ?? '') }),
         execute: async (args, ctx) => {
             const parsed = parseTranslateArgs(args);
-            if ('error' in parsed)
+            if ('error' in parsed) {
                 return parsed;
+            }
             const from = sourceLanguage(parsed.text, parsed.from);
-            if (typeof from === 'object')
+            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)
+            if ('error' in plan) {
                 return plan;
+            }
             if (plan.route === 'slm' && !slm) {
                 return { error: `this device cannot translate ${from} to ${parsed.to}` };
             }
@@ -199,6 +210,9 @@ export function createTranslateTool(runtime, { slm } = {}) {
                 await runtime.enter(ctx?.signal);
                 entered = true;
                 if (plan.route === 'slm') {
+                    if (!slm) {
+                        throw new Error('slm translation is unavailable');
+                    }
                     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),
@@ -215,14 +229,17 @@ export function createTranslateTool(runtime, { slm } = {}) {
                 return { text, from, to: parsed.to, engine: 'nmt', pivoted: Boolean(plan.pivot) };
             }
             catch (err) {
-                if (err instanceof AbortedError)
+                if (err instanceof AbortedError) {
                     return { error: 'translation canceled' };
+                }
                 throw err;
             }
             finally {
-                if (entered)
+                if (entered) {
                     runtime.exit();
+                }
             }
         }
     };
 }
+function noop() { }

package/dist-lib/lib/tools/url-guard.js

@@ -24,8 +24,9 @@ export async function resolveOutboundUrl(url, resolveHost, signal) {
         addresses = await raceAbort(resolveHost(host), signal);
     }
     catch (err) {
-        if (err instanceof AbortedError)
+        if (err instanceof AbortedError) {
             throw err;
+        }
         return { blocked: `could not resolve host: ${host}` };
     }
     if (addresses.length === 0) {

package/dist-lib/lib/tools/weather-lookup/place.js

@@ -107,16 +107,18 @@ export function describePlace(place) {
 }
 export function qualifierOf(location) {
     const comma = location.indexOf(',');
-    if (comma === -1)
+    if (comma === -1) {
         return null;
+    }
     const qualifier = fold(location.slice(comma + 1));
     return qualifier.length > 0 ? qualifier : null;
 }
 function expand(qualifier) {
     const code = qualifier.replace(/ /g, '');
     const subdivision = US_STATES[code] ?? OTHER_SUBDIVISIONS[code];
-    if (subdivision !== undefined)
+    if (subdivision !== undefined) {
         return subdivision;
+    }
     for (const [alias, full] of QUALIFIER_ALIASES) {
         if (qualifier === fold(alias))
             return full;
@@ -143,10 +145,12 @@ export function checkQualifier(qualifier, place) {
             continue;
         if (initialsOf(candidate) === code)
             return 'match';
-        if (opaque)
+        if (opaque) {
             continue;
-        if (candidate.includes(wanted) || wanted.includes(candidate))
+        }
+        if (candidate.includes(wanted) || wanted.includes(candidate)) {
             return 'match';
+        }
     }
     return opaque ? 'unverifiable' : 'contradiction';
 }

package/dist-lib/lib/tools/weather-lookup/report.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { type ResolvedPlace } from './place.ts';
 interface Translated {
     readonly value: string;
@@ -32,6 +33,11 @@ export interface WeatherJson {
     readonly current_condition?: ReadonlyArray<CurrentCondition>;
     readonly weather?: ReadonlyArray<DailyForecast>;
 }
+export declare const WeatherJsonSchema: z.ZodType<WeatherJson>;
 export declare function placeOf(json: WeatherJson): ResolvedPlace | null;
-export declare function renderReport(json: WeatherJson, place: ResolvedPlace, asked: string, verified: boolean): string;
+export interface RenderReportOptions {
+    readonly asked: string;
+    readonly verified: boolean;
+}
+export declare function renderReport(json: WeatherJson, place: ResolvedPlace, { asked, verified }: RenderReportOptions): string;
 export {};

package/dist-lib/lib/tools/weather-lookup/report.js

@@ -1,4 +1,33 @@
+import { z } from 'zod';
 import { describePlace } from './place.js';
+const TranslatedSchema = z.array(z.object({ value: z.string() })).optional();
+export const WeatherJsonSchema = z.object({
+    nearest_area: z
+        .array(z.object({ areaName: TranslatedSchema, region: TranslatedSchema, country: TranslatedSchema }))
+        .optional(),
+    current_condition: z
+        .array(z.object({
+        temp_C: z.string().optional(),
+        temp_F: z.string().optional(),
+        FeelsLikeC: z.string().optional(),
+        humidity: z.string().optional(),
+        windspeedKmph: z.string().optional(),
+        weatherDesc: TranslatedSchema
+    }))
+        .optional(),
+    weather: z
+        .array(z.object({
+        date: z.string().optional(),
+        maxtempC: z.string().optional(),
+        mintempC: z.string().optional(),
+        maxtempF: z.string().optional(),
+        mintempF: z.string().optional(),
+        hourly: z
+            .array(z.object({ time: z.string().optional(), weatherDesc: TranslatedSchema }))
+            .optional()
+    }))
+        .optional()
+});
 const MAX_DAYS = 3;
 const DAY_LABELS = ['today', 'tomorrow'];
 const RANGE = '\u2013';
@@ -8,8 +37,9 @@ function firstValue(values) {
 }
 export function placeOf(json) {
     const area = json.nearest_area?.[0];
-    if (area === undefined)
+    if (area === undefined) {
         return null;
+    }
     const place = {
         area: firstValue(area.areaName),
         region: firstValue(area.region),
@@ -17,33 +47,40 @@ export function placeOf(json) {
     };
     return place.area || place.region || place.country ? place : null;
 }
-export function renderReport(json, place, asked, verified) {
+export function renderReport(json, place, { asked, verified }) {
     const lines = [headline(place, asked, verified)];
     const now = json.current_condition?.[0];
-    if (now !== undefined)
+    if (now !== undefined) {
         lines.push(currentLine(now));
+    }
     const days = json.weather?.slice(0, MAX_DAYS) ?? [];
-    for (const [index, day] of days.entries())
+    for (const [index, day] of days.entries()) {
         lines.push(dailyLine(day, index));
+    }
     return lines.join('\n');
 }
 function headline(place, asked, verified) {
     const resolved = describePlace(place);
-    if (verified)
+    if (verified) {
         return resolved;
+    }
     return `${resolved} (not "${asked}" — this is where it resolved)`;
 }
 function currentLine(now) {
     const parts = [`Now: ${now.temp_C ?? '?'}°C / ${now.temp_F ?? '?'}°F`];
     const desc = firstValue(now.weatherDesc);
-    if (desc)
+    if (desc) {
         parts.push(desc);
-    if (now.FeelsLikeC !== undefined)
+    }
+    if (now.FeelsLikeC !== undefined) {
         parts.push(`feels like ${now.FeelsLikeC}°C`);
-    if (now.humidity !== undefined)
+    }
+    if (now.humidity !== undefined) {
         parts.push(`humidity ${now.humidity}%`);
-    if (now.windspeedKmph !== undefined)
+    }
+    if (now.windspeedKmph !== undefined) {
         parts.push(`wind ${now.windspeedKmph} km/h`);
+    }
     return parts.join(', ');
 }
 function dailyLine(day, index) {

package/dist-lib/lib/tools/weather-lookup.js

@@ -1,10 +1,11 @@
-import defaultFetch from '#no-redirect-fetch';
+import { noRedirectFetch } from '#no-redirect-fetch';
 import { AbortController } from 'bare-abort-controller';
 import { lookupHost } from '../dns-lookup.js';
-import { isRedirectStatus } from './http-request/utils.js';
+import { errorMessage } from '../guards.js';
+import { isRedirectStatus } from './http-request/request.js';
 import { resolveOutboundUrl } from './url-guard.js';
 import { checkQualifier, cityMatches, describePlace, qualifierOf } from './weather-lookup/place.js';
-import { placeOf, renderReport } from './weather-lookup/report.js';
+import { placeOf, renderReport, WeatherJsonSchema } from './weather-lookup/report.js';
 const WEATHER_HOST = 'wttr.in';
 const LOOKUP_TIMEOUT_MS = 15_000;
 const MAX_BODY_BYTES = 400_000;
@@ -36,18 +37,20 @@ export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookup
                 return { error: 'location must be a non-empty string' };
             }
             const location = raw.trim();
-            if (ctx?.signal?.aborted)
+            if (ctx?.signal?.aborted) {
                 return { error: 'weather_lookup cancelled' };
+            }
             const url = new URL(`https://${WEATHER_HOST}/${encodeURIComponent(location)}?format=j1`);
-            const fetch = fetchImpl ?? defaultFetch;
+            const fetch = fetchImpl ?? noRedirectFetch;
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(undefined), LOOKUP_TIMEOUT_MS);
             const onCallerAbort = () => controller.abort(undefined);
             ctx?.signal?.addEventListener('abort', onCallerAbort);
             try {
                 const check = await resolveOutboundUrl(url, resolveHost, ctx?.signal);
-                if (check.blocked)
+                if (check.blocked) {
                     return { error: check.blocked };
+                }
                 const response = await fetch(url, {
                     method: 'GET',
                     headers: { Accept: 'application/json' },
@@ -60,21 +63,23 @@ export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookup
                     return { error: `${WEATHER_HOST} redirected the lookup for "${location}"` };
                 }
                 const body = await response.text();
-                if (/location not found/i.test(body))
+                if (/location not found/i.test(body)) {
                     return { content: notFound(location) };
+                }
                 if (response.status !== 200) {
                     return { error: unavailable(`it answered HTTP ${response.status}`), code: 'transport' };
                 }
                 let json;
                 try {
-                    json = JSON.parse(body);
+                    json = WeatherJsonSchema.parse(JSON.parse(body));
                 }
                 catch {
                     return { error: unavailable('it did not return a forecast') };
                 }
                 const place = placeOf(json);
-                if (place === null)
+                if (place === null) {
                     return { content: notFound(location) };
+                }
                 const qualifier = qualifierOf(location);
                 const verdict = qualifier === null ? null : checkQualifier(qualifier, place);
                 const named = cityMatches(location, place);
@@ -85,11 +90,12 @@ export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookup
                     };
                 }
                 const verified = qualifier === null ? named : verdict === 'match';
-                return { content: renderReport(json, place, location, verified) };
+                return { content: renderReport(json, place, { asked: location, verified }) };
             }
             catch (err) {
-                if (ctx?.signal?.aborted)
+                if (ctx?.signal?.aborted) {
                     return { error: 'weather_lookup cancelled' };
+                }
                 if (controller.signal.aborted) {
                     return {
                         error: `weather_lookup timed out after ${LOOKUP_TIMEOUT_MS} ms`,
@@ -97,7 +103,7 @@ export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookup
                     };
                 }
                 return {
-                    error: unavailable(err instanceof Error ? err.message : String(err)),
+                    error: unavailable(errorMessage(err)),
                     code: 'transport'
                 };
             }