hasina-gemini-cli 1.0.0 → 1.0.2

package/README.md

@@ -174,10 +174,10 @@ npm start
 | `/exit` | Exit the app cleanly |
 | `/clear` | Clear in-memory history for the current session |
 | `/history` | Show recent conversation messages |
-| `/models` | Open a numbered Gemini model chooser |
+| `/models` | Open a numbered Gemini model chooser with backend version info |
 | `/save` | Persist the current session to local session storage |
 | `/new` | Start a fresh conversation session |
-| `/model` | Show the currently active model |
+| `/model` | Show the currently active model with backend version details |
 | `/use-model <model_name>` | Switch the active Gemini model at runtime |
 | `/system` | Show the active system prompt |
 | `/set-system <text>` | Override the current system prompt for this session |
@@ -196,11 +196,13 @@ Info > Type a message to chat, use /models to choose a model, or /help to list c
 You > /models
 Command > Choose a Gemini Model
 01. gemini-2.5-flash [active]
-    Gemini 2.5 Flash | input 1M | output 65.5K
+    Gemini 2.5 Flash
+    version=2.5-flash | input=1M | output=65.5K
 02. gemini-2.5-pro
-    Gemini 2.5 Pro | input 1M | output 65.5K
+    Gemini 2.5 Pro
+    version=2.5-pro | input=1M | output=65.5K
 Model > 2
-Success > Active model changed to "gemini-2.5-pro".
+Success > Active model changed to "gemini-2.5-pro" (version 2.5-pro).
 
 You > Explain event loops in Node.js.
 Gemini > The Node.js event loop coordinates timers, I/O callbacks, microtasks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hasina-gemini-cli",
-  "version": "1.0.0",
+  "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

@@ -13,6 +13,32 @@ function normalizeAssistantText(text) {
   return text.trim();
 }
 
