@vellumai/assistant 0.12.6-dev.202609292116.41f7caa → 0.12.6-staging.1

package/.env.example

@@ -2,8 +2,6 @@
 ANTHROPIC_API_KEY=sk-ant-...
 OPENAI_API_KEY=sk-...
 GEMINI_API_KEY=...
-# Optional. IO Intelligence (io.net) open-models endpoint.
-IONET_API_KEY=...
 # Optional. TypeSafe / Jev System One decision model.
 TYPESAFE_API_KEY=...
 # Optional for authenticated/proxied Ollama deployments

package/ARCHITECTURE.md

@@ -618,12 +618,12 @@ Every phone call connects over Twilio Media Streams: the voice webhook emits `<C
 
 Transcription mode is selected once per session in `media-stream-stt-session.ts`:
 
-- **Streaming** (default): when `calls.voice.telephonyStreaming` is enabled and the `telephony` role resolves a streaming transcriber (`resolveStreamingTranscriber({ role: "telephony" })`), inbound audio is decoded (mu-law → PCM16, resampled 8 kHz → 16 kHz) and fed to the provider's realtime adapter. Replies trigger only on utterance-boundary finals (for Deepgram, `speech_final`/`UtteranceEnd`, never mid-sentence `is_final` segments), and barge-in fires from local energy VAD, never from transcriber partials. Interim `partial` events are forwarded to the controller as `handleCallerPartial`: they commit nothing and start no turn, they are never persisted and never reach a setup flow, and they exist so a boundary the front door held mid-thought can be replayed on the caller's newest words rather than only the ones the provider has finalized. While something is interruptible (an assistant turn in flight, thinking or speaking, or a completed turn's tail still playing from Twilio's buffer), caller speech arms the shared sustained-speech barge-in guard (`src/calls/barge-in-guard.ts`, the same accounting live voice uses: speech accumulates toward 250 ms, short gaps are tolerated, a run that is mostly silence resets) and every inbound frame feeds it; outside that window the guard is dropped, so the caller's own utterance never carries into a turn that starts before the local VAD ends it. Only a fired guard reaches `CallController.handleBargeIn`, which interrupts a turn in either phase and ignores an idle controller (the playing tail is cleared instead).
+- **Streaming** (default): when `calls.voice.telephonyStreaming` is enabled and the `telephony` role resolves a streaming transcriber (`resolveStreamingTranscriber({ role: "telephony" })`), inbound audio is decoded (mu-law → PCM16, resampled 8 kHz → 16 kHz) and fed to the provider's realtime adapter. Replies trigger only on utterance-boundary finals (for Deepgram, `speech_final`/`UtteranceEnd`, never mid-sentence `is_final` segments), and barge-in fires from local energy VAD, never from transcriber partials. While something is interruptible (an assistant turn in flight, thinking or speaking, or a completed turn's tail still playing from Twilio's buffer), caller speech arms the shared sustained-speech barge-in guard (`src/calls/barge-in-guard.ts`, the same accounting live voice uses: speech accumulates toward 250 ms, short gaps are tolerated, a run that is mostly silence resets) and every inbound frame feeds it; outside that window the guard is dropped, so the caller's own utterance never carries into a turn that starts before the local VAD ends it. Only a fired guard reaches `CallController.handleBargeIn`, which interrupts a turn in either phase and ignores an idle controller (the playing tail is cleared instead).
 - **Batch fallback**: otherwise the session segments turns with the energy-based `MediaTurnDetector` and transcribes each completed turn via the same role's batch API. Both halves of a call read the `telephony` role, which is why a role names its consumer rather than a boundary.
 
-Every phone turn runs the same two-leg triage as live voice through `startVoiceTurn` (`src/calls/voice-session-bridge.ts`): `call-controller.ts` opens on a toolless front-door leg (`routingLeg: "front-door"`, the `voiceFrontDoor` call site) and drives it through the shared `createFrontDoorLegCoordinator` (`src/calls/voice-leg-coordinator.ts`), which reads the stream through the verdict machine and sequences the hand-off (pause narration, abort the leg, resolve and speak the bridge, mark it as the floor holder, start the escalated leg pinned to the conversation's own model, re-arm narration); each driver supplies only a host for how text and the bridge are spoken, how a leg is started or aborted, and (live voice only) the speculative hold and commit. A leg that carries the caller's own words is also the turn's endpoint decision, so it is taught the hold verdict: silence alone cannot tell a finished sentence from a thinking pause, and answering a fragment makes the rest of the sentence read as a barge-in that interrupts the assistant's own reply. On a hold the leg is discarded (its persisted user row rolled back through the handle's `discard`), the floor goes straight back to the caller, and the words are carried into their next final so the whole sentence is judged together. If no next words arrive, a replay timer (`voice.frontModel.endpointExtensionMs`) answers the sentence as it stands; any partial re-arms that timer and the next final cancels it. A partial also stretches the wait to at least `calls.voice.utteranceEndMs` plus a margin, because the provider still owes a final for those words and that final is the better boundary: racing it would ask the same words twice, once on the interim guess and once on the committed text. Reaching the timer with a partial outstanding therefore means no final is coming, so the interim text rides along as the only record of what the caller said. `voice.frontModel.endpointMaxExtensions` caps consecutive holds per sentence, after which the leg must answer. Openers, instructions, and other assistant-initiated turns are never dispatched that way. The controller also passes the bridge's turn callbacks (tool activity is recorded as `tool_use_started` / `tool_use_completed` call events, persisted row ids ride the `assistant_spoke` event), `launchedAtMs` for dispatch timing, and a `voiceTelemetry` bag keyed by the call session with a `phone_inbound` / `phone_outbound` entry. Both drivers share the spoken progress narration cadence (`src/calls/voice-progress-cadence.ts`, tuned by `voice.frontModel.progress`): the cadence owns the tool-activity log, the triggers (an ops burst, a long operation completing, a full interval of audible silence with news, the `maxSilenceMs` heartbeat) and the generated or static phrase, while each driver supplies its own view of audible silence (live voice from its TTS queue and playback-tail estimate; the media-stream transport from `isPlaybackIdle()` and a running sum of sent frame durations) and how to speak a phrase.
+Every phone turn runs the same two-leg triage as live voice through `startVoiceTurn` (`src/calls/voice-session-bridge.ts`): `call-controller.ts` opens on a toolless front-door leg (`routingLeg: "front-door"`, the `voiceFrontDoor` call site) and drives it through the shared `createFrontDoorLegCoordinator` (`src/calls/voice-leg-coordinator.ts`), which reads the stream through the verdict machine and sequences the hand-off (pause narration, abort the leg, resolve and speak the bridge, mark it as the floor holder, start the escalated leg pinned to the conversation's own model, re-arm narration); each driver supplies only a host for how text and the bridge are spoken, how a leg is started or aborted, and (live voice only) the speculative hold and commit. Phone has no partial transcripts, so the hold verdict is never taught and routing is escalate-only. The controller also passes the bridge's turn callbacks (tool activity is recorded as `tool_use_started` / `tool_use_completed` call events, persisted row ids ride the `assistant_spoke` event), `launchedAtMs` for dispatch timing, and a `voiceTelemetry` bag keyed by the call session with a `phone_inbound` / `phone_outbound` entry. Both drivers share the spoken progress narration cadence (`src/calls/voice-progress-cadence.ts`, tuned by `voice.frontModel.progress`): the cadence owns the tool-activity log, the triggers (an ops burst, a long operation completing, a full interval of audible silence with news, the `maxSilenceMs` heartbeat) and the generated or static phrase, while each driver supplies its own view of audible silence (live voice from its TTS queue and playback-tail estimate; the media-stream transport from `isPlaybackIdle()` and a running sum of sent frame durations) and how to speak a phrase.
 
-Both drivers also share the per-turn latency marks (`src/calls/voice-metrics.ts`). The controller opens a turn's marks when it dispatches, seeded with when the caller's transcript arrived and when the provider first had interim words for that same utterance, and stamps the leg dispatch, the first assistant delta, the first audible audio, a barge-in, an endpoint hold, and how the turn settled. A held turn settles as `endpoint_hold` and hands both seeds to the turn that finally answers, so the caller's wait is still measured from the moment they stopped talking. Live voice streams a snapshot to its client on every mark; a call has no client on the line, so the aggregate is logged once per turn, cancelled turns included. Each call also records a `phone_call_started` / `phone_call_ended` pair on the onboarding telemetry substrate (`src/telemetry/phone-call-funnel.ts`), written by the call store at session creation and at the single terminal status transition: duration is the gap between the two rows, and a call that took no caller turn carries why on the end row (`silent_no_connect` when it never connected, `silent_no_turn` when it did and nobody spoke).
+Both drivers also share the per-turn latency marks (`src/calls/voice-metrics.ts`). The controller opens a turn's marks when it dispatches, seeded with when the caller's transcript arrived, and stamps the leg dispatch, the first assistant delta, the first audible audio, a barge-in, and how the turn settled. Live voice streams a snapshot to its client on every mark; a call has no client on the line, so the aggregate is logged once per turn, cancelled turns included. Each call also records a `phone_call_started` / `phone_call_ended` pair on the onboarding telemetry substrate (`src/telemetry/phone-call-funnel.ts`), written by the call store at session creation and at the single terminal status transition: duration is the gap between the two rows, and a call that took no caller turn carries why on the end row (`silent_no_connect` when it never connected, `silent_no_turn` when it did and nobody spoke).
 
 A credential preflight (`resolveTelephonyCredentialReadiness()` in `src/calls/telephony-credential-preflight.ts`) gates every call: it requires a credentialed, telephony-capable STT provider **and** a media-stream-playable TTS provider (the configured one or a credentialed playable fallback). Inbound calls that fail the preflight receive `<Say>` setup-required copy plus `<Hangup/>` instead of a doomed stream; outbound placement fails before dialing via `preflightVoiceIngress()` with the same user-facing message.
 

package/openapi.yaml

@@ -6025,7 +6025,6 @@ paths:
                     - minimax
                     - atlascloud
                     - baseten
-                    - ionet
                     - poolside
                 connectionName:
                   type: string
@@ -16974,8 +16973,8 @@ paths:
             type: string
           description:
             "Filter by provider id. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, ionet, poolside,
-            typesafe, vellum"
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
+            vellum"
       responses:
         "200":
           description: Successful response
@@ -17247,8 +17246,8 @@ paths:
             type: string
           description:
             "Filter by provider. One of: anthropic, openai, gemini, ollama, fireworks, together, openrouter,
-            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, ionet, poolside,
-            typesafe, vellum, chatgpt"
+            vercel-ai-gateway, litellm, opencode, openai-compatible, minimax, atlascloud, baseten, poolside, typesafe,
+            vellum, chatgpt"
       responses:
         "200":
           description: Successful response
@@ -39426,7 +39425,6 @@ components:
         - minimax
         - atlascloud
         - baseten
-        - ionet
         - poolside
         - typesafe
         - vellum
@@ -39691,7 +39689,6 @@ components:
                     - minimax
                     - atlascloud
                     - baseten
-                    - ionet
                     - poolside
                 connectionName:
                   type: string
@@ -40080,7 +40077,6 @@ components:
                 - minimax
                 - atlascloud
                 - baseten
-                - ionet
                 - poolside
             - type: "null"
         connectionName:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.6-dev.202609292116.41f7caa",
+  "version": "0.12.6-staging.1",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/list-messages-client-message-id.test.ts

@@ -8,7 +8,6 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { MESSAGE_KEYS } from "../i18n/index.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Keep the memory system off so addMessage skips indexing side effects.
@@ -32,7 +31,6 @@ function resetTables() {
 
 interface MessagePayload {
   role: string;
-  textSegments?: string[];
   clientMessageId?: string;
 }
 
@@ -61,47 +59,6 @@ describe("handleListMessages clientMessageId", () => {
     expect(body.messages[0].clientMessageId).toBe("nonce-abc");
   });
 
-  test("localizes persisted assistant keys without rewriting legacy text", async () => {
-    const localizedConv = createConversation();
-    await addMessage(
-      localizedConv.id,
-      "assistant",
-      JSON.stringify([
-        {
-          type: "text",
-          text: MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
-        },
-      ]),
-      { skipIndexing: true },
-    );
-
-    const localizedResponse = await handleListMessages({
-      queryParams: { conversationId: localizedConv.id },
-      headers: { "accept-language": "es" },
-    });
-    const localizedBody = localizedResponse as { messages: MessagePayload[] };
-    expect(localizedBody.messages[0]?.textSegments).toEqual([
-      "Me detuve después de varias llamadas de herramienta con formato incorrecto para evitar que esta conversación creciera indefinidamente. Inténtalo de nuevo o cambia de modelo si el problema continúa.",
-    ]);
-
-    const legacyConv = createConversation();
-    const legacy =
-      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.";
-    await addMessage(
-      legacyConv.id,
-      "assistant",
-      JSON.stringify([{ type: "text", text: legacy }]),
-      { skipIndexing: true },
-    );
-
-    const legacyResponse = await handleListMessages({
-      queryParams: { conversationId: legacyConv.id },
-      headers: { "accept-language": "es" },
-    });
-    const legacyBody = legacyResponse as { messages: MessagePayload[] };
-    expect(legacyBody.messages[0]?.textSegments).toEqual([legacy]);
-  });
-
   test("omits clientMessageId when the row was persisted without one", async () => {
     // GIVEN a user message persisted without a client nonce (e.g. a channel send)
     const conv = createConversation();

package/src/__tests__/openai-provider.test.ts

@@ -1178,33 +1178,6 @@ describe("OpenAIProvider", () => {
     });
   });
 
-  test("bounds malformed arguments in the diagnostic raw response only", async () => {
-    const raw = '{"content":"' + "x".repeat(1_000);
-    fakeChunks = [
-      ...toolCallChunks([{ id: "call_large_bad", name: "test", args: raw }]),
-      usageChunk(10, 5),
-    ];
-
-    const result = await provider.sendMessage([userMsg("test")]);
-
-    expect(result.content[0]).toEqual({
-      type: "tool_use",
-      id: "call_large_bad",
-      name: "test",
-      input: { _raw: raw },
-    });
-    const rawResponse = result.rawResponse as {
-      choices: Array<{
-        message: {
-          tool_calls: Array<{ function: { arguments: string } }>;
-        };
-      }>;
-    };
-    expect(
-      rawResponse.choices[0]!.message.tool_calls[0]!.function.arguments,
-    ).toBe(raw.slice(0, 200) + "…");
-  });
-
   // -----------------------------------------------------------------------
   // stream_options and model
   // -----------------------------------------------------------------------

package/src/__tests__/skill-execute-input.test.ts

@@ -188,17 +188,6 @@ describe("recoverSkillExecuteEnvelope", () => {
     expect(recoverSkillExecuteEnvelope(wrapped)).toBe(wrapped);
   });
 
-  test("keeps recovered JSON wrapped when it lacks a string tool name", () => {
-    for (const raw of [
-      JSON.stringify({ input: { content: "hi" }, activity: "x" }),
-      JSON.stringify({ tool: 42, input: {}, activity: "x" }),
-      JSON.stringify(["document_update"]),
-    ]) {
-      const wrapped = { _raw: raw };
-      expect(recoverSkillExecuteEnvelope(wrapped)).toBe(wrapped);
-    }
-  });
-
   test("passes a normal envelope through untouched", () => {
     const envelope = {
       tool: "document_update",

package/src/__tests__/tool-approval-handler.test.ts

@@ -1357,10 +1357,6 @@ describe("ToolApprovalHandler / unparseable tool args gate", () => {
     }
     expect(result.result.content).not.toContain(raw);
     expect(result.result.content).toContain("…");
-    expect(auditCalls.error).toHaveLength(1);
-    expect(auditCalls.error[0].input).toEqual({
-      _raw: raw.slice(0, 200) + "…",
-    });
   });
 
   test("legitimate input containing a _raw field among others is not rejected", async () => {

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -341,32 +341,6 @@ describe("tool preview lifecycle", () => {
       expect((emitted as any).conversationId).toBe("test-session-id");
     });
 
-    test("caps cumulative app preview payloads and stops forwarding growth", () => {
-      const collector = createEventCollector();
-      const deps = createMockDeps({ onEvent: collector.onEvent });
-      const accumulatedJson = '{"code":"' + "x".repeat(300_000);
-
-      handleInputJsonDelta(state, deps, {
-        type: "input_json_delta",
-        toolName: "app_create",
-        toolUseId: "toolu_large_app",
-        accumulatedJson,
-      });
-      handleInputJsonDelta(state, deps, {
-        type: "input_json_delta",
-        toolName: "app_create",
-        toolUseId: "toolu_large_app",
-        accumulatedJson: accumulatedJson + "more",
-      });
-
-      expect(collector.events).toHaveLength(1);
-      const emitted = collector.events[0] as Extract<
-        AssistantEvent,
-        { type: "tool_input_delta" }
-      >;
-      expect(emitted.content).toBe(accumulatedJson.slice(0, 256_000));
-    });
-
     test("a streaming ui_show visual announces its surface exactly once", () => {
       const collector = createEventCollector();
       const deps = createMockDeps({ onEvent: collector.onEvent });

package/src/agent/loop.ts

@@ -28,12 +28,6 @@ import type {
   PreModelCallInputContext,
   StopInputContext,
 } from "../hooks/types.js";
-import {
-  MESSAGE_KEYS,
-  resolveStoredMessageText,
-  type SupportedLocale,
-  t,
-} from "../i18n/index.js";
 import {
   timeSyncSection,
   traceAsyncSection,
@@ -58,10 +52,6 @@ import type {
   ToolResultContent,
 } from "../providers/types.js";
 import { NATIVE_WEB_SEARCH_TOOL_NAME } from "../providers/types.js";
-import {
-  boundUnparseableToolArgs,
-  isUnparseableToolArgs,
-} from "../providers/unparseable-tool-args.js";
 import { recordWatchdogEvent } from "../telemetry/watchdog-events-store.js";
 import {
   ABORT_SETTLE_GRACE_MS,
@@ -74,7 +64,6 @@ import {
   applyStreamingSubstitution,
   applySubstitutions,
 } from "../tools/sensitive-output-placeholders.js";
-import { recoverSkillExecuteEnvelope } from "../tools/skills/execute.js";
 import {
   abortedToolResultText,
   isPreemptedByNewMessage,
@@ -94,8 +83,6 @@ const log = getLogger("agent-loop");
 
 /** Watchdog check name for both tool-gated reply outcomes. */
 const SEND_USER_MESSAGE_CHECK = "send_user_message_delivery";
-const MAX_CONSECUTIVE_UNPARSEABLE_TOOL_TURNS = 3;
-const SKILL_EXECUTE_TOOL_NAME = "skill_execute";
 
 /**
  * The user-facing message a `send_user_message` block carries, or null when
@@ -709,8 +696,6 @@ interface AgentLoopRunOptionsBase {
   injectionLedgerResets?: Set<string>;
   signal?: AbortSignal;
   requestId: string;
-  /** Locale for daemon-authored text emitted during this run. */
-  locale?: SupportedLocale;
   /**
    * Explicit model override (provider/model string) for every LLM call in
    * this run. When omitted, the model is resolved through the normal
@@ -1026,31 +1011,12 @@ function toolResultEventFields(
 interface NormalizedToolUse {
   /** Assistant content with at most one `tool_use` block per call id. */
   content: ContentBlock[];
-  /** The bounded `tool_use` blocks in `content`, in order. */
+  /** The `tool_use` blocks in `content`, in order. */
   toolUseBlocks: ToolUseBlock[];
-  /** Original inputs retained only until this iteration's execution attempt. */
-  executionInputsById: Map<string, Record<string, unknown>>;
-  /** Number of executable calls whose provider arguments did not parse. */
-  unparseableCount: number;
   /** Coalesced copies: a call id and name for each block dropped. */
   duplicates: Array<{ id: string; name: string }>;
 }
 
-function isRetryableUnparseableToolCall(block: ToolUseBlock): boolean {
-  if (!isUnparseableToolArgs(block.input)) {
-    return false;
-  }
-  if (block.name !== SKILL_EXECUTE_TOOL_NAME) {
-    return true;
-  }
-  const recovered = recoverSkillExecuteEnvelope(block.input);
-  return (
-    recovered === block.input ||
-    typeof recovered.tool !== "string" ||
-    recovered.tool.length === 0
-  );
-}
-
 /**
  * Resolves an assistant reply's `tool_use` blocks into an executable set keyed
  * by call id: a block with no id gets one, and a repeat of an id already in the
@@ -1064,10 +1030,8 @@ function normalizeToolUseBlocks(
 ): NormalizedToolUse {
   const nextContent: ContentBlock[] = [];
   const toolUseBlocks: ToolUseBlock[] = [];
-  const executionInputsById = new Map<string, Record<string, unknown>>();
   const duplicates: Array<{ id: string; name: string }> = [];
   const seenIds = new Set<string>();
-  let unparseableCount = 0;
 
   for (const block of content) {
     if (block.type !== "tool_use") {
@@ -1078,28 +1042,14 @@ function normalizeToolUseBlocks(
       duplicates.push({ id: block.id, name: block.name });
       continue;
     }
-    const normalizedId = block.id.length === 0 ? crypto.randomUUID() : block.id;
-    const bounded: ToolUseBlock = {
-      ...block,
-      id: normalizedId,
-      input: boundUnparseableToolArgs(block.input),
-    };
-    seenIds.add(normalizedId);
-    executionInputsById.set(normalizedId, block.input);
-    if (isRetryableUnparseableToolCall(block)) {
-      unparseableCount++;
-    }
-    nextContent.push(bounded);
-    toolUseBlocks.push(bounded);
+    const normalized: ToolUseBlock =
+      block.id.length === 0 ? { ...block, id: crypto.randomUUID() } : block;
+    seenIds.add(normalized.id);
+    nextContent.push(normalized);
+    toolUseBlocks.push(normalized);
   }
 
-  return {
-    content: nextContent,
-    toolUseBlocks,
-    executionInputsById,
-    unparseableCount,
-    duplicates,
-  };
+  return { content: nextContent, toolUseBlocks, duplicates };
 }
 
 /**
@@ -1536,7 +1486,6 @@ export class AgentLoop {
     let newMessagesStart = history.length;
     let toolUseTurns = 0;
     let postModelCallContinues = 0;
-    let consecutiveUnparseableToolTurns = 0;
     // Whether the user has been told the OUTCOME of the work so far, not
     // merely that work started. True only while the most recent tool-bearing
     // response was `send_user_message` and nothing else: a response that sends
@@ -1792,7 +1741,6 @@ export class AgentLoop {
       // request from a generation that died mid-flight. Declared here so that
       // catch can reach it.
       let streamedTokens = false;
-      let unparseableToolRetryLimitReached = false;
 
       try {
         // ── Pre-call budget gate ─────────────────────────────────────
@@ -2780,44 +2728,6 @@ export class AgentLoop {
           content: normalizedToolUse.content,
         };
         toolUseBlocks = normalizedToolUse.toolUseBlocks;
-        if (normalizedToolUse.unparseableCount > 0) {
-          consecutiveUnparseableToolTurns++;
-        } else {
-          consecutiveUnparseableToolTurns = 0;
-        }
-        if (
-          consecutiveUnparseableToolTurns >=
-          MAX_CONSECUTIVE_UNPARSEABLE_TOOL_TURNS
-        ) {
-          rlog.warn(
-            {
-              turn: toolUseTurns,
-              consecutiveUnparseableToolTurns,
-              unparseableToolCount: normalizedToolUse.unparseableCount,
-            },
-            "Repeated unparseable tool calls reached the per-run limit",
-          );
-          unparseableToolRetryLimitReached = true;
-          const visiblePrefix = suppressAssistantText
-            ? []
-            : assistantMessage.content.filter(
-                (block) => block.type !== "tool_use",
-              );
-          assistantMessage = {
-            role: "assistant",
-            content: [
-              ...visiblePrefix,
-              {
-                type: "text",
-                text: `${
-                  hasVisibleText(visiblePrefix) ? "\n\n" : ""
-                }${MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP}`,
-              },
-            ],
-          };
-          toolUseBlocks = [];
-          userToldOutcome = false;
-        }
 
         // At the no-tool stop boundary the retry decision is actionable: a
         // recovery hook may repair history and ask to re-query (a tool-bearing
@@ -2826,7 +2736,6 @@ export class AgentLoop {
         // persisting it; the per-run backstop keeps a misbehaving hook from
         // spinning forever.
         if (
-          !unparseableToolRetryLimitReached &&
           toolUseBlocks.length === 0 &&
           postModelCallDecision === "continue"
         ) {
@@ -2888,40 +2797,11 @@ export class AgentLoop {
         // Surface the finalized text if the client saw nothing live (a
         // deferred stream, a hook-rewritten empty turn, or the tool-gated
         // fallback where no `send_user_message` call ever reached the user).
-        let fallbackSurfaced = false;
-        if (unparseableToolRetryLimitReached && streamedVisibleText) {
-          onEvent({
-            type: "text_delta",
-            text: resolveStoredMessageText(
-              assistantTextOf(assistantMessage.content.slice(-1)),
-              options.locale,
-            ),
-          });
-          fallbackSurfaced = suppressAssistantText;
-        } else {
-          const displayContent = unparseableToolRetryLimitReached
-            ? assistantMessage.content.map((block) =>
-                block.type === "text" &&
-                block.text.trim() ===
-                  MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP
-                  ? {
-                      ...block,
-                      text: block.text.replace(
-                        MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
-                        t(
-                          MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
-                          options.locale,
-                        ),
-                      ),
-                    }
-                  : block,
-              )
-            : assistantMessage.content;
-          fallbackSurfaced = emitFinalAssistantText(displayContent, {
+        const textVisibility = textVisibilityOf(
+          emitFinalAssistantText(assistantMessage.content, {
             turnEnding: toolUseBlocks.length === 0,
-          });
-        }
-        const textVisibility = textVisibilityOf(fallbackSurfaced);
+          }),
+        );
 
         history.push(assistantMessage);
 
@@ -3034,8 +2914,7 @@ export class AgentLoop {
               }
               const result = await this.toolExecutor!(
                 toolUse.name,
-                normalizedToolUse.executionInputsById.get(toolUse.id) ??
-                  toolUse.input,
+                toolUse.input,
                 (chunk) => {
                   onEvent({
                     type: "tool_output_chunk",