@vybestack/llxprt-code-core 0.4.8 → 0.5.0-nightly.251102.e5b51aa3

package/dist/src/core/geminiChat.js

@@ -8,17 +8,12 @@
 import { createUserContent, } from '@google/genai';
 import { retryWithBackoff } from '../utils/retry.js';
 import { isFunctionResponse } from '../utils/messageInspectors.js';
-import { HistoryService } from '../services/history/HistoryService.js';
 import { ContentConverters } from '../services/history/ContentConverters.js';
-// import { estimateTokens } from '../utils/toolOutputLimiter.js'; // Unused after retry stream refactor
-import { logApiRequest, logApiResponse, logApiError, } from '../telemetry/loggers.js';
-import { ApiErrorEvent, ApiRequestEvent, ApiResponseEvent, } from '../telemetry/types.js';
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { hasCycleInSchema } from '../tools/tools.js';
 import { isStructuredError } from '../utils/quotaErrorDetection.js';
 import { DebugLogger } from '../debug/index.js';
 import { getCompressionPrompt } from './prompts.js';
-import { COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, } from './compression-config.js';
 import { estimateTokens as estimateTextTokens } from '../utils/toolOutputLimiter.js';
 import { tokenLimit } from './tokenLimits.js';
 export var StreamEventType;
