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

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

@@ -0,0 +1,335 @@
+import { errorMessage } from '../guards.js';
+import { hlog } from '../log.js';
+import { ModelUnloadError } from '../models/model-pool.js';
+import { trackCompletion } from './completion-run.js';
+import { createHarnessLifecycle } from './machine.js';
+export class Lifecycle {
+    static trackCompletion = trackCompletion;
+    _resource;
+    _sdk;
+    _loads;
+    _releases;
+    _models;
+    _recreate;
+    _statusChanged;
+    _teardown;
+    _machine = createHarnessLifecycle({
+        suspend: () => this._suspendRuntimes(),
+        resume: () => this._resumeRuntimes()
+    });
+    _completionRuns = new Set();
+    _detachedRuns = new Set();
+    _effectDrainWaiters = new Set();
+    _activeWork = 0;
+    _workDrainWaiters = new Set();
+    _runtimeDraining = false;
+    _runtimeUnloadFailed = false;
+    _poolUnloadFailed = false;
+    _poolCleanupFailed = false;
+    _failedModelUnloads = new Set();
+    _sdkClosed = false;
+    _runtimesReleased = false;
+    _closeRequested = false;
+    constructor(opts) {
+        this._resource = opts.resource;
+        this._sdk = opts.sdk;
+        this._loads = opts.loads;
+        this._releases = opts.releases;
+        this._models = opts.models;
+        this._recreate = opts.recreate;
+        this._statusChanged = opts.statusChanged;
+        this._teardown = opts.teardown;
+    }
+    get suspended() {
+        return this._machine.suspended;
+    }
+    get draining() {
+        return this._runtimeDraining;
+    }
+    get unloadFailed() {
+        return this._runtimeUnloadFailed;
+    }
+    get closeRequested() {
+        return this._closeRequested;
+    }
+    requestClose() {
+        this._closeRequested = true;
+    }
+    get opened() {
+        return this._resource.opened;
+    }
+    get closing() {
+        return this._resource.closing;
+    }
+    ready() {
+        return this._resource.ready();
+    }
+    async send(type, { open = true } = {}) {
+        if (!this._resource.opened) {
+            if (open) {
+                await this._resource.ready();
+            }
+        }
+        if (this._closeRequested || this._resource.closing) {
+            return;
+        }
+        await this._machine.send(type);
+    }
+    abortCompletions() {
+        for (const run of this._completionRuns) {
+            run.abort();
+        }
+    }
+    assertNotClosing() {
+        if (this._closeRequested || this._resource.closing || this._resource.closed) {
+            throw new Error('harness is closing');
+        }
+    }
+    enterWork() {
+        this.assertNotClosing();
+        if (this._runtimeDraining) {
+            throw new Error('harness is suspended');
+        }
+        if (this._runtimeUnloadFailed) {
+            throw new Error('Runtime unload failed; close the harness before loading models again');
+        }
+        this._activeWork++;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            if (--this._activeWork !== 0) {
+                return;
+            }
+            for (const resolve of this._workDrainWaiters) {
+                resolve();
+            }
+            this._workDrainWaiters.clear();
+        };
+    }
+    trackCompletion(createSource, signal) {
+        const tracked = trackCompletion(createSource, signal, (run) => {
+            this._completionRuns.delete(run);
+            this._notifyEffectDrain();
+        });
+        const { iterator, run } = tracked;
+        this._completionRuns.add(run);
+        return iterator;
+    }
+    trackDetachedRun(pending, runId) {
+        const tracked = pending.catch((error) => {
+            hlog('detached completion effect failed', { runId, err: errorMessage(error) });
+        });
+        this._detachedRuns.add(tracked);
+        void tracked
+            .finally(() => {
+            this._detachedRuns.delete(tracked);
+            this._notifyEffectDrain();
+        })
+            .catch(noop);
+    }
+    recordModelUnloadFailure(modelId, error) {
+        this._failedModelUnloads.add(modelId);
+        this._poolUnloadFailed = true;
+        this._runtimeUnloadFailed = true;
+        hlog('model unload failed', { modelId, err: errorMessage(error) });
+    }
+    recordPoolCleanupFailure() {
+        this._poolCleanupFailed = true;
+        this._poolUnloadFailed = true;
+        this._runtimeUnloadFailed = true;
+    }
+    async close() {
+        this._machine.cancelPending();
+        this.abortCompletions();
+        this._loads.drain();
+        await this._machine.settled();
+        await this.finishClose();
+    }
+    async finishClose() {
+        let completed = false;
+        try {
+            const pending = this._sdk.peek();
+            if (pending) {
+                const sdk = await pending.catch(noop);
+                if (sdk) {
+                    this._loads.drain(sdk);
+                }
+            }
+            await this._closeCompletions();
+            await this._waitForEffectDrain();
+            await this._waitForWorkDrain();
+            await this._teardown();
+            if (!this._runtimesReleased) {
+                let released = await this._releaseRuntimes();
+                if (!released && !this._poolUnloadFailed) {
+                    released = await this._releaseRuntimes();
+                }
+                this._runtimesReleased = released;
+            }
+            let sdkCloseFailed = false;
+            let sdkCloseError;
+            const sdk = !this._sdkClosed && !this._runtimeUnloadFailed ? await this._sdk.peek()?.catch(noop) : null;
+            if (sdk) {
+                try {
+                    await sdk.close();
+                    this._sdkClosed = true;
+                }
+                catch (error) {
+                    sdkCloseFailed = true;
+                    sdkCloseError = error;
+                    hlog('sdk close failed', { err: errorMessage(error) });
+                }
+            }
+            if (sdkCloseFailed) {
+                throw sdkCloseError;
+            }
+            if (this._runtimeUnloadFailed) {
+                throw new Error('Runtime unload failed; model cleanup could not be confirmed');
+            }
+            completed = true;
+        }
+        finally {
+            if (completed) {
+                this._machine.stop();
+            }
+        }
+    }
+    _waitForWorkDrain() {
+        if (!this._activeWork) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => this._workDrainWaiters.add(resolve));
+    }
+    _effectsSettled() {
+        return !this._detachedRuns.size && ![...this._completionRuns].some((run) => run.started);
+    }
+    _notifyEffectDrain() {
+        if (!this._effectsSettled())
+            return;
+        for (const resolve of this._effectDrainWaiters) {
+            resolve();
+        }
+        this._effectDrainWaiters.clear();
+    }
+    _waitForEffectDrain() {
+        if (this._effectsSettled()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => this._effectDrainWaiters.add(resolve));
+    }
+    async _closeCompletions(runs = this._completionRuns) {
+        const closed = await Promise.allSettled([...runs].map((run) => run.close()));
+        for (const outcome of closed) {
+            if (outcome.status === 'rejected') {
+                hlog('completion close failed', {
+                    err: errorMessage(outcome.reason)
+                });
+            }
+        }
+    }
+    async _suspendRuntimes() {
+        this._runtimeDraining = true;
+        hlog('suspending', { models: this._models() });
+        this.abortCompletions();
+        this._loads.drain();
+        await this._closeCompletions([...this._completionRuns].filter((run) => run.started));
+        await this._waitForEffectDrain();
+        const pending = this._sdk.peek();
+        if (pending) {
+            const sdk = await pending.catch(noop);
+            if (sdk) {
+                this._loads.drain(sdk);
+            }
+        }
+        await this._waitForWorkDrain();
+        if (!(await this._releaseRuntimes())) {
+            throw new Error('Runtime unload failed; close the harness before loading models again');
+        }
+        this._statusChanged();
+        await this._sdkLifecycle('suspend');
+        hlog('suspended');
+    }
+    async _sdkLifecycle(op) {
+        const sdk = await this._sdk.peek()?.catch(noop);
+        if (!sdk) {
+            return;
+        }
+        try {
+            await sdk[op]();
+        }
+        catch (err) {
+            hlog(`sdk ${op} failed`, { err: errorMessage(err) });
+            if (op === 'suspend') {
+                throw err;
+            }
+            await sdk.resume().catch((retryErr) => {
+                hlog('sdk resume retry failed', {
+                    err: errorMessage(retryErr)
+                });
+                throw retryErr;
+            });
+        }
+    }
+    async _releaseRuntimes() {
+        const [pools, runtimes, plugins] = await Promise.all([
+            Promise.allSettled(this._releases.pools()),
+            Promise.allSettled(this._releases.runtimes()),
+            this._releases.plugins()
+        ]);
+        for (const outcome of pools) {
+            if (outcome.status === 'rejected' && !(outcome.reason instanceof ModelUnloadError)) {
+                this._poolCleanupFailed = true;
+            }
+        }
+        const others = [...runtimes, ...plugins];
+        for (const outcome of [...pools, ...others]) {
+            if (outcome.status !== 'rejected')
+                continue;
+            hlog('unload failed', { err: errorMessage(outcome.reason) });
+        }
+        const sdk = await this._sdk.peek()?.catch(noop);
+        if (sdk) {
+            for (const modelId of this._failedModelUnloads) {
+                try {
+                    await sdk.unloadModel({ modelId });
+                    this._failedModelUnloads.delete(modelId);
+                    this._statusChanged();
+                }
+                catch (error) {
+                    hlog('model unload retry failed', {
+                        modelId,
+                        err: errorMessage(error)
+                    });
+                }
+            }
+        }
+        this._poolUnloadFailed = this._poolCleanupFailed || this._failedModelUnloads.size > 0;
+        this._runtimeUnloadFailed =
+            this._poolUnloadFailed || others.some((outcome) => outcome.status === 'rejected');
+        return !this._runtimeUnloadFailed;
+    }
+    async _resumeRuntimes() {
+        this.assertNotClosing();
+        if (this._runtimeUnloadFailed) {
+            throw new Error('Runtime unload failed; close the harness before loading models again');
+        }
+        hlog('resuming', { pools: 'recreated' });
+        this._loads.undrain();
+        this._recreate();
+        try {
+            await this._sdkLifecycle('resume');
+            this._runtimeDraining = false;
+        }
+        catch (error) {
+            const sdk = await this._sdk.peek()?.catch(noop);
+            if (sdk) {
+                this._loads.drain(sdk);
+            }
+            await this._releaseRuntimes();
+            throw error;
+        }
+    }
+}
+function noop() { }

