@vybestack/llxprt-code-core 0.5.0-nightly.251103.c825fa57 → 0.5.0-nightly.251104.319bfefc

package/README.md

@@ -8,23 +8,15 @@
 
 ![LLxprt Code Screenshot](./docs/assets/llxprt-screenshot.png)
 
-LLxprt Code is a powerful fork of [Google's Gemini CLI](https://github.com/google-gemini/gemini-cli), enhanced with multi-provider support and improved theming. We thank Google for their excellent foundation and will continue to track and merge upstream changes as long as practical.
-
-## What's new in 0.4.5
-
-- **Startup configuration:** supply ephemeral settings via `--set key=value` (same keys as `/set`), ideal for CI and automation.
-- **Resilient streaming:** unified retry defaults (6 attempts / 4 s) and better handling of transient SSE disconnects.
-- **Smarter todos:** complex request detection now nudges you to create todo lists and escalates reminders when none exist.
-- **Configurable todo UI:** control the Todo panel via `/settings → UI → Show Todo Panel`; when hidden, todo tool output appears inline in scrollback.
-- **Simplified Gemini UX:** the "Paid Mode" badge and flash fallback were removed; monitor usage with `/stats` or provider dashboards instead.
-- **Token budgeting clarity:** `context-limit` now clearly counts system prompts + `LLXPRT.md`, with improved error messaging and docs.
+LLxprt Code is a CLI-based LLM assisted coding tool. It is highly configurable and can support nearly any provider or model as well as local/self-hosted models.
 
 ## Key Features
 
-- **Multi-Provider Support**: Direct access to OpenAI (o3), Anthropic (Claude), Google Gemini, plus OpenRouter, Fireworks, and local models
+- **Multi-Provider Support**: Direct access to OpenAI (gpt-5), Anthropic (Claude Opus/Sonnet), Google Gemini, plus OpenRouter, Fireworks, Synthetic, Cerebras, Chutes, Z.ai and local models
+- **Authenticate** to use free: Gemini and Qwen models as well as using your Claude Pro/Max account. Use `/auth` to enable/disable/logout of Google/Anthropic/Qwen.
 - **Installable Provider Aliases**: Save `/provider` setups as reusable configs and load OpenAI-compatible endpoints instantly
-- **Enhanced Theme Support**: Beautiful themes applied consistently across the entire tool
-- **Full Gemini CLI Compatibility**: All original features work seamlessly, including Google authentication via `/auth`
+- **Multi-model/Provider Subagents**: Use `/subagent` to define specialized subagents with isolated contexts
+- **Configuration Profiles**: define and save specific model/provider settings using `/profile` for instance temperature or custom headers
 - **Local Model Support**: Run models locally with LM Studio, llama.cpp, or any OpenAI-compatible server
 - **Flexible Configuration**: Switch providers, models, and API keys on the fly
 - **Advanced Settings & Profiles**: Fine-tune model parameters, manage ephemeral settings, and save configurations for reuse. [Learn more →](./docs/settings-and-profiles.md)
@@ -75,7 +67,7 @@ You have two options to install LLxprt Code.
 
 ### Using OpenAI
 
-Direct access to o3, o1, GPT-4.1, and other OpenAI models:
+Direct access to GPT-5, and other OpenAI models:
 
 1. Get your API key from [OpenAI](https://platform.openai.com/api-keys)
 2. Configure LLxprt Code:

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

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { GenerateContentResponse, Content, GenerateContentConfig, SendMessageParameters, GenerateContentResponseUsageMetadata, Tool, PartListUnion } from '@google/genai';
+import { GenerateContentResponse, Content, GenerateContentConfig, SendMessageParameters, Part, GenerateContentResponseUsageMetadata, Tool, PartListUnion } from '@google/genai';
 import { ContentGenerator } from './contentGenerator.js';
 import { HistoryService } from '../services/history/HistoryService.js';
 import type { IContent } from '../services/history/IContent.js';
@@ -22,9 +22,21 @@ export type StreamEvent = {
     type: StreamEventType.RETRY;
 };
 /**
- * Custom error to signal that a stream completed without valid content,
+ * Checks if a part contains valid non-thought text content.
+ * This helps in consolidating text parts properly during stream processing.
+ */
+export declare function isValidNonThoughtTextPart(part: Part): boolean;
+/**
+ * Custom error to signal that a stream completed with invalid content,
  * which should trigger a retry.
  */
+export declare class InvalidStreamError extends Error {
+    readonly type: 'NO_FINISH_REASON' | 'NO_RESPONSE_TEXT' | 'NO_FINISH_REASON_NO_TEXT';
+    constructor(message: string, type: 'NO_FINISH_REASON' | 'NO_RESPONSE_TEXT' | 'NO_FINISH_REASON_NO_TEXT');
+}
+/**
+ * Legacy error class for backward compatibility.
+ */
 export declare class EmptyStreamError extends Error {
     constructor(message: string);
 }
@@ -42,6 +54,7 @@ export declare class GeminiChat {
     private compressionPromise;
     private logger;
     private cachedCompressionThreshold;
+    private lastPromptTokenCount;
     private readonly generationConfig;
     /**
      * Runtime state for stateless operation (Phase 6)
@@ -52,6 +65,10 @@ export declare class GeminiChat {
     private readonly runtimeState;
     private readonly historyService;
     private readonly runtimeContext;
+    /**
+     * Gets the last prompt token count.
+     */
+    getLastPromptTokenCount(): number;
     /**
      * @plan PLAN-20251028-STATELESS6.P10
      * @requirement REQ-STAT6-001.2, REQ-STAT6-002.2, REQ-STAT6-002.3

package/dist/src/core/geminiChat.js

@@ -152,9 +152,23 @@ function normalizeToolInteractionInput(message) {
     return result;
 }
 const INVALID_CONTENT_RETRY_OPTIONS = {
-    maxAttempts: 3, // 1 initial call + 2 retries
+    maxAttempts: 2, // 1 initial call + 1 retry
     initialDelayMs: 500,
 };
+/**
+ * Checks if a part contains valid non-thought text content.
+ * This helps in consolidating text parts properly during stream processing.
+ */
+export function isValidNonThoughtTextPart(part) {
+    return (typeof part.text === 'string' &&
+        !part.thought &&
+        // Technically, the model should never generate parts that have text and
+        // any of these but we don't trust them so check anyways.
+        !part.functionCall &&
+        !part.functionResponse &&
+        !part.inlineData &&
+        !part.fileData);
+}
 /**
  * Returns true if the response is valid, false otherwise.
  */
@@ -233,9 +247,20 @@ function extractCuratedHistory(comprehensiveHistory) {
     return curatedHistory;
 }
 /**
- * Custom error to signal that a stream completed without valid content,
+ * Custom error to signal that a stream completed with invalid content,
  * which should trigger a retry.
  */
+export class InvalidStreamError extends Error {
+    type;
+    constructor(message, type) {
+        super(message);
+        this.name = 'InvalidStreamError';
+        this.type = type;
+    }
+}
+/**
+ * Legacy error class for backward compatibility.
+ */
 export class EmptyStreamError extends Error {
     constructor(message) {
         super(message);
@@ -260,6 +285,7 @@ export class GeminiChat {
     logger = new DebugLogger('llxprt:gemini:chat');
     // Cache the compression threshold to avoid recalculating
     cachedCompressionThreshold = null;
+    lastPromptTokenCount = 0;
     generationConfig;
     /**
      * Runtime state for stateless operation (Phase 6)
@@ -270,6 +296,12 @@ export class GeminiChat {
     runtimeState;
     historyService;
     runtimeContext;
+    /**
+     * Gets the last prompt token count.
+     */
+    getLastPromptTokenCount() {
+        return this.lastPromptTokenCount;
+    }
     /**
      * @plan PLAN-20251028-STATELESS6.P10
      * @requirement REQ-STAT6-001.2, REQ-STAT6-002.2, REQ-STAT6-002.3
@@ -553,6 +585,7 @@ export class GeminiChat {
                     runtime: runtimeContext,
                     settings: runtimeContext.settingsService,
                     metadata: runtimeContext.metadata,
+                    userMemory: runtimeContext.config?.getUserMemory?.(),
                 });
                 // Collect all chunks from the stream
                 let lastResponse;
@@ -712,7 +745,26 @@ export class GeminiChat {
                         if (attempt > 0) {
                             yield { type: StreamEventType.RETRY };
                         }
-                        const stream = await instance.makeApiCallAndProcessStream(params, prompt_id, pendingTokens, userContent);
+                        // If this is a retry, adjust temperature to encourage different output.
+                        // Use temperature 1 as baseline (or the original temperature if it's higher than 1) and add increasing variation to avoid repetition.
+                        const currentParams = { ...params };
+                        if (attempt > 0) {
+                            // Use 1 as the baseline temperature for retries, or the original if it's higher
+                            const baselineTemperature = Math.max(params.config?.temperature ?? 1, 1);
+                            // Add increasing variation for each retry attempt to encourage different output
+                            const variation = attempt * 0.1;
+                            let newTemperature = baselineTemperature + variation;
+                            // Ensure temperature stays within valid range [0, 2] for Gemini models
+                            newTemperature = Math.min(Math.max(newTemperature, 0), 2);
+                            // Ensure config exists
+                            currentParams.config = currentParams.config || {};
+                            currentParams.config = {
+                                ...currentParams.config,
+                                temperature: newTemperature,
+                            };
+                        }
+                        const stream = await instance.makeApiCallAndProcessStream(currentParams, // Use the modified params with temperature
+                        prompt_id, pendingTokens, userContent);
                         for await (const chunk of stream) {
                             yield { type: StreamEventType.CHUNK, value: chunk };
                         }
@@ -721,7 +773,8 @@ export class GeminiChat {
                     }
                     catch (error) {
                         lastError = error;
-                        const isContentError = error instanceof EmptyStreamError;
+                        const isContentError = error instanceof InvalidStreamError ||
+                            error instanceof EmptyStreamError;
                         if (isContentError) {
                             // Check if we have more attempts left.
                             if (attempt < INVALID_CONTENT_RETRY_OPTIONS.maxAttempts - 1) {
@@ -787,6 +840,7 @@ export class GeminiChat {
                     runtime: runtimeContext,
                     settings: runtimeContext.settingsService,
                     metadata: runtimeContext.metadata,
+                    userMemory: runtimeContext.config?.getUserMemory?.(),
                 });
                 let lastResponse;
                 for await (const iContent of streamResponse) {
@@ -848,7 +902,7 @@ export class GeminiChat {
             throw error;
         }
     }
-    async makeApiCallAndProcessStream(_params, promptId, pendingTokens, userContent) {
+    async makeApiCallAndProcessStream(params, promptId, pendingTokens, userContent) {
         // Get the active provider
         let provider = this.getActiveProvider();
         if (!provider) {
@@ -918,7 +972,18 @@ export class GeminiChat {
                 baseUrl: providerBaseUrl,
                 authType: activeAuthType,
             });
-            const runtimeContext = this.buildProviderRuntime('GeminiChat.generateRequest', { historyLength: requestContents.length });
+            // Create a runtime context that incorporates the config from params
+            const baseRuntimeContext = this.buildProviderRuntime('GeminiChat.generateRequest', { historyLength: requestContents.length });
+            // If params has config, merge it with the runtime context config
+            const runtimeContext = params.config
+                ? {
+                    ...baseRuntimeContext,
+                    config: {
+                        ...baseRuntimeContext.config,
+                        ...params.config,
+                    },
+                }
+                : baseRuntimeContext;
             const streamResponse = provider.generateChatCompletion({
                 contents: requestContents,
                 tools: tools,
@@ -926,6 +991,7 @@ export class GeminiChat {
                 runtime: runtimeContext,
                 settings: runtimeContext.settingsService,
                 metadata: runtimeContext.metadata,
+                userMemory: baseRuntimeContext.config?.getUserMemory?.(),
             });
             // Convert the IContent stream to GenerateContentResponse stream
             return (async function* (instance) {
@@ -1349,6 +1415,7 @@ export class GeminiChat {
             runtime: runtimeContext,
             settings: runtimeContext.settingsService,
             metadata: runtimeContext.metadata,
+            userMemory: runtimeContext.config?.getUserMemory?.(),
         });
         // Collect response
         let summary = '';
@@ -1399,61 +1466,93 @@ export class GeminiChat {
     }
     async *processStreamResponse(streamResponse, userInput) {
         const modelResponseParts = [];
-        let hasReceivedValidContent = false;
-        let hasReceivedAnyChunk = false;
-        let invalidChunkCount = 0;
-        let totalChunkCount = 0;
-        let streamingUsageMetadata = null;
+        let hasToolCall = false;
+        let hasFinishReason = false;
+        let hasTextResponse = false;
+        const allChunks = [];
         for await (const chunk of streamResponse) {
-            hasReceivedAnyChunk = true;
-            totalChunkCount++;
-            // Capture usage metadata from IContent chunks (from providers that yield IContent)
-            const chunkWithMetadata = chunk;
-            if (chunkWithMetadata?.metadata?.usage) {
-                streamingUsageMetadata = chunkWithMetadata.metadata.usage;
-            }
+            hasFinishReason =
+                chunk?.candidates?.some((candidate) => candidate.finishReason) ?? false;
             if (isValidResponse(chunk)) {
                 const content = chunk.candidates?.[0]?.content;
-                if (content) {
-                    // Check if this chunk has meaningful content (text or function calls)
-                    if (content.parts && content.parts.length > 0) {
-                        const hasMeaningfulContent = content.parts.some((part) => part.text ||
-                            'functionCall' in part ||
-                            'functionResponse' in part);
-                        if (hasMeaningfulContent) {
-                            hasReceivedValidContent = true;
-                        }
+                if (content?.parts) {
+                    if (content.parts.some((part) => part.functionCall)) {
+                        hasToolCall = true;
+                    }
+                    // Check if any part has text content (not just thoughts)
+                    if (content.parts.some((part) => part.text &&
+                        typeof part.text === 'string' &&
+                        part.text.trim() !== '')) {
+                        hasTextResponse = true;
                     }
                     // Filter out thought parts from being added to history.
-                    if (!this.isThoughtContent(content) && content.parts) {
-                        modelResponseParts.push(...content.parts);
+                    if (!this.isThoughtContent(content)) {
+                        modelResponseParts.push(...content.parts.filter((part) => !part.thought));
                     }
                 }
             }
-            else {
-                invalidChunkCount++;
+            // Record token usage if this chunk has usageMetadata
+            if (chunk.usageMetadata) {
+                if (chunk.usageMetadata.promptTokenCount !== undefined) {
+                    this.lastPromptTokenCount = chunk.usageMetadata.promptTokenCount;
+                }
             }
+            allChunks.push(chunk);
             yield chunk; // Yield every chunk to the UI immediately.
         }
-        // Now that the stream is finished, make a decision.
-        // Only throw an error if:
-        // 1. We received no chunks at all, OR
-        // 2. We received chunks but NONE had valid content (all were invalid or empty)
-        // This allows models like Qwen to send empty chunks at the end of a stream
-        // as long as they sent valid content earlier.
-        if (!hasReceivedAnyChunk ||
-            (!hasReceivedValidContent && totalChunkCount > 0)) {
-            // Only throw if this looks like a genuinely empty/invalid stream
-            // Not just a stream that ended with some invalid chunks
-            if (invalidChunkCount === totalChunkCount ||
-                modelResponseParts.length === 0) {
-                throw new EmptyStreamError('Model stream was invalid or completed without valid content.');
+        // String thoughts and consolidate text parts.
+        const consolidatedParts = [];
+        for (const part of modelResponseParts) {
+            const lastPart = consolidatedParts[consolidatedParts.length - 1];
+            if (lastPart?.text &&
+                isValidNonThoughtTextPart(lastPart) &&
+                isValidNonThoughtTextPart(part)) {
+                lastPart.text += part.text;
+            }
+            else {
+                consolidatedParts.push(part);
+            }
+        }
+        const responseText = consolidatedParts
+            .filter((part) => part.text)
+            .map((part) => part.text)
+            .join('')
+            .trim();
+        // Enhanced stream validation logic: A stream is considered successful if:
+        // 1. There's a tool call (tool calls can end without explicit finish reasons), OR
+        // 2. There's a finish reason AND we have non-empty response text, OR
+        // 3. We detected text content during streaming (hasTextResponse = true)
+        //
+        // We throw an error only when there's no tool call AND:
+        // - No finish reason AND no text response during streaming, OR
+        // - Empty response text after consolidation (e.g., only thoughts with no actual content)
+        if (!hasToolCall &&
+            ((!hasFinishReason && !hasTextResponse) || !responseText)) {
+            if (!hasFinishReason && !hasTextResponse) {
+                throw new InvalidStreamError('Model stream ended without a finish reason and no text response.', 'NO_FINISH_REASON_NO_TEXT');
+            }
+            else {
+                throw new InvalidStreamError('Model stream ended with empty response text.', 'NO_RESPONSE_TEXT');
             }
         }
         // Use recordHistory to correctly save the conversation turn.
         const modelOutput = [
-            { role: 'model', parts: modelResponseParts },
+            { role: 'model', parts: consolidatedParts },
         ];
+        // Capture usage metadata from the stream
+        let streamingUsageMetadata = null;
+        // Find the last chunk that has usage metadata (similar to getLastChunkWithMetadata logic)
+        const lastChunkWithMetadata = allChunks
+            .slice()
+            .reverse()
+            .find((chunk) => chunk.usageMetadata);
+        if (lastChunkWithMetadata && lastChunkWithMetadata.usageMetadata) {
+            streamingUsageMetadata = {
+                promptTokens: lastChunkWithMetadata.usageMetadata.promptTokenCount || 0,
+                completionTokens: lastChunkWithMetadata.usageMetadata.candidatesTokenCount || 0,
+                totalTokens: lastChunkWithMetadata.usageMetadata.totalTokenCount || 0,
+            };
+        }
         this.recordHistory(userInput, modelOutput, undefined, streamingUsageMetadata);
     }
     recordHistory(userInput, modelOutput, automaticFunctionCallingHistory, usageMetadata) {
@@ -1771,17 +1870,15 @@ 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;
+    resolveProviderBaseUrl(_provider) {
+        // REQ-SP4-004: ONLY read baseURL from runtime state, NEVER from provider instance.
+        // This ensures each agent/subagent can have its own baseURL even when using
+        // the same provider (e.g., main uses OpenRouter, subagent uses Cerebras, both via openai).
+        //
+        // If runtime state has baseURL → use it
+        // If runtime state has no baseURL → return undefined (provider uses default endpoint)
+        // NEVER read from provider instance - that violates stateless pattern and causes bugs
+        return this.runtimeState.baseUrl;
     }
 }
 /** Visible for Testing */