@lazyingart/agintiflow 0.20.4 → 0.20.6

package/docs/model-selection.md

@@ -48,14 +48,17 @@ 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.
 
-`/venice` is a toggle. When off, it enables:
+`/venice` opens a two-step selector for the Venice route and main models. The current text choices are:
 
 ```text
-/route venice/venice-uncensored-1-2
-/main venice/venice-uncensored-1-2
+venice/venice-uncensored-1-2
+venice/venice-uncensored
+venice/gemma-4-uncensored
 ```
 
-When already on, `/venice` switches back to the DeepSeek defaults:
+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`.
+
+Use `/venice off` to switch back to the DeepSeek defaults:
 
 ```text
 /route deepseek/deepseek-v4-flash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.4",
+  "version": "0.20.6",
   "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,7 @@ Interactive equivalents:
 /auxiliary model grsai/nano-banana-2
 ```
 
-`/venice` is a toggle: it keeps smart routing enabled and points both route and main roles at `venice/venice-uncensored-1-2`; running it again or using `/venice off` restores `deepseek/deepseek-v4-flash` for route and `deepseek/deepseek-v4-pro` for main.
+`/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.
 
 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.
 
@@ -74,7 +74,7 @@ Codex wrapper defaults stay separate from native OpenAI API settings: GPT-5.5 me
 
 | UI bucket | Concrete default | Notes |
 |---|---|---|
-| `venice-uncensored` | `venice-uncensored-1-2` | Venice-native text |
+| `venice-uncensored` | `venice-uncensored-1-2` | Venice-native text; `/venice` also exposes `venice-uncensored` as Venice 1.1 |
 | `venice-qwen` | `qwen3-6-27b` | Qwen-family text/code |
 | `venice-gpt` | `openai-gpt-55` | OpenAI-family through Venice |
 | `venice-claude` | `claude-sonnet-4-6` | Claude-family through Venice |

package/references/venice-model-reference.md

@@ -19,7 +19,7 @@ Store `VENICE_API_KEY` only in ignored local files such as `.aginti/.env` or a s
 
 | Bucket | Primary model | Other useful models | Use |
 |---|---|---|---|
-| `venice-uncensored` | `venice-uncensored-1-2` | `venice-uncensored`, `venice-uncensored-role-play` | Private/uncensored Venice-native text route |
+| `venice-uncensored` | `venice-uncensored-1-2` | `e2ee-venice-uncensored-24b-p`, `venice-uncensored-role-play`, `venice-uncensored` legacy | Private/uncensored Venice-native text route |
 | `venice-gemma` | `gemma-4-uncensored` | `google-gemma-4-31b-it`, `google-gemma-4-26b-a4b-it` | Low-cost open-model writing and experimentation |
 | `venice-qwen` | `qwen3-6-27b` | `qwen-3-6-plus`, `qwen3-coder-480b-a35b-instruct-turbo`, `qwen3-vl-235b-a22b` | Chinese/open coding and general tasks |
 | `venice-gpt` | `openai-gpt-55` | `openai-gpt-54`, `openai-gpt-54-mini`, `openai-gpt-53-codex`, `openai-gpt-53-codex-spark` | OpenAI-family routes through Venice |
@@ -44,12 +44,15 @@ Store `VENICE_API_KEY` only in ignored local files such as `.aginti/.env` or a s
 | `google-gemma-4-26b-a4b-it` | 256K | Google Gemma 4 26B A4B Instruct |
 | `venice-uncensored-1-2` | 128K | Venice Uncensored 1.2 |
 | `openai-gpt-54-mini` | 400K | GPT-5.4 Mini |
+| `e2ee-venice-uncensored-24b-p` | 32K | Venice Uncensored 1.1 E2EE |
 | `venice-uncensored-role-play` | 128K | Venice Role Play Uncensored |
 | `gemini-3-1-pro-preview` | 1.0M | Gemini 3.1 Pro Preview |
 | `claude-sonnet-4-6` | 1.0M | Claude Sonnet 4.6 |
 | `openai-gpt-53-codex` | 400K | GPT-5.3 Codex |
 | `openai-gpt-52` | 256K | GPT-5.2 |
