catui-agent 1.0.0-beta.0

package/dist/core/runtime/model-controller.d.ts

@@ -0,0 +1,84 @@
+/**
+ * [WHO]: Provides ModelController, CycleModelError, ModelCycleResult — model + thinking-level management
+ * [FROM]: Depends on @catui/ai (Model, modelsAreEqual), @catui/agent-core (types),
+ *         ./session-context (ModelControllerContext), ./thinking-levels, ./model-cycle
+ * [TO]: Consumed by core/runtime/agent-session.ts (constructs one, delegates the public methods)
+ * [HERE]: core/runtime/agent-session.ts split — owns setModel/cycleModel and thinking-level methods
+ *
+ * Extracted from AgentSession (S2 controller). Session state is reached through narrow
+ * ModelControllerContext capabilities; behavior is identical to the former AgentSession methods.
+ */
+import type { AgentLoopFrameworkInput, AgentLoopPolicyOptions, ThinkingLevel } from "@catui/agent-core";
+import type { Model } from "@catui/ai/types";
+import type { ModelControllerContext } from "./session-context.js";
+/** Result of cycling the model. */
+export interface ModelCycleResult {
+    model: Model<any>;
+    thinkingLevel: ThinkingLevel;
+    isScoped: boolean;
+}
+/** Raised when cycling cannot find a usable model (e.g. all OAuth tokens expired). */
+export declare class CycleModelError extends Error {
+    readonly provider?: string | undefined;
+    readonly code?: "oauth_expired" | "no_valid_key" | "api_error" | undefined;
+    constructor(message: string, provider?: string | undefined, code?: "oauth_expired" | "no_valid_key" | "api_error" | undefined);
+}
+export declare class ModelController {
+    private readonly ctx;
+    constructor(ctx: ModelControllerContext);
+    private _emitModelSelect;
+    /**
+     * Apply a model change: persist to session + settings, set the thinking level
+     * (explicit when given, otherwise auto-picked from capabilities), and emit
+     * model_select. Shared by setModel and the cycle paths.
+     */
+    private _applyModelChange;
+    /**
+     * Set model directly. Validates API key, saves to session and settings.
+     * @throws Error if no API key available for the model
+     */
+    setModel(model: Model<any>): Promise<void>;
+    /**
+     * Restore a model from session history without appending a new model-change
+     * entry or changing default settings.
+     */
+    restoreModel(model: Model<any>): Promise<void>;
+    /**
+     * Restore thinking state while switching/resuming a session.
+     *
+     * When the session has an explicit thinking entry, use the normal setter so
+     * clamping and default-setting persistence stay identical to user-driven changes.
+     * When the session has no entry, seed the session history from the configured
+     * default without changing the configured default itself.
+     */
+    restoreThinkingLevel(options: {
+        hasThinkingEntry: boolean;
+        sessionThinkingLevel: ThinkingLevel;
+        defaultThinkingLevel: ThinkingLevel;
+    }): void;
+    /**
+     * Cycle to next/previous model. Uses scoped models if available, otherwise all available models.
+     * @returns The new model info, or undefined if only one model available
+     */
+    cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
+    private _getScopedModelsWithApiKey;
+    private _cycleScopedModel;
+    private _cycleAvailableModel;
+    /**
+     * Set thinking level, clamped to model capabilities. Saves to session and settings
+     * only if the level actually changes.
+     */
+    setThinkingLevel(level: ThinkingLevel): void;
+    /** Set the session-level agent loop framework override. */
+    setAgentLoopFramework(framework: AgentLoopFrameworkInput | undefined): void;
+    /** Update runtime loop policy options for subsequent turns. */
+    setLoopPolicy(options: Partial<AgentLoopPolicyOptions>): void;
+    /** Cycle to next thinking level. @returns new level, or undefined if model doesn't support thinking. */
+    cycleThinkingLevel(): ThinkingLevel | undefined;
+    /** Thinking levels available for the current model. */
+    getAvailableThinkingLevels(): ThinkingLevel[];
+    /** Whether the current model supports xhigh thinking. */
+    supportsXhighThinking(): boolean;
+    /** Whether the current model supports thinking/reasoning. */
+    supportsThinking(): boolean;
+}

package/dist/core/runtime/model-controller.js

