@qvac/harness 0.2.8 → 0.2.10

package/dist-lib/lib/office/index.js

@@ -0,0 +1,38 @@
+import path from 'path';
+import { extractDocxText } from '../docx/index.js';
+import { extractWithPython } from './python.js';
+import { XLSX_EXTRACT } from './xlsx.js';
+import { PPTX_EXTRACT } from './pptx.js';
+export { closePythonWorker as closeOfficeWorker } from '../tools/exec/adapters/python/worker/client.js';
+const OFFICE_MIME_EXTENSIONS = {
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx'
+};
+export async function extractOfficeText(bytes, fileName, options = {}) {
+    const mimeType = options.mimeType?.split(';')[0]?.trim().toLowerCase();
+    const suffix = path.extname(fileName).toLowerCase();
+    const extension = ['.docx', '.xlsx', '.pptx'].includes(suffix)
+        ? suffix
+        : OFFICE_MIME_EXTENSIONS[mimeType ?? ''];
+    if (extension === '.docx') {
+        return extractDocxText(bytes, fileName, options);
+    }
+    if (extension === '.xlsx') {
+        return extractWithPython(bytes, fileName, {
+            format: 'XLSX',
+            packages: ['openpyxl==3.1.5'],
+            source: XLSX_EXTRACT,
+            signal: options.signal
+        });
+    }
+    if (extension === '.pptx') {
+        return extractWithPython(bytes, fileName, {
+            format: 'PPTX',
+            packages: ['python-pptx==1.0.2'],
+            source: PPTX_EXTRACT,
+            signal: options.signal
+        });
+    }
+    throw new Error(`Unsupported Office document: ${fileName}`);
+}

package/dist-lib/lib/office/pptx.d.ts

@@ -0,0 +1 @@
+export declare const PPTX_EXTRACT: string;

package/dist-lib/lib/office/pptx.js

@@ -0,0 +1,26 @@
+export const PPTX_EXTRACT = `from pptx import Presentation
+from pptx.enum.shapes import MSO_SHAPE_TYPE
+from pathlib import Path
+
+def text(shapes):
+    for shape in shapes:
+        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+            yield from text(shape.shapes)
+        elif shape.has_text_frame:
+            if shape.text.strip():
+                yield shape.text
+        elif shape.has_table:
+            for row in shape.table.rows:
+                cells = ["" if cell.is_spanned else cell.text.replace("\\n", " ") for cell in row.cells]
+                if any(cell.strip() for cell in cells):
+                    yield " | ".join(cells)
+
+with Path("extracted.txt").open("w", encoding="utf-8") as output:
+    for number, slide in enumerate(Presentation("input.pptx").slides, 1):
+        heading = False
+        for block in text(slide.shapes):
+            if not heading:
+                output.write("Slide " + str(number) + "\\n")
+                heading = True
+            output.write(block + "\\n")
+`;

package/dist-lib/lib/office/python.d.ts

@@ -0,0 +1,7 @@
+import type { AbortSignal } from 'bare-abort-controller';
+export declare function extractWithPython(bytes: Uint8Array, fileName: string, { format, packages, source, signal }: {
+    readonly format: string;
+    readonly packages: readonly string[];
+    readonly source: string;
+    readonly signal?: AbortSignal | undefined;
+}): Promise<string>;

package/dist-lib/lib/office/python.js

