@schlenkr/ragents 0.1.6 → 0.1.8

package/packages/agent/src/core/agent-session.ts

@@ -1,1108 +0,0 @@
-/** One agent: model and thinking level, prompts, persistence, auto-compaction and retry, extension hooks and tools. */
-
-import type {
-	Agent,
-	AgentEvent,
-	AgentMessage,
-	AgentTool,
-	PrepareNextTurnContext,
-	ThinkingLevel,
-} from "../loop/index.ts";
-import type { AssistantMessage, AuthResult, Model, ProviderHeaders, UserAttachment, UserContent } from "@ragents/ai";
-import {
-	clampThinkingLevel,
-	getSupportedThinkingLevels,
-	isContextOverflow,
-	isRetryableAssistantError,
-	streamSimple,
-} from "@ragents/ai";
-import { sleep } from "../utils/sleep.ts";
-import { formatNoApiKeyFoundMessage, formatNoModelSelectedMessage } from "./auth-guidance.ts";
-import { DEFAULT_THINKING_LEVEL } from "./defaults.ts";
-import {
-	type CompactionResult,
-	calculateContextTokens,
-	compact,
-	estimateContextTokens,
-	estimateTokens,
-	prepareCompaction,
-	shouldCompact,
-} from "./compaction/index.ts";
-import {
-	type ExtensionErrorListener,
-	ExtensionRunner,
-	type ToolDefinition,
-	type ToolInfo,
-	wrapRegisteredTools,
-} from "./extensions/index.ts";
-import type { ModelRuntime } from "./model-runtime.ts";
-import type { ResourceLoader } from "./resource-loader.ts";
-import type { SessionManager } from "./session-manager.ts";
-import { getLatestCompactionEntry } from "./session-manager.ts";
-import type { AgentSettings } from "./agent-settings.ts";
-import { createSyntheticSourceInfo, type SourceInfo } from "./source-info.ts";
-import { type BuildSystemPromptOptions, buildSystemPrompt } from "./system-prompt.ts";
-
-/** Session-specific events that extend the core AgentEvent */
-export type AgentSessionEvent =
-	| Exclude<AgentEvent, { type: "agent_end" }>
-	| {
-			type: "agent_end";
-			messages: AgentMessage[];
-			willRetry: boolean;
-	  }
-	| { type: "agent_settled" }
-	| { type: "compaction_start"; reason: "threshold" | "overflow" }
-	| { type: "thinking_level_changed"; level: ThinkingLevel }
-	| {
-			type: "compaction_end";
-			reason: "threshold" | "overflow";
-			result: CompactionResult | undefined;
-			aborted: boolean;
-			willRetry: boolean;
-			errorMessage?: string;
-	  }
-	| { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number; errorMessage: string }
-	| { type: "auto_retry_end"; success: boolean; attempt: number; finalError?: string };
-
-/** Listener function for agent session events */
-export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
-
-function withoutDeletedHeaders(headers: ProviderHeaders | undefined): Record<string, string> | undefined {
-	return headers
-		? Object.fromEntries(Object.entries(headers).filter((entry): entry is [string, string] => entry[1] !== null))
-		: undefined;
-}
-
-export interface AgentSessionConfig {
-	agent: Agent;
-	sessionManager: SessionManager;
-	settings: AgentSettings;
-	cwd: string;
-	/** Resource loader for extensions, skills and the system prompt */
-	resourceLoader: ResourceLoader;
-	/** SDK custom tools registered outside extensions */
-	customTools?: ToolDefinition[];
-	/** Canonical model/auth runtime. */
-	modelRuntime: ModelRuntime;
-	/** Optional allowlist of tool names. When provided, only these tool names are exposed. */
-	allowedToolNames?: string[];
-	/** Mutable ref used by Agent to access the current ExtensionRunner */
-	extensionRunnerRef?: { current?: ExtensionRunner };
-}
-
-export interface ExtensionBindings {
-	onError?: ExtensionErrorListener;
-}
-
-/** Options for AgentSession.prompt() */
-export interface PromptOptions {
-	attachments?: UserAttachment[];
-	/** Observes whether the prompt was accepted or rejected before the agent run starts. */
-	preflightResult?: (success: boolean) => void;
-}
-
-interface ToolDefinitionEntry {
-	definition: ToolDefinition;
-	sourceInfo: SourceInfo;
-}
-
-function estimateMessagesTokens(messages: AgentMessage[]): number {
-	let tokens = 0;
-	for (const message of messages) {
-		tokens += estimateTokens(message);
-	}
-	return tokens;
-}
-
-/** Standard thinking levels */
-const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high"];
-
-export class AgentSession {
-	readonly agent: Agent;
-	readonly sessionManager: SessionManager;
-	readonly settings: AgentSettings;
-
-	// Event subscription state
-	private _unsubscribeAgent?: () => void;
-	private _eventListeners: AgentSessionEventListener[] = [];
-	private _isAgentRunActive = false;
-	private _disposed = false;
-	private _idleWaitPromise: Promise<void> | undefined;
-	private _resolveIdleWait: (() => void) | undefined;
-
-	// Compaction state
-	private _autoCompactionAbortController: AbortController | undefined = undefined;
-	private _overflowRecoveryAttempted = false;
-
-	// Retry state
-	private _retryAbortController: AbortController | undefined = undefined;
-	private _retryAttempt = 0;
-
-	// Extension system
-	private _extensionRunner!: ExtensionRunner;
-
-	private _resourceLoader: ResourceLoader;
-	private _customTools: ToolDefinition[];
-	private _cwd: string;
-	private _extensionRunnerRef?: { current?: ExtensionRunner };
-	private _allowedToolNames?: Set<string>;
-	private _extensionErrorUnsubscriber?: () => void;
-
-	private _modelRuntime: ModelRuntime;
-
-	// Tool registry for extension getAllTools/setActiveTools
-	private _toolRegistry: Map<string, AgentTool> = new Map();
-	private _toolDefinitions: Map<string, ToolDefinitionEntry> = new Map();
-	private _toolPromptSnippets: Map<string, string> = new Map();
-	private _toolPromptGuidelines: Map<string, string[]> = new Map();
-
-	// Base system prompt (without per-run extension changes)
-	private _baseSystemPrompt = "";
-	private _baseSystemPromptOptions!: BuildSystemPromptOptions;
-	private _systemPromptOverride?: string;
-
-	constructor(config: AgentSessionConfig) {
-		this.agent = config.agent;
-		this.sessionManager = config.sessionManager;
-		this.settings = config.settings;
-		this._resourceLoader = config.resourceLoader;
-		this._customTools = config.customTools ?? [];
-		this._cwd = config.cwd;
-		this._modelRuntime = config.modelRuntime;
-		this._extensionRunnerRef = config.extensionRunnerRef;
-		this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
-
-		// Always subscribe to agent events for internal handling
-		// (session persistence, auto-compaction, retry logic)
-		this._unsubscribeAgent = this.agent.subscribe(this._handleAgentEvent);
-		this._installAgentToolHooks();
-		this._installAgentNextTurnRefresh();
-
-		this._buildRuntime();
-	}
-
-
-	private async _getRequiredRequestAuth(model: Model<any>): Promise<{
-		apiKey: string;
-		headers?: Record<string, string>;
-		env?: Record<string, string>;
-	}> {
-		let result: AuthResult | undefined;
-		try {
-			result = await this._modelRuntime.getAuth(model);
-		} catch (error) {
-			const cause = error instanceof Error ? error.cause : undefined;
-			if (cause instanceof Error && cause.message === "authHeader requires a resolved API key") {
-				throw new Error(formatNoApiKeyFoundMessage(model.provider));
-			}
-			throw error;
-		}
-		if (result?.auth.apiKey) {
-			return {
-				apiKey: result.auth.apiKey,
-				headers: withoutDeletedHeaders(result.auth.headers),
-				env: result.env,
-			};
-		}
-
-		throw new Error(formatNoApiKeyFoundMessage(model.provider));
-	}
-
-	private async _getSummarizationRequestAuth(model: Model<any>): Promise<{
-		apiKey?: string;
-		headers?: Record<string, string>;
-		env?: Record<string, string>;
-	}> {
-		if (this.agent.streamFn === streamSimple) {
-			return this._getRequiredRequestAuth(model);
-		}
-
-		try {
-			const result = await this._modelRuntime.getAuth(model);
-			return result
-				? { apiKey: result.auth.apiKey, headers: withoutDeletedHeaders(result.auth.headers), env: result.env }
-				: {};
-		} catch {
-			return {};
-		}
-	}
-
-	/** The tool result hook reads `this._extensionRunner` at execution time. */
-	private _installAgentToolHooks(): void {
-		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 as Record<string, unknown>,
-				content: result.content,
-				details: result.details,
-				isError,
-			});
-
-			if (!hookResult) {
-				return undefined;
-			}
-
-			return {
-				content: hookResult.content,
-				details: hookResult.details,
-				isError: hookResult.isError ?? isError,
-			};
-		};
-	}
-
-	private _installAgentNextTurnRefresh(): void {
-		const previousPrepareNextTurnWithContext =
-			this.agent.prepareNextTurnWithContext ??
-			(this.agent.prepareNextTurn
-				? async (_turn: PrepareNextTurnContext, signal?: AbortSignal) => await this.agent.prepareNextTurn?.(signal)
-				: undefined);
-		this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-			const previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal);
-			const previousContext = previousSnapshot?.context ?? turn.context;
-
-			return {
-				...previousSnapshot,
-				context: {
-					...previousContext,
-					systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
-					tools: this.agent.state.tools.slice(),
-				},
-				model: this.agent.state.model,
-				thinkingLevel: this.agent.state.thinkingLevel,
-			};
-		};
-	}
-
-	/** Emit an event to all listeners */
-	private _emit(event: AgentSessionEvent): void {
-		for (const l of this._eventListeners) {
-			l(event);
-		}
-	}
-
-	private _getIdleWaitPromise(): Promise<void> {
-		if (!this._idleWaitPromise) {
-			this._idleWaitPromise = new Promise((resolve) => {
-				this._resolveIdleWait = resolve;
-			});
-		}
-		return this._idleWaitPromise;
-	}
-
-	private _resolveIdleWaitIfIdle(): void {
-		if (this._isAgentRunActive || !this._resolveIdleWait) {
-			return;
-		}
-		const resolve = this._resolveIdleWait;
-		this._idleWaitPromise = undefined;
-		this._resolveIdleWait = undefined;
-		resolve();
-	}
-
-	private _emitAgentSettled(): void {
-		this._isAgentRunActive = false;
-		try {
-			this._emit({ type: "agent_settled" });
-		} finally {
-			this._resolveIdleWaitIfIdle();
-		}
-	}
-
-	private _lastAssistantMessage: AssistantMessage | undefined = undefined;
-
-	/** Internal handler for agent events - shared by subscribe and reconnect */
-	private _handleAgentEvent = async (event: AgentEvent): Promise<void> => {
-		if (event.type === "message_start" && event.message.role === "user") {
-			this._overflowRecoveryAttempted = false;
-		}
-
-		// Notify all listeners
-		this._emit(event.type === "agent_end" ? { ...event, willRetry: this._willRetryAfterAgentEnd(event) } : event);
-
-		// Handle session persistence
-		if (event.type === "message_end") {
-			if (event.message.role === "user" || event.message.role === "assistant" || event.message.role === "toolResult") {
-				this.sessionManager.appendMessage(event.message);
-			}
-			// Compaction summaries are persisted as compaction entries
-
-			// Track assistant message for auto-compaction (checked on agent_end)
-			if (event.message.role === "assistant") {
-				this._lastAssistantMessage = event.message;
-
-				const assistantMsg = event.message as AssistantMessage;
-				if (assistantMsg.stopReason !== "error") {
-					this._overflowRecoveryAttempted = false;
-				}
-
-				// Reset retry counter immediately on successful assistant response
-				// This prevents accumulation across multiple LLM calls within a turn
-				if (assistantMsg.stopReason !== "error" && this._retryAttempt > 0) {
-					this._emit({
-						type: "auto_retry_end",
-						success: true,
-						attempt: this._retryAttempt,
-					});
-					this._retryAttempt = 0;
-				}
-			}
-		}
-	};
-
-	private _willRetryAfterAgentEnd(event: Extract<AgentEvent, { type: "agent_end" }>): boolean {
-		const settings = this.settings.retry;
-		if (!settings.enabled || this._retryAttempt >= settings.maxRetries) {
-			return false;
-		}
-
-		for (let i = event.messages.length - 1; i >= 0; i--) {
-			const message = event.messages[i];
-			if (message.role === "assistant") {
-				return this._isRetryableError(message as AssistantMessage);
-			}
-		}
-		return false;
-	}
-
-	/** Find the last assistant message in agent state (including aborted ones) */
-	private _findLastAssistantMessage(): AssistantMessage | undefined {
-		const messages = this.agent.state.messages;
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const msg = messages[i];
-			if (msg.role === "assistant") {
-				return msg as AssistantMessage;
-			}
-		}
-		return undefined;
-	}
-
-	/**
-	 * Subscribe to agent events.
-	 * Session persistence is handled internally (saves messages on message_end).
-	 * Multiple listeners can be added. Returns unsubscribe function for this listener.
-	 */
-	subscribe(listener: AgentSessionEventListener): () => void {
-		this._eventListeners.push(listener);
-
-		// Return unsubscribe function for this specific listener
-		return () => {
-			const index = this._eventListeners.indexOf(listener);
-			if (index !== -1) {
-				this._eventListeners.splice(index, 1);
-			}
-		};
-	}
-
-	/**
-	 * Remove all listeners and disconnect from agent.
-	 * Call this when completely done with the session.
-	 */
-	dispose(): void {
-		if (this._disposed) return;
-		this._disposed = true;
-
-		try {
-			this.abortRetry();
-			this._autoCompactionAbortController?.abort();
-			this.agent.abort();
-		} catch {
-			// Dispose must succeed even if an abort hook throws.
-		}
-
-		this._extensionRunner.invalidate();
-		this._unsubscribeAgent?.();
-		this._unsubscribeAgent = undefined;
-		this._eventListeners = [];
-	}
-
-	waitForSettlement(): Promise<void> {
-		return this._resourceLoader.waitForSettlement?.() ?? Promise.resolve();
-	}
-
-	/** Current model (may be undefined if not yet selected) */
-	get model(): Model<any> | undefined {
-		return this.agent.state.model;
-	}
-
-	/** Current thinking level */
-	get thinkingLevel(): ThinkingLevel {
-		return this.agent.state.thinkingLevel;
-	}
-
-	/** Whether the session is currently processing an agent run or post-run continuation. */
-	get isStreaming(): boolean {
-		return this._isAgentRunActive;
-	}
-
-	/** Whether the session has no active agent run, retry, auto-compaction, or queued continuation. */
-	get isIdle(): boolean {
-		return !this._isAgentRunActive;
-	}
-
-	/** Replace the custom system prompt and rebuild the effective prompt for the next model call. */
-	setSystemPrompt(prompt: string): void {
-		this._resourceLoader.setSystemPrompt(prompt);
-		this._baseSystemPrompt = this._rebuildSystemPrompt(this.getActiveToolNames());
-		this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
-	}
-
-	/**
-	 * Get the names of currently active tools.
-	 * Returns the names of tools currently set on the agent.
-	 */
-	getActiveToolNames(): string[] {
-		return this.agent.state.tools.map((t) => t.name);
-	}
-
-	/**
-	 * Get all configured tools with name, description, parameter schema, prompt guidelines, and source metadata.
-	 */
-	getAllTools(): ToolInfo[] {
-		return Array.from(this._toolDefinitions.values()).map(({ definition, sourceInfo }) => ({
-			name: definition.name,
-			description: definition.description,
-			parameters: definition.parameters,
-			promptGuidelines: definition.promptGuidelines,
-			sourceInfo,
-		}));
-	}
-
-	/**
-	 * Set active tools by name.
-	 * Only tools in the registry can be enabled. Unknown tool names are ignored.
-	 * Also rebuilds the system prompt to reflect the new tool set.
-	 * Changes take effect on the next agent turn.
-	 */
-	setActiveToolsByName(toolNames: string[]): void {
-		const tools: AgentTool[] = [];
-		const validToolNames: string[] = [];
-		for (const name of toolNames) {
-			const tool = this._toolRegistry.get(name);
-			if (tool) {
-				tools.push(tool);
-				validToolNames.push(name);
-			}
-		}
-		this.agent.state.tools = tools;
-
-		// Rebuild base system prompt with new tool set
-		this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
-		this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
-	}
-
-	/** All messages including custom types */
-	get messages(): AgentMessage[] {
-		return this.agent.state.messages;
-	}
-
-	/** Current session file path, or undefined if sessions are disabled */
-	get sessionFile(): string | undefined {
-		return this.sessionManager.getSessionFile();
-	}
-
-	/** Current session ID */
-	get sessionId(): string {
-		return this.sessionManager.getSessionId();
-	}
-
-	private _normalizePromptSnippet(text: string | undefined): string | undefined {
-		if (!text) return undefined;
-		const oneLine = text
-			.replace(/[\r\n]+/g, " ")
-			.replace(/\s+/g, " ")
-			.trim();
-		return oneLine.length > 0 ? oneLine : undefined;
-	}
-
-	private _normalizePromptGuidelines(guidelines: string[] | undefined): string[] {
-		if (!guidelines || guidelines.length === 0) {
-			return [];
-		}
-
-		const unique = new Set<string>();
-		for (const guideline of guidelines) {
-			const normalized = guideline.trim();
-			if (normalized.length > 0) {
-				unique.add(normalized);
-			}
-		}
-		return Array.from(unique);
-	}
-
-	private _rebuildSystemPrompt(toolNames: string[]): string {
-		const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
-		const toolSnippets: Record<string, string> = {};
-		const promptGuidelines: string[] = [];
-		for (const name of validToolNames) {
-			const snippet = this._toolPromptSnippets.get(name);
-			if (snippet) {
-				toolSnippets[name] = snippet;
-			}
-
-			const toolGuidelines = this._toolPromptGuidelines.get(name);
-			if (toolGuidelines) {
-				promptGuidelines.push(...toolGuidelines);
-			}
-		}
-
-		this._baseSystemPromptOptions = {
-			cwd: this._cwd,
-			skills: this._resourceLoader.getSkills(),
-			customPrompt: this._resourceLoader.getSystemPrompt(),
-			selectedTools: validToolNames,
-			toolSnippets,
-			promptGuidelines,
-		};
-		return buildSystemPrompt(this._baseSystemPromptOptions);
-	}
-
-	private async _runAgentPrompt(messages: AgentMessage | AgentMessage[]): Promise<void> {
-		this._isAgentRunActive = true;
-		try {
-			await this.agent.prompt(messages);
-			while (await this._handlePostAgentRun()) {
-				await this.agent.continue();
-			}
-		} finally {
-			this._systemPromptOverride = undefined;
-			this._emitAgentSettled();
-		}
-	}
-
-	private async _handlePostAgentRun(): Promise<boolean> {
-		const msg = this._lastAssistantMessage;
-		this._lastAssistantMessage = undefined;
-		if (!msg) {
-			return false;
-		}
-
-		if (this._isRetryableError(msg) && (await this._prepareRetry(msg))) {
-			return true;
-		}
-
-		if (msg.stopReason === "error" && this._retryAttempt > 0) {
-			this._emit({
-				type: "auto_retry_end",
-				success: false,
-				attempt: this._retryAttempt,
-				finalError: msg.errorMessage,
-			});
-			this._retryAttempt = 0;
-		}
-
-		return await this._checkCompaction(msg);
-	}
-
-	/** Run a prompt; while the agent runs, or without model or key, it throws. */
-	async prompt(text: string, options?: PromptOptions): Promise<void> {
-		const preflightResult = options?.preflightResult;
-		const attachments = options?.attachments;
-		let messages: AgentMessage[] | undefined;
-
-		try {
-			this._assertNotDisposed();
-
-			if (this.isStreaming) {
-				throw new Error("Agent is already processing.");
-			}
-
-			// Validate model
-			if (!this.model) {
-				throw new Error(formatNoModelSelectedMessage());
-			}
-
-			const auth = await this._modelRuntime.checkAuth(this.model.provider);
-			this._assertNotDisposed();
-			if (!auth) {
-				throw new Error(formatNoApiKeyFoundMessage(this.model.provider));
-			}
-
-			// Check if we need to compact before sending (catches aborted responses).
-			// The user's new prompt is sent below, so do not call agent.continue() here.
-			const lastAssistant = this._findLastAssistantMessage();
-			if (lastAssistant) {
-				await this._checkCompaction(lastAssistant, false);
-				this._assertNotDisposed();
-			}
-
-			const userContent: UserContent[] = [{ type: "text", text }];
-			if (attachments) userContent.push(...attachments);
-			messages = [{ role: "user", content: userContent, timestamp: Date.now() }];
-
-			const systemPrompt = await this._extensionRunner.emitBeforeAgentStart(
-				text,
-				this._baseSystemPrompt,
-				this._baseSystemPromptOptions,
-				attachments,
-			);
-			this._assertNotDisposed();
-			// Apply extension-modified system prompt, or reset to base
-			this._systemPromptOverride = systemPrompt;
-			this.agent.state.systemPrompt = systemPrompt ?? this._baseSystemPrompt;
-		} catch (error) {
-			preflightResult?.(false);
-			throw error;
-		}
-
-		preflightResult?.(true);
-		await this._runAgentPrompt(messages);
-	}
-
-	private _assertNotDisposed(): void {
-		if (this._disposed) {
-			throw new Error("Agent session is disposed.");
-		}
-	}
-
-	/**
-	 * Abort current operation and wait for agent to become idle.
-	 */
-	async abort(): Promise<void> {
-		this.abortRetry();
-		this.agent.abort();
-		await this.waitForIdle();
-	}
-
-	async waitForIdle(): Promise<void> {
-		if (this.isIdle) {
-			return;
-		}
-		await this._getIdleWaitPromise();
-	}
-
-	/**
-	 * Set model directly.
-	 * Validates that auth is configured, saves to session and settings.
-	 * @throws Error if no auth is configured for the model
-	 */
-	async setModel(model: Model<any>): Promise<void> {
-		if (!(await this._modelRuntime.checkAuth(model.provider))) {
-			throw new Error(`No API key for ${model.provider}/${model.id}`);
-		}
-
-		const thinkingLevel = this._getThinkingLevelForModelSwitch();
-		this.agent.state.model = model;
-		this.sessionManager.appendModelChange(model.provider, model.id);
-
-		// Re-clamp thinking level for new model's capabilities
-		this.setThinkingLevel(thinkingLevel);
-	}
-
-	/**
-	 * Set thinking level.
-	 * Clamps to model capabilities based on available thinking levels.
-	 * Saves to session and settings only if the level actually changes.
-	 */
-	setThinkingLevel(level: ThinkingLevel): void {
-		const availableLevels = this.getAvailableThinkingLevels();
-		const effectiveLevel = availableLevels.includes(level) ? level : this._clampThinkingLevel(level, availableLevels);
-
-		// Only persist if actually changing
-		const previousLevel = this.agent.state.thinkingLevel;
-		const isChanging = effectiveLevel !== previousLevel;
-
-		this.agent.state.thinkingLevel = effectiveLevel;
-
-		if (isChanging) {
-			this.sessionManager.appendThinkingLevelChange(effectiveLevel);
-			this._emit({ type: "thinking_level_changed", level: effectiveLevel });
-		}
-	}
-
-	/**
-	 * Get available thinking levels for current model.
-	 * The provider will clamp to what the specific model supports internally.
-	 */
-	getAvailableThinkingLevels(): ThinkingLevel[] {
-		if (!this.model) return THINKING_LEVELS;
-		return getSupportedThinkingLevels(this.model) as ThinkingLevel[];
-	}
-
-	/**
-	 * Check if current model supports thinking/reasoning.
-	 */
-	private supportsThinking(): boolean {
-		return !!this.model?.reasoning;
-	}
-
-	private _getThinkingLevelForModelSwitch(explicitLevel?: ThinkingLevel): ThinkingLevel {
-		if (explicitLevel !== undefined) {
-			return explicitLevel;
-		}
-		if (!this.supportsThinking()) {
-			return DEFAULT_THINKING_LEVEL;
-		}
-		return this.thinkingLevel;
-	}
-
-	private _clampThinkingLevel(level: ThinkingLevel, _availableLevels: ThinkingLevel[]): ThinkingLevel {
-		return this.model ? (clampThinkingLevel(this.model, level) as ThinkingLevel) : "off";
-	}
-
-	/**
-	 * Check if compaction is needed and run it.
-	 * Called after agent_end and before prompt submission.
-	 *
-	 * Two cases:
-	 * 1. Overflow: LLM returned context overflow error, remove error message from agent state, compact, auto-retry
-	 * 2. Threshold: Context over threshold, compact, NO auto-retry (user continues manually)
-	 *
-	 * @param assistantMessage The assistant message to check
-	 * @param skipAbortedCheck If false, include aborted messages (for pre-prompt check). Default: true
-	 */
-	private async _checkCompaction(assistantMessage: AssistantMessage, skipAbortedCheck = true): Promise<boolean> {
-		const settings = this.settings.compaction;
-		if (!settings.enabled) return false;
-
-		// Skip if message was aborted (user cancelled) - unless skipAbortedCheck is false
-		if (skipAbortedCheck && assistantMessage.stopReason === "aborted") return false;
-
-		const contextWindow = this.model?.contextWindow ?? 0;
-
-		// Skip overflow check if the message came from a different model.
-		// This handles the case where user switched from a smaller-context model (e.g. opus)
-		// to a larger-context model (e.g. codex) - the overflow error from the old model
-		// shouldn't trigger compaction for the new model.
-		const sameModel =
-			this.model && assistantMessage.provider === this.model.provider && assistantMessage.model === this.model.id;
-
-		// Skip compaction checks if this assistant message is older than the latest
-		// compaction boundary. This prevents a stale pre-compaction usage/error
-		// from retriggering compaction on the first prompt after compaction.
-		const compactionEntry = getLatestCompactionEntry(this.sessionManager.getBranch());
-		const assistantIsFromBeforeCompaction =
-			compactionEntry !== null && assistantMessage.timestamp <= new Date(compactionEntry.timestamp).getTime();
-		if (assistantIsFromBeforeCompaction) {
-			return false;
-		}
-
-		// Case 1: Overflow - LLM returned context overflow error, or reported usage exceeded
-		// the configured window. A successful response over the configured window should compact
-		// but must not retry: the assistant answer already completed and agent.continue() cannot
-		// continue from an assistant message.
-		if (sameModel && isContextOverflow(assistantMessage, contextWindow)) {
-			const willRetry = assistantMessage.stopReason !== "stop";
-
-			if (!willRetry) {
-				return await this._runAutoCompaction("overflow", false);
-			}
-
-			if (this._overflowRecoveryAttempted) {
-				this._emit({
-					type: "compaction_end",
-					reason: "overflow",
-					result: undefined,
-					aborted: false,
-					willRetry: false,
-					errorMessage:
-						"Context overflow recovery failed after one compact-and-retry attempt. Try reducing context or switching to a larger-context model.",
-				});
-				return false;
-			}
-
-			this._overflowRecoveryAttempted = true;
-			// Remove the error message from agent state (it IS saved to session for history,
-			// but we don't want it in context for the retry)
-			const messages = this.agent.state.messages;
-			if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
-				this.agent.state.messages = messages.slice(0, -1);
-			}
-			return await this._runAutoCompaction("overflow", willRetry);
-		}
-
-		// Case 2: Threshold - context is getting large
-		// For error messages or all-zero usage messages, estimate from the last valid response.
-		// This ensures sessions that hit persistent API errors (e.g. 529) or malformed zero-usage
-		// responses can still compact and do not reset context accounting.
-		let contextTokens: number;
-		const directContextTokens = assistantMessage.usage ? calculateContextTokens(assistantMessage.usage) : 0;
-		if (assistantMessage.stopReason === "error" || directContextTokens === 0) {
-			const messages = this.agent.state.messages;
-			const estimate = estimateContextTokens(messages);
-			if (estimate.lastUsageIndex === null) return false; // No usage data at all
-			// Verify the usage source is post-compaction. Kept pre-compaction messages
-			// have stale usage reflecting the old (larger) context and would falsely
-			// trigger compaction right after one just finished.
-			const usageMsg = messages[estimate.lastUsageIndex];
-			if (
-				compactionEntry &&
-				usageMsg.role === "assistant" &&
-				(usageMsg as AssistantMessage).timestamp <= new Date(compactionEntry.timestamp).getTime()
-			) {
-				return false;
-			}
-			contextTokens = estimate.tokens;
-		} else {
-			contextTokens = directContextTokens;
-		}
-		if (shouldCompact(contextTokens, contextWindow, settings)) {
-			return await this._runAutoCompaction("threshold", false);
-		}
-		return false;
-	}
-
-	/**
-	 * Internal: Run auto-compaction with events.
-	 */
-	private async _runAutoCompaction(reason: "overflow" | "threshold", willRetry: boolean): Promise<boolean> {
-		const settings = this.settings.compaction;
-		let started = false;
-
-		try {
-			if (!this.model) {
-				return false;
-			}
-
-			let apiKey: string | undefined;
-			let headers: Record<string, string> | undefined;
-			let env: Record<string, string> | undefined;
-			if (this.agent.streamFn === streamSimple) {
-				const authResult = await this._modelRuntime.getAuth(this.model);
-				if (!authResult?.auth.apiKey) return false;
-				apiKey = authResult.auth.apiKey;
-				headers = withoutDeletedHeaders(authResult.auth.headers);
-				env = authResult.env;
-			} else {
-				({ apiKey, headers, env } = await this._getSummarizationRequestAuth(this.model));
-			}
-
-			const pathEntries = this.sessionManager.getBranch();
-
-			const preparation = prepareCompaction(pathEntries, settings);
-			if (!preparation) {
-				return false;
-			}
-
-			this._emit({ type: "compaction_start", reason });
-			this._autoCompactionAbortController = new AbortController();
-			started = true;
-
-			const { summary, firstKeptEntryId, tokensBefore, details } = await compact(
-				preparation,
-				this.model,
-				apiKey,
-				headers,
-				undefined,
-				this._autoCompactionAbortController.signal,
-				this.thinkingLevel,
-				this.agent.streamFn,
-				env,
-			);
-
-			if (this._autoCompactionAbortController.signal.aborted) {
-				this._emit({
-					type: "compaction_end",
-					reason,
-					result: undefined,
-					aborted: true,
-					willRetry: false,
-				});
-				return false;
-			}
-
-			this.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, false);
-			const sessionContext = this.sessionManager.buildSessionContext();
-			this.agent.state.messages = sessionContext.messages;
-			const estimatedTokensAfter = estimateMessagesTokens(sessionContext.messages);
-
-			const result: CompactionResult = {
-				summary,
-				firstKeptEntryId,
-				tokensBefore,
-				estimatedTokensAfter,
-				details,
-			};
-			this._emit({ type: "compaction_end", reason, result, aborted: false, willRetry });
-
-			if (willRetry) {
-				const messages = this.agent.state.messages;
-				const lastMsg = messages[messages.length - 1];
-				if (lastMsg?.role === "assistant" && (lastMsg as AssistantMessage).stopReason === "error") {
-					this.agent.state.messages = messages.slice(0, -1);
-				}
-				return true;
-			}
-
-			return false;
-		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : "compaction failed";
-			if (started) {
-				this._emit({
-					type: "compaction_end",
-					reason,
-					result: undefined,
-					aborted: false,
-					willRetry: false,
-					errorMessage:
-						reason === "overflow"
-							? `Context overflow recovery failed: ${errorMessage}`
-							: `Auto-compaction failed: ${errorMessage}`,
-				});
-			}
-			return false;
-		} finally {
-			this._autoCompactionAbortController = undefined;
-		}
-	}
-
-	async bindExtensions(bindings: ExtensionBindings): Promise<void> {
-		this._extensionErrorUnsubscriber?.();
-		this._extensionErrorUnsubscriber = bindings.onError ? this._extensionRunner.onError(bindings.onError) : undefined;
-	}
-
-	private _bindExtensionCore(runner: ExtensionRunner): void {
-		runner.bindCore(
-			{
-				appendEntry: (customType, data) => {
-					this.sessionManager.appendCustomEntry(customType, data);
-				},
-				getAllTools: () => this.getAllTools(),
-				setActiveTools: (toolNames) => this.setActiveToolsByName(toolNames),
-				refreshTools: () => this._refreshToolRegistry(),
-			},
-			{
-				getModel: () => this.model,
-				getSignal: () => this.agent.signal,
-			},
-		);
-	}
-
-	private _refreshToolRegistry(options?: { activateAll?: boolean }): void {
-		const previousRegistryNames = new Set(this._toolRegistry.keys());
-		const previousActiveToolNames = this.getActiveToolNames();
-		const allowedToolNames = this._allowedToolNames;
-		const isAllowedTool = (name: string): boolean => !allowedToolNames || allowedToolNames.has(name);
-
-		const tools = [
-			...this._extensionRunner.getAllRegisteredTools(),
-			...this._customTools.map((definition) => ({
-				definition,
-				sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
-			})),
-		].filter((tool) => isAllowedTool(tool.definition.name));
-		const definitionRegistry = new Map<string, ToolDefinitionEntry>(
-			tools.map((tool) => [tool.definition.name, { definition: tool.definition, sourceInfo: tool.sourceInfo }]),
-		);
-		this._toolDefinitions = definitionRegistry;
-		this._toolPromptSnippets = new Map(
-			Array.from(definitionRegistry.values())
-				.map(({ definition }) => {
-					const snippet = this._normalizePromptSnippet(definition.promptSnippet);
-					return snippet ? ([definition.name, snippet] as const) : undefined;
-				})
-				.filter((entry): entry is readonly [string, string] => entry !== undefined),
-		);
-		this._toolPromptGuidelines = new Map(
-			Array.from(definitionRegistry.values())
-				.map(({ definition }) => {
-					const guidelines = this._normalizePromptGuidelines(definition.promptGuidelines);
-					return guidelines.length > 0 ? ([definition.name, guidelines] as const) : undefined;
-				})
-				.filter((entry): entry is readonly [string, string[]] => entry !== undefined),
-		);
-		this._toolRegistry = new Map(
-			wrapRegisteredTools(tools, this._extensionRunner).map((tool) => [tool.name, tool] as const),
-		);
-
-		const registryNames = [...this._toolRegistry.keys()];
-		const nextActiveToolNames = options?.activateAll || allowedToolNames
-			? registryNames
-			: [
-				...previousActiveToolNames.filter((name) => this._toolRegistry.has(name)),
-				...registryNames.filter((name) => !previousRegistryNames.has(name)),
-			];
-
-		this.setActiveToolsByName([...new Set(nextActiveToolNames)]);
-	}
-
-	private _buildRuntime(): void {
-		const extensionsResult = this._resourceLoader.getExtensions();
-		this._extensionRunner = new ExtensionRunner(extensionsResult.extensions, extensionsResult.runtime, this.sessionManager);
-		if (this._extensionRunnerRef) {
-			this._extensionRunnerRef.current = this._extensionRunner;
-		}
-		this._bindExtensionCore(this._extensionRunner);
-		this._refreshToolRegistry({ activateAll: true });
-	}
-
-	/**
-	 * Check if an error is retryable (overloaded, rate limit, server errors).
-	 * Context overflow errors are NOT retryable (handled by compaction instead).
-	 */
-	private _isRetryableError(message: AssistantMessage): boolean {
-		// Context overflow is handled by compaction, not retry.
-		if (isContextOverflow(message, this.model?.contextWindow ?? 0)) return false;
-		return isRetryableAssistantError(message);
-	}
-
-	/**
-	 * Prepare a retryable error for continuation with exponential backoff.
-	 * @returns true if the caller should continue the agent, false otherwise
-	 */
-	private async _prepareRetry(message: AssistantMessage): Promise<boolean> {
-		const settings = this.settings.retry;
-		if (!settings.enabled) {
-			return false;
-		}
-
-		this._retryAttempt++;
-
-		if (this._retryAttempt > settings.maxRetries) {
-			// Preserve the completed attempt count so post-run handling can emit the final failure.
-			this._retryAttempt--;
-			return false;
-		}
-
-		const delayMs = settings.baseDelayMs * 2 ** (this._retryAttempt - 1);
-
-		this._emit({
-			type: "auto_retry_start",
-			attempt: this._retryAttempt,
-			maxAttempts: settings.maxRetries,
-			delayMs,
-			errorMessage: message.errorMessage || "Unknown error",
-		});
-
-		// Remove error message from agent state (keep in session for history)
-		const messages = this.agent.state.messages;
-		if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
-			this.agent.state.messages = messages.slice(0, -1);
-		}
-
-		// Wait with exponential backoff (abortable)
-		this._retryAbortController = new AbortController();
-		try {
-			await sleep(delayMs, this._retryAbortController.signal);
-		} catch {
-			// Aborted during sleep - emit end event so UI can clean up
-			const attempt = this._retryAttempt;
-			this._retryAttempt = 0;
-			this._emit({
-				type: "auto_retry_end",
-				success: false,
-				attempt,
-				finalError: "Retry cancelled",
-			});
-			return false;
-		} finally {
-			this._retryAbortController = undefined;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Cancel in-progress retry.
-	 */
-	abortRetry(): void {
-		this._retryAbortController?.abort();
-	}
-}