@@ -0,0 +1 @@
+var u=Object.defineProperty;var d=(h,e)=>u(h,"name",{value:e,configurable:!0});import{modelsAreEqual as g}from"@catui/ai/models";import{nextCyclicIndex as p,pickThinkingLevelOnModelChange as k}from"./model-cycle.js";import{availableThinkingLevels as M,clampThinkingLevel as v,modelSupportsThinking as y,modelSupportsXhigh as f,nextThinkingLevel as L}from"./thinking-levels.js";class x extends Error{static{d(this,"CycleModelError")}provider;code;constructor(e,t,i){super(e),this.provider=t,this.code=i,this.name="CycleModelError"}}class C{static{d(this,"ModelController")}ctx;constructor(e){this.ctx=e}async _emitModelSelect(e,t,i){g(t,e)||await this.ctx.emitModelSelect({model:e,previousModel:t,source:i})}async _applyModelChange(e,t,i){const n=this.ctx.getModel();this.ctx.setAgentModel(e),this.ctx.appendModelChange(e.provider,e.id),this.ctx.setDefaultModelAndProvider(e.provider,e.id);const l=i??k(e,this.ctx.getThinkingLevel());this.setThinkingLevel(l),await this._emitModelSelect(e,n,t)}async setModel(e){if(!await this.ctx.getApiKey(e))throw new Error(`No API key for ${e.provider}/${e.id}`);await this._applyModelChange(e,"set")}async restoreModel(e){const t=this.ctx.getModel();this.ctx.setAgentModel(e),await this._emitModelSelect(e,t,"restore")}restoreThinkingLevel(e){if(e.hasThinkingEntry){this.setThinkingLevel(e.sessionThinkingLevel);return}const t=this.getAvailableThinkingLevels(),i=t.includes(e.defaultThinkingLevel)?e.defaultThinkingLevel:v(e.defaultThinkingLevel,t);this.ctx.setAgentThinkingLevel(i),this.ctx.appendThinkingLevelChange(i)}async cycleModel(e="forward"){return this.ctx.getScopedModels().length>0?this._cycleScopedModel(e):this._cycleAvailableModel(e)}async _getScopedModelsWithApiKey(){const e=new Map,t=[];for(const i of this.ctx.getScopedModels()){const n=i.model.provider;let l;e.has(n)?l=e.get(n):(l=await this.ctx.getApiKeyForProvider(n),e.set(n,l)),l&&t.push(i)}return t}async _cycleScopedModel(e){const t=await this._getScopedModelsWithApiKey();if(t.length<=1)return;const i=this.ctx.getModel();let n=t.findIndex(c=>g(c.model,i));n===-1&&(n=0);const l=p(n,t.length,e),o=t[l];return await this._applyModelChange(o.model,"cycle",o.thinkingLevel),{model:o.model,thinkingLevel:this.ctx.getThinkingLevel(),isScoped:!0}}async _cycleAvailableModel(e){const t=await this.ctx.getAvailableModels();if(t.length<=1)return;const i=this.ctx.getModel();let n=t.findIndex(s=>g(s,i));n===-1&&(n=0);const l=t.length;let o=n,c=0,r,a;for(;c<l-1;){c++,o=p(o,l,e);const s=t[o];if(s&&(a=await this.ctx.getApiKey(s),a)){r=s;break}}if(!r||!a){const s=i?.provider;throw(s?this.ctx.getAuthCredential(s):void 0)?.type==="oauth"?new x(`All available models have expired OAuth tokens. Use /login ${s} to re-authenticate.`,s,"oauth_expired"):new x("No models with valid API keys available",s,"no_valid_key")}return await this._applyModelChange(r,"cycle"),{model:r,thinkingLevel:this.ctx.getThinkingLevel(),isScoped:!1}}setThinkingLevel(e){const t=this.getAvailableThinkingLevels(),i=t.includes(e)?e:v(e,t),n=i!==this.ctx.getThinkingLevel();this.ctx.setAgentThinkingLevel(i),n&&(this.ctx.appendThinkingLevelChange(i),this.ctx.setDefaultThinkingLevel(i))}setAgentLoopFramework(e){this.ctx.setAgentLoopFramework(e)}setLoopPolicy(e){this.ctx.setLoopPolicy(e)}cycleThinkingLevel(){const e=L(this.ctx.getThinkingLevel(),this.ctx.getModel());if(e!==void 0)return this.setThinkingLevel(e),e}getAvailableThinkingLevels(){return M(this.ctx.getModel())}supportsXhighThinking(){return f(this.ctx.getModel())}supportsThinking(){return y(this.ctx.getModel())}}export{x as CycleModelError,C as ModelController};

package/dist/core/runtime/model-cycle.d.ts

@@ -0,0 +1,20 @@
+/**
+ * [WHO]: Provides pickThinkingLevelOnModelChange(), nextCyclicIndex() — pure model-cycle decisions
+ * [FROM]: Depends on @catui/ai (Model), @catui/agent-core (ThinkingLevel)
+ * [TO]: Consumed by core/runtime/model-controller.ts model switching/cycling
+ * [HERE]: core/runtime/model-cycle.ts - stateless model-cycle logic, no session state
+ *
+ * Extracted from AgentSession: the pure decisions in setModel / cycleModel. The side-effecting
+ * apply sequence (agent.setModel, persistence, emit) stays in the session.
+ */
+import type { Model } from "@catui/ai/types";
+import type { ThinkingLevel } from "@catui/agent-core";
+/**
+ * Thinking level to use after switching to `model`, given the current level:
+ * - model without reasoning → "off"
+ * - reasoning model but currently "off" → "medium" (sensible default)
+ * - otherwise keep the current level (the provider clamps to capabilities)
+ */
+export declare function pickThinkingLevelOnModelChange(model: Model<any>, currentLevel: ThinkingLevel): ThinkingLevel;
+/** Next index when cycling through a list of length `length`. */
+export declare function nextCyclicIndex(currentIndex: number, length: number, direction: "forward" | "backward"): number;

package/dist/core/runtime/model-cycle.js

@@ -0,0 +1 @@
+var r=Object.defineProperty;var f=(i,n)=>r(i,"name",{value:n,configurable:!0});function t(i,n){return i.reasoning?n==="off"?"medium":n:"off"}f(t,"pickThinkingLevelOnModelChange");function u(i,n,o){return o==="forward"?(i+1)%n:(i-1+n)%n}f(u,"nextCyclicIndex");export{u as nextCyclicIndex,t as pickThinkingLevelOnModelChange};

package/dist/core/runtime/prompt-assembly.d.ts

@@ -0,0 +1,20 @@
+/**
+ * [WHO]: Provides buildRuntimeSystemPrompt(), getActiveBaseToolNames()
+ * [FROM]: Depends on ResourceLoader for loaded prompts/context and prompt/system-prompt for rendering
+ * [TO]: Consumed by core/runtime/agent-session.ts when refreshing the agent system prompt
+ * [HERE]: core/runtime/prompt-assembly.ts - prompt input assembly extracted from AgentSession
+ *
+ * Extracted from AgentSession (P4.5). This module owns prompt resource assembly only.
+ * Soul injection state and prompt application remain in AgentSession.
+ */
+import type { AgentTool } from "@catui/agent-core";
+import type { ResourceLoader } from "../platform/config/resource-loader.js";
+export interface RuntimeSystemPromptOptions {
+    cwd: string;
+    resourceLoader: ResourceLoader;
+    toolNames: string[];
+    baseToolRegistry: Map<string, AgentTool>;
+    soulInjection?: string;
+}
+export declare function buildRuntimeSystemPrompt(options: RuntimeSystemPromptOptions): string;
+export declare function getActiveBaseToolNames(activeToolNames: string[], baseToolRegistry: Map<string, AgentTool>): string[];

package/dist/core/runtime/prompt-assembly.js

@@ -0,0 +1,3 @@
+var m=Object.defineProperty;var s=(e,t)=>m(e,"name",{value:t,configurable:!0});import{buildSystemPrompt as n}from"../prompt/system-prompt.js";function d(e){const t=e.toolNames.filter(l=>e.baseToolRegistry.has(l)),r=e.resourceLoader.getAppendSystemPrompt(),o=r.length>0?r.join(`
+
+`):void 0;return n({cwd:e.cwd,skills:e.resourceLoader.getSkills().skills,contextFiles:e.resourceLoader.getAgentsFiles().agentsFiles,customPrompt:e.resourceLoader.getSystemPrompt(),appendSystemPrompt:o,selectedTools:t,soulInjection:e.soulInjection})}s(d,"buildRuntimeSystemPrompt");function u(e,t){return e.filter(r=>t.has(r))}s(u,"getActiveBaseToolNames");export{d as buildRuntimeSystemPrompt,u as getActiveBaseToolNames};

