hasina-gemini-cli 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hasina-gemini-cli",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Production-ready terminal AI chat application powered by the official Gemini API SDK.",
   "main": "src/index.js",
   "bin": {

package/src/app.js

@@ -75,6 +75,10 @@ class App {
       sessionId: await this.sessionService.generateSessionId(),
       sessionCreatedAt: new Date().toISOString(),
       model: this.config.defaultModel,
+      activeModelInfo: {
+        id: this.config.defaultModel,
+        version: null,
+      },
       systemPrompt: this.config.systemPrompt,
       historyService: this.historyService,
     };
@@ -209,6 +213,7 @@ class App {
     }
 
     this.state.model = selectedModel.id;
+    this.state.activeModelInfo = selectedModel;
     const versionSuffix = selectedModel.version ? ` (version ${selectedModel.version})` : '';
     this.printer.printSuccess(`Active model changed to "${selectedModel.id}"${versionSuffix}.`);
     return false;
@@ -296,20 +301,11 @@ class App {
       return false;
     }
 
-    let message = `Identifiant du modele (local): ${this.state.model}.`;
+    const modelInfo = this.state.activeModelInfo || { id: this.state.model, version: null };
+    let message = `Identifiant du modele (local): ${modelInfo.id || this.state.model}.`;
 
-    if (typeof this.provider.getModelInfo === 'function') {
-      try {
-        const modelInfo = await this.provider.getModelInfo(this.state.model);
-
-        if (modelInfo?.version) {
-          message = `Identifiant du modele (local): ${modelInfo.id} (version ${modelInfo.version}).`;
-        } else if (modelInfo?.id) {
-          message = `Identifiant du modele (local): ${modelInfo.id}.`;
-        }
-      } catch (_error) {
-        // Ignore lookup failures and use the active model from local state.
-      }
+    if (modelInfo?.version) {
+      message = `Identifiant du modele (local): ${modelInfo.id} (version ${modelInfo.version}).`;
     }
 
     this.printer.printAssistant(message);

package/src/config/gemini.js

@@ -10,6 +10,8 @@ const NON_CHAT_MODEL_KEYWORDS = [
   'robotics',
   'computer-use',
 ];
+const TRANSIENT_STATUS_CODES = new Set([429, 500, 502, 503, 504]);
+const RETRY_DELAYS_MS = [1200, 2500];
 
 function buildGeminiChatParams({ model, systemPrompt, history }) {
   const params = {
@@ -53,6 +55,71 @@ function extractResponseText(response) {
     .join('');
 }
 
+function sleep(durationMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, durationMs);
+  });
+}
+
+function getErrorStatus(error) {
+  if (typeof error?.status === 'number') {
+    return error.status;
+  }
+
+  if (typeof error?.cause?.status === 'number') {
+    return error.cause.status;
+  }
+
+  return undefined;
+}
+
+function getErrorMessage(error) {
+  if (typeof error?.message === 'string' && error.message.trim()) {
+    return error.message.trim();
+  }
+
+  if (typeof error?.cause?.message === 'string' && error.cause.message.trim()) {
+    return error.cause.message.trim();
+  }
+
+  return '';
+}
+
+function isPreviewModel(model) {
+  return typeof model === 'string' && /preview|exp|experimental/i.test(model);
+}
+
+function isTransientGeminiError(error) {
+  const status = getErrorStatus(error);
+  const lowerMessage = getErrorMessage(error).toLowerCase();
+
+  return (
+    TRANSIENT_STATUS_CODES.has(status) ||
+    lowerMessage.includes('high demand') ||
+    lowerMessage.includes('service unavailable') ||
+    lowerMessage.includes('temporarily unavailable') ||
+    lowerMessage.includes('unavailable') ||
+    lowerMessage.includes('rate limit') ||
+    lowerMessage.includes('fetch failed') ||
+    lowerMessage.includes('timeout') ||
+    lowerMessage.includes('timed out') ||
+    lowerMessage.includes('econnreset') ||
+    lowerMessage.includes('enotfound')
+  );
+}
+
+function buildTemporaryUnavailableMessage(model) {
+  const baseMessage = model
+    ? `Gemini is temporarily unavailable for "${model}".`
+    : 'Gemini is temporarily unavailable.';
+
+  if (isPreviewModel(model)) {
+    return `${baseMessage} Preview models can be under heavy demand. Retry in a few moments or switch with /use-model gemini-2.5-flash.`;
+  }
+
+  return `${baseMessage} Try again in a few moments.`;
+}
+
 function normalizeModelInfo(model) {
   const id = String(model?.name || '').replace(/^models\//, '').trim();
 
@@ -102,9 +169,10 @@ function sortModels(models, currentModel) {
   });
 }
 
-function createFriendlyGeminiError(error, fallbackMessage) {
-  const status = typeof error?.status === 'number' ? error.status : undefined;
-  const message = typeof error?.message === 'string' ? error.message.trim() : '';
+function createFriendlyGeminiError(error, fallbackMessage, options = {}) {
+  const model = options.model;
+  const status = getErrorStatus(error);
+  const message = getErrorMessage(error);
   const lowerMessage = message.toLowerCase();
 
   if (status === 400) {
@@ -154,7 +222,7 @@ function createFriendlyGeminiError(error, fallbackMessage) {
   }
 
   if (status >= 500) {
-    return new Error('Gemini is temporarily unavailable. Try again in a few moments.', {
+    return new Error(buildTemporaryUnavailableMessage(model), {
       cause: error,
     });
   }
@@ -180,6 +248,26 @@ function createFriendlyGeminiError(error, fallbackMessage) {
 function createGeminiProvider({ apiKey }) {
   const client = new GoogleGenAI({ apiKey });
 
+  async function retryOperation(operation, { model, fallbackMessage }) {
+    let lastError = null;
+
+    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt += 1) {
+      try {
+        return await operation(attempt);
+      } catch (error) {
+        lastError = error;
+
+        if (!isTransientGeminiError(error) || attempt >= RETRY_DELAYS_MS.length) {
+          throw createFriendlyGeminiError(error, fallbackMessage, { model });
+        }
+
+        await sleep(RETRY_DELAYS_MS[attempt]);
+      }
+    }
+
+    throw createFriendlyGeminiError(lastError, fallbackMessage, { model });
+  }
+
   return {
     name: 'gemini',
 
@@ -191,7 +279,8 @@ function createGeminiProvider({ apiKey }) {
       } catch (error) {
         throw createFriendlyGeminiError(
           error,
-          `Unable to validate model "${normalizedModel}".`
+          `Unable to validate model "${normalizedModel}".`,
+          { model: normalizedModel }
         );
       }
     },
@@ -205,7 +294,8 @@ function createGeminiProvider({ apiKey }) {
       } catch (error) {
         throw createFriendlyGeminiError(
           error,
-          `Unable to load details for model "${normalizedModel}".`
+          `Unable to load details for model "${normalizedModel}".`,
+          { model: normalizedModel }
         );
       }
     },
@@ -236,70 +326,90 @@ function createGeminiProvider({ apiKey }) {
     },
 
     async generateReply({ model, systemPrompt, history, message }) {
-      try {
-        const chat = client.chats.create(
-          buildGeminiChatParams({
+      return retryOperation(
+        async () => {
+          const chat = client.chats.create(
+            buildGeminiChatParams({
+              model,
+              systemPrompt,
+              history,
+            })
+          );
+
+          const response = await chat.sendMessage({ message });
+
+          return {
             model,
-            systemPrompt,
-            history,
-          })
-        );
-
-        const response = await chat.sendMessage({ message });
-
-        return {
+            streamed: false,
+            text: extractResponseText(response),
+          };
+        },
+        {
           model,
-          streamed: false,
-          text: extractResponseText(response),
-        };
-      } catch (error) {
-        throw createFriendlyGeminiError(error, 'Gemini request failed.');
-      }
+          fallbackMessage: 'Gemini request failed.',
+        }
+      );
     },
 
     async streamReply({ model, systemPrompt, history, message, onTextChunk }) {
-      try {
-        const chat = client.chats.create(
-          buildGeminiChatParams({
-            model,
-            systemPrompt,
-            history,
-          })
-        );
-
-        const stream = await chat.sendMessageStream({ message });
-        let fullText = '';
-
-        for await (const chunk of stream) {
-          const chunkText = extractResponseText(chunk);
-
-          if (!chunkText) {
-            continue;
+      return retryOperation(
+        async () => {
+          const chat = client.chats.create(
+            buildGeminiChatParams({
+              model,
+              systemPrompt,
+              history,
+            })
+          );
+
+          const stream = await chat.sendMessageStream({ message });
+          let fullText = '';
+          let emittedAnyChunk = false;
+
+          try {
+            for await (const chunk of stream) {
+              const chunkText = extractResponseText(chunk);
+
+              if (!chunkText) {
+                continue;
+              }
+
+              const delta = chunkText.startsWith(fullText)
+                ? chunkText.slice(fullText.length)
+                : chunkText;
+
+              if (!delta) {
+                continue;
+              }
+
+              fullText += delta;
+              emittedAnyChunk = true;
+
+              if (typeof onTextChunk === 'function') {
+                onTextChunk(delta);
+              }
+            }
+          } catch (error) {
+            if (emittedAnyChunk) {
+              throw createFriendlyGeminiError(error, 'Gemini streaming request failed.', {
+                model,
+              });
+            }
+
+            throw error;
           }
 
-          const delta = chunkText.startsWith(fullText)
-            ? chunkText.slice(fullText.length)
-            : chunkText;
-
-          if (!delta) {
-            continue;
-          }
-
-          fullText += delta;
-
-          if (typeof onTextChunk === 'function') {
-            onTextChunk(delta);
-          }
-        }
-
-        return {
+          return {
+            model,
+            streamed: true,
+            text: fullText,
+          };
+        },
+        {
           model,
-          streamed: true,
-          text: fullText,
-        };
-      } catch (error) {
-        throw createFriendlyGeminiError(error, 'Gemini streaming request failed.');
-      }
+          fallbackMessage: 'Gemini streaming request failed.',
+        }
+      );
     },
   };
 }

package/src/services/command.service.js

@@ -226,6 +226,7 @@ class CommandService {
     }
 
     const model = await this.provider.getModelInfo(state.model);
+    state.activeModelInfo = model;
     const tags = [];
 
     if (model.isPreview) {
@@ -284,6 +285,7 @@ class CommandService {
       ? await this.provider.getModelInfo(modelName)
       : await this.provider.validateModel(modelName);
     state.model = modelName;
+    state.activeModelInfo = model?.id ? model : { id: modelName, version: null };
 
     return messageResult(
       'success',
@@ -325,6 +327,7 @@ class CommandService {
     state.sessionId = session.id;
     state.sessionCreatedAt = session.createdAt;
     state.model = session.model;
+    state.activeModelInfo = { id: session.model, version: null };
     state.systemPrompt = session.systemPrompt;
 
     return messageResult(