@nghyane/arcane 0.1.13 → 0.1.15

package/src/session/model-controller.ts

@@ -0,0 +1,406 @@
+import type { Agent, ThinkingLevel } from "@nghyane/arcane-agent";
+import type { Model, ProviderSessionState } from "@nghyane/arcane-ai";
+import { modelsAreEqual, supportsXhigh } from "@nghyane/arcane-ai";
+import { logger } from "@nghyane/arcane-utils";
+import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "../config/model-registry";
+import { expandRoleAlias, parseModelString } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import type { SessionManager } from "./session-manager";
+import type { ModelCycleResult, RoleModelCycleResult } from "./session-types";
+
+/** Standard thinking levels */
+const THINKING_LEVELS: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high"];
+
+/** Thinking levels including xhigh (for supported models) */
+const THINKING_LEVELS_WITH_XHIGH: ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"];
+
+/**
+ * Owns model selection, thinking level, and scoped model cycling.
+ *
+ * AgentSession delegates all model/thinking operations here.
+ * The controller mutates agent state (model, thinking level) and
+ * persists changes to sessionManager and settings.
+ */
+export class ModelController {
+	#agent: Agent;
+	#settings: Settings;
+	#sessionManager: SessionManager;
+	#modelRegistry: ModelRegistry;
+	#scopedModels: Array<{ model: Model; thinkingLevel: ThinkingLevel }>;
+	#forceCopilotAgentInitiator: boolean;
+	#providerSessionState = new Map<string, ProviderSessionState>();
+
+	constructor(
+		agent: Agent,
+		settings: Settings,
+		sessionManager: SessionManager,
+		modelRegistry: ModelRegistry,
+		options: {
+			scopedModels?: Array<{ model: Model; thinkingLevel: ThinkingLevel }>;
+			forceCopilotAgentInitiator?: boolean;
+		},
+	) {
+		this.#agent = agent;
+		this.#settings = settings;
+		this.#sessionManager = sessionManager;
+		this.#modelRegistry = modelRegistry;
+		this.#scopedModels = options.scopedModels ? [...options.scopedModels] : [];
+		this.#forceCopilotAgentInitiator = options.forceCopilotAgentInitiator ?? false;
+	}
+
+	get registry(): ModelRegistry {
+		return this.#modelRegistry;
+	}
+
+	get model(): Model | undefined {
+		return this.#agent.state.model;
+	}
+
+	get thinkingLevel(): ThinkingLevel {
+		return this.#agent.state.thinkingLevel;
+	}
+
+	get scopedModels(): ReadonlyArray<{ model: Model; thinkingLevel: ThinkingLevel }> {
+		return this.#scopedModels;
+	}
+
+	get providerSessionState(): Map<string, ProviderSessionState> {
+		return this.#providerSessionState;
+	}
+
+	applySessionModelOverrides(model: Model): Model {
+		if (!this.#forceCopilotAgentInitiator || model.provider !== "github-copilot") {
+			return model;
+		}
+		return {
+			...model,
+			headers: {
+				...model.headers,
+				"X-Initiator": "agent",
+			},
+		};
+	}
+
+	setModelDirect(model: Model): void {
+		const currentModel = this.model;
+		if (currentModel) {
+			this.#closeProviderSessionsForModelSwitch(currentModel, model);
+		}
+		this.#agent.setModel(this.applySessionModelOverrides(model));
+	}
+
+	async setModel(model: Model, role: ModelRole = "default"): Promise<void> {
+		const apiKey = await this.#modelRegistry.getApiKey(model, this.#sessionId);
+		if (!apiKey) {
+			throw new Error(`No API key for ${model.provider}/${model.id}`);
+		}
+
+		this.setModelDirect(model);
+		this.#sessionManager.appendModelChange(`${model.provider}/${model.id}`, role);
+		this.#settings.setModelRole(role, `${model.provider}/${model.id}`);
+		this.#settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
+	}
+
+	async setModelTemporary(model: Model): Promise<void> {
+		const apiKey = await this.#modelRegistry.getApiKey(model, this.#sessionId);
+		if (!apiKey) {
+			throw new Error(`No API key for ${model.provider}/${model.id}`);
+		}
+
+		this.setModelDirect(model);
+		this.#sessionManager.appendModelChange(`${model.provider}/${model.id}`);
+	}
+
+	async cycleModel(direction: "forward" | "backward" = "forward"): Promise<ModelCycleResult | undefined> {
+		if (this.#scopedModels.length > 0) {
+			return this.#cycleScopedModel(direction);
+		}
+		return this.#cycleAvailableModel(direction);
+	}
+
+	async cycleRoleModels(
+		roleOrder: readonly ModelRole[],
+		options?: { temporary?: boolean },
+	): Promise<RoleModelCycleResult | undefined> {
+		const availableModels = this.#modelRegistry.getAvailable();
+		if (availableModels.length === 0) return undefined;
+
+		const currentModel = this.model;
+		if (!currentModel) return undefined;
+		const roleModels: Array<{ role: ModelRole; model: Model }> = [];
+
+		for (const role of roleOrder) {
+			const roleModelStr =
+				role === "default"
+					? (this.#settings.getModelRole("default") ?? `${currentModel.provider}/${currentModel.id}`)
+					: this.#settings.getModelRole(role);
+			if (!roleModelStr) continue;
+
+			const expandedRoleModelStr = expandRoleAlias(roleModelStr, this.#settings);
+			const parsed = parseModelString(expandedRoleModelStr);
+			let match: Model | undefined;
+			if (parsed) {
+				match = availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
+			}
+			if (!match) {
+				match = availableModels.find(m => m.id.toLowerCase() === expandedRoleModelStr.toLowerCase());
+			}
+			if (!match) continue;
+
+			roleModels.push({ role, model: match });
+		}
+
+		if (roleModels.length <= 1) return undefined;
+
+		const lastRole = this.#sessionManager.getLastModelChangeRole();
+		let currentIndex = lastRole
+			? roleModels.findIndex(entry => entry.role === lastRole)
+			: roleModels.findIndex(entry => modelsAreEqual(entry.model, currentModel));
+		if (currentIndex === -1) currentIndex = 0;
+
+		const nextIndex = (currentIndex + 1) % roleModels.length;
+		const next = roleModels[nextIndex];
+
+		if (options?.temporary) {
+			await this.setModelTemporary(next.model);
+		} else {
+			await this.setModel(next.model, next.role);
+		}
+
+		return { model: next.model, thinkingLevel: this.thinkingLevel, role: next.role };
+	}
+
+	resolveRoleModel(role: ModelRole): Model | undefined {
+		return this.#resolveRoleModel(role, this.#modelRegistry.getAvailable(), this.model);
+	}
+
+	getAvailableModels(): Model[] {
+		return this.#modelRegistry.getAvailable();
+	}
+
+	setThinkingLevel(level: ThinkingLevel, persist = false): void {
+		const availableLevels = this.getAvailableThinkingLevels();
+		const effectiveLevel = availableLevels.includes(level) ? level : this.clampThinkingLevel(level, availableLevels);
+
+		const isChanging = effectiveLevel !== this.#agent.state.thinkingLevel;
+
+		this.#agent.setThinkingLevel(effectiveLevel);
+
+		if (isChanging) {
+			this.#sessionManager.appendThinkingLevelChange(effectiveLevel);
+			if (persist) {
+				this.#settings.set("defaultThinkingLevel", effectiveLevel);
+			}
+		}
+	}
+
+	cycleThinkingLevel(): ThinkingLevel | undefined {
+		if (!this.supportsThinking()) return undefined;
+
+		const levels = this.getAvailableThinkingLevels();
+		const currentIndex = levels.indexOf(this.thinkingLevel);
+		const nextIndex = (currentIndex + 1) % levels.length;
+		const nextLevel = levels[nextIndex];
+
+		this.setThinkingLevel(nextLevel);
+		return nextLevel;
+	}
+
+	getAvailableThinkingLevels(): ThinkingLevel[] {
+		if (!this.supportsThinking()) return ["off"];
+		return this.supportsXhighThinking() ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+	}
+
+	supportsXhighThinking(): boolean {
+		return this.model ? supportsXhigh(this.model) : false;
+	}
+
+	supportsThinking(): boolean {
+		return !!this.model?.reasoning;
+	}
+
+	getCompactionModelCandidates(availableModels: Model[]): Model[] {
+		const candidates: Model[] = [];
+		const seen = new Set<string>();
+
+		const addCandidate = (model: Model | undefined): void => {
+			if (!model) return;
+			const key = this.getModelKey(model);
+			if (seen.has(key)) return;
+			seen.add(key);
+			candidates.push(model);
+		};
+
+		const currentModel = this.model;
+		for (const role of MODEL_ROLE_IDS) {
+			addCandidate(this.#resolveRoleModel(role, availableModels, currentModel));
+		}
+
+		const sortedByContext = [...availableModels].sort((a, b) => b.contextWindow - a.contextWindow);
+		for (const model of sortedByContext) {
+			addCandidate(model);
+		}
+
+		return candidates;
+	}
+
+	resolveContextPromotionTarget(currentModel: Model, availableModels: Model[]): Model | undefined {
+		return this.#resolveContextPromotionConfiguredTarget(currentModel, availableModels);
+	}
+
+	closeCodexProviderSessionsForHistoryRewrite(): void {
+		const currentModel = this.model;
+		if (!currentModel || currentModel.api !== "openai-codex-responses") return;
+		this.#closeProviderSessionsForModelSwitch(currentModel, currentModel);
+	}
+
+	get #sessionId(): string {
+		return this.#sessionManager.getSessionId();
+	}
+
+	// =========================================================================
+	// Private
+	// =========================================================================
+
+	async #getScopedModelsWithApiKey(): Promise<Array<{ model: Model; thinkingLevel: ThinkingLevel }>> {
+		const apiKeysByProvider = new Map<string, string | undefined>();
+		const result: Array<{ model: Model; thinkingLevel: ThinkingLevel }> = [];
+
+		for (const scoped of this.#scopedModels) {
+			const provider = scoped.model.provider;
+			let apiKey: string | undefined;
+			if (apiKeysByProvider.has(provider)) {
+				apiKey = apiKeysByProvider.get(provider);
+			} else {
+				apiKey = await this.#modelRegistry.getApiKeyForProvider(provider, this.#sessionId);
+				apiKeysByProvider.set(provider, apiKey);
+			}
+
+			if (apiKey) {
+				result.push(scoped);
+			}
+		}
+
+		return result;
+	}
+
+	async #cycleScopedModel(direction: "forward" | "backward"): Promise<ModelCycleResult | undefined> {
+		const scopedModels = await this.#getScopedModelsWithApiKey();
+		if (scopedModels.length <= 1) return undefined;
+
+		const currentModel = this.model;
+		let currentIndex = scopedModels.findIndex(sm => modelsAreEqual(sm.model, currentModel));
+
+		if (currentIndex === -1) currentIndex = 0;
+		const len = scopedModels.length;
+		const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
+		const next = scopedModels[nextIndex];
+
+		this.setModelDirect(next.model);
+		this.#sessionManager.appendModelChange(`${next.model.provider}/${next.model.id}`);
+		this.#settings.setModelRole("default", `${next.model.provider}/${next.model.id}`);
+		this.#settings.getStorage()?.recordModelUsage(`${next.model.provider}/${next.model.id}`);
+
+		this.setThinkingLevel(next.thinkingLevel);
+
+		return { model: next.model, thinkingLevel: this.thinkingLevel, isScoped: true };
+	}
+
+	async #cycleAvailableModel(direction: "forward" | "backward"): Promise<ModelCycleResult | undefined> {
+		const availableModels = this.#modelRegistry.getAvailable();
+		if (availableModels.length <= 1) return undefined;
+
+		const currentModel = this.model;
+		let currentIndex = availableModels.findIndex(m => modelsAreEqual(m, currentModel));
+
+		if (currentIndex === -1) currentIndex = 0;
+		const len = availableModels.length;
+		const nextIndex = direction === "forward" ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
+		const nextModel = availableModels[nextIndex];
+
+		const apiKey = await this.#modelRegistry.getApiKey(nextModel, this.#sessionId);
+		if (!apiKey) {
+			throw new Error(`No API key for ${nextModel.provider}/${nextModel.id}`);
+		}
+
+		this.setModelDirect(nextModel);
+		this.#sessionManager.appendModelChange(`${nextModel.provider}/${nextModel.id}`);
+		this.#settings.setModelRole("default", `${nextModel.provider}/${nextModel.id}`);
+		this.#settings.getStorage()?.recordModelUsage(`${nextModel.provider}/${nextModel.id}`);
+
+		this.setThinkingLevel(this.thinkingLevel);
+
+		return { model: nextModel, thinkingLevel: this.thinkingLevel, isScoped: false };
+	}
+
+	clampThinkingLevel(level: ThinkingLevel, availableLevels: ThinkingLevel[]): ThinkingLevel {
+		const ordered = THINKING_LEVELS_WITH_XHIGH;
+		const available = new Set(availableLevels);
+		const requestedIndex = ordered.indexOf(level);
+		if (requestedIndex === -1) {
+			return availableLevels[0] ?? "off";
+		}
+		for (let i = requestedIndex; i < ordered.length; i++) {
+			const candidate = ordered[i];
+			if (available.has(candidate)) return candidate;
+		}
+		for (let i = requestedIndex - 1; i >= 0; i--) {
+			const candidate = ordered[i];
+			if (available.has(candidate)) return candidate;
+		}
+		return availableLevels[0] ?? "off";
+	}
+
+	#closeProviderSessionsForModelSwitch(currentModel: Model, nextModel: Model): void {
+		if (currentModel.api !== "openai-codex-responses" && nextModel.api !== "openai-codex-responses") return;
+
+		const providerKey = "openai-codex-responses";
+		const state = this.#providerSessionState.get(providerKey);
+		if (!state) return;
+
+		try {
+			state.close();
+		} catch (error) {
+			logger.warn("Failed to close provider session state during model switch", {
+				providerKey,
+				error: String(error),
+			});
+		}
+
+		this.#providerSessionState.delete(providerKey);
+	}
+
+	getModelKey(model: Model): string {
+		return `${model.provider}/${model.id}`;
+	}
+
+	#resolveContextPromotionConfiguredTarget(currentModel: Model, availableModels: Model[]): Model | undefined {
+		const configuredTarget = currentModel.contextPromotionTarget?.trim();
+		if (!configuredTarget) return undefined;
+
+		const parsed = parseModelString(configuredTarget);
+		if (parsed) {
+			const explicitModel = availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
+			if (explicitModel) return explicitModel;
+		}
+
+		return availableModels.find(m => m.provider === currentModel.provider && m.id === configuredTarget);
+	}
+
+	#resolveRoleModel(role: ModelRole, availableModels: Model[], currentModel: Model | undefined): Model | undefined {
+		const roleModelStr =
+			role === "default"
+				? (this.#settings.getModelRole("default") ??
+					(currentModel ? `${currentModel.provider}/${currentModel.id}` : undefined))
+				: this.#settings.getModelRole(role);
+
+		if (!roleModelStr) return undefined;
+
+		const parsed = parseModelString(roleModelStr);
+		if (parsed) {
+			return availableModels.find(m => m.provider === parsed.provider && m.id === parsed.id);
+		}
+		const roleLower = roleModelStr.toLowerCase();
+		return availableModels.find(m => m.id.toLowerCase() === roleLower);
+	}
+}

