@zhiman_innies/innies-codex 0.122.47 → 0.122.49

package/bin/innies-config.js

@@ -13,7 +13,14 @@ const DEFAULT_PROVIDER = "zhiman_35b";
 // The earlier "qwen3.6-27b" string was a placeholder that did not
 // correspond to a real DashScope model id.
 const DASHSCOPE_MODEL = "qwen3.6-27b";
-const QWEN_MODELS = new Set([DEFAULT_MODEL, DASHSCOPE_MODEL]);
+// Private-deployment 27B vLLM slug. Distinct from the 35B `qwen35_35b`
+// managed default and the bailian public-cloud `qwen3.6-27b`. Lives
+// behind its own provider id (`zhiman_27b`) so the two private
+// deployments can carry different base_url / env_key overrides
+// without colliding on the builtin `zhiman` factory.
+const PRIVATE_27B_MODEL = "qwen36_27b";
+const PRIVATE_27B_PROVIDER = "zhiman_27b";
+const QWEN_MODELS = new Set([DEFAULT_MODEL, DASHSCOPE_MODEL, PRIVATE_27B_MODEL]);
 const LEGACY_MODELS = new Set(["qwen-plus", "qwen-plus-latest"]);
 const DEFAULT_HOME_DIR = ".inniescoder";
 const DEFAULT_CATALOG_FILENAME = "catalog.json";
@@ -23,6 +30,7 @@ const DEFAULT_SUPERPOWERS_DIRNAME = "superpowers";
 const INSTALL_SUPERPOWERS_ENV = "INNIES_INSTALL_SUPERPOWERS";
 const SUPERPOWERS_MARKER_FILENAME = ".innies-superpowers.marker";
 const ZHIMAN_35B_PROVIDER_HEADER = "[model_providers.zhiman_35b]";
+const ZHIMAN_27B_PROVIDER_HEADER = "[model_providers.zhiman_27b]";
 const DASHSCOPE_PROVIDER_HEADER = "[model_providers.dashscope]";
 // Default `wire_api` emitted in freshly generated provider blocks. Both
 // the private vLLM and the DashScope public cloud only expose the
@@ -45,9 +53,6 @@ const ROOT_MANAGED_SETTINGS = Object.freeze([
   ["model_catalog_json", null],
   ["model_reasoning_effort", null],
 ]);
