@averyyy/pi-coding-agent 0.80.3-piclient.3 → 0.80.3-piclient.6

package/dist/core/agent-session.js

@@ -62,12 +62,36 @@ function estimateMessagesTokens(messages) {
 // ============================================================================
 /** Standard thinking levels */
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high"];
+const INTRA_TURN_COMPACTION_MARKER_TYPE = "pi:intra-turn-compaction";
+const INTRA_TURN_COMPACTION_MARKER_TEXT = "Continue from the compaction summary above. The previous tool loop was compacted before the next provider request; use the summary's Operational State, file lists, failures, last command, and next steps.";
+const VALIDATION_HINT_MESSAGE_TYPE = "pi:validation-hint";
+const VALIDATION_HINT_FILE_LIMIT = 12;
+const VALIDATION_HINT_FAILURE_CHAR_LIMIT = 1200;
 function isPiServerMode() {
     return process.env.PI_SERVER_MODE === "true";
 }
 function toProviderReasoning(thinkingLevel) {
     return thinkingLevel === "off" ? undefined : thinkingLevel;
 }
+function getStringField(input, key) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return undefined;
+    const value = input[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function toolTextContent(content) {
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+}
+function compactValidationSummary(text) {
+    const trimmed = text.trim();
+    if (trimmed.length <= VALIDATION_HINT_FAILURE_CHAR_LIMIT)
+        return trimmed;
+    return `...${trimmed.slice(trimmed.length - VALIDATION_HINT_FAILURE_CHAR_LIMIT + 3)}`;
+}
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -98,6 +122,8 @@ export class AgentSession {
     // Bash execution state
     _bashAbortController = undefined;
     _pendingBashMessages = [];
+    _validationModifiedFiles = new Set();
+    _validationFailure = undefined;
     // Extension system
     _extensionRunner;
     _turnIndex = 0;
@@ -197,6 +223,71 @@ export class AgentSession {
         const result = await this._modelRegistry.getApiKeyAndHeaders(model);
         return result.ok ? { apiKey: result.apiKey, headers: result.headers, env: result.env } : {};
     }
+    _resetValidationHintState() {
+        this._validationModifiedFiles.clear();
+        this._validationFailure = undefined;
+    }
+    _recordValidationToolResult(toolName, input, content, isError) {
+        if ((toolName === "edit" || toolName === "write") && !isError) {
+            const path = getStringField(input, "path") ?? getStringField(input, "file_path");
+            if (path) {
+                this._validationModifiedFiles.add(path);
+            }
+            return;
+        }
+        if (toolName !== "bash") {
+            return;
+        }
+        const command = getStringField(input, "command");
+        if (!command) {
+            return;
+        }
+        if (isError) {
+            this._validationFailure = {
+                command,
+                summary: compactValidationSummary(toolTextContent(content)),
+            };
+        }
+        else if (this._validationFailure?.command === command) {
+            this._resetValidationHintState();
+        }
+        else if (!this._validationFailure) {
+            this._validationModifiedFiles.clear();
+        }
+    }
+    _createValidationHintMessage() {
+        const modifiedFiles = Array.from(this._validationModifiedFiles).slice(-VALIDATION_HINT_FILE_LIMIT);
+        if (modifiedFiles.length === 0 && !this._validationFailure) {
+            return undefined;
+        }
+        const lines = ["<validation-hint>"];
+        if (modifiedFiles.length > 0) {
+            lines.push("Recent modified files:", ...modifiedFiles.map((file) => `- ${file}`));
+        }
+        if (this._validationFailure) {
+            lines.push("Recent failed command:", this._validationFailure.command, "Failure summary:", this._validationFailure.summary || "(no output)", "Suggested next validation command:", this._validationFailure.command);
+        }
+        else {
+            lines.push("Suggested next step:", "Run the smallest project validation that covers the modified files.");
+        }
+        lines.push("Inspect failures, fix the root cause, then rerun validation before finalizing.", "</validation-hint>");
+        return {
+            role: "custom",
+            customType: VALIDATION_HINT_MESSAGE_TYPE,
+            content: [{ type: "text", text: lines.join("\n") }],
+            display: false,
+            details: { modifiedFiles, failedCommand: this._validationFailure?.command },
+            timestamp: Date.now(),
+        };
+    }
+    _withValidationHint(context) {
+        const messages = context.messages.filter((message) => !(message.role === "custom" && message.customType === VALIDATION_HINT_MESSAGE_TYPE));
+        const hint = this._createValidationHintMessage();
+        return {
+            ...context,
+            messages: hint ? [...messages, hint] : messages,
+        };
+    }
     /**
      * Install tool hooks once on the Agent instance.
      *
@@ -228,18 +319,20 @@ export class AgentSession {
         };
         this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
             const runner = this._extensionRunner;
-            if (!runner.hasHandlers("tool_result")) {
-                return undefined;
-            }
-            const hookResult = await runner.emitToolResult({
-                type: "tool_result",
-                toolName: toolCall.name,
-                toolCallId: toolCall.id,
-                input: args,
-                content: result.content,
-                details: result.details,
-                isError,
-            });
+            const hookResult = runner.hasHandlers("tool_result")
+                ? await runner.emitToolResult({
+                    type: "tool_result",
+                    toolName: toolCall.name,
+                    toolCallId: toolCall.id,
+                    input: args,
+                    content: result.content,
+                    details: result.details,
+                    isError,
+                })
+                : undefined;
+            const finalContent = hookResult?.content ?? result.content;
+            const finalIsError = hookResult?.isError ?? isError;
+            this._recordValidationToolResult(toolCall.name, args, finalContent, finalIsError);
             if (!hookResult) {
                 return undefined;
             }
@@ -256,15 +349,17 @@ export class AgentSession {
                 ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal)
                 : undefined);
         this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-            const previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal);
-            const previousContext = previousSnapshot?.context ?? turn.context;
+            const compactedContext = await this._compactBeforeNextProviderRequest(turn, signal);
+            const nextTurn = compactedContext ? { ...turn, context: compactedContext } : turn;
+            const previousSnapshot = await previousPrepareNextTurnWithContext?.(nextTurn, signal);
+            const previousContext = previousSnapshot?.context ?? nextTurn.context;
             return {
                 ...previousSnapshot,
-                context: {
+                context: this._withValidationHint({
                     ...previousContext,
                     systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
                     tools: this.agent.state.tools.slice(),
-                },
+                }),
                 model: this.agent.state.model,
                 thinkingLevel: this.agent.state.thinkingLevel,
             };
@@ -394,6 +489,20 @@ export class AgentSession {
     _isTerminalAssistantFailure(message) {
         return message.stopReason === "error" || message.stopReason === "aborted" || message.stopReason === "length";
     }
+    _isPostAssistantPiServerSyncFailure(message) {
+        if (!isPiServerMode() || !message.errorMessage) {
+            return false;
+        }
+        if (!/^(Session init|Session tree (append|sync|switch)|Session history reconciliation) failed/.test(message.errorMessage)) {
+            return false;
+        }
+        const messages = this.agent.state.messages;
+        if (messages[messages.length - 1] !== message) {
+            return false;
+        }
+        const previous = messages[messages.length - 2];
+        return previous?.role === "assistant" && !this._isTerminalAssistantFailure(previous);
+    }
     _detachTerminalAssistantFailure() {
         const branch = this.sessionManager.getBranch();
         let terminalMessageEntry;
@@ -423,6 +532,16 @@ export class AgentSession {
     _detachPiServerTerminalAssistantFailure() {
         this._detachTerminalAssistantFailure();
     }
+    _restoreSessionLeaf(leafId) {
+        if (leafId) {
+            this.sessionManager.branch(leafId);
+        }
+        else {
+            this.sessionManager.resetLeaf();
+        }
+        const sessionContext = this.sessionManager.buildSessionContext();
+        this.agent.state.messages = sessionContext.messages;
+    }
     _replaceMessageInPlace(target, replacement) {
         // Agent-core stores the finalized message object in its state before emitting message_end.
         // SessionManager persistence happens later in _handleAgentEvent() with event.message.
@@ -743,10 +862,26 @@ export class AgentSession {
     // Prompting
     // =========================================================================
     async _runAgentPrompt(messages) {
+        this._resetValidationHintState();
         try {
             await this.agent.prompt(messages);
             while (await this._handlePostAgentRun()) {
-                await this.agent.continue();
+                try {
+                    await this.agent.continue();
+                }
+                catch (error) {
+                    if (this._retryAttempt > 0) {
+                        const attempt = this._retryAttempt;
+                        this._retryAttempt = 0;
+                        this._emit({
+                            type: "auto_retry_end",
+                            success: false,
+                            attempt,
+                            finalError: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                    throw error;
+                }
             }
         }
         finally {
@@ -1636,7 +1771,7 @@ export class AgentSession {
     /**
      * Internal: Run auto-compaction with events.
      */
-    async _runAutoCompaction(reason, willRetry, preparationOverride) {
+    async _runAutoCompaction(reason, willRetry, preparationOverride, preparationOptions) {
         const settings = this.settingsManager.getCompactionSettings();
         let started = false;
         try {
@@ -1672,6 +1807,7 @@ export class AgentSession {
                     apiKey,
                     headers,
                     settings,
+                    preparation: preparationOptions,
                     sessionTree: { entries: this.sessionManager.getEntries(), leafId: this.sessionManager.getLeafId() },
                     signal,
                     reasoning: toProviderReasoning(this.thinkingLevel),
@@ -1812,6 +1948,63 @@ export class AgentSession {
     get autoCompactionEnabled() {
         return this.settingsManager.getCompactionEnabled();
     }
+    _shouldCompactBeforeNextProviderRequest(turn) {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!settings.enabled || turn.toolResults.length === 0)
+            return false;
+        const contextWindow = this.model?.contextWindow ?? 0;
+        if (contextWindow <= 0)
+            return false;
+        const projectedTokens = estimateContextTokens(turn.context.messages).tokens;
+        if (projectedTokens >= contextWindow - settings.reserveTokens)
+            return true;
+        const toolResultTokens = estimateMessagesTokens(turn.toolResults);
+        return toolResultTokens >= settings.keepRecentTokens;
+    }
+    _appendIntraTurnCompactionMarker() {
+        const marker = {
+            role: "custom",
+            customType: INTRA_TURN_COMPACTION_MARKER_TYPE,
+            content: [{ type: "text", text: INTRA_TURN_COMPACTION_MARKER_TEXT }],
+            display: false,
+            details: { reason: "intra-turn-compaction" },
+            timestamp: Date.now(),
+        };
+        const markerId = this.sessionManager.appendCustomMessageEntry(marker.customType, marker.content, marker.display, marker.details);
+        this.agent.state.messages = [...this.agent.state.messages, marker];
+        return markerId;
+    }
+    _currentAgentContext(baseContext) {
+        return {
+            ...baseContext,
+            messages: this.agent.state.messages.slice(),
+            systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
+            tools: this.agent.state.tools.slice(),
+        };
+    }
+    async _compactBeforeNextProviderRequest(turn, signal) {
+        if (signal?.aborted || !this._shouldCompactBeforeNextProviderRequest(turn)) {
+            return undefined;
+        }
+        const settings = this.settingsManager.getCompactionSettings();
+        const markerParentId = this.sessionManager.getLeafId();
+        const markerId = this._appendIntraTurnCompactionMarker();
+        const preparationOptions = { firstKeptEntryId: markerId };
+        const branchWithMarker = this.sessionManager.getBranch();
+        const previousCompactionId = getLatestCompactionEntry(branchWithMarker)?.id;
+        const preparation = prepareCompaction(branchWithMarker, settings, preparationOptions);
+        if (!preparation) {
+            this._restoreSessionLeaf(markerParentId);
+            return undefined;
+        }
+        await this._runAutoCompaction("threshold", false, preparation, preparationOptions);
+        const currentCompactionId = getLatestCompactionEntry(this.sessionManager.getBranch())?.id;
+        if (currentCompactionId === previousCompactionId) {
+            this._restoreSessionLeaf(markerParentId);
+            return undefined;
+        }
+        return this._currentAgentContext(turn.context);
+    }
     async bindExtensions(bindings) {
         if (bindings.uiContext !== undefined) {
             this._extensionUIContext = bindings.uiContext;
@@ -2150,6 +2343,8 @@ export class AgentSession {
         // Context overflow is handled by compaction, not retry.
         if (isContextOverflow(message, this.model?.contextWindow ?? 0))
             return false;
+        if (this._isPostAssistantPiServerSyncFailure(message))
+            return false;
         if (message.errorMessage && this._isNonRetryableProviderLimitError(message.errorMessage))
             return false;
         return isRetryableAssistantError(message);
@@ -2187,6 +2382,18 @@ export class AgentSession {
                 this.agent.state.messages = messages.slice(0, -1);
             }
         }
+        const lastMessage = this.agent.state.messages[this.agent.state.messages.length - 1];
+        if (!lastMessage || lastMessage.role === "assistant") {
+            const attempt = this._retryAttempt;
+            this._retryAttempt = 0;
+            this._emit({
+                type: "auto_retry_end",
+                success: false,
+                attempt,
+                finalError: lastMessage ? "Cannot continue from message role: assistant" : "No messages to continue from",
+            });
+            return false;
+        }
         // Wait with exponential backoff (abortable)
         this._retryAbortController = new AbortController();
         try {