@lazyingart/agintiflow 0.20.6 → 0.20.8

package/docs/model-selection.md

@@ -48,12 +48,15 @@ Interactive commands:
 
 In the interactive CLI, `/provider`, `/route`, `/model`, `/spare`, and `/auxiliary model` without arguments open selectors. Use Up/Down/Left/Right to move through choices, Enter to confirm, and Esc to cancel. Slash-command hints use the same arrow selection behavior: type a prefix such as `/mo`, use arrows to choose `/model` or `/models`, then press Enter or Tab.
 
+`/route`, `/model`, and `/spare` intentionally share the same text-model selector so users do not need to learn three different catalogs. The shared list is grouped as DeepSeek, Venice Uncensored, Venice GPT/Claude/Gemma/Qwen, OpenAI, Qwen, and Mock. OpenAI entries show the recommended default reasoning effort in the description; `/spare` stores that reasoning value when selected.
+
 `/venice` opens a two-step selector for the Venice route and main models. The current text choices are:
 
 ```text
 venice/venice-uncensored-1-2
 venice/venice-uncensored
 venice/gemma-4-uncensored
+Disable Venice
 ```
 
 For scripts or non-interactive terminals, `/venice` uses Venice 1.2 for both roles. You can also set both roles directly with `/venice 1.2`, `/venice 1.1`, or `/venice gemma`. Use two values to set route and main separately, for example `/venice 1.2 gemma`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.6",
+  "version": "0.20.8",
   "type": "module",
   "description": "AgInTiFlow is a web-first coding agent and CLI with DeepSeek routing, sandboxed tools, model providers, canvas artifacts, and optional wrappers.",
   "license": "Apache-2.0",

package/references/model-routing-provider-design.md