+function normalizeIntentText(text) {
+  return String(text)
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .trim();
+}
+
+function isModelIdentityQuestion(text) {
+  const normalized = normalizeIntentText(text);
+  const patterns = [
+    /identifiant.*modele/,
+    /id.*modele/,
+    /modele.*exact/,
+    /quel.*modele.*(utilise|actif|es)/,
+    /donne.*modele/,
+    /model.*identifier/,
+    /exact.*model.*id/,
+    /what.*model.*are.*you/,
+    /which.*model.*are.*you/,
+    /model.*id/,
+  ];
+
+  return patterns.some((pattern) => pattern.test(normalized));
+}
+
 class App {
   constructor({ config, provider, printer }) {
     this.config = config;
@@ -49,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,
     };
@@ -177,12 +207,15 @@ class App {
     }
 
     if (selectedModel.id === this.state.model) {
-      this.printer.printInfo(`"${selectedModel.id}" is already the active model.`);
+      const versionSuffix = selectedModel.version ? ` (version ${selectedModel.version})` : '';
+      this.printer.printInfo(`"${selectedModel.id}" is already the active model${versionSuffix}.`);
       return false;
     }
 
     this.state.model = selectedModel.id;
-    this.printer.printSuccess(`Active model changed to "${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;
   }
 
@@ -206,6 +239,12 @@ class App {
   }
 
   async handleChatTurn(userInput) {
+    const handledLocally = await this.tryHandleLocalModelIdentityQuestion(userInput);
+
+    if (handledLocally) {
+      return;
+    }
+
     const loading = this.printer.createLoadingIndicator();
     let streamStarted = false;
 
@@ -257,6 +296,24 @@ class App {
     }
   }
 
+  async tryHandleLocalModelIdentityQuestion(userInput) {
+    if (!isModelIdentityQuestion(userInput)) {
+      return false;
+    }
+
+    const modelInfo = this.state.activeModelInfo || { id: this.state.model, version: null };
+    let message = `Identifiant du modele (local): ${modelInfo.id || this.state.model}.`;
+
+    if (modelInfo?.version) {
+      message = `Identifiant du modele (local): ${modelInfo.id} (version ${modelInfo.version}).`;
+    }
+
+    this.printer.printAssistant(message);
+    this.state.historyService.addMessage('user', userInput);
+    this.state.historyService.addMessage('assistant', message);
+    return true;
+  }
+
   async shutdown() {
     if (this.readline) {
       try {

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,7 +55,72 @@ function extractResponseText(response) {
     .join('');
 }
 
-function normalizeListedModel(model) {
+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();
 
   if (!id) {
@@ -62,7 +129,9 @@ function normalizeListedModel(model) {
 
   return {
     id,
+    apiName: String(model.name || `models/${id}`),
     displayName: model.displayName || id,
+    version: typeof model.version === 'string' && model.version.trim() ? model.version.trim() : null,
     description: model.description || '',
     inputTokenLimit: Number.isFinite(model.inputTokenLimit) ? model.inputTokenLimit : null,
     outputTokenLimit: Number.isFinite(model.outputTokenLimit) ? model.outputTokenLimit : null,
@@ -100,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) {
@@ -152,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,
     });
   }
@@ -178,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',
 
@@ -189,7 +279,23 @@ function createGeminiProvider({ apiKey }) {
       } catch (error) {
         throw createFriendlyGeminiError(
           error,
-          `Unable to validate model "${normalizedModel}".`
+          `Unable to validate model "${normalizedModel}".`,
+          { model: normalizedModel }
+        );
+      }
+    },
+
+    async getModelInfo(model) {
+      const normalizedModel = normalizeModelName(model);
+
+      try {
+        const response = await client.models.get({ model: normalizedModel });
+        return normalizeModelInfo(response);
+      } catch (error) {
+        throw createFriendlyGeminiError(
+          error,
+          `Unable to load details for model "${normalizedModel}".`,
+          { model: normalizedModel }
         );
       }
     },
@@ -204,7 +310,7 @@ function createGeminiProvider({ apiKey }) {
         const models = [];
 
         for await (const model of pager) {
-          const normalized = normalizeListedModel(model);
+          const normalized = normalizeModelInfo(model);
 
           if (!isChatCapableModel(normalized)) {
             continue;
@@ -220,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;
-          }
-
-          const delta = chunkText.startsWith(fullText)
-            ? chunkText.slice(fullText.length)
-            : chunkText;
-
-          if (!delta) {
-            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;
           }
 
-          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

@@ -68,6 +68,10 @@ function formatTokenCount(value) {
   return String(value);
 }
 
+function formatModelVersion(model) {
+  return model?.version || 'unknown';
+}
+
 class CommandService {
   constructor({ sessionService, provider }) {
     this.sessionService = sessionService;
@@ -129,7 +133,7 @@ class CommandService {
           return this.handleNew(state);
 
         case 'model':
-          return messageResult('info', `Active model: ${state.model}`);
+          return this.handleModel(state);
 
         case 'use-model':
           return this.handleUseModel(state, command.rawArgs);
@@ -203,16 +207,49 @@ class CommandService {
       const header = `${String(index + 1).padStart(2, '0')}. ${model.id}${
         tags.length ? ` [${tags.join(', ')}]` : ''
       }`;
-      const details = `${compactText(model.displayName, 48)} | input ${formatTokenCount(
-        model.inputTokenLimit
-      )} | output ${formatTokenCount(model.outputTokenLimit)}`;
-
-      return `${header}\n    ${details}`;
+      const details = [
+        compactText(model.displayName, 64),
+        `version=${formatModelVersion(model)} | input=${formatTokenCount(
+          model.inputTokenLimit
+        )} | output=${formatTokenCount(model.outputTokenLimit)}`,
+      ].map((line) => `    ${line}`).join('\n');
+
+      return `${header}\n${details}`;
     });
 
     return modelPickerResult('Choose a Gemini Model', lines, models);
   }
 
+  async handleModel(state) {
+    if (typeof this.provider.getModelInfo !== 'function') {
+      return messageResult('info', `Active model: ${state.model}`);
+    }
+
+    const model = await this.provider.getModelInfo(state.model);
+    state.activeModelInfo = model;
+    const tags = [];
+
+    if (model.isPreview) {
+      tags.push('preview');
+    }
+
+    if (model.isLatest) {
+      tags.push('latest');
+    }
+
+    const lines = [
+      `id=${model.id}${tags.length ? ` [${tags.join(', ')}]` : ''}`,
+      `display=${model.displayName}`,
+      `version=${formatModelVersion(model)}`,
+      `api=${model.apiName}`,
+      `input=${formatTokenCount(model.inputTokenLimit)} | output=${formatTokenCount(
+        model.outputTokenLimit
+      )}`,
+    ];
+
+    return blockResult('Active Model', lines);
+  }
+
   async handleSave(state) {
     const savedSession = await this.sessionService.saveSession({
       id: state.sessionId,
@@ -244,10 +281,16 @@ class CommandService {
       assertCommandArgument(rawArgs, 'Usage: /use-model <model_name>')
     );
 
-    await this.provider.validateModel(modelName);
+    const model = typeof this.provider.getModelInfo === 'function'
+      ? 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', `Active model changed to "${modelName}".`);
+    return messageResult(
+      'success',
+      `Active model changed to "${modelName}" (version ${formatModelVersion(model)}).`
+    );
   }
 
   handleSetSystem(state, rawArgs) {
@@ -284,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(