@namzu/sdk 62.6.0 → 62.7.0

package/dist/runtime/query/iteration/index.js

@@ -14,6 +14,7 @@ import { GENAI, NAMZU, agentIterationSpanName, parentContext, } from '../../../t
 import { getTracer } from '../../../telemetry/runtime-accessors.js';
 import { STRUCTURED_OUTPUT_TOOL_NAME } from '../../../tools/builtins/structuredOutput.js';
 import { RECALLED_MEMORY_ENTRY_KEY, recalledMemoryIds } from '../../../turn/memory-recall.js';
+import { promptSizeOf } from '../../../types/common/index.js';
 import { NamzuError } from '../../../types/errors/index.js';
 import { createAssistantMessage, createRuntimeContextMessage, createSystemMessage, createToolMessage, turnContextEntries, turnContextKey, } from '../../../types/message/index.js';
 import { classifyProviderError, readOutputOverflow } from '../../../types/provider/errors.js';
@@ -30,7 +31,8 @@ import { diffRequestContext, snapshotRequestContext, } from '../request-context.
 import { markProviderRejectedImage, projectRequestRichContent, resolveMaxRequestRichContentBytes, } from '../request-rich-content.js';
 import { withoutVoidAssistantTurns } from '../request-void-turns.js';
 import { formatSteeringNote, isOperatorUserMessage } from '../steering.js';
-import { COMPLETION_AUDIT_MESSAGE, CompletionAudit } from '../turn/completion-audit.js';
+import { CompletionAudit } from '../turn/completion-audit.js';
+import { OutcomeLedger } from '../turn/outcome-ledger.js';
 import { FORCED_STEP_MESSAGE, REASONING_CAPPED_MESSAGE, REASONING_ONLY_MESSAGE, StallMonitor, callChangedState, reasoningCapChars, } from '../turn/stall-monitor.js';
 import { effortForModel } from './effort-clamp.js';
 import { parseNativeCandidate } from './native-output.js';
