@mikode13/harness 9.3.1 → 10.0.0

package/dist/engines/domain/model/llmAgent.js

@@ -1,18 +1,19 @@
 import { readDecision, } from '#src/agent/domain/approval';
 import { ignoreProgress, } from '#src/agent/domain/agent';
-import { RunContext, runContextOf, withRunContext, } from '#src/agent/domain/runContext';
+import { delegationOf, RunContext, runContextOf, withRunContext, } from '#src/agent/domain/runContext';
 import { InvalidAgentConfigError, RecoverableError, UnrecoverableError, withSpentTokens, } from '#src/shared/domain/errors';
 import { classifyHostFailure, classifyLocalFailure, classifyProviderFailure, describeFailure, treatErrors, } from '#src/shared/domain/providerFailure';
 import { Conversation } from '#src/llm/domain/conversation';
 import { asNative, nativeOf } from '#src/llm/domain/tool';
-import { prepareCall, ToolExecutionError, } from '#src/tools/domain/preparedCall';
+import { readAnswers } from '#src/agent/domain/question';
+import { prepareCall, RunEndingToolError, ToolExecutionError, } from '#src/tools/domain/preparedCall';
 import { ReadRegistry } from '#src/tools/domain/readRegistry';
 import { InvalidToolInputError } from '#src/tools/domain/tool';
 import { isAbortError } from '#src/shared/domain/isAbortError';
 import { addTokens } from '#src/shared/domain/tokens';
 import { anotherAttempt, askAt, CommandLoops, extensionNote, loopQuestion, loopStop, loopWarning, repeatedAnswersAt, repeatNote, repeatQuestion, repeatStop, stop, warnAt, } from "./commandLoops.js";
 import { measureContext } from "./stepContext.js";
