@qvac/harness 0.7.0 → 1.0.0-rc.0

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

@@ -0,0 +1,81 @@
+import type { CompletionContext, CompletionMachineEvent, SkillLoadOutput, ToolExecutionSnapshot } from './types.ts';
+interface Args {
+    context: CompletionContext;
+    event: CompletionMachineEvent;
+}
+export declare const completionGuards: {
+    preloadNeeded: ({ event }: Args) => boolean;
+    preloadFailed: ({ event }: Args) => boolean;
+    directSearchNeeded: ({ event }: Args) => boolean;
+    directRejected: ({ event }: Args) => boolean;
+    directNeedsApproval: ({ context, event }: Args) => boolean;
+    directAutoRuns: ({ event }: Args) => boolean;
+    noDirectTool: ({ event }: Args) => boolean;
+    searchPending: ({ context }: Args) => boolean;
+    roundHasToolCalls: ({ event }: Args) => boolean;
+    narratedIntent: ({ context, event }: Args) => boolean;
+    hasAnswer: ({ event }: Args) => boolean;
+    canMuteRetry: ({ context }: Args) => boolean;
+    hasRoundsLeft: ({ context }: Args) => boolean;
+    hasQueuedTool: ({ context }: Args) => boolean;
+    repeatOfFailed: ({ context }: Args) => boolean;
+    repeatsBlocked: ({ context }: Args) => boolean;
+    allResolvedToolsCapped: ({ context }: Args) => boolean;
+    canRetrySearchCap: ({ context }: Args) => boolean;
+    toolRejected: ({ event }: Args) => boolean;
+    skillLoadAllowed: ({ event }: Args) => boolean;
+    approved: ({ event }: Args) => boolean;
+    needsApproval: ({ context }: Args, execution: ToolExecutionSnapshot | null | undefined) => boolean;
+    toolAutoRuns: ({ event }: Args) => boolean;
+    directExecution: ({ context }: Args) => boolean;
+    timeUp: ({ context }: Args) => boolean;
+    failedOutcome: ({ context }: Args) => boolean;
+    needsRecovery: ({ event }: Args) => boolean;
+    interrupted: ({ event }: Args) => boolean;
+};
+export declare const completionActions: {
+    requestPreload: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").SkillPreloadPayload, never, never, never, never, never>;
+    authorizePreload: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreloadInspectionOutput, never, never, never, never, never>;
+    settlePreloadFailure: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreloadInspectionOutput | SkillLoadOutput, never, never, never, never, never>;
+    startDirectTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").DirectToolOutput, never, never, never, never, never>;
+    queueDirectSearch: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreparingOutput, never, never, never, never, never>;
+    rejectDeniedApproval: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RejectDeniedApprovalParams, never, never, never, never, never>;
+    startInitialRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreparingPayload, never, never, never, never, never>;
+    settleSkill: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, SkillLoadOutput, never, never, never, never, never>;
+    finishRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RoundDonePayload, never, never, never, never, never>;
+    finishWrapRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RoundDonePayload, never, never, never, never, never>;
+    wrapCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RunOutcome, never, never, never, never, never>;
+    resolveTools: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolsResolvedPayload, never, never, never, never, never>;
+    answerCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").AnsweredPayload, never, never, never, never, never>;
+    retryMuteRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    retryNarratedRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").AnsweredPayload, never, never, never, never, never>;
+    wrapMuteCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    selectNextTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ResolvedCallSnapshot, never, never, never, never, never>;
+    rejectRepeatedTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RepeatOfFailedCallParams, never, never, never, never, never>;
+    retryCappedSearch: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    wrapSearchCappedCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    startNextRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    wrapExhaustedCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    startSkillTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").SkillToolExecutionSnapshot, never, never, never, never, never>;
+    startTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").GatedToolExecutionSnapshot, never, never, never, never, never>;
+    rejectTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./actions/tools.ts").RejectToolParams, never, never, never, never, never>;
+    finishDirectTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolDonePayload, never, never, never, never, never>;
+    finishTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolDonePayload, never, never, never, never, never>;
+    settleToolSkill: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, SkillLoadOutput, never, never, never, never, never>;
+    approveCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    requestApproval: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ApprovalCall, never, never, never, never, never>;
+    failCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./actions/completion.ts").CompletionFailureMessage | {
+        tag: 'failed';
+        message: string;
+        name: string;
+        code?: string;
+        stack?: string;
+        cause?: import("../errors.ts").ErrorCause;
+    }, never, never, never, never, never>;
+    markTimeUp: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    recordPause: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    recordRecovery: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    resumeRun: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    recordFacts: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+};
+export {};

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