package/dist/core/runtime/retry-coordinator.d.ts

@@ -0,0 +1,84 @@
+/**
+ * [WHO]: RetryCoordinator class, auto-retry with exponential backoff, in-loop retry preparation
+ * [FROM]: Depends on agent-core (AssistantMessage), ai (isContextOverflow), core/runtime/utils/sleep
+ * [TO]: Consumed by core/runtime/agent-session.ts
+ * [HERE]: core/runtime/retry-coordinator.ts - retry orchestration extracted from AgentSession
+ */
+import type { AssistantMessage } from "@catui/ai/types";
+/** Retry settings from SettingsManager */
+export interface RetrySettings {
+    enabled: boolean;
+    maxRetries: number;
+    baseDelayMs: number;
+}
+/** Callbacks the coordinator needs from its host */
+export interface RetryCoordinatorHost {
+    /** Get current model's context window (for overflow detection) */
+    getContextWindow(): number;
+    /** Get current retry settings */
+    getRetrySettings(): RetrySettings;
+    /** Remove the last message from agent state (error cleanup) */
+    removeLastAssistantMessage(): void;
+    /** Trigger agent.continue() for retry */
+    triggerContinue(): void;
+    /** Emit a session event */
+    emitEvent(event: RetrySessionEvent): void;
+}
+/** Events emitted by RetryCoordinator (subset of AgentSessionEvent) */
+export type RetrySessionEvent = {
+    type: "auto_retry_start";
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    errorMessage: string;
+} | {
+    type: "auto_retry_end";
+    success: boolean;
+    attempt: number;
+    finalError?: string;
+};
+/**
+ * RetryCoordinator — manages auto-retry with exponential backoff.
+ * Extracted from AgentSession to isolate retry state and logic.
+ */
+export declare class RetryCoordinator {
+    private _host;
+    private _retryAbortController;
+    private _retryAttempt;
+    private _retryPromise;
+    private _retryResolve;
+    constructor(host: RetryCoordinatorHost);
+    /** Current retry attempt (0 if not retrying) */
+    get attempt(): number;
+    /** Whether a retry is currently in progress */
+    get isActive(): boolean;
+    /**
+     * Check if an assistant message represents a retryable error.
+     * Context overflow errors are NOT retryable (handled by compaction).
+     */
+    isRetryableError(message: AssistantMessage): boolean;
+    /**
+     * Handle a retryable error with exponential backoff.
+     * @returns true if retry was initiated, false if max retries exceeded or disabled
+     */
+    handleError(message: AssistantMessage): Promise<boolean>;
+    /**
+     * Handle a retryable error inside an active agent loop.
+     *
+     * Unlike handleError(), this does not mutate host messages and does not
+     * schedule agent.continue(); the caller remains responsible for replacing
+     * loop context and continuing in-place.
+     */
+    handleErrorInLoop(message: AssistantMessage): Promise<boolean>;
+    private _prepareRetry;
+    /**
+     * Called when an assistant response succeeds — resets retry counter
+     * and resolves the pending retry promise.
+     */
+    onSuccess(): void;
+    /** Abort in-progress retry. */
+    abort(): void;
+    /** Wait for any in-progress retry to complete. */
+    waitForCompletion(): Promise<void>;
+    private _resolveRetry;
+}

package/dist/core/runtime/retry-coordinator.js

@@ -0,0 +1 @@
+var n=Object.defineProperty;var o=(i,t)=>n(i,"name",{value:t,configurable:!0});import{isContextOverflow as a}from"@catui/ai/overflow";import{sleep as y}from"../platform/utils/sleep.js";class d{static{o(this,"RetryCoordinator")}_host;_retryAbortController=void 0;_retryAttempt=0;_retryPromise=void 0;_retryResolve=void 0;constructor(t){this._host=t}get attempt(){return this._retryAttempt}get isActive(){return this._retryPromise!==void 0}isRetryableError(t){if(t.stopReason!=="error"||!t.errorMessage)return!1;const e=this._host.getContextWindow();if(a(t,e))return!1;const r=t.errorMessage;return/insufficient.?balance|insufficient.?quota|quota.?exceeded|credit.?balance|billing|payment required|invalid api key|incorrect api key|unauthorized|unauthenticated|authentication|forbidden|permission denied|access denied|model_not_found|model not found/i.test(r)?!1:/overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay/i.test(r)}async handleError(t){return await this._prepareRetry(t)?(this._host.removeLastAssistantMessage(),this._host.triggerContinue(),!0):!1}async handleErrorInLoop(t){return this._prepareRetry(t)}async _prepareRetry(t){const e=this._host.getRetrySettings();if(!e.enabled)return!1;if(this._retryAttempt++,this._retryAttempt===1&&!this._retryPromise&&(this._retryPromise=new Promise(s=>{this._retryResolve=s})),this._retryAttempt>e.maxRetries)return this._host.emitEvent({type:"auto_retry_end",success:!1,attempt:this._retryAttempt-1,finalError:t.errorMessage}),this._retryAttempt=0,this._resolveRetry(),!1;const r=e.baseDelayMs*2**(this._retryAttempt-1);this._host.emitEvent({type:"auto_retry_start",attempt:this._retryAttempt,maxAttempts:e.maxRetries,delayMs:r,errorMessage:t.errorMessage||"Unknown error"}),this._retryAbortController=new AbortController;try{await y(r,this._retryAbortController.signal)}catch{const s=this._retryAttempt;return this._retryAttempt=0,this._retryAbortController=void 0,this._host.emitEvent({type:"auto_retry_end",success:!1,attempt:s,finalError:"Retry cancelled"}),this._resolveRetry(),!1}return this._retryAbortController=void 0,!0}onSuccess(){this._retryAttempt>0&&(this._host.emitEvent({type:"auto_retry_end",success:!0,attempt:this._retryAttempt}),this._retryAttempt=0,this._resolveRetry())}abort(){this._retryAbortController?.abort(),this._retryAttempt=0,this._resolveRetry()}async waitForCompletion(){this._retryPromise&&await this._retryPromise}_resolveRetry(){this._retryResolve&&(this._retryResolve(),this._retryResolve=void 0,this._retryPromise=void 0)}}export{d as RetryCoordinator};

package/dist/core/runtime/sdk.d.ts