-import { askUserDefinition, askUserName, describeAnswers, readAnswers, readQuestions, summarizeQuestions, } from "./askUser.js";
+import { askUserDefinition, askUserName, describeAnswers, readQuestions, summarizeQuestions, } from "./askUser.js";
 import { followHistory, transcriptOf, undoNote, } from "./historyFollower.js";
 function describePart(part) {
     switch (part.type) {
@@ -305,8 +306,8 @@ export class LLMAgent {
     }
     /**
      * Always answers the call: a missing tool, a denied call or a failing one becomes an error
-     * result, so the model can correct itself. Only a cancellation, or a failing approver,
-     * escapes, whatever error the tool turned it into.
+     * result, so the model can correct itself. Only a cancellation, a failing approver, or host
+     * code that failed inside the call, such as an agent's approver, escapes.
      */
     async runTool(call, { signal, onProgress: callback = ignoreProgress, approve, ask }, effects, toolCall) {
         const result = { type: 'toolResult', callId: call.id, name: call.name };
@@ -398,6 +399,8 @@ export class LLMAgent {
         }
         catch (error) {
             signal.throwIfAborted();
+            if (error instanceof RunEndingToolError)
+                throw error.failure;
             const ending = prepared.ending?.();
             return {
                 result: { ...result, output: describeFailure(error), isError: true },
@@ -447,60 +450,39 @@ export class LLMAgent {
             summary,
         };
     }
-    /** One at a time and in order, so their effects and their narration never interleave. */
+    /**
+     * One at a time and in order, so their effects and their narration never interleave. Only
+     * calls of a `parallel` tool next to each other run at once, such as agents being delegated
+     * to, each narrated as it goes.
+     */
     async runTools(calls, options, effects, toolCall, 
     // Throws the failure of a progress callback a call narrated through.
     throwIfProgressFailed, loops) {
-        const { signal, onProgress: callback = ignoreProgress } = options;
+        const { signal } = options;
         const results = [];
+        // The calls before this index already ran, with the ones they ran beside.
+        let ranTo = 0;
         for (const [index, call] of calls.entries()) {
+            if (index < ranTo)
+                continue;
             // A call before this one may have ignored the cancellation; this one must not start,
             // nor be announced as running.
             signal.throwIfAborted();
+            const together = this.parallelFrom(calls, index);
+            if (together.length > 1) {
+                results.push(...(await this.runTogether(together, options, effects, toolCall, loops)));
+                throwIfProgressFailed();
+                ranTo = index + together.length;
+                continue;
+            }
             // `runTool` announces the call only once it is allowed to run, so a consumer never
             // shows a call as running early, nor while the user is still being asked.
             const ran = await this.runTool(call, options, effects, toolCall);
-            const { denied, diff, summary, exitCode, ending } = ran;
-            let { result } = ran;
             // A call that failed to narrate ends the run before the next one can start.
             throwIfProgressFailed();
-            if (ran.unrecorded)
-                loops.unrecordedCallRan();
-            const key = callKey(call);
-            const label = summary ?? call.name;
-            const alike = ending === undefined ? undefined : loops.observe(key, ending);
-            // A command that changed what the history cannot copy hides that change from the next.
-            if (ending !== undefined && ending.state === undefined)
-                loops.unrecordedCallRan();
-            // Narrated with it, so the person watching reads what the model is told.
-            if (alike?.times === warnAt) {
-                result = {
-                    ...result,
-                    output: `${result.output}\n\n${loopWarning(label, alike, options.ask !== undefined && !loops.wentOn)}`,
-                };
-            }
-            if (denied) {
-                emit({
-                    type: 'tool',
-                    id: call.id,
-                    name: call.name,
-                    status: 'denied',
-                    ...(summary === undefined ? {} : { summary }),
-                }, callback);
-            }
-            // The diff of a change it made, for the person watching; only once it was made.
-            else if (diff !== undefined) {
-                emit({
-                    type: 'tool',
-                    id: call.id,
-                    name: call.name,
-                    status: 'completed',
-                    diff,
-                    ...(summary === undefined ? {} : { summary }),
-                }, callback);
-            }
-            else
-                narrate(result, callback, summary, exitCode);
+            const settled = this.settle(call, ran, loops, options);
+            let { result } = settled;
+            const { alike, key, label } = settled;
             // After its result is narrated, so the user is asked about the ending they have seen.
             if (alike !== undefined && alike.times >= askAt) {
                 const decision = await this.decideOnLoop({
@@ -526,6 +508,93 @@ export class LLMAgent {
         }
         return { message: { role: 'tool', content: results } };
     }
+    /** The calls from `index` on whose tool is `parallel`, up to the first that is not. */
+    parallelFrom(calls, index) {
+        const together = [];
+        for (const call of calls.slice(index)) {
+            const tool = this.tools.get(call.name);
+            if (!tool || !('parallel' in tool) || tool.parallel !== true)
+                break;
+            together.push(call);
+        }
+        return together;
+    }
+    /**
+     * Runs the calls at once, their results in the order of the calls. The first failure that
+     * ends the run stops the others, and the run ends once every one has.
+     */
+    async runTogether(calls, options, effects, toolCall, loops) {
+        const stopping = new AbortController();
+        const together = { ...options, signal: AbortSignal.any([options.signal, stopping.signal]) };
+        const ended = {};
+        const settled = await Promise.allSettled(calls.map(async (call) => {
+            try {
+                const ran = await this.runTool(call, together, effects, toolCall);
+                return this.settle(call, ran, loops, options).result;
+            }
+            catch (error) {
+                ended.failure ??= { error };
+                stopping.abort();
+                throw error;
+            }
+        }));
+        // The others were stopped for it: what ended the run is the first failure, or the user.
+        options.signal.throwIfAborted();
+        if (ended.failure) {
+            const { error } = ended.failure;
+            // A call stopped on its way may have spent on the model, and a stop carries no tokens:
+            // the run's total is unknown, not short.
+            const stopped = settled.some(outcome => outcome.status === 'rejected' && outcome.reason !== error);
+            throw stopped ? withSpentTokens(error, undefined, true) : error;
+        }
+        return settled.flatMap(outcome => (outcome.status === 'fulfilled' ? [outcome.value] : []));
+    }
+    /**
+     * Narrates how a call ended and notes its command's ending, with the warning for the model
+     * when that ending keeps coming back alike.
+     */
+    settle(call, ran, loops, { onProgress: callback = ignoreProgress, ask }) {
+        const { denied, diff, summary, exitCode, ending } = ran;
+        let { result } = ran;
+        if (ran.unrecorded)
+            loops.unrecordedCallRan();
+        const key = callKey(call);
+        const label = summary ?? call.name;
+        const alike = ending === undefined ? undefined : loops.observe(key, ending);
+        // A command that changed what the history cannot copy hides that change from the next.
+        if (ending !== undefined && ending.state === undefined)
+            loops.unrecordedCallRan();
+        // Narrated with it, so the person watching reads what the model is told.
+        if (alike?.times === warnAt) {
+            result = {
+                ...result,
+                output: `${result.output}\n\n${loopWarning(label, alike, ask !== undefined && !loops.wentOn)}`,
+            };
+        }
+        if (denied) {
+            emit({
+                type: 'tool',
+                id: call.id,
+                name: call.name,
+                status: 'denied',
+                ...(summary === undefined ? {} : { summary }),
+            }, callback);
+        }
+        // The diff of a change it made, for the person watching; only once it was made.
+        else if (diff !== undefined) {
+            emit({
+                type: 'tool',
+                id: call.id,
+                name: call.name,
+                status: 'completed',
+                diff,
+                ...(summary === undefined ? {} : { summary }),
+            }, callback);
+        }
+        else
+            narrate(result, callback, summary, exitCode);
+        return { result, alike, key, label };
+    }
     /**
      * On a loop found, the fifth ending alike of a command or the fifth answer in a row asking for
      * the same calls: the note for the model if the user lets the run go on, or the failure that
@@ -607,16 +676,17 @@ export class LLMAgent {
             response = await this.takeSteps(prompt, options, context, seen);
         }
         catch (error) {
-            await this.transcribe(seen, isAbortError(error) ? 'cancelled' : 'failed', error);
+            await this.transcribe(seen, options, isAbortError(error) ? 'cancelled' : 'failed', error);
             throw error;
         }
-        await this.transcribe(seen, 'completed');
+        await this.transcribe(seen, options, 'completed');
         return response;
     }
     /** Hands the run's transcript to the consumer, whose failure is logged, not the run's. */
-    async transcribe(seen, outcome, error) {
+    async transcribe(seen, options, outcome, error) {
         if (!this.onTranscript)
             return;
+        const delegation = delegationOf(options);
         try {
             // A copy, so a consumer that changes it cannot change the agent's tools or conversation.
             const content = structuredClone({
@@ -629,7 +699,19 @@ export class LLMAgent {
                 messages: seen.messages(),
                 ...(outcome === 'completed' ? {} : { error: describeFailure(error) }),
             });
-            await this.onTranscript({ outcome, content });
+            await this.onTranscript({
+                ...(delegation
+                    ? {
+                        delegation: {
+                            tool: delegation.tool,
+                            callId: delegation.callId,
+                            subagent: delegation.subagent,
+                        },
+                    }
+                    : {}),
+                outcome,
+                content,
+            });
         }
         catch (failure) {
             treatErrors(() => {
@@ -801,7 +883,15 @@ export class LLMAgent {
                 }
                 // On the last step no call is left to send the results to, so the tools do not run.
                 if (step < this.maxSteps) {
-                    const { message, stopped } = await this.runTools(calls, options, effects, { run: context, reads, onProgress, spend }, throwIfProgressFailed, loops);
+                    const { message, stopped } = await this.runTools(calls, options, effects, {
+                        run: context,
+                        reads,
+                        onProgress,
+                        spend,
+                        depth: delegationOf(options)?.depth ?? 0,
+                        ...(options.approve ? { approve: options.approve } : {}),
+                        ...(options.ask ? { ask: options.ask } : {}),
+                    }, throwIfProgressFailed, loops);
                     runMessages.push(repeatedNote === undefined ? message : withNote(message, repeatedNote));
                     // Kept like a run cut by the output limit: the user may take it up.
                     if (stopped) {