package/dist-lib/lib/{harness-lifecycle.js → lifecycle/machine.js}

@@ -1,6 +1,6 @@
 import { assign, createActor, fromPromise, setup, waitFor } from 'xstate';
-import { errorMessage, isRecord } from './guards.js';
-import { hlog } from './log.js';
+import { errorMessage, isRecord } from '../guards.js';
+import { hlog } from '../log.js';
 function errorFromEvent(event) {
     return isRecord(event) ? event.error : undefined;
 }

package/dist-lib/lib/machine/completion/actions/completion.d.ts

@@ -1,15 +1,24 @@
-import type { AnsweredPayload, CompletionActionArgs, CompletionContext, RunOutcome, PreparingPayload, RoundDonePayload } from '../types.ts';
-import type { EngineError } from '../../errors.ts';
+import type { AnsweredPayload, CompletionActionArgs, CompletionContext, PreparingPayload, RetrievingOutput, RoundDonePayload } from '../types.ts';
+import type { RunOutcome } from '../../../contract/run.ts';
+import type { EngineError } from '../../../helpers/engine-error.ts';
 export declare function startInitialRound({ context, params }: CompletionActionArgs<PreparingPayload>): Partial<CompletionContext>;
 export declare function startNextRound({ context }: CompletionActionArgs): Partial<CompletionContext>;
 export declare function retryMuteRound({ context }: CompletionActionArgs): Partial<CompletionContext>;
 export declare function retryNarratedRound({ context, params }: CompletionActionArgs<AnsweredPayload>): Partial<CompletionContext>;
