claude-scionos 4.2.0 → 4.3.1

package/README.fr.md

@@ -54,7 +54,7 @@ npx claude-scionos auth login
 npx claude-scionos auth login --service llm
 npx claude-scionos auth test
 npx claude-scionos --strategy aws
-npx claude-scionos --service llm --strategy claude-glm-5
+npx claude-scionos --service llm --strategy claude-gpt
 npx claude-scionos --strategy aws --no-prompt -p "Résume ce dépôt"
 ```
 
@@ -64,17 +64,18 @@ npx claude-scionos --strategy aws --no-prompt -p "Résume ce dépôt"
 - `--service llm` bascule le lanceur vers `https://llm.routerlab.ch`
 - `llm` est prévu pour un accès sur invitation
 - les tokens enregistrés avec `auth login --service llm` sont stockés séparément du token RouterLab par défaut
-- `llm` expose pour l'instant `claude-glm-5`, `claude-gpt-5.4` et `claude-qwen3.6-plus`
-- `routerlab` expose aussi `claude-gpt-5.4`
+- `llm` expose pour l'instant `claude-gpt`, `claude-qwen3.6-plus`, `claude-minimax-m2.7` et `claude-glm-5.1`
+- `routerlab` expose aussi `claude-gpt`, `claude-minimax-m2.7` et `claude-glm-5.1`
 
 ## Stratégies
 
 - `default` : utilise Claude Code normalement sans proxy local
 - `aws` : remappe les familles de modèles Claude vers les variantes Claude AWS de RouterLab
-- `claude-glm-5` : force toutes les requêtes vers `claude-glm-5`
-- `claude-minimax-m2.5` : force toutes les requêtes vers `claude-minimax-m2.5`
-- `claude-gpt-5.4` : force toutes les requêtes vers `claude-gpt-5.4`
+- `claude-gpt` : mappe les requêtes Claude vers la famille `claude-gpt`
+  `claude-gpt-5.5 ==> claude-opus-4.7`, `claude-gpt-5.4 ==> claude-sonnet-4.6`, `claude-gpt-5.4-mini ==> claude-gpt-5.4-mini`
 - `claude-qwen3.6-plus` : force toutes les requêtes vers `claude-qwen3.6-plus`
+- `claude-minimax-m2.7` : force toutes les requêtes vers `claude-minimax-m2.7`
+- `claude-glm-5.1` : force toutes les requêtes vers `claude-glm-5.1`
 
 Utilise `--list-strategies` pour voir les stratégies disponibles pour le service choisi et leur disponibilité réelle quand un token est disponible.
 

package/README.md

@@ -54,7 +54,7 @@ npx claude-scionos auth login
 npx claude-scionos auth login --service llm
 npx claude-scionos auth test
 npx claude-scionos --strategy aws
-npx claude-scionos --service llm --strategy claude-glm-5
+npx claude-scionos --service llm --strategy claude-gpt
 npx claude-scionos --strategy aws --no-prompt -p "Summarize this repo"
 ```
 
@@ -64,17 +64,18 @@ npx claude-scionos --strategy aws --no-prompt -p "Summarize this repo"
 - `--service llm` switches the launcher to `https://llm.routerlab.ch`
 - `llm` is intended for invitation-only access
 - Tokens stored with `auth login --service llm` are kept separate from the default RouterLab token
-- `llm` currently exposes `claude-glm-5`, `claude-gpt-5.4`, and `claude-qwen3.6-plus`
-- `routerlab` also exposes `claude-gpt-5.4`
+- `llm` currently exposes `claude-gpt`, `claude-qwen3.6-plus`, `claude-minimax-m2.7`, and `claude-glm-5.1`
+- `routerlab` also exposes `claude-gpt`, `claude-minimax-m2.7`, and `claude-glm-5.1`
 
 ## Strategies
 
 - `default`: use Claude Code normally without the local proxy
 - `aws`: remap Claude model families to RouterLab AWS-backed Claude variants