@@ -0,0 +1,163 @@
+import { type AgentLoopFrameworkInput, type AgentLoopPolicyOptions, type ThinkingLevel } from "@catui/agent-core";
+import type { Model } from "@catui/ai/types";
+import { AgentSession } from "./agent-session.js";
+import type { Theme as ThemeContract } from "../theme-contract.js";
+import { AuthStorage } from "../platform/config/auth-storage.js";
+import type { LoadExtensionsResult, ToolDefinition } from "../extensions-host/index.js";
+import { ModelRegistry } from "../model-registry.js";
+import type { ResourceLoader } from "../platform/config/resource-loader.js";
+import { SessionManager } from "../session/session-manager.js";
+import { SettingsManager } from "../platform/config/settings-manager.js";
+import { AgentDirContext } from "../agent-dir/agent-dir-context.js";
+import type { SoulOptionsContract } from "../soul-options-contract.js";
+import { allTools, bashTool, codingTools, createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, editTool, findTool, grepTool, lsTool, readOnlyTools, readTool, type Tool, writeTool } from "../tools/index.js";
+/**
+ * Custom logger interface for SDK users.
+ * Replace console.error/warn/info with user-provided handlers.
+ */
+export interface SDKLogger {
+    error(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+}
+/**
+ * Silent logger - suppresses all output
+ */
+export declare const silentLogger: SDKLogger;
+/**
+ * Default logger - uses console
+ */
+export declare const defaultLogger: SDKLogger;
+export interface CreateAgentSessionOptions extends SoulOptionsContract {
+    /** Working directory for project-local discovery. Default: process.cwd() */
+    cwd?: string;
+    /** Global config directory. Default: ~/.catui/agents/default */
+    agentDir?: string;
+    /** Multi-agent context. */
+    agentCtx?: AgentDirContext;
+    /** Auth storage for credentials. Default: AuthStorage.create(agentDir/auth.json) */
+    authStorage?: AuthStorage;
+    /** Model registry. Default: new ModelRegistry(authStorage, agentDir/models.json) */
+    modelRegistry?: ModelRegistry;
+    /** Model to use. Default: from settings, else first available */
+    model?: Model<any>;
+    /** Thinking level. Default: from settings, else 'medium' (clamped to model capabilities) */
+    thinkingLevel?: ThinkingLevel;
+    /** Session-level agent loop framework override. Default: from settings/model. */
+    agentLoopFramework?: AgentLoopFrameworkInput;
+    /** Optional runtime loop policy overrides applied at session creation. */
+    loopPolicy?: Pick<AgentLoopPolicyOptions, "maxTurnsPerPrompt" | "maxToolCallsPerPrompt" | "maxToolConcurrency" | "maxToolResultBatchSizeChars" | "outputTokenBudget" | "maxOutputTokenRecoveryAttempts" | "maxModelErrorRecoveryAttempts" | "maxStopHookContinuations">;
+    /** Maximum assistant turns allowed for one prompt. */
+    maxTurnsPerPrompt?: number;
+    /** Maximum tool calls allowed for one prompt. */
+    maxToolCallsPerPrompt?: number;
+    /** Maximum concurrent safe tool calls in compatible loops. */
+    maxToolConcurrency?: number;
+    /** Aggregate tool-result batch budget in characters. */
+    maxToolResultBatchSizeChars?: number;
+    /** Optional target for automatic continuation when output is under-complete. */
+    outputTokenBudget?: AgentLoopPolicyOptions["outputTokenBudget"];
+    /** Maximum automatic output-token recovery turns per prompt. */
+    maxOutputTokenRecoveryAttempts?: number;
+    /** Maximum in-loop model error recoveries per prompt. */
+    maxModelErrorRecoveryAttempts?: number;
+    /** Maximum stop-hook validation/correction continuations per prompt. */
+    maxStopHookContinuations?: number;
+    /** Models available for cycling (Ctrl+P in interactive mode) */
+    scopedModels?: Array<{
+        model: Model<any>;
+        thinkingLevel: ThinkingLevel;
+    }>;
+    /** Built-in tools to use. Default: codingTools [read, bash, edit, write] */
+    tools?: Tool[];
+    /** Custom tools to register (in addition to built-in tools). */
+    customTools?: ToolDefinition[];
+    /** Enable MCP (Model Context Protocol) tools. Default: false */
+    enableMCP?: boolean;
+    /**
+     * Defer MCP tool loading off the startup critical path. When true,
+     * createAgentSession does NOT block on MCP server spawn/handshake; the caller
+     * must call `session.warmupMcpTools()` (interactive mode does this in the
+     * background once the UI is ready). When false/omitted, MCP is loaded
+     * synchronously before returning (one-shot modes: print/acp/rpc). Default: false
+     */
+    deferMcpInit?: boolean;
+    /** Resource loader. When omitted, DefaultResourceLoader is used. */
+    resourceLoader?: ResourceLoader;
+    /** Additional directories to search for skills. Appended to default paths. */
+    additionalSkillPaths?: string[];
+    /** Additional directories to search for AGENT.md/CLAUDE.md context files. */
+    additionalAgentDirs?: string[];
+    /** Custom MCP config file path. Overrides default agentDir/mcp.json. */
+    mcpConfigPath?: string;
+    /** Debug event verbosity level. "off" = none, "basic" = lifecycle, "verbose" = all. Default: "off" */
+    debugLevel?: "off" | "basic" | "verbose";
+    /** Session manager. Default: SessionManager.create(cwd) */
+    sessionManager?: SessionManager;
+    /** Settings manager. Default: SettingsManager.create(cwd, agentDir) */
+    settingsManager?: SettingsManager;
+    /** External abort signal for stopping the session (e.g., from SubAgent runtime) */
+    signal?: AbortSignal;
+    /**
+     * Theme for HTML-export custom-tool rendering. Provided by the composition root
+     * (UI layer); when omitted, HTML export skips custom-tool rendering. Keeps
+     * core/runtime free of a modes/ UI import (U2 seam).
+     */
+    theme?: ThemeContract;
+    /** Suppress all console output. Default: false */
+    silent?: boolean;
+    /** Custom logger for SDK output. Default: console */
+    logger?: SDKLogger;
+}
+/** Result from createAgentSession */
+export interface CreateAgentSessionResult {
+    /** The created session */
+    session: AgentSession;
+    /** Extensions result (for UI context setup in interactive mode) */
+    extensionsResult: LoadExtensionsResult;
+    /** Warning if session was restored with a different model than saved */
+    modelFallbackMessage?: string;
+    /** Soul manager for AI personality (if enabled) */
+    soulManager?: any;
+}
+export type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ExtensionFactory, SlashCommandInfo, SlashCommandLocation, SlashCommandSource, ToolDefinition, } from "../extensions-host/index.js";
+export type { PromptTemplate } from "../prompt/prompt-templates.js";
+export type { Skill } from "../skills.js";
+export type { Tool } from "../tools/index.js";
+export { readTool, bashTool, editTool, writeTool, grepTool, findTool, lsTool, codingTools, readOnlyTools, allTools as allBuiltInTools, createCodingTools, createReadOnlyTools, createReadTool, createBashTool, createEditTool, createWriteTool, createGrepTool, createFindTool, createLsTool, };
+/**
+ * Create an AgentSession with the specified options.
+ *
+ * @example
+ * ```typescript
+ * // Minimal - uses defaults
+ * const { session } = await createAgentSession();
+ *
+ * // With explicit model
+ * import { getModel } from '@catui/ai/models';
+ * const { session } = await createAgentSession({
+ *   model: getModel('anthropic', 'claude-opus-4-5'),
+ *   thinkingLevel: 'high',
+ * });
+ *
+ * // Continue previous session
+ * const { session, modelFallbackMessage } = await createAgentSession({
+ *   continueSession: true,
+ * });
+ *
+ * // Full control
+ * const loader = new DefaultResourceLoader({
+ *   cwd: process.cwd(),
+ *   agentDir: getAgentDir(),
+ *   settingsManager: SettingsManager.create(),
+ * });
+ * await loader.reload();
+ * const { session } = await createAgentSession({
+ *   model: myModel,
+ *   tools: [readTool, bashTool],
+ *   resourceLoader: loader,
+ *   sessionManager: SessionManager.inMemory(),
+ * });
+ * ```
+ */
+export declare function createAgentSession(options?: CreateAgentSessionOptions): Promise<CreateAgentSessionResult>;

