@vellumai/assistant 0.11.3-dev.202608132218.8ea1f84 → 0.11.3-dev.202608140136.76df6b7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.3-dev.202608132218.8ea1f84",
+  "version": "0.11.3-dev.202608140136.76df6b7",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/app-compiler.test.ts

@@ -20,6 +20,7 @@ import {
   packageName,
   resolvePackage,
 } from "../bundler/package-resolver.js";
+import { ensureBun } from "../util/bun-runtime.js";
 
 // ---------------------------------------------------------------------------
 // Shared temp directory
@@ -56,6 +57,29 @@ async function scaffold(
   return appDir;
 }
 
+/**
+ * Download `pkg` into bun's global module cache via a throwaway install.
+ *
+ * `resolvePackage` bounds its own install at INSTALL_TIMEOUT_MS (10s), which a
+ * cold global cache can exceed for a large package on a slow network. Priming
+ * first is unbounded, so the install the test measures resolves from cache and
+ * stays well inside that bound.
+ */
+async function primeBunCache(pkg: string): Promise<void> {
+  const primeDir = join(tempDir, `prime-${pkg.replaceAll(/[^a-z0-9]/gi, "-")}`);
+  await mkdir(primeDir, { recursive: true });
+  await writeFile(
+    join(primeDir, "package.json"),
+    JSON.stringify({ name: "prime-cache", private: true }),
+  );
+  const proc = Bun.spawn([await ensureBun(), "install", "--no-save", pkg], {
+    cwd: primeDir,
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+  await proc.exited;
+}
+
 const MINIMAL_HTML = `<!DOCTYPE html>
 <html>
 <head><title>Test</title></head>
@@ -466,10 +490,21 @@ describe("package-resolver", () => {
     expect(ALLOWED_PACKAGES).toContain("clsx");
   });
 
-  // `lucide` (the vanilla package) unpacks to ~29 MB, far above the resolver's
-  // size cap, so it is installed then deleted and never resolves. It also
-  // exports icon data arrays, not Preact components. Apps use inline SVG.
+  // `lucide` (the vanilla package) exports icon data arrays, not Preact
+  // components, and unpacks to ~29 MB for no benefit. Apps use inline SVG.
   test("ALLOWED_PACKAGES excludes lucide", () => {
     expect(ALLOWED_PACKAGES).not.toContain("lucide");
   });
+
+  // `chart.js` is a large allowlisted package: it must install into the shared
+  // cache and resolve so apps importing it can compile.
+  test("resolvePackage installs a large allowlisted package", async () => {
+    await primeBunCache("chart.js");
+
+    const result = await resolvePackage("chart.js");
+    expect(result).not.toBeNull();
+    expect(existsSync(join(getCacheDir(), "node_modules", "chart.js"))).toBe(
+      true,
+    );
+  }, 60_000);
 });

package/src/__tests__/mtime-cache.test.ts

@@ -30,10 +30,10 @@ import {
 } from "bun:test";
 
 import { _inspectHookCacheForTests } from "../hooks/hook-loader.js";
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
   _inspectToolCacheForTests,
   getCachedUserTools,
-  getUserHooksFor,
   populateCacheAtBoot,
   reconcilePluginSourcesNow,
   resetPluginCacheForTests,

package/src/__tests__/plugin-secret-pattern-contribution.test.ts

@@ -34,8 +34,8 @@ import {
 } from "bun:test";
 
 import { bootstrapPlugins } from "../daemon/external-plugins-bootstrap.js";
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
-  getUserHooksFor,
   populateCacheAtBoot,
   reconcilePluginSourcesNow,
   resetPluginCacheForTests,

package/src/__tests__/user-plugin-loader.test.ts

@@ -23,9 +23,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
   getCachedUserTools,
-  getUserHooksFor,
   resetPluginCacheForTests,
 } from "../plugins/mtime-cache.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";

package/src/bundler/package-resolver.ts

@@ -6,7 +6,7 @@
  */
 
 import { existsSync } from "node:fs";
-import { mkdir, stat } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 
 import { ensureBun } from "../util/bun-runtime.js";
@@ -24,8 +24,8 @@ export const ALLOWED_PACKAGES: readonly string[] = [
   "clsx",
 ] as const;
 
+/** Bounds a runaway install; the allowlist above bounds what may be installed. */
 const INSTALL_TIMEOUT_MS = 10_000;
-const MAX_PACKAGE_SIZE_BYTES = 5 * 1024 * 1024; // 5 MB
 
 /** In-flight install promises keyed by package name, to deduplicate concurrent requests. */
 const inflight = new Map<string, Promise<string | null>>();
@@ -148,37 +148,9 @@ async function installPackage(
       return null;
     }
 
-    // Enforce max size
-    if (existsSync(pkgDir)) {
-      const size = await dirSize(pkgDir);
-      if (size > MAX_PACKAGE_SIZE_BYTES) {
-        log.warn({ pkg, size }, "Package exceeds size limit, removing");
-        const { rm } = await import("node:fs/promises");
-        await rm(pkgDir, { recursive: true, force: true });
-        return null;
-      }
-    }
-
     return existsSync(pkgDir) ? nodeModulesDir : null;
   } catch (err) {
     log.warn({ pkg, err }, "Package resolution failed");
     return null;
   }
 }
-
-/** Recursively sum file sizes under a directory. */
-async function dirSize(dir: string): Promise<number> {
-  const { readdir } = await import("node:fs/promises");
-  const entries = await readdir(dir, { withFileTypes: true });
-  let total = 0;
-  for (const entry of entries) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      total += await dirSize(full);
-    } else {
-      const s = await stat(full);
-      total += s.size;
-    }
-  }
-  return total;
-}

package/src/calls/call-controller.ts

@@ -21,6 +21,7 @@ import type { TrustContext } from "../daemon/trust-context-types.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { computeToolApprovalDigest } from "../security/tool-approval-digest.js";
 import { getCatalogProvider } from "../tts/provider-catalog.js";
+import { createReasoningTagFilter } from "../tts/reasoning-tag-filter.js";
 import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import {
   type AudioStoreSink,
@@ -728,6 +729,10 @@ export class CallController {
     // could be the start of a control marker.
     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.
+    const reasoningFilter = createReasoningTagFilter();
 
     // Synthesized path: text is split at speakable boundaries as it streams
     // and each segment is synthesized while the LLM keeps generating. The
@@ -931,7 +936,7 @@ export class CallController {
           return;
         }
         fullResponseText += text;
-        ttsBuffer += text;
+        ttsBuffer += reasoningFilter.push(text);
         ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
         flushSafeText();
       };
@@ -1010,7 +1015,9 @@ export class CallController {
       return fullResponseText;
     }
 
-    // Final sweep: strip any remaining control markers from the buffer
+    // Final sweep: release any held-back partial tag, then strip any
+    // remaining control markers from the buffer.
+    ttsBuffer += reasoningFilter.flush();
     ttsBuffer = stripInternalSpeechMarkers(ttsBuffer);
     if (ttsBuffer.length > 0) {
       emitSafeChunk(ttsBuffer);

package/src/hooks/hook-loader.ts

@@ -39,9 +39,9 @@
  * registry, so the next read re-resolves fresh.
  *
  * Plugin *discovery* (which plugin directories exist, in what order) lives in
- * `../plugins/mtime-cache.ts`; the orchestrator there passes the discovered
- * directories into {@link collectUserHookEntries}. Keeping discovery out of
- * this module lets it sit below the plugin cache with no import cycle.
+ * `../plugins/mtime-cache.ts`; hook lookup in `./registry.ts` passes the
+ * discovered names into {@link collectUserHookEntries}. Keeping discovery out
+ * of this module lets it sit below the plugin cache with no import cycle.
  */
 
 import {

package/src/hooks/registry.ts

@@ -6,20 +6,22 @@
  * hook-chain ordering.
  *
  * User-land hooks (from the filesystem) are owned by
- * {@link ./hook-loader.ts} and surfaced through `getUserHooksFor` in
- * `plugins/mtime-cache.ts`. This module owns only the in-process hooks that
- * default plugins register at boot.
+ * {@link ./hook-loader.ts} and surfaced through {@link getUserHooksFor}.
+ * This module owns the in-process hooks that default plugins register at
+ * boot, plus the user-land lookup that walks discovered plugin names from
+ * the plugin cache.
  *
  * {@link getHooksFor} combines both sources: in-process hooks from this
  * registry (filtered by `isPluginDisabled` at read time) and user-land hooks
  * from the plugin cache. The read-time filtering is what makes `assistant
- * plugins disable default-*` take effect immediately in a running assistant
- * — the hooks stay registered but are filtered out on the next turn.
+ * plugins disable default-*` take effect immediately in a running assistant:
+ * the hooks stay registered but are filtered out on the next turn.
  */
 
 import { isPluginDisabled } from "../plugins/disabled-state.js";
-import { getUserHookEntriesFor } from "../plugins/mtime-cache.js";
+import { getDiscoveredUserPluginNames } from "../plugins/mtime-cache.js";
 import type { HookEntry, HookFunction } from "../plugins/types.js";
+import { collectUserHookEntries } from "./hook-loader.js";
 
 // ─── Internal state ──────────────────────────────────────────────────────────
 
@@ -75,6 +77,48 @@ export function unregisterPluginHooks(pluginName: string): void {
 
 // ─── Queries ─────────────────────────────────────────────────────────────────
 
+/**
+ * Get all hooks for a given event name from user plugins and standalone
+ * workspace hooks, from the hook loader's in-memory cache. Plugin hooks run
+ * in install-date order, the workspace hook runs last.
+ *
+ * This is a pure cache read: it never scans disk, activates a plugin, or
+ * runs `init`. Activation happens only at boot (`populateCacheAtBoot`)
+ * and through the imperative install/uninstall poke
+ * (`reconcilePluginSourcesNow`), both main-daemon paths, so a
+ * sidecar process that dispatches hooks (a worker running conversation
+ * turns) can never bring a plugin up in its own process.
+ *
+ * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null,
+ * user plugins outside the set are skipped (standalone workspace hooks always
+ * run). `null`/omitted means no per-chat restriction.
+ */
+export async function getUserHookEntriesFor<TCtx = unknown>(
+  hookName: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): Promise<HookEntry<TCtx>[]> {
+  return collectUserHookEntries<TCtx>(
+    hookName,
+    getDiscoveredUserPluginNames(),
+    effectiveEnabledPlugins,
+  );
+}
+
+/**
+ * {@link getUserHookEntriesFor} without owner attribution. Returns just the
+ * hook functions in the same order.
+ */
+export async function getUserHooksFor<TCtx = unknown>(
+  hookName: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): Promise<HookFunction<TCtx>[]> {
+  const entries = await getUserHookEntriesFor<TCtx>(
+    hookName,
+    effectiveEnabledPlugins,
+  );
+  return entries.map((e) => e.fn);
+}
+
 /**
  * Collect every registered hook for the given name, in registration order.
  * Plugins that don't declare a hook for `name` are skipped. Used by the

package/src/live-voice/live-voice-session.ts

@@ -73,6 +73,10 @@ import type {
 import { getSubagentManager } from "../subagent/index.js";
 import { liveVoiceEndScreen } from "../telemetry/live-voice-funnel.js";
 import { getToolOwner } from "../tools/registry.js";
+import {
+  createReasoningTagFilter,
+  type ReasoningTagFilter,
+} from "../tts/reasoning-tag-filter.js";
 import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { hasLocalizedEntry } from "../util/language-subtag.js";
@@ -717,6 +721,10 @@ interface ActiveAssistantTurn {
   // the hand-off idempotent.
   escalationHandedOff: boolean;
   ttsBuffer: string;
+  // Strips inline <think> reasoning spans from the spoken stream. Stateful
+  // per turn because spans and tags cross delta boundaries; display frames
+  // keep the raw text.
+  ttsReasoningFilter: ReasoningTagFilter;
   // A non-empty speakable segment reached the TTS queue — gates the eager
   // first-segment flush that trades clause quality for speech onset.
   ttsSegmentEnqueued: boolean;
@@ -4503,6 +4511,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       deltaEpoch: 0,
       escalationHandedOff: false,
       ttsBuffer: "",
+      ttsReasoningFilter: createReasoningTagFilter(),
       ttsSegmentEnqueued: false,
       ttsJobs: [],
       ttsQueue: Promise.resolve(),
@@ -5492,7 +5501,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
-    activeTurn.ttsBuffer += text;
+    activeTurn.ttsBuffer += activeTurn.ttsReasoningFilter.push(text);
     this.flushTtsBuffer(token, false);
   }
 
@@ -5503,6 +5512,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }
 
     this.clearFillerTimers(activeTurn);
+    activeTurn.ttsBuffer += activeTurn.ttsReasoningFilter.flush();
     this.flushTtsBuffer(token, true);
     activeTurn.ttsQueue = activeTurn.ttsQueue
       .catch(() => {})

package/src/plugins/mtime-cache.ts

@@ -26,9 +26,9 @@
  * - Plugins are never "registered" as a unit — we register their tools into
  *   the global tool registry.
  *
- * Tools are populated at boot by `loadUserPlugins()`; `getHooksFor` reads
- * hooks on every dispatch via {@link getUserHookEntriesFor}, which resolves
- * each hook through the hook loader on demand.
+ * Tools are populated at boot by `loadUserPlugins()`; hook dispatch reads
+ * discovered plugin names from this cache via {@link getDiscoveredUserPluginNames}
+ * and resolves each hook through the hook loader on demand.
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
@@ -38,7 +38,6 @@ import type { Logger } from "pino";
 
 import {
   clearPluginHooks,
-  collectUserHookEntries,
   evictHooksForOwner,
   hasWorkspaceHooks,
   type HookOwnerKind,
@@ -47,7 +46,7 @@ import {
   runShutdownHook,
   WORKSPACE_HOOKS_OWNER,
 } from "../hooks/hook-loader.js";
-import type { HookFunction, ShutdownReason } from "../plugin-api/types.js";
+import type { ShutdownReason } from "../plugin-api/types.js";
 import {
   registerPluginSecretPatterns,
   resetPluginSecretPatternsForTests,
@@ -76,11 +75,7 @@ import {
   importWithTimeout,
   setSurfaceImportTimeout,
 } from "./surface-import.js";
-import type { HookEntry, PluginCredentialKeyPattern } from "./types.js";
-
-// Re-export for type compat — consumers that import HookFunction from
-// the mtime cache module still resolve.
-export type { HookFunction } from "./types.js";
+import type { PluginCredentialKeyPattern } from "./types.js";
 
 const log = getLogger("plugin-mtime-cache");
 
@@ -206,48 +201,15 @@ let lastVersions: Record<string, PluginSourceVersion> = {};
 /** In-flight reconcile — concurrent imperative pokes await it rather than racing. */
 let reconcileInFlight: Promise<void> | null = null;
 
-// ─── Hook reads ──────────────────────────────────────────────────────────────
+// ─── Discovery reads ─────────────────────────────────────────────────────────
 
 /**
- * Get all hooks for a given event name from user plugins and standalone
- * workspace hooks, from the hook loader's in-memory cache. Plugin hooks run
- * in install-date order, the workspace hook runs last.
- *
- * This is a pure cache read: it never scans disk, activates a plugin, or
- * runs `init`. Activation happens only at boot ({@link populateCacheAtBoot})
- * and through the imperative install/uninstall poke
- * ({@link reconcilePluginSourcesNow}) — both main-daemon paths — so a
- * sidecar process that dispatches hooks (a worker running conversation
- * turns) can never bring a plugin up in its own process.
- *
- * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null,
- * user plugins outside the set are skipped (standalone workspace hooks always
- * run). `null`/omitted means no per-chat restriction.
+ * Plugin names currently in the discovery cache, in install-date order.
+ * Hook lookup in `hooks/registry.ts` walks this set; the cache itself does
+ * not resolve hooks.
  */
-export async function getUserHookEntriesFor<TCtx = unknown>(
-  hookName: string,
-  effectiveEnabledPlugins?: Set<string> | null,
-): Promise<HookEntry<TCtx>[]> {
-  return collectUserHookEntries<TCtx>(
-    hookName,
-    discoveredPluginDirs.values(),
-    effectiveEnabledPlugins,
-  );
-}
-
-/**
- * {@link getUserHookEntriesFor} without owner attribution — returns just the
- * hook functions in the same order.
- */
-export async function getUserHooksFor<TCtx = unknown>(
-  hookName: string,
-  effectiveEnabledPlugins?: Set<string> | null,
-): Promise<HookFunction<TCtx>[]> {
-  const entries = await getUserHookEntriesFor<TCtx>(
-    hookName,
-    effectiveEnabledPlugins,
-  );
-  return entries.map((e) => e.fn);
+export function getDiscoveredUserPluginNames(): Iterable<string> {
+  return discoveredPluginDirs.values();
 }
 
 // ─── Source-versions reconcile ───────────────────────────────────────────────

package/src/tools/registry.ts

@@ -431,7 +431,8 @@ export function unregisterPluginTools(pluginName: string): void {
  * {@link import("../plugins/mtime-cache.js").getActiveUserPluginTools} and diffs
  * the result into the registry: plugins that vanished are unregistered, new
  * plugins register, and a plugin whose per-tool source mtimes moved is
- * re-registered. Mirrors how hooks resolve through `getUserHookEntriesFor`.
+ * re-registered. Mirrors how hooks resolve through `getUserHookEntriesFor`
+ * in `hooks/registry.ts`.
  *
  * This is a pure read of the plugin cache — it does NOT reconcile the cache
  * against the source-versions sentinel, so it never activates a plugin or runs

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

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+
+import { createReasoningTagFilter } from "../reasoning-tag-filter.js";
+
+function run(chunks: string[]): string {
+  const filter = createReasoningTagFilter();
+  let out = "";
+  for (const chunk of chunks) {
+    out += filter.push(chunk);
+  }
+  out += filter.flush();
+  return out;
+}
+
+describe("ReasoningTagFilter", () => {
+  test("passes plain text through unchanged", () => {
+    expect(run(["Hello ", "there."])).toBe("Hello there.");
+  });
+
+  test("drops a complete think span within one delta", () => {
+    expect(run(["<think>hm, let me reason</think>Answer."])).toBe("Answer.");
+  });
+
+  test("drops a reasoning span crossing many deltas", () => {
+    expect(
+      run(["<thi", "nk>step one", " step two", "</th", "ink>Spoken reply"]),
+    ).toBe("Spoken reply");
+  });
+
+  test("drops thinking-tag variant and is case-insensitive", () => {
+    expect(run(["<Thinking>inner</Thinking>ok"])).toBe("ok");
+  });
+
+  test("keeps text before and after the span", () => {
+    expect(run(["Sure. <think>secret</think> Done."])).toBe("Sure.  Done.");
+  });
+
+  test("handles multiple spans in one turn", () => {
+    expect(run(["a<think>x</think>b", "<think>y", "z</think>c"])).toBe("abc");
+  });
+
+  test("an unclosed span at end of stream stays dropped", () => {
+    expect(run(["ok<think>never closes"])).toBe("ok");
+  });
+
+  test("a dangling partial open tag is released as literal text at flush", () => {
+    expect(run(["price <th"])).toBe("price <th");
+  });
+
+  test("a false partial that disambiguates to text is released", () => {
+    expect(run(["a <th", "ree-step plan"])).toBe("a <three-step plan");
+  });
+
+  test("does not touch angle brackets that are not think tags", () => {
+    expect(run(["use <b>bold</b> and x < y"])).toBe(
+      "use <b>bold</b> and x < y",
+    );
+  });
+
+  test("holds back nothing across an empty stream", () => {
+    expect(run([""])).toBe("");
+  });
+});

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

@@ -0,0 +1,110 @@
+/**
+ * Streaming reasoning-tag filter for the TTS pipelines.
+ *
+ * Some OpenAI-compatible reasoning models emit their chain of thought inline
+ * in the content stream as `<think>...</think>` (or `<thinking>...</thinking>`)
+ * spans. When a profile has not opted into the chat-completions provider's
+ * `parseThinkTags` (which re-routes those spans to `thinking_delta`), the raw
+ * reasoning rides `text_delta`, and anything downstream that speaks text
+ * deltas would read the model's inner monologue aloud and delay real speech
+ * by the full length of the reasoning.
+ *
+ * This filter is the TTS-boundary guard: voice output must never speak
+ * reasoning regardless of profile configuration. It is stateful because a
+ * tag or a reasoning span routinely crosses delta boundaries; feed every
+ * delta through {@link ReasoningTagFilter.push} and call
+ * {@link ReasoningTagFilter.flush} when the turn's stream ends.
+ *
+ * Display paths are deliberately untouched: `assistant_text_delta` frames
+ * keep the raw text, exactly like the markdown handling in
+ * `calls/tts-text-sanitizer.ts`.
+ */
+
+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 = "";
+
+  /**
+   * Feed one streamed delta; returns the speakable text it releases.
+   * Reasoning spans are dropped; a partial tag at the end of the buffer is
+   * held back until the next delta disambiguates it.
+   */
+  push(text: string): string {
+    this.pending += text;
+    let out = "";
+    for (;;) {
+      if (this.insideReasoning) {
+        const close = indexOfAny(this.pending, CLOSE_TAGS);
+        if (close) {
+          this.pending = this.pending.slice(close.index + close.tag.length);
+          this.insideReasoning = false;
+          continue;
+        }
+        // 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);
+        this.pending = partial > 0 ? this.pending.slice(-partial) : "";
+        return out;
+      }
+      const open = indexOfAny(this.pending, OPEN_TAGS);
+      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 safeLength = this.pending.length - partial;
+      out += this.pending.slice(0, safeLength);
+      this.pending = partial > 0 ? this.pending.slice(safeLength) : "";
+      return out;
+    }
+  }
+
+  /**
+   * End of stream: release any held-back partial. Outside a reasoning span a
+   * dangling "<thin" was ordinary text after all; inside one, the span never
+   * closed and its content stays dropped.
+   */
+  flush(): string {
+    const rest = this.insideReasoning ? "" : this.pending;
+    this.pending = "";
+    this.insideReasoning = false;
+    return rest;
+  }
+}
+
+export function createReasoningTagFilter(): ReasoningTagFilter {
+  return new ReasoningTagFilter();
+}