@@ -255,8 +250,6 @@ export class EmptyStreamError extends Error {
  * The session maintains all the turns between user and model.
  */
 export class GeminiChat {
-    config;
-    generationConfig;
     static TOKEN_SAFETY_MARGIN = 256;
     static DEFAULT_COMPLETION_BUDGET = 65_536;
     // A promise to represent the current state of the message being sent to the
@@ -264,31 +257,50 @@ export class GeminiChat {
     sendPromise = Promise.resolve();
     // A promise to represent any ongoing compression operation
     compressionPromise = null;
-    historyService;
     logger = new DebugLogger('llxprt:gemini:chat');
     // Cache the compression threshold to avoid recalculating
     cachedCompressionThreshold = null;
-    constructor(config, contentGenerator, generationConfig = {}, initialHistory = [], historyService) {
-        this.config = config;
+    generationConfig;
+    /**
+     * Runtime state for stateless operation (Phase 6)
+     * @plan PLAN-20251028-STATELESS6.P10
+     * @requirement REQ-STAT6-001.2
+     * @pseudocode agent-runtime-context.md lines 83-91 (step 006)
+     */
+    runtimeState;
+    historyService;
+    runtimeContext;
+    /**
+     * @plan PLAN-20251028-STATELESS6.P10
+     * @requirement REQ-STAT6-001.2, REQ-STAT6-002.2, REQ-STAT6-002.3
+     * @pseudocode agent-runtime-context.md lines 83-91 (step 006.1-006.2)
+     *
+     * Phase 6 constructor: Accept AgentRuntimeContext as first parameter
+     * Eliminates Config dependency by using runtime view adapters
+     */
+    constructor(view, contentGenerator, generationConfig = {}, initialHistory = []) {
+        if (!view) {
+            throw new Error('AgentRuntimeContext is required for GeminiChat');
+        }
+        // Step 006.2: Extract runtime state and history from view
+        this.runtimeContext = view;
+        this.runtimeState = view.state;
+        this.historyService = view.history;
         this.generationConfig = generationConfig;
+        void contentGenerator;
         validateHistory(initialHistory);
-        // Use provided HistoryService or create a new one
-        this.historyService = historyService || new HistoryService();
+        const model = this.runtimeState.model;
         this.logger.debug('GeminiChat initialized:', {
-            model: this.config.getModel(),
+            model,
             initialHistoryLength: initialHistory.length,
-            hasHistoryService: !!historyService,
+            hasHistoryService: !!this.historyService,
+            hasRuntimeState: true,
         });
-        // Convert and add initial history if provided
         if (initialHistory.length > 0) {
-            const currentModel = this.config.getModel();
-            this.logger.debug('Adding initial history to service:', {
-                count: initialHistory.length,
-            });
             const idGen = this.historyService.getIdGeneratorCallback();
             for (const content of initialHistory) {
                 const matcher = this.makePositionMatcher();
-                this.historyService.add(ContentConverters.toIContent(content, idGen, matcher), currentModel);
+                this.historyService.add(ContentConverters.toIContent(content, idGen, matcher), model);
             }
         }
     }
@@ -314,17 +326,77 @@ export class GeminiChat {
     _getRequestTextFromContents(contents) {
         return JSON.stringify(contents);
     }
-    async _logApiRequest(contents, model, prompt_id) {
+    buildProviderRuntime(source, metadata = {}) {
+        const baseRuntime = this.runtimeContext.providerRuntime;
+        const runtimeId = baseRuntime.runtimeId ?? this.runtimeState.runtimeId ?? 'geminiChat';
+        return {
+            ...baseRuntime,
+            runtimeId,
+            metadata: {
+                ...(baseRuntime.metadata ?? {}),
+                source,
+                ...metadata,
+            },
+        };
+    }
+    /**
+     * @plan PLAN-20251028-STATELESS6.P10
+     * @requirement REQ-STAT6-002.3
+     * @pseudocode agent-runtime-context.md line 88 (step 006.5)
+     */
+    async _logApiRequest(contents, model, promptId) {
         const requestText = this._getRequestTextFromContents(contents);
-        logApiRequest(this.config, new ApiRequestEvent(model, prompt_id, requestText));
+        // Step 006.5: Replace telemetry logging with view.telemetry adapter
+        this.runtimeContext.telemetry.logApiRequest({
+            model,
+            promptId,
+            requestText,
+            sessionId: this.runtimeState.sessionId,
+            runtimeId: this.runtimeState.runtimeId,
+            provider: this.runtimeState.provider,
+            authType: this.runtimeState.authType,
+            timestamp: Date.now(),
+        });
     }
-    async _logApiResponse(durationMs, prompt_id, usageMetadata, responseText) {
-        logApiResponse(this.config, new ApiResponseEvent(this.config.getModel(), durationMs, prompt_id, this.config.getContentGeneratorConfig()?.authType, usageMetadata, responseText));
+    /**
+     * @plan PLAN-20251028-STATELESS6.P10
+     * @requirement REQ-STAT6-002.3
+     * @pseudocode agent-runtime-context.md line 88 (step 006.5)
+     */
+    async _logApiResponse(durationMs, promptId, usageMetadata, responseText) {
+        // Step 006.5: Replace telemetry logging with view.telemetry adapter
+        this.runtimeContext.telemetry.logApiResponse({
+            model: this.runtimeState.model,
+            promptId,
+            durationMs,
+            authType: this.runtimeState.authType,
+            sessionId: this.runtimeState.sessionId,
+            runtimeId: this.runtimeState.runtimeId,
+            provider: this.runtimeState.provider,
+            usageMetadata,
+            responseText,
+        });
     }
-    _logApiError(durationMs, error, prompt_id) {
+    /**
+     * @plan PLAN-20251028-STATELESS6.P10
+     * @requirement REQ-STAT6-002.3
+     * @pseudocode agent-runtime-context.md line 88 (step 006.5)
+     */
+    _logApiError(durationMs, error, promptId) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const errorType = error instanceof Error ? error.name : 'unknown';
-        logApiError(this.config, new ApiErrorEvent(this.config.getModel(), errorMessage, durationMs, prompt_id, this.config.getContentGeneratorConfig()?.authType, errorType));
+        // Step 006.5: Replace telemetry logging with view.telemetry adapter
+        this.runtimeContext.telemetry.logApiError({
+            model: this.runtimeState.model,
+            promptId,
+            durationMs,
+            error: errorMessage,
+            errorType,
+            authType: this.runtimeState.authType,
+            sessionId: this.runtimeState.sessionId,
+            runtimeId: this.runtimeState.runtimeId,
+            provider: this.runtimeState.provider,
+        });
     }
     setSystemInstruction(sysInstr) {
         this.generationConfig.systemInstruction = sysInstr;
@@ -336,6 +408,9 @@ export class GeminiChat {
     getHistoryService() {
         return this.historyService;
     }
+    getToolsView() {
+        return this.runtimeContext.tools;
+    }
     /**
      * Sends a message to the model and returns the response.
      *
@@ -368,10 +443,41 @@ export class GeminiChat {
         await this.ensureCompressionBeforeSend(prompt_id, pendingTokens, 'send');
         // DO NOT add user content to history yet - use send-then-commit pattern
         // Get the active provider
-        const provider = this.getActiveProvider();
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-002.2
+        // @pseudocode agent-runtime-context.md line 87 (step 006.4)
+        let provider = this.getActiveProvider();
         if (!provider) {
             throw new Error('No active provider configured');
         }
+        // Step 006.4: Replace providerManager access with view.provider adapter
+        const desiredProviderName = this.runtimeState.provider;
+        if (desiredProviderName && provider.name !== desiredProviderName) {
+            const previousProviderName = provider.name;
+            try {
+                this.runtimeContext.provider.setActiveProvider(desiredProviderName);
+                const updatedProvider = this.runtimeContext.provider.getActiveProvider();
+                if (updatedProvider) {
+                    provider = updatedProvider;
+                }
+                this.logger.debug(() => `[GeminiChat] enforced provider switch to '${desiredProviderName}' (previous '${previousProviderName}')`);
+            }
+            catch (error) {
+                this.logger.debug(() => `[GeminiChat] provider switch skipped (read-only context): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const activeAuthType = this.runtimeState.authType;
+        const providerBaseUrl = this.resolveProviderBaseUrl(provider);
+        // @plan PLAN-20251027-STATELESS5.P10
+        // @requirement REQ-STAT5-004.1
+        this.logger.debug(() => '[GeminiChat] Active provider snapshot before stream/send', {
+            providerName: provider.name,
+            providerDefaultModel: provider.getDefaultModel?.(),
+            configModel: this.runtimeState.model,
+            baseUrl: providerBaseUrl,
+            authType: activeAuthType,
+        });
+        // Enforce context window limits before proceeding
         await this.enforceContextWindow(pendingTokens, prompt_id, provider);
         // Check if provider supports IContent interface
         if (!this.providerSupportsIContent(provider)) {
@@ -381,12 +487,16 @@ export class GeminiChat {
         const currentHistory = this.historyService.getCuratedForProvider();
         // Build request with history + new message(s)
         const iContents = [...currentHistory, ...userIContents];
-        this._logApiRequest(ContentConverters.toGeminiContents(iContents), this.config.getModel(), prompt_id);
+        // @plan PLAN-20251027-STATELESS5.P10
+        // @requirement REQ-STAT5-004.1
+        this._logApiRequest(ContentConverters.toGeminiContents(iContents), this.runtimeState.model, prompt_id);
         const startTime = Date.now();
         let response;
         try {
             const apiCall = async () => {
-                const modelToUse = this.config.getModel() || DEFAULT_GEMINI_FLASH_MODEL;
+                // @plan PLAN-20251027-STATELESS5.P10
+                // @requirement REQ-STAT5-004.1
+                const modelToUse = this.runtimeState.model || DEFAULT_GEMINI_FLASH_MODEL;
                 // Get tools in the format the provider expects
                 const tools = this.generationConfig.tools;
                 // Critical debug for intermittent "Tool not present" errors
@@ -426,7 +536,24 @@ export class GeminiChat {
                     providerName: provider.name,
                 });
                 // Call the provider directly with IContent
-                const streamResponse = provider.generateChatCompletion(iContents, tools);
+                // @plan PLAN-20251027-STATELESS5.P10
+                // @requirement REQ-STAT5-004.1
+                this.logger.debug(() => '[GeminiChat] Calling provider.generateChatCompletion', {
+                    providerName: provider.name,
+                    model: this.runtimeState.model,
+                    toolCount: tools?.length ?? 0,
+                    baseUrl: this.resolveProviderBaseUrl(provider),
+                    authType: this.runtimeState.authType,
+                });
+                const runtimeContext = this.buildProviderRuntime('GeminiChat.trySendMessage', { toolCount: tools?.length ?? 0 });
+                const streamResponse = provider.generateChatCompletion({
+                    contents: iContents,
+                    tools: tools,
+                    config: runtimeContext.config,
+                    runtime: runtimeContext,
+                    settings: runtimeContext.settingsService,
+                    metadata: runtimeContext.metadata,
+                });
                 // Collect all chunks from the stream
                 let lastResponse;
                 for await (const iContent of streamResponse) {
@@ -457,7 +584,9 @@ export class GeminiChat {
             this.sendPromise = (async () => {
                 const outputContent = response.candidates?.[0]?.content;
                 // Send-then-commit: Now that we have a successful response, add both user and model messages
-                const currentModel = this.config.getModel();
+                // @plan PLAN-20251027-STATELESS5.P10
+                // @requirement REQ-STAT5-004.1
+                const currentModel = this.runtimeState.model;
                 // Handle AFC history or regular history
                 const fullAutomaticFunctionCallingHistory = response.automaticFunctionCallingHistory;
                 if (fullAutomaticFunctionCallingHistory &&
@@ -546,7 +675,9 @@ export class GeminiChat {
      */
     async sendMessageStream(params, prompt_id) {
         this.logger.debug(() => 'DEBUG [geminiChat]: ===== SEND MESSAGE STREAM START =====');
-        this.logger.debug(() => `DEBUG [geminiChat]: Model from config: ${this.config.getModel()}`);
+        // @plan PLAN-20251027-STATELESS5.P10
+        // @requirement REQ-STAT5-004.1
+        this.logger.debug(() => `DEBUG [geminiChat]: Model from config: ${this.runtimeState.model}`);
         this.logger.debug(() => `DEBUG [geminiChat]: Params: ${JSON.stringify(params, null, 2)}`);
         this.logger.debug(() => `DEBUG [geminiChat]: Message type: ${typeof params.message}`);
         this.logger.debug(() => `DEBUG [geminiChat]: Message content: ${JSON.stringify(params.message, null, 2)}`);
@@ -576,7 +707,7 @@ export class GeminiChat {
         return (async function* (instance) {
             try {
                 let lastError = new Error('Request failed after all retries.');
-                for (let attempt = 0; attempt <= INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
+                for (let attempt = 0; attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
                     try {
                         if (attempt > 0) {
                             yield { type: StreamEventType.RETRY };
@@ -613,12 +744,142 @@ export class GeminiChat {
             }
         })(this);
     }
+    async generateDirectMessage(params, prompt_id) {
+        const provider = this.getActiveProvider();
+        if (!provider) {
+            throw new Error('No active provider configured');
+        }
+        const userContent = normalizeToolInteractionInput(params.message);
+        const idGen = this.historyService.getIdGeneratorCallback();
+        const matcher = this.makePositionMatcher();
+        const userIContents = Array.isArray(userContent)
+            ? userContent.map((content) => ContentConverters.toIContent(content, idGen, matcher))
+            : [ContentConverters.toIContent(userContent, idGen, matcher)];
+        const requestContents = ContentConverters.toGeminiContents(userIContents);
+        // @plan PLAN-20251027-STATELESS5.P10
+        // @requirement REQ-STAT5-004.1
+        await this._logApiRequest(requestContents, this.runtimeState.model, prompt_id);
+        const startTime = Date.now();
+        let aggregatedText = '';
+        try {
+            const response = await retryWithBackoff(async () => {
+                const toolsFromConfig = params.config?.tools && Array.isArray(params.config.tools)
+                    ? params.config.tools
+                    : undefined;
+                const baseUrlForCall = this.resolveProviderBaseUrl(provider);
+                const activeAuthType = this.runtimeState.authType;
+                // @plan PLAN-20251027-STATELESS5.P10
+                // @requirement REQ-STAT5-004.1
+                this.logger.debug(() => '[GeminiChat] Calling provider.generateChatCompletion (non-stream retry path)', {
+                    providerName: provider.name,
+                    model: this.runtimeState.model,
+                    toolCount: toolsFromConfig?.length ?? 0,
+                    baseUrl: baseUrlForCall,
+                    authType: activeAuthType,
+                });
+                const runtimeContext = this.buildProviderRuntime('GeminiChat.streamGeneration', { toolCount: toolsFromConfig?.length ?? 0 });
+                const streamResponse = provider.generateChatCompletion({
+                    contents: userIContents,
+                    tools: toolsFromConfig && toolsFromConfig.length > 0
+                        ? toolsFromConfig
+                        : undefined,
+                    config: runtimeContext.config,
+                    runtime: runtimeContext,
+                    settings: runtimeContext.settingsService,
+                    metadata: runtimeContext.metadata,
+                });
+                let lastResponse;
+                for await (const iContent of streamResponse) {
+                    lastResponse = iContent;
+                    for (const block of iContent.blocks ?? []) {
+                        if (block.type === 'text') {
+                            aggregatedText += block.text;
+                        }
+                    }
+                }
+                if (!lastResponse) {
+                    throw new Error('No response from provider');
+                }
+                const directResponse = this.convertIContentToResponse(lastResponse);
+                if (aggregatedText.trim()) {
+                    const candidate = directResponse.candidates?.[0];
+                    if (candidate) {
+                        const parts = candidate.content?.parts ?? [];
+                        const hasText = parts.some((part) => 'text' in part && part.text?.trim());
+                        if (!hasText) {
+                            candidate.content = candidate.content || {
+                                role: 'model',
+                                parts: [],
+                            };
+                            candidate.content.parts = [
+                                ...(candidate.content.parts || []),
+                                { text: aggregatedText },
+                            ];
+                        }
+                    }
+                    Object.defineProperty(directResponse, 'text', {
+                        configurable: true,
+                        get() {
+                            return aggregatedText;
+                        },
+                    });
+                }
+                return directResponse;
+            }, {
+                shouldRetry: (error) => {
+                    if (error instanceof Error && error.message) {
+                        if (isSchemaDepthError(error.message))
+                            return false;
+                        if (error.message.includes('429'))
+                            return true;
+                        if (error.message.match(/5\d{2}/))
+                            return true;
+                    }
+                    return false;
+                },
+            });
+            const durationMs = Date.now() - startTime;
+            await this._logApiResponse(durationMs, prompt_id, response.usageMetadata, JSON.stringify(response));
+            return response;
+        }
+        catch (error) {
+            const durationMs = Date.now() - startTime;
+            this._logApiError(durationMs, error, prompt_id);
+            throw error;
+        }
+    }
     async makeApiCallAndProcessStream(_params, promptId, pendingTokens, userContent) {
         // Get the active provider
-        const provider = this.getActiveProvider();
+        let provider = this.getActiveProvider();
         if (!provider) {
             throw new Error('No active provider configured');
         }
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-002.2
+        // @pseudocode agent-runtime-context.md line 87 (step 006.4)
+        const desiredProviderName = this.runtimeState.provider;
+        // Step 006.4: Replace providerManager access with view.provider adapter
+        if (desiredProviderName && provider.name !== desiredProviderName) {
+            const previousProviderName = provider.name;
+            try {
+                this.runtimeContext.provider.setActiveProvider(desiredProviderName);
+                provider = this.runtimeContext.provider.getActiveProvider();
+                this.logger.debug(() => `[GeminiChat] enforced provider switch (stream path) to '${desiredProviderName}' (previous '${previousProviderName}')`);
+            }
+            catch (error) {
+                this.logger.debug(() => `[GeminiChat] provider switch skipped (stream path, read-only context): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const activeAuthType = this.runtimeState.authType;
+        const providerBaseUrl = this.resolveProviderBaseUrl(provider);
+        this.logger.debug(() => '[GeminiChat] Active provider snapshot before stream request', {
+            providerName: provider.name,
+            providerDefaultModel: provider.getDefaultModel?.(),
+            configModel: this.runtimeState.model,
+            baseUrl: providerBaseUrl,
+            authType: activeAuthType,
+        });
+        // Enforce context window limits before proceeding
         await this.enforceContextWindow(pendingTokens, promptId, provider);
         // Check if provider supports IContent interface
         if (!this.providerSupportsIContent(provider)) {
@@ -649,7 +910,23 @@ export class GeminiChat {
             // Get tools in the format the provider expects
             const tools = this.generationConfig.tools;
             // Call the provider directly with IContent
-            const streamResponse = provider.generateChatCompletion(requestContents, tools);
+            this.logger.debug(() => '[GeminiChat] Calling provider.generateChatCompletion (generatorRequest)', {
+                providerName: provider.name,
+                model: this.runtimeState.model,
+                historyLength: requestContents.length,
+                toolCount: tools?.length ?? 0,
+                baseUrl: providerBaseUrl,
+                authType: activeAuthType,
+            });
+            const runtimeContext = this.buildProviderRuntime('GeminiChat.generateRequest', { historyLength: requestContents.length });
+            const streamResponse = provider.generateChatCompletion({
+                contents: requestContents,
+                tools: tools,
+                config: runtimeContext.config,
+                runtime: runtimeContext,
+                settings: runtimeContext.settingsService,
+                metadata: runtimeContext.metadata,
+            });
             // Convert the IContent stream to GenerateContentResponse stream
             return (async function* (instance) {
                 for await (const iContent of streamResponse) {
@@ -716,11 +993,11 @@ export class GeminiChat {
      * Adds a new entry to the chat history.
      */
     addHistory(content) {
-        this.historyService.add(ContentConverters.toIContent(content), this.config.getModel());
+        this.historyService.add(ContentConverters.toIContent(content), this.runtimeState.model);
     }
     setHistory(history) {
         this.historyService.clear();
-        const currentModel = this.config.getModel();
+        const currentModel = this.runtimeState.model;
         for (const content of history) {
             this.historyService.add(ContentConverters.toIContent(content), currentModel);
         }
@@ -730,12 +1007,16 @@ export class GeminiChat {
     }
     /**
      * Check if compression is needed based on token count
+     * @plan PLAN-20251028-STATELESS6.P10
+     * @requirement REQ-STAT6-002.2
+     * @pseudocode agent-runtime-context.md line 86 (step 006.3)
      */
     shouldCompress(pendingTokens = 0) {
         // Calculate compression threshold only if not cached
         if (this.cachedCompressionThreshold === null) {
-            const threshold = this.config.getEphemeralSetting('compression-threshold') ?? COMPRESSION_TOKEN_THRESHOLD;
-            const contextLimit = this.config.getEphemeralSetting('context-limit') ?? 60000; // Default context limit
+            // Step 006.3: Replace config.getEphemeralSetting with view.ephemerals
+            const threshold = this.runtimeContext.ephemerals.compressionThreshold();
+            const contextLimit = this.runtimeContext.ephemerals.contextLimit();
             this.cachedCompressionThreshold = threshold * contextLimit;
             this.logger.debug('Calculated compression threshold:', {
                 threshold,
@@ -786,7 +1067,7 @@ export class GeminiChat {
             return 0;
         }
         try {
-            return await this.historyService.estimateTokensForContents(contents, this.config.getModel());
+            return await this.historyService.estimateTokensForContents(contents, this.runtimeState.model);
         }
         catch (error) {
             this.logger.debug('Failed to estimate pending tokens with tokenizer, using fallback', error);
@@ -875,27 +1156,18 @@ export class GeminiChat {
         const generationBudget = this.asNumber(this.generationConfig.maxOutputTokens);
         const providerParams = provider?.getModelParams?.();
         const providerBudget = this.extractCompletionBudgetFromParams(providerParams);
-        let configBudget;
-        if (typeof this.config.getEphemeralSetting === 'function') {
-            const candidateKeys = ['maxOutputTokens', 'max-output-tokens'];
-            for (const key of candidateKeys) {
-                const value = this.asNumber(this.config.getEphemeralSetting(key));
-                if (value !== undefined) {
-                    configBudget = value;
-                    break;
-                }
-            }
-        }
-        return (generationBudget ??
-            providerBudget ??
-            configBudget ??
-            GeminiChat.DEFAULT_COMPLETION_BUDGET);
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-002.2
+        // @pseudocode agent-runtime-context.md line 86 (step 006.3)
+        // Note: maxOutputTokens is not part of core ephemerals; removed config dependency
+        return (generationBudget ?? providerBudget ?? GeminiChat.DEFAULT_COMPLETION_BUDGET);
     }
     async enforceContextWindow(pendingTokens, promptId, provider) {
         await this.historyService.waitForTokenUpdates();
         const completionBudget = Math.max(0, this.getCompletionBudget(provider));
-        const userContextLimit = this.config.getEphemeralSetting('context-limit');
-        const limit = tokenLimit(this.config.getModel(), userContextLimit);
+        // Merged from main: Use user context limit from ephemerals
+        const userContextLimit = this.runtimeContext.ephemerals.contextLimit();
+        const limit = tokenLimit(this.runtimeState.model, userContextLimit);
         const marginAdjustedLimit = Math.max(0, limit - GeminiChat.TOKEN_SAFETY_MARGIN);
         const projected = this.historyService.getTotalTokens() +
             Math.max(0, pendingTokens) +
@@ -961,7 +1233,10 @@ export class GeminiChat {
     getCompressionSplit() {
         const curated = this.historyService.getCurated();
         // Calculate split point (keep last 30%)
-        const preserveThreshold = this.config.getEphemeralSetting('compression-preserve-threshold') ?? COMPRESSION_PRESERVE_THRESHOLD;
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-002.2
+        // @pseudocode agent-runtime-context.md line 86 (step 006.3)
+        const preserveThreshold = this.runtimeContext.ephemerals.preserveThreshold();
         let splitIndex = Math.floor(curated.length * (1 - preserveThreshold));
         // Adjust for tool call boundaries
         splitIndex = this.adjustForToolCallBoundary(curated, splitIndex);
@@ -1009,10 +1284,30 @@ export class GeminiChat {
      * Direct API call for compression, bypassing normal message flow
      */
     async directCompressionCall(historyToCompress, _prompt_id) {
-        const provider = this.getActiveProvider();
-        if (!provider || !this.providerSupportsIContent(provider)) {
+        let provider = this.getActiveProvider();
+        if (!provider) {
+            throw new Error('No active provider configured');
+        }
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-002.2
+        // @pseudocode agent-runtime-context.md line 87 (step 006.4)
+        const desiredProviderName = this.runtimeState.provider;
+        // Step 006.4: Replace providerManager access with view.provider adapter
+        if (desiredProviderName && provider.name !== desiredProviderName) {
+            try {
+                this.runtimeContext.provider.setActiveProvider(desiredProviderName);
+                provider = this.runtimeContext.provider.getActiveProvider();
+                this.logger.debug(() => `[GeminiChat] enforced provider switch (compression) to '${desiredProviderName}'`);
+            }
+            catch (error) {
+                this.logger.debug(() => `[GeminiChat] provider switch skipped (compression, read-only context): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (!this.providerSupportsIContent(provider)) {
             throw new Error('Provider does not support compression');
         }
+        const activeAuthType = this.runtimeState.authType;
+        const providerBaseUrl = this.resolveProviderBaseUrl(provider);
         // Build compression request with system prompt and user history
         const compressionRequest = [
             // Add system instruction as the first message
@@ -1039,7 +1334,22 @@ export class GeminiChat {
             },
         ];
         // Direct provider call without tools for compression
-        const stream = provider.generateChatCompletion(compressionRequest, undefined);
+        this.logger.debug(() => '[GeminiChat] Calling provider.generateChatCompletion (directCompression)', {
+            providerName: provider.name,
+            model: this.runtimeState.model,
+            historyLength: compressionRequest.length,
+            baseUrl: providerBaseUrl,
+            authType: activeAuthType,
+        });
+        const runtimeContext = this.buildProviderRuntime('GeminiChat.directCompression', { historyLength: compressionRequest.length });
+        const stream = provider.generateChatCompletion({
+            contents: compressionRequest,
+            tools: undefined,
+            config: runtimeContext.config,
+            runtime: runtimeContext,
+            settings: runtimeContext.settingsService,
+            metadata: runtimeContext.metadata,
+        });
         // Collect response
         let summary = '';
         for await (const chunk of stream) {
@@ -1059,7 +1369,7 @@ export class GeminiChat {
     applyCompression(summary, toKeep) {
         // Clear and rebuild history atomically
         this.historyService.clear();
-        const currentModel = this.config.getModel();
+        const currentModel = this.runtimeState.model;
         // Add compressed summary as user message
         this.historyService.add({
             speaker: 'human',
@@ -1204,7 +1514,7 @@ export class GeminiChat {
             }
         }
         // Part 4: Add the new turn (user and model parts) to the history service.
-        const currentModel = this.config.getModel();
+        const currentModel = this.runtimeState.model;
         for (const entry of newHistoryEntries) {
             this.historyService.add(entry, currentModel);
         }
@@ -1244,147 +1554,25 @@ export class GeminiChat {
             typeof content.parts[0].thought === 'boolean' &&
             content.parts[0].thought === true);
     }
-    /**
-     * Trim prompt contents to fit within token limit
-     * Strategy: Keep the most recent user message, trim older history and tool outputs
-     */
-    //   private _trimPromptContents(
-    //     contents: Content[],
-    //     maxTokens: number,
-    //   ): Content[] {
-    //     if (contents.length === 0) return contents;
-    //
-    //     // Always keep the last message (current user input)
-    //     const lastMessage = contents[contents.length - 1];
-    //     const result: Content[] = [];
-    //
-    //     // Reserve tokens for the last message and warning
-    //     const lastMessageTokens = estimateTokens(JSON.stringify(lastMessage));
-    //     const warningTokens = 200; // Reserve for warning message
-    //     let remainingTokens = maxTokens - lastMessageTokens - warningTokens;
-    //
-    //     if (remainingTokens <= 0) {
-    //       // Even the last message is too big, truncate it
-    //       return [this._truncateContent(lastMessage, maxTokens - warningTokens)];
-    //     }
-    //
-    //     // Add messages from most recent to oldest, stopping when we hit the limit
-    //     for (let i = contents.length - 2; i >= 0; i--) {
-    //       const content = contents[i];
-    //       const contentTokens = estimateTokens(JSON.stringify(content));
-    //
-    //       if (contentTokens <= remainingTokens) {
-    //         result.unshift(content);
-    //         remainingTokens -= contentTokens;
-    //       } else if (remainingTokens > 100) {
-    //         // Try to truncate this content to fit
-    //         const truncated = this._truncateContent(content, remainingTokens);
-    //         // Only add if we actually got some content back
-    //         if (truncated.parts && truncated.parts.length > 0) {
-    //           result.unshift(truncated);
-    //         }
-    //         break;
-    //       } else {
-    //         // No room left, stop
-    //         break;
-    //       }
-    //     }
-    //
-    //     // Add the last message
-    //     result.push(lastMessage);
-    //
-    //     return result;
-    //   }
-    //
-    /**
-     * Truncate a single content to fit within token limit
-     */
-    //   private _truncateContent(content: Content, maxTokens: number): Content {
-    //     if (!content.parts || content.parts.length === 0) {
-    //       return content;
-    //     }
-    //
-    //     const truncatedParts: Part[] = [];
-    //     let currentTokens = 0;
-    //
-    //     for (const part of content.parts) {
-    //       if ('text' in part && part.text) {
-    //         const partTokens = estimateTokens(part.text);
-    //         if (currentTokens + partTokens <= maxTokens) {
-    //           truncatedParts.push(part);
-    //           currentTokens += partTokens;
-    //         } else {
-    //           // Truncate this part
-    //           const remainingTokens = maxTokens - currentTokens;
-    //           if (remainingTokens > 10) {
-    //             const remainingChars = remainingTokens * 4;
-    //             truncatedParts.push({
-    //               text:
-    //                 part.text.substring(0, remainingChars) +
-    //                 '\n[...content truncated due to token limit...]',
-    //             });
-    //           }
-    //           break;
-    //         }
-    //       } else {
-    //         // Non-text parts (function calls, responses, etc) - NEVER truncate these
-    //         // Either include them fully or skip them entirely to avoid breaking JSON
-    //         const partTokens = estimateTokens(JSON.stringify(part));
-    //         if (currentTokens + partTokens <= maxTokens) {
-    //           truncatedParts.push(part);
-    //           currentTokens += partTokens;
-    //         } else {
-    //           // Skip this part entirely - DO NOT truncate function calls/responses
-    //           // Log what we're skipping for debugging
-    //           if (process.env.DEBUG || process.env.VERBOSE) {
-    //             let skipInfo = 'unknown part';
-    //             if ('functionCall' in part) {
-    //               const funcPart = part as { functionCall?: { name?: string } };
-    //               skipInfo = `functionCall: ${funcPart.functionCall?.name || 'unnamed'}`;
-    //             } else if ('functionResponse' in part) {
-    //               const respPart = part as { functionResponse?: { name?: string } };
-    //               skipInfo = `functionResponse: ${respPart.functionResponse?.name || 'unnamed'}`;
-    //             }
-    //             console.warn(
-    //               `INFO: Skipping ${skipInfo} due to token limit (needs ${partTokens} tokens, only ${maxTokens - currentTokens} available)`,
-    //             );
-    //           }
-    //           // Add a marker that content was omitted
-    //           if (
-    //             truncatedParts.length > 0 &&
-    //             !truncatedParts.some(
-    //               (p) =>
-    //                 'text' in p &&
-    //                 p.text?.includes(
-    //                   '[...function calls omitted due to token limit...]',
-    //                 ),
-    //             )
-    //           ) {
-    //             truncatedParts.push({
-    //               text: '[...function calls omitted due to token limit...]',
-    //             });
-    //           }
-    //           break;
-    //         }
-    //       }
-    //     }
-    //
-    //     return {
-    //       role: content.role,
-    //       parts: truncatedParts,
-    //     };
-    //   }
     async maybeIncludeSchemaDepthContext(error) {
         // Check for potentially problematic cyclic tools with cyclic schemas
         // and include a recommendation to remove potentially problematic tools.
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-001.2
+        // @pseudocode agent-runtime-context.md line 89 (step 006.6)
         if (isStructuredError(error) && isSchemaDepthError(error.message)) {
-            const tools = this.config.getToolRegistry().getAllTools();
+            // Step 006.6: Replace tool registry access with view.tools
+            // Note: ToolRegistryView provides read-only access; getAllTools() not available
+            // For diagnostic purposes, we can list tool names
+            const toolNames = this.runtimeContext.tools.listToolNames();
             const cyclicSchemaTools = [];
-            for (const tool of tools) {
-                if ((tool.schema.parametersJsonSchema &&
-                    hasCycleInSchema(tool.schema.parametersJsonSchema)) ||
-                    (tool.schema.parameters && hasCycleInSchema(tool.schema.parameters))) {
-                    cyclicSchemaTools.push(tool.displayName);
+            // Check each tool's metadata for cyclic schemas
+            for (const toolName of toolNames) {
+                const metadata = this.runtimeContext.tools.getToolMetadata(toolName);
+                if (metadata?.parameterSchema) {
+                    if (hasCycleInSchema(metadata.parameterSchema)) {
+                        cyclicSchemaTools.push(toolName);
+                    }
                 }
             }
             if (cyclicSchemaTools.length > 0) {
@@ -1560,15 +1748,15 @@ export class GeminiChat {
      * Get the active provider from the ProviderManager via Config
      */
     getActiveProvider() {
-        const providerManager = this.config.getProviderManager();
-        if (!providerManager) {
-            return undefined;
-        }
+        // @plan PLAN-20251028-STATELESS6.P10
+        // @requirement REQ-STAT6-002.2
+        // @pseudocode agent-runtime-context.md line 87 (step 006.4)
+        // Step 006.4: Replace providerManager access with view.provider adapter
         try {
-            return providerManager.getActiveProvider();
+            return this.runtimeContext.provider.getActiveProvider();
         }
         catch {
-            // No active provider set
+            // No active provider set or read-only context
             return undefined;
         }
     }
@@ -1583,6 +1771,18 @@ export class GeminiChat {
         return (typeof provider
             .generateChatCompletion === 'function');
     }
+    resolveProviderBaseUrl(provider) {
+        const candidate = provider;
+        try {
+            if (typeof candidate.getBaseURL === 'function') {
+                return candidate.getBaseURL();
+            }
+        }
+        catch {
+            // Ignore failures from provider-specific base URL accessors
+        }
+        return candidate.baseURL;
+    }
 }
 /** Visible for Testing */
 export function isSchemaDepthError(errorMessage) {