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

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

@@ -1,13 +1,20 @@
-import { and, emit, or, setup, stateIn } from 'xstate';
-import { tagError } from '../errors.js';
-import { emptyCompletionContext } from './context.js';
+import { and, emit, fromPromise, not, or, setup, stateIn } from 'xstate';
+import { tagError } from '../../helpers/engine-error.js';
 import { completionActions, completionGuards } from './implementations.js';
-import { createCompletionActors } from './ports.js';
 const MAX_DELAY = 2 ** 31 - 1;
 const withParent = ({ self }) => ({ parent: self });
 const selected = (value) => value;
 const activeOrResuming = or([stateIn('#completion.active'), stateIn('#completion.resuming')]);
+const inFinishing = stateIn('#completion.active.finishing');
 const activeResumingOrPausing = or([activeOrResuming, stateIn('#completion.pausing')]);
+const nextRoundAck = {
+    type: 'ackSteering',
+    params: ({ context }) => ({ round: context.round + 1 })
+};
+const sameRoundAck = {
+    type: 'ackSteering',
+    params: ({ context }) => ({ round: context.round })
+};
 function directToolRouting() {
     return [
         {
@@ -51,16 +58,40 @@ function directToolRouting() {
     ];
 }
 const noClock = () => 0;
-const createCompletionMachineImplementation = (context = emptyCompletionContext(), now = noClock, deps) => setup({
+function unprovided() {
+    return fromPromise(() => Promise.reject(new Error('Completion runtime implementations were not provided')));
+}
+const settled = () => fromPromise(() => Promise.resolve());
+const placeholderActors = {
+    preparing: unprovided(),
+    inspectPrepare: unprovided(),
+    runPrepare: unprovided(),
+    searching: unprovided(),
+    generating: unprovided(),
+    resolving: unprovided(),
+    inspecting: unprovided(),
+    rejecting: unprovided(),
+    approving: unprovided(),
+    executing: unprovided(),
+    batching: unprovided(),
+    wrapping: unprovided(),
+    answering: unprovided(),
+    retrieving: unprovided(),
+    finishing: unprovided(),
+    cleanup: settled(),
+    resume: settled()
+};
+const createCompletionMachineImplementation = (context, now = noClock) => setup({
     types: {},
-    actors: createCompletionActors(deps),
+    actors: placeholderActors,
     actions: completionActions,
     guards: {
         ...completionGuards,
         errorInPausing: stateIn('#completion.pausing'),
         errorInActiveOrResumingAndRecoveryRequired: and([activeOrResuming, 'needsRecovery']),
         errorInActiveOrResumingAndInterrupted: and([activeOrResuming, 'interrupted']),
-        errorInFinishing: stateIn('#completion.active.finishing'),
+        errorInFinishing: inFinishing,
+        failInFinishing: inFinishing,
         errorInRoutableState: activeResumingOrPausing
     },
     delays: {
@@ -70,7 +101,7 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
         }
     }
 }).createMachine({
-    context: ({ input }) => structuredContext(input ?? context),
+    context: ({ input }) => startingContext(input ?? context),
     id: 'completion',
     initial: 'active',
     output: ({ context }) => context.outcome === 'failed'
@@ -79,6 +110,7 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
     on: {
         RECOVERY_REQUIRED: { target: '.paused', actions: 'recordRecovery' },
         OUTPUT: { actions: emit(({ event }) => event.event) },
+        INPUT: { actions: 'queueInput' },
         FACTS: { actions: 'recordFacts' },
         'xstate.error.actor.*': [
             { guard: 'errorInPausing', target: '#completion.paused', actions: 'recordRecovery' },
@@ -110,10 +142,17 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
             after: { deadline: { actions: 'markTimeUp' } },
             on: {
                 PAUSE: { target: '#completion.pausing', actions: 'recordPause' },
-                FAIL: {
-                    target: '.finishing',
-                    actions: { type: 'failCompletion', params: ({ event }) => event.value }
-                }
+                FAIL: [
+                    {
+                        guard: 'failInFinishing',
+                        target: '#completion.failed',
+                        actions: { type: 'failCompletion', params: ({ event }) => event.value }
+                    },
+                    {
+                        target: '.finishing',
+                        actions: { type: 'failCompletion', params: ({ event }) => event.value }
+                    }
+                ]
             },
             states: {
                 history: { type: 'history', history: 'deep' },
@@ -128,11 +167,14 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                         input: withParent,
                         onDone: [
                             {
-                                guard: 'preloadNeeded',
-                                target: 'preloadChecking',
+                                guard: 'prepareNeeded',
+                                target: 'prepareChecking',
                                 actions: {
-                                    type: 'requestPreload',
-                                    params: ({ event }) => selected(event.output.preload)
+                                    type: 'requestPrepare',
+                                    params: ({ event }) => ({
+                                        preparation: event.output.preparation,
+                                        step: selected(event.output.step)
+                                    })
                                 }
                             },
                             {
@@ -153,53 +195,59 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                         ]
                     }
                 },
-                preloadChecking: {
-                    tags: ['running', 'skill', 'policy-check'],
+                prepareChecking: {
+                    tags: ['running'],
                     invoke: {
-                        src: 'inspectPreload',
+                        src: 'inspectPrepare',
                         input: withParent,
                         onDone: [
                             {
-                                guard: and(['preloadFailed', 'searchPending']),
+                                guard: and(['prepareFailed', 'searchPending']),
                                 target: 'searching',
-                                actions: { type: 'settlePreloadFailure', params: ({ event }) => event.output }
+                                actions: { type: 'settlePrepareFailure', params: ({ event }) => event.output }
                             },
                             {
-                                guard: 'preloadFailed',
+                                guard: 'prepareFailed',
                                 target: 'round',
-                                actions: { type: 'settlePreloadFailure', params: ({ event }) => event.output }
+                                actions: { type: 'settlePrepareFailure', params: ({ event }) => event.output }
                             },
                             {
-                                target: 'preloading',
-                                actions: { type: 'authorizePreload', params: ({ event }) => event.output }
+                                target: 'prepareRunning',
+                                actions: { type: 'authorizePrepare', params: ({ event }) => event.output }
                             }
                         ]
                     }
                 },
-                preloading: {
-                    tags: ['running', 'skill'],
+                prepareRunning: {
+                    tags: ['running'],
                     invoke: {
-                        src: 'preloading',
+                        src: 'runPrepare',
                         input: withParent,
                         onDone: [
                             {
-                                guard: and(['preloadFailed', 'searchPending']),
+                                guard: and(['prepareFailed', 'searchPending']),
                                 target: 'searching',
-                                actions: { type: 'settlePreloadFailure', params: ({ event }) => event.output }
+                                actions: { type: 'settlePrepareFailure', params: ({ event }) => event.output }
                             },
                             {
-                                guard: 'preloadFailed',
+                                guard: 'prepareFailed',
                                 target: 'round',
-                                actions: { type: 'settlePreloadFailure', params: ({ event }) => event.output }
+                                actions: { type: 'settlePrepareFailure', params: ({ event }) => event.output }
                             },
                             {
                                 guard: 'searchPending',
                                 target: 'searching',
-                                actions: { type: 'settleSkill', params: ({ event }) => event.output }
+                                actions: {
+                                    type: 'settlePrepare',
+                                    params: ({ event }) => selected(event.output)
+                                }
                             },
                             {
                                 target: 'round',
-                                actions: { type: 'settleSkill', params: ({ event }) => event.output }
+                                actions: {
+                                    type: 'settlePrepare',
+                                    params: ({ event }) => selected(event.output)
+                                }
                             }
                         ]
                     }
@@ -244,10 +292,18 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                                 target: 'tools',
                                 actions: { type: 'resolveTools', params: ({ event }) => event.output }
                             },
+                            {
+                                guard: 'malformedToolCall',
+                                target: 'round',
+                                actions: { type: 'retryMalformedRound', params: ({ event }) => event.output }
+                            },
                             {
                                 guard: 'narratedIntent',
                                 target: 'round',
-                                actions: { type: 'retryNarratedRound', params: ({ event }) => event.output }
+                                actions: [
+                                    nextRoundAck,
+                                    { type: 'retryNarratedRound', params: ({ event }) => event.output }
+                                ]
                             },
                             {
                                 guard: 'hasAnswer',
@@ -263,9 +319,50 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                     invoke: {
                         src: 'answering',
                         input: withParent,
+                        onDone: [
+                            {
+                                guard: and(['hasInput', 'hasRoundsLeft', not('timeUp')]),
+                                target: 'retrieving',
+                                actions: [
+                                    { type: 'answerCompletion', params: ({ event }) => event.output },
+                                    'ackInput',
+                                    'continueWithInput'
+                                ]
+                            },
+                            {
+                                guard: and(['stopContinues', 'hasRoundsLeft', not('timeUp')]),
+                                target: 'round',
+                                actions: [
+                                    { type: 'answerCompletion', params: ({ event }) => event.output },
+                                    { type: 'continueStop', params: ({ event }) => event.output }
+                                ]
+                            },
+                            {
+                                guard: and(['goalUnmet', 'hasRoundsLeft', not('timeUp'), 'goalTokensLeft']),
+                                target: 'round',
+                                actions: [
+                                    { type: 'answerCompletion', params: ({ event }) => event.output },
+                                    'continueGoal'
+                                ]
+                            },
+                            {
+                                target: 'finishing',
+                                actions: [
+                                    { type: 'answerCompletion', params: ({ event }) => event.output },
+                                    'settleGoal'
+                                ]
+                            }
+                        ]
+                    }
+                },
+                retrieving: {
+                    tags: ['running', 'preparing'],
+                    invoke: {
+                        src: 'retrieving',
+                        input: withParent,
                         onDone: {
-                            target: 'finishing',
-                            actions: { type: 'answerCompletion', params: ({ event }) => event.output }
+                            target: 'round',
+                            actions: { type: 'addKnowledge', params: ({ event }) => event.output }
                         }
                     }
                 },
@@ -274,6 +371,14 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                     states: {
                         selecting: {
                             always: [
+                                {
+                                    guard: and(['hasQueuedTool', 'roundCutOff']),
+                                    target: 'rejecting',
+                                    actions: {
+                                        type: 'rejectCutOffTool',
+                                        params: ({ context }) => context.toolQueue[0]
+                                    }
+                                },
                                 {
                                     guard: and(['hasQueuedTool', 'repeatOfFailed']),
                                     target: 'rejecting',
@@ -288,6 +393,7 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                                         }
                                     }
                                 },
+                                { guard: and(['hasQueuedTool', 'readBatchQueued']), target: 'batching' },
                                 {
                                     guard: 'hasQueuedTool',
                                     target: 'inspecting',
@@ -296,29 +402,59 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                                         params: ({ context }) => context.toolQueue[0]
                                     }
                                 },
+                                { guard: 'toolAnswered', target: '#completion.active.answering' },
+                                {
+                                    guard: 'deliveredBefore',
+                                    target: '#completion.active.wrapping',
+                                    actions: [sameRoundAck, 'wrapDeliveredCompletion']
+                                },
                                 {
                                     guard: 'repeatsBlocked',
                                     target: '#completion.active.wrapping',
-                                    actions: 'wrapExhaustedCompletion'
+                                    actions: [sameRoundAck, 'wrapExhaustedCompletion']
                                 },
                                 {
                                     guard: and(['allResolvedToolsCapped', 'canRetrySearchCap', 'hasRoundsLeft']),
                                     target: '#completion.active.round',
-                                    actions: 'retryCappedSearch'
+                                    actions: [nextRoundAck, 'retryCappedSearch']
                                 },
                                 {
                                     guard: 'allResolvedToolsCapped',
                                     target: '#completion.active.wrapping',
-                                    actions: 'wrapSearchCappedCompletion'
+                                    actions: [sameRoundAck, 'wrapSearchCappedCompletion']
                                 },
                                 {
                                     guard: 'hasRoundsLeft',
                                     target: '#completion.active.round',
-                                    actions: 'startNextRound'
+                                    actions: [nextRoundAck, 'startNextRound']
                                 },
-                                { target: '#completion.active.wrapping', actions: 'wrapExhaustedCompletion' }
+                                {
+                                    target: '#completion.active.wrapping',
+                                    actions: [sameRoundAck, 'wrapExhaustedCompletion']
+                                }
                             ]
                         },
+                        batching: {
+                            tags: ['running', 'tool'],
+                            invoke: {
+                                src: 'batching',
+                                input: withParent,
+                                onDone: [
+                                    {
+                                        guard: 'batchRan',
+                                        target: 'selecting',
+                                        actions: { type: 'finishBatch', params: ({ event }) => event.output }
+                                    },
+                                    {
+                                        target: 'inspecting',
+                                        actions: {
+                                            type: 'selectNextTool',
+                                            params: ({ context }) => context.toolQueue[0]
+                                        }
+                                    }
+                                ]
+                            }
+                        },
                         inspecting: {
                             tags: ['running', 'tool'],
                             invoke: {
@@ -338,11 +474,14 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                                         }
                                     },
                                     {
-                                        guard: 'skillLoadAllowed',
-                                        target: 'loadingSkill',
+                                        guard: 'planModeWrite',
+                                        target: 'rejecting',
                                         actions: {
-                                            type: 'startSkillTool',
-                                            params: ({ event }) => selected(event.output.execution)
+                                            type: 'rejectPlanModeWrite',
+                                            params: ({ event }) => ({
+                                                call: event.output.call,
+                                                execution: selected(event.output.execution)
+                                            })
                                         }
                                     },
                                     {
@@ -391,17 +530,6 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                                 ]
                             }
                         },
-                        loadingSkill: {
-                            tags: ['running', 'skill'],
-                            invoke: {
-                                src: 'loadingSkill',
-                                input: withParent,
-                                onDone: {
-                                    target: 'selecting',
-                                    actions: { type: 'settleToolSkill', params: ({ event }) => event.output }
-                                }
-                            }
-                        },
                         approving: {
                             tags: ['running', 'tool', 'approval'],
                             invoke: {
@@ -428,6 +556,11 @@ const createCompletionMachineImplementation = (context = emptyCompletionContext(
                                 src: 'executing',
                                 input: withParent,
                                 onDone: [
+                                    {
+                                        guard: 'toolEndedRun',
+                                        target: '#completion.active.finishing',
+                                        actions: { type: 'endRunOnTool', params: ({ event }) => event.output }
+                                    },
                                     {
                                         guard: 'directExecution',
                                         target: '#completion.active.preparing',
@@ -506,6 +639,9 @@ function errorParams({ event }) {
         name: error?.name ?? 'Error'
     };
 }
-function structuredContext(context) {
+function startingContext(context) {
+    if (!context) {
+        throw new Error('A completion run starts from a context that carries its policy');
+    }
     return JSON.parse(JSON.stringify(context));
 }

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

@@ -1,35 +1,6 @@
-import { type ActorRef, type Snapshot } from 'xstate';
-import type { RunJournal } from '../../run-log/run-journal.ts';
-import type { CompletionActorOutputs, CompletionContext, CompletionMachineEvent, EngineEvent, EngineFacts } from './types.ts';
+import type { ActorRef, PromiseActorLogic, Snapshot } from 'xstate';
+import type { CompletionActorOutputs, CompletionContext, CompletionMachineEvent } from './types.ts';
 export type Stage = keyof CompletionActorOutputs;
-export interface Invocation {
-    context: CompletionContext;
-    signal: AbortSignal;
-    stage: string;
-    emit(event: EngineEvent): void;
-    commit(facts: EngineFacts): void;
-    commitSettledResult(operationId: string): void;
-}
-export interface EnginePorts {
-    stages: {
-        [S in Stage]: (cx: Invocation) => Promise<CompletionActorOutputs[S]>;
-    };
-    rebuild(cx: Invocation): Promise<void>;
-    lifecycle(phase: 'runPause' | 'runResume', context: CompletionContext): Promise<void>;
-    settledResultFacts?(operationId: string, current: EngineFacts | null): EngineFacts | undefined;
-    now(): number;
-}
-export interface InvokeTracker {
-    trackInvoke(): () => void;
-    waitForInvokes(): Promise<void>;
-    drainTimedOut(): Promise<boolean>;
-}
-export interface EngineDeps {
-    ports: EnginePorts;
-    journal: RunJournal;
-    invokes: InvokeTracker;
-    emitContent?(event: EngineEvent): void;
-}
 type CompletionParentSnapshot = Snapshot<unknown> & {
     context: CompletionContext;
 };
@@ -37,29 +8,10 @@ export type CompletionParent = Pick<ActorRef<CompletionParentSnapshot, Completio
 export interface InvocationInput {
     parent: CompletionParent;
 }
-export declare function createInvokeTracker(): InvokeTracker;
-export declare function createCompletionActors(deps?: EngineDeps): CompletionActors;
-type CompletionActors = ReturnType<typeof makeCompletionActors>;
-declare function makeCompletionActors(deps?: EngineDeps): {
-    preparing: import("xstate").PromiseActorLogic<import("./types.ts").PreparingOutput, InvocationInput, import("xstate").EventObject>;
-    inspectPreload: import("xstate").PromiseActorLogic<import("./types.ts").PreloadInspectionOutput, InvocationInput, import("xstate").EventObject>;
-    preloading: import("xstate").PromiseActorLogic<import("./types.ts").SkillLoadOutput, InvocationInput, import("xstate").EventObject>;
-    searching: import("xstate").PromiseActorLogic<import("./types.ts").SearchingOutput, InvocationInput, import("xstate").EventObject>;
-    generating: import("xstate").PromiseActorLogic<import("./types.ts").RoundDonePayload, InvocationInput, import("xstate").EventObject>;
-    resolving: import("xstate").PromiseActorLogic<import("./types.ts").ResolvingOutput, InvocationInput, import("xstate").EventObject>;
-    inspecting: import("xstate").PromiseActorLogic<import("./types.ts").InspectingOutput, InvocationInput, import("xstate").EventObject>;
-    rejecting: import("xstate").PromiseActorLogic<import("./types.ts").ToolDonePayload, InvocationInput, import("xstate").EventObject>;
-    loadingSkill: import("xstate").PromiseActorLogic<import("./types.ts").SkillLoadOutput, InvocationInput, import("xstate").EventObject>;
-    approving: import("xstate").PromiseActorLogic<{
-        approved: boolean;
-    }, InvocationInput, import("xstate").EventObject>;
-    executing: import("xstate").PromiseActorLogic<import("./types.ts").ToolDonePayload, InvocationInput, import("xstate").EventObject>;
-    wrapping: import("xstate").PromiseActorLogic<import("./types.ts").RoundDonePayload & {
-        response: string;
-    }, InvocationInput, import("xstate").EventObject>;
-    answering: import("xstate").PromiseActorLogic<import("./types.ts").AnsweredPayload, InvocationInput, import("xstate").EventObject>;
-    finishing: import("xstate").PromiseActorLogic<void, InvocationInput, import("xstate").EventObject>;
-    cleanup: import("xstate").PromiseActorLogic<void, InvocationInput, import("xstate").EventObject>;
-    resume: import("xstate").PromiseActorLogic<void, InvocationInput, import("xstate").EventObject>;
+export type CompletionActorLogic = {
+    [S in Stage]: PromiseActorLogic<CompletionActorOutputs[S], InvocationInput>;
+} & {
+    cleanup: PromiseActorLogic<void, InvocationInput>;
+    resume: PromiseActorLogic<void, InvocationInput>;
 };
 export {};