@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/lib/{machine/errors.js → helpers/engine-error.js}

@@ -5,6 +5,15 @@ export class RecoveryRequired extends Error {
         this.operation = operation;
     }
 }
+export class HookHalt extends Error {
+    code = 'hook-halt';
+    hook;
+    constructor(reason, hook) {
+        super(reason);
+        this.name = 'HookHalt';
+        this.hook = hook;
+    }
+}
 export class AbortedError extends Error {
     constructor() {
         super('aborted');
@@ -12,31 +21,6 @@ export class AbortedError extends Error {
         Error.captureStackTrace?.(this, AbortedError);
     }
 }
-export class ToolPolicyChanged extends Error {
-    constructor(tool) {
-        super(`Tool effect changed after approval: ${tool}`);
-        this.name = 'ToolPolicyChanged';
-    }
-}
-export const EFFECT_DRAIN_TIMEOUT_MS = 5000;
-const TIMED_OUT = Symbol('timed-out');
-export async function raceDrain(promise, timeoutMs = EFFECT_DRAIN_TIMEOUT_MS) {
-    let timer;
-    const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(TIMED_OUT), timeoutMs);
-    });
-    try {
-        return await Promise.race([promise, timeout]);
-    }
-    finally {
-        if (timer !== undefined) {
-            clearTimeout(timer);
-        }
-    }
-}
-export function didDrainTimeOut(value) {
-    return value === TIMED_OUT;
-}
 const CAUSE_DEPTH = 3;
 function tagCause(error, depth) {
     if (depth <= 0 || error === undefined || error === null)

package/dist-lib/lib/helpers/failure-result.d.ts

@@ -0,0 +1,21 @@
+import type { CompletionHistoryEntry, FailureResultReference } from '../contract/run.ts';
+export type StoredFailureResult = {
+    value: unknown;
+} | {
+    undefined: true;
+};
+export interface FailureResultValue {
+    name: string;
+    result: StoredFailureResult;
+}
+export interface ToolDeniedResult {
+    error: string;
+    denied: true;
+}
+export declare function toolDeniedResult(message: string): ToolDeniedResult;
+export declare function failureResultRef(key: string, round: number, callId: string): string;
+export declare function failureResultReference(ref: string, callId: string): FailureResultReference;
+export declare function isCompactedLength(value: unknown): value is number;
+export declare function isFailureResultReference(entry: CompletionHistoryEntry): entry is FailureResultReference;
+export declare function storeFailureResult(value: unknown): StoredFailureResult;
+export declare function readFailureResult(value: StoredFailureResult): unknown;

package/dist-lib/lib/helpers/failure-result.js

@@ -0,0 +1,39 @@
+import { isRecord } from '../guards.js';
+import { stableStringify } from './stable-stringify.js';
+export function toolDeniedResult(message) {
+    return { error: message, denied: true };
+}
+export function failureResultRef(key, round, callId) {
+    return `failure:${stableStringify([key, round, callId])}`;
+}
+export function failureResultReference(ref, callId) {
+    return { type: 'qvac-failure-result-ref', ref, callId };
+}
+const MIN_COMPACTED_LENGTH = 37;
+export function isCompactedLength(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= MIN_COMPACTED_LENGTH;
+}
+export function isFailureResultReference(entry) {
+    if (!isRecord(entry) || Array.isArray(entry)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(entry);
+    if (prototype !== Object.prototype && prototype !== null) {
+        return false;
+    }
+    const keys = Reflect.ownKeys(entry).length;
+    return (Object.hasOwn(entry, 'type') &&
+        entry.type === 'qvac-failure-result-ref' &&
+        Object.hasOwn(entry, 'ref') &&
+        typeof entry.ref === 'string' &&
+        Object.hasOwn(entry, 'callId') &&
+        typeof entry.callId === 'string' &&
+        (keys === 3 ||
+            (keys === 4 && Object.hasOwn(entry, 'compactedTo') && isCompactedLength(entry.compactedTo))));
+}
+export function storeFailureResult(value) {
+    return value === undefined ? { undefined: true } : { value };
+}
+export function readFailureResult(value) {
+    return 'undefined' in value ? undefined : value.value;
+}

package/dist-lib/lib/helpers/head-tail.d.ts

@@ -0,0 +1,7 @@
+export interface Ends {
+    readonly head: string;
+    readonly tail: string;
+    readonly total: number;
+}
+export declare function headTail(text: string, limit: number): string;
+export declare function joinHeadTail(ends: Ends, limit: number, locator?: string | null): string;

package/dist-lib/lib/helpers/head-tail.js

@@ -0,0 +1,19 @@
+function omitted(count, locator, startLine) {
+    const where = locator ? `; read_files path=${locator} startLine=${startLine}` : '';
+    return `\n…[${count} chars omitted${where}]…\n`;
+}
+export function headTail(text, limit) {
+    return text.length <= limit
+        ? text
+        : joinHeadTail({ head: text, tail: text, total: text.length }, limit);
+}
+export function joinHeadTail(ends, limit, locator) {
+    const { head, tail, total } = ends;
+    const kept = limit - omitted(total, locator, total).length;
+    if (kept < 2) {
+        return locator ? joinHeadTail(ends, limit) : head.slice(0, limit);
+    }
+    const end = Math.floor(kept / 2);
+    const start = head.slice(0, kept - end);
+    return `${start}${omitted(total - kept, locator, start.split('\n').length)}${tail.slice(tail.length - end)}`;
+}

package/dist-lib/lib/helpers/image-settings.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig, ImageSettings } from '../contract/index.ts';
+export declare function imageSettingsFrom(agent?: AgentConfig): ImageSettings | undefined;

package/dist-lib/lib/helpers/image-settings.js

@@ -0,0 +1,19 @@
+export function imageSettingsFrom(agent) {
+    if (!agent) {
+        return undefined;
+    }
+    const settings = {};
+    if (agent.imageModelChoice) {
+        settings.modelChoice = agent.imageModelChoice;
+    }
+    if (agent.imageSteps) {
+        settings.steps = agent.imageSteps;
+    }
+    if (agent.imageWidth) {
+        settings.width = agent.imageWidth;
+    }
+    if (agent.imageHeight) {
+        settings.height = agent.imageHeight;
+    }
+    return Object.keys(settings).length ? settings : undefined;
+}

package/dist-lib/lib/helpers/mcp-methods.d.ts

@@ -0,0 +1,2 @@
+export declare const METADATA_METHODS: Set<string>;
+export declare function isMetadataMethod(method: unknown): boolean;

package/dist-lib/lib/helpers/mcp-methods.js

@@ -0,0 +1,14 @@
+export const METADATA_METHODS = new Set([
+    'initialize',
+    'ping',
+    'tools/list',
+    'resources/list',
+    'resources/read',
+    'resources/templates/list',
+    'prompts/list',
+    'prompts/get',
+    'completion/complete'
+]);
+export function isMetadataMethod(method) {
+    return typeof method === 'string' && METADATA_METHODS.has(method);
+}

package/dist-lib/lib/helpers/race-abort.d.ts

@@ -1,4 +1,4 @@
-import { AbortedError } from '../machine/index.ts';
+import { AbortedError } from './engine-error.ts';
 export { AbortedError };
 export interface AbortSignalLike {
     readonly aborted: boolean;

package/dist-lib/lib/helpers/race-abort.js

@@ -1,4 +1,4 @@
-import { AbortedError } from '../machine/index.js';
+import { AbortedError } from './engine-error.js';
 export { AbortedError };
 export function raceAbort(promise, signal) {
     if (!signal)

package/dist-lib/lib/helpers/repeated-reply.d.ts

@@ -0,0 +1,2 @@
+import type { CompletionSdkResult } from '../contract/index.ts';
+export declare function withoutRepeatedReply(result: CompletionSdkResult): CompletionSdkResult;

package/dist-lib/lib/helpers/repeated-reply.js

@@ -0,0 +1,63 @@
+const MIN_REPEAT_CHARS = 16;
+function doubled(text) {
+    if (text.length < MIN_REPEAT_CHARS * 2 || text.length % 2) {
+        return false;
+    }
+    const half = text.length / 2;
+    return text.slice(0, half) === text.slice(half);
+}
+function halve(text) {
+    return doubled(text) ? text.slice(0, text.length / 2) : text;
+}
+function firstHalf(items, key) {
+    const half = items.length / 2;
+    if (items.length % 2) {
+        return items;
+    }
+    const repeats = items.slice(half).every((item, at) => key(item) === key(items[at]));
+    return repeats ? items.slice(0, half) : items;
+}
+async function* withoutRepeatedTail(tokens) {
+    let streamed = '';
+    let held = '';
+    for await (const token of tokens) {
+        if (held && streamed.startsWith(held + token)) {
+            held += token;
+            continue;
+        }
+        if (held) {
+            yield held;
+            streamed += held;
+            held = '';
+        }
+        if (streamed.length >= MIN_REPEAT_CHARS && token && streamed.startsWith(token)) {
+            held = token;
+            continue;
+        }
+        streamed += token;
+        yield token;
+    }
+    if (held && held !== streamed) {
+        yield held;
+    }
+}
+function once(reply) {
+    if (!doubled(reply.raw.fullText)) {
+        return reply;
+    }
+    return {
+        ...reply,
+        contentText: halve(reply.contentText),
+        thinkingText: reply.thinkingText && halve(reply.thinkingText),
+        raw: { ...reply.raw, fullText: halve(reply.raw.fullText) },
+        toolCalls: firstHalf(reply.toolCalls, ({ name, arguments: args }) => JSON.stringify([name, args])),
+        toolErrors: reply.toolErrors &&
+            firstHalf(reply.toolErrors, ({ code, message, raw }) => JSON.stringify([code, message, raw]))
+    };
+}
+export function withoutRepeatedReply(result) {
+    const final = result.final.then(once);
+    final.catch(noop);
+    return { ...result, tokenStream: withoutRepeatedTail(result.tokenStream), final };
+}
+function noop() { }

package/dist-lib/lib/helpers/run-outcome.d.ts

@@ -1,14 +1,15 @@
-import type { RunOutcome } from '../machine/index.ts';
-import type { ToolExecutionOutcome } from '../tool-call-display.ts';
+import type { RunOutcome, ToolExecutionOutcome } from '../contract/index.ts';
 export type { RunOutcome };
 export declare const DEGENERATE_ANSWER_FALLBACK = "I couldn't complete that step and don't have a useful result to share.";
 export declare const ROUND_CAP_ANSWER = "I ran out of steps before I could finish that. Ask me to continue and I'll pick up where I left off.";
 export declare const SEARCH_CAPPED_ANSWER = "I searched the web but couldn't find the answer in the results I got.";
+export declare const DELIVERED_ANSWER = "Your file is attached to the chat.";
 export declare const WRITE_RESULT_LEAD = "Here's what came back:";
 export declare const TIME_CAPPED_ANSWER = "I hit this run's time budget before I could finish that. Ask me to continue and I'll pick up where I left off.";
 export interface RunOutcomeFacts {
     readonly latestFailure: string | null;
     readonly confirmedWrites: ReadonlyArray<string>;
+    readonly delivered?: boolean;
 }
 export interface HistoryTurn {
     readonly role: string;
@@ -32,8 +33,8 @@ export interface RunOutcomeState {
 export declare function createRunOutcomeTracker(state?: RunOutcomeState): RunOutcomeTracker;
 export declare function normalizeToolExecutionOutcome(result: unknown, outcome: ToolExecutionOutcome): ToolExecutionOutcome;
 export declare function failureFromToolExecution(result: unknown, outcome: ToolExecutionOutcome): string | null;
-export declare function degenerateAnswer(outcome: Exclude<RunOutcome, 'answered'>, history: ReadonlyArray<HistoryTurn>, facts?: RunOutcomeFacts): string;
-export declare function lastFailedToolAnswer(history: ReadonlyArray<HistoryTurn>): string | null;
+export declare function degenerateAnswer(outcome: Exclude<RunOutcome, 'answered'>, history: ReadonlyArray<HistoryTurn>, facts: RunOutcomeFacts): string;
+export declare function lastFailedToolAnswer(history: ReadonlyArray<HistoryTurn>, nudge: string): string | null;
 export declare function writeResult(output: unknown): string | null;
 export declare function unnamedWrites(answer: string, landed: ReadonlyArray<string>): ReadonlyArray<string>;
 export declare function writeReport(landed: ReadonlyArray<string>): string | null;

package/dist-lib/lib/helpers/run-outcome.js

@@ -1,8 +1,8 @@
-import { TOOL_CONTINUATION_NUDGE } from '../capabilities/tool-turns.js';
 import { isRecord } from '../guards.js';
 export const DEGENERATE_ANSWER_FALLBACK = "I couldn't complete that step and don't have a useful result to share.";
 export const ROUND_CAP_ANSWER = "I ran out of steps before I could finish that. Ask me to continue and I'll pick up where I left off.";
 export const SEARCH_CAPPED_ANSWER = "I searched the web but couldn't find the answer in the results I got.";
+export const DELIVERED_ANSWER = 'Your file is attached to the chat.';
 export const WRITE_RESULT_LEAD = "Here's what came back:";
 export const TIME_CAPPED_ANSWER = "I hit this run's time budget before I could finish that. Ask me to continue and I'll pick up where I left off.";
 const MAX_FAILURE_CHARS = 300;
@@ -66,12 +66,13 @@ export function failureFromToolExecution(result, outcome) {
     return resultFailure(result);
 }
 export function degenerateAnswer(outcome, history, facts) {
-    const rest = (facts ? facts.latestFailure : lastFailedToolAnswer(history)) ?? cappedAnswer(outcome, history);
-    const written = writeReport(facts?.confirmedWrites ?? []);
-    if (written) {
-        return rest ? `${written}\n\n${rest}` : written;
-    }
-    return rest ?? DEGENERATE_ANSWER_FALLBACK;
+    const rest = facts.latestFailure ?? cappedAnswer(outcome, history);
+    const lines = [
+        writeReport(facts.confirmedWrites),
+        facts.delivered ? DELIVERED_ANSWER : null,
+        rest
+    ].filter((line) => line !== null);
+    return lines.length ? lines.join('\n\n') : DEGENERATE_ANSWER_FALLBACK;
 }
 function cappedAnswer(outcome, history) {
     if (outcome === 'search-capped') {
@@ -108,10 +109,11 @@ function searchCappedAnswer(history) {
     }
     return `${SEARCH_CAPPED_ANSWER} These pages looked most relevant:\n${lines.join('\n')}`;
 }
-export function lastFailedToolAnswer(history) {
+export function lastFailedToolAnswer(history, nudge) {
     for (let i = history.length - 1; i >= 0; i--) {
         const turn = history[i];
-        if (turn?.role === 'user' && turn.content === TOOL_CONTINUATION_NUDGE) {
+        if (turn?.role === 'user' &&
+            (turn.content === nudge || turn.content.startsWith(`${nudge}\nPlan:\n`))) {
             continue;
         }
         if (turn?.role !== 'tool') {

package/dist-lib/lib/{machine → helpers}/stable-stringify.js

@@ -1,4 +1,4 @@
-import { isRecord } from './guards.js';
+import { isRecord } from '../guards.js';
 export function stableStringify(value) {
     if (Array.isArray(value)) {
         return `[${value.map(stableStringify).join(',')}]`;

package/dist-lib/lib/helpers/tool-call-markup.d.ts

@@ -5,6 +5,7 @@ export interface RecoveredToolCall {
     raw?: string;
 }
 export declare const MAX_RAW_CALL_CHARS = 4096;
+export declare const MALFORMED_CALL_ID = "call-malformed";
 export declare function clipRawCall(raw: string): string;
 export interface KnownTool {
     readonly name: string;

package/dist-lib/lib/helpers/tool-call-markup.js

@@ -4,6 +4,7 @@ const TOOL_RESPONSE = { open: '<tool_response>', close: '</tool_response>' };
 const TOOL_CALL = { open: '<tool_call>', close: '</tool_call>' };
 const MAX_NAME_LENGTH = 64;
 export const MAX_RAW_CALL_CHARS = 4096;
+export const MALFORMED_CALL_ID = 'call-malformed';
 export function clipRawCall(raw) {
     return raw.length > MAX_RAW_CALL_CHARS ? raw.slice(0, MAX_RAW_CALL_CHARS) : raw;
 }
@@ -81,7 +82,7 @@ function redactedMarkupBlock(block, redactArgs) {
     const redacted = redactArgs(block.name, decoded);
     const replacement = deepEqual(decoded, redacted)
         ? null
-        : markupForCall({ name: block.name, arguments: redacted });
+        : functionMarkup({ name: block.name, arguments: redacted });
     return replacement;
 }
 export function redactBareParameterMarkup(text, isSensitiveName) {
@@ -201,13 +202,16 @@ export function toolCallMarkup(calls) {
     return calls.map(markupForCall).join('\n');
 }
 function markupForCall(call) {
+    return `<tool_call>\n${functionMarkup(call)}\n</tool_call>`;
+}
+function functionMarkup(call) {
     const params = Object.entries(call.arguments ?? {})
-        .map(([key, value]) => `<parameter=${key}>${encodeMarkupValue(value)}</parameter>`)
+        .map(([key, value]) => `<parameter=${key}>\n${markupValue(value)}\n</parameter>\n`)
         .join('');
-    return `<function=${call.name}>${params}</function>`;
+    return `<function=${call.name}>\n${params}</function>`;
 }
-function encodeMarkupValue(value) {
-    return JSON.stringify(value ?? null).replace(/</g, '\\u003c');
+function markupValue(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value ?? null);
 }
 const ARG_WRAPPER_KEYS = new Set(['parameters', 'arguments', 'args', 'input', 'params']);
 function isPlainObject(value) {

package/dist-lib/lib/helpers/tool-label.d.ts

@@ -1,5 +1,5 @@
-import type { ResponseFormat } from '../capabilities/completion.ts';
-import type { ToolCallDisplay } from '../tool-call-display.ts';
+import type { ResponseFormat } from '../contract/index.ts';
+import type { ToolCallDisplay } from '../contract/index.ts';
 export declare const TOOL_LABEL_SCHEMA: ResponseFormat;
 export declare function buildToolLabelPrompt(name: string, args: Record<string, unknown>): string;
 export declare function skillCallLabel(args: Record<string, unknown>): string;

package/dist-lib/lib/helpers/tool-label.js

@@ -1,6 +1,6 @@
 import { unwrap } from 'asenion';
-import { SKILL_TOOL_NAME } from '../capabilities/tool-names.js';
-import { unquoteArg } from '../tools/model-args.js';
+import { Agent } from '../agent/index.js';
+import { unquoteArg } from './model-args.js';
 import { stripControlTokens } from './control-tokens.js';
 const MAX_LABEL_WORDS = 6;
 const MAX_LABEL_LENGTH = 60;
@@ -65,7 +65,7 @@ export function skillCallLabel(args) {
     return file ? `Read ${title}/${fileName(file)}` : `Load ${title}`;
 }
 export function isSkillTool(name) {
-    return name === SKILL_TOOL_NAME;
+    return name === Agent.SKILL_TOOL_NAME;
 }
 function stringArg(args, key) {
     const value = args[key];

package/dist-lib/lib/hooks/built-in/arg-repair.d.ts

@@ -1,4 +1,4 @@
-import type { HarnessHook, HookContext, HookResult } from '../types.ts';
+import type { HarnessHook, HookContext, HookResult } from '../../contract/index.ts';
 export declare class ArgRepairHook implements HarnessHook {
     readonly name = "arg-repair";
     readonly phase: 'preToolCall';

package/dist-lib/lib/hooks/built-in/arg-repair.js

@@ -1,35 +1,125 @@
 import { jsonrepair } from 'jsonrepair';
 import { isRecord } from '../../guards.js';
 import { hlog } from '../../log.js';
-const STRUCTURED_TYPES = new Set(['object', 'array']);
+import { escapeLiteralDollars } from '../../tools/exec/scope.js';
+const JSON_NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
 export class ArgRepairHook {
     name = 'arg-repair';
     phase = 'preToolCall';
     run(ctx) {
         if (ctx.phase !== 'preToolCall' || !ctx.parameters)
             return;
-        let args = ctx.args;
-        for (const [key, schema] of Object.entries(ctx.parameters.properties)) {
-            const value = args[key];
-            if (typeof value !== 'string') {
-                continue;
+        let args = coerceProperties(ctx.args, ctx.parameters, { tool: ctx.toolName, path: '' });
+        if (ctx.toolName === 'exec' && args.language !== 'python' && typeof args.command === 'string') {
+            const command = escapeLiteralDollars(args.command);
+            if (command !== args.command) {
+                args = { ...args, command };
             }
-            const types = structuredTypes(schema);
-            if (types.size === 0) {
-                continue;
-            }
-            const parsed = parseStructured(value, types);
-            if (parsed === null) {
-                hlog('arg repair declined', { tool: ctx.toolName, param: key, length: value.length });
-                continue;
-            }
-            args = { ...args, [key]: parsed };
         }
         if (args !== ctx.args) {
             return { args };
         }
     }
 }
+function coerce(value, schema, site) {
+    if (!isPlainObject(schema)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return coerceString(value, schema, site);
+    }
+    if (Array.isArray(value)) {
+        return coerceItems(value, schema.items, site);
+    }
+    if (isPlainObject(value)) {
+        return coerceProperties(value, schema, site);
+    }
+    return value;
+}
+function coerceString(value, schema, site) {
+    const folded = foldEnum(value, schema.enum);
+    if (folded !== undefined) {
+        return folded;
+    }
+    const types = schemaTypes(schema);
+    const structured = types.has('object') || types.has('array');
+    if (structured) {
+        const parsed = parseStructured(value, types);
+        if (parsed !== null) {
+            return coerce(parsed, schema, site);
+        }
+    }
+    const scalarOnly = types.size > 0 && !types.has('string');
+    if (scalarOnly) {
+        const scalar = parseScalar(value.trim(), types);
+        if (scalar !== undefined) {
+            return scalar;
+        }
+    }
+    if (structured || scalarOnly) {
+        hlog('arg repair declined', { tool: site.tool, param: site.path, length: value.length });
+    }
+    return value;
+}
+function coerceProperties(value, schema, site) {
+    if (!isPlainObject(schema.properties)) {
+        return value;
+    }
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    let out = null;
+    for (const [key, child] of Object.entries(schema.properties)) {
+        const before = value[key];
+        if (before === 'null' && !required.includes(key) && omittable(child)) {
+            out ??= { ...value };
+            delete out[key];
+            continue;
+        }
+        const after = coerce(before, child, at(site, key));
+        if (after !== before) {
+            out ??= { ...value };
+            out[key] = after;
+        }
+    }
+    return out ?? value;
+}
+function coerceItems(value, items, site) {
+    const out = value.map((item, i) => coerce(item, items, at(site, String(i))));
+    return out.some((item, i) => item !== value[i]) ? out : value;
+}
+function at(site, key) {
+    return { tool: site.tool, path: site.path ? `${site.path}.${key}` : key };
+}
+function foldEnum(value, values) {
+    if (!Array.isArray(values) || values.includes(value))
+        return undefined;
+    const lower = value.toLowerCase();
+    const matches = values.filter((v) => typeof v === 'string' && v.toLowerCase() === lower);
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function parseScalar(text, types) {
+    if (text === 'null' && types.has('null'))
+        return null;
+    const lower = text.toLowerCase();
+    if (types.has('boolean') && (lower === 'true' || lower === 'false')) {
+        return lower === 'true';
+    }
+    if (!JSON_NUMBER.test(text)) {
+        return undefined;
+    }
+    const number = Number(text);
+    if (number === 0 && /[1-9]/.test(text.split(/e/i)[0])) {
+        return undefined;
+    }
+    if (Number.isInteger(number)) {
+        const numeric = types.has('integer') || types.has('number');
+        return numeric && Number.isSafeInteger(number) ? number : undefined;
+    }
+    return types.has('number') && Number.isFinite(number) ? number : undefined;
+}
+function omittable(schema) {
+    const types = schemaTypes(schema);
+    return types.size > 0 && !types.has('string') && !types.has('null');
+}
 function parseStructured(value, types) {
     const text = value.trim();
     const parsed = read(text);
@@ -70,14 +160,14 @@ function accept(value, types) {
         return value;
     return null;
 }
-function structuredTypes(schema) {
+function schemaTypes(schema) {
     const found = new Set();
     if (!isPlainObject(schema)) {
         return found;
     }
     const declared = Array.isArray(schema.type) ? schema.type : [schema.type];
     for (const type of declared) {
-        if (typeof type === 'string' && STRUCTURED_TYPES.has(type)) {
+        if (typeof type === 'string') {
             found.add(type);
         }
     }
@@ -87,7 +177,7 @@ function structuredTypes(schema) {
             continue;
         }
         for (const branch of branches) {
-            for (const type of structuredTypes(branch)) {
+            for (const type of schemaTypes(branch)) {
                 found.add(type);
             }
         }

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

@@ -1,4 +1,4 @@
-import type { HarnessHook, HookContext, HookResult } from '../types.ts';
+import type { HarnessHook, HookContext, HookResult } from '../../contract/index.ts';
 export declare class EgressGuardHook implements HarnessHook {
     readonly name = "egress-guard";
     readonly phase: 'preToolCall';

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

@@ -1,4 +1,3 @@
-import { mcpTargetUrl } from '../../tools/mcp-call.js';
 import { checkOutboundHost } from '../../tools/url-guard.js';
 export class EgressGuardHook {
     name = 'egress-guard';
@@ -6,26 +5,19 @@ export class EgressGuardHook {
     run(ctx) {
         if (ctx.phase !== 'preToolCall')
             return;
-        let target;
-        if (ctx.toolName === 'http_request' || ctx.toolName === 'web_fetch') {
-            target = typeof ctx.args.url === 'string' ? ctx.args.url : '';
-        }
-        else if (ctx.toolName === 'mcp_call') {
-            target = mcpTargetUrl(ctx.args);
-        }
-        else {
-            return;
-        }
-        let url;
-        try {
-            url = new URL(target);
-        }
-        catch {
-            return;
-        }
-        const blocked = checkOutboundHost(url);
-        if (blocked) {
-            return { kind: 'hook-rejection', error: blocked, guidance: true };
+        const targets = ctx.egress?.(ctx.args) ?? [];
+        for (const target of typeof targets === 'string' ? [targets] : targets) {
+            let url;
+            try {
+                url = new URL(target);
+            }
+            catch {
+                continue;
+            }
+            const blocked = checkOutboundHost(url);
+            if (blocked) {
+                return { kind: 'hook-rejection', error: blocked, guidance: true };
+            }
         }
     }
 }

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

@@ -1,4 +1,4 @@
-import type { HarnessHook, HookContext, HookResult } from '../types.ts';
+import type { HarnessHook, HookContext, HookResult } from '../../contract/index.ts';
 export declare class SandboxHook implements HarnessHook {
     readonly name = "sandbox";
     readonly phase: 'preToolCall';