@@ -38,7 +40,7 @@ import { drainArrivedTaskCompletions, holdForOutstandingWork, settleOutstandingW
 import { runAdvisoryPhase } from './phases/advisory.js';
 import { runIterationCheckpoint } from './phases/checkpoint.js';
 import { compactionBreaker, estimateRefillTokens } from './phases/compaction-breaker.js';
-import { AUTOMATIC_COMPACTION_FAILED, OVERFLOW_RELIEF_LIMIT, activeContextWindow, clearCompactionErrorNote, compactionErrorNote, measureContext, relieveOverflow, runCompactionCheck, stopOnRefill, } from './phases/compaction.js';
+import { AUTOMATIC_COMPACTION_FAILED, OVERFLOW_RELIEF_LIMIT, activeContextWindow, clearCompactionErrorNote, compactionErrorNote, measureContext, relieveOverflow, runCompactionCheck, runStaleResultClear, stopOnRefill, } from './phases/compaction.js';
 import { runHandoffPause } from './phases/handoff.js';
 import { runPlanGate } from './phases/plan.js';
 import { runToolReview } from './phases/tool-review.js';
@@ -212,6 +214,9 @@ export class IterationOrchestrator {
     stallMonitor;
     /** Holds the turn back once when it changed files and checked nothing afterwards. */
     completionAudit;
+    /** What the turn changed and what checked it; see {@link OutcomeLedger}. Kept whether or not the host asked. */
+    outcomeLedger;
+    outcomeHydrated = false;
     /** The next step must call a tool, at low effort: set by the stall monitor or a capped step. */
     forceActionNextStep = false;
     /** Steps in a row cut at the per-step reasoning cap; past a few the cap stops applying. */
@@ -238,6 +243,10 @@ export class IterationOrchestrator {
     turnEndFired = false;
     /** A hook already kept this turn going once: it is asked again with `stop_hook_active`. */
     stopHookActive = false;
+    /** End-of-turn refusals honoured since the last tool call. */
+    consecutiveHookRefusals = 0;
+    /** The cap was reached and its notice recorded; refusals are ignored for the rest of the turn. */
+    hookRefusalCapReached = false;
     get turnEndHooksFired() {
         return this.turnEndFired;
     }
@@ -249,6 +258,10 @@ export class IterationOrchestrator {
      * are returned, joined, as feedback for the model. A hook that asks for the
      * turn to halt wins over any such feedback (`takeHalt`). With nothing asked,
      * the events have fired for this turn and the finalizer does not repeat them.
+     *
+     * Refusals are counted in a row (a tool call in between starts the count
+     * over). Once `maxHookRefusals` have been honoured the next one is not: the
+     * turn ends, with one notice that names the hook.
      */
     async *askStopHooks() {
         const manager = this.ctx.pluginManager;
@@ -256,6 +269,12 @@ export class IterationOrchestrator {
             return undefined;
         const recorder = this.ctx.recorder;
         const feedback = [];
+        const refusers = [];
+        const emit = async (event) => {
+            if (event.type === 'plugin_hook_completed' && event.result.action === 'skip')
+                refusers.push(String(event.pluginId));
+            await this.ctx.emitEvent(event);
+        };
         const ask = async (event, extra) => {
             const results = await manager.executeHooks(event, {
                 sessionId: recorder.sessionId,
@@ -263,7 +282,7 @@ export class IterationOrchestrator {
                 ...extra,
                 ...(this.stopHookActive ? { stopHookActive: true } : {}),
                 signal: this.ctx.abortController.signal,
-            }, this.ctx.emitEvent);
+            }, emit);
             applyLifecycleHookResults(event, results);
             for (const result of results) {
                 if (result.action === 'skip')
@@ -283,10 +302,30 @@ export class IterationOrchestrator {
             });
             yield* this.ctx.drainPending();
         }
-        if (feedback.length === 0) {
+        // Once the cap has been reached, refusals stay ignored for the rest of the turn,
+        // whatever a tool call does to the count; a halt was already passed on above.
+        if (feedback.length === 0 || this.hookRefusalCapReached) {
             this.turnEndFired = true;
             return undefined;
         }
+        const limit = this.ctx.turnConfig.maxHookRefusals ?? 0;
+        if (limit > 0 && this.consecutiveHookRefusals >= limit) {
+            // The turn has been kept going `limit` times in a row. A hook that
+            // still refuses is not going to stop; say so once, and let the turn end.
+            this.turnEndFired = true;
+            if (!this.hookRefusalCapReached) {
+                this.hookRefusalCapReached = true;
+                const names = [...new Set(refusers)];
+                const who = names.length > 0 ? names.map((n) => `"${n}"`).join(', ') : 'A hook';
+                recorder.pushMessage(createRuntimeContextMessage(`${who} asked for more before this turn could end ${limit} times in a row. Namzu is ending the turn anyway and will not honour further requests from it this turn.`, 'hook-feedback'));
+                this.ctx.log.warn('Hook refusal limit reached — ending the turn', {
+                    [NAMZU.TURN_ID]: recorder.turnId,
+                    'namzu.runtime.limit': limit,
+                });
+            }
+            return undefined;
+        }
+        this.consecutiveHookRefusals++;
         this.stopHookActive = true;
         return feedback.join('\n');
     }
@@ -304,6 +343,13 @@ export class IterationOrchestrator {
         };
         if (ctx.turnConfig.completionAudit === true)
             this.completionAudit = new CompletionAudit();
+        this.outcomeLedger = new OutcomeLedger(ctx.turnConfig.outcome);
+        ctx.checkpointMgr.setOutcomeSource?.(() => {
+            this.hydrateOutcome();
+            return this.outcomeLedger.recorded
+                ? this.outcomeLedger.snapshot()
+                : undefined;
+        });
         if (ctx.turnConfig.reasoning?.stall !== false) {
             this.stallMonitor = new StallMonitor(ctx.turnConfig.reasoning?.stall || undefined);
         }
@@ -640,6 +686,8 @@ export class IterationOrchestrator {
                     // edge BEFORE compaction runs (so the refreshed slot is what
                     // compaction preserves). No-op when no provider is configured.
                     await refreshWorkingMemory(this.ctx);
+                    if (iterationNum === 1)
+                        await runStaleResultClear(this.ctx);
                     await runCompactionCheck(this.ctx);
                     yield* this.ctx.drainPending();
                     if (this.stopForCompactionBreaker())
@@ -1089,7 +1137,7 @@ export class IterationOrchestrator {
                         'namzu.runtime.finish_reason': response.finishReason,
                         'namzu.runtime.has_content': response.message.content !== null && response.message.content.length > 0,
                         'namzu.runtime.tool_call_count': response.message.toolCalls?.length ?? 0,
-                        [GENAI.USAGE_INPUT_TOKENS]: response.usage.promptTokens,
+                        [GENAI.USAGE_INPUT_TOKENS]: promptSizeOf(response.usage),
                         [GENAI.USAGE_OUTPUT_TOKENS]: response.usage.completionTokens,
                         'namzu.usage.total_tokens': recorder.tokenUsage.totalTokens,
                         'namzu.runtime.total_cost': recorder.costInfo.totalCost,
@@ -1187,7 +1235,7 @@ export class IterationOrchestrator {
                     }
                     yield* this.ctx.drainPending();
                     iterSpan.setAttributes({
-                        [GENAI.USAGE_INPUT_TOKENS]: response.usage.promptTokens,
+                        [GENAI.USAGE_INPUT_TOKENS]: promptSizeOf(response.usage),
                         [GENAI.USAGE_OUTPUT_TOKENS]: response.usage.completionTokens,
                     });
                     iterSpan.setStatus({ code: SpanStatusCode.OK });
@@ -1609,13 +1657,14 @@ export class IterationOrchestrator {
                         // back to the model and the turn goes on.
                         // Files were changed and nothing checked them afterwards: ask once
                         // for a check before the turn is allowed to end.
-                        if (!forceFinalize &&
-                            closingStopReason === undefined &&
-                            this.completionAudit?.takeBlock()) {
+                        const auditReminder = !forceFinalize && closingStopReason === undefined
+                            ? this.completionAudit?.takeReminder(() => this.outcomeLedger.peek())
+                            : undefined;
+                        if (auditReminder !== undefined) {
                             this.ctx.log.info('Files changed and nothing checked them — asking for a check', {
                                 [NAMZU.TURN_ID]: recorder.turnId,
                             });
-                            recorder.pushMessage(createRuntimeContextMessage(COMPLETION_AUDIT_MESSAGE, 'progress-nudge'));
+                            recorder.pushMessage(createRuntimeContextMessage(auditReminder, 'progress-nudge'));
                             continue;
                         }
                         if (!forceFinalize && closingStopReason === undefined) {
@@ -1635,6 +1684,9 @@ export class IterationOrchestrator {
                             (stopWasDeferredForOutstandingWork ? 'stop_condition' : 'end_turn'));
                         break;
                     }
+                    // A real tool call: whatever a hook refused before it is behind us.
+                    this.consecutiveHookRefusals = 0;
+                    await this.outcomeBefore(response);
                     const reviewOutcome = yield* runToolReview(this.ctx, response, iterationNum);
                     // The step record is built even for a rejected batch: a turn that
                     // spent a turn getting its tools refused still spent the tokens,
@@ -1658,6 +1710,7 @@ export class IterationOrchestrator {
                     this.reasoningOnlyRetried = false;
                     this.observeStall(response, reviewOutcome.results);
                     this.observeAudit(response, reviewOutcome.results);
+                    await this.outcomeObserve(iterationNum, response, reviewOutcome.results);
                     if (reviewOutcome.decision === 'stop') {
                         return;
                     }
@@ -2814,6 +2867,101 @@ export class IterationOrchestrator {
             return undefined;
         }
     }
+    /**
+     * Take back the outcome record a checkpoint kept. Done at first use rather
+     * than at construction: the checkpoint is read after this is built. A turn
+     * resumed from a checkpoint with no record cannot say what came before it,
+     * so it keeps none.
+     */
+    hydrateOutcome() {
+        if (this.outcomeHydrated)
+            return;
+        this.outcomeHydrated = true;
+        const restored = this.ctx.checkpointMgr.restoredOutcome;
+        if (restored?.resumed !== true)
+            return;
+        if (restored.snapshot === undefined)
+            this.outcomeLedger.markUnrecorded();
+        else
+            this.outcomeLedger.restore(restored.snapshot);
+    }
+    /** Whether a call is one the outcome record may treat as only looking. */
+    lookedOnly(toolName, input) {
+        try {
+            return !callChangedState(toolName, this.ctx.tools.get(toolName)?.isReadOnly?.(input), false);
+        }
+        catch {
+            return false;
+        }
+    }
+    parsedInput(call) {
+        try {
+            return call ? JSON.parse(call.function.arguments) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Before a step's calls run: the first one that could change the workspace
+     * takes the starting fingerprint. A failure here must not fail the turn.
+     */
+    async outcomeBefore(response) {
+        try {
+            this.hydrateOutcome();
+            const pending = (response.message.toolCalls ?? []).map((call) => {
+                const input = this.parsedInput(call);
+                return {
+                    toolName: call.function.name,
+                    input,
+                    readOnly: this.lookedOnly(call.function.name, input),
+                };
+            });
+            await this.outcomeLedger.before(pending);
+        }
+        catch (err) {
+            this.ctx.log.warn('The outcome record could not take its starting point', {
+                'exception.message': toErrorMessage(err),
+            });
+        }
+    }
+    /** Feed the outcome record the calls of one finished step. */
+    async outcomeObserve(step, response, results) {
+        try {
+            this.hydrateOutcome();
+            const calls = new Map((response.message.toolCalls ?? []).map((c) => [c.id, c]));
+            const seen = results.map((result) => {
+                const input = this.parsedInput(calls.get(result.toolCallId));
+                return {
+                    toolName: result.toolName,
+                    input,
+                    isError: result.isError,
+                    ...(result.skipped ? { skipped: true } : {}),
+                    readOnly: this.lookedOnly(result.toolName, input),
+                    ...(result.facts ? { facts: result.facts } : {}),
+                };
+            });
+            await this.outcomeLedger.observe(step, seen);
+        }
+        catch (err) {
+            this.ctx.log.warn('The outcome record could not read a step', {
+                'exception.message': toErrorMessage(err),
+            });
+        }
+    }
+    /** The outcome record as the turn leaves it; `undefined` when none was kept. */
+    async takeOutcome() {
+        try {
+            this.hydrateOutcome();
+            return await this.outcomeLedger.finish();
+        }
+        catch (err) {
+            this.ctx.log.warn('The outcome record could not be settled', {
+                'exception.message': toErrorMessage(err),
+            });
+            return undefined;
+        }
+    }
     /** Feed the completion audit the calls of one finished step. */
     observeAudit(response, results) {
         const audit = this.completionAudit;