@vybestack/llxprt-code-core 0.4.7 → 0.5.0-nightly.251102.f115237d

package/dist/src/core/client.d.ts

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { GenerateContentConfig, PartListUnion, Content, GenerateContentResponse } from '@google/genai';
+import { GenerateContentConfig, PartListUnion, Content, GenerateContentResponse, SendMessageParameters } from '@google/genai';
 import { Turn, ServerGeminiStreamEvent } from './turn.js';
 import type { ChatCompressionInfo } from './turn.js';
 import { Config } from '../config/config.js';
@@ -11,6 +11,7 @@ import { UserTierId } from '../code_assist/types.js';
 import { GeminiChat } from './geminiChat.js';
 import { HistoryService } from '../services/history/HistoryService.js';
 import { ContentGenerator, ContentGeneratorConfig } from './contentGenerator.js';
+import type { AgentRuntimeState } from '../runtime/AgentRuntimeState.js';
 /**
  * Returns the index of the content after the fraction of the total characters in the history.
  *
@@ -33,6 +34,7 @@ export declare class GeminiClient {
     private lastPromptId?;
     private readonly complexityAnalyzer;
     private readonly todoReminderService;
+    private todoToolsAvailable;
     private lastComplexitySuggestionTime;
     private readonly complexitySuggestionCooldown;
     private lastSentIdeContext;
@@ -42,13 +44,30 @@ export declare class GeminiClient {
     private lastComplexitySuggestionTurn?;
     private toolActivityCount;
     private toolCallReminderLevel;
-    private pendingInstallerNotices;
     /**
      * At any point in this conversation, was compression triggered without
      * being forced and did it fail?
      */
     private hasFailedCompressionAttempt;
-    constructor(config: Config);
+    /**
+     * Runtime state for stateless operation (Phase 5)
+     * @plan PLAN-20251027-STATELESS5.P10
+     * @requirement REQ-STAT5-003.1
+     * @pseudocode gemini-runtime.md lines 21-42
+     */
+    private readonly runtimeState;
+    private _historyService?;
+    private _unsubscribe?;
+    /**
+     * @plan PLAN-20251027-STATELESS5.P10
+     * @requirement REQ-STAT5-003.1
+     * @pseudocode gemini-runtime.md lines 11-66
+     *
+     * Phase 5 constructor: Accept optional AgentRuntimeState and HistoryService
+     * When provided, client operates in stateless mode using runtime state
+     * Otherwise falls back to Config-based operation (backward compatibility)
+     */
+    constructor(config: Config, runtimeState: AgentRuntimeState, historyService?: HistoryService);
     initialize(contentGeneratorConfig: ContentGeneratorConfig): Promise<void>;
     private lazyInitialize;
     getContentGenerator(): ContentGenerator;
@@ -58,10 +77,6 @@ export declare class GeminiClient {
     private isTodoToolCall;
     private appendTodoSuffixToRequest;
     private recordModelActivity;
-    /**
-     * Analyzes the current user request to determine if it's complex enough
-     * to warrant todo reminders
-     */
     addHistory(content: Content): Promise<void>;
     getChat(): GeminiChat;
     /**
@@ -89,6 +104,7 @@ export declare class GeminiClient {
     setTools(): Promise<void>;
     resetChat(): Promise<void>;
     addDirectoryContext(): Promise<void>;
+    generateDirectMessage(params: SendMessageParameters, promptId: string): Promise<GenerateContentResponse>;
     startChat(extraHistory?: Content[]): Promise<GeminiChat>;
     private getIdeContextParts;
     sendMessageStream(request: PartListUnion, signal: AbortSignal, prompt_id: string, turns?: number, originalModel?: string): AsyncGenerator<ServerGeminiStreamEvent, Turn>;
@@ -100,5 +116,9 @@ export declare class GeminiClient {
      * Returns compression info if successful, null if not needed
      */
     tryCompressChat(prompt_id: string, force?: boolean): Promise<ChatCompressionInfo>;
+    private getToolGovernanceEphemerals;
+    private readToolList;
+    private buildToolDeclarationsFromView;
     private getEnabledToolNamesForPrompt;
+    private updateTodoToolAvailabilityFromDeclarations;
 }

