@ponythewhite/base-context 1.0.13 → 1.0.15

package/dist/core/agent-session.js

@@ -12,7 +12,7 @@ import { sleep } from "../utils/sleep.js";
 import { AGENT_MESSAGE_CUSTOM_TYPE, AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL, AGENT_MESSAGE_SKILL_NAME, assertAgentMessageQueueCapacity, assertAgentSessionNameAvailable, assertDirectAgentMessageTarget, createAgentMessageHostHandlers, DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION, formatAgentSessionNameUnavailable, isAgentSessionMessage, isAgentSessionMessagePrompt, normalizeAgentSessionMessage, parseAgentSessionMessagePromptId, startsAgentRun, } from "./agent-messages.js";
 import { AGENT_OBSERVE_SKILL_NAME, createAgentObserveHostHandlers, normalizeObserveLimit, normalizeObserveMaxChars, ORCHESTRATION_HEARTBEAT_SKILL_NAME, } from "./agent-observe.js";
 import { addLoginGuidanceToAuthError, formatAuthenticationFailedMessage, formatNoApiKeyFoundMessage, formatNoModelSelectedMessage, isLikelyAuthenticationError, } from "./auth-guidance.js";
-import { addAutonomousContinuation, addAutonomousUsage, autonomousStatus, createAutonomousRuntimeState, nextAutonomousContinuation, refreshAutonomousQualityGates, setAutonomousEnabled, } from "./autonomous.js";
+import { addAutonomousContinuation, addAutonomousUsage, autonomousRunLimitReason, autonomousStatus, createAutonomousRuntimeState, nextAutonomousContinuation, refreshAutonomousQualityGates, setAutonomousEnabled, } from "./autonomous.js";
 import { executeBashWithOperations } from "./bash-executor.js";
 import { stringifyBoundedJson } from "./bounded-json.js";
 import { CanonicalContextCompiler, canonicalRecoveryBoundary, getCanonicalEpochContext, getCanonicalMessageSource, getCanonicalViewSelectionSource, getCanonicalViewUnits, MissingRecoveryReplayContractError, prepareCanonicalEpoch, prepareContextModeEpoch, prepareRecoveryCompaction, readCanonicalContextMode, } from "./canonical-context.js";
