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

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

@@ -0,0 +1,267 @@
+import { createEmbedLane } from '../capabilities/embed.js';
+import { AbortedError, raceAbort } from '../helpers/race-abort.js';
+import { assertEmbedDevice, createEmbedConfig } from '../models/embed-config.js';
+import { curatedModelAsset, residentSrc } from '../models/model-catalog.js';
+import { ModelFit } from '../models/model-fit.js';
+import { createEmbedPool, evictIdle, isResident, ModelUnloadError, releaseModel } from '../models/model-pool.js';
+import { openclCacheDir } from '../models/opencl-cache.js';
+import { createGpuFaultState, isSdkGpuDeviceLostError } from '../models/sdk-faults.js';
+const EMBED_FIT_TOKENS = 1_048_576;
+export class Embeddings {
+    _sdk;
+    _loads;
+    _gate;
+    _notify;
+    _settleFit;
+    _evictIdleChat;
+    _embedModels;
+    _retiredEmbedModels = new Set();
+    _faultedEmbedKeys = new WeakMap();
+    _embedLane = createEmbedLane();
+    _embedFaults;
+    _embedGpuLayers;
+    _embedBatchSize;
+    _embedControl = Promise.resolve();
+    constructor(opts) {
+        this._sdk = opts.sdk;
+        this._loads = opts.loads;
+        this._gate = opts.gate;
+        this._notify = opts.notify;
+        this._settleFit = opts.settleFit;
+        this._evictIdleChat = opts.evictIdleChat;
+        const embedConfig = createEmbedConfig({
+            device: opts.device,
+            gpuLayers: opts.gpuLayers,
+            batchSize: opts.batchSize
+        });
+        this._embedGpuLayers = embedConfig.gpuLayers;
+        this._embedBatchSize = embedConfig.batchSize;
+        this._embedFaults = createGpuFaultState({
+            device: embedConfig.device,
+            gpuLayers: embedConfig.gpuLayers
+        });
+        this._embedModels = this._createEmbedPool();
+    }
+    get pool() {
+        return this._embedModels;
+    }
+    get device() {
+        return this._embedFaults.device;
+    }
+    pools() {
+        return [this._embedModels, ...this._retiredEmbedModels];
+    }
+    target(model) {
+        const key = this._embedFaults.key(residentSrc(model, 'embeddings'));
+        return { pool: this._embedModels, key, open: () => this._embedModels.open(key, model) };
+    }
+    recreate() {
+        this._embedModels = this._createEmbedPool();
+    }
+    evictIdle() {
+        return [
+            evictIdle(this._embedModels),
+            ...[...this._retiredEmbedModels].map((pool) => this._collectRetiredEmbedPool(pool))
+        ];
+    }
+    setDevice(device) {
+        assertEmbedDevice(device);
+        return this._enqueueEmbedControl(() => this._setEmbeddingDevice(device));
+    }
+    async makeRoom(model, { pool, key }) {
+        const asset = curatedModelAsset(model, 'embeddings');
+        if (!asset || pool !== this._embedModels || isResident(this._embedModels, key)) {
+            return;
+        }
+        const assessed = await this._settleFit(ModelFit.query(asset, EMBED_FIT_TOKENS, { modelType: 'embeddings' }));
+        if (assessed?.verdict !== 'likely-too-large') {
+            return;
+        }
+        await this._evictIdleChat();
+    }
+    async destroy() {
+        const pools = [this._embedModels, ...this._retiredEmbedModels].filter((pool) => Boolean(pool));
+        const outcomes = await Promise.allSettled(pools.map(async (pool) => {
+            await pool.destroy();
+            this._retiredEmbedModels.delete(pool);
+        }));
+        const generic = outcomes.find((outcome) => outcome.status === 'rejected' && !(outcome.reason instanceof ModelUnloadError));
+        if (generic?.status === 'rejected') {
+            throw generic.reason;
+        }
+        const failed = outcomes.find((outcome) => outcome.status === 'rejected');
+        if (failed?.status === 'rejected') {
+            throw failed.reason;
+        }
+    }
+    async embed({ model, texts, signal }) {
+        if (!this._gate.opened) {
+            await this._gate.ready();
+        }
+        this._gate.assertNotClosing();
+        if (this._gate.suspended) {
+            throw new Error('harness is suspended');
+        }
+        if (texts.length === 0) {
+            return [];
+        }
+        const pool = this._embedModels;
+        const faults = this._embedFaults;
+        const generation = faults.generation;
+        const key = faults.key(residentSrc(model, 'embeddings'));
+        await this.makeRoom(model, { pool, key });
+        const releaseWork = this._gate.enterWork();
+        let handle;
+        try {
+            handle = pool.open(key, model);
+        }
+        catch (error) {
+            releaseWork();
+            throw error;
+        }
+        let loaded = null;
+        let job = null;
+        let releaseAfter = null;
+        let drainWorkAfter = null;
+        try {
+            loaded = await raceAbort(handle.load(), signal);
+            const sdk = await this._sdk.loadEmbed();
+            this._gate.assertNotClosing();
+            job = this._embedLane(sdk, { modelId: loaded.modelId, texts });
+            const vectors = await raceAbort(job, signal);
+            faults.reset();
+            return vectors;
+        }
+        catch (err) {
+            if (err instanceof AbortedError) {
+                if (job || this._retiredEmbedModels.has(pool)) {
+                    releaseAfter = job ?? handle.peek();
+                }
+                else {
+                    drainWorkAfter = handle.peek();
+                }
+            }
+            if (isSdkGpuDeviceLostError(err)) {
+                this._markEmbedFault({ pool, key, faults, generation });
+            }
+            throw err;
+        }
+        finally {
+            if (releaseAfter) {
+                void this._releaseEmbedResourceAfter(releaseAfter, {
+                    pool,
+                    key,
+                    faults,
+                    generation
+                }).finally(releaseWork);
+            }
+            else {
+                const releasing = this._releaseEmbedResource(pool, key);
+                if (drainWorkAfter) {
+                    void Promise.allSettled([releasing, drainWorkAfter]).then(releaseWork);
+                }
+                else {
+                    await this._releaseEmbedResourceBeforeWork(releasing, releaseWork);
+                }
+            }
+        }
+    }
+    _createEmbedPool() {
+        const loadSdk = () => this._sdk.loadEmbed();
+        return createEmbedPool(loadSdk, (state) => this._notify(state), {
+            faults: this._embedFaults,
+            batchSize: this._embedBatchSize,
+            openclCacheDir,
+            loads: this._loads,
+            onUnloadFailure: (modelId, error) => this._gate.recordModelUnloadFailure(modelId, error)
+        });
+    }
+    async _collectRetiredEmbedPool(pool) {
+        if (!this._retiredEmbedModels.has(pool) || pool.idle !== pool.size)
+            return;
+        try {
+            await pool.destroy();
+        }
+        catch (error) {
+            if (!(error instanceof ModelUnloadError)) {
+                this._gate.recordPoolCleanupFailure();
+            }
+            throw error;
+        }
+        this._retiredEmbedModels.delete(pool);
+    }
+    async _releaseEmbedResource(pool, key) {
+        releaseModel(pool, key);
+        const faulted = this._faultedEmbedKeys.get(pool);
+        if (faulted?.has(key)) {
+            await evictIdle(pool);
+            if (!isResident(pool, key)) {
+                faulted.delete(key);
+            }
+        }
+        await this._collectRetiredEmbedPool(pool);
+    }
+    async _releaseEmbedResourceBeforeWork(releasing, releaseWork) {
+        try {
+            await releasing;
+        }
+        finally {
+            releaseWork();
+        }
+    }
+    _markEmbedFault({ pool, key, faults, generation }) {
+        faults.recordFault(generation);
+        let faulted = this._faultedEmbedKeys.get(pool);
+        if (!faulted) {
+            faulted = new Set();
+            this._faultedEmbedKeys.set(pool, faulted);
+        }
+        faulted.add(key);
+    }
+    _releaseEmbedResourceAfter(settled, fault) {
+        return settled
+            .then(() => this._releaseEmbedResource(fault.pool, fault.key), (error) => {
+            if (isSdkGpuDeviceLostError(error)) {
+                this._markEmbedFault(fault);
+            }
+            return this._releaseEmbedResource(fault.pool, fault.key);
+        })
+            .catch(noop);
+    }
+    _enqueueEmbedControl(run) {
+        const next = this._embedControl.then(run, run);
+        this._embedControl = next.catch(noop);
+        return next;
+    }
+    async _setEmbeddingDevice(device) {
+        if (!this._gate.opened) {
+            await this._gate.ready();
+        }
+        if (this._gate.suspended) {
+            this._gate.assertNotClosing();
+            if (this._embedFaults.device === device) {
+                return;
+            }
+            this._embedFaults = createGpuFaultState({ device, gpuLayers: this._embedGpuLayers });
+            return;
+        }
+        const releaseWork = this._gate.enterWork();
+        try {
+            if (this._embedFaults.device === device) {
+                return;
+            }
+            this._embedFaults = createGpuFaultState({ device, gpuLayers: this._embedGpuLayers });
+            if (this._gate.suspended) {
+                return;
+            }
+            const retired = this._embedModels;
+            this._retiredEmbedModels.add(retired);
+            this._embedModels = this._createEmbedPool();
+            await this._collectRetiredEmbedPool(retired);
+        }
+        finally {
+            releaseWork();
+        }
+    }
+}
+function noop() { }