package/dist/src/core/client.js

@@ -4,18 +4,20 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { getDirectoryContextString, getEnvironmentContext, } from '../utils/environmentContext.js';
-import { Turn, GeminiEventType } from './turn.js';
+import { Turn, GeminiEventType, DEFAULT_AGENT_ID, } from './turn.js';
 import { CompressionStatus } from './turn.js';
-import { getCoreSystemPromptAsync, getCompressionPrompt, drainPromptInstallerNotices, } from './prompts.js';
+import { getCoreSystemPromptAsync, getCompressionPrompt } from './prompts.js';
 import { getResponseText } from '../utils/generateContentResponseUtilities.js';
 import { reportError } from '../utils/errorReporting.js';
 import { GeminiChat } from './geminiChat.js';
 import { DebugLogger } from '../debug/index.js';
 import { HistoryService } from '../services/history/HistoryService.js';
 import { ContentConverters } from '../services/history/ContentConverters.js';
+import { createProviderRuntimeContext } from '../runtime/providerRuntimeContext.js';
+import { loadAgentRuntime } from '../runtime/AgentRuntimeLoader.js';
 import { retryWithBackoff } from '../utils/retry.js';
 import { getErrorMessage } from '../utils/errors.js';
-import { createContentGenerator, } from './contentGenerator.js';
+import { AuthType, createContentGenerator, } from './contentGenerator.js';
 import { ProxyAgent, setGlobalDispatcher } from 'undici';
 import { tokenLimit } from './tokenLimits.js';
 import { COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, } from './compression-config.js';
@@ -25,10 +27,11 @@ import { ComplexityAnalyzer, } from '../services/complexity-analyzer.js';
 import { TodoReminderService } from '../services/todo-reminder-service.js';
 import { isFunctionResponse } from '../utils/messageInspectors.js';
 import { estimateTokens as estimateTextTokens } from '../utils/toolOutputLimiter.js';
+import { subscribeToAgentRuntimeState } from '../runtime/AgentRuntimeState.js';
 const COMPLEXITY_ESCALATION_TURN_THRESHOLD = 3;