-| `venice-uncensored` | 32K | Venice Uncensored legacy |
+| `venice-uncensored` | 32K | Venice Uncensored legacy / deprecated |
+
+AgInTiFlow exposes the primary Venice text choices through `/venice`: Venice 1.2 (`venice-uncensored-1-2`), Venice 1.1 (`venice-uncensored`), and Gemma 4 (`gemma-4-uncensored`). The command can select route and main independently, so a fast Venice route can be paired with a larger Gemma main model when useful. The E2EE 1.1 ID (`e2ee-venice-uncensored-24b-p`) is documented for reference, but the selector uses the working non-E2EE 1.1 route because the E2EE route currently returns an upstream provider error in live tests.
 
 ## Image And Edit Models
 

package/scripts/smoke-model-roles.js

@@ -9,7 +9,7 @@ import {
   modelsForProviderGroup,
   selectModelRoute,
 } from "../src/model-routing.js";
-import { parseTextToolCalls } from "../src/model-client.js";
+import { parseTextToolCalls, usesTextToolProtocol } from "../src/model-client.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -109,11 +109,24 @@ assert(fastRoute.model === "deepseek-v4-flash", "fast route did not use route mo
 
 assert(MODEL_PROVIDER_GROUPS["venice-gpt"].provider === "venice", "venice-gpt group missing");
 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 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");
 assert(parsedTextToolCalls[0].function.arguments.includes('"maxDepth":1'), "Venice text tool-call parser returned wrong arguments");
+const looseTextToolCalls = parseTextToolCalls('[TOOL_CALLS]list_files[ARGS]{"path":"."}[TOOL_CALLS]inspect_project[ARGS]{"path":"."}');
+assert(looseTextToolCalls.length === 2, "Venice loose text tool-call parser did not detect multiple calls");
+assert(looseTextToolCalls[1].function.name === "inspect_project", "Venice loose text tool-call parser returned wrong second tool");
+const nativeMarkerText = parseTextToolCalls('Done. <|tool_call>call:finish{result:<|"|>Done<|"|>}');
+assert(nativeMarkerText.length === 0, "native marker text should not be treated as JSON text tool call");
+const jsonBlockToolCalls = parseTextToolCalls('TOOL_CALLS:\n```json\n[{"name":"list_files","arguments":{"path":"/workspace"}}]\n```');
+assert(jsonBlockToolCalls.length === 1, "Venice JSON text tool-call parser did not detect JSON block calls");
+assert(jsonBlockToolCalls[0].function.arguments.includes("/workspace"), "Venice JSON text tool-call parser returned wrong arguments");
+assert(usesTextToolProtocol({ provider: "venice", model: "gemma-4-uncensored" }), "Venice Gemma should use text tool protocol");
+assert(usesTextToolProtocol({ provider: "venice", model: "e2ee-venice-uncensored-24b-p" }), "Venice 1.1 should use text tool protocol");
+assert(usesTextToolProtocol({ provider: "venice", model: "venice-uncensored" }), "Venice legacy 1.1 should use text tool protocol");
+assert(!usesTextToolProtocol({ provider: "venice", model: "venice-uncensored-1-2" }), "Venice 1.2 should keep native tool calls first");
 
 const output = await runCli(["models"]);
 assert(output.includes("/route") && output.includes("/spare") && output.includes("venice-gpt"), "aginti models output missing role details");
@@ -122,6 +135,9 @@ const interactiveOutput = await runInteractive("/venice\n");
 assert(interactiveOutput.includes("venice=on"), "/venice did not enable Venice roles");
 assert(interactiveOutput.includes("route=venice/venice-uncensored-1-2"), "/venice did not set Venice route role");
 assert(interactiveOutput.includes("main=venice/venice-uncensored-1-2"), "/venice did not set Venice main role");