package/dist-lib/lib/fold/index.d.ts

@@ -0,0 +1,50 @@
+import type { FoldEvent, Message } from '../contract/index.ts';
+export interface FoldReading {
+    cacheTokens: number | undefined;
+    ctxSize: number | undefined;
+}
+export interface FoldSummary {
+    text: string | null;
+    overflowed: boolean;
+}
+export type Summarize = (prompt: string) => Promise<FoldSummary>;
+export type FoldRefusal = 'below-floor' | 'no-id' | 'nothing-to-fold' | 'already-compacted' | 'no-summary' | 'summary-not-smaller';
+export interface FoldBoundary {
+    end: number;
+    foldedTurns: number;
+}
+export type FoldResult = {
+    folded: true;
+    summary: string;
+    throughId: string;
+    foldedTurns: number;
+    end: number;
+} | {
+    folded: false;
+    reason: FoldRefusal;
+};
+export interface FoldOptions {
+    ctxSize?: number | undefined;
+    instructions?: string | undefined;
+}
+export declare class Fold {
+    static FLOOR: number;
+    static TIERS: readonly (readonly [below: number, ratio: number])[];
+    static RATIO: number;
+    static KEEP_TURNS: number;
+    static PREFIX: string;
+    summarize: Summarize;
+    constructor(summarize: Summarize);
+    static turn(summary: string): string;
+    static isSummary(message: Pick<Message, 'role' | 'content'>): boolean;
+    static ratio(ctxSize: number): number;
+    static fits(ctxSize: number | undefined): boolean;
+    static due({ cacheTokens, ctxSize }: FoldReading): boolean;
+    static observe(cacheKey: string, reading: FoldReading): void;
+    static reading(cacheKey: string): FoldReading | undefined;
+    static forget(cacheKey: string): void;
+    static boundary(messages: readonly Message[], keepTurns?: number): FoldBoundary | null;
+    static prompt(messages: readonly Message[], instructions?: string): string;
+    static shrinks(folded: readonly Message[], summary: string): boolean;
+    run(messages: readonly Message[], options?: FoldOptions): AsyncGenerator<FoldEvent, FoldResult>;
+}

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