@@ -2345,6 +2345,9 @@ export class AgentSession {
             "proceed");
     }
     async _getTurnOutcome(context, signal) {
+        // Usage is recorded by message_end. Join it before admitting another native tool turn.
+        if (this._autonomousState.enabled)
+            await this._agentEventQueue;
         const sourceOwner = signal ? this._invocationCompactionOwner : this._captureCompactionOwner();
         if (!sourceOwner ||
             signal?.aborted ||
@@ -2371,6 +2374,8 @@ export class AgentSession {
                 return { kind: "finish" };
             if (!current())
                 return { kind: "cancelled" };
+            if (this._autonomousState.enabled && autonomousRunLimitReason(this._autonomousState))
+                return { kind: "finish" };
             try {
                 if (await this._accountGoalUsageForAssistantMessage(context.message, goalOwner)) {
                     this._assertGoalContinuationOwner(goalOwner);
@@ -3212,14 +3217,14 @@ export class AgentSession {
                 this._assertCompactionOwner(owner);
                 const compaction = owner.manager.bindCompactionSink();
                 const captured = owner.requests.capture(compaction);
-                let branch;
                 let preparation;
+                let leafKind;
                 try {
-                    branch = await compaction.readBranch();
-                    this._assertCompactionOwner(owner);
-                    preparation = this.isStreaming
-                        ? (await this._prepareCapturedCompaction(branch, settings, captured, compaction, owner)).preparation
-                        : undefined;
+                    if (this.isStreaming) {
+                        const prepared = await this._prepareCapturedCompaction(settings, captured, compaction, owner);
+                        preparation = prepared.preparation;
+                        leafKind = prepared.leafKind;
+                    }
                 }
                 catch (error) {
                     try {
@@ -3240,10 +3245,9 @@ export class AgentSession {
                         reason: "no active turn; compaction can only be requested while a turn is running",
                     };
                 if (!preparation) {
-                    const lastEntry = branch.at(-1);
                     return {
                         scheduled: false,
-                        reason: lastEntry?.type === "compaction" ? "already compacted" : "session is too short to compact",
+                        reason: leafKind === "compaction" ? "already compacted" : "session is too short to compact",
                     };
                 }
                 this._assertContextOptimizationAllowed();
@@ -6487,10 +6491,13 @@ export class AgentSession {
                         actionId: action.id,
                         submittedText: input.submitted?.text,
                     };
+                    const clearedGoal = Boolean(this._goalState.objective) && this._parseGoalSlashCommand(input.text)?.kind === "clear";
                     await this._handleGoalSlashCommand(input.text, input.images, goalOrigin);
                     resultText = this._goalState.objective
                         ? `Goal ${this._goalState.status}: ${this._goalState.objective}`
-                        : "No active goal.";
+                        : clearedGoal
+                            ? "Goal cleared."
+                            : "No active goal.";
                     break;
                 }
                 case "autonomous":
@@ -7781,14 +7788,12 @@ export class AgentSession {
             const semanticEdges = owner.semanticEdges;
             compaction = owner.manager.bindCompactionSink();
             requests = owner.requests.capture(compaction);
-            const pathEntries = await compaction.readBranch();
             this._assertCompactionOwner(owner);
             const { apiKey, headers } = await this._getRequiredRequestAuth(model);
             this._assertCompactionOwner(owner);
             committed = await this._performCompaction({
                 model,
                 thinkingLevel,
-                pathEntries,
                 settings,
                 requests,
                 compaction,
@@ -7882,33 +7887,47 @@ export class AgentSession {
         }
     }
     /** A private compiled context keeps extension summary edits separate from retained source recipes. */
-    async _prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
+    async _prepareCapturedCompaction(settings, requests, compaction, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, capacity) {
         this._assertCompactionOwner(owner);
         const limits = this.settingsManager.getCanonicalContextLimits();
         const resource = this._captureKernelResource();
         const source = await compaction.source;
         this._assertCompactionOwner(owner);
-        if (!source.persistent)
+        if (!source.persistent) {
+            const pathEntries = await compaction.readBranch();
+            this._assertCompactionOwner(owner);
             return {
                 preparation: prepareCompaction(pathEntries, settings, allowShortSession),
+                pathEntries,
+                leafKind: pathEntries.at(-1)?.type,
                 maxSourceBytes: limits.maxSourceBytes,
             };
+        }
         return requests.readHistory(async (view) => {
             const messages = await new CanonicalContextCompiler().compile(view, limits, undefined, {}, resource, this._initialContextMode, false, "read");
             this._assertCompactionOwner(owner);
             const context = getCanonicalEpochContext(messages);
-            if (context.checkpoint?.includeSummary && pathEntries.at(-1)?.type === "compaction")
-                return { preparation: undefined, maxSourceBytes: limits.maxSourceBytes };
+            const entryIds = context.references.map((ref) => ref?.ref.entryId);
+            const selected = await compaction.readCompactionEntries(entryIds.filter((id) => id !== undefined));
+            this._assertCompactionOwner(owner);
+            const pathEntries = selected.entries;
+            if (context.checkpoint?.includeSummary && selected.leafKind === "compaction")
+                return {
+                    preparation: undefined,
+                    pathEntries,
+                    leafKind: selected.leafKind,
+                    maxSourceBytes: limits.maxSourceBytes,
+                };
             const authorization = getRecoveryCompactionAuthorization(capacity);
             const boundary = canonicalRecoveryBoundary(messages, authorization);
-            const preparation = budgetPressure || context.checkpoint || boundary
-                ? prepareViewCompaction(messages, context.references.map((ref) => ref?.ref.entryId), pathEntries, settings, boundary, allowShortSession, budgetPressure)
-                : prepareCompaction(pathEntries, settings, allowShortSession);
+            const preparation = prepareViewCompaction(messages, entryIds, pathEntries, settings, boundary, allowShortSession, budgetPressure, selected.suffixAnchors);
             // Refuse unsupported public data or open groups before starting the summary model call.
             if (preparation)
                 prepareRecoveryCompaction(messages, preparation.firstKeptEntryId, limits.maxSourceBytes, authorization);
             return {
                 preparation,
+                pathEntries,
+                leafKind: selected.leafKind,
                 messages,
                 resource: context.resourceRevision !== undefined ? resource : undefined,
                 maxSourceBytes: limits.maxSourceBytes,
@@ -7921,15 +7940,15 @@ export class AgentSession {
      * Error("Compaction cancelled") on abort or extension cancel.
      */
     async _performCompaction(options) {
-        const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, pathEntries, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, } = options;
-        const prepared = await this._prepareCapturedCompaction(pathEntries, settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
+        const { model, apiKey, headers, customInstructions, signal, thinkingLevel, requests, compaction, semanticEdges, settings, owner = this._captureCompactionOwner(), allowShortSession = false, budgetPressure = false, } = options;
+        const prepared = await this._prepareCapturedCompaction(settings, requests, compaction, owner, allowShortSession, budgetPressure, options.capacity);
         this._assertCompactionOwner(owner);
         if (prepared.resource)
             assertResourceCurrent(prepared.resource);
         const preparation = prepared.preparation;
+        const pathEntries = prepared.pathEntries;
         if (!preparation) {
-            const lastEntry = pathEntries[pathEntries.length - 1];
-            if (lastEntry?.type === "compaction") {
+            if (prepared.leafKind === "compaction") {
                 throw new CompactionSkippedError("Already compacted");
             }
             throw new CompactionSkippedError("Session is too short to compact — try again once it grows");
@@ -9361,7 +9380,6 @@ export class AgentSession {
             const semanticEdges = owner.semanticEdges;
             compaction = owner.manager.bindCompactionSink();
             requests = owner.requests.capture(compaction);
-            const pathEntries = await compaction.readBranch();
             this._assertCompactionOwner(owner);
             const authResult = model ? await this._modelRegistry.getApiKeyAndHeaders(model) : undefined;
             this._assertCompactionOwner(owner);
@@ -9380,7 +9398,6 @@ export class AgentSession {
             committed = await this._performCompaction({
                 model,
                 thinkingLevel,
-                pathEntries,
                 settings,
                 requests,
                 compaction,