@vellumai/assistant 0.12.6-dev.202609292019.a6f6d85 → 0.12.6-dev.202609292116.41f7caa

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. 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. 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).
 - **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. 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.
+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.
 
-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).
+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).
 
 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/package.json

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

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

@@ -8,6 +8,7 @@
 
 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.
@@ -31,6 +32,7 @@ function resetTables() {
 
 interface MessagePayload {
   role: string;
+  textSegments?: string[];
   clientMessageId?: string;
 }
 
@@ -59,6 +61,47 @@ 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,6 +1178,33 @@ 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,6 +188,17 @@ 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,6 +1357,10 @@ 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,6 +341,32 @@ 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-unparseable-tool-retry.test.ts

@@ -0,0 +1,333 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { createMockProvider } from "../__tests__/helpers/mock-provider.js";
+import { MESSAGE_CATALOGS, MESSAGE_KEYS } from "../i18n/index.js";
+import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
+import type {
+  ContentBlock,
+  Message,
+  ProviderResponse,
+} from "../providers/types.js";
+import { wrapUnparseableToolArgs } from "../providers/unparseable-tool-args.js";
+import { type AgentEvent, AgentLoop } from "./loop.js";
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "Write the file" }],
+};
+
+function malformedToolResponse(
+  id: string,
+  raw: string,
+  options: { name?: string; text?: string } = {},
+): ProviderResponse {
+  return {
+    content: [
+      ...(options.text ? [{ type: "text" as const, text: options.text }] : []),
+      {
+        type: "tool_use",
+        id,
+        name: options.name ?? "file_write",
+        input: wrapUnparseableToolArgs(raw),
+      },
+    ],
+    model: "mock-model",
+    usage: { inputTokens: 1, outputTokens: 1 },
+    stopReason: "tool_use",
+  };
+}
+
+function toolBlocks(
+  history: Message[],
+  type: "tool_use" | "tool_result",
+): ContentBlock[] {
+  return history
+    .flatMap((message) => message.content)
+    .filter((block) => {
+      return block.type === type;
+    });
+}
+
+describe("AgentLoop: unparseable tool retries", () => {
+  beforeEach(() => {
+    resetPluginRegistryAndRegisterDefaults();
+  });
+
+  test("bounds persisted input and stops after three consecutive malformed turns", async () => {
+    const raw =
+      '{"path":"/workspace/file.md","content":"' + "x".repeat(2_000_000);
+    const { provider, calls } = createMockProvider([
+      malformedToolResponse("bad-1", raw),
+      malformedToolResponse("bad-2", raw),
+      malformedToolResponse("bad-3", raw, { text: "Still trying." }),
+      malformedToolResponse("bad-4", raw),
+    ]);
+    const executionInputs: Record<string, unknown>[] = [];
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "conversation-123",
+      tools: [
+        {
+          name: "file_write",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async (_name, input) => {
+        executionInputs.push(input);
+        return { content: "invalid JSON", isError: true };
+      },
+    });
+
+    const result = await loop.run({
+      requestId: "request-123",
+      messages: [userMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(calls).toHaveLength(3);
+    expect(executionInputs).toHaveLength(2);
+    expect(executionInputs[0]).toEqual(wrapUnparseableToolArgs(raw));
+    expect(toolBlocks(result.history, "tool_use")).toHaveLength(2);
+    expect(toolBlocks(result.history, "tool_result")).toHaveLength(2);
+
+    const serializedHistory = JSON.stringify(result.history);
+    expect(serializedHistory.length).toBeLessThan(5_000);
+    expect(serializedHistory).not.toContain("x".repeat(1_000));
+    expect(result.history.at(-1)?.content).toEqual([
+      { type: "text", text: "Still trying." },
+      {
+        type: "text",
+        text: `\n\n${MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP}`,
+      },
+    ]);
+    expect(events.filter((event) => event.type === "tool_use")).toHaveLength(2);
+    expect(
+      events
+        .filter((event) => event.type === "text_delta")
+        .map((event) => event.text)
+        .join(""),
+    ).toEndWith(
+      `Still trying.\n\n${
+        MESSAGE_CATALOGS.en[MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP]
+      }`,
+    );
+  });
+
+  test("surfaces only the stop notice when assistant text is tool-gated", async () => {
+    const raw = "{" + "x".repeat(1_000);
+    const { provider } = createMockProvider([
+      malformedToolResponse("bad-1", raw, { text: "Private notes one." }),
+      malformedToolResponse("bad-2", raw, { text: "Private notes two." }),
+      malformedToolResponse("bad-3", raw, { text: "Private notes three." }),
+    ]);
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "conversation-gated",
+      tools: [
+        {
+          name: "file_write",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async () => ({ content: "invalid JSON", isError: true }),
+    });
+
+    const result = await loop.run({
+      requestId: "request-gated",
+      messages: [userMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      suppressAssistantText: true,
+    });
+
+    expect(result.history.at(-1)?.content).toEqual([
+      {
+        type: "text",
+        text: MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
+      },
+    ]);
+    expect(
+      events
+        .filter((event) => event.type === "text_delta")
+        .map((event) => event.text)
+        .join(""),
+    ).toBe(
+      MESSAGE_CATALOGS.en[MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP],
+    );
+    const finalMessage = events
+      .filter((event) => event.type === "message_complete")
+      .at(-1);
+    expect(finalMessage?.assistantTextVisibility).toBe("visible");
+  });
+
+  test("streams the localized stop notice while persisting its key", async () => {
+    const raw = "{" + "x".repeat(1_000);
+    const { provider } = createMockProvider([
+      malformedToolResponse("bad-1", raw),
+      malformedToolResponse("bad-2", raw),
+      malformedToolResponse("bad-3", raw),
+    ]);
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "conversation-spanish",
+      tools: [
+        {
+          name: "file_write",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async () => ({ content: "invalid JSON", isError: true }),
+    });
+
+    const result = await loop.run({
+      requestId: "request-spanish",
+      messages: [userMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      locale: "es",
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(result.history.at(-1)?.content).toEqual([
+      {
+        type: "text",
+        text: MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP,
+      },
+    ]);
+    expect(
+      events
+        .filter((event) => event.type === "text_delta")
+        .map((event) => event.text)
+        .join(""),
+    ).toBe(
+      MESSAGE_CATALOGS.es[MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP],
+    );
+  });
+
+  test("does not count skill_execute envelopes recovered from valid outer JSON", async () => {
+    const recoverableRaw = JSON.stringify({
+      tool: "document_update",
+      input: "body",
+      activity: "Updating the document",
+    });
+    const malformedRaw = "{" + "x".repeat(1_000);
+    const done: ProviderResponse = {
+      content: [{ type: "text", text: "Done" }],
+      model: "mock-model",
+      usage: { inputTokens: 1, outputTokens: 1 },
+      stopReason: "end_turn",
+    };
+    const { provider, calls } = createMockProvider([
+      malformedToolResponse("recover-1", recoverableRaw, {
+        name: "skill_execute",
+      }),
+      malformedToolResponse("bad-1", malformedRaw),
+      malformedToolResponse("recover-2", recoverableRaw, {
+        name: "skill_execute",
+      }),
+      malformedToolResponse("bad-2", malformedRaw),
+      done,
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "conversation-789",
+      tools: [
+        {
+          name: "skill_execute",
+          description: "",
+          input_schema: { type: "object" },
+        },
+        {
+          name: "file_write",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async () => ({ content: "result", isError: false }),
+    });
+
+    const result = await loop.run({
+      requestId: "request-789",
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(calls).toHaveLength(5);
+    expect(result.history.at(-1)?.content).toEqual([
+      { type: "text", text: "Done" },
+    ]);
+  });
+
+  test("resets the streak after a well-formed tool turn", async () => {
+    const raw = "{" + "x".repeat(1_000);
+    const valid: ProviderResponse = {
+      content: [
+        {
+          type: "tool_use",
+          id: "valid",
+          name: "file_write",
+          input: { path: "/workspace/file.md", content: "ok" },
+        },
+      ],
+      model: "mock-model",
+      usage: { inputTokens: 1, outputTokens: 1 },
+      stopReason: "tool_use",
+    };
+    const done: ProviderResponse = {
+      content: [{ type: "text", text: "Done" }],
+      model: "mock-model",
+      usage: { inputTokens: 1, outputTokens: 1 },
+      stopReason: "end_turn",
+    };
+    const { provider, calls } = createMockProvider([
+      malformedToolResponse("bad-1", raw),
+      malformedToolResponse("bad-2", raw),
+      valid,
+      malformedToolResponse("bad-3", raw),
+      malformedToolResponse("bad-4", raw),
+      done,
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "conversation-456",
+      tools: [
+        {
+          name: "file_write",
+          description: "",
+          input_schema: { type: "object" },
+        },
+      ],
+      toolExecutor: async () => ({ content: "result", isError: false }),
+    });
+
+    const result = await loop.run({
+      requestId: "request-456",
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(calls).toHaveLength(6);
+    expect(result.history.at(-1)?.content).toEqual([
+      { type: "text", text: "Done" },
+    ]);
+  });
+});