package/dist/core/runtime/sdk.js

@@ -0,0 +1 @@
+var Q=Object.defineProperty;var n=(e,s)=>Q(e,"name",{value:s,configurable:!0});import{join as E}from"node:path";import{Agent as X}from"@catui/agent-core";import{getAgentDir as Y,getDocsPath as Z}from"../../config.js";import{AgentSession as ee}from"./agent-session.js";import{AuthStorage as te}from"../platform/config/auth-storage.js";import{DEFAULT_THINKING_LEVEL as B}from"../platform/config/defaults.js";import{convertToLlm as oe}from"../messages.js";import{MCPManager as re}from"../mcp/mcp-manager.js";import{registerFigmaMcpOAuthProvider as ne}from"../mcp/figma-auth.js";import{ModelRegistry as le}from"../model-registry.js";import{findInitialModel as ae}from"../model-resolver.js";import{DefaultResourceLoader as ie}from"../platform/config/resource-loader.js";import{SessionManager as se}from"../session/session-manager.js";import{SettingsManager as F}from"../platform/config/settings-manager.js";import{defaultAgentDirContext as ce}from"../agent-dir/agent-dir-context.js";import{time as v}from"../platform/timings.js";import{isSoulEnabled as de,createSoulManager as z}from"../soul-integration.js";import{allTools as O,bashTool as ge,codingTools as me,createBashTool as ue,createCodingTools as fe,createEditTool as pe,createFindTool as he,createGrepTool as Te,createLsTool as ve,createReadOnlyTools as ye,createReadTool as xe,createWriteTool as Se,editTool as Me,findTool as Pe,grepTool as we,lsTool as ke,readOnlyTools as Ce,readTool as Ae,writeTool as Le}from"../tools/index.js";const be={error:n(()=>{},"error"),warn:n(()=>{},"warn"),info:n(()=>{},"info")},Re={error:n((e,...s)=>console.error(e,...s),"error"),warn:n((e,...s)=>console.warn(e,...s),"warn"),info:n((e,...s)=>console.log(e,...s),"info")};function $e(e,s,w){if(e instanceof F)return e;const a=F.create(s,w);if(!e||typeof e!="object"||typeof e.getSettings!="function")return a;const g=a;for(const c of Object.keys(e)){const p=e[c];typeof p=="function"&&(g[c]=p.bind(e))}return a}n($e,"normalizeSettingsManager");function Ye(){return Y()}n(Ye,"getDefaultAgentDir");async function De(e={}){ne();const s=typeof import.meta.url=="string"&&import.meta.url.includes("node_modules"),w=process.env.NODE_ENV==="production"||process.env.NODE_ENV!=="development"&&s,a=e.silent?be:e.logger??Re,g=e.cwd??process.cwd(),c=e.agentCtx??ce(),p=e.agentDir??c.path;let y=e.resourceLoader;const r=$e(e.settingsManager,g,c),N=r.getSettings().locale??"en",{setLocale:j}=await import("../platform/i18n/index.js");j(N);const _=e.authStorage??te.create(c),U=E(p,"models.json"),h=e.modelRegistry??new le(_,U),m=e.sessionManager??se.create(g,void 0,c);y||(y=new ie({cwd:g,agentDir:p,settingsManager:r,agentCtx:c,additionalSkillPaths:e.additionalSkillPaths,additionalAgentDirs:e.additionalAgentDirs}),await y.reload(),v("resourceLoader.reload"));const d=m.buildSessionContext(),P=d.messages.length>0,L=m.getBranch().some(t=>t.type==="thinking_level_change");let l=e.model,x;if(!l&&P&&d.model){const t=h.find(d.model.provider,d.model.modelId);t&&await h.getApiKey(t)&&(l=t),l||(x=`Could not restore model ${d.model.provider}/${d.model.modelId}`)}l||(l=(await ae({scopedModels:[],isContinuing:P,defaultProvider:r.getDefaultProvider(),defaultModelId:r.getDefaultModel(),defaultThinkingLevel:r.getDefaultThinkingLevel(),modelRegistry:h})).model,l?x&&(x+=`. Using ${l.provider}/${l.id}`):x=`No models available. Use /login or set an API key environment variable. See ${E(Z(),"providers.md")}. Then use /model to select a model.`);let u;e.thinkingLevel!==void 0?u=e.thinkingLevel:P?u=L?d.thinkingLevel:r.getDefaultThinkingLevel()??B:u=r.getDefaultThinkingLevel()??B,(!l||!l.reasoning)&&(u="off");const H=["read","bash","edit","write"],K=e.tools?e.tools.map(t=>t.name).filter(t=>t in O):H;let S;const V=n(t=>{const o=oe(t);return r.getBlockImages()?o.map(i=>{if(i.role==="user"||i.role==="toolResult"){const T=i.content;if(Array.isArray(T)&&T.some(C=>C.type==="image")){const C=T.map(M=>M.type==="image"?{type:"text",text:"Image reading is disabled."}:M).filter((M,A,I)=>!(M.type==="text"&&M.text==="Image reading is disabled."&&A>0&&I[A-1].type==="text"&&I[A-1].text==="Image reading is disabled."));return{...i,content:C}}}return i}):o},"convertToLlmWithBlockImages"),b={};S=new X({initialState:{systemPrompt:"",model:l,thinkingLevel:u,tools:[]},convertToLlm:V,sessionId:m.getSessionId(),transformContext:n(async t=>{const o=b.current;return o?o.emitContext(t):t},"transformContext"),steeringMode:r.getSteeringMode(),followUpMode:r.getFollowUpMode(),transport:r.getTransport(),agentLoopFramework:e.agentLoopFramework??r.getAgentLoopFramework(),thinkingBudgets:r.getThinkingBudgets(),maxRetryDelayMs:r.getRetrySettings().maxDelayMs,maxToolResultBatchSizeChars:e.maxToolResultBatchSizeChars??e.loopPolicy?.maxToolResultBatchSizeChars??r.getAgentLoopSettings().maxToolResultBatchSizeChars,maxToolConcurrency:e.maxToolConcurrency??e.loopPolicy?.maxToolConcurrency,maxTurnsPerPrompt:e.maxTurnsPerPrompt??e.loopPolicy?.maxTurnsPerPrompt,maxToolCallsPerPrompt:e.maxToolCallsPerPrompt??e.loopPolicy?.maxToolCallsPerPrompt,outputTokenBudget:e.outputTokenBudget??e.loopPolicy?.outputTokenBudget,maxOutputTokenRecoveryAttempts:e.maxOutputTokenRecoveryAttempts??e.loopPolicy?.maxOutputTokenRecoveryAttempts,maxModelErrorRecoveryAttempts:e.maxModelErrorRecoveryAttempts??e.loopPolicy?.maxModelErrorRecoveryAttempts,maxStopHookContinuations:e.maxStopHookContinuations??e.loopPolicy?.maxStopHookContinuations,getApiKey:n(async t=>{const o=t||S.state.model?.provider;if(!o)throw new Error("No model selected");const i=await h.getApiKeyForProvider(o);if(!i){const T=S.state.model;throw T&&h.isUsingOAuth(T)?new Error(`Authentication failed for "${o}". Credentials may have expired or network is unavailable. Run '/login ${o}' to re-authenticate.`):new Error(`No API key found for "${o}". Set an API key environment variable or run '/login ${o}'.`)}return i},"getApiKey")}),P?(S.replaceMessages(d.messages),L||m.appendThinkingLevelChange(u)):(l&&m.appendModelChange(l.provider,l.id),m.appendThinkingLevelChange(u)),v("agent.construct");let f;const W=[],G=e.customTools??[];let R;e.enableMCP&&(process.once("exit",()=>f?.dispose()),R=n(async()=>{try{f?.dispose()}catch{}f=new re({mcpConfigPath:e.mcpConfigPath}),f.setWorkingDir(g),await f.initialize(),v("mcp.initialize");const t=f.getStatus();if(w){const o=t.startedServers,i=t.failedServers;o.length>0&&a.info(`MCP: ${o.length} server(s) ready (${o.join(", ")})`),i.length>0&&a.warn(`MCP: ${i.length} failed (${i.join(", ")})`)}else if(t.toolCount===0){const o=t.failedServers.length>0?` failed=${t.failedServers.join(",")}`:"";a.warn(`MCP enabled but no tools loaded (enabled=${t.enabledServers.length}, started=${t.startedServers.length}, tools=0).${o}`)}else a.info(`MCP tools loaded: ${t.toolCount}`),t.failedServers.length>0&&a.warn(`MCP: ${t.failedServers.length} server(s) failed to start (${t.failedServers.join(", ")}); tools from other servers are still available.`);return f.getTools()},"mcpToolsFactory"));let k,$;if(de(e)){try{const t=await z(c);t?(k=t,await t.initialize(),v("soul.initialize")):a.warn("Soul not available (nanosoul package not installed). Skipping...")}catch(t){a.warn(`Failed to initialize Soul: ${t}`)}$=n(async()=>{try{const t=await z(c);return t?(await t.initialize(),v("soul.initialize"),t):null}catch(t){return a.warn(`Failed to refresh Soul: ${t}`),null}},"soulManagerFactory")}const D=new ee({agent:S,sessionManager:m,settingsManager:r,cwd:g,agentDir:p,agentCtx:c,scopedModels:e.scopedModels,resourceLoader:y,customTools:G,initialMcpTools:W,mcpToolsFactory:R,modelRegistry:h,initialActiveToolNames:K,extensionRunnerRef:b,soulManager:k,soulManagerFactory:$,signal:e.signal,theme:e.theme,createSession:De,debugLevel:e.debugLevel});v("session.construct"),e.enableMCP&&!e.deferMcpInit&&await D.warmupMcpTools();const q=y.getExtensions();return{session:D,extensionsResult:q,modelFallbackMessage:x,soulManager:k}}n(De,"createAgentSession");export{O as allBuiltInTools,ge as bashTool,me as codingTools,De as createAgentSession,ue as createBashTool,fe as createCodingTools,pe as createEditTool,he as createFindTool,Te as createGrepTool,ve as createLsTool,ye as createReadOnlyTools,xe as createReadTool,Se as createWriteTool,Re as defaultLogger,Me as editTool,Pe as findTool,we as grepTool,ke as lsTool,Ce as readOnlyTools,Ae as readTool,be as silentLogger,Le as writeTool};

