@caupulican/pi-adaptative 0.75.5 → 0.75.7

package/dist/core/agent-session.js

@@ -131,6 +131,8 @@ export class AgentSession {
         // (session persistence, extensions, auto-compaction, retry logic)
         this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
         this._installAgentToolHooks();
+        this._installAgentContextTransform();
+        this._installAgentTurnRefresh();
         this._buildRuntime({
             activeToolNames: this._initialActiveToolNames,
             includeAllExtensionTools: true,
@@ -174,6 +176,74 @@ export class AgentSession {
      * registered tool execution to the extension context. Tool call and tool result interception now
      * happens here instead of in wrappers.
      */
+    _installAgentContextTransform() {
+        const previousTransformContext = this.agent.transformContext?.bind(this.agent);
+        this.agent.transformContext = async (messages, signal) => {
+            const transformed = previousTransformContext ? await previousTransformContext(messages, signal) : messages;
+            const authoritativeMessages = this.agent.state.messages.length > 0 ? this.agent.state.messages : transformed;
+            try {
+                const settings = this.settingsManager.getCompactionSettings();
+                const contextWindow = this.model?.contextWindow ?? 0;
+                if (!settings.enabled || contextWindow <= 0 || this.isCompacting) {
+                    return authoritativeMessages;
+                }
+                const contextTokens = this._estimateCurrentContextTokens(authoritativeMessages);
+                if (!shouldCompact(contextTokens, contextWindow, settings)) {
+                    return authoritativeMessages;
+                }
+                const latestBefore = getLatestCompactionEntry(this.sessionManager.getBranch())?.id;
+                await this._runAutoCompaction("threshold", false);
+                const latestAfter = getLatestCompactionEntry(this.sessionManager.getBranch())?.id;
+                return latestAfter && latestAfter !== latestBefore
+                    ? this.agent.state.messages.slice()
+                    : authoritativeMessages;
+            }
+            catch {
+                return authoritativeMessages;
+            }
+        };
+    }
+    _installAgentTurnRefresh() {
+        const previousPrepareNextTurn = this.agent.prepareNextTurn?.bind(this.agent);
+        this.agent.prepareNextTurn = async (signal) => {
+            const previous = previousPrepareNextTurn ? await previousPrepareNextTurn(signal) : undefined;
+            const snapshot = this._createAgentContextSnapshot();
+            return {
+                ...previous,
+                context: {
+                    ...(previous?.context ?? snapshot),
+                    systemPrompt: snapshot.systemPrompt,
+                    tools: snapshot.tools,
+                },
+                model: previous?.model ?? this.agent.state.model,
+                thinkingLevel: previous?.thinkingLevel ?? this.agent.state.thinkingLevel,
+            };
+        };
+    }
+    _createAgentContextSnapshot() {
+        return {
+            systemPrompt: this.agent.state.systemPrompt,
+            messages: this.agent.state.messages.slice(),
+            tools: this.agent.state.tools.slice(),
+        };
+    }
+    _estimateCurrentContextTokens(messages) {
+        const estimate = estimateContextTokens(messages);
+        const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
+        if (estimate.lastUsageIndex === null || !compactionEntry) {
+            return estimate.tokens;
+        }
+        const usageMessage = messages[estimate.lastUsageIndex];
+        if (usageMessage?.role !== "assistant") {
+            return estimate.tokens;
+        }
+        const usageTimestamp = usageMessage.timestamp;
+        const compactionTimestamp = new Date(compactionEntry.timestamp).getTime();
+        if (usageTimestamp <= compactionTimestamp) {
+            return estimate.trailingTokens;
+        }
+        return estimate.tokens;
+    }
     _installAgentToolHooks() {
         this.agent.beforeToolCall = async ({ toolCall, args }) => {
             const runner = this._extensionRunner;
@@ -1478,6 +1548,16 @@ export class AgentSession {
         }
         else {
             contextTokens = calculateContextTokens(assistantMessage.usage);
+            const estimate = estimateContextTokens(this.agent.state.messages);
+            if (estimate.lastUsageIndex !== null) {
+                const usageMsg = this.agent.state.messages[estimate.lastUsageIndex];
+                const usageIsPostCompaction = !(compactionEntry &&
+                    usageMsg.role === "assistant" &&
+                    usageMsg.timestamp <= new Date(compactionEntry.timestamp).getTime());
+                if (usageIsPostCompaction) {
+                    contextTokens = Math.max(contextTokens, estimate.tokens);
+                }
+            }
         }
         if (shouldCompact(contextTokens, contextWindow, settings)) {
             return await this._runAutoCompaction("threshold", false);
@@ -1822,12 +1902,9 @@ export class AgentSession {
                 })();
             },
             reload: () => {
-                if (this.isStreaming) {
-                    throw new Error("Cannot reload while the agent is streaming.");
-                }
                 const actions = this._extensionCommandContextActions;
-                if (!actions) {
-                    throw new Error("Reload is unavailable before extension command context is bound.");
+                if (this.isStreaming || !actions) {
+                    return this.reload();
                 }
                 return actions.reload();
             },