package/src/session/retry-utils.ts

@@ -0,0 +1,71 @@
+/**
+ * Pure utility functions for retry logic.
+ * Stateless — no class dependencies, no side effects.
+ */
+
+/**
+ * Check if an error message indicates a retryable API error.
+ * Matches: overloaded, rate limit, usage limit, 429, 5xx, connection errors.
+ */
+export function isRetryableErrorMessage(errorMessage: string): boolean {
+	return /overloaded|rate.?limit|usage.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|unable to connect|fetch failed|retry delay/i.test(
+		errorMessage,
+	);
+}
+
+/**
+ * Check if an error message indicates a usage/billing limit (non-transient).
+ */
+export function isUsageLimitErrorMessage(errorMessage: string): boolean {
+	return /usage.?limit|usage_limit_reached|limit_reached/i.test(errorMessage);
+}
+
+/**
+ * Parse retry-after delay from an error message.
+ * Supports: retry-after-ms, retry-after (seconds or HTTP-date), x-ratelimit-reset-ms, x-ratelimit-reset.
+ * Returns delay in milliseconds, or undefined if no header found.
+ */
+export function parseRetryAfterMs(errorMessage: string): number | undefined {
+	const now = Date.now();
+	const retryAfterMsMatch = /retry-after-ms\s*[:=]\s*(\d+)/i.exec(errorMessage);
+	if (retryAfterMsMatch) {
+		return Math.max(0, Number(retryAfterMsMatch[1]));
+	}
+
+	const retryAfterMatch = /retry-after\s*[:=]\s*([^\s,;]+)/i.exec(errorMessage);
+	if (retryAfterMatch) {
+		const value = retryAfterMatch[1];
+		const seconds = Number(value);
+		if (!Number.isNaN(seconds)) {
+			return Math.max(0, seconds * 1000);
+		}
+		const dateMs = Date.parse(value);
+		if (!Number.isNaN(dateMs)) {
+			return Math.max(0, dateMs - now);
+		}
+	}
+
+	const resetMsMatch = /x-ratelimit-reset-ms\s*[:=]\s*(\d+)/i.exec(errorMessage);
+	if (resetMsMatch) {
+		const resetMs = Number(resetMsMatch[1]);
+		if (!Number.isNaN(resetMs)) {
+			if (resetMs > 1_000_000_000_000) {
+				return Math.max(0, resetMs - now);
+			}
+			return Math.max(0, resetMs);
+		}
+	}
+
+	const resetMatch = /x-ratelimit-reset\s*[:=]\s*(\d+)/i.exec(errorMessage);
+	if (resetMatch) {
+		const resetSeconds = Number(resetMatch[1]);
+		if (!Number.isNaN(resetSeconds)) {
+			if (resetSeconds > 1_000_000_000) {
+				return Math.max(0, resetSeconds * 1000 - now);
+			}
+			return Math.max(0, resetSeconds * 1000);
+		}
+	}
+
+	return undefined;
+}

