@lazyingart/agintiflow 0.20.5 → 0.20.7

package/docs/model-selection.md

@@ -52,7 +52,7 @@ In the interactive CLI, `/provider`, `/route`, `/model`, `/spare`, and `/auxilia
 
 ```text
 venice/venice-uncensored-1-2
-venice/e2ee-venice-uncensored-24b-p
+venice/venice-uncensored
 venice/gemma-4-uncensored
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.5",
+  "version": "0.20.7",
   "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` opens a route/main selector for Venice text models. The selector includes `venice/venice-uncensored-1-2` (Venice 1.2), `venice/e2ee-venice-uncensored-24b-p` (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.
+`/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` also exposes `e2ee-venice-uncensored-24b-p` as Venice 1.1 |
+| `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

@@ -52,7 +52,7 @@ Store `VENICE_API_KEY` only in ignored local files such as `.aginti/.env` or a s
 | `openai-gpt-52` | 256K | GPT-5.2 |
 | `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 (`e2ee-venice-uncensored-24b-p`), 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 older `venice-uncensored` ID is retained only as a legacy alias.
+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-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

@@ -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)), "..");
 
@@ -115,6 +115,18 @@ const parsedTextToolCalls = parseTextToolCalls('[TOOL_CALLS]list_files[ARGS]call
 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");
@@ -124,7 +136,7 @@ assert(interactiveOutput.includes("venice=on"), "/venice did not enable Venice r
 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/e2ee-venice-uncensored-24b-p"), "/venice 1.1 did not set Venice 1.1 route role");
+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");

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

@@ -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,
@@ -1650,9 +1684,9 @@ function veniceTextModelChoices() {
     },
     {
       provider: "venice",
-      model: "e2ee-venice-uncensored-24b-p",
+      model: "venice-uncensored",
       label: "Venice 1.1",
-      description: "E2EE Venice text model; 32K context",
+      description: "legacy Venice text model; 32K context",
     },
     {
       provider: "venice",
@@ -1670,14 +1704,16 @@ function resolveVeniceTextModel(value = "") {
   }
   if (
     normalized === "1.1" ||
-    normalized === "venice-1.1" ||
-    normalized === "e2ee-venice-uncensored-24b-p"
+    normalized === "venice-1.1"
   ) {
-    return "e2ee-venice-uncensored-24b-p";
+    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";
   }
@@ -1781,9 +1817,9 @@ function modelRoleChoices(role = "main") {
     },
     {
       provider: "venice",
-      model: "e2ee-venice-uncensored-24b-p",
+      model: "venice-uncensored",
       label: "Venice 1.1",
-      description: "E2EE Venice text route; use /auth venice if missing",
+      description: "legacy Venice text route; use /auth venice if missing",
       route: true,
       main: true,
       spare: true,
@@ -1930,8 +1966,11 @@ 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);
@@ -1948,7 +1987,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;
 }
 
@@ -2639,6 +2678,7 @@ async function runPrompt(prompt, state, packageDir) {
     printSystemLine(`status=running workingOn=${state.activeGoal}`);
   }
   let result;
+  let runError = null;
   let queuedAfterFinish = [];
   try {
     result = await runAgent({
@@ -2666,6 +2706,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") {
@@ -2688,10 +2730,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);
 }