@@ -0,0 +1,123 @@
+const TIERS = [
+    [12_288, 0.75],
+    [16_384, 0.82],
+    [32_768, 0.85],
+    [65_536, 0.9]
+];
+const readings = new Map();
+export class Fold {
+    static FLOOR = 4_096;
+    static TIERS = TIERS;
+    static RATIO = 0.95;
+    static KEEP_TURNS = 1;
+    static PREFIX = '[Summary of the earlier conversation in this chat, written by another model. Treat it as established context, not as a new request.]';
+    summarize;
+    constructor(summarize) {
+        this.summarize = summarize;
+    }
+    static turn(summary) {
+        return `${Fold.PREFIX}\n\n${summary}`;
+    }
+    static isSummary(message) {
+        return message.role === 'user' && message.content.startsWith(Fold.PREFIX);
+    }
+    static ratio(ctxSize) {
+        return TIERS.find(([below]) => ctxSize < below)?.[1] ?? Fold.RATIO;
+    }
+    static fits(ctxSize) {
+        return ctxSize === undefined || ctxSize >= Fold.FLOOR;
+    }
+    static due({ cacheTokens, ctxSize }) {
+        if (!cacheTokens || !ctxSize)
+            return false;
+        return cacheTokens >= ctxSize * Fold.ratio(ctxSize);
+    }
+    static observe(cacheKey, reading) {
+        readings.set(cacheKey, reading);
+    }
+    static reading(cacheKey) {
+        return readings.get(cacheKey);
+    }
+    static forget(cacheKey) {
+        readings.delete(cacheKey);
+    }
+    static boundary(messages, keepTurns = Fold.KEEP_TURNS) {
+        const users = messages.flatMap((message, at) => message.role === 'user' && !Fold.isSummary(message) ? [at] : []);
+        if (users.length <= keepTurns) {
+            return null;
+        }
+        const end = users[users.length - keepTurns];
+        return end > 0 ? { end, foldedTurns: users.length - keepTurns } : null;
+    }
+    static prompt(messages, instructions) {
+        const prior = messages[0] !== undefined && Fold.isSummary(messages[0]);
+        const transcript = messages
+            .map((message) => {
+            const sender = message.role === 'user' && message.name ? `${message.name}: ` : '';
+            return `${message.role === 'user' ? 'User' : 'Assistant'}: ${sender}${message.content}`;
+        })
+            .join('\n\n');
+        return [
+            'Summarize the conversation below so another model can continue it without seeing it.',
+            prior
+                ? 'The conversation opens with an earlier summary. Carry everything from it that is still true into your new summary — it is discarded after this, so whatever you leave out is lost — and correct it where the later turns disagree.'
+                : null,
+            'Output exactly these four sections, in this order, keeping every heading even when it has nothing under it:',
+            '## Objective\n## Facts and decisions\n## State\n## Next steps',
+            'Rules: at most three bullets per section, at most fifteen words per bullet. Preserve names, numbers, file paths and identifiers exactly. Write "(none)" under a heading with nothing to say. Do not continue the conversation, do not answer anything asked in it, and do not mention summarizing.',
+            instructions ? `Also: ${instructions}` : null,
+            '<conversation>',
+            transcript,
+            '</conversation>'
+        ]
+            .filter((part) => part !== null)
+            .join('\n\n');
+    }
+    static shrinks(folded, summary) {
+        const replaced = folded.reduce((total, message) => total + message.content.length, 0);
+        return Fold.turn(summary).length < replaced;
+    }
+    async *run(messages, options = {}) {
+        if (!Fold.fits(options.ctxSize)) {
+            return { folded: false, reason: 'below-floor' };
+        }
+        const opensWithSummary = messages[0] !== undefined && Fold.isSummary(messages[0]);
+        const userTurns = messages.filter((message) => message.role === 'user' && !Fold.isSummary(message)).length;
+        let keepTurns = Fold.KEEP_TURNS;
+        let started = false;
+        for (;;) {
+            const boundary = Fold.boundary(messages, keepTurns);
+            if (!boundary || (opensWithSummary && boundary.end <= 1)) {
+                return { folded: false, reason: opensWithSummary ? 'already-compacted' : 'nothing-to-fold' };
+            }
+            const throughId = messages[boundary.end - 1].id;
+            if (typeof throughId !== 'string' || !throughId) {
+                return { folded: false, reason: 'no-id' };
+            }
+            const folded = messages.slice(0, boundary.end);
+            if (!started) {
+                yield { type: 'fold', phase: 'start' };
+                started = true;
+            }
+            const attempt = await this.summarize(Fold.prompt(folded, options.instructions));
+            const summary = attempt.text?.trim() || null;
+            if (!summary) {
+                if (attempt.overflowed && boundary.foldedTurns > 1) {
+                    keepTurns = userTurns - Math.floor(boundary.foldedTurns / 2);
+                    continue;
+                }
+                return { folded: false, reason: 'no-summary' };
+            }
+            if (!Fold.shrinks(folded, summary)) {
+                return { folded: false, reason: 'summary-not-smaller' };
+            }
+            return {
+                folded: true,
+                summary,
+                throughId,
+                foldedTurns: boundary.foldedTurns,
+                end: boundary.end
+            };
+        }
+    }
+}