@@ -0,0 +1,152 @@
+import { assign } from 'xstate';
+import { approveCompletion, requestApproval } from './actions/approval.js';
+import { answerCompletion, failCompletion, finishWrapRound, finishRound, retryCappedSearch, retryMuteRound, retryNarratedRound, startInitialRound, startNextRound, wrapCompletion, wrapExhaustedCompletion, wrapMuteCompletion, wrapSearchCappedCompletion } from './actions/completion.js';
+import { failSkill, failToolSkill, finishSkill, finishToolSkill, requestPreload, authorizePreload, settlePreloadFailure, startSkillTool } from './actions/skills.js';
+import { finishDirectTool, finishTool, queueDirectSearch, rejectDeniedApproval, rejectRepeatedTool, rejectTool, resolveTools, selectNextTool, startDirectTool, startTool } from './actions/tools.js';
+import { allResolvedToolsCapped, canMuteRetry, canRetryNarrated, canRetrySearchCap, hasQueuedTool, hasRoundsLeft, repeatsBlocked, searchPending } from './guards/retry.js';
+function output(event) {
+    return ('output' in event ? event.output : {});
+}
+function errorOf(event) {
+    return 'error' in event ? event.error : undefined;
+}
+function preflightFacts(execution) {
+    return execution?.gate?.facts;
+}
+function preflightReady(execution) {
+    const facts = preflightFacts(execution);
+    return Boolean(facts && !facts.validationError && !facts.refusal && !facts.deniedKey);
+}
+function autoRuns(execution) {
+    const facts = preflightFacts(execution);
+    return Boolean(facts && (facts.effect === 'read' || facts.autoApprove || facts.skipApprovals));
+}
+function needsApproval(context, execution) {
+    return Boolean(preflightReady(execution) &&
+        !autoRuns(execution) &&
+        context.approval.status === 'idle' &&
+        execution?.gate?.approver);
+}
+export const completionGuards = {
+    preloadNeeded: ({ event }) => {
+        const facts = output(event);
+        return (facts.skillCandidate !== null &&
+            facts.skillLoaderAvailable === true &&
+            facts.skillLoaderEffect === 'read' &&
+            facts.skillAlreadyLoaded === false);
+    },
+    preloadFailed: ({ event }) => Boolean(output(event).failure),
+    directSearchNeeded: ({ event }) => Boolean(output(event).searchQuery),
+    directRejected: ({ event }) => Boolean(output(event).directTool?.rejection),
+    directNeedsApproval: ({ context, event }) => needsApproval(context, output(event).directTool?.execution),
+    directAutoRuns: ({ event }) => preflightReady(output(event).directTool?.execution) &&
+        autoRuns(output(event).directTool?.execution),
+    noDirectTool: ({ event }) => !output(event).directTool,
+    searchPending: ({ context }) => searchPending(context),
+    roundHasToolCalls: ({ event }) => (output(event).calls?.length ?? 0) > 0,
+    narratedIntent: ({ context, event }) => canRetryNarrated(context) && Boolean(output(event).narrated),
+    hasAnswer: ({ event }) => Boolean(output(event).response?.trim()),
+    canMuteRetry: ({ context }) => canMuteRetry(context),
+    hasRoundsLeft: ({ context }) => hasRoundsLeft(context),
+    hasQueuedTool: ({ context }) => hasQueuedTool(context),
+    repeatOfFailed: ({ context }) => {
+        const next = context.toolQueue[0];
+        return Boolean(next && context.failedCalls[next.key]);
+    },
+    repeatsBlocked: ({ context }) => repeatsBlocked(context),
+    allResolvedToolsCapped: ({ context }) => allResolvedToolsCapped(context),
+    canRetrySearchCap: ({ context }) => canRetrySearchCap(context),
+    toolRejected: ({ event }) => Boolean(output(event).rejection),
+    skillLoadAllowed: ({ event }) => {
+        const facts = output(event);
+        return Boolean(facts.skillCall &&
+            facts.toolAvailable &&
+            facts.skillActive &&
+            facts.effect === 'read' &&
+            preflightReady(facts.execution) &&
+            autoRuns(facts.execution));
+    },
+    approved: ({ event }) => output(event).approved === true,
+    needsApproval: ({ context }, execution) => needsApproval(context, execution),
+    toolAutoRuns: ({ event }) => preflightReady(output(event).execution) &&
+        autoRuns(output(event).execution),
+    directExecution: ({ context }) => context.execution?.kind === 'direct',
+    timeUp: ({ context }) => context.timeUp,
+    failedOutcome: ({ context }) => context.outcome === 'failed',
+    needsRecovery: ({ event }) => errorOf(event)?.tag === 'recovery',
+    interrupted: ({ event }) => errorOf(event)?.tag === 'aborted'
+};
+export const completionActions = {
+    requestPreload: assignAction(requestPreload),
+    authorizePreload: assignAction(authorizePreload),
+    settlePreloadFailure: assignAction(settlePreloadFailure),
+    startDirectTool: assignAction(startDirectTool),
+    queueDirectSearch: assignAction(queueDirectSearch),
+    rejectDeniedApproval: assignAction(rejectDeniedApproval),
+    startInitialRound: assignAction(startInitialRound),
+    settleSkill: assignAction((args) => 'failure' in args.params
+        ? failSkill({ ...args, params: args.params.failure })
+        : finishSkill({ ...args, params: args.params })),
+    finishRound: assignAction(finishRound),
+    finishWrapRound: assignAction(finishWrapRound),
+    wrapCompletion: assignAction(wrapCompletion),
+    resolveTools: assignAction(resolveTools),
+    answerCompletion: assignAction(answerCompletion),
+    retryMuteRound: assignAction(retryMuteRound),
+    retryNarratedRound: assignAction(retryNarratedRound),
+    wrapMuteCompletion: assignAction(wrapMuteCompletion),
+    selectNextTool: assignAction(selectNextTool),
+    rejectRepeatedTool: assignAction(rejectRepeatedTool),
+    retryCappedSearch: assignAction(retryCappedSearch),
+    wrapSearchCappedCompletion: assignAction(wrapSearchCappedCompletion),
+    startNextRound: assignAction(startNextRound),
+    wrapExhaustedCompletion: assignAction(wrapExhaustedCompletion),
+    startSkillTool: assignAction(startSkillTool),
+    startTool: assignAction(startTool),
+    rejectTool: assignAction(rejectTool),
+    finishDirectTool: assignAction(finishDirectTool),
+    finishTool: assignAction(finishTool),
+    settleToolSkill: assignAction((args) => 'failure' in args.params
+        ? failToolSkill({ ...args, params: args.params.failure })
+        : finishToolSkill({ ...args, params: args.params })),
+    approveCompletion: assignAction(approveCompletion),
+    requestApproval: assignAction(requestApproval),
+    failCompletion: assignAction(failCompletion),
+    markTimeUp: assignAction(() => ({ timeUp: true })),
+    recordPause: assignAction(({ context }) => ({
+        pauseCount: context.pauseCount + 1
+    })),
+    recordRecovery: assign(({ event }) => {
+        const error = errorOf(event);
+        let recovery;
+        if (event.type === 'RECOVERY_REQUIRED') {
+            recovery = event.operation;
+        }
+        else if (error?.tag === 'recovery') {
+            recovery = error.operation;
+        }
+        return {
+            recovery
+        };
+    }),
+    resumeRun: assign(({ context, event }) => {
+        const pausedMs = event.type === 'RESUME' ? (event.pausedMs ?? 0) : 0;
+        const durable = context.durable;
+        return {
+            recovery: undefined,
+            durable: durable && pausedMs > 0
+                ? {
+                    ...durable,
+                    runBudget: {
+                        ...durable.runBudget,
+                        deadlineMs: durable.runBudget.deadlineMs + pausedMs
+                    }
+                }
+                : durable
+        };
+    }),
+    recordFacts: assign(({ event }) => (event.type === 'FACTS' ? { durable: event.value } : {}))
+};
+function assignAction(action) {
+    return assign(({ context }, params) => action({ context, params }));
+}

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

