open-multi-agent-kit 0.98.1 → 0.98.2

package/dist/core/agent-session.js

@@ -31,6 +31,7 @@ import { parseBangInvocation } from "./bang-skill-invocation.js";
 import { getCompactionHeadroomThreshold } from "./compaction/compaction.js";
 import { createCompactionHysteresisConfig, createCompactionHysteresisState, stepCompactionHysteresis, } from "./compaction/hysteresis.js";
 import { calculateContextTokens, collectEntriesForBranchSummary, compact, estimateContextTokens, estimateProjectedContextTokens, generateBranchSummary, prepareCompaction, resolveCompactionModel, } from "./compaction/index.js";
+import { summarizeWithOAuthRecovery } from "./compaction/oauth-recovery.js";
 import { compactionEmitWillRetry } from "./compaction/resume-policy.js";
 import { isSessionModelOverflow, shouldSkipCompactionCheck } from "./compaction-gate.js";
 import { estimateToolResultReserve, } from "./context-budget-reserved-tokens.js";
@@ -55,6 +56,16 @@ const DISABLED_ENV_VALUES = new Set(["0", "false", "off", "disable", "disabled"]
 const MAX_OVERFLOW_RECOVERY_ATTEMPTS = 2;
 const OVERFLOW_RECOVERY_EMERGENCY_TOKENS = 4_096;
 const MAX_RESOURCE_OBSERVATION_JOURNALS = 32;
+/**
+ * Token headroom demanded before a compaction run.
+ *
+ * Compaction resolves auth once and then reuses that token for a summarization
+ * that can stream for minutes and be retried with backoff. A token accepted
+ * with only seconds of validity left comes back as a provider 401 mid-run
+ * ("authentication token is expired"), which reads as a compaction failure.
+ * Refreshing up front is cheap; failing a long compaction is not.
+ */
+const COMPACTION_MIN_TOKEN_VALIDITY_MS = 10 * 60 * 1000;
 function isDisabledEnvValue(value) {
     return value !== undefined && DISABLED_ENV_VALUES.has(value.trim().toLowerCase());
 }
@@ -712,8 +723,8 @@ export class AgentSession {
     _getBashSandboxPreflight(override) {
         return this._bashRuntime.sandboxPreflight(override);
     }
-    async _getRequiredRequestAuth(model) {
-        const result = await this._modelRegistry.getApiKeyAndHeaders(model);
+    async _getRequiredRequestAuth(model, options) {
+        const result = await this._modelRegistry.getApiKeyAndHeaders(model, options);
         if (!result.ok) {
             if (result.error.startsWith("No API key found")) {
                 throw new Error(formatNoApiKeyFoundMessage(model.provider));
@@ -732,10 +743,11 @@ export class AgentSession {
         throw new Error(formatNoApiKeyFoundMessage(model.provider));
     }
     async _getCompactionRequestAuth(model) {
+        const options = { minRemainingMs: COMPACTION_MIN_TOKEN_VALIDITY_MS };
         if (isBuiltinStreamFn(this.agent.streamFn)) {
-            return this._getRequiredRequestAuth(model);
+            return this._getRequiredRequestAuth(model, options);
         }
-        const result = await this._modelRegistry.getApiKeyAndHeaders(model);
+        const result = await this._modelRegistry.getApiKeyAndHeaders(model, options);
         return result.ok ? { apiKey: result.apiKey, headers: result.headers } : {};
     }
     /**
@@ -2814,6 +2826,21 @@ export class AgentSession {
      * Used when the primary model's quota is exhausted (same-model retry is
      * useless until reset; another provider can still save the compaction).
      */
+    /**
+     * Summarize for manual and automatic compaction alike. If the provider
+     * rejects the OAuth token as expired despite a still-future stored expiry
+     * (ChatGPT `401 token_expired`), the credential is force-refreshed once and
+     * the summarization retried; the retry classifier rightly never replays a 401.
+     */
+    _summarizeCompaction(input) {
+        const { model } = input;
+        return summarizeWithOAuthRecovery({
+            apiKey: input.apiKey,
+            provider: model.provider,
+            refreshRejectedToken: (rejected) => this._modelRegistry.refreshRejectedOAuthToken(model, rejected),
+            run: (requestApiKey) => compact(input.preparation, model, requestApiKey, input.headers, input.customInstructions, input.signal, this.thinkingLevel, this.agent.streamFn, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: input.reason }), this._compactionFailoverModels(model)),
+        });
+    }
     _compactionFailoverModels(primary) {
         const candidates = resolveFailoverCandidates(this.settingsManager.getProviderResilienceSettings());
         const available = this._modelRegistry.getAvailable();
@@ -2838,11 +2865,14 @@ export class AgentSession {
         this._compactionAbortController = new AbortController();
         this._emit({ type: "compaction_start", reason: "manual" });
         let committedCompaction = false;
+        // Hoisted so a failure is attributed to the model that actually summarized,
+        // which `compaction.model` may make different from the session model.
+        let compactionModel;
         try {
             if (!this.model) {
                 throw new Error(formatNoModelSelectedMessage());
             }
-            const compactionModel = this._resolveCompactionModel(this.model);
+            compactionModel = this._resolveCompactionModel(this.model);
             const { apiKey, headers } = await this._getCompactionRequestAuth(compactionModel);
             const settings = this.settingsManager.getCompactionSettings();
             const begun = this._beginCompactionTransaction(compactionModel, false);
@@ -2886,8 +2916,15 @@ export class AgentSession {
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const result = await compact(preparation, compactionModel, apiKey, headers, customInstructions, this._compactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason: "manual" }), this._compactionFailoverModels(compactionModel));
+                const result = await this._summarizeCompaction({
+                    preparation,
+                    model: compactionModel,
+                    apiKey,
+                    headers,
+                    customInstructions,
+                    signal: this._compactionAbortController.signal,
+                    reason: "manual",
+                });
                 summary = result.summary;
                 firstKeptEntryId = result.firstKeptEntryId;
                 tokensBefore = result.tokensBefore;
@@ -2941,7 +2978,11 @@ export class AgentSession {
                 message: terminationMessage(message, "Manual compaction failed."),
                 cause: { area: "compaction", code: compactionCode },
                 sideEffects: committedCompaction ? "confirmed" : "none",
-                ...(this.model ? { provider: this.model.provider, model: this.model.id } : {}),
+                ...(compactionModel
+                    ? { provider: compactionModel.provider, model: compactionModel.id }
+                    : this.model
+                        ? { provider: this.model.provider, model: this.model.id }
+                        : {}),
             }));
             this._emit({
                 type: "compaction_end",
@@ -3134,6 +3175,8 @@ export class AgentSession {
             : configuredSettings;
         this._emit({ type: "compaction_start", reason });
         this._autoCompactionAbortController = new AbortController();
+        // Hoisted so the failure message names the model that actually summarized.
+        let compactionModel;
         try {
             if (!this.model) {
                 this._emit({
@@ -3145,11 +3188,13 @@ export class AgentSession {
                 });
                 return false;
             }
-            const compactionModel = this._resolveCompactionModel(this.model);
+            compactionModel = this._resolveCompactionModel(this.model);
             let apiKey;
             let headers;
             if (isBuiltinStreamFn(this.agent.streamFn)) {
-                const authResult = await this._modelRegistry.getApiKeyAndHeaders(compactionModel);
+                const authResult = await this._modelRegistry.getApiKeyAndHeaders(compactionModel, {
+                    minRemainingMs: COMPACTION_MIN_TOKEN_VALIDITY_MS,
+                });
                 if (!authResult.ok || !authResult.apiKey) {
                     const providerLabel = compactionModel.provider;
                     this._emit({
@@ -3219,8 +3264,14 @@ export class AgentSession {
                 details = extensionCompaction.details;
             }
             else {
-                // Generate compaction result
-                const compactResult = await compact(preparation, compactionModel, apiKey, headers, undefined, this._autoCompactionAbortController.signal, this.thinkingLevel, this.agent.streamFn, this.settingsManager.getRetrySettings(), this._summarizationRetryCallbacks({ source: "compaction", reason }), this._compactionFailoverModels(compactionModel));
+                const compactResult = await this._summarizeCompaction({
+                    preparation,
+                    model: compactionModel,
+                    apiKey,
+                    headers,
+                    signal: this._autoCompactionAbortController.signal,
+                    reason,
+                });
                 summary = compactResult.summary;
                 firstKeptEntryId = compactResult.firstKeptEntryId;
                 tokensBefore = compactResult.tokensBefore;
@@ -3288,6 +3339,7 @@ export class AgentSession {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            const modelLabel = compactionModel ? ` (${compactionModel.provider}/${compactionModel.id})` : "";
             this._emit({
                 type: "compaction_end",
                 reason,
@@ -3295,8 +3347,8 @@ export class AgentSession {
                 aborted: false,
                 willRetry: false,
                 errorMessage: reason === "overflow"
-                    ? `Context overflow recovery failed: ${errorMessage}`
-                    : `Auto-compaction failed: ${errorMessage}`,
+                    ? `Context overflow recovery failed${modelLabel}: ${errorMessage}`
+                    : `Auto-compaction failed${modelLabel}: ${errorMessage}`,
             });
             return false;
         }