@pentoshi/clai 3.11.28 → 3.11.31

package/dist/agent/runner.js

@@ -6,7 +6,7 @@ import { classifyStreamFailure, planStreamRecovery, recordRecoveryAttempt, creat
 import { modelSupportsVision, resolveToolDialect } from "../llm/capabilities.js";
 import { syntheticToolCallId, isTextOnlyModel, markTextOnlyModel, fromWireName, } from "../llm/tool-protocol.js";
 import { sanitizeAssistantText } from "../ui/ansi-box.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { jobManager, } from "../tools/jobs.js";
 import { isResponderResultLedgerMessage, responderContextMessage, upsertResponderContextMessage, upsertResponderResultLedger, } from "./responder-context.js";
 import { agentModeDirective, planModeDirective, renderAgentSystemPrompt, renderCompactAgentSystemPrompt, renderRequestEnvironmentContext, scratchDirFor, toolNudge, } from "../prompts/index.js";
@@ -86,7 +86,7 @@ import { buildRichStopSummary } from "./stop-summary.js";
 import { composeAgentSystemPrompt } from "./prompt-composer.js";
 import { createGovernorState, governProgress, } from "./evidence-governor.js";
 import { createTurnState, transitionTurn, } from "./turn-state.js";
-import { deriveOutcomeStatus, inferOutcomeKind, openOutcomeState, recordAnswerEvidence, recordFailedHypothesis, recordToolEvidence, saveOutcomeState, validateCriterionEvidence, } from "./outcomes.js";
+import { deriveOutcomeStatus, inferOutcomeKind, openOutcomeState, recordAnswerEvidence, recordFailedHypothesis, recordToolEvidence, completedOperationObservationDigest, saveOutcomeState, validateCriterionEvidence, } from "./outcomes.js";
 import { createTurnOutcome, normalizeTurnOutcomeInput, renderTurnOutcome, } from "./turn-outcome.js";
 import { beginEngagementAction, finishEngagementAction, recordEngagementCheckpoint, reconcileEngagementJob, openEngagement, saveEngagement, } from "../store/engagement.js";
 export * from "./tool-call-parser.js";
@@ -458,6 +458,9 @@ export async function runAgentTurn(prompt, options = {}) {
         let provider = initialProvider;
         await ensureProviderConfigured(provider);
         let model = initialModel;
+        const currentContextLimitTokens = () => options.getContextLimitTokens
+            ? options.getContextLimitTokens(provider, model)
+            : options.contextLimitTokens;
         // Some Groq free-tier models have a per-request/per-minute input budget
         // below the normal agent prompt alone. Select a purpose-built compact
         // instruction set before the request is made, rather than treating the
@@ -853,6 +856,17 @@ export async function runAgentTurn(prompt, options = {}) {
             }
             return message;
         };
+        const upsertActionCycleRecovery = (content) => {
+            const prefix = "[ACTION CYCLE RECOVERY] ";
+            for (let index = messages.length - 1; index >= 0; index -= 1) {
+                const message = messages[index];
+                if (message.role === "user" && message.internal && message.content.startsWith(prefix)) {
+                    messages.splice(index, 1);
+                    break;
+                }
+            }
+            messages.push(recoveryUserMessage(prefix + content));
+        };
         const recoveryProse = (content) => {
             const text = textBeforeToolCall(stripSentinelTokens(content)).trim();
             if (!text ||
@@ -1373,8 +1387,14 @@ export async function runAgentTurn(prompt, options = {}) {
                 ...(retryReason ? { retryReason } : {}),
             });
             if (loopCheck.block) {
-                const reason = loopCheck.reason ??
+                const baseReason = loopCheck.reason ??
                     `${call.name} previously failed with identical arguments. Change the command/args and retry.`;
+                const priorObservation = loopCheck.kind === "unchanged-success"
+                    ? loopGuard.getPriorObservation(call.name, call.args)
+                    : undefined;
+                const reason = priorObservation
+                    ? `${baseReason}\n\nPrior successful result (reuse this; it is the result of the requested call):\n${priorObservation}`
+                    : baseReason;
                 if (loopCheck.kind === "unchanged-success") {
                     const result = { ok: true, output: reason, exitCode: 0 };
                     emitVisibleSyntheticReceipt(result, reason);
@@ -2931,11 +2951,12 @@ export async function runAgentTurn(prompt, options = {}) {
         }
         async function maybeAutoCompact(reason, force = false) {
             const beforeTokens = estimateNextRequestTokens(messages);
+            const contextLimitTokens = currentContextLimitTokens();
             const compactTrigger = autoCompactTriggerTokens(getReliabilityPolicy(), {
                 provider,
                 model,
-                ...(options.contextLimitTokens
-                    ? { contextLimitTokens: options.contextLimitTokens }
+                ...(contextLimitTokens !== undefined
+                    ? { contextLimitTokens }
                     : {}),
             });
             if (!force && beforeTokens < compactTrigger)
@@ -3196,6 +3217,7 @@ export async function runAgentTurn(prompt, options = {}) {
                             writeNotice("info", notice, chalk.dim(`  ℹ ${notice}\n`));
                         }
                     }
+                    const contextLimitTokens = currentContextLimitTokens();
                     await auditLog("agent.turn", {
                         provider,
                         model,
@@ -3204,7 +3226,13 @@ export async function runAgentTurn(prompt, options = {}) {
                         step,
                         // Metadata-only composition metrics (no prompt/tool text).
                         ...contextBreakdownAuditPayload(contextBreakdown),
-                        compactTriggerTokens: autoCompactTriggerTokens(),
+                        compactTriggerTokens: autoCompactTriggerTokens(getReliabilityPolicy(), {
+                            provider,
+                            model,
+                            ...(contextLimitTokens !== undefined
+                                ? { contextLimitTokens }
+                                : {}),
+                        }),
                         maxTokensBudget: resolveStepMaxTokens({
                             nativeToolsActive,
                             toolsAttached,
@@ -3873,7 +3901,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         // Exhausted retries — fall through to the normal answer path.
                     }
-                    if (/<\|tool_call(?:s_section)?_begin\|>|<\|tool_call_argument_begin\|>/i.test(assistantText.visible)) {
+                    if (/<\|tool_call(?:s_section)?_begin\|>|<\|tool_call_argument_begin\|>|<[|｜]DSML[|｜](?:tool_calls|invoke|parameter)\b/i.test(assistantText.visible)) {
                         writeNotice("warn", "tool call was malformed or cut off — asking the model to retry in JSON form", chalk.yellow("  ⚠ tool call was malformed or cut off — asking the model to retry in JSON form\n"));
                         commitAssistantRetry(assistantText.visible);
                         messages.push(recoveryUserMessage(toolsAttached
@@ -4280,11 +4308,20 @@ export async function runAgentTurn(prompt, options = {}) {
                     writeNotice("warn", reason, chalk.yellow(`  ⚠ ${reason}\n`));
                     const suppressedResults = bound.map((b) => {
                         const duplicate = runIds.has(b.id);
-                        const resultReason = duplicate ? reason : deferReason;
+                        const priorObservation = duplicate
+                            ? loopGuard.getPriorObservation(b.call.name, b.call.args)
+                            : undefined;
+                        const resultReason = duplicate
+                            ? reason +
+                                (priorObservation
+                                    ? `\n\nPrior successful result for ${b.call.name}:\n${priorObservation}`
+                                    : "")
+                            : deferReason;
                         const result = {
-                            ok: false,
+                            ok: duplicate,
                             output: resultReason,
-                            exitCode: duplicate ? 409 : 130,
+                            exitCode: duplicate ? 0 : 130,
+                            ...(duplicate ? { suppressedRepeat: true } : {}),
                         };
                         return { b, resultReason, result };
                     });
@@ -4305,22 +4342,6 @@ export async function runAgentTurn(prompt, options = {}) {
                         writeToolOutput(eventId, output, chalk.dim(`  ${output}`));
                         emitToolResult(eventId, result, resultReason);
                     }
-                    if (historyNativeCalls.length) {
-                        appendAssistantWithTools(messages, beforeTool ?? "", historyNativeCalls, completion.reasoningBlock ??
-                            (assistantText.hasThinking && assistantText.thinkContent
-                                ? { text: assistantText.thinkContent }
-                                : undefined));
-                        for (const { b, resultReason, result } of suppressedResults) {
-                            appendToolResult(messages, b.id, `Tool ${b.call.name} result (exit=${result.exitCode}, ok=false):\n${resultReason}`, b.call.name, false);
-                        }
-                    }
-                    else {
-                        const standardizedContent = (beforeTool ? beforeTool.trim() + "\n\n" : "") +
-                            allCalls
-                                .map((candidate) => `\`\`\`tool\n${JSON.stringify(candidate)}\n\`\`\``)
-                                .join("\n\n");
-                        pushAssistantHistory(standardizedContent);
-                    }
                     if (sequenceDecision.terminal) {
                         const remainingCriteria = unreadResponderNotificationIds.size > 0
                             ? ["Analyze and acknowledge the delivered Responder result without repeating completed foreground work."]
@@ -4330,10 +4351,10 @@ export async function runAgentTurn(prompt, options = {}) {
                         moveTurn("partial", "repeated identical action sequence");
                         return finishTurn("Stopped an identical action cycle before it could execute again.", productiveSteps, "partial", remainingCriteria, "The model repeated an identical action sequence without a new premise or state change.");
                     }
-                    messages.push(recoveryUserMessage(reason +
+                    upsertActionCycleRecovery(reason +
                         (unreadResponderNotificationIds.size > 0
                             ? " A delivered Responder result is still unread: analyze the available result, gather only genuinely necessary bounded evidence, then call job.read before returning to foreground work."
-                            : " Reassess the evidence and select the next action yourself; do not replay completed work.")));
+                            : " The original successful tool result remains in context. Reassess that evidence and either finish or select a materially different action; do not replay completed work."));
                     continue;
                 }
                 if (sequenceDecision.warn && sequenceDecision.warnMessage) {
@@ -4397,6 +4418,7 @@ export async function runAgentTurn(prompt, options = {}) {
                 let planCreatedThisTurn = Boolean(activePlan && activePlan.tasks.length > 0);
                 let actionSequenceExecuted = 0;
                 let actionSequenceEligible = allCalls.length > 0;
+                const actionSequenceOutcomes = new Map();
                 /**
                  * Record a tool result into history. Failures / user declines are
                  * always returned to the model — we never cancel later siblings or
@@ -4407,6 +4429,15 @@ export async function runAgentTurn(prompt, options = {}) {
                     consecutiveModelOnlyRounds = 0;
                     recordedNativeIds.add(boundCall.id);
                     actionSequenceExecuted += 1;
+                    const sequenceObservation = res.suppressedRepeat
+                        ? loopGuard.getPriorObservation(res.call.name, res.call.args) ??
+                            res.contextOutput
+                        : res.result.output ?? res.contextOutput;
+                    actionSequenceOutcomes.set(boundCall.id, JSON.stringify({
+                        ok: res.ok,
+                        exitCode: res.result.exitCode ?? null,
+                        digest: completedOperationObservationDigest(res.call.name, sequenceObservation),
+                    }));
                     // A policy-suppressed call is deterministic: replaying it verbatim
                     // returns the identical receipt. It must therefore keep the sequence
                     // eligible, otherwise the tool-level suppression and the sequence
@@ -4746,12 +4777,16 @@ export async function runAgentTurn(prompt, options = {}) {
                     }
                     fillMissingToolResults(messages, historyNativeCalls, "Cancelled — not executed this turn.");
                 }
+                const actionSequenceOutcome = createHash("sha256")
+                    .update(JSON.stringify(bound.map((entry) => actionSequenceOutcomes.get(entry.id) ?? null)))
+                    .digest("hex")
+                    .slice(0, 24);
                 loopGuard.completeActionSequence(actionSequenceCalls, actionSequenceEligible &&
                     toRun.length === bound.length &&
                     actionSequenceExecuted === allCalls.length &&
                     !aborted &&
                     !awaitingPlanApproval &&
-                    !governorPauseReason);
+                    !governorPauseReason, actionSequenceOutcome);
                 // Keep ledger system rows outside the native assistant→tool group so
                 // protocol repair preserves the real successful job.read body.
                 for (const notification of deferredResponderLedgerNotifications.splice(0)) {