-const TODO_PROMPT_SUFFIX = 'Consider using a todo list to organize this multi-step work.';
-const TOOL_BASE_TODO_MESSAGE = 'Consider using a todo list to help organize your work if this is a complex task.';
-const TOOL_ESCALATED_TODO_MESSAGE = 'This task seems to involve multiple steps. A todo list might help track your progress.';
+const TODO_PROMPT_SUFFIX = 'Use TODO List to organize this effort.';
+const TOOL_BASE_TODO_MESSAGE = 'After this next tool call I need to call todo_write and create a todo list to organize this effort.';
+const TOOL_ESCALATED_TODO_MESSAGE = 'I have already made several tool calls without a todo list. Immediately call todo_write after this next tool call to organize the work.';
 function isThinkingSupported(model) {
     if (model.startsWith('gemini-2.5'))
         return true;
@@ -88,6 +91,7 @@ export class GeminiClient {
     lastPromptId;
     complexityAnalyzer;
     todoReminderService;
+    todoToolsAvailable = false;
     lastComplexitySuggestionTime = 0;
     complexitySuggestionCooldown;
     lastSentIdeContext;
@@ -97,21 +101,61 @@ export class GeminiClient {
     lastComplexitySuggestionTurn;
     toolActivityCount = 0;
     toolCallReminderLevel = 'none';
-    pendingInstallerNotices = [];
     /**
      * At any point in this conversation, was compression triggered without
      * being forced and did it fail?
      */
     hasFailedCompressionAttempt = false;
-    constructor(config) {
+    /**
+     * Runtime state for stateless operation (Phase 5)
+     * @plan PLAN-20251027-STATELESS5.P10
+     * @requirement REQ-STAT5-003.1
+     * @pseudocode gemini-runtime.md lines 21-42
+     */
+    runtimeState;
+    _historyService;
+    _unsubscribe;
+    /**
+     * @plan PLAN-20251027-STATELESS5.P10
+     * @requirement REQ-STAT5-003.1
+     * @pseudocode gemini-runtime.md lines 11-66
+     *
+     * Phase 5 constructor: Accept optional AgentRuntimeState and HistoryService
+     * When provided, client operates in stateless mode using runtime state
+     * Otherwise falls back to Config-based operation (backward compatibility)
+     */
+    constructor(config, runtimeState, historyService) {
         this.config = config;
-        if (config.getProxy()) {
-            setGlobalDispatcher(new ProxyAgent(config.getProxy()));
+        if (!runtimeState.provider || runtimeState.provider === '') {
+            throw new Error('AgentRuntimeState must have a valid provider');
+        }
+        if (!runtimeState.model || runtimeState.model === '') {
+            throw new Error('AgentRuntimeState must have a valid model');
+        }
+        if (runtimeState.authType === AuthType.API_KEY &&
+            !runtimeState.authPayload?.apiKey) {
+            throw new Error('AgentRuntimeState must include apiKey when authType is API_KEY');
+        }
+        if (runtimeState.authType === AuthType.OAUTH &&
+            !runtimeState.authPayload?.token) {
+            throw new Error('AgentRuntimeState must include token when authType is OAUTH');
         }
+        this.runtimeState = runtimeState;
+        this._historyService = historyService;
         this.logger = new DebugLogger('llxprt:core:client');
-        this.embeddingModel = config.getEmbeddingModel();
+        this._unsubscribe = subscribeToAgentRuntimeState(runtimeState.runtimeId, (event) => {
+            this.logger.debug('Runtime state changed', event);
+        });
+        void this._historyService;
+        void this._unsubscribe;
+        const proxyUrl = runtimeState.proxyUrl;
+        if (proxyUrl) {
+            setGlobalDispatcher(new ProxyAgent(proxyUrl));
+        }
+        const embeddingModel = config.getEmbeddingModel();
+        this.embeddingModel = embeddingModel || runtimeState.model;
         this.loopDetector = new LoopDetectionService(config);
-        this.lastPromptId = this.config.getSessionId();
+        this.lastPromptId = runtimeState.sessionId;
         // Initialize complexity analyzer with config settings
         const complexitySettings = config.getComplexityAnalyzerSettings();
         this.complexityAnalyzer = new ComplexityAnalyzer({
@@ -121,7 +165,6 @@ export class GeminiClient {
         this.complexitySuggestionCooldown =
             complexitySettings.suggestionCooldownMs ?? 300000;
         this.todoReminderService = new TodoReminderService();
-        this.pendingInstallerNotices = [];
     }
     async initialize(contentGeneratorConfig) {
         // Preserve chat history before resetting, but only if we don't already have stored history
@@ -162,6 +205,10 @@ export class GeminiClient {
         return this.contentGenerator?.userTier;
     }
     processComplexityAnalysis(analysis) {
+        if (!this.todoToolsAvailable) {
+            this.consecutiveComplexTurns = 0;
+            return undefined;
+        }
         if (!analysis.isComplex || !analysis.shouldSuggestTodos) {
             this.consecutiveComplexTurns = 0;
             return undefined;
@@ -213,25 +260,22 @@ export class GeminiClient {
         return request;
     }
     recordModelActivity(event) {
+        if (!this.todoToolsAvailable) {
+            return;
+        }
         if (event.type !== GeminiEventType.Content &&
             event.type !== GeminiEventType.ToolCallRequest) {
             return;
         }
         this.toolActivityCount += 1;
-        // Always trigger reminders after a certain number of tool calls
-        // regardless of complexity - this is the core safety feature
-        if (this.toolActivityCount > 5) {
+        if (this.toolActivityCount > 4) {
             this.toolCallReminderLevel = 'escalated';
         }
-        else if (this.toolActivityCount === 5 &&
+        else if (this.toolActivityCount === 4 &&
             this.toolCallReminderLevel === 'none') {
             this.toolCallReminderLevel = 'base';
         }
     }
-    /**
-     * Analyzes the current user request to determine if it's complex enough
-     * to warrant todo reminders
-     */
     async addHistory(content) {
         // Ensure chat is initialized before adding history
         if (!this.hasChatInitialized()) {
@@ -331,7 +375,16 @@ export class GeminiClient {
     }
     async setTools() {
         const toolRegistry = this.config.getToolRegistry();
-        const toolDeclarations = toolRegistry.getFunctionDeclarations();
+        if (!toolRegistry) {
+            return;
+        }
+        const toolsView = typeof this.chat?.getToolsView === 'function'
+            ? this.chat.getToolsView()
+            : undefined;
+        const toolDeclarations = toolsView
+            ? this.buildToolDeclarationsFromView(toolRegistry, toolsView)
+            : toolRegistry.getFunctionDeclarations();
+        this.updateTodoToolAvailabilityFromDeclarations(toolDeclarations);
         // Debug log for intermittent tool issues
         const logger = new DebugLogger('llxprt:client:setTools');
         logger.debug(() => `setTools called, declarations count: ${toolDeclarations.length}`);
@@ -378,6 +431,13 @@ export class GeminiClient {
             parts: [{ text: await getDirectoryContextString(this.config) }],
         });
     }
+    async generateDirectMessage(params, promptId) {
+        await this.lazyInitialize();
+        if (!this.chat) {
+            this.chat = await this.startChat([]);
+        }
+        return this.getChat().generateDirectMessage(params, promptId);
+    }
     async startChat(extraHistory) {
         this.forceFullIdeContext = true;
         this.hasFailedCompressionAttempt = false;
@@ -385,8 +445,6 @@ export class GeminiClient {
         await this.lazyInitialize();
         const envParts = await getEnvironmentContext(this.config);
         const toolRegistry = this.config.getToolRegistry();
-        const toolDeclarations = toolRegistry.getFunctionDeclarations();
-        const tools = [{ functionDeclarations: toolDeclarations }];
         const enabledToolNames = this.getEnabledToolNamesForPrompt();
         // CRITICAL: Reuse stored HistoryService if available to preserve UI conversation display
         // This is essential for maintaining conversation history across provider switches
@@ -403,21 +461,22 @@ export class GeminiClient {
         }
         // Add extraHistory if provided
         if (extraHistory && extraHistory.length > 0) {
-            const currentModel = this.config.getModel();
+            // @plan PLAN-20251027-STATELESS5.P10
+            // @requirement REQ-STAT5-003.1
+            const currentModel = this.runtimeState.model;
             for (const content of extraHistory) {
                 historyService.add(ContentConverters.toIContent(content), currentModel);
             }
         }
         try {
             const userMemory = this.config.getUserMemory();
-            const model = this.config.getModel();
+            // @plan PLAN-20251027-STATELESS5.P10
+            // @requirement REQ-STAT5-003.1
+            const model = this.runtimeState.model;
+            // Provider name removed from prompt call signature
             const logger = new DebugLogger('llxprt:client:start');
             logger.debug(() => `DEBUG [client.startChat]: Model from config: ${model}`);
             let systemInstruction = await getCoreSystemPromptAsync(userMemory, model, enabledToolNames);
-            const installerNotices = await drainPromptInstallerNotices();
-            if (installerNotices.length > 0) {
-                this.pendingInstallerNotices.push(...installerNotices);
-            }
             // Add environment context to system instruction
             const envContextText = envParts
                 .map((part) => ('text' in part ? part.text : ''))
@@ -435,7 +494,9 @@ export class GeminiClient {
             }
             historyService.setBaseTokenOffset(systemPromptTokens);
             logger.debug(() => `DEBUG [client.startChat]: System instruction includes Flash instructions: ${systemInstruction.includes('IMPORTANT: You MUST use the provided tools')}`);
-            const generateContentConfigWithThinking = isThinkingSupported(this.config.getModel())
+            // @plan PLAN-20251027-STATELESS5.P10
+            // @requirement REQ-STAT5-003.1
+            const generateContentConfigWithThinking = isThinkingSupported(this.runtimeState.model)
                 ? {
                     ...this.generateContentConfig,
                     thinkingConfig: {
@@ -444,12 +505,48 @@ export class GeminiClient {
                     },
                 }
                 : this.generateContentConfig;
-            return new GeminiChat(this.config, this.getContentGenerator(), {
+            // @plan PLAN-20251028-STATELESS6.P10
+            // @requirement REQ-STAT6-001.2
+            // Create runtime context from config (foreground agent)
+            const settings = {
+                compressionThreshold: this.config.getEphemeralSetting('compression-threshold') ?? 0.8,
+                contextLimit: this.config.getEphemeralSetting('context-limit') ?? 60000,
+                preserveThreshold: this.config.getEphemeralSetting('compression-preserve-threshold') ?? 0.2,
+                telemetry: {
+                    enabled: true,
+                    target: null,
+                },
+                tools: this.getToolGovernanceEphemerals(),
+            };
+            const providerRuntime = createProviderRuntimeContext({
+                settingsService: this.config.getSettingsService(),
+                config: this.config,
+                runtimeId: this.runtimeState.runtimeId,
+                metadata: { source: 'GeminiClient.startChat' },
+            });
+            const runtimeBundle = await loadAgentRuntime({
+                profile: {
+                    config: this.config,
+                    state: this.runtimeState,
+                    settings,
+                    providerRuntime,
+                    contentGeneratorConfig: this.config.getContentGeneratorConfig(),
+                    toolRegistry,
+                    providerManager: this.config.getProviderManager?.(),
+                },
+                overrides: {
+                    historyService,
+                    contentGenerator: this.getContentGenerator(),
+                },
+            });
+            const filteredDeclarations = this.buildToolDeclarationsFromView(toolRegistry, runtimeBundle.toolsView);
+            this.updateTodoToolAvailabilityFromDeclarations(filteredDeclarations);
+            const tools = [{ functionDeclarations: filteredDeclarations }];
+            return new GeminiChat(runtimeBundle.runtimeContext, runtimeBundle.contentGenerator, {
                 systemInstruction,
                 ...generateContentConfigWithThinking,
                 tools,
-            }, [], // Empty initial history since we're using HistoryService
-            historyService);
+            }, []);
         }
         catch (error) {
             await reportError(error, 'Error initializing chat session.', extraHistory ?? [], 'startChat');
@@ -624,13 +721,6 @@ export class GeminiClient {
                 this.chat = await this.startChat();
             }
         }
-        if (this.pendingInstallerNotices.length > 0) {
-            const notices = [...this.pendingInstallerNotices];
-            this.pendingInstallerNotices = [];
-            for (const notice of notices) {
-                yield { type: GeminiEventType.SystemNotice, value: notice };
-            }
-        }
         if (this.lastPromptId !== prompt_id) {
             this.loopDetector.reset(prompt_id);
             this.lastPromptId = prompt_id;
@@ -644,7 +734,7 @@ export class GeminiClient {
             const contentGenConfig = this.config.getContentGeneratorConfig();
             const providerManager = contentGenConfig?.providerManager;
             const providerName = providerManager?.getActiveProviderName() || 'backend';
-            return new Turn(this.getChat(), prompt_id, providerName);
+            return new Turn(this.getChat(), prompt_id, DEFAULT_AGENT_ID, providerName);
         }
         // Ensure turns never exceeds MAX_TURNS to prevent infinite loops
         const boundedTurns = Math.min(turns, this.MAX_TURNS);
@@ -652,16 +742,15 @@ export class GeminiClient {
             const contentGenConfig = this.config.getContentGeneratorConfig();
             const providerManager = contentGenConfig?.providerManager;
             const providerName = providerManager?.getActiveProviderName() || 'backend';
-            return new Turn(this.getChat(), prompt_id, providerName);
+            return new Turn(this.getChat(), prompt_id, DEFAULT_AGENT_ID, providerName);
         }
         // Track the original model from the first call to detect model switching
-        const initialModel = originalModel || this.config.getModel();
-        // Only try compression if chat is properly initialized
-        if (this.chat && typeof this.chat.getHistoryService === 'function') {
-            const compressed = await this.tryCompressChat(prompt_id);
-            if (compressed.compressionStatus === CompressionStatus.COMPRESSED) {
-                yield { type: GeminiEventType.ChatCompressed, value: compressed };
-            }
+        // @plan PLAN-20251027-STATELESS5.P10
+        // @requirement REQ-STAT5-003.1
+        const initialModel = originalModel || this.runtimeState.model;
+        const compressed = await this.tryCompressChat(prompt_id);
+        if (compressed.compressionStatus === CompressionStatus.COMPRESSED) {
+            yield { type: GeminiEventType.ChatCompressed, value: compressed };
         }
         // Prevent context updates from being sent while a tool call is
         // waiting for a response. The Gemini API requires that a functionResponse
@@ -712,7 +801,7 @@ export class GeminiClient {
         const contentGenConfig = this.config.getContentGeneratorConfig();
         const providerManager = contentGenConfig?.providerManager;
         const providerName = providerManager?.getActiveProviderName() || 'backend';
-        const turn = new Turn(this.getChat(), prompt_id, providerName);
+        const turn = new Turn(this.getChat(), prompt_id, DEFAULT_AGENT_ID, providerName);
         const loopDetected = await this.loopDetector.turnStarted(signal);
         if (loopDetected) {
             yield { type: GeminiEventType.LoopDetected };
@@ -735,7 +824,7 @@ export class GeminiClient {
                 return turn;
             }
         }
-        if (this.toolCallReminderLevel !== 'none') {
+        if (this.todoToolsAvailable && this.toolCallReminderLevel !== 'none') {
             const reminderText = this.toolCallReminderLevel === 'escalated'
                 ? TOOL_ESCALATED_TODO_MESSAGE
                 : TOOL_BASE_TODO_MESSAGE;
@@ -752,7 +841,9 @@ export class GeminiClient {
         }
         if (!turn.pendingToolCalls.length && signal && !signal.aborted) {
             // Check if model was switched during the call (likely due to quota error)
-            const currentModel = this.config.getModel();
+            // @plan PLAN-20251027-STATELESS5.P10
+            // @requirement REQ-STAT5-003.1
+            const currentModel = this.runtimeState.model;
             if (currentModel !== initialModel) {
                 // Model was switched (likely due to quota error fallback)
                 // Don't continue with recursive call to prevent unwanted Flash execution
@@ -768,6 +859,7 @@ export class GeminiClient {
         const modelToUse = model;
         try {
             const userMemory = this.config.getUserMemory();
+            // Provider name removed from prompt call signature
             const systemInstruction = await getCoreSystemPromptAsync(userMemory, modelToUse, this.getEnabledToolNamesForPrompt());
             const requestConfig = {
                 abortSignal,
@@ -846,6 +938,7 @@ export class GeminiClient {
         };
         try {
             const userMemory = this.config.getUserMemory();
+            // Provider name removed from prompt call signature
             const systemInstruction = await getCoreSystemPromptAsync(userMemory, modelToUse, this.getEnabledToolNamesForPrompt());
             const requestConfig = {
                 abortSignal,
@@ -920,7 +1013,9 @@ export class GeminiClient {
             };
         }
         // Note: chat variable used later in method
-        const model = this.config.getModel();
+        // @plan PLAN-20251027-STATELESS5.P10
+        // @requirement REQ-STAT5-003.1
+        const model = this.runtimeState.model;
         // Get the ACTUAL token count from the history service, not the curated subset
         const historyService = this.getChat().getHistoryService();
         const originalTokenCount = historyService
@@ -939,7 +1034,9 @@ export class GeminiClient {
         // Don't compress if not forced and we are under the limit.
         if (!force) {
             const threshold = contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
-            if (originalTokenCount < threshold * tokenLimit(model)) {
+            const userContextLimit = this.config.getEphemeralSetting('context-limit');
+            if (originalTokenCount <
+                threshold * tokenLimit(model, userContextLimit)) {
                 return {
                     originalTokenCount,
                     newTokenCount: originalTokenCount,
@@ -1014,10 +1111,13 @@ export class GeminiClient {
             if (typeof compressedChat.getHistoryService === 'function') {
                 const historyService = compressedChat.getHistoryService();
                 if (historyService) {
+                    const userContextLimit = this.config.getEphemeralSetting('context-limit');
+                    // @plan PLAN-20251027-STATELESS5.P10
+                    // @requirement REQ-STAT5-003.1
                     historyService.emit('tokensUpdated', {
                         totalTokens: newTokenCount,
                         addedTokens: newTokenCount - originalTokenCount,
-                        tokenLimit: tokenLimit(this.config.getModel()),
+                        tokenLimit: tokenLimit(this.runtimeState.model, userContextLimit),
                     });
                 }
             }
@@ -1028,6 +1128,63 @@ export class GeminiClient {
             compressionStatus: CompressionStatus.COMPRESSED,
         };
     }
+    getToolGovernanceEphemerals() {
+        const allowedList = this.readToolList(this.config.getEphemeralSetting('tools.allowed'));
+        const disabledList = this.readToolList(this.config.getEphemeralSetting('tools.disabled') ??
+            this.config.getEphemeralSetting('disabled-tools'));
+        const hasAllowed = allowedList.length > 0;
+        const hasDisabled = disabledList.length > 0;
+        if (!hasAllowed && !hasDisabled) {
+            return undefined;
+        }
+        return {
+            allowed: hasAllowed ? allowedList : undefined,
+            disabled: hasDisabled ? disabledList : undefined,
+        };
+    }
+    readToolList(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        const filtered = value.filter((entry) => typeof entry === 'string' && entry.trim().length > 0);
+        return filtered.length > 0 ? [...filtered] : [];
+    }
+    buildToolDeclarationsFromView(toolRegistry, view) {
+        if (!toolRegistry) {
+            return [];
+        }
+        const allowedNames = view.listToolNames();
+        if (allowedNames.length === 0) {
+            return [];
+        }
+        const declarations = [];
+        if (typeof toolRegistry.getAllTools === 'function') {
+            const toolsByName = new Map(toolRegistry.getAllTools().map((tool) => [tool.name, tool]));
+            for (const name of allowedNames) {
+                const tool = toolsByName.get(name);
+                if (!tool) {
+                    continue;
+                }
+                const schema = tool.schema;
+                if (schema) {
+                    declarations.push(schema);
+                }
+            }
+            return declarations;
+        }
+        if (typeof toolRegistry.getFunctionDeclarations === 'function') {
+            const declarationsByName = new Map(toolRegistry
+                .getFunctionDeclarations()
+                .map((decl) => [decl.name, decl]));
+            for (const name of allowedNames) {
+                const declaration = declarationsByName.get(name);
+                if (declaration) {
+                    declarations.push(declaration);
+                }
+            }
+        }
+        return declarations;
+    }
     getEnabledToolNamesForPrompt() {
         const toolRegistry = this.config.getToolRegistry();
         if (!toolRegistry ||
@@ -1040,5 +1197,13 @@ export class GeminiClient {
             .map((tool) => tool.name)
             .filter(Boolean)));
     }
+    updateTodoToolAvailabilityFromDeclarations(declarations) {
+        const normalizedNames = new Set(declarations
+            .map((decl) => decl?.name)
+            .filter((name) => typeof name === 'string')
+            .map((name) => name.toLowerCase()));
+        this.todoToolsAvailable =
+            normalizedNames.has('todo_write') && normalizedNames.has('todo_read');
+    }
 }
 //# sourceMappingURL=client.js.map