package/dist/core/runtime/session-context.d.ts

@@ -0,0 +1,155 @@
+/**
+ * [WHO]: Provides ScopedModel, ModelSelectPayload, and runtime controller context contracts
+ * [FROM]: Depends on agent-core and ai public types, auth-storage credential type, session entry type,
+ *         and the extension runner type
+ * [TO]: Consumed by core/runtime/*-controller.ts; implemented by AgentSession through capability adapters
+ * [HERE]: core/runtime/session-context.ts - S2 seam: narrow capability contracts for runtime controllers
+ *
+ * Controllers depend on capability functions rather than AgentSession, Agent, SessionManager,
+ * SettingsManager, ModelRegistry, or ExtensionRunner objects. This keeps extraction from turning
+ * into a service locator while preserving one-directional imports.
+ */
+import type { AgentLoopFrameworkInput, AgentLoopPolicyOptions, AgentMessage, ThinkingLevel } from "@catui/agent-core";
+import type { Model } from "@catui/ai/types";
+import type { CompactionResult } from "../session/compaction/index.js";
+import type { ExtensionRunner } from "../extensions-host/index.js";
+import type { AuthCredential } from "../platform/config/auth-storage.js";
+import type { SessionContext, SessionEntry, SessionManager } from "../session/session-manager.js";
+/** Scoped model entry (from --models): a model plus its preferred thinking level. */
+export interface ScopedModel {
+    model: Model<any>;
+    thinkingLevel: ThinkingLevel;
+}
+export interface ModelSelectPayload {
+    model: Model<any>;
+    previousModel?: Model<any>;
+    source: "set" | "cycle" | "restore";
+}
+/** Narrow capability surface for ModelController. */
+export interface ModelControllerContext {
+    getModel(): Model<any> | undefined;
+    getThinkingLevel(): ThinkingLevel;
+    getScopedModels(): ReadonlyArray<ScopedModel>;
+    setAgentModel(model: Model<any>): void;
+    setAgentThinkingLevel(level: ThinkingLevel): void;
+    setAgentLoopFramework(framework: AgentLoopFrameworkInput | undefined): void;
+    setLoopPolicy(options: Partial<AgentLoopPolicyOptions>): void;
+    getApiKey(model: Model<any>): Promise<string | undefined>;
+    getApiKeyForProvider(provider: string): Promise<string | undefined>;
+    getAvailableModels(): Promise<Model<any>[]>;
+    getAuthCredential(provider: string): AuthCredential | undefined;
+    appendModelChange(provider: string, modelId: string): void;
+    appendThinkingLevelChange(level: ThinkingLevel): void;
+    setDefaultModelAndProvider(provider: string, modelId: string): void;
+    setDefaultThinkingLevel(level: ThinkingLevel): void;
+    emitModelSelect(payload: ModelSelectPayload): Promise<void>;
+}
+/** Compaction settings the pipeline reads (mirrors SettingsManager.getCompactionSettings). */
+export interface CompactionSettings {
+    enabled: boolean;
+    reserveTokens: number;
+    keepRecentTokens: number;
+}
+/**
+ * Narrow capability surface for CompactionController. Manual compaction must disconnect the agent,
+ * abort the active turn, rebuild messages after summarizing, and reconnect — those lifecycle
+ * effects are exposed as capabilities rather than handing over the AgentSession.
+ */
+export interface CompactionControllerContext {
+    getModel(): Model<any> | undefined;
+    getApiKey(model: Model<any>): Promise<string | undefined>;
+    getExtensionRunner(): ExtensionRunner | undefined;
+    getBranch(): SessionEntry[];
+    getEntries(): SessionEntry[];
+    getCompactionSettings(): CompactionSettings;
+    appendCompaction(summary: string, firstKeptEntryId: string, tokensBefore: number, details: unknown, fromExtension: boolean): void;
+    /** Rebuild agent messages from the (post-compaction) session context; returns the new messages. */
+    applyCompactedMessages(): AgentMessage[];
+    logInfo(message: string, meta?: Record<string, unknown>): void;
+    /** Detach the agent-event subscription before compacting (manual only). */
+    disconnectFromAgent(): void;
+    /** Re-attach the agent-event subscription after compacting (manual only). */
+    reconnectToAgent(): void;
+    /** Abort the in-flight agent turn before compacting (manual only). */
+    abortAgent(): Promise<void>;
+    emitAutoCompactionStart(reason: "overflow" | "threshold"): void;
+    emitAutoCompactionEnd(payload: {
+        result: CompactionResult | undefined;
+        aborted: boolean;
+        willRetry: boolean;
+        errorMessage?: string;
+    }): void;
+    getAutoCompactionEnabled(): boolean;
+    setAutoCompactionEnabled(enabled: boolean): void;
+}
+/**
+ * Narrow capability surface for SessionTreeController (navigateTree + branch summary). Tree
+ * navigation reads/mutates the session tree and may summarize the abandoned branch; those effects
+ * are exposed as capabilities rather than handing over the AgentSession or SessionManager.
+ */
+export interface SessionTreeControllerContext {
+    getModel(): Model<any> | undefined;
+    getApiKey(model: Model<any>): Promise<string | undefined>;
+    getExtensionRunner(): ExtensionRunner | undefined;
+    getLeafId(): string | null;
+    getEntry(entryId: string): SessionEntry | undefined;
+    collectBranchSummaryEntries(oldLeafId: string | null, targetId: string): {
+        entries: SessionEntry[];
+        commonAncestorId: string | null;
+    };
+    getBranchSummaryReserveTokens(): number;
+    branchWithSummary(newLeafId: string | null, summaryText: string, summaryDetails: unknown, fromExtension: boolean): string;
+    appendLabelChange(entryId: string, label: string): void;
+    resetLeaf(): void;
+    branch(newLeafId: string): void;
+    /** Rebuild agent messages from the (post-navigation) session context. */
+    rebuildAgentMessages(): void;
+    extractUserMessageText(content: string | Array<{
+        type: string;
+        text?: string;
+    }>): string;
+}
+/** Inputs for restoring thinking level when resuming a session (mirrors ModelController). */
+export interface ThinkingRestore {
+    hasThinkingEntry: boolean;
+    sessionThinkingLevel: ThinkingLevel;
+    defaultThinkingLevel: ThinkingLevel;
+}
+/**
+ * Narrow capability surface for SessionLifecycleController (new / switch / fork — identity-change
+ * choreography). The agent subscription teardown/reset, pending-queue clearing, and model/thinking
+ * restore are exposed as capabilities; restore is delegated to ModelController by the host adapter.
+ */
+export interface SessionLifecycleControllerContext {
+    getSessionFile(): string | undefined;
+    getExtensionRunner(): ExtensionRunner | undefined;
+    disconnectFromAgent(): void;
+    reconnectToAgent(): void;
+    abortAgent(): Promise<void>;
+    resetAgent(): void;
+    /** agent.sessionId = sessionManager.getSessionId() */
+    syncAgentSessionId(): void;
+    /** Clear steering / follow-up / pending-next-turn queues (session-owned). */
+    clearPendingQueues(): void;
+    /** Clear only the next-turn queue when forking; steering/follow-up queues are not part of fork behavior. */
+    clearPendingNextTurnMessages(): void;
+    sessionNewSession(parentSession: string | undefined): void;
+    sessionSetFile(path: string): void;
+    sessionCreateBranchedSession(parentId: string): void;
+    getEntry(entryId: string): SessionEntry | undefined;
+    buildSessionContext(): SessionContext;
+    replaceAgentMessages(messages: SessionContext["messages"]): void;
+    appendThinkingLevelChange(level: ThinkingLevel): void;
+    getThinkingLevel(): ThinkingLevel;
+    getBranch(): SessionEntry[];
+    /** Default thinking level with the built-in fallback already applied. */
+    getDefaultThinkingLevel(): ThinkingLevel;
+    getAvailableModels(): Model<any>[];
+    restoreModel(model: Model<any>): Promise<void>;
+    restoreThinkingLevel(opts: ThinkingRestore): void;
+    runSetup(setup: (sessionManager: SessionManager) => Promise<void>): Promise<void>;
+    extractUserMessageText(content: string | Array<{
+        type: string;
+        text?: string;
+    }>): string;
+}

