@vellumai/assistant 0.11.4-staging.1 → 0.11.4-staging.2

package/src/calls/call-controller.ts

@@ -730,8 +730,10 @@ export class CallController {
     let ttsBuffer = "";
     let fullResponseText = "";
     // Reasoning models can inline <think> spans in the content stream when a
-    // profile has not opted into parseThinkTags; the spoken path must never
-    // read them aloud. fullResponseText keeps the raw stream.
+    // profile has not opted into parseThinkTags. Neither the spoken path nor
+    // the post-turn consumers of fullResponseText (transcripts,
+    // assistant_spoke, END_CALL/ASK_GUARDIAN detection) may see them: both
+    // are fed only filtered text.
     const reasoningFilter = createReasoningTagFilter();
 
     // Synthesized path: text is split at speakable boundaries as it streams
@@ -935,8 +937,13 @@ export class CallController {
         if (!this.isCurrentRun(runVersion)) {
           return;
         }
-        fullResponseText += text;
-        ttsBuffer += reasoningFilter.push(text);
+        // One filter feeds both consumers: the spoken stream and the text
+        // used for transcripts, assistant_spoke, and END_CALL/ASK_GUARDIAN
+        // marker detection. A control marker inside a reasoning span must
+        // never trigger a real action the caller did not hear.
+        const speakable = reasoningFilter.push(text);
+        fullResponseText += speakable;
+        ttsBuffer += speakable;
         ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
         flushSafeText();
       };
@@ -1015,9 +1022,11 @@ export class CallController {
       return fullResponseText;
     }
 
-    // Final sweep: release any held-back partial tag, then strip any
-    // remaining control markers from the buffer.
-    ttsBuffer += reasoningFilter.flush();
+    // Final sweep: release any held-back partial tag to both consumers,
+    // then strip any remaining control markers from the buffer.
+    const filterTail = reasoningFilter.flush();
+    fullResponseText += filterTail;
+    ttsBuffer += filterTail;
     ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
     if (ttsBuffer.length > 0) {
       emitSafeChunk(ttsBuffer);

package/src/config/bundled-skills/settings/tools/navigate-settings-tab.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import type { ToolContext } from "../../../../tools/types.js";
+import { run } from "./navigate-settings-tab.js";
+
+let sentMessages: Array<{ type: string; [key: string]: unknown }> = [];
+
+function makeContext(overrides?: Partial<ToolContext>): ToolContext {
+  return {
+    workingDir: "/tmp",
+    conversationId: "conv-xyz",
+    trustClass: "guardian",
+    sendToClient: (msg) => {
+      sentMessages.push(msg);
+    },
+    ...overrides,
+  };
+}
+
+describe("navigate_settings_tab tool", () => {
+  beforeEach(() => {
+    sentMessages = [];
+  });
+
+  test("navigates to the Voice tab and hints the inline picker", async () => {
+    const result = await run({ tab: "Voice" }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(sentMessages).toEqual([{ type: "navigate_settings", tab: "Voice" }]);
+    expect(result.content).toStartWith("Opened settings to the Voice tab.");
+    expect(result.content).toContain(
+      'ui_show { surface_type: "voice_picker", data: {} }',
+    );
+  });
+
+  test("leaves a non-Voice tab's result unchanged", async () => {
+    const result = await run({ tab: "Billing" }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(sentMessages).toEqual([
+      { type: "navigate_settings", tab: "Billing" },
+    ]);
+    expect(result.content).toBe("Opened settings to the Billing tab.");
+    expect(result.content).not.toContain("voice_picker");
+  });
+
+  test("resolves legacy tab aliases without hinting", async () => {
+    const result = await run({ tab: "Archived Conversations" }, makeContext());
+
+    expect(result.isError).toBe(false);
+    expect(sentMessages).toEqual([
+      { type: "navigate_settings", tab: "Archive" },
+    ]);
+    expect(result.content).toBe("Opened settings to the Archive tab.");
+    expect(result.content).not.toContain("voice_picker");
+  });
+
+  test("rejects an unknown tab without navigating", async () => {
+    const result = await run({ tab: "Telepathy" }, makeContext());
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('unknown tab "Telepathy"');
+    expect(sentMessages).toEqual([]);
+  });
+});

package/src/config/bundled-skills/settings/tools/navigate-settings-tab.ts

@@ -2,6 +2,7 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
+import { voicePickerHint } from "./shared.js";
 
 const SETTINGS_TABS = [
   "General",
@@ -23,6 +24,10 @@ const LEGACY_TAB_ALIASES: Record<string, SettingsTab> = {
   "Archived Conversations": "Archive",
 };
 
+const VOICE_TAB_PICKER_HINT = voicePickerHint(
+  "which puts the picker in the conversation without navigating away. Navigating here is right only when the user explicitly asked to open Settings.",
+);
+
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -45,8 +50,9 @@ export async function run(
     });
   }
 
+  const opened = `Opened settings to the ${tab} tab.`;
   return {
-    content: `Opened settings to the ${tab} tab.`,
+    content: tab === "Voice" ? `${opened} ${VOICE_TAB_PICKER_HINT}` : opened,
     isError: false,
   };
 }

package/src/config/bundled-skills/settings/tools/shared.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared helpers for the settings skill's tool executors.
+ */
+
+/**
+ * Steer the model back to the inline voice picker.
+ *
+ * Both settings tools a "change my voice" request can land on (the Voice tab
+ * navigation and a managed `tts_voice_id` write) end by naming the picker, so
+ * the invocation itself lives here: one edit keeps both tools teaching the same
+ * call. Each caller supplies its own tail, because the reason the picker is
+ * better differs by the tool the model just reached for.
+ */
+export function voicePickerHint(tail: string): string {
+  return `Next time the user wants to change or hear a voice, prefer \`ui_show { surface_type: "voice_picker", data: {} }\`, ${tail}`;
+}

package/src/config/bundled-skills/settings/tools/voice-config-update.ts

@@ -19,6 +19,7 @@ import {
 } from "../../../loader.js";
 import { VALID_CONVERSATION_TIMEOUTS } from "../../../schemas/elevenlabs.js";
 import { VALID_STT_PROVIDERS } from "../../../schemas/stt.js";
+import { voicePickerHint } from "./shared.js";
 
 /**
  * Valid voice config settings and their UserDefaults key mappings.
@@ -187,6 +188,19 @@ const STT_LANGUAGE_ALIASES: Record<
   "code-switching": "multi",
 };
 
+/**
+ * Same steer `navigate_settings_tab` puts on the Voice tab, applied to the
+ * strongest competing affordance: this tool's description coaches the model to
+ * read the managed catalog and set `tts_voice_id` itself, which is exactly the
+ * "assistant names voices in prose" outcome the inline picker exists to
+ * replace. Managed only, because that is the catalog the picker renders. The
+ * write still happens and the result stays non-error; this only redirects the
+ * next request.
+ */
+const MANAGED_VOICE_PICKER_HINT = voicePickerHint(
+  "which lets them hear and pick from the managed catalog in the conversation. Set the id here only when the user named a specific voice.",
+);
+
 function validateSetting(
   setting: string,
   value: unknown,
@@ -530,10 +544,14 @@ export async function run(
     AUTO_DETECT_STT_PROVIDERS.has(activeSttProviderId)
       ? ` Note: the configured STT provider (${activeSttProviderId}) auto-detects the spoken language natively and ignores this setting.`
       : "";
+  const pickerNote =
+    setting === "tts_voice_id" && activeTtsProviderId === "vellum"
+      ? ` ${MANAGED_VOICE_PICKER_HINT}`
+      : "";
   return {
     content: `${friendlyName} updated to ${JSON.stringify(
       validation.coerced,
-    )}.${broadcastNote}${autoDetectNote}`,
+    )}.${broadcastNote}${autoDetectNote}${pickerNote}`,
     isError: false,
   };
 }

package/src/config/default-profile-catalog.ts

@@ -98,7 +98,7 @@ const VELLUM_PROFILE_IMPLS: ProfileImpls = {
     },
   },
   "cost-optimized": {
-    model: "accounts/fireworks/models/deepseek-v4-flash",
+    model: "accounts/fireworks/models/deepseek-v4-flash-0731",
     provider: "vellum",
     source: "managed",
     label: "Cost",

package/src/daemon/conversation-process.ts

@@ -60,6 +60,7 @@ import {
 } from "./conversation-slash.js";
 import { getModelInfo } from "./handlers/config-model.js";
 import { preactivateHostProxySkills } from "./host-proxy-preactivation.js";
+import { bindInteractiveTurnSender } from "./interactive-turn-sender.js";
 import type { UserMessageAttachment } from "./message-protocol.js";
 import { buildTransportHints } from "./transport-hints.js";
 import { sameTrustIdentity, type TrustContext } from "./trust-context-types.js";
@@ -1292,11 +1293,26 @@ async function drainSingleMessage(
     drainLoopOptions.isHiddenPrompt = true;
   }
 
+  // By the time the drain runs, the conversation-level sender is usually the
+  // no-op the just-finished interactive turn's restore (or conversation
+  // birth) left behind, and the drain bypasses `processMessage`, so without
+  // a fresh bind the PermissionPrompter's confirmation_request (which reads
+  // the conversation-level sender, not the turn's `onEvent`) would be
+  // emitted into nothing and hang until the permission timeout. Same
+  // bind/restore contract as `processMessage`.
+  const restoreSender =
+    next.isInteractive === true
+      ? bindInteractiveTurnSender(conversation)
+      : undefined;
+
   conversation
     .runAgentLoop(agentLoopContent, userMessageId, {
       ...drainLoopOptions,
       onEvent: next.onEvent,
     })
+    .finally(() => {
+      restoreSender?.();
+    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -1779,6 +1795,14 @@ async function drainBatch(
     drainLoopOptions.isHiddenPrompt = true;
   }
 
+  // Same sender contract as drainSingleMessage: an interactive drained batch
+  // must rebind the conversation-level sender or prompter confirmations
+  // raised during this turn reach no client.
+  const restoreSender =
+    drainLoopOptions.isInteractive === true
+      ? bindInteractiveTurnSender(conversation)
+      : undefined;
+
   // Fire-and-forget: runAgentLoop's finally block recursively calls drainQueue
   // when this run completes. Mirrors drainSingleMessage.
   conversation
@@ -1786,6 +1810,9 @@ async function drainBatch(
       ...drainLoopOptions,
       onEvent: fanOutOnEvent,
     })
+    .finally(() => {
+      restoreSender?.();
+    })
     .catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
       log.error(

package/src/daemon/conversation-surfaces.ts

@@ -140,14 +140,28 @@ const MAX_UNDO_DEPTH = 10;
 
 /**
  * Pending surface types that do not hold the one-interactive-surface-at-a-time
- * lock. Both render content the user reads rather than a question they must
- * answer, so a live one must not block the next surface.
+ * lock. Each renders content the user reads (or settles on its own) rather
+ * than a question they must answer, so a live one must not block the next
+ * surface.
  */
 const NON_BLOCKING_PENDING_SURFACE_TYPES = new Set<SurfaceType>([
   "dynamic_page",
   "visual",
+  "voice_picker",
 ]);
 
+/**
+ * Surface types that carry no terminal action: the card settles when the user
+ * interacts with it, so no click could ever satisfy an attached `actions`
+ * entry or an explicit `await_action`. Both are generic ui_show params though,
+ * so nothing stops the model attaching them here, and doing so wedges the
+ * turn: the client latches `awaiting_user_input` on the presence of actions
+ * alone and no action ever arrives to clear it, leaving the composer disabled
+ * and Stop hidden while the daemon is still streaming. Stripping them makes
+ * the "never blocks a turn" contract structural rather than advisory.
+ */
+const ACTIONLESS_SURFACE_TYPES = new Set<SurfaceType>(["voice_picker"]);
+
 /**
  * Debounce window for persisting `ui_surface_update` data back to the
  * message row. Surfaces typically receive bursts of updates (e.g. a
@@ -3279,8 +3293,12 @@ export async function surfaceProxyResolver(
       }
       inputActions = valid.length > 0 ? valid : undefined;
     }
-    const actions =
-      choiceData !== undefined ? buildChoiceActions(choiceData) : inputActions;
+    const isActionless = ACTIONLESS_SURFACE_TYPES.has(surfaceType);
+    const actions = isActionless
+      ? undefined
+      : choiceData !== undefined
+        ? buildChoiceActions(choiceData)
+        : inputActions;
     const hasActions = Array.isArray(actions) && actions.length > 0;
     if (surfaceType === "choice" && !hasActions) {
       return {
@@ -3332,7 +3350,11 @@ export async function surfaceProxyResolver(
           : surfaceType === "table"
             ? hasActions
             : INTERACTIVE_SURFACE_TYPES.includes(surfaceType);
-    const awaitAction = (input.await_action as boolean) ?? isInteractive;
+    // An explicit `await_action: true` is honored for every other type; an
+    // actionless surface has nothing to await, so it is forced false.
+    const awaitAction = isActionless
+      ? false
+      : ((input.await_action as boolean) ?? isInteractive);
 
     // Only one non-persistent interactive surface at a time. If another
     // surface is already awaiting user input, reject this one so the LLM

package/src/daemon/interactive-turn-sender.ts

@@ -0,0 +1,59 @@
+/**
+ * The interactive-turn sender contract, in one place.
+ *
+ * `Conversation.sendToClient` is conversation-level mutable state: born a
+ * no-op, bound to the SSE hub for the duration of an interactive turn, and
+ * restored when that turn ends. Some subsystems read this conversation-level
+ * sender instead of the turn's own `onEvent` sink; the `PermissionPrompter`
+ * is the load-bearing one, so a `confirmation_request` raised by a turn that
+ * never bound the sender is emitted into the no-op, reaches no client, and
+ * hangs until the permission timeout auto-denies. Every path that runs an
+ * interactive agent turn MUST therefore bind before the loop and restore
+ * after it. The queue drain bypasses `processMessage`, so it uses this
+ * helper directly.
+ *
+ * The restore is a snapshot of the sender state taken at bind time, not an
+ * unconditional reset to a no-op: a live binding that predated the turn
+ * (e.g. installed by the send route while a non-interactive turn was
+ * running) survives the turn, so out-of-turn producers that read the live
+ * sender (call transcript and completion notifiers) keep their client. In
+ * the ordinary interactive flow the snapshot is the no-op the previous
+ * turn's restore left behind, so restoring it is identical to the reset
+ * this contract has always performed. The restore is also identity-guarded:
+ * it only replaces the hub binding this contract installed, so a sender
+ * some other subsystem rebound mid-turn to anything else is left alone.
+ *
+ * TRANSITIONAL: this helper is the paved road for a pattern we want less
+ * of. Bind/restore of shared mutable sender state is why the drain, the
+ * compaction card, and the host-browser proxy have each needed their own
+ * restore step. The durable design is a per-turn sink threaded to the
+ * prompter and the other conversation-level-sender readers, at which point
+ * this module and every call site of it should be deleted. Prefer that
+ * refactor over adding new bind/restore call sites.
+ */
+
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
+import { getSubagentManager } from "../subagent/index.js";
+import type { Conversation } from "./conversation.js";
+
+/**
+ * Point the conversation-level sender (and the subagent parent sender) at
+ * the SSE hub for the duration of an interactive turn. Returns the restore
+ * closure the turn's cleanup must invoke.
+ */
+export function bindInteractiveTurnSender(
+  conversation: Conversation,
+): () => void {
+  const previousSender = conversation.getCurrentSender();
+  const previousHasNoClient = conversation.hasNoClient;
+  conversation.updateClient(broadcastMessage, false);
+  getSubagentManager().updateParentSender(
+    conversation.conversationId,
+    broadcastMessage,
+  );
+  return () => {
+    if (conversation.getCurrentSender() === broadcastMessage) {
+      conversation.updateClient(previousSender, previousHasNoClient);
+    }
+  };
+}

package/src/daemon/process-message.ts

@@ -34,7 +34,6 @@ import { updateMetaFile } from "../persistence/conversation-disk-view.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
-import { getSubagentManager } from "../subagent/index.js";
 import {
   readTurnFailure,
   type TurnFailure,
@@ -70,6 +69,7 @@ import {
   preactivateHostProxySkills,
   shouldAttachHostProxyForCapability,
 } from "./host-proxy-preactivation.js";
+import { bindInteractiveTurnSender } from "./interactive-turn-sender.js";
 import type { SubagentToolGateMode } from "./tool-setup-types.js";
 import { restingTrust } from "./trust-context-types.js";
 
@@ -709,10 +709,10 @@ export async function processMessage(
     };
   }
 
-  if (options?.isInteractive === true) {
-    conversation.updateClient(broadcastMessage, false);
-    getSubagentManager().updateParentSender(conversationId, broadcastMessage);
-  }
+  const restoreSender =
+    options?.isInteractive === true
+      ? bindInteractiveTurnSender(conversation)
+      : undefined;
 
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   try {
@@ -731,12 +731,7 @@ export async function processMessage(
     });
   } finally {
     restoreToolScope();
-    if (
-      options?.isInteractive === true &&
-      conversation.getCurrentSender() === broadcastMessage
-    ) {
-      conversation.updateClient(() => {}, true);
-    }
+    restoreSender?.();
   }
 
   // Read the just-finished turn's outcome from the stamp `runAgentLoop`'s
@@ -795,10 +790,10 @@ export async function processMessageInBackground(
     return { messageId };
   }
 
-  if (options?.isInteractive === true) {
-    conversation.updateClient(broadcastMessage, false);
-    getSubagentManager().updateParentSender(conversationId, broadcastMessage);
-  }
+  const restoreSender =
+    options?.isInteractive === true
+      ? bindInteractiveTurnSender(conversation)
+      : undefined;
 
   const restoreToolScope = applyTurnToolAllowlist(conversation, options);
   conversation
@@ -814,12 +809,7 @@ export async function processMessageInBackground(
     })
     .finally(() => {
       restoreToolScope();
-      if (
-        options?.isInteractive === true &&
-        conversation.getCurrentSender() === broadcastMessage
-      ) {
-        conversation.updateClient(() => {}, true);
-      }
+      restoreSender?.();
     })
     .catch((err) => {
       log.error({ err, conversationId }, "Background agent loop failed");

package/src/plugin-api/vision-support.test.ts

@@ -107,7 +107,7 @@ describe("doesSupportVision", () => {
       managed: { provider: "vellum", model: "claude-fable-5" },
       "managed-text": {
         provider: "vellum",
-        model: "accounts/fireworks/models/deepseek-v4-flash",
+        model: "accounts/fireworks/models/deepseek-v4-flash-0731",
       },
     });
     expect(doesSupportVision(profile("managed"))).toBe(true);

package/src/providers/model-catalog.ts

@@ -939,7 +939,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
       {
-        id: "accounts/fireworks/models/deepseek-v4-flash",
+        id: "accounts/fireworks/models/deepseek-v4-flash-0731",
         displayName: "DeepSeek V4 Flash",
         contextWindowTokens: 1040000,
         maxOutputTokens: 131072,
@@ -951,11 +951,11 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         pricing: {
           inputPer1mTokens: 0.14,
           outputPer1mTokens: 0.28,
-          cacheReadPer1mTokens: 0.03,
+          cacheReadPer1mTokens: 0.028,
         },
       },
     ],
-    defaultModel: "accounts/fireworks/models/deepseek-v4-flash",
+    defaultModel: "accounts/fireworks/models/deepseek-v4-flash-0731",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",
     apiKeyPlaceholder: "fw_...",
   },

package/src/providers/model-intents.ts

@@ -46,8 +46,8 @@ const PROVIDER_MODEL_INTENTS: Record<string, Record<ModelIntent, string>> = {
   },
   fireworks: {
     balanced: "accounts/fireworks/models/minimax-m3",
-    "cost-optimized": "accounts/fireworks/models/deepseek-v4-flash",
-    "latency-optimized": "accounts/fireworks/models/deepseek-v4-flash",
+    "cost-optimized": "accounts/fireworks/models/deepseek-v4-flash-0731",
+    "latency-optimized": "accounts/fireworks/models/deepseek-v4-flash-0731",
     "quality-optimized": "accounts/fireworks/models/kimi-k2p6",
     "vision-optimized": "accounts/fireworks/models/kimi-k2p6",
   },

package/src/providers/openai/chat-completions-provider.ts

@@ -5,6 +5,7 @@ import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError, type ProviderErrorReason } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
+import { partialTagSuffix as sharedPartialTagSuffix } from "../../util/think-tag-stream.js";
 import { escapeXmlAttr } from "../../util/xml.js";
 import {
   base64Source,
@@ -293,13 +294,11 @@ const OPENAI_SUPPORTED_IMAGE_TYPES = new Set([
   "image/webp",
 ]);
 
+// Think-tag scanning primitives are shared with the TTS reasoning filter
+// (util/think-tag-stream.ts) so the two stream parsers cannot drift. This
+// provider keeps its exact historical behavior: case-sensitive, <think> only.
 function partialTagSuffix(text: string, tag: string): number {
-  for (let len = Math.min(text.length, tag.length - 1); len > 0; len--) {
-    if (text.endsWith(tag.substring(0, len))) {
-      return len;
-    }
-  }
-  return 0;
+  return sharedPartialTagSuffix(text, [tag], false);
 }
 
 /**

package/src/tools/ui-surface/surface-shape-docs.ts

@@ -211,6 +211,17 @@ export const SURFACE_SHAPE_DOCS: Record<string, SurfaceShapeDoc> = {
         ? null
         : '`data.channel` must be one of "slack", "telegram", "phone"',
   },
+  voice_picker: {
+    // The steering lives in `purpose` because that is the only part of a cold
+    // type the model ever sees: `shape` ships solely inside a teaching error,
+    // and an empty payload has no missing-content state to raise one. The
+    // surface exists to replace prose voice tours, so losing the directive
+    // would leave nothing but a renderer nobody invokes.
+    purpose:
+      "inline picker for the voice the assistant speaks in; show it when the user asks to change, hear, or pick a voice rather than describing voices in prose or sending them to Settings; attach no actions and never set await_action; during a live voice call answer in speech instead, the room already carries its own picker",
+    shape:
+      "{}: no payload, the card reads the current voice and the catalog itself. Selecting a voice applies on the assistant's next spoken turn",
+  },
 };
 
 /** Model-facing surface_type enum, derived so docs and schema cannot drift. */

package/src/tts/__tests__/reasoning-tag-filter.test.ts

@@ -60,4 +60,19 @@ describe("ReasoningTagFilter", () => {
   test("holds back nothing across an empty stream", () => {
     expect(run([""])).toBe("");
   });
+
+  test("does not shift indexes for characters whose lowercase form is longer", () => {
+    // U+0130 (dotted capital I) lowers to two code units; positional
+    // scanning must never lowercase the haystack wholesale.
+    expect(run(["\u0130stanbul rocks. <think>hidden</think> Done."])).toBe(
+      "\u0130stanbul rocks.  Done.",
+    );
+    expect(run(["\u0130\u0130\u0130<THINK>x</THINK>ok"])).toBe(
+      "\u0130\u0130\u0130ok",
+    );
+  });
+
+  test("prefers the longer tag when both match at one index", () => {
+    expect(run(["a<thinking>x</thinking>b"])).toBe("ab");
+  });
 });

package/src/tts/reasoning-tag-filter.ts

@@ -18,39 +18,18 @@
  * Display paths are deliberately untouched: `assistant_text_delta` frames
  * keep the raw text, exactly like the markdown handling in
  * `calls/tts-text-sanitizer.ts`.
+ *
+ * Tag scanning lives in `util/think-tag-stream.ts`, shared with the
+ * chat-completions provider's think-tag router, and is positionally exact
+ * on the original string (no full-string lowercasing, which shifts indexes
+ * for characters like the dotted capital I).
  */
 
+import { indexOfTag, partialTagSuffix } from "../util/think-tag-stream.js";
+
 const OPEN_TAGS = ["<think>", "<thinking>"] as const;
 const CLOSE_TAGS = ["</think>", "</thinking>"] as const;
 
-/** Longest suffix of `text` that is a proper prefix of any listed tag. */
-function partialTagSuffix(text: string, tags: readonly string[]): number {
-  const max = Math.max(...tags.map((tag) => tag.length)) - 1;
-  const window = Math.min(max, text.length);
-  for (let len = window; len > 0; len -= 1) {
-    const suffix = text.slice(text.length - len).toLowerCase();
-    if (tags.some((tag) => tag.startsWith(suffix))) {
-      return len;
-    }
-  }
-  return 0;
-}
-
-function indexOfAny(
-  haystack: string,
-  tags: readonly string[],
-): { index: number; tag: string } | null {
-  const lower = haystack.toLowerCase();
-  let best: { index: number; tag: string } | null = null;
-  for (const tag of tags) {
-    const index = lower.indexOf(tag);
-    if (index >= 0 && (best === null || index < best.index)) {
-      best = { index, tag };
-    }
-  }
-  return best;
-}
-
 export class ReasoningTagFilter {
   private insideReasoning = false;
   private pending = "";
@@ -65,7 +44,7 @@ export class ReasoningTagFilter {
     let out = "";
     for (;;) {
       if (this.insideReasoning) {
-        const close = indexOfAny(this.pending, CLOSE_TAGS);
+        const close = indexOfTag(this.pending, CLOSE_TAGS, true);
         if (close) {
           this.pending = this.pending.slice(close.index + close.tag.length);
           this.insideReasoning = false;
@@ -73,18 +52,18 @@ export class ReasoningTagFilter {
         }
         // Everything buffered is reasoning except a possible partial close
         // tag at the end; drop the reasoning, keep the partial.
-        const partial = partialTagSuffix(this.pending, CLOSE_TAGS);
+        const partial = partialTagSuffix(this.pending, CLOSE_TAGS, true);
         this.pending = partial > 0 ? this.pending.slice(-partial) : "";
         return out;
       }
-      const open = indexOfAny(this.pending, OPEN_TAGS);
+      const open = indexOfTag(this.pending, OPEN_TAGS, true);
       if (open) {
         out += this.pending.slice(0, open.index);
         this.pending = this.pending.slice(open.index + open.tag.length);
         this.insideReasoning = true;
         continue;
       }
-      const partial = partialTagSuffix(this.pending, OPEN_TAGS);
+      const partial = partialTagSuffix(this.pending, OPEN_TAGS, true);
       const safeLength = this.pending.length - partial;
       out += this.pending.slice(0, safeLength);
       this.pending = partial > 0 ? this.pending.slice(safeLength) : "";