indusagi 0.12.13 → 0.12.16

package/dist/agent/agent-session.js

@@ -0,0 +1,870 @@
+/**
+ * AgentSession - Core orchestration layer for agent lifecycle and session management.
+ *
+ * This is the main entry point for agent operations, providing:
+ * - Event subscription and emission
+ * - Model and thinking level management
+ * - Compaction and retry logic
+ * - Extension system integration
+ * - Bash execution
+ * - Session management (fork, navigate, export)
+ *
+ * Adapted from PI-MONO coding-agent (3,044 lines).
+ */
+import { Agent } from "./agent.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
+import { AgentEventBus } from "./event-bus.js";
+import { compact, prepareCompaction, shouldCompact, isContextOverflow, calculateContextTokens, estimateContextTokens, getLatestCompactionEntry, } from "./compaction/index.js";
+import { executeBashCommand, executeBashWithOperations } from "./bash-executor.js";
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error("Aborted"));
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(new Error("Aborted"));
+        });
+    });
+}
+const DEFAULT_THINKING_LEVEL = "medium";
+// ============================================================================
+// AgentSession Class
+// ============================================================================
+export class AgentSession {
+    _agent;
+    _sessionManager;
+    _settingsManager;
+    _eventBus;
+    _cwd;
+    // Event handling
+    _sessionEventListeners = new Set();
+    _agentEventUnsubscribe;
+    // State
+    _isStreaming = false;
+    _model;
+    // Compaction state
+    _compactionAbortController;
+    _autoCompactionAbortController;
+    _overflowRecoveryAttempted = false;
+    // Retry state
+    _retryAbortController;
+    _retryPromise;
+    _retryResolve;
+    _retryAttempt = 0;
+    // Bash state
+    _bashAbortController;
+    _pendingBashMessages = [];
+    // Steering and follow-up
+    _steeringMessages = [];
+    _followUpMessages = [];
+    _pendingNextTurnMessages = [];
+    // Tools
+    _activeToolNames = new Set(["read", "bash", "edit", "write"]);
+    _toolRegistry = new Map();
+    _baseToolsOverride;
+    constructor(config) {
+        this._cwd = config.cwd;
+        this._sessionManager = config.sessionManager ?? SessionManager.inMemory(config.cwd);
+        this._settingsManager = config.settingsManager ?? SettingsManager.inMemory();
+        this._eventBus = config.eventBus ?? new AgentEventBus();
+        // Apply settings overrides
+        if (config.autoCompact !== undefined) {
+            this._settingsManager.setCompactionEnabled(config.autoCompact);
+        }
+        if (config.autoRetry !== undefined) {
+            this._settingsManager.setRetryEnabled(config.autoRetry);
+        }
+        // Store base tools override
+        this._baseToolsOverride = config.tools;
+        // Create agent
+        this._agent = new Agent({
+            initialState: {
+                thinkingLevel: config.thinkingLevel ?? this._settingsManager.getDefaultThinkingLevel() ?? DEFAULT_THINKING_LEVEL,
+            },
+        });
+        // Set initial model
+        if (config.model) {
+            this._model = config.model;
+            this._agent.setModel(config.model);
+        }
+        // Connect to agent events
+        this._reconnectToAgent();
+    }
+    // =========================================================================
+    // Properties
+    // =========================================================================
+    get agent() {
+        return this._agent;
+    }
+    get sessionManager() {
+        return this._sessionManager;
+    }
+    get settingsManager() {
+        return this._settingsManager;
+    }
+    get eventBus() {
+        return this._eventBus;
+    }
+    get cwd() {
+        return this._cwd;
+    }
+    get sessionFile() {
+        return this._sessionManager.getSessionFile();
+    }
+    get sessionId() {
+        return this._sessionManager.getSessionId();
+    }
+    get model() {
+        return this._model;
+    }
+    get messages() {
+        return this._agent.state.messages;
+    }
+    get state() {
+        return this._agent.state;
+    }
+    get isStreaming() {
+        return this._isStreaming;
+    }
+    get thinkingLevel() {
+        return this._agent.state.thinkingLevel;
+    }
+    get pendingMessageCount() {
+        return this._steeringMessages.length + this._followUpMessages.length + this._pendingNextTurnMessages.length;
+    }
+    // =========================================================================
+    // Event Handling
+    // =========================================================================
+    /**
+     * Subscribe to session events.
+     */
+    subscribe(callback) {
+        this._sessionEventListeners.add(callback);
+        return () => this._sessionEventListeners.delete(callback);
+    }
+    /**
+     * Emit a session event to all listeners.
+     */
+    _emit(event) {
+        for (const listener of this._sessionEventListeners) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                console.error("Session event listener error:", err);
+            }
+        }
+    }
+    /**
+     * Connect to agent events.
+     */
+    _reconnectToAgent() {
+        this._disconnectFromAgent();
+        this._agentEventUnsubscribe = this._agent.subscribe((event) => {
+            this._handleAgentEvent(event);
+        });
+    }
+    /**
+     * Disconnect from agent events.
+     */
+    _disconnectFromAgent() {
+        if (this._agentEventUnsubscribe) {
+            this._agentEventUnsubscribe();
+            this._agentEventUnsubscribe = undefined;
+        }
+    }
+    /**
+     * Handle agent events.
+     */
+    _handleAgentEvent(event) {
+        switch (event.type) {
+            case "agent_start":
+                this._isStreaming = true;
+                this._overflowRecoveryAttempted = false;
+                break;
+            case "agent_end": {
+                this._isStreaming = false;
+                this._flushPendingBashMessages();
+                const messages = this._agent.state.messages;
+                const lastMessage = messages[messages.length - 1];
+                if (lastMessage && lastMessage.role === "assistant") {
+                    const assistantMsg = lastMessage;
+                    // Check for retryable errors
+                    if (this._isRetryableError(assistantMsg)) {
+                        this._handleRetryableError(assistantMsg).catch(() => { });
+                        return;
+                    }
+                    // Check for compaction
+                    this._checkCompaction(assistantMsg).catch(() => { });
+                }
+                // Resolve retry promise if exists
+                this._resolveRetry();
+                break;
+            }
+            case "message_start":
+            case "message_update":
+            case "message_end":
+            case "tool_execution_start":
+            case "tool_execution_end":
+                // Forward these events to session manager for persistence
+                if (event.type === "message_end" && "message" in event) {
+                    this._sessionManager.appendMessage(event.message);
+                }
+                break;
+        }
+    }
+    // =========================================================================
+    // Model Management
+    // =========================================================================
+    /**
+     * Set the current model.
+     */
+    async setModel(model) {
+        const previousModel = this._model;
+        this._model = model;
+        this._agent.setModel(model);
+        // Save to session
+        this._sessionManager.appendModelChange(model.provider, model.id);
+        this._emit({
+            type: "model_select",
+            model,
+            previousModel,
+            source: "set",
+        });
+    }
+    // =========================================================================
+    // Thinking Level Management
+    // =========================================================================
+    /**
+     * Set thinking level.
+     */
+    setThinkingLevel(level) {
+        const previousLevel = this._agent.state.thinkingLevel;
+        // Clamp to model capabilities
+        const availableLevels = this.getAvailableThinkingLevels();
+        const effectiveLevel = availableLevels.includes(level)
+            ? level
+            : this._clampThinkingLevel(level, availableLevels);
+        this._agent.setThinkingLevel(effectiveLevel);
+        this._sessionManager.appendThinkingLevelChange(effectiveLevel);
+        this._emit({
+            type: "thinking_level_change",
+            level: effectiveLevel,
+            previousLevel,
+        });
+    }
+    /**
+     * Get available thinking levels for current model.
+     */
+    getAvailableThinkingLevels() {
+        if (!this._model) {
+            return ["off", "minimal", "low", "medium", "high"];
+        }
+        // Check if model supports thinking
+        if (!this._model.reasoning) {
+            return ["off"];
+        }
+        return ["off", "minimal", "low", "medium", "high", "xhigh"];
+    }
+    /**
+     * Cycle to next thinking level.
+     */
+    cycleThinkingLevel() {
+        const levels = this.getAvailableThinkingLevels();
+        const currentIndex = levels.indexOf(this.thinkingLevel);
+        const nextIndex = (currentIndex + 1) % levels.length;
+        this.setThinkingLevel(levels[nextIndex]);
+    }
+    /**
+     * Check if model supports thinking.
+     */
+    supportsThinking() {
+        return this._model ? Boolean(this._model.reasoning) : false;
+    }
+    /**
+     * Clamp thinking level to available levels.
+     */
+    _clampThinkingLevel(requested, available) {
+        if (available.includes(requested))
+            return requested;
+        const order = ["off", "minimal", "low", "medium", "high", "xhigh"];
+        const requestedIndex = order.indexOf(requested);
+        // Find closest available level
+        for (let i = requestedIndex; i >= 0; i--) {
+            if (available.includes(order[i]))
+                return order[i];
+        }
+        return available[0] ?? "off";
+    }
+    // =========================================================================
+    // Queue Mode Management
+    // =========================================================================
+    /**
+     * Set steering message mode.
+     */
+    setSteeringMode(mode) {
+        this._settingsManager.setSteeringMode(mode);
+    }
+    /**
+     * Set follow-up message mode.
+     */
+    setFollowUpMode(mode) {
+        this._settingsManager.setFollowUpMode(mode);
+    }
+    // =========================================================================
+    // Compaction
+    // =========================================================================
+    /**
+     * Manually compact the session context.
+     */
+    async compact(customInstructions) {
+        this._disconnectFromAgent();
+        await this.abort();
+        this._compactionAbortController = new AbortController();
+        try {
+            if (!this.model) {
+                throw new Error("No model selected");
+            }
+            const pathEntries = this.sessionManager.getBranch();
+            const settings = this.settingsManager.getCompactionSettings();
+            const preparation = prepareCompaction(pathEntries, settings);
+            if (!preparation) {
+                const lastEntry = pathEntries[pathEntries.length - 1];
+                if (lastEntry?.type === "compaction") {
+                    throw new Error("Already compacted");
+                }
+                throw new Error("Nothing to compact (session too small)");
+            }
+            // Get API key (would need ModelRegistry in real implementation)
+            const apiKey = process.env[`${this.model.provider.toUpperCase()}_API_KEY`] || "";
+            if (!apiKey) {
+                throw new Error(`No API key for ${this.model.provider}`);
+            }
+            const result = await compact(preparation, this.model, apiKey, customInstructions, this._compactionAbortController.signal);
+            if (this._compactionAbortController.signal.aborted) {
+                throw new Error("Compaction cancelled");
+            }
+            this.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, false);
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.replaceMessages(sessionContext.messages);
+            return result;
+        }
+        finally {
+            this._compactionAbortController = undefined;
+            this._reconnectToAgent();
+        }
+    }
+    /**
+     * Cancel in-progress compaction.
+     */
+    abortCompaction() {
+        this._compactionAbortController?.abort();
+        this._autoCompactionAbortController?.abort();
+    }
+    /**
+     * Check if compaction is needed and run it.
+     */
+    async _checkCompaction(assistantMessage, skipAbortedCheck = true) {
+        const settings = this.settingsManager.getCompactionSettings();
+        if (!settings.enabled)
+            return;
+        if (skipAbortedCheck && assistantMessage.stopReason === "aborted")
+            return;
+        const contextWindow = this.model?.contextWindow ?? 0;
+        // Check for overflow
+        if (isContextOverflow(assistantMessage, contextWindow)) {
+            if (this._overflowRecoveryAttempted) {
+                this._emit({
+                    type: "auto_compaction_end",
+                    result: undefined,
+                    aborted: false,
+                    willRetry: false,
+                    errorMessage: "Context overflow recovery failed",
+                });
+                return;
+            }
+            this._overflowRecoveryAttempted = true;
+            const messages = this.agent.state.messages;
+            if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+                this.agent.replaceMessages(messages.slice(0, -1));
+            }
+            await this._runAutoCompaction("overflow", true);
+            return;
+        }
+        // Check threshold
+        const contextTokens = calculateContextTokens(assistantMessage.usage);
+        if (shouldCompact(contextTokens, contextWindow, settings)) {
+            await this._runAutoCompaction("threshold", false);
+        }
+    }
+    /**
+     * Run auto-compaction with events.
+     */
+    async _runAutoCompaction(reason, willRetry) {
+        this._emit({ type: "auto_compaction_start", reason });
+        this._autoCompactionAbortController = new AbortController();
+        try {
+            if (!this.model) {
+                this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+                return;
+            }
+            const apiKey = process.env[`${this.model.provider.toUpperCase()}_API_KEY`] || "";
+            if (!apiKey) {
+                this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+                return;
+            }
+            const pathEntries = this.sessionManager.getBranch();
+            const settings = this.settingsManager.getCompactionSettings();
+            const preparation = prepareCompaction(pathEntries, settings);
+            if (!preparation) {
+                this._emit({ type: "auto_compaction_end", result: undefined, aborted: false, willRetry: false });
+                return;
+            }
+            const result = await compact(preparation, this.model, apiKey, undefined, this._autoCompactionAbortController.signal);
+            if (this._autoCompactionAbortController.signal.aborted) {
+                this._emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+                return;
+            }
+            this.sessionManager.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details, false);
+            const sessionContext = this.sessionManager.buildSessionContext();
+            this.agent.replaceMessages(sessionContext.messages);
+            this._emit({ type: "auto_compaction_end", result, aborted: false, willRetry });
+            if (willRetry) {
+                setTimeout(() => {
+                    this.agent.continue().catch(() => { });
+                }, 100);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "compaction failed";
+            this._emit({
+                type: "auto_compaction_end",
+                result: undefined,
+                aborted: false,
+                willRetry: false,
+                errorMessage,
+            });
+        }
+        finally {
+            this._autoCompactionAbortController = undefined;
+        }
+    }
+    /**
+     * Toggle auto-compaction setting.
+     */
+    setAutoCompactionEnabled(enabled) {
+        this.settingsManager.setCompactionEnabled(enabled);
+    }
+    get autoCompactionEnabled() {
+        return this.settingsManager.getCompactionEnabled();
+    }
+    // =========================================================================
+    // Auto-Retry
+    // =========================================================================
+    /**
+     * Check if an error is retryable.
+     */
+    _isRetryableError(message) {
+        if (message.stopReason !== "error" || !message.errorMessage)
+            return false;
+        const contextWindow = this.model?.contextWindow ?? 0;
+        if (isContextOverflow(message, contextWindow))
+            return false;
+        const err = message.errorMessage;
+        return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|fetch failed/i.test(err);
+    }
+    /**
+     * Handle retryable errors with exponential backoff.
+     */
+    async _handleRetryableError(message) {
+        const settings = this.settingsManager.getRetrySettings();
+        if (!settings.enabled) {
+            this._resolveRetry();
+            return false;
+        }
+        if (!this._retryPromise) {
+            this._retryPromise = new Promise((resolve) => {
+                this._retryResolve = resolve;
+            });
+        }
+        this._retryAttempt++;
+        if (this._retryAttempt > settings.maxRetries) {
+            this._emit({
+                type: "auto_retry_end",
+                success: false,
+                attempt: this._retryAttempt - 1,
+                finalError: message.errorMessage,
+            });
+            this._retryAttempt = 0;
+            this._resolveRetry();
+            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
+        const messages = this.agent.state.messages;
+        if (messages.length > 0 && messages[messages.length - 1].role === "assistant") {
+            this.agent.replaceMessages(messages.slice(0, -1));
+        }
+        // Wait with exponential backoff
+        this._retryAbortController = new AbortController();
+        try {
+            await sleep(delayMs, this._retryAbortController.signal);
+        }
+        catch {
+            const attempt = this._retryAttempt;
+            this._retryAttempt = 0;
+            this._retryAbortController = undefined;
+            this._emit({
+                type: "auto_retry_end",
+                success: false,
+                attempt,
+                finalError: "Retry cancelled",
+            });
+            this._resolveRetry();
+            return false;
+        }
+        this._retryAbortController = undefined;
+        // Retry via continue()
+        setTimeout(() => {
+            this.agent.continue().catch(() => { });
+        }, 0);
+        return true;
+    }
+    /**
+     * Cancel in-progress retry.
+     */
+    abortRetry() {
+        this._retryAbortController?.abort();
+        this._resolveRetry();
+    }
+    /**
+     * Resolve retry promise.
+     */
+    _resolveRetry() {
+        if (this._retryResolve) {
+            this._retryResolve();
+            this._retryResolve = undefined;
+        }
+        this._retryPromise = undefined;
+    }
+    get isRetrying() {
+        return this._retryPromise !== undefined;
+    }
+    get autoRetryEnabled() {
+        return this.settingsManager.getRetryEnabled();
+    }
+    setAutoRetryEnabled(enabled) {
+        this.settingsManager.setRetryEnabled(enabled);
+    }
+    // =========================================================================
+    // Bash Execution
+    // =========================================================================
+    /**
+     * Execute a bash command.
+     */
+    async executeBash(command, onChunk, options) {
+        this._bashAbortController = new AbortController();
+        const prefix = this.settingsManager.getShellCommandPrefix();
+        const resolvedCommand = prefix ? `${prefix}\n${command}` : command;
+        this._emit({ type: "bash_start", command });
+        try {
+            const result = options?.operations
+                ? await executeBashWithOperations(resolvedCommand, this._cwd, options.operations, {
+                    onChunk,
+                    signal: this._bashAbortController.signal,
+                })
+                : await executeBashCommand(resolvedCommand, {
+                    onChunk,
+                    signal: this._bashAbortController.signal,
+                });
+            this.recordBashResult(command, result, options);
+            this._emit({ type: "bash_end", result });
+            return result;
+        }
+        finally {
+            this._bashAbortController = undefined;
+        }
+    }
+    /**
+     * Record a bash execution result.
+     */
+    recordBashResult(command, result, options) {
+        const bashMessage = {
+            role: "bashExecution",
+            command,
+            output: result.output,
+            exitCode: result.exitCode,
+            cancelled: result.cancelled,
+            truncated: result.truncated,
+            fullOutputPath: result.fullOutputPath,
+            timestamp: Date.now(),
+            excludeFromContext: options?.excludeFromContext,
+        };
+        if (this.isStreaming) {
+            this._pendingBashMessages.push(bashMessage);
+        }
+        else {
+            this.agent.appendMessage(bashMessage);
+            this.sessionManager.appendMessage(bashMessage);
+        }
+    }
+    /**
+     * Cancel running bash command.
+     */
+    abortBash() {
+        this._bashAbortController?.abort();
+    }
+    get isBashRunning() {
+        return this._bashAbortController !== undefined;
+    }
+    /**
+     * Flush pending bash messages.
+     */
+    _flushPendingBashMessages() {
+        if (this._pendingBashMessages.length === 0)
+            return;
+        for (const bashMessage of this._pendingBashMessages) {
+            this.agent.appendMessage(bashMessage);
+            this.sessionManager.appendMessage(bashMessage);
+        }
+        this._pendingBashMessages = [];
+    }
+    // =========================================================================
+    // Session Management
+    // =========================================================================
+    /**
+     * Abort current operation.
+     */
+    async abort() {
+        this._agent.abort();
+        this.abortCompaction();
+        this.abortRetry();
+        this.abortBash();
+    }
+    /**
+     * Switch to a different session.
+     */
+    async switchSession(sessionPath) {
+        this._disconnectFromAgent();
+        await this.abort();
+        this._steeringMessages = [];
+        this._followUpMessages = [];
+        this._pendingNextTurnMessages = [];
+        const previousSessionFile = this.sessionManager.getSessionFile();
+        this.sessionManager.setSessionFile(sessionPath);
+        this.agent.sessionId = this.sessionManager.getSessionId();
+        const sessionContext = this.sessionManager.buildSessionContext();
+        this.agent.replaceMessages(sessionContext.messages);
+        this._emit({
+            type: "session_switch",
+            reason: "resume",
+            previousSessionFile,
+        });
+        this._reconnectToAgent();
+        return true;
+    }
+    /**
+     * Create a new session.
+     */
+    newSession(options) {
+        this._disconnectFromAgent();
+        this._steeringMessages = [];
+        this._followUpMessages = [];
+        this._pendingNextTurnMessages = [];
+        const previousSessionFile = this.sessionManager.getSessionFile();
+        this.sessionManager.newSession(options);
+        this.agent.sessionId = this.sessionManager.getSessionId();
+        this.agent.replaceMessages([]);
+        this._reconnectToAgent();
+    }
+    /**
+     * Set session display name.
+     */
+    setSessionName(name) {
+        this.sessionManager.appendSessionInfo(name);
+    }
+    /**
+     * Get session statistics.
+     */
+    getSessionStats() {
+        const state = this.state;
+        const userMessages = state.messages.filter((m) => m.role === "user").length;
+        const assistantMessages = state.messages.filter((m) => m.role === "assistant").length;
+        const toolResults = state.messages.filter((m) => m.role === "toolResult").length;
+        let toolCalls = 0;
+        let totalInput = 0;
+        let totalOutput = 0;
+        let totalCacheRead = 0;
+        let totalCacheWrite = 0;
+        let totalCost = 0;
+        for (const message of state.messages) {
+            if (message.role === "assistant") {
+                const assistantMsg = message;
+                toolCalls += assistantMsg.content.filter((c) => c.type === "toolCall").length;
+                totalInput += assistantMsg.usage.input;
+                totalOutput += assistantMsg.usage.output;
+                totalCacheRead += assistantMsg.usage.cacheRead;
+                totalCacheWrite += assistantMsg.usage.cacheWrite;
+                totalCost += assistantMsg.usage.cost.total;
+            }
+        }
+        return {
+            sessionFile: this.sessionFile,
+            sessionId: this.sessionId,
+            userMessages,
+            assistantMessages,
+            toolCalls,
+            toolResults,
+            totalMessages: state.messages.length,
+            tokens: {
+                input: totalInput,
+                output: totalOutput,
+                cacheRead: totalCacheRead,
+                cacheWrite: totalCacheWrite,
+                total: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
+            },
+            cost: totalCost,
+        };
+    }
+    /**
+     * Get context usage.
+     */
+    getContextUsage() {
+        const model = this.model;
+        if (!model)
+            return undefined;
+        const contextWindow = model.contextWindow ?? 0;
+        if (contextWindow <= 0)
+            return undefined;
+        const branchEntries = this.sessionManager.getBranch();
+        const latestCompaction = getLatestCompactionEntry(branchEntries);
+        if (latestCompaction) {
+            const compactionIndex = branchEntries.lastIndexOf(latestCompaction);
+            let hasPostCompactionUsage = false;
+            for (let i = branchEntries.length - 1; i > compactionIndex; i--) {
+                const entry = branchEntries[i];
+                if (entry.type === "message" && entry.message.role === "assistant") {
+                    const assistant = entry.message;
+                    if (assistant.stopReason !== "aborted" && assistant.stopReason !== "error") {
+                        hasPostCompactionUsage = true;
+                        break;
+                    }
+                }
+            }
+            if (!hasPostCompactionUsage) {
+                return { tokens: null, contextWindow, percent: null };
+            }
+        }
+        const estimate = estimateContextTokens(this.messages);
+        const percent = (estimate.tokens / contextWindow) * 100;
+        return {
+            tokens: estimate.tokens,
+            contextWindow,
+            percent,
+        };
+    }
+    // =========================================================================
+    // Steering & Follow-up
+    // =========================================================================
+    /**
+     * Send steering message (mid-stream guidance).
+     */
+    steer(content, options) {
+        this._steeringMessages.push({ content, options });
+    }
+    /**
+     * Send follow-up message (post-stream continuation).
+     */
+    followUp(content, options) {
+        this._followUpMessages.push({ content, options });
+    }
+    /**
+     * Clear all queued messages.
+     */
+    clearQueue() {
+        this._steeringMessages = [];
+        this._followUpMessages = [];
+        this._pendingNextTurnMessages = [];
+    }
+    getSteeringMessages() {
+        return [...this._steeringMessages];
+    }
+    getFollowUpMessages() {
+        return [...this._followUpMessages];
+    }
+    // =========================================================================
+    // Tool Management
+    // =========================================================================
+    /**
+     * Get active tool names.
+     */
+    getActiveToolNames() {
+        return [...this._activeToolNames];
+    }
+    /**
+     * Get all available tools.
+     */
+    getAllTools() {
+        const tools = [];
+        for (const [name, tool] of this._toolRegistry) {
+            tools.push({ name, description: tool.description });
+        }
+        return tools;
+    }
+    /**
+     * Set active tools by name.
+     */
+    setActiveToolsByName(toolNames) {
+        this._activeToolNames = new Set(toolNames);
+        this._emit({ type: "tools_changed", activeTools: toolNames });
+    }
+    // =========================================================================
+    // Utilities
+    // =========================================================================
+    /**
+     * Get text content of last assistant message.
+     */
+    getLastAssistantText() {
+        const lastAssistant = this.messages
+            .slice()
+            .reverse()
+            .find((m) => {
+            if (m.role !== "assistant")
+                return false;
+            const msg = m;
+            if (msg.stopReason === "aborted" && msg.content.length === 0)
+                return false;
+            return true;
+        });
+        if (!lastAssistant)
+            return undefined;
+        let text = "";
+        for (const content of lastAssistant.content) {
+            if (content.type === "text") {
+                text += content.text;
+            }
+        }
+        return text.trim() || undefined;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+export function createAgentSession(config) {
+    return new AgentSession(config);
+}
+//# sourceMappingURL=agent-session.js.map