const DEFAULT_QUERY_MODE = "recent" as const;

const DEFAULT_QMD_SEARCH_MODE = "search" as const;

const DEFAULT_TRANSCRIPT_DIR = "active-memory";

const DEFAULT_CIRCUIT_BREAKER_MAX_TIMEOUTS = 3;

const DEFAULT_CIRCUIT_BREAKER_COOLDOWN_MS = 60_000;

const TOGGLE_STATE_FILE = "session-toggles.json";

const DEFAULT_PARTIAL_TRANSCRIPT_MAX_CHARS = 32_000;

const DEFAULT_TRANSCRIPT_READ_MAX_LINES = 2_000;

recentAssistantChars?: number;

logging?: boolean;

cacheTtlMs?: number;

circuitBreakerMaxTimeouts?: number;

circuitBreakerCooldownMs?: number;

persistTranscripts?: boolean;

transcriptDir?: string;

qmd?: {

recentAssistantChars: number;

logging: boolean;

cacheTtlMs: number;

circuitBreakerMaxTimeouts: number;

circuitBreakerCooldownMs: number;

persistTranscripts: boolean;

transcriptDir: string;

qmd: {

const activeRecallCache = new Map<string, CachedActiveRecallResult>();

type CircuitBreakerEntry = {

consecutiveTimeouts: number;

lastTimeoutAt: number;

};

const timeoutCircuitBreaker = new Map<string, CircuitBreakerEntry>();

function buildCircuitBreakerKey(agentId: string, provider?: string, model?: string): string {

return `${agentId}:${provider ?? "unknown"}/${model ?? "unknown"}`;

}

function isCircuitBreakerOpen(key: string, maxTimeouts: number, cooldownMs: number): boolean {

const entry = timeoutCircuitBreaker.get(key);

if (!entry || entry.consecutiveTimeouts < maxTimeouts) {

return false;

}

if (Date.now() - entry.lastTimeoutAt >= cooldownMs) {

// Cooldown expired — reset and allow one attempt through.

timeoutCircuitBreaker.delete(key);

return false;

}

return true;

}

function recordCircuitBreakerTimeout(key: string): void {

const entry = timeoutCircuitBreaker.get(key);

if (entry) {

entry.consecutiveTimeouts++;

entry.lastTimeoutAt = Date.now();

} else {

timeoutCircuitBreaker.set(key, { consecutiveTimeouts: 1, lastTimeoutAt: Date.now() });

}

}

function resetCircuitBreaker(key: string): void {

timeoutCircuitBreaker.delete(key);

}

function parseOptionalPositiveInt(value: unknown, fallback: number): number {

const parsed =

typeof value === "number"

),

logging: raw.logging === true,

cacheTtlMs: clampInt(raw.cacheTtlMs, DEFAULT_CACHE_TTL_MS, 1000, 120_000),

circuitBreakerMaxTimeouts: clampInt(

raw.circuitBreakerMaxTimeouts,

DEFAULT_CIRCUIT_BREAKER_MAX_TIMEOUTS,

1,

20,

),

circuitBreakerCooldownMs: clampInt(

raw.circuitBreakerCooldownMs,

DEFAULT_CIRCUIT_BREAKER_COOLDOWN_MS,

5000,

600_000,

),

persistTranscripts: raw.persistTranscripts === true,

transcriptDir: normalizeTranscriptDir(raw.transcriptDir),

qmd: {

return cached;

}

// Circuit breaker: skip recall when the same agent/model has timed out

// too many times in a row (#74054).

const cbKey = buildCircuitBreakerKey(

params.agentId,

resolvedModelRef?.provider,

resolvedModelRef?.model,

);

if (

isCircuitBreakerOpen(

cbKey,

params.config.circuitBreakerMaxTimeouts,

params.config.circuitBreakerCooldownMs,

)

) {

const result: ActiveRecallResult = {

status: "timeout",

elapsedMs: 0,

summary: null,

};

if (params.config.logging) {

params.api.logger.info?.(

`${logPrefix} skipped (circuit breaker open after consecutive timeouts)`,

);

}

await persistPluginStatusLines({

api: params.api,

agentId: params.agentId,

sessionKey: params.sessionKey,

statusLine: `${buildPluginStatusLine({ result, config: params.config })} circuit-breaker`,

});

return result;

}

if (params.config.logging) {

params.api.logger.info?.(

`${logPrefix} start timeoutMs=${String(params.config.timeoutMs)} queryChars=${String(params.query.length)}`,

debugSummary: buildPersistedDebugSummary(result),

searchDebug: result.searchDebug,

});

recordCircuitBreakerTimeout(cbKey);

return result;

}

if (shouldCacheResult(result)) {

setCachedResult(cacheKey, result, params.config.cacheTtlMs);

}

resetCircuitBreaker(cbKey);

return result;

} catch (error) {

if (controller.signal.aborted) {

debugSummary: buildPersistedDebugSummary(result),

searchDebug: result.searchDebug,

});

recordCircuitBreakerTimeout(cbKey);

return result;

}

const message = toSingleLineLogValue(error instanceof Error ? error.message : String(error));

export const __testing = {

buildCacheKey,

buildCircuitBreakerKey,

buildMetadata,

buildPluginStatusLine,

buildPromptPrefix,

getCachedResult,

isCircuitBreakerOpen,

normalizePluginConfig,

readActiveMemorySearchDebug,

readPartialAssistantText,

shouldCacheResult,

resetActiveRecallCacheForTests() {

activeRecallCache.clear();

timeoutCircuitBreaker.clear();

lastActiveRecallCacheSweepAt = 0;

minimumTimeoutMs = DEFAULT_MIN_TIMEOUT_MS;

setupGraceTimeoutMs = DEFAULT_SETUP_GRACE_TIMEOUT_MS;

setupGraceTimeoutMs = Math.max(0, Math.floor(value));

},

setCachedResult,

getCircuitBreakerEntry(key: string) {

return timeoutCircuitBreaker.get(key);

},

};