package/src/session/session-manager.ts

@@ -20,193 +20,29 @@ import {
 import type { SessionStorage, SessionStorageWriter } from "./session-storage";
 import { FileSessionStorage, MemorySessionStorage } from "./session-storage";
 
-export const CURRENT_SESSION_VERSION = 3;
-
-export interface SessionHeader {
-	type: "session";
-	version?: number; // v1 sessions don't have this
-	id: string;
-	title?: string; // Auto-generated title from first message
-	timestamp: string;
-	cwd: string;
-	parentSession?: string;
-}
-
-export interface NewSessionOptions {
-	parentSession?: string;
-}
-
-export interface SessionEntryBase {
-	type: string;
-	id: string;
-	parentId: string | null;
-	timestamp: string;
-}
-
-export interface SessionMessageEntry extends SessionEntryBase {
-	type: "message";
-	message: AgentMessage;
-}
-
-export interface ThinkingLevelChangeEntry extends SessionEntryBase {
-	type: "thinking_level_change";
-	thinkingLevel: string;
-}
-
-export interface ModelChangeEntry extends SessionEntryBase {
-	type: "model_change";
-	/** Model in "provider/modelId" format */
-	model: string;
-	/** Role: "default", "fast", "oracle", etc. Undefined treated as "default" */
-	role?: string;
-}
-
-export interface CompactionEntry<T = unknown> extends SessionEntryBase {
-	type: "compaction";
-	summary: string;
-	shortSummary?: string;
-	firstKeptEntryId: string;
-	tokensBefore: number;
-	/** Extension-specific data (e.g., ArtifactIndex, version markers for structured compaction) */
-	details?: T;
-	/** Hook-provided data to persist across compaction */
-	preserveData?: Record<string, unknown>;
-	/** True if generated by an extension, undefined/false if pi-generated (backward compatible) */
-	fromExtension?: boolean;
-}
-
-export interface BranchSummaryEntry<T = unknown> extends SessionEntryBase {
-	type: "branch_summary";
-	fromId: string;
-	summary: string;
-	/** Extension-specific data (not sent to LLM) */
-	details?: T;
-	/** True if generated by an extension, false if pi-generated */
-	fromExtension?: boolean;
-}
-
-/**
- * Custom entry for extensions to store extension-specific data in the session.
- * Use customType to identify your extension's entries.
- *
- * Purpose: Persist extension state across session reloads. On reload, extensions can
- * scan entries for their customType and reconstruct internal state.
- *
- * Does NOT participate in LLM context (ignored by buildSessionContext).
- * For injecting content into context, see CustomMessageEntry.
- */
-export interface CustomEntry<T = unknown> extends SessionEntryBase {
-	type: "custom";
-	customType: string;
-	data?: T;
-}
+export * from "./session-types";
 
-/** Label entry for user-defined bookmarks/markers on entries. */
-export interface LabelEntry extends SessionEntryBase {
-	type: "label";
-	targetId: string;
-	label: string | undefined;
-}
-
-/** TTSR injection entry - tracks which time-traveling rules have been injected this session. */
-export interface TtsrInjectionEntry extends SessionEntryBase {
-	type: "ttsr_injection";
-	/** Names of rules that were injected */
-	injectedRules: string[];
-}
-
-/** Session init entry - captures initial context for subagent sessions (debugging/replay). */
-export interface SessionInitEntry extends SessionEntryBase {
-	type: "session_init";
-	/** Full system prompt sent to the model */
-	systemPrompt: string;
-	/** Initial task/user message */
-	task: string;
-	/** Tools available to the agent */
-	tools: string[];
-}
-
-/** Mode change entry - tracks agent mode transitions. */
-export interface ModeChangeEntry extends SessionEntryBase {
-	type: "mode_change";
-	/** Current mode name, or "none" when exiting a mode */
-	mode: string;
-	/** Optional mode-specific data (e.g. plan file path) */
-	data?: Record<string, unknown>;
-}
-
-/**
- * Custom message entry for extensions to inject messages into LLM context.
- * Use customType to identify your extension's entries.
- *
- * Unlike CustomEntry, this DOES participate in LLM context.
- * The content is converted to a user message in buildSessionContext().
- * Use details for extension-specific metadata (not sent to LLM).
- *
- * display controls TUI rendering:
- * - false: hidden entirely
- * - true: rendered with distinct styling (different from user messages)
- */
-export interface CustomMessageEntry<T = unknown> extends SessionEntryBase {
-	type: "custom_message";
-	customType: string;
-	content: string | (TextContent | ImageContent)[];
-	details?: T;
-	display: boolean;
-}
-
-/** Session entry - has id/parentId for tree structure (returned by "read" methods in SessionManager) */
-export type SessionEntry =
-	| SessionMessageEntry
-	| ThinkingLevelChangeEntry
-	| ModelChangeEntry
-	| CompactionEntry
-	| BranchSummaryEntry
-	| CustomEntry
-	| CustomMessageEntry
-	| LabelEntry
-	| TtsrInjectionEntry
-	| SessionInitEntry
-	| ModeChangeEntry;
-
-/** Raw file entry (includes header) */
-export type FileEntry = SessionHeader | SessionEntry;
-
-/** Tree node for getTree() - defensive copy of session structure */
-export interface SessionTreeNode {
-	entry: SessionEntry;
-	children: SessionTreeNode[];
-	/** Resolved label for this entry, if any */
-	label?: string;
-}
-
-export interface SessionContext {
-	messages: AgentMessage[];
-	thinkingLevel: string;
-	/** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
-	models: Record<string, string>;
-	/** Names of TTSR rules that have been injected this session */
-	injectedTtsrRules: string[];
-	/** Active mode (e.g. "plan") or "none" if no special mode is active */
-	mode: string;
-	/** Mode-specific data from the last mode_change entry */
-	modeData?: Record<string, unknown>;
-}
-
-export interface SessionInfo {
-	path: string;
-	id: string;
-	/** Working directory where the session was started. Empty string for old sessions. */
-	cwd: string;
-	title?: string;
-	/** Path to the parent session (if this session was forked). */
-	parentSessionPath?: string;
-	created: Date;
-	modified: Date;
-	messageCount: number;
-	firstMessage: string;
-	allMessagesText: string;
-}
+import {
+	type BranchSummaryEntry,
+	type CompactionEntry,
+	CURRENT_SESSION_VERSION,
+	type CustomEntry,
+	type CustomMessageEntry,
+	type FileEntry,
+	type LabelEntry,
+	type ModeChangeEntry,
+	type ModelChangeEntry,
+	type NewSessionOptions,
+	type SessionContext,
+	type SessionEntry,
+	type SessionHeader,
+	type SessionInfo,
+	type SessionInitEntry,
+	type SessionMessageEntry,
+	type SessionTreeNode,
+	type ThinkingLevelChangeEntry,
+	type TtsrInjectionEntry,
+} from "./session-types";
 
 export type ReadonlySessionManager = Pick<
 	SessionManager,