-const LEGACY_MANAGED_GPT_MODEL = "gpt-5.5";
-const LEGACY_MANAGED_GPT_PROVIDER = "openai";
-const LEGACY_MANAGED_GPT_REASONING = "high";
 
 export function resolveInniesHome() {
   if (process.env.INNIES_HOME) {
@@ -300,6 +305,8 @@ function defaultInniesConfig(catalogPath, managedDefault) {
     "",
     defaultZhiman35bProviderBlock(),
     "",
+    defaultZhiman27bProviderBlock(),
+    "",
     defaultDashscopeProviderBlock(),
     "",
   ].join("\n");
@@ -332,6 +339,9 @@ function normalizeInniesConfig(contents, catalogPath, state) {
   if (!updated.includes(ZHIMAN_35B_PROVIDER_HEADER)) {
     updated = `${updated.trimEnd()}\n\n${defaultZhiman35bProviderBlock()}\n`;
   }
+  if (!updated.includes(ZHIMAN_27B_PROVIDER_HEADER)) {
+    updated = `${updated.trimEnd()}\n\n${defaultZhiman27bProviderBlock()}\n`;
+  }
   if (!updated.includes(DASHSCOPE_PROVIDER_HEADER)) {
     updated = `${updated.trimEnd()}\n\n${defaultDashscopeProviderBlock()}\n`;
   }
@@ -360,14 +370,17 @@ function preservedUserManagedLines(contents, catalogPath) {
     (preservedModelValue === DEFAULT_MODEL &&
       (preservedProviderValue == null || preservedProviderValue === DEFAULT_PROVIDER)) ||
     (preservedModelValue === DASHSCOPE_MODEL &&
-      (preservedProviderValue == null || preservedProviderValue === "dashscope"));
+      (preservedProviderValue == null || preservedProviderValue === "dashscope")) ||
+    (preservedModelValue === PRIVATE_27B_MODEL &&
+      (preservedProviderValue == null ||
+        preservedProviderValue === PRIVATE_27B_PROVIDER));
   const preservedEffort = preservesQwenModel
     ? null
     : readRootSetting(contents, "model_reasoning_effort");
 
   return [
-    preservedModelProvider ?? 'model_provider = "openai"',
-    preservedModel ?? 'model = "gpt-5.5"',
+    preservedModelProvider ?? `model_provider = "${DEFAULT_PROVIDER}"`,
+    preservedModel ?? `model = "${DEFAULT_MODEL}"`,
     `model_catalog_json = ${JSON.stringify(catalogPath)}`,
     ...(preservedEffort ? [preservedEffort] : []),
   ];
@@ -419,11 +432,8 @@ function determineModelSelectionState(contents, previousState) {
   }
 
   if (
-    previousState.model_selection_state === MODEL_SELECTION_STATES.MANAGED_DEFAULT &&
-    currentModel === LEGACY_MANAGED_GPT_MODEL &&
-    currentProvider === LEGACY_MANAGED_GPT_PROVIDER &&
-    extractRootSettingValue(contents, "model_reasoning_effort") ===
-      LEGACY_MANAGED_GPT_REASONING
+    currentModel === PRIVATE_27B_MODEL &&
+    (currentProvider == null || currentProvider === PRIVATE_27B_PROVIDER)
   ) {
     return previousState;
   }
@@ -432,7 +442,8 @@ function determineModelSelectionState(contents, previousState) {
     currentModel != null &&
     !LEGACY_MODELS.has(currentModel) &&
     (currentModel !== DEFAULT_MODEL || currentProvider !== DEFAULT_PROVIDER) &&
-    (currentModel !== DASHSCOPE_MODEL || currentProvider !== "dashscope")
+    (currentModel !== DASHSCOPE_MODEL || currentProvider !== "dashscope") &&
+    (currentModel !== PRIVATE_27B_MODEL || currentProvider !== PRIVATE_27B_PROVIDER)
   ) {
     return {
       model_selection_state: MODEL_SELECTION_STATES.USER_SELECTED,
@@ -481,20 +492,82 @@ function normalizeManagedProviderBlocks(contents) {
   // NOTE: we deliberately do NOT auto-inject `base_url` or `env_key`
   // into user blocks. The user must configure these themselves (either
   // in the TOML block or via the corresponding env var: ZHIMAN_API_KEY
-  // / BAILIAN_API_KEY / ZHIMAN_35B_API_KEY). The Rust builtin
+  // / DASHSCOPE_API_KEY / ZHIMAN_35B_API_KEY). The Rust builtin
   // providers fall back to the env var when `env_key` is absent from
   // the TOML, so the only thing that is strictly required from the
-  // user is `base_url` (or the ZHIMAN_BASE_URL / BAILIAN_BASE_URL env
+  // user is `base_url` (or the ZHIMAN_BASE_URL / DASHSCOPE_BASE_URL env
   // var). We only normalize `wire_api` to a known-good value.
   let updated = normalizeProviderBlock(contents, {
     providerHeader: ZHIMAN_35B_PROVIDER_HEADER,
   });
+  updated = normalizeProviderBlock(updated, {
+    providerHeader: ZHIMAN_27B_PROVIDER_HEADER,
+  });
   updated = normalizeProviderBlock(updated, {
     providerHeader: DASHSCOPE_PROVIDER_HEADER,
   });
+  // Migration safety net: legacy / typo'd `env_key` names for the
+  // dashscope block. If a user has `env_key = "BAILIAN_API_KEY"` (the
+  // pre-rename name) or any other variant, codex will read that env
+  // var, find it unset, and silently fall back to the builtin OpenAI
+  // default — which then 401s on api.openai.com with whatever
+  // OPENAI_API_KEY happens to be set. That looks like a streaming /
+  // interruption bug to the user. Pin the value to the canonical
+  // DASHSCOPE_API_KEY here so the lookup matches the factory and the
+  // user manual.
+  updated = enforceDashscopeEnvKey(updated);
   return updated;
 }
 
+// Pin the dashscope block's `env_key` to DASHSCOPE_API_KEY. The block
+// is the user-facing alias for the builtin `bailian` provider; the
+// factory at codex-rs/model-provider-info/src/lib.rs reads
+// `DASHSCOPE_API_KEY` (and only that name) from the environment, so
+// anything else here is a typo / legacy name. Auto-correct with a
+// console warning instead of failing the whole normalize run.
+function enforceDashscopeEnvKey(contents) {
+  const lines = contents.split(/\r?\n/);
+  let inDashscope = false;
+  let rewrote = false;
+  const updated = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^\[[^\]]+\]$/.test(trimmed)) {
+      inDashscope = trimmed === DASHSCOPE_PROVIDER_HEADER;
+      updated.push(line);
+      continue;
+    }
+    if (inDashscope) {
+      const m = line.match(/^(\s*)env_key\s*=\s*"?([^"\s#]+)"?(\s*)(#.*)?$/);
+      if (m) {
+        const [, indent, value, , comment] = m;
+        if (value !== "DASHSCOPE_API_KEY") {
+          console.warn(
+            `[innies-config] ${DASHSCOPE_PROVIDER_HEADER} env_key="${value}" ` +
+              `is not the canonical DASHSCOPE_API_KEY — auto-correcting ` +
+              `(legacy name or typo; the Rust factory only reads ` +
+              `DASHSCOPE_API_KEY, so anything else triggers a silent ` +
+              `fallback to api.openai.com and a 401).`
+          );
+          const tail = comment ? ` ${comment}` : "";
+          updated.push(`${indent}env_key = "DASHSCOPE_API_KEY"${tail}`);
+          rewrote = true;
+          continue;
+        }
+      }
+    }
+    updated.push(line);
+  }
+  return rewrote ? updated.join("\n") : contents;
+}
+
+// Exported for unit testing in scripts/test_innies_config.js. Keep
+// the signature stable — the test imports it directly via
+// `require()` and asserts on the input/output transform.
+export function _enforceDashscopeEnvKeyForTest(contents) {
+  return enforceDashscopeEnvKey(contents);
+}
+
 function normalizeProviderBlock(contents, provider) {
   const lines = contents.split(/\r?\n/);
   const updated = [];
@@ -556,12 +629,35 @@ function defaultZhiman35bProviderBlock() {
   ].join("\n");
 }
 
+function defaultZhiman27bProviderBlock() {
+  // Mirrors defaultZhiman35bProviderBlock for the 27B private
+  // deployment. Same install-contract rule: do NOT prefill `base_url` or
+  // `env_key` — the user must configure both, otherwise the binary
+  // would call a real network endpoint on first run. Distinct provider
+  // name (`zhiman_27b` vs `zhiman_35b`) and env var so the two private
+  // deployments can be configured independently.
+  return [
+    ZHIMAN_27B_PROVIDER_HEADER,
+    'name = "zhiman_27b"',
+    `# base_url = "http://your-private-deployment/v1"   # FILL IN: private vLLM / OpenAI-compatible endpoint`,
+    `# env_key  = "ZHIMAN_27B_API_KEY"                   # FILL IN: name of the env var holding your API key`,
+    `wire_api = "${DEFAULT_PROVIDER_WIRE_API}"`,
+  ].join("\n");
+}
+
 function defaultDashscopeProviderBlock() {
+  // The DashScope user block is the user-facing alias for the builtin
+  // `bailian` provider (same DashScope public cloud, same qwen3.6-27b
+  // model). The `env_key` placeholder is `DASHSCOPE_API_KEY` to match
+  // the builtin factory's canonical name and the user manual —
+  // either uncomment this line and set DASHSCOPE_API_KEY, or leave
+  // it commented and set DASHSCOPE_API_KEY as a regular env var, both
+  // paths converge.
   return [
     DASHSCOPE_PROVIDER_HEADER,
     'name = "DashScope"',
     `# base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"   # FILL IN: DashScope OpenAI-compatible endpoint`,
-    `# env_key  = "DASHSCOPE_API_KEY"                                  # FILL IN: name of the env var holding your DashScope API key`,
+    `# env_key  = "DASHSCOPE_API_KEY"                                   # FILL IN: name of the env var holding your DashScope API key`,
     `wire_api = "${DEFAULT_PROVIDER_WIRE_API}"`,
   ].join("\n");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhiman_innies/innies-codex",
-  "version": "0.122.47",
+  "version": "0.122.49",
   "license": "Apache-2.0",
   "bin": {
     "innies": "bin/innies.js"
@@ -23,9 +23,9 @@
     "postinstall": "node bin/innies-init.js"
   },
   "optionalDependencies": {
-    "@zhiman_innies/innies-codex-darwin-x64": "0.122.47-darwin-x64",
-    "@zhiman_innies/innies-codex-darwin-arm64": "0.122.47-darwin-arm64",
-    "@zhiman_innies/innies-codex-win32-x64": "0.122.47-win32-x64",
-    "@zhiman_innies/innies-codex-win32-arm64": "0.122.47-win32-arm64"
+    "@zhiman_innies/innies-codex-darwin-x64": "0.122.49-darwin-x64",
+    "@zhiman_innies/innies-codex-darwin-arm64": "0.122.49-darwin-arm64",
+    "@zhiman_innies/innies-codex-win32-x64": "0.122.49-win32-x64",
+    "@zhiman_innies/innies-codex-win32-arm64": "0.122.49-win32-arm64"
   }
 }