+export declare function retryMalformedRound({ context, params }: CompletionActionArgs<AnsweredPayload>): Partial<CompletionContext>;
 export declare function retryCappedSearch({ context }: CompletionActionArgs): Partial<CompletionContext>;
+export declare function continueWithInput({ context }: CompletionActionArgs): Partial<CompletionContext>;
+export declare function addKnowledge({ context, params }: CompletionActionArgs<RetrievingOutput>): Partial<CompletionContext>;
+export declare function goalTurn({ policy, goal, plan }: Readonly<CompletionContext>): string;
+export declare function continueGoal({ context }: CompletionActionArgs): Partial<CompletionContext>;
+export declare function continueStop({ context, params }: CompletionActionArgs<AnsweredPayload>): Partial<CompletionContext>;
+export declare function settleGoal({ context }: CompletionActionArgs): Partial<CompletionContext>;
 export declare function finishRound({ context, params }: CompletionActionArgs<RoundDonePayload>): Partial<CompletionContext>;
 export declare function finishWrapRound({ context, params }: CompletionActionArgs<RoundDonePayload>): Partial<CompletionContext>;
 export declare function wrapCompletion({ params }: CompletionActionArgs<RunOutcome>): Partial<CompletionContext>;
 export declare function wrapMuteCompletion(_args: CompletionActionArgs): Partial<CompletionContext>;
 export declare function wrapSearchCappedCompletion({ context }: CompletionActionArgs): Partial<CompletionContext>;