package/dist/core/runtime/session-lifecycle-controller.d.ts

@@ -0,0 +1,42 @@
+/**
+ * [WHO]: Provides SessionLifecycleController — session identity-change choreography
+ * [FROM]: Depends on agent-core (ThinkingLevel), extensions-host session hook result types,
+ *         session-manager (SessionManager type), and ./session-context
+ * [TO]: Consumed by core/runtime/agent-session.ts (constructs one, delegates newSession()/switchSession()/fork())
+ * [HERE]: core/runtime/agent-session.ts split (AS08) — session identity transitions
+ *
+ * Extracted from AgentSession (AS08/AS11). Owns the new/switch/fork choreography: before/after extension
+ * hooks, agent disconnect/abort/reset, pending-queue clearing, session-manager transition, message
+ * rebuild, and (on resume) model/thinking restoration delegated through the context to
+ * ModelController. Behavior is identical to the former AgentSession methods.
+ */
+import type { SessionManager } from "../session/session-manager.js";
+import type { SessionLifecycleControllerContext } from "./session-context.js";
+export interface NewSessionOptions {
+    parentSession?: string;
+    setup?: (sessionManager: SessionManager) => Promise<void>;
+}
+export interface ForkResult {
+    selectedText: string;
+    cancelled: boolean;
+}
+export declare class SessionLifecycleController {
+    private readonly ctx;
+    constructor(ctx: SessionLifecycleControllerContext);
+    /**
+     * Start a new session, optionally with initial messages and parent tracking.
+     * Listeners are preserved and continue receiving events.
+     * @returns true if completed, false if cancelled by an extension
+     */
+    newSession(options?: NewSessionOptions): Promise<boolean>;
+    /**
+     * Resume an existing session file: restore messages, model, and thinking level.
+     * @returns true if completed, false if cancelled by an extension
+     */
+    switchSession(sessionPath: string): Promise<boolean>;
+    /**
+     * Create a new session identity from a user-message branch point.
+     * @returns selected user text plus cancellation state
+     */
+    fork(entryId: string): Promise<ForkResult>;
+}