+const interactiveGemmaOutput = await runInteractive("/venice 1.1 gemma\n");
+assert(interactiveGemmaOutput.includes("route=venice/venice-uncensored"), "/venice 1.1 did not set Venice 1.1 route role");
+assert(interactiveGemmaOutput.includes("main=venice/gemma-4-uncensored"), "/venice gemma did not set Gemma 4 main role");
 const interactiveOffOutput = await runInteractive("/venice off\n");
 assert(interactiveOffOutput.includes("venice=off"), "/venice off did not restore DeepSeek roles");
 assert(interactiveOffOutput.includes("route=deepseek/deepseek-v4-flash"), "/venice off did not restore DeepSeek route role");

package/src/agent-runner.js

@@ -739,7 +739,7 @@ async function buildSnapshot(browserState, store, step, config) {
 
 async function injectQueuedUserMessages(store, state, observers) {
   const inbox = await store.drainInbox();
-  if (inbox.length === 0) return;
+  if (inbox.length === 0) return 0;
 
   for (const item of inbox) {
     const content = String(item.content || "").trim();
@@ -762,6 +762,7 @@ async function injectQueuedUserMessages(store, state, observers) {
       priority: item.priority || "normal",
     });
   }
+  return inbox.length;
 }
 
 async function executeTool(browserState, toolCall, snapshot, config, store, observers, state) {
@@ -1374,6 +1375,16 @@ export async function runAgent(config) {
       });
 
       throwIfAborted(config);