+export declare function wrapDeliveredCompletion({ context }: CompletionActionArgs): Partial<CompletionContext>;
 export declare function wrapExhaustedCompletion({ context }: CompletionActionArgs): Partial<CompletionContext>;
 export declare function answerCompletion({ context, params }: CompletionActionArgs<AnsweredPayload>): Partial<CompletionContext>;
 export interface CompletionFailureMessage {

package/dist-lib/lib/machine/completion/actions/completion.js

@@ -1,4 +1,5 @@
-import { applyHistorySplice, applySplice, foldMetrics, retainFailureResults, TOOL_CONTINUATION_NUDGE } from '../rules.js';
+import { hasRoundsLeft } from '../guards/retry.js';
+import { activate, applyHistorySplice, applySplice, foldMetrics, goalTokensLeft, nudgeWithPlan, planDone, retainFailureResults } from '../rules.js';
 export function startInitialRound({ context, params }) {
     return applyPreparation(context, params);
 }
@@ -6,10 +7,11 @@ export function startNextRound({ context }) {
     return {
         ...applyPreparation(context),
         ...closeFailureMemo(context),
-        history: endToolRound(context),
+        ...endToolRound(context),
         round: context.round + 1,
         mute: 0,
         narrated: false,
+        malformed: false,
         cappedRounds: 0
     };
 }
@@ -22,8 +24,16 @@ export function retryNarratedRound({ context, params }) {
         history: [
             ...context.history,
             { role: 'assistant', content: params.narrated ?? '' },
-            { role: 'user', content: TOOL_CONTINUATION_NUDGE }
+            ...continuation(context)
         ],
+        steering: [],
+        round: context.round + 1
+    };
+}
+export function retryMalformedRound({ context, params }) {
+    return {
+        ...applyHistorySplice(context, params.history),
+        malformed: true,
         round: context.round + 1
     };
 }
@@ -31,10 +41,11 @@ export function retryCappedSearch({ context }) {
     return {
         ...applyPreparation(context),
         ...closeFailureMemo(context),
-        history: endToolRound(context),
+        ...endToolRound(context),
         round: context.round + 1,
         mute: 0,
         narrated: false,
+        malformed: false,
         cappedRounds: context.cappedRounds + 1
     };
 }