-- `claude-glm-5`: force all requests to `claude-glm-5`
-- `claude-minimax-m2.5`: force all requests to `claude-minimax-m2.5`
-- `claude-gpt-5.4`: force all requests to `claude-gpt-5.4`
+- `claude-gpt`: map Claude requests to the `claude-gpt` family
+  `claude-gpt-5.5 ==> claude-opus-4.7`, `claude-gpt-5.4 ==> claude-sonnet-4.6`, `claude-gpt-5.4-mini ==> claude-gpt-5.4-mini`
 - `claude-qwen3.6-plus`: force all requests to `claude-qwen3.6-plus`
+- `claude-minimax-m2.7`: force all requests to `claude-minimax-m2.7`
+- `claude-glm-5.1`: force all requests to `claude-glm-5.1`
 
 Use `--list-strategies` to see the strategies available for the selected service and their live availability when a token is available.
 

package/index.js

@@ -118,7 +118,7 @@ function showHelp() {
     console.log(chalk.gray("Examples"));
     console.log(`  ${chalk.cyan("claude-scionos --strategy aws")}`);
     console.log(`  ${chalk.cyan("claude-scionos auth login --service llm")}`);
-    console.log(`  ${chalk.cyan("claude-scionos --service llm --strategy claude-glm-5")}`);
+    console.log(`  ${chalk.cyan("claude-scionos --service llm --strategy claude-gpt")}`);
     console.log(`  ${chalk.cyan('claude-scionos --strategy aws --no-prompt -p "Summarize this repo"')}`);
     console.log(`  ${chalk.cyan("claude-scionos auth test")}`);
     console.log("");
@@ -159,11 +159,15 @@ function getStrategyIndicator(strategyValue, modelIds, serviceValue) {
 }
 
 function getStrategyMenuLabel(strategyValue) {
-    if (strategyValue === 'aws') {
+    const strategy = getServiceStrategies(DEFAULT_SERVICE)
+        .concat(getServiceStrategies('llm'))
+        .find((entry) => entry.value === strategyValue || entry.aliases?.includes(strategyValue));
+
+    if (strategy?.value === 'aws') {
         return '💰 aws 50%';
     }
 
-    return strategyValue;
+    return strategy?.selectionName || strategy?.name || strategyValue;
 }
 
 function normalizeStrategyValue(strategy) {
@@ -427,7 +431,9 @@ async function resolveStrategyChoice(parsed, modelIds, serviceConfig) {
     };
 
     if (parsed.strategy) {
-        const strategy = getServiceStrategies(serviceConfig.value).find((entry) => entry.value === parsed.strategy);
+        const strategy = getServiceStrategies(serviceConfig.value).find((entry) => (
+            entry.value === parsed.strategy || entry.aliases?.includes(parsed.strategy)
+        ));
         if (!strategy) {
             throw new Error(`Unknown strategy "${parsed.strategy}". Use --list-strategies to inspect the supported values.`);
         }
@@ -442,12 +448,13 @@ async function resolveStrategyChoice(parsed, modelIds, serviceConfig) {
     const strategyChoices = getStrategyChoices(modelIds, serviceConfig.value).map((choice) => {
         const launchReadiness = assessStrategyLaunch(choice.value, modelIds, serviceConfig.value);
         const disabled = hasVerifiedModelIds(modelIds) && !launchReadiness.ready ? launchReadiness.note : false;
+        const menuLabel = getStrategyMenuLabel(choice.value);
         return {
             ...choice,
             disabled,
-            name: `${getStrategyIndicator(choice.value, modelIds, serviceConfig.value)} ${getStrategyMenuLabel(choice.value)}`,
-            short: getStrategyMenuLabel(choice.value),
-            description: launchReadiness.note
+            name: `${getStrategyIndicator(choice.value, modelIds, serviceConfig.value)} ${menuLabel}`,
+            short: menuLabel,
+            description: choice.description
         };
     });
 
@@ -455,9 +462,12 @@ async function resolveStrategyChoice(parsed, modelIds, serviceConfig) {
         throw new Error(`No launchable strategy is available on ${serviceConfig.availabilityLabel}.`);
     }
 
-    const spacedStrategyChoices = strategyChoices.flatMap((choice, index) => (
-        index === strategyChoices.length - 1 ? [choice] : [choice, new Separator(' ')]
-    ));
+    const spacedStrategyChoices = [
+        new Separator(' '),
+        ...strategyChoices.flatMap((choice, index) => (
+            index === strategyChoices.length - 1 ? [choice] : [choice, new Separator(' ')]
+        ))
+    ];
 
     const selected = await select({
         message: 'Select Model Strategy:',
@@ -472,7 +482,7 @@ function showStrategies(modelIds = null, serviceConfig) {
     const strategies = listStrategies(modelIds, serviceConfig.value);
     showSection('Strategies', strategies.map((strategy) => {
         const indicator = getStrategyIndicator(strategy.value, modelIds, serviceConfig.value);
-        return `${indicator} ${chalk.white(getStrategyMenuLabel(strategy.value))} ${chalk.gray(`(${strategy.value})`)}\n    ${strategy.description}`;
+        return `${indicator} ${chalk.white(getStrategyMenuLabel(strategy.value))} ${chalk.gray(`(${strategy.value})`)}\n    ${[strategy.description, strategy.availability.note].filter(Boolean).join(' ')}`;
     }));
 }
 
@@ -694,6 +704,7 @@ async function main() {
         }
 
         const proxyInfo = await startProxyServer(modelChoice, token, {
+            availableModels: validation.models,
             baseUrl: resolveServiceBaseUrl(serviceConfig.value),
             debug: isDebug,
             onDebug: (message) => console.log(chalk.yellow(message)),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-scionos",
-    "version": "4.2.0",
+    "version": "4.3.1",
     "description": "RouterLab launcher, strategy proxy and secure token wrapper for Claude Code CLI",
     "type": "module",
     "main": "index.js",
@@ -43,12 +43,12 @@
     },
     "private": false,
     "dependencies": {
-        "@inquirer/prompts": "^8.4.1"
+        "@inquirer/prompts": "^8.4.2"
     },
     "devDependencies": {
         "@eslint/js": "^10.0.1",
-        "eslint": "^10.2.0",
+        "eslint": "^10.2.1",
         "globals": "^17.5.0",
-        "vitest": "^4.1.4"
+        "vitest": "^4.1.5"
     }
 }

package/src/proxy.js

@@ -52,9 +52,42 @@ function buildProxyRequestOptions(url, method, upstreamHeaders, validToken, body
   };
 }
 
-function resolveMappedModel(targetModel, requestedModel = '') {
+function getPreferredClaudeGptModel(requestedModel = '') {
+  if (requestedModel.includes('haiku') || requestedModel.includes('mini')) {
+    return 'claude-gpt-5.4-mini';
+  }
+
+  if (requestedModel.includes('opus')) {
+    return 'claude-gpt-5.5';
+  }
+
+  return 'claude-gpt-5.4';
+}
+
+function resolveMappedModel(targetModel, requestedModel = '', availableModels = []) {
   if (targetModel !== 'aws') {
-    return targetModel;
+    if (targetModel !== 'claude-gpt') {
+      return targetModel;
+    }
+
+    const preferredModel = getPreferredClaudeGptModel(requestedModel);
+    const availableClaudeGptModels = Array.isArray(availableModels)
+      ? availableModels.filter((model) => model.startsWith('claude-gpt-'))
+      : [];
+
+    if (availableClaudeGptModels.length === 0) {
+      return preferredModel;
+    }
+
+    if (availableClaudeGptModels.includes(preferredModel)) {
+      return preferredModel;
+    }
+
+    return (
+      availableClaudeGptModels.find((model) => model === 'claude-gpt-5.4')
+      ?? availableClaudeGptModels[0]
+      ?? preferredModel
+    );
   }
 
   if (requestedModel.includes('haiku')) {
@@ -94,7 +127,7 @@ function isAllowedProxyRoute(req) {
 }
 
 async function handleMessageRequest(req, res, options) {
-  const {baseUrl, debug, onDebug, onError, targetModel, validToken} = options;
+  const {availableModels = [], baseUrl, debug, onDebug, onError, targetModel, validToken} = options;
   const chunks = [];
   const maxSize = 100 * 1024 * 1024;
   let totalSize = 0;
@@ -122,9 +155,13 @@ async function handleMessageRequest(req, res, options) {
       }
 
       if (bodyJson?.model) {
-        const newModel = resolveMappedModel(targetModel, bodyJson.model);
+        const preferredModel = resolveMappedModel(targetModel, bodyJson.model);
+        const newModel = resolveMappedModel(targetModel, bodyJson.model, availableModels);
         if (debug) {
           onDebug(`[Proxy] Swapping model ${bodyJson.model} -> ${newModel}`);
+          if (preferredModel !== newModel) {
+            onDebug(`[Proxy] Fallback applied because ${preferredModel} is not available for this token`);
+          }
         }
 
         bodyJson.model = newModel;
@@ -216,6 +253,7 @@ async function forwardRequest(req, res, options) {
 
 function startProxyServer(targetModel, validToken, options = {}) {
   const {
+    availableModels = [],
     baseUrl = BASE_URL,
     debug = false,
     onDebug = () => {},
@@ -236,6 +274,7 @@ function startProxyServer(targetModel, validToken, options = {}) {
       }
 
       handleMessageRequest(req, res, {
+        availableModels,
         baseUrl,
         debug,
         onDebug,
@@ -261,4 +300,3 @@ export {
   resolveMappedModel,
   startProxyServer,
 };
-

package/src/routerlab.js

@@ -15,7 +15,7 @@ const SERVICES = {
     secureStorageAccount: 'routerlab-token',
     secureStorageLabel: 'RouterLab Token',
     secureStorageFileName: 'routerlab-token.secure.txt',
-    strategyValues: ['default', 'aws', 'claude-gpt-5.4', 'claude-glm-5', 'claude-minimax-m2.5'],
+    strategyValues: ['default', 'aws', 'claude-gpt', 'claude-minimax-m2.7', 'claude-glm-5.1'],
   },
   llm: {
     value: 'llm',
@@ -28,7 +28,7 @@ const SERVICES = {
     secureStorageAccount: 'routerlab-llm-token',
     secureStorageLabel: 'RouterLab LLM Token',
     secureStorageFileName: 'routerlab-llm-token.secure.txt',
-    strategyValues: ['claude-glm-5', 'claude-gpt-5.4', 'claude-qwen3.6-plus'],
+    strategyValues: ['claude-gpt', 'claude-qwen3.6-plus', 'claude-minimax-m2.7', 'claude-glm-5.1'],
   },
 };
 const DEFAULT_SERVICE = 'routerlab';
@@ -55,17 +55,17 @@ const AWS_CLAUDE_MODELS = [
 const STRATEGIES = [
   {
     value: 'default',
-    name: 'Default',
+    name: 'Claude Native',
     description: 'Uses Claude natively without a local proxy.',
-    selectionName: 'Default (Use Claude natively)',
+    selectionName: 'Claude Native (Opus 4.7)',
     selectionDescription: 'Standard behavior. Claude decides which model to use.',
     requiredModels: DEFAULT_CLAUDE_MODELS,
   },
   {
     value: 'aws',
-    name: 'Claude AWS',
+    name: 'Claude via AWS',
     description: 'Maps Claude requests to AWS-backed Claude variants.',
-    selectionName: 'Claude AWS (-50% du prix 💰)',
+    selectionName: 'Claude via AWS (Opus 4.6, -50%)',
     selectionDescription: 'Map models to aws-claude-haiku, aws-claude-sonnet, aws-claude-opus.',
     requiredModels: AWS_CLAUDE_MODELS,
     mappedModels: AWS_CLAUDE_MODELS,
@@ -85,11 +85,13 @@ const STRATEGIES = [
     mappedModels: ['claude-minimax-m2.5'],
   },
   {
-    value: 'claude-gpt-5.4',
-    name: 'GPT-5.4',
-    description: 'Forces all requests to claude-gpt-5.4.',
-    selectionDescription: 'Forces all requests to claude-gpt-5.4.',
-    mappedModels: ['claude-gpt-5.4'],
+    value: 'claude-gpt',
+    name: 'OpenAI GPT',
+    selectionName: 'OpenAI GPT (5.5, 5.4, 5.4-mini)',
+    description: 'Maps Claude requests to the claude-gpt family. Opus 4.7 => claude-gpt-5.5, Sonnet 4.6 => claude-gpt-5.4, Haiku => claude-gpt-5.4-mini.',
+    selectionDescription: 'Opus 4.7 => claude-gpt-5.5, Sonnet 4.6 => claude-gpt-5.4, Haiku => claude-gpt-5.4-mini.',
+    aliases: ['claude-gpt-5.4'],
+    verificationModels: ['claude-gpt-5.4'],
   },
   {
     value: 'claude-qwen3.6-plus',
@@ -98,6 +100,20 @@ const STRATEGIES = [
     selectionDescription: 'Forces all requests to claude-qwen3.6-plus.',
     mappedModels: ['claude-qwen3.6-plus'],
   },
+  {
+    value: 'claude-minimax-m2.7',
+    name: 'MiniMax M2.7',
+    description: 'Forces all requests to claude-minimax-m2.7.',
+    selectionDescription: 'Forces all requests to claude-minimax-m2.7.',
+    mappedModels: ['claude-minimax-m2.7'],
+  },
+  {
+    value: 'claude-glm-5.1',
+    name: 'GLM-5.1',
+    description: 'Forces all requests to claude-glm-5.1.',
+    selectionDescription: 'Forces all requests to claude-glm-5.1.',
+    mappedModels: ['claude-glm-5.1'],
+  },
 ];
 
 async function fetchModels(apiKey, options = {}) {
@@ -191,7 +207,7 @@ function getServiceConfig(serviceValue = DEFAULT_SERVICE) {
   return SERVICES[normalizeServiceValue(serviceValue)] ?? null;
 }
 
-function resolveServiceBaseUrl(serviceValue = DEFAULT_SERVICE, env = process.env) {
+function resolveServiceBaseUrl(serviceValue = DEFAULT_SERVICE, env = {}) {
   return env.ANTHROPIC_BASE_URL?.trim() || getServiceConfig(serviceValue)?.baseUrl || BASE_URL;
 }
 
@@ -245,12 +261,19 @@ function getServiceStrategies(serviceValue = DEFAULT_SERVICE) {
     .filter(Boolean);
 }
 
+function normalizeStrategyValue(strategyValue) {
+  return strategyValue === 'claude-gpt-5.4' ? 'claude-gpt' : strategyValue;
+}
+
 function findStrategy(strategyValue, serviceValue = DEFAULT_SERVICE) {
-  return getServiceStrategies(serviceValue).find((strategy) => strategy.value === strategyValue) ?? null;
+  const normalizedValue = normalizeStrategyValue(strategyValue);
+  return getServiceStrategies(serviceValue).find((strategy) => (
+    strategy.value === normalizedValue || strategy.aliases?.includes(strategyValue)
+  )) ?? null;
 }
 
 function getRequiredModels(strategy) {
-  return strategy?.requiredModels ?? strategy?.mappedModels ?? [];
+  return strategy?.requiredModels ?? strategy?.verificationModels ?? strategy?.mappedModels ?? [];
 }
 
 function hasVerifiedModelIds(modelIds) {
@@ -391,17 +414,18 @@ function assessStrategyLaunch(strategyValue, modelIds = [], serviceValue = DEFAU
 }
 
 function getFallbackStrategy(strategyValue, modelIds = [], serviceValue = DEFAULT_SERVICE) {
+  const normalizedValue = normalizeStrategyValue(strategyValue);
   if (hasExploitableModelIds(modelIds, serviceValue)) {
-    return assessStrategyLaunch(strategyValue, modelIds, serviceValue).ready ? strategyValue : null;
+    return assessStrategyLaunch(normalizedValue, modelIds, serviceValue).ready ? normalizedValue : null;
   }
 
-  const availability = assessStrategy(strategyValue, modelIds, serviceValue);
-  return availability.level === 'unavailable' ? null : strategyValue;
+  const availability = assessStrategy(normalizedValue, modelIds, serviceValue);
+  return availability.level === 'unavailable' ? null : normalizedValue;
 }
 
 function getStrategyChoices(modelIds = [], serviceValue = DEFAULT_SERVICE) {
   return listStrategies(modelIds, serviceValue).map((strategy) => ({
-    name: strategy.value,
+    name: strategy.selectionName ?? strategy.name ?? strategy.value,
     value: strategy.value,
     description: strategy.selectionDescription ?? strategy.description,
   }));