@@ -53,7 +53,9 @@ Interactive equivalents:
 /auxiliary model grsai/nano-banana-2
 ```
 
-`/venice` opens a route/main selector for Venice text models. The selector includes `venice/venice-uncensored-1-2` (Venice 1.2), `venice/venice-uncensored` (Venice 1.1), and `venice/gemma-4-uncensored` (Gemma 4). In non-interactive shells, `/venice` keeps script compatibility by selecting `venice/venice-uncensored-1-2` for both roles. `/venice 1.2 gemma` sets route to Venice 1.2 and main to Gemma 4; `/venice off` restores `deepseek/deepseek-v4-flash` for route and `deepseek/deepseek-v4-pro` for main.
+`/route`, `/model`, and `/spare` share a single text-model selector. The selector is grouped as DeepSeek, Venice Uncensored, Venice GPT/Claude/Gemma/Qwen, OpenAI, Qwen, and Mock so the user sees the same union of route/main/spare-capable models in every role.
+
+`/venice` opens a route/main selector for Venice text models. The selector includes `venice/venice-uncensored-1-2` (Venice 1.2), `venice/venice-uncensored` (Venice 1.1), `venice/gemma-4-uncensored` (Gemma 4), and a Disable Venice option. In non-interactive shells, `/venice` keeps script compatibility by selecting `venice/venice-uncensored-1-2` for both roles. `/venice 1.2 gemma` sets route to Venice 1.2 and main to Gemma 4; `/venice off` or the Disable Venice selector option restores `deepseek/deepseek-v4-flash` for route and `deepseek/deepseek-v4-pro` for main.
 
 The web UI should expose model names as dropdowns, not free-text fields. The left panel should stay focused on common daily controls, while model-role editing and less-used switches live in an Advanced settings modal. The terminal-like capability panels belong after the runtime log so the left control panel remains short.
 

package/scripts/smoke-cli-chat.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import {
   buildLaunchHeaderLines,
   buildPromptLayout,
+  buildPromptRenderSequence,
   canonicalSlashPromptBuffer,
   classifyEscapeAction,
   formatWorkspaceChange,
@@ -131,6 +132,16 @@ try {
   if (promptLayout.cursorRow < 0 || promptLayout.cursorColumn < 0) {
     throw new Error("terminal prompt layout returned an invalid cursor location");
   }
+  const promptCursorMoveBefore = buildPromptLayout("smooth typing", 13, 90, 24, { commandCwd: "/tmp/aginti-project" });
+  const promptCursorMoveAfter = buildPromptLayout("smooth typing", 4, 90, 24, { commandCwd: "/tmp/aginti-project" });
+  const cursorOnlySequence = buildPromptRenderSequence(promptCursorMoveAfter, {
+    lineCount: promptCursorMoveBefore.renderedRows.length,
+    cursorRow: promptCursorMoveBefore.cursorRow,
+    renderedRows: promptCursorMoveBefore.renderedRows,
+  });
+  if (cursorOnlySequence.includes("\x1b[2K") || cursorOnlySequence.includes("\x1b[?25l")) {
+    throw new Error("cursor-only prompt moves should not clear/redraw the input panel");
+  }
   const paddedPromptLayout = buildPromptLayout("hello", 5, 80, 24, { commandCwd: "/tmp/aginti-project" });
   const paddedRows = paddedPromptLayout.renderedRows.map((line) => line.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, ""));
   if (
@@ -271,6 +282,7 @@ try {
           "workspace-patch-event-render",
           "large-launch-header",
           "prompt-layout",
+          "prompt-redraw-fast-path",
           "user-prompt-label",
           "escape-policy",
           "live-input-status-layout",

package/scripts/smoke-model-roles.js

@@ -10,6 +10,7 @@ import {
   selectModelRoute,
 } from "../src/model-routing.js";
 import { parseTextToolCalls, usesTextToolProtocol } from "../src/model-client.js";
+import { modelRoleChoices } from "../src/interactive-cli.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -111,6 +112,32 @@ assert(MODEL_PROVIDER_GROUPS["venice-gpt"].provider === "venice", "venice-gpt gr
 assert(modelsForProviderGroup("venice-gemma").some((item) => item.id === "gemma-4-uncensored"), "venice-gemma bucket missing Gemma");
 assert(modelsForProviderGroup("venice-uncensored").some((item) => item.id === "e2ee-venice-uncensored-24b-p"), "venice-uncensored bucket missing Venice 1.1");
 assert(AUXILIARY_MODEL_CATALOG["venice-image"].some((item) => item.id === "gpt-image-2"), "Venice image catalog missing GPT Image 2");
+const routeChoices = modelRoleChoices("route").map((item) => `${item.provider}/${item.model}`);
+const mainChoices = modelRoleChoices("main").map((item) => `${item.provider}/${item.model}`);
+const spareChoices = modelRoleChoices("spare").map((item) => `${item.provider}/${item.model}`);
+assert(JSON.stringify(routeChoices) === JSON.stringify(mainChoices), "route and main selectors should share the same text-model list");
+assert(JSON.stringify(routeChoices) === JSON.stringify(spareChoices), "route and spare selectors should share the same text-model list");
+for (const expected of [
+  "deepseek/deepseek-v4-flash",
+  "deepseek/deepseek-v4-pro",
+  "venice/venice-uncensored-1-2",
+  "venice/venice-uncensored",
+  "venice/gemma-4-uncensored",
+  "venice/openai-gpt-55",
+  "venice/claude-sonnet-4-6",
+  "venice/qwen3-6-27b",
+  "openai/gpt-5.5",
+  "openai/gpt-5.4",
+  "openai/gpt-5.4-mini",
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.3-codex-spark",
+  "qwen/qwen-plus",
+  "mock/mock-agent",
+]) {
+  assert(routeChoices.includes(expected), `shared model selector missing ${expected}`);
+}
+assert(!routeChoices.includes("venice/e2ee-venice-uncensored-24b-p"), "shared model selector should hide unstable E2EE Venice 1.1");
+assert(modelRoleChoices("auxiliary").some((item) => item.provider === "grsai"), "auxiliary selector missing GRS AI");
 const parsedTextToolCalls = parseTextToolCalls('[TOOL_CALLS]list_files[ARGS]call_123[ARGS]{"path":".","maxDepth":1}');
 assert(parsedTextToolCalls.length === 1, "Venice text tool-call parser did not detect encoded tool call");
 assert(parsedTextToolCalls[0].function.name === "list_files", "Venice text tool-call parser returned wrong tool name");
@@ -151,6 +178,7 @@ console.log(
         "route-overrides",
         "provider-groups",
         "auxiliary-catalog",
+        "shared-model-selectors",
         "venice-text-tool-parser",
         "cli-models-command",
         "venice-shortcut",

package/src/interactive-cli.js

@@ -832,24 +832,58 @@ function cursorLocation(layout, cursor) {
 
 function clearRenderedPrompt(previous) {
   if (!previous.lineCount) return;
+  let sequence = ansi.cursorHide;
   const below = previous.lineCount - 1 - previous.cursorRow;
-  if (below > 0) output.write(`\x1b[${below}B`);
-  output.write(`\r${ansi.clearLine}`);
+  if (below > 0) sequence += `\x1b[${below}B`;
+  sequence += `\r${ansi.clearLine}`;
   for (let index = 1; index < previous.lineCount; index += 1) {
-    output.write(`\x1b[1A\r${ansi.clearLine}`);
+    sequence += `\x1b[1A\r${ansi.clearLine}`;
+  }
+  sequence += ansi.cursorShow;
+  output.write(sequence);
+}
+
+function renderedRowsEqual(left = [], right = []) {
+  if (left.length !== right.length) return false;
+  return left.every((line, index) => line === right[index]);
+}
+
+export function buildPromptRenderSequence(layout, previous = { lineCount: 0, cursorRow: 0, renderedRows: [] }) {
+  const previousRows = Array.isArray(previous.renderedRows) ? previous.renderedRows : [];
+  const previousLineCount = Number(previous.lineCount) || 0;
+  const previousCursorRow = Number(previous.cursorRow) || 0;
+  const nextRows = layout.renderedRows || [];
+
+  if (previousLineCount > 0 && renderedRowsEqual(previousRows, nextRows)) {
+    const rowDelta = layout.cursorRow - previousCursorRow;
+    return `${rowDelta > 0 ? `\x1b[${rowDelta}B` : rowDelta < 0 ? `\x1b[${Math.abs(rowDelta)}A` : ""}\r\x1b[${
+      layout.cursorColumn + 1
+    }G`;
+  }
+
+  let sequence = ansi.cursorHide;
+  if (previousLineCount > 0) {
+    const below = Math.max(previousLineCount - 1 - previousCursorRow, 0);
+    if (below > 0) sequence += `\x1b[${below}B`;
+    sequence += "\r";
+    if (previousLineCount > 1) sequence += `\x1b[${previousLineCount - 1}A`;
+  }
+
+  const lineCount = Math.max(previousLineCount, nextRows.length);
+  for (let index = 0; index < lineCount; index += 1) {
+    sequence += `\r${ansi.clearLine}${nextRows[index] || ""}`;
+    if (index < lineCount - 1) sequence += "\n";
   }
+
+  const cursorUp = Math.max(lineCount - 1 - layout.cursorRow, 0);
+  if (cursorUp > 0) sequence += `\x1b[${cursorUp}A`;
+  sequence += `\r\x1b[${layout.cursorColumn + 1}G${ansi.cursorShow}`;
+  return sequence;
 }
 
 function renderPromptBuffer(buffer, cursor, previous = { lineCount: 0, cursorRow: 0, renderedRows: [] }, options = {}) {
   const layout = buildPromptLayout(buffer, cursor, terminalWidth(), terminalHeight(), options);
-  output.write(ansi.cursorHide);
-  clearRenderedPrompt(previous);
-  output.write(layout.renderedRows.join("\n"));
-
-  const below = layout.renderedRows.length - 1 - layout.cursorRow;
-  if (below > 0) output.write(`\x1b[${below}A`);
-  output.write(`\r\x1b[${layout.cursorColumn + 1}G`);
-  output.write(ansi.cursorShow);
+  output.write(buildPromptRenderSequence(layout, previous));
   return {
     lineCount: layout.renderedRows.length,
     cursorRow: layout.cursorRow,
@@ -1660,6 +1694,13 @@ function veniceTextModelChoices() {
       label: "Gemma 4",
       description: "Gemma-family Venice text model; 256K context",
     },
+    {
+      action: "disable",
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      label: "Disable Venice",
+      description: "restore DeepSeek route/main defaults",
+    },
   ];
 }
 
@@ -1755,98 +1796,69 @@ function printModelRoles(state) {
   );
 }
 
-function modelRoleChoices(role = "main") {
+function compactReasoning(model = {}) {
+  const values = Array.isArray(model.reasoning) ? model.reasoning : [];
+  if (values.length === 0) return "";
+  const preferred = model.id === "gpt-5.4-mini" || model.id === "gpt-5.3-codex-spark" ? "high" : "medium";
+  return `${preferred} reasoning`;
+}
+
+function modelSelectorGroup(provider, model = {}) {
+  if (provider === "deepseek") return "DeepSeek";
+  if (provider === "openai") return "OpenAI";
+  if (provider === "qwen") return "Qwen";
+  if (provider === "mock") return "Mock";
+  if (provider === "venice") {
+    if (model.bucket === "venice-uncensored") return "Venice Uncensored";
+    if (model.bucket === "venice-gpt") return "Venice GPT";
+    if (model.bucket === "venice-claude") return "Venice Claude";
+    if (model.bucket === "venice-gemma") return "Venice Gemma";
+    if (model.bucket === "venice-qwen") return "Venice Qwen";
+    return "Venice";
+  }
+  return provider;
+}
+
+function textModelRoleChoices() {
+  const providerOrder = ["deepseek", "venice", "openai", "qwen", "mock"];
+  const veniceOrder = [
+    "venice-uncensored-1-2",
+    "venice-uncensored",
+    "gemma-4-uncensored",
+    "openai-gpt-55",
+    "claude-sonnet-4-6",
+    "qwen3-6-27b",
+  ];
+  const choices = [];
+  for (const provider of providerOrder) {
+    let models = PROVIDER_MODEL_CATALOG[provider] || [];
+    if (provider === "venice") {
+      const byId = new Map(models.filter((model) => !model.hidden).map((model) => [model.id, model]));
+      models = veniceOrder.map((id) => byId.get(id)).filter(Boolean);
+    } else {
+      models = models.filter((model) => !model.hidden);
+    }
+    for (const model of models) {
+      const group = modelSelectorGroup(provider, model);
+      const reasoning = compactReasoning(model);
+      const context = model.context ? `${model.context} context` : "";
+      const details = [reasoning, context, model.description].filter(Boolean).join("; ");
+      choices.push({
+        provider,
+        model: model.id,
+        label: `${group} · ${model.label}`,
+        group,
+        description: details,
+        reasoningDefault: reasoning ? reasoning.split(" ")[0] : "",
+      });
+    }
+  }
+  return choices;
+}
+
+export function modelRoleChoices(role = "main") {
+  if (role !== "auxiliary") return textModelRoleChoices();
   const common = [
-    {
-      provider: "deepseek",
-      model: "deepseek-v4-flash",
-      label: "DeepSeek V4 Flash",
-      description: "fast planner, short shell/browser/code work",
-      route: true,
-    },
-    {
-      provider: "deepseek",
-      model: "deepseek-v4-pro",
-      label: "DeepSeek V4 Pro",
-      description: "complex coding, debugging, writing, and long tasks",
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "venice",
-      model: "venice-uncensored-1-2",
-      label: "Venice 1.2",
-      description: "Venice text route; use /auth venice if missing",
-      route: true,
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "venice",
-      model: "venice-uncensored",
-      label: "Venice 1.1",
-      description: "legacy Venice text route; use /auth venice if missing",
-      route: true,
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "venice",
-      model: "gemma-4-uncensored",
-      label: "Gemma 4",
-      description: "Gemma-family Venice route; use /auth venice if missing",
-      route: true,
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "openai",
-      model: "gpt-5.5",
-      label: "OpenAI GPT-5.5",
-      description: "frontier spare/manual model",
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "openai",
-      model: "gpt-5.4",
-      label: "OpenAI GPT-5.4",
-      description: "strong everyday coding spare",
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "openai",
-      model: "gpt-5.4-mini",
-      label: "OpenAI GPT-5.4 Mini",
-      description: "small fast spare route",
-      route: true,
-      spare: true,
-    },
-    {
-      provider: "qwen",
-      model: "qwen-plus",
-      label: "Qwen Plus",
-      description: "general Qwen route",
-      route: true,
-    },
-    {
-      provider: "qwen",
-      model: "qwen-max",
-      label: "Qwen Max",
-      description: "larger Qwen route",
-      main: true,
-      spare: true,
-    },
-    {
-      provider: "mock",
-      model: "mock-agent",
-      label: "Mock Agent",
-      description: "local deterministic test route",
-      route: true,
-      main: true,
-      spare: true,
-    },
     {
       provider: "grsai",
       model: "nano-banana-2",
@@ -1869,22 +1881,7 @@ function modelRoleChoices(role = "main") {
       auxiliary: true,
     },
   ];
-  const filtered = common.filter((item) => {
-    if (role === "route") return item.route;
-    if (role === "spare") return item.spare;
-    if (role === "auxiliary") return item.auxiliary;
-    return item.main;
-  });
-  if (role === "route") {
-    return filtered.sort((a, b) => Number(b.model === "deepseek-v4-flash") - Number(a.model === "deepseek-v4-flash"));
-  }
-  if (role === "spare") {
-    return filtered.sort((a, b) => Number(b.model === "gpt-5.4") - Number(a.model === "gpt-5.4"));
-  }
-  if (role === "auxiliary") {
-    return filtered.sort((a, b) => Number(b.provider === "grsai") - Number(a.provider === "grsai"));
-  }
-  return filtered.sort((a, b) => Number(b.model === "deepseek-v4-pro") - Number(a.model === "deepseek-v4-pro"));
+  return common.filter((item) => item.auxiliary).sort((a, b) => Number(b.provider === "grsai") - Number(a.provider === "grsai"));
 }
 
 function providerChoices() {
@@ -1923,6 +1920,7 @@ function providerChoices() {
 }
 
 function modelChoiceLine(option) {
+  if (option.action === "disable") return `${option.label}  ${option.description}`;
   return `${option.label}  ${option.provider}/${option.model}  ${option.description}`;
 }
 
@@ -2058,7 +2056,7 @@ async function pickModelRole(role, state) {
   } else if (role === "spare") {
     state.spareProvider = selected.provider;
     state.spareModel = selected.model;
-    state.spareReasoning = state.spareReasoning || "medium";
+    state.spareReasoning = selected.reasoningDefault || state.spareReasoning || "medium";
     printSystemLine(`spare=${state.spareProvider}/${state.spareModel} reasoning=${state.spareReasoning}`);
   } else if (role === "auxiliary") {
     state.auxiliaryProvider = selected.provider;
@@ -2086,10 +2084,15 @@ async function pickVeniceRouteAndMain(state) {
     initialIndex: routeIndex,
   });
   if (!route) return false;
+  if (route.action === "disable") {
+    useDeepSeekDefaults(state);
+    printSystemLine("venice=off routing=smart route=deepseek/deepseek-v4-flash main=deepseek/deepseek-v4-pro");
+    return true;
+  }
 
   const mainIndex = Math.max(
-    options.findIndex((item) => item.provider === state.mainProvider && item.model === state.mainModel),
-    options.findIndex((item) => item.model === route.model),
+    options.findIndex((item) => item.action !== "disable" && item.provider === state.mainProvider && item.model === state.mainModel),
+    options.findIndex((item) => item.action !== "disable" && item.model === route.model),
     0
   );
   const main = await selectModelChoice({
@@ -2099,6 +2102,11 @@ async function pickVeniceRouteAndMain(state) {
     initialIndex: mainIndex,
   });
   if (!main) return false;
+  if (main.action === "disable") {
+    useDeepSeekDefaults(state);
+    printSystemLine("venice=off routing=smart route=deepseek/deepseek-v4-flash main=deepseek/deepseek-v4-pro");
+    return true;
+  }
 
   useVeniceModels(state, route.model, main.model);
   printSystemLine(`venice=on routing=smart route=venice/${state.routeModel} main=venice/${state.mainModel}`);

package/src/model-routing.js

@@ -216,24 +216,26 @@ export const PROVIDER_MODEL_CATALOG = {
       description: "Current Venice uncensored text route.",
     },
     {
-      id: "e2ee-venice-uncensored-24b-p",
+      id: "venice-uncensored",
       label: "Venice Uncensored 1.1",
       bucket: "venice-uncensored",
       context: "32K",
-      description: "E2EE Venice uncensored 1.1 text route.",
+      description: "Working Venice uncensored 1.1 text route.",
     },
     {
-      id: "venice-uncensored",
-      label: "Venice Uncensored Legacy",
+      id: "e2ee-venice-uncensored-24b-p",
+      label: "Venice Uncensored 1.1 E2EE",
       bucket: "venice-uncensored",
       context: "32K",
-      description: "Deprecated legacy Venice uncensored text route.",
+      hidden: true,
+      description: "Documented E2EE Venice 1.1 route; hidden from selectors until upstream stabilizes.",
     },
     {
       id: "venice-uncensored-role-play",
       label: "Venice Role Play Uncensored",
       bucket: "venice-uncensored",
       context: "128K",
+      hidden: true,
       description: "Role-play oriented Venice route.",
     },
     {