@vybestack/llxprt-code-agents 0.10.0-nightly.260613.1adad3b34

package/dist/src/core/chatSession.js

@@ -0,0 +1,720 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* eslint-disable max-lines -- ChatSession coordinates legacy decomposed modules; further splitting is outside this change. */
+// ChatSession — thin coordinator that wires up the decomposed modules.
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { DebugLogger } from '@vybestack/llxprt-code-core/debug/index.js';
+import { triggerPreCompressHook } from '@vybestack/llxprt-code-core/core/lifecycleHookTriggers.js';
+import { PreCompressTrigger } from '@vybestack/llxprt-code-core/hooks/types.js';
+import { SettingsService } from '@vybestack/llxprt-code-settings';
+import { getProviderKeyStorage } from '@vybestack/llxprt-code-core/storage/provider-key-storage.js';
+import { createRuntimeInvocationContext } from '@vybestack/llxprt-code-core/runtime/RuntimeInvocationContext.js';
+import { isLoadBalancerProfile } from '@vybestack/llxprt-code-settings';
+// Decomposed modules
+import { CompressionHandler } from '../compression/CompressionHandler.js';
+import { ConversationManager } from './ConversationManager.js';
+import { TurnProcessor } from './TurnProcessor.js';
+import { StreamProcessor } from './StreamProcessor.js';
+import { DirectMessageProcessor } from './DirectMessageProcessor.js';
+import { convertPartListUnionToIContent, convertIContentToResponse, validateHistory, } from './MessageConverter.js';
+// Re-exports — consumers import from './chatSession.js'
+export { StreamEventType, } from '@vybestack/llxprt-code-core/core/chatSessionTypes.js';
+export { InvalidStreamError, EmptyStreamError, isSchemaDepthError, } from '@vybestack/llxprt-code-core/core/chatSessionTypes.js';
+export { aggregateTextWithSpacing, isValidNonThoughtTextPart, } from './MessageConverter.js';
+import { CompressionProfileNotFoundError } from '@vybestack/llxprt-code-core/core/compression/types.js';
+/**
+ * Error thrown when agent execution is stopped by a hook.
+ */
+export class AgentExecutionStoppedError extends Error {
+    reason;
+    systemMessage;
+    contextCleared;
+    constructor(reason, systemMessage, contextCleared) {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty systemMessage should fall through to reason
+        super(`Agent execution stopped: ${systemMessage || reason}`);
+        this.name = 'AgentExecutionStoppedError';
+        this.reason = reason;
+        this.systemMessage = systemMessage;
+        this.contextCleared = contextCleared;
+    }
+}
+/**
+ * Error thrown when agent execution is blocked by a hook.
+ */
+export class AgentExecutionBlockedError extends Error {
+    reason;
+    systemMessage;
+    syntheticResponse;
+    contextCleared;
+    constructor(reason, syntheticResponse, systemMessage, contextCleared) {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: empty systemMessage should fall through to reason
+        super(`Agent execution blocked: ${systemMessage || reason}`);
+        this.name = 'AgentExecutionBlockedError';
+        this.reason = reason;
+        this.systemMessage = systemMessage;
+        this.syntheticResponse = syntheticResponse;
+        this.contextCleared = contextCleared;
+    }
+}
+class CompressionLoadBalancingProvider {
+    strategy;
+    candidates;
+    name = 'load-balancer';
+    selectedRoundRobinCandidate;
+    constructor(strategy, candidates, initialIndex) {
+        this.strategy = strategy;
+        this.candidates = candidates;
+        if (candidates.length === 0) {
+            throw new Error('Load-balanced compression profile requires subprofiles');
+        }
+        if (strategy === 'round-robin') {
+            this.selectedRoundRobinCandidate =
+                this.candidates[initialIndex % this.candidates.length];
+        }
+    }
+    async getModels() {
+        return [];
+    }
+    getDefaultModel() {
+        return this.candidates[0]?.resolved?.model ?? '';
+    }
+    getServerTools() {
+        return [];
+    }
+    async invokeServerTool(toolName) {
+        throw new Error(`Server tool '${toolName}' not supported by compression load-balancer provider`);
+    }
+    async *generateChatCompletion(optionsOrContent) {
+        const options = Array.isArray(optionsOrContent)
+            ? { contents: optionsOrContent }
+            : optionsOrContent;
+        if (this.strategy === 'failover') {
+            yield* this.generateWithFailover(options);
+            return;
+        }
+        yield* this.generateWithCandidate(this.selectedRoundRobinCandidate ?? this.candidates[0], options);
+    }
+    async *generateWithFailover(options) {
+        let lastError;
+        for (const candidate of this.candidates) {
+            try {
+                const bufferedChunks = [];
+                for await (const chunk of this.generateWithCandidate(candidate, options)) {
+                    bufferedChunks.push(chunk);
+                }
+                yield* bufferedChunks;
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    async *generateWithCandidate(candidate, options) {
+        const candidateOptions = {
+            ...options,
+            runtime: candidate.runtime,
+            settings: candidate.runtime
+                .settingsService,
+            config: candidate.config,
+            resolved: {
+                ...options.resolved,
+                ...candidate.resolved,
+            },
+            invocation: candidate.invocation,
+            metadata: {
+                ...options.metadata,
+                ...candidate.invocation.metadata,
+                selectedCompressionProfile: candidate.profileName,
+            },
+        };
+        yield* candidate.provider.generateChatCompletion(candidateOptions);
+    }
+}
+/**
+ * Chat session that enables sending messages to the model with previous
+ * conversation context.
+ *
+ * @remarks
+ * The session maintains all the turns between user and model.
+ * Delegates to focused modules: CompressionHandler, ConversationManager,
+ * TurnProcessor, StreamProcessor, DirectMessageProcessor.
+ */
+export class ChatSession {
+    logger = new DebugLogger('llxprt:gemini:chat');
+    runtimeState;
+    historyService;
+    runtimeContext;
+    generationConfig;
+    // Composed modules
+    compressionHandler;
+    conversationManager;
+    turnProcessor;
+    streamProcessor;
+    directMessageProcessor;
+    compressionLoadBalancerRoundRobinIndexes = new Map();
+    constructor(view, contentGenerator, generationConfig = {}, initialHistory = []) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+        if (view == null) {
+            throw new Error('AgentRuntimeContext is required for ChatSession');
+        }
+        this.runtimeContext = view;
+        this.runtimeState = view.state;
+        this.historyService = view.history;
+        this.generationConfig = generationConfig;
+        void contentGenerator;
+        // Wire density-dirty tracking on historyService.add
+        this._installDensityWrapper();
+        validateHistory(initialHistory);
+        const model = this.runtimeState.model;
+        this.logger.debug('ChatSession initialized:', {
+            model,
+            initialHistoryLength: initialHistory.length,
+            hasHistoryService: true,
+            hasRuntimeState: true,
+        });
+        // Create composed modules
+        const providerResolver = (ctx) => this.resolveProviderForRuntime(ctx);
+        const providerRuntimeBuilder = (s, m) => this.buildProviderRuntime(s, m);
+        const makePositionMatcher = () => this._makePositionMatcher();
+        const resolveBaseUrl = (p) => this.resolveProviderBaseUrl(p);
+        this.compressionHandler = new CompressionHandler(view, this.historyService, this.generationConfig, this.resolveCompressionProvider.bind(this), async (context) => {
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+            const config = view.providerRuntime?.config;
+            if (config) {
+                await triggerPreCompressHook(config, context.trigger === 'auto'
+                    ? PreCompressTrigger.Auto
+                    : PreCompressTrigger.Manual);
+            }
+        });
+        this.conversationManager = new ConversationManager(this.historyService, view, model);
+        this.conversationManager.importInitialHistory(initialHistory, model);
+        this.streamProcessor = new StreamProcessor(view, this.conversationManager, this.compressionHandler, providerResolver, providerRuntimeBuilder, this.historyService, this.generationConfig);
+        const { turnProcessor, directMessageProcessor } = this._buildMessageProcessors(view, providerResolver, providerRuntimeBuilder, makePositionMatcher, resolveBaseUrl);
+        this.turnProcessor = turnProcessor;
+        this.directMessageProcessor = directMessageProcessor;
+    }
+    _buildMessageProcessors(view, providerResolver, providerRuntimeBuilder, makePositionMatcher, resolveBaseUrl) {
+        const turnProcessor = new TurnProcessor(view, this.compressionHandler, providerResolver, providerRuntimeBuilder, this.generationConfig, this.historyService, this.streamProcessor, makePositionMatcher, resolveBaseUrl);
+        const directMessageProcessor = new DirectMessageProcessor(view, providerResolver, providerRuntimeBuilder, this.generationConfig, this.historyService, makePositionMatcher);
+        return { turnProcessor, directMessageProcessor };
+    }
+    // ── Density wrapper ──────────────────────────────────────────────
+    static DENSITY_WRAPPED = Symbol('densityWrapped');
+    _installDensityWrapper() {
+        if (typeof this.historyService.add !== 'function')
+            return;
+        const hs = this.historyService;
+        if (hs[ChatSession.DENSITY_WRAPPED] === true)
+            return;
+        const originalAdd = this.historyService.add.bind(this.historyService);
+        this.historyService.add = (...args) => {
+            const result = originalAdd(...args);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+            this.compressionHandler?.markDensityDirty();
+            return result;
+        };
+        hs[ChatSession.DENSITY_WRAPPED] = true;
+    }
+    // ── Provider resolution (stays on coordinator) ───────────────────
+    getActiveProvider() {
+        try {
+            return this.runtimeContext.provider.getActiveProvider();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    lookupProviderByName(adapter, desiredProviderName, compressionProfileName) {
+        if (typeof adapter.getProviderByName !== 'function') {
+            return undefined;
+        }
+        try {
+            const candidate = adapter.getProviderByName(desiredProviderName);
+            if (candidate !== undefined) {
+                const active = this.getActiveProvider();
+                if (active !== undefined && active.name !== desiredProviderName) {
+                    this.logger.debug(() => `[ChatSession] selected provider '${desiredProviderName}' via getProviderByName (active remains '${active.name}') [${compressionProfileName}]`);
+                }
+                return candidate;
+            }
+        }
+        catch (error) {
+            this.logger.debug(() => `[ChatSession] provider lookup skipped (${compressionProfileName}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return undefined;
+    }
+    resolveProviderForRuntime(compressionProfileName) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+        const desiredProviderName = this.runtimeState.provider?.trim();
+        const adapter = this.runtimeContext.provider;
+        if (desiredProviderName) {
+            const candidate = this.lookupProviderByName(adapter, desiredProviderName, compressionProfileName);
+            if (candidate) {
+                return candidate;
+            }
+        }
+        let provider = this.getActiveProvider();
+        if (!provider) {
+            throw new Error('No active provider configured');
+        }
+        if (desiredProviderName && provider.name !== desiredProviderName) {
+            const previousProviderName = provider.name;
+            try {
+                adapter.setActiveProvider(desiredProviderName);
+                const updatedProvider = adapter.getActiveProvider();
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+                if (updatedProvider != null) {
+                    provider = updatedProvider;
+                }
+                this.logger.debug(() => `[ChatSession] enforced provider switch to '${desiredProviderName}' (previous '${previousProviderName}') [${compressionProfileName}]`);
+            }
+            catch (error) {
+                this.logger.debug(() => `[ChatSession] provider switch skipped (${compressionProfileName}, read-only context): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return provider;
+    }
+    resolveExplicitCompressionProvider(profileName, providerName, lookupProviderName = providerName) {
+        const adapter = this.runtimeContext.provider;
+        const lookupResult = this.lookupProviderByName(adapter, lookupProviderName, `compression.profile:${profileName}`);
+        if (lookupResult) {
+            return lookupResult;
+        }
+        const activeProvider = this.getActiveProvider();
+        if (activeProvider?.name === providerName ||
+            activeProvider?.name === lookupProviderName) {
+            return activeProvider;
+        }
+        throw new CompressionProfileNotFoundError(profileName, `provider '${lookupProviderName}' is not available for compression.profile: provider lookup by name is required when it is not already active`);
+    }
+    providerSupportsIContent(provider) {
+        if (!provider)
+            return false;
+        return (typeof provider
+            .generateChatCompletion === 'function');
+    }
+    async resolveCompressionProvider(profileName) {
+        if (!profileName) {
+            const provider = this.resolveProviderForRuntime('ChatSession.resolveCompressionProvider.default');
+            const runtime = this.runtimeContext.providerRuntime;
+            return {
+                provider,
+                runtime,
+                config: runtime.config,
+            };
+        }
+        const config = this.runtimeContext.providerRuntime.config;
+        const profileManager = config?.getProfileManager();
+        if (!profileManager) {
+            throw new CompressionProfileNotFoundError(profileName, 'profile manager is unavailable');
+        }
+        let profile;
+        try {
+            profile = await profileManager.loadProfile(profileName);
+        }
+        catch (error) {
+            throw new CompressionProfileNotFoundError(profileName, error instanceof Error ? error.message : String(error));
+        }
+        if (isLoadBalancerProfile(profile)) {
+            return this.resolveLoadBalancedCompressionProvider(profileName, profile, config, profileManager);
+        }
+        return this.resolveStandardCompressionProvider(profileName, profile, profileManager, config);
+    }
+    async resolveLoadBalancedCompressionProvider(profileName, profile, config, profileManager) {
+        const candidates = await this.buildCompressionLoadBalancerCandidates(profileName, profile, config, profileManager);
+        const strategy = profile.policy === 'failover' ? 'failover' : 'round-robin';
+        const initialIndex = this.compressionLoadBalancerRoundRobinIndexes.get(profileName) ?? 0;
+        if (strategy === 'round-robin') {
+            this.compressionLoadBalancerRoundRobinIndexes.set(profileName, (initialIndex + 1) % candidates.length);
+        }
+        const provider = new CompressionLoadBalancingProvider(strategy, candidates, initialIndex);
+        const runtimeId = `${this.runtimeContext.providerRuntime.runtimeId}::compression-profile:${profileName}`;
+        const settings = new SettingsService();
+        settings.setCurrentProfileName(profileName);
+        settings.set('activeProvider', 'load-balancer');
+        settings.set('model', profile.model || provider.getDefaultModel());
+        for (const [key, value] of Object.entries(profile.ephemeralSettings)) {
+            if (value !== undefined) {
+                settings.set(key, value);
+            }
+        }
+        const metadata = {
+            ...(this.runtimeContext.providerRuntime.metadata ?? {}),
+            source: 'ChatSession.resolveCompressionProvider',
+            compressionProfile: profileName,
+            compressionProvider: 'load-balancer',
+            runtimeId,
+            provider: 'load-balancer',
+            model: settings.get('model'),
+        };
+        const runtime = {
+            settingsService: settings,
+            config,
+            runtimeId,
+            metadata,
+        };
+        const invocation = createRuntimeInvocationContext({
+            runtime,
+            settings,
+            providerName: 'load-balancer',
+            ephemeralsSnapshot: this.buildCompressionProfileEphemeralsSnapshot(settings, 'load-balancer'),
+            metadata,
+            fallbackRuntimeId: runtimeId,
+        });
+        return {
+            provider,
+            runtime,
+            config,
+            invocation,
+        };
+    }
+    async buildCompressionLoadBalancerCandidates(profileName, profile, config, profileManager) {
+        const candidates = [];
+        for (const subProfileName of profile.profiles) {
+            const subProfile = await profileManager.loadProfile(subProfileName);
+            if (isLoadBalancerProfile(subProfile)) {
+                throw new CompressionProfileNotFoundError(profileName, `load-balanced compression profile references nested load-balanced profile '${subProfileName}'`);
+            }
+            const candidate = await this.resolveStandardCompressionProvider(subProfileName, subProfile, profileManager, config, profile.ephemeralSettings);
+            if (!candidate.invocation) {
+                throw new CompressionProfileNotFoundError(profileName, `failed to build invocation context for subprofile '${subProfileName}'`);
+            }
+            candidates.push({
+                profileName: subProfileName,
+                provider: candidate.provider,
+                runtime: candidate.runtime,
+                config: candidate.config,
+                resolved: candidate.resolved,
+                invocation: candidate.invocation,
+            });
+        }
+        return candidates;
+    }
+    async resolveStandardCompressionProvider(profileName, profile, profileManager, config, parentEphemerals = {}) {
+        const provider = this.resolveExplicitCompressionProvider(profileName, profile.provider);
+        const profileSettings = new SettingsService();
+        await profileManager.applyLoadedProfile(profileName, profile, profileSettings);
+        this.applyCompressionProfileParentEphemerals(profileSettings, profile.provider, parentEphemerals);
+        this.applyCompressionProfileSettings(profileSettings, profileName, profile);
+        const runtimeId = `${this.runtimeContext.providerRuntime.runtimeId}::compression-profile:${profileName}`;
+        const metadata = {
+            ...(this.runtimeContext.providerRuntime.metadata ?? {}),
+            source: 'ChatSession.resolveCompressionProvider',
+            compressionProfile: profileName,
+            compressionProvider: profile.provider,
+            runtimeId,
+            provider: profile.provider,
+            model: profile.model,
+        };
+        const runtime = {
+            settingsService: profileSettings,
+            config,
+            runtimeId,
+            metadata,
+        };
+        const resolved = await this.buildCompressionProfileResolvedOptions(profileSettings, profile);
+        const invocation = createRuntimeInvocationContext({
+            runtime,
+            settings: profileSettings,
+            providerName: profile.provider,
+            ephemeralsSnapshot: this.buildCompressionProfileEphemeralsSnapshot(profileSettings, profile.provider),
+            metadata,
+            fallbackRuntimeId: runtimeId,
+        });
+        return {
+            provider,
+            runtime,
+            config,
+            resolved,
+            invocation,
+        };
+    }
+    applyCompressionProfileSettings(profileSettings, profileName, profile) {
+        const provider = profile.provider;
+        const ephemerals = profile.ephemeralSettings;
+        profileSettings.setCurrentProfileName(profileName);
+        profileSettings.set('activeProvider', provider);
+        profileSettings.set('model', profile.model);
+        profileSettings.setProviderSetting(provider, 'enabled', true);
+        profileSettings.setProviderSetting(provider, 'model', profile.model);
+        for (const [key, value] of Object.entries(ephemerals)) {
+            if (value !== undefined) {
+                profileSettings.set(key, value);
+                profileSettings.setProviderSetting(provider, key, value);
+            }
+        }
+        this.applyCompressionProfileAuthSettings(profileSettings, provider, ephemerals);
+        this.applyCompressionProfileModelParams(profileSettings, provider, profile.modelParams);
+        if (profile.auth) {
+            profileSettings.set('auth.type', profile.auth.type);
+            profileSettings.setProviderSetting(provider, 'auth', profile.auth);
+            if (profile.auth.buckets) {
+                profileSettings.set('auth.buckets', profile.auth.buckets);
+            }
+        }
+    }
+    applyCompressionProfileAuthSettings(profileSettings, provider, ephemerals) {
+        this.copyProfileSettingAliases(profileSettings, provider, ephemerals, [
+            { sourceKey: 'auth-key', globalKey: 'auth-key', providerKey: 'auth-key' },
+            {
+                sourceKey: 'auth-keyfile',
+                globalKey: 'auth-keyfile',
+                providerKey: 'auth-keyfile',
+            },
+            {
+                sourceKey: 'auth-key-name',
+                globalKey: 'auth-key-name',
+                providerKey: 'auth-key-name',
+            },
+        ]);
+        for (const key of ['base-url', 'sandbox-base-url', 'api-version']) {
+            const value = ephemerals[key];
+            if (value !== undefined) {
+                profileSettings.setProviderSetting(provider, key, value);
+            }
+        }
+    }
+    copyProfileSettingAliases(profileSettings, provider, ephemerals, aliases) {
+        for (const alias of aliases) {
+            const value = ephemerals[alias.sourceKey];
+            if (value === undefined) {
+                continue;
+            }
+            if (alias.globalKey) {
+                profileSettings.set(alias.globalKey, value);
+            }
+            profileSettings.setProviderSetting(provider, alias.providerKey, value);
+        }
+    }
+    applyCompressionProfileModelParams(profileSettings, provider, modelParams) {
+        for (const [key, value] of Object.entries(modelParams)) {
+            if (value !== undefined) {
+                profileSettings.setProviderSetting(provider, key, value);
+            }
+        }
+        const aliases = {
+            temperature: modelParams.temperature,
+            maxTokens: modelParams.max_tokens,
+            topP: modelParams.top_p,
+            topK: modelParams.top_k,
+            presencePenalty: modelParams.presence_penalty,
+            frequencyPenalty: modelParams.frequency_penalty,
+        };
+        for (const [key, value] of Object.entries(aliases)) {
+            if (value !== undefined) {
+                profileSettings.setProviderSetting(provider, key, value);
+            }
+        }
+    }
+    applyCompressionProfileParentEphemerals(profileSettings, provider, parentEphemerals) {
+        for (const [key, value] of Object.entries(parentEphemerals)) {
+            if (value !== undefined && profileSettings.get(key) === undefined) {
+                profileSettings.set(key, value);
+            }
+        }
+        for (const key of ['custom-headers', 'api-version', 'sandbox-base-url']) {
+            const value = parentEphemerals[key];
+            if (value !== undefined) {
+                profileSettings.setProviderSetting(provider, key, value);
+            }
+        }
+    }
+    resolveProviderBaseUrl(_provider) {
+        return this.runtimeState.baseUrl;
+    }
+    buildProviderRuntime(source, metadata = {}) {
+        const baseRuntime = this.runtimeContext.providerRuntime;
+        const runtimeId = 
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+        baseRuntime.runtimeId ?? this.runtimeState.runtimeId ?? 'chatSession';
+        return {
+            ...baseRuntime,
+            runtimeId,
+            metadata: {
+                ...(baseRuntime.metadata ?? {}),
+                source,
+                ...metadata,
+            },
+        };
+    }
+    async buildCompressionProfileResolvedOptions(profileSettings, profile) {
+        const providerSettings = profileSettings.getProviderSettings(profile.provider);
+        const baseURL = typeof providerSettings['base-url'] === 'string'
+            ? providerSettings['base-url']
+            : undefined;
+        const temperature = typeof providerSettings.temperature === 'number'
+            ? providerSettings.temperature
+            : undefined;
+        const maxTokens = typeof providerSettings.maxTokens === 'number'
+            ? providerSettings.maxTokens
+            : undefined;
+        return {
+            model: profile.model,
+            ...(baseURL ? { baseURL } : {}),
+            ...(await this.resolveCompressionProfileAuthToken(profileSettings, profile.provider)),
+            ...(temperature !== undefined ? { temperature } : {}),
+            ...(maxTokens !== undefined ? { maxTokens } : {}),
+        };
+    }
+    async resolveCompressionProfileAuthToken(profileSettings, provider) {
+        const providerSettings = profileSettings.getProviderSettings(provider);
+        const directAuth = this.getStringSettingFromValues([
+            providerSettings['auth-key'],
+            profileSettings.get('auth-key'),
+        ]);
+        if (directAuth) {
+            return { authToken: directAuth };
+        }
+        const keyName = this.getStringSettingFromValues([
+            providerSettings['auth-key-name'],
+            profileSettings.get('auth-key-name'),
+        ]);
+        if (keyName) {
+            const token = await getProviderKeyStorage().getKey(keyName);
+            if (token) {
+                return { authToken: token };
+            }
+        }
+        const keyFile = this.getStringSettingFromValues([
+            providerSettings['auth-keyfile'],
+            profileSettings.get('auth-keyfile'),
+        ]);
+        if (keyFile) {
+            const token = (await fs.readFile(this.expandProfilePath(keyFile), 'utf8')).trim();
+            if (token) {
+                return { authToken: token };
+            }
+        }
+        return {};
+    }
+    getStringSettingFromValues(values) {
+        for (const value of values) {
+            if (typeof value === 'string' && value.trim() !== '') {
+                return value.trim();
+            }
+        }
+        return undefined;
+    }
+    expandProfilePath(value) {
+        if (value.startsWith('~/')) {
+            return path.join(os.homedir(), value.slice(2));
+        }
+        return value;
+    }
+    buildCompressionProfileEphemeralsSnapshot(profileSettings, provider) {
+        return {
+            ...profileSettings.getAllGlobalSettings(),
+            [provider]: { ...profileSettings.getProviderSettings(provider) },
+        };
+    }
+    // ── Position matcher (used by multiple modules) ──────────────────
+    _makePositionMatcher() {
+        return this.conversationManager.makePositionMatcher();
+    }
+    // ── Public API — thin delegation ─────────────────────────────────
+    async sendMessage(params, prompt_id) {
+        return this.turnProcessor.sendMessage(params, prompt_id);
+    }
+    async sendMessageStream(params, prompt_id) {
+        return this.turnProcessor.sendMessageStream(params, prompt_id);
+    }
+    async generateDirectMessage(params, prompt_id) {
+        return this.directMessageProcessor.generateDirectMessage(params, prompt_id);
+    }
+    async waitForIdle() {
+        return this.turnProcessor.waitForIdle();
+    }
+    setSystemInstruction(sysInstr) {
+        this.generationConfig.systemInstruction = sysInstr;
+    }
+    getHistoryService() {
+        return this.historyService;
+    }
+    getToolsView() {
+        return this.runtimeContext.tools;
+    }
+    setTools(tools) {
+        this.generationConfig.tools = tools;
+    }
+    clearTools() {
+        this.generationConfig.tools = undefined;
+    }
+    getHistory(curated = false) {
+        return this.conversationManager.getHistory(curated);
+    }
+    clearHistory() {
+        this.conversationManager.clearHistory();
+    }
+    addHistory(content) {
+        this.conversationManager.addHistory(content);
+    }
+    setHistory(history) {
+        this.conversationManager.setHistory(history);
+    }
+    setActiveTodosProvider(provider) {
+        this.compressionHandler.setActiveTodosProvider(provider);
+    }
+    async performCompression(prompt_id, options) {
+        return this.compressionHandler.performCompression(prompt_id, options);
+    }
+    wasRecentlyCompressed() {
+        return this.compressionHandler.wasRecentlyCompressed();
+    }
+    getLastPromptTokenCount() {
+        return this.compressionHandler.lastPromptTokenCount ?? 0;
+    }
+    recordCompletedToolCalls(_model, _toolCalls) {
+        // No-op stub for compatibility
+    }
+    // Public conversion methods — delegated to standalone functions
+    convertPartListUnionToIContent(input) {
+        return convertPartListUnionToIContent(input);
+    }
+    convertIContentToResponse(input) {
+        return convertIContentToResponse(input);
+    }
+    async estimatePendingTokens(contents) {
+        return this.turnProcessor.estimatePendingTokens(contents);
+    }
+    // ── Internal compat pass-throughs (used by tests via `as never` casts) ──
+    get densityDirty() {
+        return this.compressionHandler.densityDirty;
+    }
+    set densityDirty(value) {
+        this.compressionHandler.densityDirty = value;
+    }
+    get _suppressDensityDirty() {
+        return this.compressionHandler._suppressDensityDirty;
+    }
+    set _suppressDensityDirty(value) {
+        this.compressionHandler._suppressDensityDirty = value;
+    }
+    async ensureDensityOptimized() {
+        return this.compressionHandler.ensureDensityOptimized();
+    }
+    async ensureCompressionBeforeSend(promptId, pendingTokens, source, trigger = 'auto') {
+        return this.compressionHandler.ensureCompressionBeforeSend(promptId, pendingTokens, source, trigger);
+    }
+    async enforceContextWindow(pendingTokens, promptId) {
+        return this.compressionHandler.enforceContextWindow(pendingTokens, promptId);
+    }
+    shouldCompress(pendingTokens) {
+        return this.compressionHandler.shouldCompress(pendingTokens);
+    }
+    /**
+     * Returns the Config instance from the provider runtime.
+     * Used by Turn and other consumers to access ephemeral settings.
+     */
+    getConfig() {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Gemini chat runtime payloads.
+        return this.runtimeContext.providerRuntime?.config;
+    }
+}
+//# sourceMappingURL=chatSession.js.map