@plexor-dev/claude-code-plugin-staging 0.1.0-beta.16 → 0.1.0-beta.17

package/commands/plexor-provider.js

@@ -74,9 +74,16 @@ function main() {
 
   config.settings = config.settings || {};
   config.settings.preferred_provider = requested;
+  if (requested !== 'auto') {
+    delete config.settings.preferred_model;
+    delete config.settings.preferredModel;
+  }
   if (!saveConfig(config)) { process.exit(1); }
 
   console.log(`Provider: ${current.value} → ${requested}`);
+  if (requested !== 'auto') {
+    console.log('  Cleared preferred_model to keep provider/model force hints mutually exclusive.');
+  }
   console.log(`  ${DESC[requested]}`);
   console.log('  Takes effect on next request.');
 }

package/commands/plexor-settings.js

@@ -127,6 +127,10 @@ function setDimension(dimension, value, config) {
 
   config.settings = config.settings || {};
   config.settings[configKey] = resolved;
+  if (configKey === 'preferred_provider' && resolved !== 'auto') {
+    delete config.settings.preferred_model;
+    delete config.settings.preferredModel;
+  }
   if (configKeyAlt && config.settings[configKeyAlt]) {
     delete config.settings[configKeyAlt];
   }
@@ -134,6 +138,9 @@ function setDimension(dimension, value, config) {
   if (!saveConfig(config)) { process.exit(1); }
 
   console.log(`${label} updated: ${current.value} → ${resolved}`);
+  if (configKey === 'preferred_provider' && resolved !== 'auto') {
+    console.log('  Cleared preferred_model to keep provider/model force hints mutually exclusive.');
+  }
   console.log(`  ${descMap[resolved]}`);
   console.log(`  Takes effect on next request.`);
 }

package/hooks/intercept.js

@@ -54,6 +54,8 @@ const VALID_PROVIDER_HINTS = new Set([
   'cohere'
 ]);
 
+const DISABLED_MODEL_HINTS = new Set(['auto', 'none', 'off']);
+
 function normalizeOrchestrationMode(mode) {
   if (typeof mode !== 'string') {
     return null;
@@ -120,6 +122,42 @@ function resolvePreferredProvider(settings) {
   return cfgProvider || 'auto';
 }
 
+function normalizePreferredModel(model) {
+  if (typeof model !== 'string') {
+    return null;
+  }
+  const trimmed = model.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (DISABLED_MODEL_HINTS.has(trimmed.toLowerCase())) {
+    return null;
+  }
+  return trimmed;
+}
+
+function resolvePreferredModel(settings) {
+  const envModel = normalizePreferredModel(
+    process.env.PLEXOR_MODEL || process.env.PLEXOR_PREFERRED_MODEL
+  );
+  if (envModel) {
+    return envModel;
+  }
+  const cfgModel = normalizePreferredModel(settings?.preferredModel || settings?.preferred_model);
+  return cfgModel || null;
+}
+
+function validateForceHintSelection(preferredProvider, preferredModel) {
+  if (!preferredModel || preferredProvider === 'auto') {
+    return;
+  }
+  const error = new Error(
+    'Invalid Plexor config: force only one hint. Set preferred_provider OR preferred_model, not both.'
+  );
+  error.code = 'PLEXOR_CONFIG_CONFLICT';
+  throw error;
+}
+
 // Try to load lib modules, fall back to inline implementations
 let ConfigManager, SessionManager, LocalCache, Logger, PlexorClient;
 let config, session, cache, logger;
@@ -175,6 +213,7 @@ try {
           localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
           mode: cfg.settings?.mode || 'balanced',
           preferredProvider: cfg.settings?.preferred_provider || 'auto',
+          preferredModel: cfg.settings?.preferredModel || cfg.settings?.preferred_model || null,
           orchestrationMode:
             cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
         };
@@ -298,6 +337,8 @@ async function main() {
     const orchestrationMode = resolveOrchestrationMode(settings);
     const gatewayMode = resolveGatewayMode(settings);
     const preferredProvider = resolvePreferredProvider(settings);
+    const preferredModel = resolvePreferredModel(settings);
+    validateForceHintSelection(preferredProvider, preferredModel);
 
     // Phase 3 Hypervisor Mode Detection
     // When ANTHROPIC_BASE_URL points to Plexor, all intelligence is server-side
@@ -316,6 +357,7 @@ async function main() {
       // Add session tracking metadata (server will use this for analytics)
       return output({
         ...request,
+        ...(preferredModel ? { model: preferredModel } : {}),
         plexor_mode: gatewayMode,
         ...(preferredProvider !== 'auto' ? { plexor_provider: preferredProvider } : {}),
         plexor_orchestration_mode: orchestrationMode,
@@ -326,6 +368,7 @@ async function main() {
           orchestration_mode: orchestrationMode,
           plexor_mode: gatewayMode,
           preferred_provider: preferredProvider,
+          preferred_model: preferredModel,
           cwd: process.cwd(),
           timestamp: Date.now(),
         }
@@ -488,6 +531,13 @@ async function main() {
     return output(optimizedRequest);
 
   } catch (error) {
+    if (error?.code === 'PLEXOR_CONFIG_CONFLICT') {
+      logger.error(`Configuration error: ${error.message}`);
+      logger.ux(error.message);
+      process.stderr.write(`\n[Plexor] ${error.message}\n`);
+      process.exit(1);
+    }
+
     logger.error(`Error: ${error.message}`);
     logger.ux(`Optimization hook error: ${error.message}`);
     logger.debug(error.stack);

package/lib/config-utils.js

@@ -7,6 +7,50 @@ const path = require('path');
 const crypto = require('crypto');
 const { PLEXOR_DIR, CONFIG_PATH } = require('./constants');
 
+const DISABLED_HINT_VALUES = new Set(['', 'auto', 'none', 'off']);
+
+function normalizeForcedProvider(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized || normalized === 'auto') {
+    return 'auto';
+  }
+  return normalized;
+}
+
+function normalizeForcedModel(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const normalized = value.trim();
+  if (!normalized || DISABLED_HINT_VALUES.has(normalized.toLowerCase())) {
+    return null;
+  }
+  return normalized;
+}
+
+function hasForcedHintConflict(config) {
+  const settings = config?.settings || {};
+  const provider = normalizeForcedProvider(
+    settings.preferred_provider ?? settings.preferredProvider ?? 'auto'
+  );
+  const model = normalizeForcedModel(settings.preferred_model ?? settings.preferredModel);
+  return Boolean(model) && provider !== 'auto';
+}
+
+function validateForcedHintConfig(config) {
+  if (!hasForcedHintConflict(config)) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    message:
+      'Invalid Plexor config: set only one force hint. Use preferred_provider OR preferred_model, not both.'
+  };
+}
+
 function loadConfig() {
   try {
     if (!fs.existsSync(CONFIG_PATH)) {
@@ -31,6 +75,12 @@ function loadConfig() {
 
 function saveConfig(config) {
   try {
+    const validation = validateForcedHintConfig(config);
+    if (!validation.ok) {
+      console.error(`Error: ${validation.message}`);
+      return false;
+    }
+
     if (!fs.existsSync(PLEXOR_DIR)) {
       fs.mkdirSync(PLEXOR_DIR, { recursive: true, mode: 0o700 });
     }
@@ -71,4 +121,4 @@ function readSetting(config, configKey, configKeyAlt, envVar, validValues, defau
   return { value: defaultValue, source: 'default' };
 }
 
-module.exports = { loadConfig, saveConfig, readSetting };
+module.exports = { loadConfig, saveConfig, readSetting, hasForcedHintConflict, validateForcedHintConfig };

package/lib/config.js

@@ -5,6 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const { CONFIG_PATH, PLEXOR_DIR, DEFAULT_API_URL, DEFAULT_TIMEOUT } = require('./constants');
+const { validateForcedHintConfig } = require('./config-utils');
 
 class ConfigManager {
   constructor() {
@@ -23,6 +24,7 @@ class ConfigManager {
         localCacheEnabled: cfg.settings?.localCacheEnabled ?? false,
         mode: cfg.settings?.mode || 'balanced',
         preferredProvider: cfg.settings?.preferred_provider || 'auto',
+        preferredModel: cfg.settings?.preferredModel || cfg.settings?.preferred_model || null,
         orchestrationMode:
           cfg.settings?.orchestrationMode || cfg.settings?.orchestration_mode || 'autonomous'
       };
@@ -55,6 +57,11 @@ class ConfigManager {
           localCacheEnabled: config.localCacheEnabled ?? existing.settings?.localCacheEnabled,
           mode: config.mode ?? existing.settings?.mode,
           preferred_provider: config.preferredProvider ?? existing.settings?.preferred_provider,
+          preferred_model:
+            config.preferredModel ??
+            config.preferred_model ??
+            existing.settings?.preferredModel ??
+            existing.settings?.preferred_model,
           orchestrationMode:
             config.orchestrationMode ??
             config.orchestration_mode ??
@@ -63,6 +70,11 @@ class ConfigManager {
         }
       };
 
+      const validation = validateForcedHintConfig(updated);
+      if (!validation.ok) {
+        return false;
+      }
+
       fs.writeFileSync(this.configPath, JSON.stringify(updated, null, 2), { mode: 0o600 });
       return true;
     } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plexor-dev/claude-code-plugin-staging",
-  "version": "0.1.0-beta.16",
+  "version": "0.1.0-beta.17",
   "description": "STAGING - LLM cost optimization plugin for Claude Code (internal testing)",
   "main": "lib/constants.js",
   "bin": {