@vybestack/llxprt-code-core 0.5.0-nightly.251106.c2b44a77 → 0.5.0-nightly.251107.2c6eee18

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

@@ -44,6 +44,7 @@ export declare class GeminiClient {
     private lastComplexitySuggestionTurn?;
     private toolActivityCount;
     private toolCallReminderLevel;
+    private lastTodoSnapshot?;
     /**
      * At any point in this conversation, was compression triggered without
      * being forced and did it fail?
@@ -77,6 +78,13 @@ export declare class GeminiClient {
     private isTodoToolCall;
     private appendTodoSuffixToRequest;
     private recordModelActivity;
+    private readTodoSnapshot;
+    private getActiveTodos;
+    private areTodoSnapshotsEqual;
+    private getTodoReminderForCurrentState;
+    private appendSystemReminderToRequest;
+    private shouldDeferStreamEvent;
+    private isTodoPauseResponse;
     addHistory(content: Content): Promise<void>;
     getChat(): GeminiChat;
     /**
@@ -107,7 +115,7 @@ export declare class GeminiClient {
     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>;
+    sendMessageStream(initialRequest: PartListUnion, signal: AbortSignal, prompt_id: string, turns?: number): AsyncGenerator<ServerGeminiStreamEvent, Turn>;
     generateJson(contents: Content[], schema: Record<string, unknown>, abortSignal: AbortSignal, model: string, config?: GenerateContentConfig): Promise<Record<string, unknown>>;
     generateContent(contents: Content[], generationConfig: GenerateContentConfig, abortSignal: AbortSignal, model: string): Promise<GenerateContentResponse>;
     generateEmbedding(texts: string[]): Promise<number[][]>;

package/dist/src/core/client.js

@@ -25,13 +25,12 @@ import { LoopDetectionService } from '../services/loopDetectionService.js';
 import { ideContext } from '../ide/ideContext.js';
 import { ComplexityAnalyzer, } from '../services/complexity-analyzer.js';
 import { TodoReminderService } from '../services/todo-reminder-service.js';
+import { TodoStore } from '../tools/todo-store.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 = '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;
@@ -101,6 +100,7 @@ export class GeminiClient {
     lastComplexitySuggestionTurn;
     toolActivityCount = 0;
     toolCallReminderLevel = 'none';
+    lastTodoSnapshot;
     /**
      * At any point in this conversation, was compression triggered without
      * being forced and did it fail?
@@ -263,8 +263,7 @@ export class GeminiClient {
         if (!this.todoToolsAvailable) {
             return;
         }
-        if (event.type !== GeminiEventType.Content &&
-            event.type !== GeminiEventType.ToolCallRequest) {
+        if (event.type !== GeminiEventType.ToolCallResponse) {
             return;
         }
         this.toolActivityCount += 1;
@@ -276,6 +275,87 @@ export class GeminiClient {
             this.toolCallReminderLevel = 'base';
         }
     }
+    async readTodoSnapshot() {
+        try {
+            const sessionId = this.config.getSessionId();
+            const store = new TodoStore(sessionId, DEFAULT_AGENT_ID);
+            return await store.readTodos();
+        }
+        catch (_error) {
+            return [];
+        }
+    }
+    getActiveTodos(todos) {
+        const inProgress = todos.filter((todo) => todo.status === 'in_progress');
+        const pending = todos.filter((todo) => todo.status === 'pending');
+        return [...inProgress, ...pending];
+    }
+    areTodoSnapshotsEqual(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        const normalize = (todos) => todos
+            .map((todo) => ({
+            id: `${todo.id ?? ''}`,
+            status: (todo.status ?? 'pending').toLowerCase(),
+            content: todo.content ?? '',
+            priority: todo.priority ?? 'medium',
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id));
+        const normalizedA = normalize(a);
+        const normalizedB = normalize(b);
+        return normalizedA.every((todo, index) => JSON.stringify(todo) === JSON.stringify(normalizedB[index]));
+    }
+    async getTodoReminderForCurrentState(options) {
+        const todos = options?.todoSnapshot ?? (await this.readTodoSnapshot());
+        const activeTodos = options?.activeTodos ?? this.getActiveTodos(todos);
+        let reminder = null;
+        if (todos.length === 0) {
+            reminder = this.todoReminderService.getCreateListReminder([]);
+        }
+        else if (activeTodos.length > 0) {
+            reminder = options?.escalate
+                ? this.todoReminderService.getEscalatedActiveTodoReminder(activeTodos[0])
+                : this.todoReminderService.getUpdateActiveTodoReminder(activeTodos[0]);
+        }
+        return { reminder, todos, activeTodos };
+    }
+    appendSystemReminderToRequest(request, reminderText) {
+        if (Array.isArray(request)) {
+            const cloned = [...request];
+            const alreadyPresent = cloned.some((part) => typeof part === 'object' &&
+                part !== null &&
+                'text' in part &&
+                typeof part.text === 'string' &&
+                part.text === reminderText);
+            if (!alreadyPresent) {
+                cloned.push({ text: reminderText });
+            }
+            return cloned;
+        }
+        return [{ text: reminderText }];
+    }
+    shouldDeferStreamEvent(event) {
+        return (event.type === GeminiEventType.Content ||
+            event.type === GeminiEventType.Finished ||
+            event.type === GeminiEventType.Citation);
+    }
+    isTodoPauseResponse(response) {
+        if (!response?.responseParts) {
+            return false;
+        }
+        return response.responseParts.some((part) => {
+            if (part &&
+                typeof part === 'object' &&
+                'functionResponse' in part &&
+                part.functionResponse &&
+                typeof part.functionResponse === 'object') {
+                const name = part.functionResponse.name;
+                return typeof name === 'string' && name.toLowerCase() === 'todo_pause';
+            }
+            return false;
+        });
+    }
     async addHistory(content) {
         // Ensure chat is initialized before adding history
         if (!this.hasChatInitialized()) {
@@ -710,21 +790,18 @@ export class GeminiClient {
             };
         }
     }
-    async *sendMessageStream(request, signal, prompt_id, turns = this.MAX_TURNS, originalModel) {
+    async *sendMessageStream(initialRequest, signal, prompt_id, turns = this.MAX_TURNS) {
         const logger = new DebugLogger('llxprt:client:stream');
         logger.debug(() => 'DEBUG: GeminiClient.sendMessageStream called');
-        logger.debug(() => `DEBUG: GeminiClient.sendMessageStream request: ${JSON.stringify(request, null, 2)}`);
-        logger.debug(() => `DEBUG: GeminiClient.sendMessageStream typeof request: ${typeof request}`);
-        logger.debug(() => `DEBUG: GeminiClient.sendMessageStream Array.isArray(request): ${Array.isArray(request)}`);
+        logger.debug(() => `DEBUG: GeminiClient.sendMessageStream request: ${JSON.stringify(initialRequest, null, 2)}`);
+        logger.debug(() => `DEBUG: GeminiClient.sendMessageStream typeof request: ${typeof initialRequest}`);
+        logger.debug(() => `DEBUG: GeminiClient.sendMessageStream Array.isArray(request): ${Array.isArray(initialRequest)}`);
         await this.lazyInitialize();
-        // Ensure chat is initialized after lazyInitialize
         if (!this.chat) {
-            // If we have previous history, restore it when creating the chat
             if (this._previousHistory && this._previousHistory.length > 0) {
                 this.logger.debug('Restoring previous history during prompt generation', {
                     historyLength: this._previousHistory.length,
                 });
-                // Extract the conversation history after the initial environment setup
                 const conversationHistory = this._previousHistory.slice(2);
                 this.chat = await this.startChat(conversationHistory);
                 this.logger.debug('Chat started with restored history', {
@@ -750,7 +827,6 @@ export class GeminiClient {
             const providerName = providerManager?.getActiveProviderName() || 'backend';
             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);
         if (!boundedTurns) {
             const contentGenConfig = this.config.getContentGeneratorConfig();
@@ -758,19 +834,10 @@ export class GeminiClient {
             const providerName = providerManager?.getActiveProviderName() || 'backend';
             return new Turn(this.getChat(), prompt_id, DEFAULT_AGENT_ID, providerName);
         }
-        // Track the original model from the first call to detect model switching
-        // @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
-        // part from the user immediately follows a functionCall part from the model
-        // in the conversation history . The IDE context is not discarded; it will
-        // be included in the next regular message sent to the model.
         const history = await this.getHistory();
         const lastMessage = history.length > 0 ? history[history.length - 1] : undefined;
         const hasPendingToolCall = !!lastMessage &&
@@ -787,85 +854,207 @@ export class GeminiClient {
             this.lastSentIdeContext = newIdeContext;
             this.forceFullIdeContext = false;
         }
-        let shouldAppendTodoSuffix = false;
-        if (Array.isArray(request) && request.length > 0) {
-            const userMessage = request
-                .filter((part) => typeof part === 'object' && 'text' in part)
-                .map((part) => part.text)
-                .join(' ')
-                .trim();
-            if (userMessage.length > 0) {
-                const analysis = this.complexityAnalyzer.analyzeComplexity(userMessage);
-                const complexityReminder = this.processComplexityAnalysis(analysis);
-                if (complexityReminder) {
-                    shouldAppendTodoSuffix = true;
+        let baseRequest = Array.isArray(initialRequest)
+            ? [...initialRequest]
+            : initialRequest;
+        let retryCount = 0;
+        const MAX_RETRIES = 2;
+        let lastTurn;
+        let hadToolCallsThisTurn = false; // Track if model executed tools - preserve across retries
+        while (retryCount < MAX_RETRIES) {
+            let request = Array.isArray(baseRequest)
+                ? [...baseRequest]
+                : baseRequest;
+            // Complexity analysis only on first iteration
+            if (retryCount === 0) {
+                let shouldAppendTodoSuffix = false;
+                if (Array.isArray(request) && request.length > 0) {
+                    const userMessage = request
+                        .filter((part) => typeof part === 'object' && 'text' in part)
+                        .map((part) => part.text)
+                        .join(' ')
+                        .trim();
+                    if (userMessage.length > 0) {
+                        const analysis = this.complexityAnalyzer.analyzeComplexity(userMessage);
+                        const complexityReminder = this.processComplexityAnalysis(analysis);
+                        if (complexityReminder) {
+                            shouldAppendTodoSuffix = true;
+                        }
+                    }
+                    else {
+                        this.consecutiveComplexTurns = 0;
+                    }
+                }
+                else {
+                    this.consecutiveComplexTurns = 0;
                 }
+                if (shouldAppendTodoSuffix) {
+                    request = this.appendTodoSuffixToRequest(request);
+                }
+                baseRequest = Array.isArray(request)
+                    ? [...request]
+                    : request;
             }
             else {
                 this.consecutiveComplexTurns = 0;
             }
-        }
-        else {
-            this.consecutiveComplexTurns = 0;
-        }
-        if (shouldAppendTodoSuffix) {
-            request = this.appendTodoSuffixToRequest(request);
-        }
-        // Get provider name for error messages
-        const contentGenConfig = this.config.getContentGeneratorConfig();
-        const providerManager = contentGenConfig?.providerManager;
-        const providerName = providerManager?.getActiveProviderName() || 'backend';
-        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 };
-            return turn;
-        }
-        const resultStream = turn.run(request, signal);
-        for await (const event of resultStream) {
-            if (this.loopDetector.addAndCheck(event)) {
+            // Apply todo reminder if one is pending from previous iteration
+            if (this.todoToolsAvailable && this.toolCallReminderLevel !== 'none') {
+                const reminderResult = await this.getTodoReminderForCurrentState({
+                    todoSnapshot: this.lastTodoSnapshot,
+                    escalate: this.toolCallReminderLevel === 'escalated',
+                });
+                if (reminderResult.reminder) {
+                    request = this.appendSystemReminderToRequest(request, reminderResult.reminder);
+                    this.lastTodoSnapshot = reminderResult.todos;
+                }
+                this.toolCallReminderLevel = 'none';
+                this.toolActivityCount = 0;
+            }
+            const contentGenConfig = this.config.getContentGeneratorConfig();
+            const providerManager = contentGenConfig?.providerManager;
+            const providerName = providerManager?.getActiveProviderName() || 'backend';
+            const turn = new Turn(this.getChat(), prompt_id, DEFAULT_AGENT_ID, providerName);
+            lastTurn = turn;
+            const loopDetected = await this.loopDetector.turnStarted(signal);
+            if (loopDetected) {
                 yield { type: GeminiEventType.LoopDetected };
                 return turn;
             }
-            this.recordModelActivity(event);
-            yield event;
-            if (event.type === GeminiEventType.ToolCallRequest &&
-                this.isTodoToolCall(event.value?.name)) {
-                this.lastTodoToolTurn = this.sessionTurnCount;
-                this.consecutiveComplexTurns = 0;
+            // Reset flags for this iteration (hadToolCallsThisTurn persists across duplicate todo retries)
+            let todoPauseSeen = false;
+            const deferredEvents = [];
+            const resultStream = turn.run(request, signal);
+            // Stream events, deferring Content/Finished/Citation until we decide on a retry
+            for await (const event of resultStream) {
+                if (this.loopDetector.addAndCheck(event)) {
+                    yield { type: GeminiEventType.LoopDetected };
+                    return turn;
+                }
+                this.recordModelActivity(event);
+                // Track tool execution during this turn
+                if (event.type === GeminiEventType.ToolCallRequest) {
+                    hadToolCallsThisTurn = true;
+                }
+                if (event.type === GeminiEventType.ToolCallResponse) {
+                    if (this.isTodoPauseResponse(event.value)) {
+                        todoPauseSeen = true;
+                    }
+                }
+                // Handle duplicate todo writes
+                if (event.type === GeminiEventType.ToolCallRequest &&
+                    this.isTodoToolCall(event.value?.name)) {
+                    this.lastTodoToolTurn = this.sessionTurnCount;
+                    this.consecutiveComplexTurns = 0;
+                    const requestedTodos = Array.isArray(event.value?.args?.todos)
+                        ? event.value.args.todos
+                        : [];
+                    if (requestedTodos.length > 0) {
+                        this.lastTodoSnapshot = requestedTodos.map((todo) => ({
+                            id: `${todo.id ?? ''}`,
+                            content: todo.content ?? '',
+                            status: todo.status ?? 'pending',
+                            priority: todo.priority ?? 'medium',
+                        }));
+                    }
+                }
+                if (this.shouldDeferStreamEvent(event)) {
+                    deferredEvents.push(event);
+                }
+                else {
+                    yield event;
+                }
+                if (event.type === GeminiEventType.Error) {
+                    for (const deferred of deferredEvents) {
+                        yield deferred;
+                    }
+                    return turn;
+                }
             }
-            if (event.type === GeminiEventType.Error) {
+            // Turn stream is now complete. Decide if we should retry.
+            // Check if model made progress by executing tools FIRST
+            if (hadToolCallsThisTurn) {
+                // Model executed tools - that's progress, flush deferred events and exit
+                const reminderState = await this.getTodoReminderForCurrentState();
+                for (const deferred of deferredEvents) {
+                    yield deferred;
+                }
+                this.lastTodoSnapshot = reminderState.todos;
+                this.toolCallReminderLevel = 'none';
+                this.toolActivityCount = 0;
                 return turn;
             }
-        }
-        if (this.todoToolsAvailable && this.toolCallReminderLevel !== 'none') {
-            const reminderText = this.toolCallReminderLevel === 'escalated'
-                ? TOOL_ESCALATED_TODO_MESSAGE
-                : TOOL_BASE_TODO_MESSAGE;
-            this.getChat().addHistory({
-                role: 'model',
-                parts: [{ text: reminderText }],
-            });
-            const currentTime = Date.now();
-            this.lastComplexitySuggestionTime = currentTime;
-            this.lastComplexitySuggestionTurn = this.sessionTurnCount;
-            this.consecutiveComplexTurns = 0;
-            this.toolCallReminderLevel = 'none';
-            this.toolActivityCount = 0;
-        }
-        if (!turn.pendingToolCalls.length && signal && !signal.aborted) {
-            // Check if model was switched during the call (likely due to quota error)
-            // @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
+            // No tool work detected - check todo/pause state
+            const reminderState = await this.getTodoReminderForCurrentState();
+            const latestSnapshot = reminderState.todos;
+            const activeTodos = reminderState.activeTodos;
+            if (todoPauseSeen) {
+                // Model explicitly paused - respect that
+                for (const deferred of deferredEvents) {
+                    yield deferred;
+                }
+                this.lastTodoSnapshot = latestSnapshot;
+                this.toolCallReminderLevel = 'none';
+                this.toolActivityCount = 0;
+                return turn;
+            }
+            // Check if todos are still pending
+            const todosStillPending = activeTodos.length > 0;
+            const hasPendingReminder = this.todoToolsAvailable && this.toolCallReminderLevel !== 'none';
+            if (!todosStillPending && !hasPendingReminder) {
+                // All todos complete or list is empty, and no reminder pending - return normally
+                for (const deferred of deferredEvents) {
+                    yield deferred;
+                }
+                this.lastTodoSnapshot = latestSnapshot;
+                this.toolCallReminderLevel = 'none';
+                this.toolActivityCount = 0;
                 return turn;
             }
-            // nextSpeakerChecker disabled
+            // Model tried to return with incomplete todos or has pending reminder - check if we should retry
+            retryCount++;
+            if (retryCount >= MAX_RETRIES) {
+                // Hit retry limit - return anyway, let continuation service handle it
+                for (const deferred of deferredEvents) {
+                    yield deferred;
+                }
+                this.lastTodoSnapshot = latestSnapshot;
+                this.toolCallReminderLevel = 'none';
+                this.toolActivityCount = 0;
+                return turn;
+            }
+            // If we have a pending reminder (from toolActivityCount), it will be injected
+            // at the start of the next iteration. Otherwise, prepare a followUp reminder.
+            if (!hasPendingReminder) {
+                // Prepare retry with escalated reminder
+                const previousSnapshot = this.lastTodoSnapshot ?? [];
+                const snapshotUnchanged = this.areTodoSnapshotsEqual(previousSnapshot, latestSnapshot);
+                const followUpReminder = (await this.getTodoReminderForCurrentState({
+                    todoSnapshot: latestSnapshot,
+                    activeTodos,
+                    escalate: snapshotUnchanged,
+                })).reminder;
+                this.lastTodoSnapshot = latestSnapshot;
+                if (!followUpReminder) {
+                    // No reminder to add - flush and return
+                    for (const deferred of deferredEvents) {
+                        yield deferred;
+                    }
+                    this.toolCallReminderLevel = 'none';
+                    this.toolActivityCount = 0;
+                    return turn;
+                }
+                // Set up retry request with reminder
+                baseRequest = this.appendSystemReminderToRequest(baseRequest, followUpReminder);
+            }
+            else {
+                // hasPendingReminder is true - reminder will be injected at loop start
+                this.lastTodoSnapshot = latestSnapshot;
+            }
+            // Loop back for one more try
         }
-        return turn;
+        // Shouldn't reach here, but return last turn if we do
+        return lastTurn;
     }
     async generateJson(contents, schema, abortSignal, model, config = {}) {
         await this.lazyInitialize();