+      await store.appendEvent("model.requested", {
+        step,
+        provider: config.provider,
+        model: config.model,
+      });
+      observers.event("model.requested", {
+        step,
+        provider: config.provider,
+        model: config.model,
+      });
       const response = await requestNextStep(client, config, state.messages);
       const assistantMessage = response.choices[0]?.message;
       if (!assistantMessage) {
@@ -1399,6 +1410,13 @@ export async function runAgent(config) {
       const toolCalls = assistantMessage.tool_calls || [];
 
       if (toolCalls.length === 0) {
+        const queuedCount = await injectQueuedUserMessages(store, state, observers);
+        if (queuedCount > 0) {
+          state.stepsCompleted = step;
+          state.updatedAt = new Date().toISOString();
+          await store.saveState(state);
+          continue;
+        }
         const fallback = assistantMessage.content?.trim() || "No tool call returned.";
         appendChatEntry(state, "assistant", fallback);
         await store.appendEvent("session.finished", {
@@ -1419,6 +1437,7 @@ export async function runAgent(config) {
         };
       }
 
+      let continueForQueuedInput = false;
       for (const toolCall of toolCalls) {
         throwIfAborted(config);
         const toolResult = await executeTool(browserState, toolCall, snapshot, config, store, observers, state);
@@ -1462,6 +1481,14 @@ export async function runAgent(config) {
         }
 
         if (toolResult.done) {
+          const queuedCount = await injectQueuedUserMessages(store, state, observers);
+          if (queuedCount > 0) {
+            state.stepsCompleted = step;
+            state.updatedAt = new Date().toISOString();
+            await store.saveState(state);
+            continueForQueuedInput = true;
+            break;
+          }
           state.stepsCompleted = step;
           state.updatedAt = new Date().toISOString();
           state.meta.lastUrl = browserState.page?.url() || state.meta.lastUrl;
@@ -1487,6 +1514,8 @@ export async function runAgent(config) {
         }
       }
 
+      if (continueForQueuedInput) continue;
+
       await injectQueuedUserMessages(store, state, observers);
 
       state.stepsCompleted = step;

package/src/interactive-cli.js

@@ -593,7 +593,7 @@ function printHelp() {
       "  /instructions             Show AGINTI.md project instructions status.",
       "  /memory                   Alias for /instructions.",
       "  /models                   Show route/main/spare/wrapper/auxiliary model roles.",
-      "  /venice [on|off]          Toggle Venice Uncensored 1.2 for route and main roles.",
+      "  /venice [off|model]       Pick Venice route/main models, or restore DeepSeek defaults.",
       "  /route [mode|provider/model]",
       "                            Open route selector, or set routing/fast route model.",
       "  /model [provider/model]   Open main-model selector, or set the active/main model.",
@@ -1640,23 +1640,61 @@ function useDeepSeekDefaults(state) {
   state.mainModel = "deepseek-v4-pro";
 }
 
-function useVeniceDefaults(state) {
+function veniceTextModelChoices() {
+  return [
+    {
+      provider: "venice",
+      model: "venice-uncensored-1-2",
+      label: "Venice 1.2",
+      description: "default Venice text model; 128K context",
+    },
+    {
+      provider: "venice",
+      model: "venice-uncensored",
+      label: "Venice 1.1",
+      description: "legacy Venice text model; 32K context",
+    },
+    {
+      provider: "venice",
+      model: "gemma-4-uncensored",
+      label: "Gemma 4",
+      description: "Gemma-family Venice text model; 256K context",
+    },
+  ];
+}
+
+function resolveVeniceTextModel(value = "") {
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized || normalized === "on" || normalized === "venice" || normalized === "1.2" || normalized === "venice-1.2") {
+    return "venice-uncensored-1-2";
+  }
+  if (
+    normalized === "1.1" ||
+    normalized === "venice-1.1"
+  ) {
+    return "venice-uncensored";
+  }
+  if (normalized === "legacy" || normalized === "venice-uncensored") {
+    return "venice-uncensored";
+  }
+  if (normalized === "e2ee" || normalized === "e2ee-venice-uncensored-24b-p") {
+    return "e2ee-venice-uncensored-24b-p";
+  }
+  if (normalized === "gemma" || normalized === "gemma4" || normalized === "gemma-4" || normalized === "gemma-4-uncensored") {
+    return "gemma-4-uncensored";
+  }
+  const exact = veniceTextModelChoices().find((item) => item.model.toLowerCase() === normalized);
+  return exact?.model || "";
+}
+
+function useVeniceModels(state, routeModel = "venice-uncensored-1-2", mainModel = routeModel) {
   state.routingMode = "smart";
   state.provider = "deepseek";
   state.model = "";
   state.routeProvider = "venice";
-  state.routeModel = "venice-uncensored-1-2";
+  state.routeModel = routeModel;
   state.mainProvider = "venice";
-  state.mainModel = "venice-uncensored-1-2";
-}
-
-function isVeniceDefaultActive(state) {
-  return (
-    state.routeProvider === "venice" &&
-    state.routeModel === "venice-uncensored-1-2" &&
-    state.mainProvider === "venice" &&
-    state.mainModel === "venice-uncensored-1-2"
-  );
+  state.mainModel = mainModel;
 }
 
 function printModelRoles(state) {
@@ -1737,12 +1775,30 @@ function modelRoleChoices(role = "main") {
     {
       provider: "venice",
       model: "venice-uncensored-1-2",
-      label: "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",
@@ -1849,7 +1905,7 @@ function providerChoices() {
       provider: "venice",
       model: "venice-uncensored-1-2",
       label: "Venice",
-      description: "manual Venice route; /venice toggles route+main roles",
+      description: "manual Venice route; /venice picks route+main roles",
     },
     {
       provider: "qwen",
@@ -1876,14 +1932,19 @@ function clearSelector(lineCount) {
   }
 }
 
+function clearSelectorSequence(lineCount) {
+  return Array.from({ length: Math.max(lineCount, 0) }, () => "\x1b[1A\r\x1b[2K").join("");
+}
+
 function renderSelector({ title, subtitle, options, selectedIndex, lineCount = 0 }) {
-  if (lineCount > 0) clearSelector(lineCount);
   const width = Math.min(Math.max(terminalWidth() - 2, 60), 110);
   const bodyWidth = width - 4;
+  const safeTitle = compactLine(title, bodyWidth);
+  const safeSubtitle = compactLine(subtitle, bodyWidth);
   const rows = [
     `╭${"─".repeat(width - 2)}╮`,
-    `│ ${padVisible(title, bodyWidth)} │`,
-    `│ ${padVisible(subtitle, bodyWidth)} │`,
+    `│ ${padVisible(safeTitle, bodyWidth)} │`,
+    `│ ${padVisible(safeSubtitle, bodyWidth)} │`,
     `├${"─".repeat(width - 2)}┤`,
     ...options.map((option, index) => {
       const marker = index === selectedIndex ? ">" : " ";
@@ -1892,7 +1953,7 @@ function renderSelector({ title, subtitle, options, selectedIndex, lineCount = 0
     }),
     `╰${"─".repeat(width - 2)}╯`,
   ];
-  output.write(`${rows.join("\n")}\n`);
+  output.write(`${lineCount > 0 ? clearSelectorSequence(lineCount) : ""}${rows.join("\n")}\n`);
   return rows.length;
 }
 
@@ -2012,6 +2073,38 @@ async function pickModelRole(role, state) {
   return true;
 }
 
+async function pickVeniceRouteAndMain(state) {
+  const options = veniceTextModelChoices();
+  const routeIndex = Math.max(
+    options.findIndex((item) => item.provider === state.routeProvider && item.model === state.routeModel),
+    0
+  );
+  const route = await selectModelChoice({
+    title: "Select Venice route model",
+    subtitle: "Route handles planning and short turns. Up/Down selects, Enter confirms, Esc cancels.",
+    options,
+    initialIndex: routeIndex,
+  });
+  if (!route) return false;
+
+  const mainIndex = Math.max(
+    options.findIndex((item) => item.provider === state.mainProvider && item.model === state.mainModel),
+    options.findIndex((item) => item.model === route.model),
+    0
+  );
+  const main = await selectModelChoice({
+    title: "Select Venice main model",
+    subtitle: "Main handles complex work. Up/Down selects, Enter confirms, Esc cancels.",
+    options,
+    initialIndex: mainIndex,
+  });
+  if (!main) return false;
+
+  useVeniceModels(state, route.model, main.model);
+  printSystemLine(`venice=on routing=smart route=venice/${state.routeModel} main=venice/${state.mainModel}`);
+  return true;
+}
+
 async function pickProvider(state) {
   const options = providerChoices();
   const currentProvider = state.provider || "deepseek";
@@ -2266,19 +2359,45 @@ async function handleCommand(line, state, packageDir) {
     return true;
   }
   if (command === "venice") {
-    const action = value || (isVeniceDefaultActive(state) ? "off" : "on");
+    const canUseSelector = input.isTTY && output.isTTY && typeof input.setRawMode === "function";
+    const action = value || (canUseSelector ? "select" : "on");
     if (action === "off" || action === "deepseek" || action === "default") {
       useDeepSeekDefaults(state);
       printSystemLine("venice=off routing=smart route=deepseek/deepseek-v4-flash main=deepseek/deepseek-v4-pro");
       return true;
     }
-    if (action !== "on" && action !== "venice") {
-      printAgentMessage("Usage: /venice [on|off]. No argument toggles between Venice and DeepSeek defaults.");
+    if (action === "select" && canUseSelector) {
+      const changed = await pickVeniceRouteAndMain(state);
+      if (!changed) {
+        printSystemLine(`route=${state.routeProvider || "deepseek"}/${state.routeModel || "deepseek-v4-flash"} main=${state.mainProvider || "deepseek"}/${state.mainModel || "deepseek-v4-pro"}`);
+        return true;
+      }
+      const keys = providerKeyStatus(process.cwd());
+      if (!keys.venice) {
+        printAgentMessage("Venice model roles are selected, but no Venice key is configured. Run `/auth venice` to save one.");
+      }
       return true;
     }
-    useVeniceDefaults(state);
+
+    const parts = action.split(/\s+/).filter(Boolean);
+    const routeModel = resolveVeniceTextModel(parts[0] || "on");
+    const mainModel = resolveVeniceTextModel(parts.slice(1).join(" ") || parts[0] || "on");
+    if (!routeModel || !mainModel) {
+      printAgentMessage(
+        [
+          "Usage: /venice [off|1.2|1.1|gemma] [main-model]",
+          "Examples:",
+          "  /venice",
+          "  /venice gemma",
+          "  /venice 1.2 gemma",
+          "  /venice off",
+        ].join("\n")
+      );
+      return true;
+    }
+    useVeniceModels(state, routeModel, mainModel);
     const keys = providerKeyStatus(process.cwd());
-    printSystemLine("venice=on routing=smart route=venice/venice-uncensored-1-2 main=venice/venice-uncensored-1-2");
+    printSystemLine(`venice=on routing=smart route=venice/${state.routeModel} main=venice/${state.mainModel}`);
     if (!keys.venice) {
       printAgentMessage("Venice model roles are selected, but no Venice key is configured. Run `/auth venice` to save one.");
     }
@@ -2525,6 +2644,7 @@ async function runPrompt(prompt, state, packageDir) {
     printSystemLine(`status=running workingOn=${state.activeGoal}`);
   }
   let result;
+  let runError = null;
   let queuedAfterFinish = [];
   try {
     result = await runAgent({
@@ -2552,6 +2672,8 @@ async function runPrompt(prompt, state, packageDir) {
       onEvent: (type, data = {}) => {
         if (type === "plan.created") {
           printStatusEvent(state, "planned");
+        } else if (type === "model.requested") {
+          printStatusEvent(state, "model_wait", `${data.provider || "model"}/${data.model || ""}`);
         } else if (type === "tool.started") {
           printStatusEvent(state, "tool", data.toolName || "unknown");
         } else if (type === "tool.completed") {
@@ -2574,10 +2696,18 @@ async function runPrompt(prompt, state, packageDir) {
         }
       },
     });
+  } catch (error) {
+    runError = error;
   } finally {
     detachInterrupts();
     queuedAfterFinish = await liveInput.stop();
   }
+  if (runError) {
+    state.status = isAbortError(runError) ? "stopped" : "failed";
+    state.activeGoal = "";
+    printSystemLine(`status=${state.status} session=${state.sessionId}`);
+    throw runError;
+  }
   state.sessionId = result.sessionId || state.sessionId;
   state.status = result.stopped ? "stopped" : "idle";
   state.activeGoal = "";

package/src/model-client.js

@@ -73,16 +73,110 @@ function toolChoiceForProvider(config, messages = []) {
   return messages.some((message) => message.role === "tool") ? "auto" : "required";
 }
 
+export function usesTextToolProtocol(config = {}) {
+  if (config.provider !== "venice") return false;
+  const model = String(config.model || "").toLowerCase();
+  return model === "gemma-4-uncensored" || model === "e2ee-venice-uncensored-24b-p" || model === "venice-uncensored";
+}
+
+function shouldRetryWithTextToolProtocol(error, config = {}) {
+  if (config.provider !== "venice") return false;
+  const message = [
+    error?.message,
+    error?.error?.message,
+    error?.response?.data?.error?.message,
+    error?.response?.data?.message,
+  ]
+    .filter(Boolean)
+    .join(" ");
+  return /invalid request parameters|tool_choice|parallel_tool_calls|tools/i.test(message);
+}
+
+function textToolProtocolPrompt(tools = []) {
+  const toolLines = tools.map((tool) => {
+    const fn = tool.function || {};
+    const properties = fn.parameters?.properties ? Object.keys(fn.parameters.properties).slice(0, 8) : [];
+    const required = Array.isArray(fn.parameters?.required) ? fn.parameters.required : [];
+    const args = properties.length > 0 ? ` args=${properties.join(",")}${required.length ? ` required=${required.join(",")}` : ""}` : "";
+    return `- ${fn.name}: ${String(fn.description || "").slice(0, 180)}${args}`;
+  });
+  return [
+    "This provider/model may not accept native OpenAI function-call parameters.",
+    "Use this text tool protocol when you need a tool:",
+    '[TOOL_CALLS]tool_name[ARGS]{"arg":"value"}',
+    'A strict id form is also accepted: [TOOL_CALLS]tool_name[ARGS]call_short_id[ARGS]{"arg":"value"}',
+    'A JSON block form is accepted too: TOOL_CALLS: ```json [{"name":"tool_name","arguments":{"arg":"value"}}] ```',
+    "Return only one or more TOOL_CALLS blocks when calling tools; do not wrap them in markdown.",
+    "If no tool is needed, answer normally.",
+    "Available text tools:",
+    ...toolLines,
+  ].join("\n");
+}
+
+function messagesWithTextToolProtocol(config, messages, tools) {
+  const prepared = prepareMessages(config, messages).map((message) => {
+    if (message.role === "tool") {
+      return {
+        role: "user",
+        content: `Tool result for ${message.tool_call_id || "previous tool"}:\n${message.content || ""}`,
+      };
+    }
+    if (message.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+      return {
+        role: "assistant",
+        content:
+          message.content ||
+          `Requested tools: ${message.tool_calls
+            .map((call) => `${call.function?.name || "tool"}(${call.function?.arguments || "{}"})`)
+            .join("; ")}`,
+      };
+    }
+    return message;
+  });
+  const protocol = { role: "system", content: textToolProtocolPrompt(tools) };
+  if (prepared[0]?.role === "system") return [prepared[0], protocol, ...prepared.slice(1)];
+  return [protocol, ...prepared];
+}
+
 export function parseTextToolCalls(content = "") {
   const text = String(content || "");
-  if (!text.includes("[TOOL_CALLS]")) return [];
+  if (!text.includes("[TOOL_CALLS]") && !/TOOL_CALLS\s*:/i.test(text)) return [];
 
   const calls = [];
-  const pattern = /\[TOOL_CALLS\]([A-Za-z0-9_-]+)\[ARGS\]([A-Za-z0-9_.:-]+)\[ARGS\]([\s\S]*?)(?=\[TOOL_CALLS\]|$)/g;
-  for (const match of text.matchAll(pattern)) {
-    const name = match[1]?.trim();
-    const id = match[2]?.trim() || `text-tool-${calls.length + 1}`;
-    const rawArgs = match[3]?.trim() || "{}";
+  const jsonBlock = text.match(/TOOL_CALLS\s*:\s*```(?:json)?\s*([\s\S]*?)```/i);
+  if (jsonBlock?.[1]) {
+    try {
+      const parsed = JSON.parse(jsonBlock[1].trim());
+      if (Array.isArray(parsed)) {
+        for (const item of parsed) {
+          const name = String(item?.name || item?.tool || "").trim();
+          if (!name) continue;
+          const args = item?.arguments && typeof item.arguments === "object" ? item.arguments : {};
+          calls.push({
+            id: String(item?.id || `text-tool-${calls.length + 1}`),
+            type: "function",
+            function: {
+              name,
+              arguments: JSON.stringify(args),
+            },
+          });
+        }
+      }
+    } catch {
+      // Fall through to bracket parser below.
+    }
+  }
+
+  for (const chunk of text.split("[TOOL_CALLS]").slice(1)) {
+    const match = chunk.match(/^([A-Za-z0-9_-]+)\[ARGS\]([\s\S]*?)$/);
+    const name = match?.[1]?.trim();
+    let rawArgs = match?.[2]?.trim() || "{}";
+    let id = `text-tool-${calls.length + 1}`;
+    const strictParts = rawArgs.split("[ARGS]");
+    if (strictParts.length >= 2 && !rawArgs.startsWith("{") && !rawArgs.startsWith("[")) {
+      id = strictParts.shift()?.trim() || id;
+      rawArgs = strictParts.join("[ARGS]").trim() || "{}";
+    }
     if (!name) continue;
     try {
       JSON.parse(rawArgs);
@@ -101,14 +195,39 @@ export function parseTextToolCalls(content = "") {
   return calls;
 }
 
+function textBeforeToolCallMarker(content = "") {
+  return String(content || "")
+    .split("[TOOL_CALLS]")[0]
+    .split("TOOL_CALLS:")[0]
+    .split("<|tool_call>")[0]
+    .trim();
+}
+
 function normalizeTextToolCallResponse(response) {
   const message = response?.choices?.[0]?.message;
   if (!message || Array.isArray(message.tool_calls) && message.tool_calls.length > 0) return response;
 
   const calls = parseTextToolCalls(message.content || "");
-  if (calls.length === 0) return response;
+  if (calls.length === 0) {
+    const cleanedContent = textBeforeToolCallMarker(message.content || "");
+    if (!cleanedContent || cleanedContent === message.content) return response;
+    return {
+      ...response,
+      choices: response.choices.map((choice, index) =>
+        index === 0
+          ? {
+              ...choice,
+              message: {
+                ...message,
+                content: cleanedContent,
+              },
+            }
+          : choice
+      ),
+    };
+  }
 
-  const content = String(message.content || "").split("[TOOL_CALLS]")[0].trim();
+  const content = textBeforeToolCallMarker(message.content || "");
   return {
     ...response,
     choices: response.choices.map((choice, index) =>
@@ -919,16 +1038,33 @@ export async function requestNextStep(client, config, messages) {
     ]);
   }
 
-  const response = await client.chat.completions.create(
-    {
-      model: config.model,
-      temperature: 0,
-      tool_choice: toolChoiceForProvider(config, messages),
-      parallel_tool_calls: false,
-      messages: prepareMessages(config, messages),
-      tools,
-    },
-    requestOptions(config)
-  );
+  const textToolProtocol = usesTextToolProtocol(config);
+  const nativePayload = {
+    model: config.model,
+    temperature: 0,
+    tool_choice: toolChoiceForProvider(config, messages),
+    parallel_tool_calls: false,
+    messages: prepareMessages(config, messages),
+    tools,
+  };
+  const textPayload = {
+    model: config.model,
+    temperature: 0,
+    messages: messagesWithTextToolProtocol(config, messages, tools),
+  };
+
+  let response;
+  try {
+    response = await client.chat.completions.create(
+      textToolProtocol ? textPayload : nativePayload,
+      requestOptions(config)
+    );
+  } catch (error) {
+    if (!textToolProtocol && shouldRetryWithTextToolProtocol(error, config)) {
+      response = await client.chat.completions.create(textPayload, requestOptions(config));
+    } else {
+      throw error;
+    }
+  }
   return normalizeTextToolCallResponse(response);
 }

package/src/model-routing.js

@@ -215,12 +215,19 @@ export const PROVIDER_MODEL_CATALOG = {
       context: "128K",
       description: "Current Venice uncensored text route.",
     },
+    {
+      id: "e2ee-venice-uncensored-24b-p",
+      label: "Venice Uncensored 1.1",
+      bucket: "venice-uncensored",
+      context: "32K",
+      description: "E2EE Venice uncensored 1.1 text route.",
+    },
     {
       id: "venice-uncensored",
-      label: "Venice Uncensored",
+      label: "Venice Uncensored Legacy",
       bucket: "venice-uncensored",
       context: "32K",
-      description: "Legacy Venice uncensored text route.",
+      description: "Deprecated legacy Venice uncensored text route.",
     },
     {
       id: "venice-uncensored-role-play",