@@ -0,0 +1,32 @@
+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';
+const MAX_OFFICE_BYTES = 20 * 1024 * 1024;
+export async function extractWithPython(bytes, fileName, { format, packages, source, signal }) {
+    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 ${format} extraction packages are unavailable`);
+    }
+    const result = await runPython(source, {
+        packages,
+        inputs: [{ path: `input.${format.toLowerCase()}`, bytes }],
+        outputs: ['extracted.txt'],
+        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 ?? `${format} extraction produced no text file`);
+    }
+    return b4a.toString(output, 'utf8');
+}

package/dist-lib/lib/office/xlsx.d.ts

@@ -0,0 +1 @@
+export declare const XLSX_EXTRACT: string;

package/dist-lib/lib/office/xlsx.js

@@ -0,0 +1,26 @@
+export const XLSX_EXTRACT = `from openpyxl import load_workbook
+from pathlib import Path
+
+formulas = load_workbook("input.xlsx", read_only=True, data_only=False, keep_links=False)
+values = load_workbook("input.xlsx", read_only=True, data_only=True, keep_links=False)
+try:
+    with Path("extracted.txt").open("w", encoding="utf-8") as output:
+        for sheet in formulas.worksheets:
+            heading = False
+            cached = values[sheet.title]
+            sheet.reset_dimensions()
+            cached.reset_dimensions()
+            for cells, results in zip(sheet.iter_rows(), cached.iter_rows()):
+                row = [result.value if cell.data_type == "f" and result.value is not None else cell.value
+                       for cell, result in zip(cells, results)]
+                if not any(value is not None and str(value).strip() for value in row):
+                    continue
+                if not heading:
+                    output.write("Sheet: " + sheet.title + "\\n")
+                    heading = True
+                output.write(" | ".join("" if value is None else str(value).replace("\\n", " ")
+                                        for value in row) + "\\n")
+finally:
+    formulas.close()
+    values.close()
+`;

package/dist-lib/lib/serve.js

@@ -414,6 +414,7 @@ function completion(harness) {
                 thinkingDefault: frame.thinkingDefault ?? undefined,
                 generationParams: frame.generationParams ?? undefined,
                 responseFormat: frame.responseFormat ?? undefined,
+                captureInferenceCalls: frame.captureInferenceCalls ?? undefined,
                 messages: (frame.messages ?? []).map(({ role, content, attachments }) => ({
                     role,
                     content,

package/dist-lib/lib/tools/edit-image.js

@@ -170,7 +170,7 @@ export function createEditImageTool(runtime, { loadMedia = defaultLoadMedia, res
             if (sources.length > 1 && !inContext)
                 return { error: MULTI_SOURCE_UNSUPPORTED };
             if (!runtime.acquire())
-                return { error: BUSY_ERROR };
+                return { error: BUSY_ERROR, code: 'busy' };
             const report = ctx.progress;
             const onTick = report && generationPercentTick((percentage) => report({ percentage }), sources.length);
             try {

package/dist-lib/lib/tools/generate-image.js

@@ -323,7 +323,7 @@ export function createGenerateImageTool(runtime, clamps) {
             if (!ctx?.attach)
                 return { error: 'this device cannot persist generated images' };
             if (!runtime.acquire())
-                return { error: BUSY_ERROR };
+                return { error: BUSY_ERROR, code: 'busy' };
             const report = ctx.progress;
             const onTick = report && generationPercentTick((percentage) => report({ percentage }));
             try {

package/dist-lib/lib/tools/generate-music.js

@@ -443,7 +443,7 @@ export function createGenerateMusicTool(runtime, clamps) {
             if (!ctx?.attach)
                 return { error: 'this device cannot persist generated audio' };
             if (!runtime.acquire())
-                return { error: BUSY_ERROR };
+                return { error: BUSY_ERROR, code: 'busy' };
             const report = ctx.progress;
             const onTick = report && musicPercentTick((percentage) => report({ percentage }));
             const capMax = stepsCap ?? MAX_STEPS;

package/dist-lib/lib/tools/http-request.js

@@ -163,10 +163,10 @@ export function createHttpRequestTool({ fetch: fetchImpl, credentialStore, crede
             }
             catch (err) {
                 const error = err instanceof Error ? err : new Error(String(err));
+                const timedOut = error.name === 'AbortError' || error instanceof AbortedError;
                 return {
-                    error: error.name === 'AbortError' || error instanceof AbortedError
-                        ? 'request timed out'
-                        : `request failed: ${error.message}`
+                    error: timedOut ? 'request timed out' : `request failed: ${error.message}`,
+                    code: timedOut ? 'timeout' : 'transport'
                 };
             }
             finally {

package/dist-lib/lib/tools/mcp-call.js

@@ -141,10 +141,10 @@ export function createMcpCallTool({ fetch: fetchImpl, credentialStore, credentia
             }
             catch (err) {
                 const error = err instanceof Error ? err : new Error(String(err));
+                const timedOut = error.name === 'AbortError' || error instanceof AbortedError;
                 return {
-                    error: error.name === 'AbortError' || error instanceof AbortedError
-                        ? 'request timed out'
-                        : `request failed: ${error.message}`
+                    error: timedOut ? 'request timed out' : `request failed: ${error.message}`,
+                    code: timedOut ? 'timeout' : 'transport'
                 };
             }
             finally {

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

@@ -131,8 +131,10 @@ export function createSkillTool({ skillsDir, overlayDir = resolveSkillsOverlayDi
                 if (file === MAIN_FILE)
                     return { error: `skill not found: ${name}` };
                 const available = await listSkillFiles([overlayDrive, baseDrive], name);
-                const listing = available.length ? ` — files this skill has: ${available.join(', ')}` : '';
-                return { error: `file not found in skill ${name}: ${file}${listing}` };
+                const rest = available.length
+                    ? ` — files this skill has: ${available.join(', ')}`
+                    : '. This skill has no other files; you already have its full instructions — act now.';
+                return { error: `file not found in skill ${name}: ${file}${rest}` };
             }
         }
     };

package/dist-lib/lib/tools/skills/auth-resolver.d.ts

@@ -19,6 +19,7 @@ export declare function isCredentialUrlAllowed(target: string, patterns: readonl
 export type CredentialAllowListFn = (ctx?: ToolExecuteContext) => CredentialAllowList;
 export type AuthOutcome = {
     readonly token: string;
+    readonly key: string;
 } | {
     readonly error: string;
 };

package/dist-lib/lib/tools/skills/auth-resolver.js

@@ -60,49 +60,79 @@ export function parseAuth(v) {
     }
     return { ok: true, value: { type: 'bearer', tokenCredentialKey: key } };
 }
-export async function resolveAuth(auth, url, credentialStore, credentialAllowList, ctx) {
-    const key = auth.tokenCredentialKey;
-    if (!credentialStore)
-        return { error: 'credentials not configured' };
-    const entry = credentialAllowList?.[key];
-    if (!entry) {
+function grantedKeys(url, credentialAllowList) {
+    return Object.entries(credentialAllowList)
+        .filter(([, entry]) => urlAllowed(url, Array.isArray(entry) ? entry : [entry]))
+        .map(([key]) => key);
+}
+async function connectedCredentials(keys, credentialStore, ctx) {
+    const connected = [];
+    for (const key of keys) {
+        const record = credentialRecord(await credentialStore(key, ctx));
+        if (record)
+            connected.push({ token: record.token, key });
+    }
+    return connected;
+}
+function ambiguous(keys) {
+    return {
+        error: `multiple credentials match this URL; set auth.tokenCredentialKey to one of ${keys.join(', ')}`
+    };
+}
+async function resolveGuessedKey(key, url, credentialStore, credentialAllowList, ctx) {
+    const granted = grantedKeys(url, credentialAllowList);
+    if (granted.length === 0) {
         return {
-            error: `credential ${key} is not available here — load the skill that declares it first`
+            error: `unknown credential key ${key}; no loaded skill grants a credential for ${url.host} — omit auth, or load the skill that declares it`
         };
     }
+    const [first, ...rest] = await connectedCredentials(granted, credentialStore, ctx);
+    if (!first) {
+        return {
+            error: `unknown credential key ${key}; no connected credential for ${url.host} (${granted.join(', ')}). Tell the user to connect it in Skills; do not retry`
+        };
+    }
+    if (rest.length > 0)
+        return ambiguous([first, ...rest].map((c) => c.key));
+    return first;
+}
+async function resolveDeclaredKey(key, url, credentialStore, credentialAllowList, ctx) {
+    const entry = credentialAllowList?.[key];
+    if (!entry)
+        return null;
     const patterns = Array.isArray(entry) ? entry : [entry];
     if (!urlAllowed(url, patterns)) {
         return { error: `credential ${key} is not allowed for URL ${url.href}` };
     }
     const record = credentialRecord(await credentialStore(key, ctx));
-    if (!record)
-        return { error: `unknown credential: ${key}` };
-    return { token: record.token };
+    if (!record) {
+        return {
+            error: `credential ${key} is not connected for ${url.host}. Tell the user to connect it in Skills; do not retry`
+        };
+    }
+    return { token: record.token, key };
+}
+export async function resolveAuth(auth, url, credentialStore, credentialAllowList, ctx) {
+    const key = auth.tokenCredentialKey;
+    if (!credentialStore)
+        return { error: 'credentials not configured' };
+    return ((await resolveDeclaredKey(key, url, credentialStore, credentialAllowList, ctx)) ??
+        resolveGuessedKey(key, url, credentialStore, credentialAllowList ?? {}, ctx));
 }
 export async function resolveAutoAuth(url, credentialStore, credentialAllowList, ctx) {
     if (!credentialStore || !credentialAllowList)
         return null;
-    let selected = null;
-    for (const [key, entry] of Object.entries(credentialAllowList)) {
-        const patterns = Array.isArray(entry) ? entry : [entry];
-        if (!urlAllowed(url, patterns))
-            continue;
-        const record = credentialRecord(await credentialStore(key, ctx));
-        if (!record)
-            continue;
-        if (selected) {
-            return { error: 'multiple credentials match this URL; set auth.tokenCredentialKey' };
-        }
-        selected = { token: record.token, key };
-    }
-    return selected;
+    const connected = await connectedCredentials(grantedKeys(url, credentialAllowList), credentialStore, ctx);
+    if (connected.length > 1)
+        return ambiguous(connected.map((c) => c.key));
+    return connected[0] ?? null;
 }
 export async function resolveBearerHeader(auth, url, credentialStore, credentialAllowList, ctx, signal) {
     if (auth) {
         const resolved = await raceAbort(resolveAuth(auth, url, credentialStore, credentialAllowList, ctx), signal);
         if ('error' in resolved)
             return { error: resolved.error };
-        return { header: `Bearer ${resolved.token}`, credentialKey: auth.tokenCredentialKey };
+        return { header: `Bearer ${resolved.token}`, credentialKey: resolved.key };
     }
     const resolved = await raceAbort(resolveAutoAuth(url, credentialStore, credentialAllowList, ctx), signal);
     if (resolved && 'error' in resolved)
@@ -112,10 +142,10 @@ export async function resolveBearerHeader(auth, url, credentialStore, credential
         : { header: null };
 }
 export async function resolveRedirectBearerHeader(auth, url, credentialStore, credentialAllowList, ctx, signal) {
-    if (!auth)
+    if (!auth || !credentialStore)
         return { header: null };
-    const resolved = await raceAbort(resolveAuth(auth, url, credentialStore, credentialAllowList, ctx), signal);
-    return 'error' in resolved
+    const resolved = await raceAbort(resolveDeclaredKey(auth.tokenCredentialKey, url, credentialStore, credentialAllowList, ctx), signal);
+    return !resolved || 'error' in resolved
         ? { header: null }
-        : { header: `Bearer ${resolved.token}`, credentialKey: auth.tokenCredentialKey };
+        : { header: `Bearer ${resolved.token}`, credentialKey: resolved.key };
 }

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

@@ -4,5 +4,6 @@ export declare function asToolset(value?: string | null): Toolset | null;
 export interface ToolsetScoped {
     toolset?: string | null;
 }
+export declare const NETWORK_TOOLSETS: ReadonlyArray<Toolset>;
 export declare function permittedTools<T extends ToolsetScoped>(tools: ReadonlyArray<T>, disabled?: ReadonlyArray<string> | null): T[];
 export declare function toolsetEnabled(toolset: Toolset, disabled?: ReadonlyArray<string> | null): boolean;

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

@@ -9,6 +9,7 @@ export const TOOLSETS = [
 export function asToolset(value) {
     return TOOLSETS.find((toolset) => toolset === value) ?? null;
 }
+export const NETWORK_TOOLSETS = ['web-search', 'http-request', 'mcp-call'];
 export function permittedTools(tools, disabled) {
     if (!disabled?.length)
         return [...tools];

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

@@ -63,7 +63,7 @@ export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookup
                 if (/location not found/i.test(body))
                     return { content: notFound(location) };
                 if (response.status !== 200) {
-                    return { error: unavailable(`it answered HTTP ${response.status}`) };
+                    return { error: unavailable(`it answered HTTP ${response.status}`), code: 'transport' };
                 }
                 let json;
                 try {
@@ -91,9 +91,15 @@ export function createWeatherLookupTool({ fetch: fetchImpl, resolveHost = lookup
                 if (ctx?.signal?.aborted)
                     return { error: 'weather_lookup cancelled' };
                 if (controller.signal.aborted) {
-                    return { error: `weather_lookup timed out after ${LOOKUP_TIMEOUT_MS} ms` };
+                    return {
+                        error: `weather_lookup timed out after ${LOOKUP_TIMEOUT_MS} ms`,
+                        code: 'timeout'
+                    };
                 }
-                return { error: unavailable(err instanceof Error ? err.message : String(err)) };
+                return {
+                    error: unavailable(err instanceof Error ? err.message : String(err)),
+                    code: 'transport'
+                };
             }
             finally {
                 clearTimeout(timeout);

package/dist-lib/lib/tools/web-fetch.js

@@ -79,7 +79,10 @@ export function createWebFetchTool({ fetch: fetchImpl, resolveHost = lookupHost
                     return { error: got.error };
                 const { response, finalUrl: currentUrl } = got;
                 if (response.status < 200 || response.status >= 300) {
-                    return { error: `HTTP ${response.status} fetching ${currentUrl.toString()}` };
+                    return {
+                        error: `HTTP ${response.status} fetching ${currentUrl.toString()}`,
+                        status: response.status
+                    };
                 }
                 const rawBody = await response.text();
                 const body = rawBody.length > MAX_HTML_CHARS ? rawBody.slice(0, MAX_HTML_CHARS) : rawBody;
@@ -140,9 +143,9 @@ export function createWebFetchTool({ fetch: fetchImpl, resolveHost = lookupHost
                     return { error: 'web_fetch cancelled' };
                 }
                 if (controller.signal.aborted) {
-                    return { error: `${url.hostname} timed out after ${PAGE_TIMEOUT_MS}ms` };
+                    return { error: `${url.hostname} timed out after ${PAGE_TIMEOUT_MS}ms`, code: 'timeout' };
                 }
-                return { error: err instanceof Error ? err.message : String(err) };
+                return { error: err instanceof Error ? err.message : String(err), code: 'transport' };
             }
             finally {
                 clearTimeout(timeout);

package/dist-lib/lib/tools/web-search.js

@@ -43,12 +43,15 @@ export function createWebSearchTool({ fetch } = {}) {
                 }
                 const failed = engineSummary.filter((e) => e.status !== 'ok').length;
                 if (engineSummary.length > 0 && failed === engineSummary.length) {
-                    return { error: `web_search unavailable: all ${failed} engines failed (timeout/error)` };
+                    return {
+                        error: `web_search unavailable: all ${failed} engines failed (timeout/error)`,
+                        code: 'transport'
+                    };
                 }
                 return { content: `No web results found for "${query}".` };
             }
             catch (err) {
-                return { error: err instanceof Error ? err.message : String(err) };
+                return { error: err instanceof Error ? err.message : String(err), code: 'transport' };
             }
         }
     };

package/dist-lib/lib/wire.js

@@ -32,6 +32,20 @@ export function toWire(event) {
             const { type, ...metrics } = event;
             return { type, metrics };
         }
+        case 'inference-call':
+            return { type: 'inference-call', payload: event.call };
+        case 'inference-sent':
+            return {
+                type: 'inference-sent',
+                payload: {
+                    round: event.round,
+                    droppedTurns: event.droppedTurns,
+                    messages: event.messages,
+                    tokens: event.tokens,
+                    outcome: event.outcome,
+                    reason: event.reason
+                }
+            };
         case 'error':
             return { type: 'error', message: event.message };
         case 'aborted':
@@ -73,6 +87,20 @@ export function fromWire(event) {
             };
         case 'metrics':
             return { type: 'metrics', ...event.metrics };
+        case 'inference-call':
+            return { type: 'inference-call', call: event.payload };
+        case 'inference-sent': {
+            const sent = (event.payload ?? {});
+            return {
+                type: 'inference-sent',
+                messages: sent.messages,
+                round: Number(sent.round ?? 0),
+                droppedTurns: Number(sent.droppedTurns ?? 0),
+                tokens: sent.tokens,
+                outcome: sent.outcome || 'completed',
+                reason: sent.reason || undefined
+            };
+        }
         case 'error':
             return { type: 'error', message: event.message ?? 'harness error' };
         case 'aborted':

package/dist-lib/schema/harness.js

@@ -23,7 +23,8 @@ export function registerHarnessTypes(ns) {
             { name: 'imageWidth', type: 'uint' },
             { name: 'imageHeight', type: 'uint' },
             { name: 'approvalMode', type: '@harness/approval-mode' },
-            { name: 'disabledToolsets', type: 'string', array: true }
+            { name: 'disabledToolsets', type: 'string', array: true },
+            { name: 'sandboxMode', type: 'bool' }
         ]
     });
     ns.register({
@@ -107,7 +108,8 @@ export function registerHarnessTypes(ns) {
             { name: 'grantedDirs', type: 'string', array: true },
             { name: 'grantedDrives', type: '@harness/granted-drive', array: true },
             { name: 'payload', type: 'json' },
-            { name: 'grantedWriteDirs', type: 'string', array: true }
+            { name: 'grantedWriteDirs', type: 'string', array: true },
+            { name: 'captureInferenceCalls', type: 'bool' }
         ]
     });
     ns.register({
@@ -128,7 +130,9 @@ export function registerHarnessTypes(ns) {
             'question-ask',
             'done',
             'tool-activity',
-            'drive-ask'
+            'drive-ask',
+            'inference-call',
+            'inference-sent'
         ],
         strings: true
     });

package/dist-lib/spec/hrpc/messages.js

@@ -1,12 +1,12 @@
 // This file is autogenerated by the hyperschema compiler
-// Schema Version: 8
+// Schema Version: 10
 /* eslint-disable camelcase */
 /* eslint-disable quotes */
 /* eslint-disable space-before-function-paren */
 
 import { c } from 'hyperschema/runtime'
 
-const VERSION = 8
+const VERSION = 10
 
 // eslint-disable-next-line no-unused-vars
 let version = VERSION
@@ -143,7 +143,8 @@ const encoding4 = {
       (m.imageWidth ? 8192 : 0) |
       (m.imageHeight ? 16384 : 0) |
       ((version >= 5 && m.approvalMode) ? 32768 : 0) |
-      ((version >= 5 && m.disabledToolsets) ? 65536 : 0)
+      ((version >= 5 && m.disabledToolsets) ? 65536 : 0) |
+      ((version >= 10 && m.sandboxMode) ? 131072 : 0)
 
     c.uint.preencode(state, flags)
 
@@ -183,7 +184,8 @@ const encoding4 = {
       (m.imageWidth ? 8192 : 0) |
       (m.imageHeight ? 16384 : 0) |
       ((version >= 5 && m.approvalMode) ? 32768 : 0) |
-      ((version >= 5 && m.disabledToolsets) ? 65536 : 0)
+      ((version >= 5 && m.disabledToolsets) ? 65536 : 0) |
+      ((version >= 10 && m.sandboxMode) ? 131072 : 0)
 
     c.uint.encode(state, flags)
 
@@ -225,7 +227,8 @@ const encoding4 = {
       imageWidth: (flags & 8192) !== 0 ? c.uint.decode(state) : 0,
       imageHeight: (flags & 16384) !== 0 ? c.uint.decode(state) : 0,
       approvalMode: (version >= 5 && (flags & 32768) !== 0) ? encoding59.decode(state) : null,
-      disabledToolsets: (version >= 5 && (flags & 65536) !== 0) ? encoding4_16.decode(state) : null
+      disabledToolsets: (version >= 5 && (flags & 65536) !== 0) ? encoding4_16.decode(state) : null,
+      sandboxMode: (version >= 10 && (flags & 131072) !== 0)
     }
   }
 }
@@ -478,7 +481,8 @@ const encoding11 = {
       ((version >= 5 && m.grantedDirs) ? 2097152 : 0) |
       ((version >= 5 && m.grantedDrives) ? 4194304 : 0) |
       ((version >= 5 && m.payload) ? 8388608 : 0) |
-      ((version >= 5 && m.grantedWriteDirs) ? 16777216 : 0)
+      ((version >= 5 && m.grantedWriteDirs) ? 16777216 : 0) |
+      ((version >= 9 && m.captureInferenceCalls) ? 33554432 : 0)
 
     encoding10.preencode(state, m.type)
     c.uint.preencode(state, flags)
@@ -533,7 +537,8 @@ const encoding11 = {
       ((version >= 5 && m.grantedDirs) ? 2097152 : 0) |
       ((version >= 5 && m.grantedDrives) ? 4194304 : 0) |
       ((version >= 5 && m.payload) ? 8388608 : 0) |
-      ((version >= 5 && m.grantedWriteDirs) ? 16777216 : 0)
+      ((version >= 5 && m.grantedWriteDirs) ? 16777216 : 0) |
+      ((version >= 9 && m.captureInferenceCalls) ? 33554432 : 0)
 
     encoding10.encode(state, m.type)
     c.uint.encode(state, flags)
@@ -592,7 +597,8 @@ const encoding11 = {
       grantedDirs: (version >= 5 && (flags & 2097152) !== 0) ? encoding11_22.decode(state) : null,
       grantedDrives: (version >= 5 && (flags & 4194304) !== 0) ? encoding11_23.decode(state) : null,
       payload: (version >= 5 && (flags & 8388608) !== 0) ? c.json.decode(state) : null,
-      grantedWriteDirs: (version >= 5 && (flags & 16777216) !== 0) ? encoding11_25.decode(state) : null
+      grantedWriteDirs: (version >= 5 && (flags & 16777216) !== 0) ? encoding11_25.decode(state) : null,
+      captureInferenceCalls: (version >= 9 && (flags & 33554432) !== 0)
     }
   }
 }
@@ -613,13 +619,15 @@ const encoding12_enum = {
   "question-ask": 'question-ask',
   done: 'done',
   "tool-activity": 'tool-activity',
-  "drive-ask": 'drive-ask'
+  "drive-ask": 'drive-ask',
+  "inference-call": 'inference-call',
+  "inference-sent": 'inference-sent'
 }
 
 // @harness/completion-event-type enum
 const encoding12 = {
   preencode (state, m) {
-    state.end++ // max enum is 16 so always one byte
+    state.end++ // max enum is 18 so always one byte
   },
   encode (state, m) {
     switch (m) {
@@ -671,6 +679,12 @@ const encoding12 = {
       case 'drive-ask':
         c.uint.encode(state, 16)
         break
+      case 'inference-call':
+        c.uint.encode(state, 17)
+        break
+      case 'inference-sent':
+        c.uint.encode(state, 18)
+        break
       default:
         throw new Error('Unknown enum')
     }
@@ -709,6 +723,10 @@ const encoding12 = {
         return 'tool-activity'
       case 16:
         return 'drive-ask'
+      case 17:
+        return 'inference-call'
+      case 18:
+        return 'inference-sent'
       default: return null
     }
   }