package/dist-lib/lib/{tools/exec/adapters/python/guarded-fetch.d.ts → guarded-fetch.d.ts}

@@ -1,14 +1,7 @@
-import { type HostResolver } from '../../../url-guard.ts';
-import type { NoRedirectFetchInit, NoRedirectFetchResponse } from '../../../../no-redirect-fetch-impl.ts';
+import { type HostResolver } from './tools/url-guard.ts';
+import type { NoRedirectFetchInit, NoRedirectFetchResponse } from './no-redirect-fetch-impl.ts';
 export declare const MAX_RESPONSE_BYTES: number;
 type NoRedirectFetch = (url: URL, init?: NoRedirectFetchInit) => Promise<NoRedirectFetchResponse>;
-declare const GUARDED: unique symbol;
-export interface ConnectPolicy {
-    readonly named: readonly string[];
-    readonly ask: (host: string) => Promise<boolean>;
-}
-export declare function setConnectPolicy(next: ConnectPolicy | null): void;
-export declare function isGuardedFetch(fetch: unknown): boolean;
 interface SignalLike {
     readonly aborted: boolean;
     addEventListener(type: 'abort', listener: () => void): void;
@@ -25,6 +18,8 @@ interface FetchInit {
 }
 export interface GuardedFetchOptions {
     readonly fetch?: NoRedirectFetch;
+    readonly mayConnect?: (host: string) => Promise<boolean>;
+    readonly signal?: SignalLike;
     readonly resolveHost?: HostResolver;
     readonly maxBytes?: number;
     readonly timeoutMs?: number;
@@ -76,8 +71,6 @@ export declare class GuardedResponse {
     json(): Promise<unknown>;
     clone(): GuardedResponse;
 }
-type GuardedFetch = ((input: string | URL | RequestLike, init?: FetchInit) => Promise<GuardedResponse>) & {
-    [GUARDED]: true;
-};
+export type GuardedFetch = (input: string | URL | RequestLike, init?: FetchInit) => Promise<GuardedResponse>;
 export declare function createGuardedFetch(options?: GuardedFetchOptions): GuardedFetch;
 export {};

package/dist-lib/lib/{tools/exec/adapters/python/guarded-fetch.js → guarded-fetch.js}

@@ -1,33 +1,12 @@
 import { AbortController } from 'bare-abort-controller';
 import b4a from 'b4a';
 import { noRedirectFetch } from '#no-redirect-fetch';
-import { lookupHost } from '../../../../dns-lookup.js';
-import { hostIsNamed } from './named-hosts.js';
-import { checkOutboundHost, resolveOutboundUrl } from '../../../url-guard.js';
+import { lookupHost } from './dns-lookup.js';
+import { checkOutboundHost, resolveOutboundUrl } from './tools/url-guard.js';
 export const MAX_RESPONSE_BYTES = 100 * 1024 * 1024;
 const MAX_REDIRECTS = 10;
 const TIMEOUT_MS = 120_000;
 const CHUNK_BYTES = 1024 * 1024;
-const GUARDED = Symbol.for('qvac.harness.guardedFetch');
-let policy = null;
-const granted = new Set();
-export function setConnectPolicy(next) {
-    policy = next;
-    granted.clear();
-}
-async function mayConnect(host) {
-    if (!policy || granted.has(host) || hostIsNamed(host, policy.named)) {
-        return true;
-    }
-    const allowed = await policy.ask(host);
-    if (allowed) {
-        granted.add(host);
-    }
-    return allowed;
-}
-export function isGuardedFetch(fetch) {
-    return typeof fetch === 'function' && GUARDED in fetch && fetch[GUARDED] === true;
-}
 function isRedirect(status) {
     return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
 }
@@ -165,20 +144,23 @@ export class GuardedResponse {
 }
 export function createGuardedFetch(options = {}) {
     const send = options.fetch ?? noRedirectFetch;
+    const mayConnect = options.mayConnect ?? allowAll;
     const resolveHost = options.resolveHost ?? lookupHost;
     const maxBytes = options.maxBytes ?? MAX_RESPONSE_BYTES;
     const timeoutMs = options.timeoutMs ?? TIMEOUT_MS;
-    const guardedFetch = async function (input, init = {}) {
+    return async (input, init = {}) => {
         let url = new URL(typeof input === 'string' || input instanceof URL ? input : input.url);
         let method = (init.method ?? 'GET').toUpperCase();
         let body = bodyBytes(init.body);
         const headers = headerRecord(init.headers);
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(undefined), timeoutMs);
-        if (init.signal?.aborted) {
-            controller.abort(undefined);
+        for (const signal of [options.signal, init.signal]) {
+            if (signal?.aborted) {
+                controller.abort(undefined);
+            }
+            signal?.addEventListener('abort', () => controller.abort(undefined));
         }
-        init.signal?.addEventListener('abort', () => controller.abort(undefined));
         try {
             for (let hops = 0;; hops++) {
                 if (url.protocol !== 'http:' && url.protocol !== 'https:') {
@@ -234,12 +216,6 @@ export function createGuardedFetch(options = {}) {
             clearTimeout(timer);
         }
     };
-    const fetch = (input, init) => {
-        const response = guardedFetch(input, init);
-        response.catch(noop);
-        return response;
-    };
-    return Object.assign(fetch, { [GUARDED]: true });
 }
 function stripCredentials(headers) {
     for (const name of Object.keys(headers)) {
@@ -248,4 +224,6 @@ function stripCredentials(headers) {
         }
     }
 }
-function noop() { }
+async function allowAll() {
+    return true;
+}

package/dist-lib/lib/helpers/completion-params.d.ts

@@ -0,0 +1,3 @@
+import type { CompletionSdk } from '../contract/index.ts';
+export type CompletionParams = Parameters<CompletionSdk['completion']>[0];
+export declare function completionParams({ modelId, history, tools, generationParams, responseFormat, toolDialect, kvCache }: Omit<CompletionParams, 'stream'>): CompletionParams;

package/dist-lib/lib/helpers/completion-params.js

@@ -0,0 +1,12 @@
+export function completionParams({ modelId, history, tools, generationParams, responseFormat, toolDialect, kvCache }) {
+    return {
+        modelId,
+        history,
+        stream: true,
+        tools,
+        generationParams,
+        responseFormat,
+        toolDialect,
+        kvCache
+    };
+}

package/dist-lib/lib/helpers/copy.d.ts

@@ -0,0 +1 @@
+export declare function copy<Value>(value: Value): Value;

package/dist-lib/lib/helpers/copy.js

@@ -0,0 +1,5 @@
+export function copy(value) {
+    if (value === undefined)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}

package/dist-lib/lib/helpers/drain.d.ts

@@ -0,0 +1,5 @@
+export declare const EFFECT_DRAIN_TIMEOUT_MS = 5000;
+declare const TIMED_OUT: unique symbol;
+export declare function raceDrain<T>(promise: Promise<T>, timeoutMs?: number): Promise<T | typeof TIMED_OUT>;
+export declare function didDrainTimeOut(value: unknown): value is typeof TIMED_OUT;
+export {};

package/dist-lib/lib/helpers/drain.js

@@ -0,0 +1,19 @@
+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;
+}

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

@@ -1,19 +1,16 @@
-import type { Operation } from '../run-log/protocol-types.ts';
-export type { Operation } from '../run-log/protocol-types.ts';
+import type { Operation } from '../contract/run.ts';
 export declare class RecoveryRequired extends Error {
     readonly operation: Operation;
     constructor(operation: Operation);
 }
+export declare class HookHalt extends Error {
+    readonly code = "hook-halt";
+    readonly hook: string;
+    constructor(reason: string, hook: string);
+}
 export declare class AbortedError extends Error {
     constructor();
 }
-export declare class ToolPolicyChanged extends Error {
-    constructor(tool: string);
-}
-export declare const EFFECT_DRAIN_TIMEOUT_MS = 5000;
-declare const TIMED_OUT: unique symbol;
-export declare function raceDrain<T>(promise: Promise<T>, timeoutMs?: number): Promise<T | typeof TIMED_OUT>;
-export declare function didDrainTimeOut(value: unknown): value is typeof TIMED_OUT;
 export interface ErrorCause {
     message: string;
     name: string;