@@ -49,11 +60,83 @@ function closeFailureMemo(context) {
     };
 }
 function endToolRound(context) {
-    return [...context.history, { role: 'user', content: TOOL_CONTINUATION_NUDGE }];
+    return {
+        history: [...context.history, ...continuation(context)],
+        steering: [],
+        delivered: context.delivered || context.deliveredThisRound,
+        deliveredThisRound: false
+    };
+}
+function continuation(context) {
+    const { policy, deliveredThisRound, plan } = context;
+    const nudge = deliveredThisRound ? policy.deliveredNudge : policy.continuationNudge;
+    return context.steering.length
+        ? userTurns(context.steering)
+        : [{ role: 'user', content: nudgeWithPlan(nudge, plan) }];
+}
+function userTurns(queued) {
+    return queued.map(({ text }) => ({ role: 'user', content: text }));
+}
+function continueAfterAnswer(context, turns) {
+    return {
+        history: [...context.history, ...turns],
+        outcome: null,
+        answer: null,
+        round: context.round + 1,
+        mute: 0,
+        narrated: false,
+        malformed: false,
+        cappedRounds: 0
+    };
+}
+export function continueWithInput({ context }) {
+    return {
+        ...continueAfterAnswer(context, [
+            ...userTurns(context.steering),
+            ...userTurns(context.followUps)
+        ]),
+        steering: [],
+        followUps: []
+    };
+}
+export function addKnowledge({ context, params }) {
+    return {
+        ...applyHistorySplice(context, params.history),
+        sources: params.sources ? [...context.sources, ...params.sources] : context.sources
+    };
+}
+export function goalTurn({ policy, goal, plan }) {
+    return nudgeWithPlan(`${policy.goalNudge}\nGoal: ${goal?.objective ?? ''}`, plan);
+}
+export function continueGoal({ context }) {
+    const { goal } = context;
+    return {
+        ...continueAfterAnswer(context, [{ role: 'user', content: goalTurn(context) }]),
+        goal: goal && { ...goal, turns: goal.turns + 1 }
+    };
+}
+export function continueStop({ context, params }) {
+    return continueAfterAnswer(context, [{ role: 'user', content: params.continue ?? '' }]);
+}
+export function settleGoal({ context }) {
+    const { goal } = context;
+    return goal ? { goal: { ...goal, status: goalStatus(context) } } : {};
+}
+function goalStatus(context) {
+    if (planDone(context.plan)) {
+        return 'met';
+    }
+    if (!hasRoundsLeft(context)) {
+        return 'rounds';
+    }
+    if (context.timeUp) {
+        return 'time';
+    }
+    return goalTokensLeft(context) ? 'open' : 'tokens';
 }
 export function finishRound({ context, params }) {
     const metrics = { ...context.metrics };
-    foldMetrics(metrics, params.stats, params.stopReason);
+    foldMetrics(metrics, context.round, params);
     const historyState = applyHistorySplice(context, params.history);
     return {
         lastRound: { ...params, history: undefined },
@@ -66,7 +149,7 @@ export function finishRound({ context, params }) {
 }
 export function finishWrapRound({ context, params }) {
     const metrics = { ...context.metrics };
-    foldMetrics(metrics, params.stats, params.stopReason);
+    foldMetrics(metrics, context.roundsSent, params);
     const historyState = applyHistorySplice(context, params.history);
     return {
         ...historyState,
@@ -81,17 +164,20 @@ export function wrapMuteCompletion(_args) {
     return { outcome: 'mute' };
 }
 export function wrapSearchCappedCompletion({ context }) {
-    return { history: endToolRound(context), outcome: 'search-capped' };
+    return { ...endToolRound(context), outcome: 'search-capped' };
+}
+export function wrapDeliveredCompletion({ context }) {
+    return { ...endToolRound(context), outcome: 'delivered' };
 }
 export function wrapExhaustedCompletion({ context }) {
-    return { history: endToolRound(context), outcome: 'exhausted' };
+    return { ...endToolRound(context), outcome: 'exhausted' };
 }
 export function answerCompletion({ context, params }) {
     const historyState = applyHistorySplice(context, params.history);
     const history = historyState.history;
     const metrics = { ...context.metrics };
     if ('stats' in params) {
-        foldMetrics(metrics, params.stats, params.stopReason);
+        foldMetrics(metrics, context.roundsSent, params);
     }
     return {
         ...historyState,
@@ -121,9 +207,7 @@ export function applyPreparation(context, payload) {
     const historyState = applyHistorySplice(context, payload?.history);
     return {
         ...historyState,
-        skills: payload?.loadedSkills
-            ? { ...context.skills, snapshot: { loaded: [...payload.loadedSkills] } }
-            : context.skills,
+        activated: activate(context.activated, payload?.activated ?? []),
         webSearches: payload?.webSearches ?? context.webSearches,
         deniedKeys: payload?.deniedKeys ? [...payload.deniedKeys] : context.deniedKeys,
         sources: payload?.sources ? [...payload.sources] : context.sources,
@@ -134,7 +218,7 @@ export function applyPreparation(context, payload) {
         rejectedCall: null,
         toolQueue: [],
         pendingCall: null,
-        skillPreload: null,
+        prepareStep: null,
         pendingSearch: null,
         cappedCalls: 0,
         resolvedCount: 0

package/dist-lib/lib/machine/completion/actions/prepare.d.ts

@@ -0,0 +1,9 @@
+import type { CompletionActionArgs, CompletionContext, PrepareInspectionOutput, PrepareResult, PrepareRunOutput, PrepareStepProposal, PreparingPayload } from '../types.ts';
+export interface RequestPrepareParams {
+    preparation: PreparingPayload;
+    step: PrepareStepProposal;
+}
+export declare function requestPrepare({ context, params }: CompletionActionArgs<RequestPrepareParams>): Partial<CompletionContext>;
+export declare function authorizePrepare({ context, params }: CompletionActionArgs<PrepareInspectionOutput>): Partial<CompletionContext>;
+export declare function settlePrepareFailure({ context, params }: CompletionActionArgs<PrepareInspectionOutput | PrepareRunOutput>): Partial<CompletionContext>;
+export declare function settlePrepare({ context, params }: CompletionActionArgs<PrepareResult>): Partial<CompletionContext>;

package/dist-lib/lib/machine/completion/actions/prepare.js

@@ -0,0 +1,30 @@
+import { applyPreparation } from './completion.js';
+import { activate, applyHistorySplice } from '../rules.js';
+export function requestPrepare({ context, params }) {
+    const { preparation, step } = params;
+    return {
+        ...applyPreparation(context, { ...preparation, history: step.history }),
+        prepareStep: { id: step.id, tool: step.tool, args: step.args },
+        pendingSearch: step.pendingSearch
+    };
+}
+export function authorizePrepare({ context, params }) {
+    const step = context.prepareStep;
+    return { prepareStep: step && { ...step, args: params.args, facts: params.facts ?? undefined } };
+}
+export function settlePrepareFailure({ context, params }) {
+    const failure = 'failure' in params ? params.failure : null;
+    if (!failure) {
+        return {};
+    }
+    return { ...applyHistorySplice(context, failure.history), prepareStep: null };
+}
+export function settlePrepare({ context, params }) {
+    return {
+        activated: activate(context.activated, params.activate ? [params.activate] : []),
+        cacheKey: params.cacheable === false ? null : context.cacheKey,
+        ...applyHistorySplice(context, params.history),
+        sources: params.source ? [...context.sources, params.source] : context.sources,
+        prepareStep: null
+    };
+}

package/dist-lib/lib/machine/completion/actions/tools.d.ts

@@ -1,4 +1,4 @@
-import type { CompletionActionArgs, CompletionContext, DirectToolOutput, GatedToolExecutionSnapshot, RejectDeniedApprovalParams, PreparingOutput, RepeatOfFailedCallParams, ResolvedCallSnapshot, ToolDonePayload, ToolExecutionSnapshot, ToolRejection, ToolsResolvedPayload } from '../types.ts';
+import type { BatchDonePayload, CompletionActionArgs, CompletionContext, DirectToolOutput, GatedToolExecutionSnapshot, RejectDeniedApprovalParams, PreparingOutput, RepeatOfFailedCallParams, ResolvedCallSnapshot, ToolDonePayload, ToolExecutionSnapshot, ToolRejection, ToolsResolvedPayload } from '../types.ts';
 export declare function resolveTools({ context, params }: CompletionActionArgs<ToolsResolvedPayload>): Partial<CompletionContext>;
 export declare function selectNextTool({ params }: CompletionActionArgs<ResolvedCallSnapshot>): Partial<CompletionContext>;
 export interface RejectToolParams {
@@ -12,5 +12,14 @@ export declare function queueDirectSearch({ context, params }: CompletionActionA
 export declare function startDirectTool({ params }: CompletionActionArgs<DirectToolOutput>): Partial<CompletionContext>;
 export declare function startTool({ params }: CompletionActionArgs<GatedToolExecutionSnapshot>): Partial<CompletionContext>;
 export declare function finishTool({ context, params }: CompletionActionArgs<ToolDonePayload>): Partial<CompletionContext>;
+export declare function finishBatch({ context, params }: CompletionActionArgs<BatchDonePayload>): Partial<CompletionContext>;
+export declare function endRunOnTool(args: CompletionActionArgs<ToolDonePayload>): Partial<CompletionContext>;
 export declare function finishDirectTool({ context, params }: CompletionActionArgs<ToolDonePayload>): Partial<CompletionContext>;
 export declare function rejectRepeatedTool({ params }: CompletionActionArgs<RepeatOfFailedCallParams>): Partial<CompletionContext>;
+export declare function rejectCutOffTool({ context, params }: CompletionActionArgs<ResolvedCallSnapshot>): Partial<CompletionContext>;
+export declare const PLAN_MODE_REFUSAL: string;
+export interface RejectPlanModeWriteParams {
+    call: ResolvedCallSnapshot;
+    execution: GatedToolExecutionSnapshot;
+}
+export declare function rejectPlanModeWrite({ params }: CompletionActionArgs<RejectPlanModeWriteParams>): Partial<CompletionContext>;