@qvac/harness 0.2.9 → 0.2.12

package/dist/prebuilds-manifest.json

@@ -272,14 +272,6 @@
       "win32-arm64",
       "win32-x64"
     ],
-    "bare-tty/node_modules/bare-signals": [
-      "darwin-arm64",
-      "darwin-x64",
-      "linux-arm64",
-      "linux-x64",
-      "win32-arm64",
-      "win32-x64"
-    ],
     "bare-tty": [
       "darwin-arm64",
       "darwin-x64",

package/dist-lib/index.d.ts

@@ -1,6 +1,8 @@
 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 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 +24,8 @@ 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 { 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 +41,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 +110,15 @@ export interface CompletionContext {
     askUser?: AskUserFn;
     signal?: BareAbortSignal;
 }
+export interface InvokeContext {
+    capability: Capability;
+    args: Record<string, unknown>;
+    agent?: Agent;
+    attach?: AttachFn;
+    fetchAttachment?: FetchAttachmentFn;
+    progress?: ProgressFn;
+    signal?: BareAbortSignal;
+}
 export declare class Harness extends ReadyResource {
     private _tools;
     private _sdk;
@@ -224,6 +237,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,6 +254,7 @@ export declare class Harness extends ReadyResource {
         agent?: Agent;
         signal?: BareAbortSignal;
     }): Promise<void>;
+    invoke({ capability, args, 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 _makeRoomForCompletion;
     private _evictWedgedModel;

package/dist-lib/index.js

@@ -5,7 +5,9 @@ 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 { download } from './lib/capabilities/download.js';
 import { createEmbedLane } from './lib/capabilities/embed.js';
 import { deleteAllKvCaches, deleteKvCacheKey } from './lib/capabilities/kv-cache.js';
@@ -45,6 +47,7 @@ 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 * from './lib/capabilities/download.js';
 export * from './lib/models/model-catalog.js';
 export * from './lib/models/model-list.js';
@@ -809,6 +812,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 +949,30 @@ export class Harness extends ReadyResource {
             releaseModel(pool, key);
         }
     }
+    async *invoke({ capability, args, agent, attach, fetchAttachment, progress, signal }) {
+        if (!this.opened)
+            await this.ready();
+        if (this.suspended)
+            return yield { type: 'aborted' };
+        hlog('invoke start', { capability });
+        try {
+            yield* invoke({
+                capability,
+                args,
+                tools: this._tools,
+                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)

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

@@ -36,6 +36,7 @@ export interface Agent {
     imageHeight?: number | null;
     approvalMode?: 'ask' | 'skip-all' | null;
     disabledToolsets?: string[] | null;
+    sandboxMode?: boolean | null;
 }
 export interface ImageSettings {
     modelChoice?: string;

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

@@ -24,7 +24,7 @@ import { collectToolGrants, enabledTools, isSelected, skillIsActive, skillsAreSe
 import { guardToolCall } from '../tools/outbound-guard.js';
 import { isAvailableState } from '../tools/skills/skill-state-constants.js';
 import { resolveImplicitSkill, resolveSkillMention, skillPreloadMessage } from '../tools/skills/mention.js';
-import { permittedTools } from '../tools/toolsets.js';
+import { NETWORK_TOOLSETS, permittedTools } from '../tools/toolsets.js';
 import { promptPrefixHash } from './prompt-prefix.js';
 import { logToolPrompt } from './tool-prompt-log.js';
 import { DIRECT_CALL_ID, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn, withoutSkillLoadTurns } from './tool-turns.js';
@@ -202,7 +202,7 @@ const TOOL_DENIED_MESSAGE = 'The user declined this call. Do not retry it or cal
 function deniedResult() {
     return { error: TOOL_DENIED_MESSAGE, denied: true };
 }
-function denialKey(name, args) {
+function callKey(name, args) {
     try {
         return `${name}:${JSON.stringify(args)}`;
     }
@@ -210,6 +210,34 @@ function denialKey(name, args) {
         return name;
     }
 }
+const RETRYABLE_STATUS = new Set([408, 429]);
+const RETRYABLE_CODE = new Set(['timeout', 'transport', 'busy']);
+function callSucceeded(result, outcome) {
+    if (outcome.kind !== 'success')
+        return false;
+    const exitCode = result?.exitCode;
+    return typeof exitCode !== 'number' || exitCode === 0;
+}
+function retryHints(result) {
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        return {};
+    const record = result;
+    return {
+        ...(typeof record.status === 'number' ? { status: record.status } : {}),
+        ...(typeof record.code === 'string' ? { code: record.code } : {})
+    };
+}
+function settledFailure(result, outcome) {
+    if (outcome.kind === 'denied' || callSucceeded(result, outcome))
+        return false;
+    if (outcome.kind === 'error' && outcome.error !== undefined)
+        return false;
+    const { code, status } = retryHints(result);
+    if (code !== undefined && RETRYABLE_CODE.has(code))
+        return false;
+    return status === undefined || (status < 500 && !RETRYABLE_STATUS.has(status));
+}
+const MAX_BLOCKED_REPEATS = 3;
 function terminalCall(result, outcome, options) {
     return { result, outcome, executed: options.executed };
 }
@@ -250,7 +278,7 @@ async function executeCall(tool, args, ctx, { approve, signal, denied, sources =
         });
         return blockedResult({ error: refusal, guidance: true }, refusal);
     }
-    const key = denialKey(tool.name, args);
+    const key = callKey(tool.name, args);
     if (denied?.has(key)) {
         hlog('tool denied already, not asking again', { tool: tool.name });
         return deniedCall();
@@ -366,7 +394,7 @@ function blockedSkillMessage(name, catalog, listShown) {
             `skill is available this turn — do not guess another name, and answer from what you ` +
             `already have.`;
 }
-async function resolveToolCalls(toolCalls, enabled, agentId, pipeline, skillNames, signal) {
+async function resolveToolCalls(toolCalls, enabled, agentId, pipeline, skillNames, { sandboxMode, signal }) {
     const resolved = [];
     for (const call of toolCalls) {
         if (signal?.aborted)
@@ -390,6 +418,7 @@ async function resolveToolCalls(toolCalls, enabled, agentId, pipeline, skillName
             agentId,
             skillNames,
             parameters: tool.parameters,
+            sandboxMode,
             signal
         });
         resolved.push(fold.ok
@@ -611,7 +640,10 @@ function* reportUnnamedWrites(said, landed) {
 export async function* completion(sdk, { modelId, acquireRound, model, agent, ctxSize, cacheKey, thinkingDefault, generationParams: generationParamsOverride, responseFormat, messages: storedMessages, tools: allTools = [], skillCatalog = [], approve, attach, fetchAttachment, ragSearch, progress, askUser, signal, toolConfigs, fsRoots = [], fsWriteRoots = [], captureInferenceCalls = false }) {
     const pipeline = new HookPipeline();
     const agentId = agent?.id ?? null;
-    const tools = permittedTools(allTools, agent?.disabledToolsets);
+    const disabledToolsets = agent?.sandboxMode
+        ? [...(agent.disabledToolsets ?? []), ...NETWORK_TOOLSETS]
+        : agent?.disabledToolsets;
+    const tools = permittedTools(allTools, disabledToolsets);
     const writableRoots = [
         ...fsWriteRoots,
         ...fsRoots.filter((root) => root.kind === 'hyper' && root.writable && !fsWriteRoots.includes(root))
@@ -766,6 +798,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         let roundCacheKey = stubDropped ? undefined : visionHistoryCacheKey(cacheKey, history);
         const runUsage = () => usageBreakdown(promptParts, stats.cacheTokens, model);
         const denied = new Set();
+        const failed = new Map();
+        let blockedRepeats = 0;
         let webSearches = 0;
         const sources = trustedSourcesFrom(messages);
         if (preloadedSkill)
@@ -943,7 +977,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             }
             mute = 0;
             narrated = false;
-            const resolved = await resolveToolCalls(toolCalls, enabled, agent?.id ?? null, pipeline, inContextSkills.map((skill) => skill.name), signal);
+            const resolved = await resolveToolCalls(toolCalls, enabled, agent?.id ?? null, pipeline, inContextSkills.map((skill) => skill.name), { sandboxMode: agent?.sandboxMode === true, signal });
             if (signal?.aborted)
                 throw new AbortedError();
             history = [
@@ -954,10 +988,12 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 }
             ];
             let cappedCalls = 0;
+            let progressed = false;
             runOutcomes.beginRound();
             for (const { call, tool, args, rawCall, rejection, intent } of resolved) {
                 if (signal?.aborted)
                     throw new AbortedError();
+                const priorFailure = failed.get(callKey(call.name, args));
                 const searchCapped = tool?.name === WEB_SEARCH_TOOL_NAME && webSearches >= MAX_WEB_SEARCHES_PER_TURN;
                 const callCtx = {
                     ...toolContext(turnImages, ctxSize),
@@ -975,7 +1011,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 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 silent = searchCapped || skillReloaded;
+                const silent = searchCapped || skillReloaded || priorFailure !== undefined;
                 const display = silent
                     ? undefined
                     : labelOf(call.name, args, skillCall ? skillEmoji(skillName) : skillIcon);
@@ -989,7 +1025,15 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 const unreadyReason = `skill "${skillName}" is ${unreadyState ?? 'unavailable'} and cannot be used yet. ` +
                     `Tell the user to open it in Skills and finish its setup; do not retry.`;
                 let execution;
-                if (skillReloaded) {
+                if (priorFailure) {
+                    blockedRepeats++;
+                    hlog('repeat of a call that already failed; answered without running it', {
+                        tool: call.name,
+                        blockedRepeats
+                    });
+                    execution = terminalCall(priorFailure.result, priorFailure.outcome, { executed: false });
+                }
+                else if (skillReloaded) {
                     execution = terminalCall({
                         name: skillName,
                         content: `${skillName} is already loaded. Follow the instructions you were given and do not load it again.`
@@ -1037,13 +1081,20 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 });
                 const output = settled.result;
                 const executionOutcome = settled.outcome;
+                if (!priorFailure && settledFailure(output, executionOutcome)) {
+                    failed.set(callKey(call.name, args), settled);
+                }
+                else if (execution.executed && callSucceeded(output, executionOutcome)) {
+                    progressed = true;
+                }
                 runOutcomes.record(output, executionOutcome);
                 if (searchCapped) {
                     cappedCalls++;
                     hlog('web_search capped', { searches: webSearches });
                 }
-                else if (tool?.name === WEB_SEARCH_TOOL_NAME && !rejection)
+                else if (tool?.name === WEB_SEARCH_TOOL_NAME && !rejection && !priorFailure) {
                     webSearches++;
+                }
                 if (call.name === SKILL_TOOL_NAME &&
                     output &&
                     typeof output === 'object' &&
@@ -1095,7 +1146,13 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 history.push({ role: 'tool', content: turn });
             }
             runOutcomes.finishRound();
+            if (progressed) {
+                failed.clear();
+                blockedRepeats = 0;
+            }
             history.push({ role: 'user', content: TOOL_CONTINUATION_NUDGE });
+            if (blockedRepeats >= MAX_BLOCKED_REPEATS)
+                break;
             if (cappedCalls === resolved.length) {
                 if (cappedRounds++ >= MAX_CAPPED_ROUNDS) {
                     outcome = 'search-capped';

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/invoke.d.ts

@@ -0,0 +1,15 @@
+import type { CompletionEvent, ToolDefinition, ToolExecuteContext } from './completion.ts';
+declare const CAPABILITY_TOOLS: {
+    readonly image: 'generate_image';
+};
+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;
+}
+export declare function invoke({ capability, args, tools, ctx }: InvokeOptions): AsyncGenerator<CompletionEvent>;
+export {};

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

@@ -0,0 +1,33 @@
+import { AbortedError } from '../helpers/race-abort.js';
+const CAPABILITY_TOOLS = {
+    image: 'generate_image'
+};
+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);
+    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) };
+    try {
+        const result = await tool.execute(args, ctx);
+        if (ctx.signal?.aborted)
+            return yield { type: 'aborted' };
+        yield { type: 'tool-result', name, 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: 0, durationMs: Date.now() - startedAt };
+}

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,44 @@ 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,
+            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 +142,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 +308,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 +370,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);
@@ -656,7 +684,8 @@ function knobs(agent) {
         imageWidth: agent.imageWidth ?? undefined,
         imageHeight: agent.imageHeight ?? undefined,
         approvalMode: agent.approvalMode ?? undefined,
-        disabledToolsets: agent.disabledToolsets ?? undefined
+        disabledToolsets: agent.disabledToolsets ?? undefined,
+        sandboxMode: agent.sandboxMode ?? undefined
     };
 }
 async function bridgeAttach(event, attach) {

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

@@ -38,6 +38,7 @@ export interface AgentKnobs {
     imageHeight?: number | null;
     approvalMode?: 'ask' | 'skip-all' | null;
     disabledToolsets?: string[] | null;
+    sandboxMode?: boolean | null;
 }
 export interface CompletionContext {
     model: string;
@@ -67,6 +68,24 @@ export interface CompletionContext {
         removeEventListener?: (type: 'abort', fn: () => void) => void;
     };
 }
+export interface InvokeContext {
+    capability: string;
+    args: Record<string, unknown>;
+    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;
@@ -145,10 +164,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/docx/index.js

@@ -1,9 +1,5 @@
-import b4a from 'b4a';
-import fs from 'fs';
-import { runPython } from '../tools/exec/adapters/python/pyodide.js';
-import { planVendoredInstall, vendoredManifest, wheelsDir } from '../tools/exec/adapters/python/wheels.js';
+import { extractWithPython } from '../office/python.js';
 export { closePythonWorker as closeDocxWorker } from '../tools/exec/adapters/python/worker/client.js';
-const MAX_OFFICE_BYTES = 20 * 1024 * 1024;
 const PACKAGES = ['python-docx==1.2.0'];
 const EXTRACT = `from docx import Document
 from docx.text.paragraph import Paragraph
@@ -21,29 +17,10 @@ def text(container):
 Path("extracted.txt").write_text("\\n".join(text(Document("input.docx"))), encoding="utf-8")
 `;
 export async function extractDocxText(bytes, fileName, options = {}) {
-    if (bytes.byteLength > MAX_OFFICE_BYTES) {
-        throw new Error(`document is too large to extract: ${bytes.byteLength} bytes, limit ${MAX_OFFICE_BYTES}`);
-    }
-    const dir = wheelsDir();
-    const manifest = vendoredManifest(dir);
-    const install = planVendoredInstall(PACKAGES, { dir, manifest });
-    if (!dir ||
-        !manifest ||
-        !install ||
-        !['micropip', ...install.packages].every((name) => Object.keys(manifest.files).some((file) => file.replaceAll('_', '-').startsWith(`${name}-`) && fs.existsSync(`${dir}/${file}`)))) {
-        throw new Error('bundled DOCX extraction packages are unavailable');
-    }
-    const result = await runPython(EXTRACT, {
+    return extractWithPython(bytes, fileName, {
+        format: 'DOCX',
         packages: PACKAGES,
-        inputs: [{ path: 'input.docx', bytes }],
-        outputs: ['extracted.txt'],
+        source: EXTRACT,
         signal: options.signal
     });
-    if (result.exitCode !== 0)
-        throw new Error(`${fileName}: ${result.stderr.trim()}`);
-    const output = result.files?.get('extracted.txt');
-    if (!output) {
-        throw new Error(result.rejected?.[0]?.reason ?? 'DOCX extraction produced no text file');
-    }
-    return b4a.toString(output, 'utf8');
 }

package/dist-lib/lib/hooks/built-in/index.d.ts

@@ -1,3 +1,4 @@
 export { ArgRepairHook } from './arg-repair.ts';
 export { EgressGuardHook } from './egress.ts';
+export { SandboxHook } from './sandbox.ts';
 export { SkillCatalogGuardHook } from './skill-catalog.ts';

package/dist-lib/lib/hooks/built-in/index.js

@@ -1,3 +1,4 @@
 export { ArgRepairHook } from './arg-repair.js';
 export { EgressGuardHook } from './egress.js';
+export { SandboxHook } from './sandbox.js';
 export { SkillCatalogGuardHook } from './skill-catalog.js';

package/dist-lib/lib/hooks/built-in/sandbox.d.ts

@@ -0,0 +1,5 @@
+import type { HarnessHook, HookContext, HookResult } from '../types.ts';
+export declare class SandboxHook implements HarnessHook {
+    readonly phase: 'preToolCall';
+    run(ctx: HookContext): HookResult;
+}