@@ -0,0 +1,375 @@
+import { type EngineDeps } from './ports.ts';
+import type { CompletionContext, DirectToolOutput, EngineEvent, RejectDeniedApprovalParams, SearchingOutput } from './types.ts';
+declare const createCompletionMachineImplementation: (context?: CompletionContext, now?: () => number, deps?: EngineDeps) => import("xstate").StateMachine<CompletionContext, {
+    type: 'START';
+} | {
+    type: 'PAUSE';
+} | {
+    type: 'RESUME';
+    pausedMs?: number;
+} | {
+    type: 'RECOVERY_REQUIRED';
+    operation: import("../errors.ts").Operation;
+} | {
+    type: 'FACTS';
+    value: import("./types.ts").EngineFacts;
+} | {
+    type: 'FAIL';
+    value: {
+        error: string;
+    };
+} | {
+    type: `xstate.error.actor.${string}`;
+    error: import("../errors.ts").EngineError;
+} | {
+    type: `xstate.done.actor.${string}`;
+    output: import("./types.ts").CompletionActorOutput;
+} | {
+    type: 'OUTPUT';
+    event: EngineEvent;
+}, {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").AnsweredPayload, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").InspectingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").PreloadInspectionOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").PreparingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").RoundDonePayload, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<SearchingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").ToolDonePayload, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<{
+        approved: boolean;
+    }, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").SkillLoadOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").ResolvingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject> | import("xstate").PromiseActorLogic<import("./types.ts").RoundDonePayload & {
+        response: string;
+    }, import("./ports.ts").InvocationInput, import("xstate").EventObject>> | undefined;
+}, {
+    src: "answering";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").AnsweredPayload, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "approving";
+    logic: import("xstate").PromiseActorLogic<{
+        approved: boolean;
+    }, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "cleanup";
+    logic: import("xstate").PromiseActorLogic<void, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "executing";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").ToolDonePayload, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "finishing";
+    logic: import("xstate").PromiseActorLogic<void, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "generating";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").RoundDonePayload, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "inspectPreload";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").PreloadInspectionOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "inspecting";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").InspectingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "loadingSkill";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").SkillLoadOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "preloading";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").SkillLoadOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "preparing";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").PreparingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "rejecting";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").ToolDonePayload, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "resolving";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").ResolvingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "resume";
+    logic: import("xstate").PromiseActorLogic<void, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "searching";
+    logic: import("xstate").PromiseActorLogic<SearchingOutput, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+} | {
+    src: "wrapping";
+    logic: import("xstate").PromiseActorLogic<import("./types.ts").RoundDonePayload & {
+        response: string;
+    }, import("./ports.ts").InvocationInput, import("xstate").EventObject>;
+    id: string | undefined;
+}, {
+    type: "answerCompletion";
+    params: import("./types.ts").AnsweredPayload;
+} | {
+    type: "approveCompletion";
+    params: undefined;
+} | {
+    type: "authorizePreload";
+    params: import("./types.ts").PreloadInspectionOutput;
+} | {
+    type: "failCompletion";
+    params: import("./actions/completion.ts").CompletionFailureMessage | {
+        tag: 'failed';
+        message: string;
+        name: string;
+        code?: string;
+        stack?: string;
+        cause?: import("../errors.ts").ErrorCause;
+    };
+} | {
+    type: "finishDirectTool";
+    params: import("./types.ts").ToolDonePayload;
+} | {
+    type: "finishRound";
+    params: import("./types.ts").RoundDonePayload;
+} | {
+    type: "finishTool";
+    params: import("./types.ts").ToolDonePayload;
+} | {
+    type: "finishWrapRound";
+    params: import("./types.ts").RoundDonePayload;
+} | {
+    type: "markTimeUp";
+    params: undefined;
+} | {
+    type: "queueDirectSearch";
+    params: import("./types.ts").PreparingOutput;
+} | {
+    type: "recordFacts";
+    params: undefined;
+} | {
+    type: "recordPause";
+    params: undefined;
+} | {
+    type: "recordRecovery";
+    params: undefined;
+} | {
+    type: "rejectDeniedApproval";
+    params: RejectDeniedApprovalParams;
+} | {
+    type: "rejectRepeatedTool";
+    params: import("./types.ts").RepeatOfFailedCallParams;
+} | {
+    type: "rejectTool";
+    params: import("./actions/tools.ts").RejectToolParams;
+} | {
+    type: "requestApproval";
+    params: import("./types.ts").ApprovalCall;
+} | {
+    type: "requestPreload";
+    params: import("./types.ts").PreparingPayload & {
+        name: string;
+        history: import("./types.ts").HistorySplice;
+        pendingSearch: string | null;
+    };
+} | {
+    type: "resolveTools";
+    params: import("./types.ts").ToolsResolvedPayload;
+} | {
+    type: "resumeRun";
+    params: undefined;
+} | {
+    type: "retryCappedSearch";
+    params: undefined;
+} | {
+    type: "retryMuteRound";
+    params: undefined;
+} | {
+    type: "retryNarratedRound";
+    params: import("./types.ts").AnsweredPayload;
+} | {
+    type: "selectNextTool";
+    params: import("./types.ts").ResolvedCallSnapshot;
+} | {
+    type: "settlePreloadFailure";
+    params: import("./types.ts").PreloadInspectionOutput | import("./types.ts").SkillLoadOutput;
+} | {
+    type: "settleSkill";
+    params: import("./types.ts").SkillLoadOutput;
+} | {
+    type: "settleToolSkill";
+    params: import("./types.ts").SkillLoadOutput;
+} | {
+    type: "startDirectTool";
+    params: DirectToolOutput;
+} | {
+    type: "startInitialRound";
+    params: import("./types.ts").PreparingPayload;
+} | {
+    type: "startNextRound";
+    params: undefined;
+} | {
+    type: "startSkillTool";
+    params: Omit<import("./types.ts").ToolExecutionSnapshot, "kind" | "skillName"> & {
+        kind: 'skill';
+        skillName: string;
+    };
+} | {
+    type: "startTool";
+    params: import("./types.ts").ToolExecutionSnapshot & {
+        gate: import("./types.ts").ApprovalGate;
+    };
+} | {
+    type: "wrapCompletion";
+    params: import("./types.ts").RunOutcome;
+} | {
+    type: "wrapExhaustedCompletion";
+    params: undefined;
+} | {
+    type: "wrapMuteCompletion";
+    params: undefined;
+} | {
+    type: "wrapSearchCappedCompletion";
+    params: undefined;
+}, {
+    type: "allResolvedToolsCapped";
+    params: unknown;
+} | {
+    type: "approved";
+    params: unknown;
+} | {
+    type: "canMuteRetry";
+    params: unknown;
+} | {
+    type: "canRetrySearchCap";
+    params: unknown;
+} | {
+    type: "directAutoRuns";
+    params: unknown;
+} | {
+    type: "directExecution";
+    params: unknown;
+} | {
+    type: "directNeedsApproval";
+    params: unknown;
+} | {
+    type: "directRejected";
+    params: unknown;
+} | {
+    type: "directSearchNeeded";
+    params: unknown;
+} | {
+    type: "errorInActiveOrResumingAndInterrupted";
+    params: unknown;
+} | {
+    type: "errorInActiveOrResumingAndRecoveryRequired";
+    params: unknown;
+} | {
+    type: "errorInFinishing";
+    params: unknown;
+} | {
+    type: "errorInPausing";
+    params: unknown;
+} | {
+    type: "errorInRoutableState";
+    params: unknown;
+} | {
+    type: "failedOutcome";
+    params: unknown;
+} | {
+    type: "hasAnswer";
+    params: unknown;
+} | {
+    type: "hasQueuedTool";
+    params: unknown;
+} | {
+    type: "hasRoundsLeft";
+    params: unknown;
+} | {
+    type: "interrupted";
+    params: unknown;
+} | {
+    type: "narratedIntent";
+    params: unknown;
+} | {
+    type: "needsApproval";
+    params: import("./types.ts").ToolExecutionSnapshot | null | undefined;
+} | {
+    type: "needsRecovery";
+    params: unknown;
+} | {
+    type: "noDirectTool";
+    params: unknown;
+} | {
+    type: "preloadFailed";
+    params: unknown;
+} | {
+    type: "preloadNeeded";
+    params: unknown;
+} | {
+    type: "repeatOfFailed";
+    params: unknown;
+} | {
+    type: "repeatsBlocked";
+    params: unknown;
+} | {
+    type: "roundHasToolCalls";
+    params: unknown;
+} | {
+    type: "searchPending";
+    params: unknown;
+} | {
+    type: "skillLoadAllowed";
+    params: unknown;
+} | {
+    type: "timeUp";
+    params: unknown;
+} | {
+    type: "toolAutoRuns";
+    params: unknown;
+} | {
+    type: "toolRejected";
+    params: unknown;
+}, "deadline", "done" | "failed" | "paused" | "pausing" | "resuming" | {
+    active: "answering" | "finishing" | "generating" | "idle" | "preloadChecking" | "preloading" | "preparing" | "resolving" | "round" | "searching" | "wrapping" | {
+        tools: "approving" | "executing" | "inspecting" | "loadingSkill" | "rejecting" | "selecting";
+    };
+}, string, CompletionContext, {
+    status: 'success';
+    response: string;
+    metrics: CompletionContext['metrics'];
+} | {
+    status: 'failure';
+    error: string;
+}, EngineEvent, import("xstate").MetaObject, {
+    id: "completion";
+    states: {
+        readonly active: {
+            states: {
+                readonly history: {};
+                readonly idle: {};
+                readonly preparing: {};
+                readonly preloadChecking: {};
+                readonly preloading: {};
+                readonly searching: {};
+                readonly round: {};
+                readonly generating: {};
+                readonly resolving: {};
+                readonly answering: {};
+                readonly tools: {
+                    states: {
+                        readonly selecting: {};
+                        readonly inspecting: {};
+                        readonly rejecting: {};
+                        readonly loadingSkill: {};
+                        readonly approving: {};
+                        readonly executing: {};
+                    };
+                };
+                readonly wrapping: {};
+                readonly finishing: {};
+            };
+        };
+        readonly pausing: {};
+        readonly resuming: {};
+        readonly paused: {};
+        readonly done: {};
+        readonly failed: {};
+    };
+}, import("xstate").MetaObject>;
+export declare const createCompletionMachine: typeof createCompletionMachineImplementation;
+export {};