package/dist/core/runtime/session-lifecycle-controller.js

@@ -0,0 +1 @@
+var h=Object.defineProperty;var l=(a,s)=>h(a,"name",{value:s,configurable:!0});class g{static{l(this,"SessionLifecycleController")}ctx;constructor(s){this.ctx=s}async newSession(s){const i=this.ctx.getSessionFile(),e=this.ctx.getExtensionRunner();if(e?.hasHandlers("session_before_switch")&&(await e.emit({type:"session_before_switch",reason:"new"}))?.cancel)return!1;if(this.ctx.disconnectFromAgent(),await this.ctx.abortAgent(),this.ctx.resetAgent(),this.ctx.sessionNewSession(s?.parentSession),this.ctx.syncAgentSessionId(),this.ctx.clearPendingQueues(),this.ctx.appendThinkingLevelChange(this.ctx.getThinkingLevel()),s?.setup){await this.ctx.runSetup(s.setup);const t=this.ctx.buildSessionContext();this.ctx.replaceAgentMessages(t.messages)}return this.ctx.reconnectToAgent(),e&&await e.emit({type:"session_switch",reason:"new",previousSessionFile:i}),!0}async switchSession(s){const i=this.ctx.getSessionFile(),e=this.ctx.getExtensionRunner();if(e?.hasHandlers("session_before_switch")&&(await e.emit({type:"session_before_switch",reason:"resume",targetSessionFile:s}))?.cancel)return!1;this.ctx.disconnectFromAgent(),await this.ctx.abortAgent(),this.ctx.clearPendingQueues(),this.ctx.sessionSetFile(s),this.ctx.syncAgentSessionId();const t=this.ctx.buildSessionContext();if(e&&await e.emit({type:"session_switch",reason:"resume",previousSessionFile:i}),this.ctx.replaceAgentMessages(t.messages),t.model){const r=this.ctx.getAvailableModels().find(o=>o.provider===t.model.provider&&o.id===t.model.modelId);r&&await this.ctx.restoreModel(r)}const c=this.ctx.getBranch().some(n=>n.type==="thinking_level_change");return this.ctx.restoreThinkingLevel({hasThinkingEntry:c,sessionThinkingLevel:t.thinkingLevel,defaultThinkingLevel:this.ctx.getDefaultThinkingLevel()}),this.ctx.reconnectToAgent(),!0}async fork(s){const i=this.ctx.getSessionFile(),e=this.ctx.getEntry(s);if(!e||e.type!=="message"||e.message.role!=="user")throw new Error("Invalid entry ID for forking");const t=this.ctx.extractUserMessageText(e.message.content);let c=!1;const n=this.ctx.getExtensionRunner();if(n?.hasHandlers("session_before_fork")){const o=await n.emit({type:"session_before_fork",entryId:s});if(o?.cancel)return{selectedText:t,cancelled:!0};c=o?.skipConversationRestore??!1}this.ctx.clearPendingNextTurnMessages(),e.parentId?this.ctx.sessionCreateBranchedSession(e.parentId):this.ctx.sessionNewSession(i),this.ctx.syncAgentSessionId();const r=this.ctx.buildSessionContext();return n&&await n.emit({type:"session_fork",previousSessionFile:i}),c||this.ctx.replaceAgentMessages(r.messages),{selectedText:t,cancelled:!1}}}export{g as SessionLifecycleController};