@averyyy/pi-coding-agent 0.80.3-piclient.5 → 0.80.3-piclient.7

package/dist/core/agent-session.js

@@ -62,12 +62,84 @@ 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;
+const AUTO_SESSION_NAME_INPUT_CHAR_LIMIT = 4000;
+const AUTO_SESSION_NAME_MAX_CHARS = 80;
+const AUTO_SESSION_NAME_PROMPT = "Name this coding session from the transcript below. Return only a concise title, in the user's language when clear. No quotes, no markdown, no explanation. Do not call tools.";
 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 getPiServerFailurePhase(message) {
+    for (const diagnostic of message.diagnostics ?? []) {
+        if (diagnostic.type !== "pi_server_failure")
+            continue;
+        const phase = diagnostic.details?.phase;
+        if (typeof phase === "string")
+            return phase;
+    }
+    return 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)}`;
+}
+function messageTextContent(message) {
+    if (!("content" in message))
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n")
+        .trim();
+}
+function truncateForSessionNameInput(text) {
+    if (text.length <= AUTO_SESSION_NAME_INPUT_CHAR_LIMIT)
+        return text;
+    return text.slice(0, AUTO_SESSION_NAME_INPUT_CHAR_LIMIT).trim();
+}
+function sanitizeGeneratedSessionName(text) {
+    const firstLine = text
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstLine)
+        return undefined;
+    const title = firstLine
+        .replace(/^title:\s*/iu, "")
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!title)
+        return undefined;
+    return title.length > AUTO_SESSION_NAME_MAX_CHARS ? title.slice(0, AUTO_SESSION_NAME_MAX_CHARS).trim() : title;
+}
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -98,6 +170,8 @@ export class AgentSession {
     // Bash execution state
     _bashAbortController = undefined;
     _pendingBashMessages = [];
+    _validationModifiedFiles = new Set();
+    _validationFailure = undefined;
     // Extension system
     _extensionRunner;
     _turnIndex = 0;
@@ -118,6 +192,7 @@ export class AgentSession {
     _extensionShutdownHandler;
     _extensionErrorListener;
     _extensionErrorUnsubscriber;
+    _autoSessionNameAttempted = false;
     // Model registry for API key resolution
     _modelRegistry;
     // Tool registry for extension getTools/setTools
@@ -197,6 +272,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 +368,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 +398,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 +538,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 +581,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,17 +911,100 @@ 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;
+                }
             }
+            await this._maybeGenerateSessionName();
         }
         finally {
             this._systemPromptOverride = undefined;
             this._flushPendingBashMessages();
         }
     }
+    _sessionHasInfoEntry() {
+        return this.sessionManager.getEntries().some((entry) => entry.type === "session_info");
+    }
+    _buildSessionNameTranscript() {
+        const lines = [];
+        for (const message of this.agent.state.messages) {
+            if (message.role !== "user" && message.role !== "assistant")
+                continue;
+            const text = messageTextContent(message);
+            if (!text)
+                continue;
+            lines.push(`${message.role === "user" ? "User" : "Assistant"}: ${text}`);
+        }
+        const transcript = lines.join("\n\n").trim();
+        return transcript ? truncateForSessionNameInput(transcript) : undefined;
+    }
+    _shouldGenerateSessionName() {
+        if (this._autoSessionNameAttempted || this._sessionHasInfoEntry())
+            return false;
+        const userMessages = this.agent.state.messages.filter((message) => message.role === "user");
+        if (userMessages.length !== 1)
+            return false;
+        const lastAssistant = this._findLastAssistantMessage();
+        return lastAssistant !== undefined && !this._isTerminalAssistantFailure(lastAssistant);
+    }
+    async _maybeGenerateSessionName() {
+        if (!this._shouldGenerateSessionName())
+            return;
+        this._autoSessionNameAttempted = true;
+        const model = this.model;
+        const transcript = this._buildSessionNameTranscript();
+        if (!model || !transcript)
+            return;
+        try {
+            const stream = await this.agent.streamFn(model, {
+                systemPrompt: this.systemPrompt,
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: `${AUTO_SESSION_NAME_PROMPT}\n\n${transcript}` }],
+                        timestamp: Date.now(),
+                    },
+                ],
+                tools: this.agent.state.tools,
+            }, {
+                maxTokens: 32,
+                reasoning: undefined,
+                sessionId: this.sessionId,
+                transport: this.agent.transport,
+                thinkingBudgets: this.agent.thinkingBudgets,
+                maxRetryDelayMs: this.agent.maxRetryDelayMs,
+            });
+            for await (const _event of stream) {
+                // Drain the title stream without surfacing it as a chat message.
+            }
+            const response = await stream.result();
+            if (response.stopReason === "error" || response.stopReason === "aborted")
+                return;
+            const title = sanitizeGeneratedSessionName(messageTextContent(response));
+            if (title)
+                this.setSessionName(title);
+        }
+        catch {
+            // Session naming is a post-turn convenience; the completed assistant turn stays authoritative.
+        }
+    }
     async _handlePostAgentRun() {
         const msg = this._lastAssistantMessage;
         this._lastAssistantMessage = undefined;
@@ -1636,7 +1887,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 +1923,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 +2064,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 +2459,11 @@ 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;
+        const piServerPhase = getPiServerFailurePhase(message);
+        if (piServerPhase && piServerPhase !== "provider_stream")
+            return false;
         if (message.errorMessage && this._isNonRetryableProviderLimitError(message.errorMessage))
             return false;
         return isRetryableAssistantError(message);
@@ -2187,6 +2501,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 {