@bitkyc08/opencodex 2.67.0 → 2.68.0

package/src/responses/citation-markers.ts

@@ -16,6 +16,12 @@
  * Strip, do not translate. The `turnNviewN` ids are turn-scoped and opaque, and the
  * response carries no mapping from them to a URL, so there is nothing to convert them
  * into. Structured `url_citation` annotations are a separate path and are untouched.
+ *
+ * Only citation spans are stripped. The same delimiters carry other inline directives
+ * that the Codex App renders, such as `\uE200visualize\uE202{"path":…}\uE201` from the
+ * bundled visualize plugin (#6039). A span is a citation only when the keyword between
+ * START and its first SEPARATOR or END is one of `CITATION_KEYWORDS`; any other span
+ * passes through byte for byte.
  */
 
 /** Opens a citation span. */
@@ -25,6 +31,12 @@ export const CITATION_MARKER_SEPARATOR = "\uE202";
 /** Closes a citation span. */
 export const CITATION_MARKER_END = "\uE201";
 
+/**
+ * Keywords that mark a span as a ChatGPT citation. `filecite` is the uploaded-file variant
+ * of `cite` and uses the same `turnN…` reference grammar.
+ */
+const CITATION_KEYWORDS: readonly string[] = ["cite", "filecite"];
+
 /** True when the text contains any of the three delimiters. Cheap pre-check. */
 export function hasCitationMarker(text: string): boolean {
   return text.includes(CITATION_MARKER_START)
@@ -33,34 +45,15 @@ export function hasCitationMarker(text: string): boolean {
 }
 
 /**
- * Remove every complete `START … END` span from a whole string.
+ * Upper bound on the length of a span (START through END inclusive).
  *
- * A START with no END is left alone rather than truncating the remainder: an unterminated
- * marker is malformed input, and dropping everything after it would delete real answer
- * text. A stray SEPARATOR or END outside a span is also left alone for the same reason —
- * this function only removes what it can prove is a citation span.
+ * A real citation is `cite` plus a few turn-scoped ids, so it is far under this. Without a
+ * bound, a backend that emits a START and never terminates it makes the streaming filter
+ * withhold the rest of the response. A non-citation directive keeps later STARTs literal
+ * only within the same bound, so one unterminated directive cannot hide a real citation for
+ * the rest of the message.
  */
-export function stripCitationMarkers(text: string): string {
-  if (!text.includes(CITATION_MARKER_START)) return text;
-  // Walk START-delimited segments exactly like the streaming filter below: a START whose
-  // own segment (up to the next START) contains an END within the span bound is a span and
-  // is removed; a START that is superseded by another START before any END, or whose span
-  // exceeds MAX_CITATION_SPAN_LENGTH, is malformed text and stays verbatim. Pairing an
-  // earlier malformed START with a later span's END would delete real answer text and,
-  // worse, disagree with what the streaming deltas already emitted (#3843). The bound is
-  // shared with the streaming filter for the same reason: a span it has already released
-  // as over-bound must not be swallowed here when the END finally arrives.
-  let start = text.indexOf(CITATION_MARKER_START);
-  let out = text.slice(0, start);
-  while (start !== -1) {
-    const nextStart = text.indexOf(CITATION_MARKER_START, start + 1);
-    const segment = text.slice(start, nextStart === -1 ? text.length : nextStart);
-    const end = segment.indexOf(CITATION_MARKER_END, 1);
-    out += end === -1 || end + 1 > MAX_CITATION_SPAN_LENGTH ? segment : segment.slice(end + 1);
-    start = nextStart;
-  }
-  return out;
-}
+const MAX_CITATION_SPAN_LENGTH = 4_096;
 
 export interface CitationMarkerFilter {
   /** Feed one streaming delta; returns the portion safe to emit now. */
@@ -70,63 +63,137 @@ export interface CitationMarkerFilter {
 }
 
 /**
- * Upper bound on the length of a citation span (START through END inclusive), and therefore
- * on the text the streaming filter withholds for one unterminated START.
+ * Remove every complete citation span from a whole string.
  *
- * A real span is `cite` plus a few turn-scoped ids, so it is far under this. Without a
- * bound, a backend that emits a START and never terminates it makes `held` grow for the
- * whole response, and every later delta re-scans that accumulated prefix. The whole-string
- * strip applies the same bound so both paths classify a span identically regardless of how
- * the text was chunked.
+ * This runs the streaming filter over the whole text, so the bridge's re-stripped
+ * `output_text.done` always equals the concatenated deltas it already emitted (#3843).
+ * Anything that is not a complete citation span stays verbatim: an unterminated START, a
+ * stray SEPARATOR or END, and every non-citation directive.
  */
-const MAX_CITATION_SPAN_LENGTH = 4_096;
+export function stripCitationMarkers(text: string): string {
+  if (!text.includes(CITATION_MARKER_START)) return text;
+  const filter = createCitationMarkerFilter();
+  return filter.push(text) + filter.flush();
+}
 
 /**
- * Streaming filter.
+ * Streaming filter, as a per-character state machine so the result never depends on how the
+ * text was split into deltas.
  *
- * A marker can straddle a delta boundary — `\uE200cite` in one chunk and the rest in the
- * next — so a stateless per-delta strip would emit the tail of a span it never recognized.
- * This holds back the text from an unterminated START and releases it once the END arrives
- * (removed) or the stream ends (verbatim, so nothing the model actually said is lost).
+ * - `text`: ordinary text, emitted at once. A START opens `keyword`.
+ * - `keyword`: the START and keyword so far are withheld while the keyword can still become
+ *   a citation keyword. A SEPARATOR after a citation keyword enters `citation`; an END right
+ *   after one removes the span. Any other keyword releases the text and enters `other`.
+ * - `citation`: withheld until its END, then removed. A new START means this one was
+ *   malformed, so it is released verbatim; so is a span that reaches the length bound.
+ * - `other`: the keyword of a non-citation span, emitted at once. A START here means the
+ *   earlier one was malformed and opens a new span; a SEPARATOR enters `opaque`.
+ * - `opaque`: the body of a non-citation directive such as `visualize` (#6039), emitted at
+ *   once. STARTs inside it are payload, not new spans, until its END or the length bound.
  *
- * A span that grows past `MAX_CITATION_SPAN_LENGTH` is malformed ordinary text, so
- * it is released verbatim instead of withheld; a later START can still open a valid span.
+ * A stream that ends while text is withheld releases it verbatim, so nothing the model
+ * actually said is lost.
  */
 export function createCitationMarkerFilter(): CitationMarkerFilter {
-  // Text from an open START that has not been terminated yet.
+  let mode: "text" | "keyword" | "citation" | "other" | "opaque" = "text";
+  // The withheld START, keyword, and body in `keyword` and `citation` modes.
   let held = "";
+  // Characters from START so far in `other` and `opaque` modes.
+  let spanLength = 0;
+  const isKeywordPrefix = (keyword: string): boolean => CITATION_KEYWORDS.some(k => k.startsWith(keyword));
+
   return {
     push(delta: string): string {
-      const combined = held + delta;
-      held = "";
-      let start = combined.indexOf(CITATION_MARKER_START);
-      if (start === -1) return combined;
-      let out = combined.slice(0, start);
-      // Walk START-delimited segments independently so an earlier malformed START is never
-      // paired with a later span's END (the whole-string strip would do exactly that).
-      while (start !== -1) {
-        const nextStart = combined.indexOf(CITATION_MARKER_START, start + 1);
-        const segment = combined.slice(start, nextStart === -1 ? combined.length : nextStart);
-        const end = segment.indexOf(CITATION_MARKER_END, 1);
-        if (end !== -1 && end + 1 <= MAX_CITATION_SPAN_LENGTH) {
-          // A complete span: drop it, keep whatever trails it inside this segment.
-          out += segment.slice(end + 1);
-        } else if (end === -1 && nextStart === -1 && segment.length <= MAX_CITATION_SPAN_LENGTH) {
-          // Only a bounded trailing span can still be completed by a later delta.
-          held = segment;
-        } else {
-          // Superseded by a later START, or over the bound (with or without a late END):
-          // ordinary text, emitted verbatim so neither the retained text nor the per-delta
-          // rescan grows without limit.
-          out += segment;
+      let out = "";
+      let i = 0;
+      while (i < delta.length) {
+        if (mode === "text") {
+          const next = delta.indexOf(CITATION_MARKER_START, i);
+          if (next === -1) {
+            out += delta.slice(i);
+            break;
+          }
+          out += delta.slice(i, next);
+          held = CITATION_MARKER_START;
+          mode = "keyword";
+          i = next + 1;
+          continue;
+        }
+        const ch = delta[i]!;
+        if (mode === "other" || mode === "opaque") {
+          if (spanLength + 1 > MAX_CITATION_SPAN_LENGTH) {
+            // Past the bound this is ordinary text again; handle the character in `text`.
+            mode = "text";
+            continue;
+          }
+          if (ch === CITATION_MARKER_START && mode === "other") {
+            held = CITATION_MARKER_START;
+            mode = "keyword";
+          } else {
+            out += ch;
+            spanLength += 1;
+            if (ch === CITATION_MARKER_END) mode = "text";
+            else if (ch === CITATION_MARKER_SEPARATOR) mode = "opaque";
+          }
+          i += 1;
+          continue;
+        }
+        i += 1;
+        if (ch === CITATION_MARKER_START) {
+          // The withheld START was malformed: release it and open a new span here.
+          out += held;
+          held = CITATION_MARKER_START;
+          mode = "keyword";
+          continue;
+        }
+        if (mode === "citation") {
+          if (ch === CITATION_MARKER_END) {
+            held = "";
+            mode = "text";
+            continue;
+          }
+          held += ch;
+          // One more character plus an END would exceed the bound, so this is not a span.
+          if (held.length >= MAX_CITATION_SPAN_LENGTH) {
+            out += held;
+            held = "";
+            mode = "text";
+          }
+          continue;
+        }
+        // mode === "keyword"
+        if (ch === CITATION_MARKER_SEPARATOR || ch === CITATION_MARKER_END) {
+          if (CITATION_KEYWORDS.includes(held.slice(1))) {
+            if (ch === CITATION_MARKER_END) {
+              held = "";
+              mode = "text";
+            } else {
+              held += ch;
+              mode = "citation";
+            }
+          } else {
+            out += held + ch;
+            spanLength = held.length + 1;
+            held = "";
+            mode = ch === CITATION_MARKER_END ? "text" : "opaque";
+          }
+          continue;
+        }
+        held += ch;
+        if (!isKeywordPrefix(held.slice(1))) {
+          out += held;
+          spanLength = held.length;
+          held = "";
+          mode = "other";
         }
-        start = nextStart;
       }
       return out;
     },
     flush(): string {
       const rest = held;
       held = "";
+      spanLength = 0;
+      mode = "text";
       return rest;
     },
   };

package/src/responses/hosted-tool-policy.ts

@@ -1,11 +1,22 @@
-/** Hosted tools rejected by specific native model slugs or exact provider destinations. */
+/**
+ * Hosted tools rejected by specific native model slugs or exact provider destinations.
+ *
+ * Add a row only for a destination that refuses the tool itself.
+ */
 const UNSUPPORTED_HOSTED_TOOLS: ReadonlyArray<{
   match: (model: string, baseUrl?: string) => boolean;
   tools: ReadonlySet<string>;
 }> = [
   {
-    match: (model, baseUrl) => model === "grok-4.6"
-      && baseUrl?.replace(/\/+$/, "") === "https://opencode.ai/zen/go/v1",
+    // MiMo rejects hosted search with "tool type 'web_search' is not supported by this gateway phase" (#5501).
+    match: (_model, baseUrl) => {
+      if (!baseUrl) return false;
+      try {
+        return /(?:^|\.)xiaomimimo\.com$/i.test(new URL(baseUrl).hostname);
+      } catch {
+        return false;
+      }
+    },
     tools: new Set(["web_search", "web_search_preview"]),
   },
 ];

package/src/responses/parser-content.ts

@@ -9,7 +9,7 @@ type InputBlock =
   | { type: "input_text"; text: string }
   | { type: "text"; text: string }
   | { type: "input_image"; image_url?: string; file_id?: string; detail?: string }
-  | { type: "input_video"; video_url?: string }
+  | { type: "input_video"; video_url?: string; processing?: string }
   // codex-rs protocol/src/models.rs sends audio as input_audio with an audio_url.
   | { type: "input_audio"; audio_url?: string; format?: string }
   | { type: "input_file"; file_id?: string; filename?: string; file_data?: string };
@@ -62,7 +62,8 @@ export function inputContentParts(blocks: unknown): string | OcxContentPart[] {
       // the request never carried, which is worse than dropping malformed input.
     } else if (block.type === "input_video") {
       const videoUrl = nonEmptyString(block.video_url);
-      if (videoUrl) parts.push({ type: "video", videoUrl });
+      const processing = nonEmptyString((block as { processing?: string }).processing);
+      if (videoUrl) parts.push({ type: "video", videoUrl, ...(processing ? { processing } : {}) });
     } else if (block.type === "input_audio") {
       // Upstream Codex sends input_audio with an audio_url (codex-rs
       // protocol/src/models.rs). The IR has no audio carrier and no adapter consumes

package/src/responses/parser.ts

@@ -27,6 +27,7 @@ import { isObj, inputContentParts, outputTextOf, outputToToolResultContent, tool
 import { mapToolChoice, buildTools, customToolNamespaces } from "./parser-tools";
 import { parseTextFormat } from "./parser-text-format";
 import { externalTaskInputContent } from "./task-input";
+import { normalizeVisualizationContext } from "./visualization-directives";
 
 /**
  * Wrap a remembered proxy-side signature as provider metadata for a replayed tool call.
@@ -644,7 +645,9 @@ export function parseRequest(
   return {
     modelId: data.model,
     ...(data.previous_response_id ? { previousResponseId: data.previous_response_id } : {}),
-    context,
+    // Codex App visualization references in the private-use form are invisible to some models;
+    // hand every model the app's ASCII directive instead (visualization-directives.ts).
+    context: normalizeVisualizationContext(context),
     stream: data.stream === true,
     options,
     _rawBody: body,

package/src/responses/schema.ts

@@ -14,6 +14,10 @@ const inputImageBlockSchema = z.object({
 const inputVideoBlockSchema = z.object({
   type: z.literal("input_video"),
   video_url: z.string().min(1),
+  // Gemini agentic video understanding (#3271). z.object() strips unknown keys,
+  // so without declaring it here the mode is dropped before any adapter sees it
+  // and the request silently degrades to frame-by-frame decoding.
+  processing: z.string().min(1).optional(),
 });
 const inputFileBlockSchema = z.object({
   type: z.literal("input_file"),

package/src/responses/visualization-directives.ts

@@ -0,0 +1,182 @@
+/**
+ * Codex App visualization references for models that cannot see private-use characters.
+ *
+ * The bundled Visualize skill teaches the model to answer with
+ *
+ *     \uE200visualize\uE202{"path":"/abs/chart.html"}\uE201
+ *
+ * and the Codex App renders that span as an inline visualization. Some providers drop Basic
+ * Multilingual Plane private-use characters before the model sees them (every Claude route checked
+ * on 2026-09-27, direct and through Cursor), so the model reads and writes a bare
+ * `visualize{"path":...}` that the app shows verbatim.
+ *
+ * The app does not need the private-use form. Its own renderer rewrites each span into the plain
+ * directive `::codex-inline-vis{path="/abs/chart.html"}` before parsing, and it renders that
+ * directive when it appears directly. Rewriting the span the same way in model-visible text gives
+ * every model an ASCII instruction it can read and repeat.
+ *
+ * The rules mirror the app (26.924.22138, `f2` in app-shared) with two deliberate differences: code
+ * blocks are rewritten too, because the skill's example sits in a fenced block, and the skill's
+ * `<absolute-path>/<title>.html` placeholder is accepted so the model still sees the template.
+ * Matching follows the app's regex `/\uE200visualize\uE202([^\uE201]+)\uE201/g` exactly, scanned in
+ * linear time. Anything the app would keep as-is is kept as-is here.
+ *
+ * Only the parsed context is rewritten. The raw request body, which native passthrough serializes
+ * and which is stored for `previous_response_id` replay, is never touched.
+ */
+import { posix } from "node:path";
+import type { OcxContentPart, OcxContext, OcxMessage, OcxTextContent } from "../types";
+
+const START = "\uE200";
+const END = "\uE201";
+const PREFIX = `${START}visualize\uE202`;
+const INLINE_DIRECTIVE = "codex-inline-vis";
+const LIVE_DIRECTIVE = "codex-live-vis";
+/** The placeholder path in the Visualize skill's own template. */
+const TEMPLATE_PATH = "<absolute-path>/<title>.html";
+const HTML_BASENAME = /^[a-z0-9]+(?:-[a-z0-9]+)*\.html$/;
+const PARENT_SEGMENT = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+const UNSAFE_ATTRIBUTE = /["\n\r]/;
+
+/** The app's absolute-path test: POSIX (not `//`), drive letter, UNC with either slash. */
+function isAbsoluteAppPath(path: string): boolean {
+  return (path.startsWith("/") && !path.startsWith("//"))
+    || /^[A-Za-z]:[\\/]/.test(path)
+    || /^\\\\[^\\]+\\[^\\]+/.test(path)
+    || /^\/\/[^/]+\/[^/]+/.test(path);
+}
+
+interface VisualizationReference {
+  path: string | null;
+  title?: string;
+  type?: "inline" | "live";
+  mode?: "wide";
+}
+
+/** The app's payload schema: `path` is required but nullable; the rest are optional and typed. */
+function parseReference(value: unknown): VisualizationReference | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  if (!("path" in record) || (record.path !== null && typeof record.path !== "string")) return undefined;
+  if (record.title !== undefined && typeof record.title !== "string") return undefined;
+  if (record.type !== undefined && record.type !== "inline" && record.type !== "live") return undefined;
+  if (record.mode !== undefined && record.mode !== "wide") return undefined;
+  if (record.wide !== undefined && typeof record.wide !== "boolean") return undefined;
+  return {
+    path: record.path as string | null,
+    ...(record.title !== undefined ? { title: record.title as string } : {}),
+    ...(record.type !== undefined ? { type: record.type as "inline" | "live" } : {}),
+    ...(record.mode !== undefined ? { mode: "wide" as const } : {}),
+  };
+}
+
+/** The ASCII directive for one span payload, or undefined when the app would keep the span. */
+function toAsciiDirective(payload: string): string | undefined {
+  const isJson = payload.startsWith("{");
+  let raw: unknown = { path: payload };
+  if (isJson) {
+    try {
+      raw = JSON.parse(payload);
+    } catch {
+      return undefined;
+    }
+  }
+  const reference = parseReference(raw);
+  if (!reference) return undefined;
+  const live = reference.type === "live";
+  const { path } = reference;
+  if (path === null) return live ? `::${LIVE_DIRECTIVE}{}` : undefined;
+
+  const template = isJson && path === TEMPLATE_PATH;
+  if (!template) {
+    const basename = posix.basename(path.replaceAll("\\", "/"));
+    if (PARENT_SEGMENT.test(path) || UNSAFE_ATTRIBUTE.test(path) || !HTML_BASENAME.test(basename)) return undefined;
+    if (!isAbsoluteAppPath(path) && (isJson || path !== basename)) return undefined;
+  }
+  const attribute = template || isAbsoluteAppPath(path) ? "path" : "file";
+  const title = reference.title !== undefined && !UNSAFE_ATTRIBUTE.test(reference.title)
+    ? ` title="${reference.title}"`
+    : "";
+  const mode = !live && reference.mode === "wide" ? ` mode="wide"` : "";
+  return `::${live ? LIVE_DIRECTIVE : INLINE_DIRECTIVE}{${attribute}="${path}"${title}${mode}}`;
+}
+
+/**
+ * Rewrite every visualization span in `text` to the app's ASCII directive.
+ *
+ * Returns the same string when nothing changes. The scan finds the same matches as the app's regex:
+ * a prefix, one or more characters that are not END, then END. When no END follows a prefix, no
+ * later prefix can match either, so the scan stops instead of rescanning the tail for every prefix.
+ */
+export function normalizeVisualizationText(text: string): string {
+  let prefixAt = text.indexOf(PREFIX);
+  if (prefixAt === -1) return text;
+  let out = "";
+  let copiedTo = 0;
+  while (prefixAt !== -1) {
+    const payloadStart = prefixAt + PREFIX.length;
+    const endAt = text.indexOf(END, payloadStart);
+    if (endAt === -1) break;
+    if (endAt === payloadStart) {
+      // Empty payload: the regex moves on one character and tries again.
+      prefixAt = text.indexOf(PREFIX, prefixAt + 1);
+      continue;
+    }
+    const directive = toAsciiDirective(text.slice(payloadStart, endAt));
+    if (directive !== undefined) {
+      out += text.slice(copiedTo, prefixAt) + directive;
+      copiedTo = endAt + 1;
+    }
+    prefixAt = text.indexOf(PREFIX, endAt + 1);
+  }
+  return copiedTo === 0 ? text : out + text.slice(copiedTo);
+}
+
+function normalizeParts<P extends { type: string }>(parts: P[]): P[] {
+  let changed = false;
+  const next = parts.map((part) => {
+    if (part.type !== "text") return part;
+    const text = (part as unknown as OcxTextContent).text;
+    if (typeof text !== "string") return part;
+    const normalized = normalizeVisualizationText(text);
+    if (normalized === text) return part;
+    changed = true;
+    return { ...part, text: normalized };
+  });
+  return changed ? next : parts;
+}
+
+function normalizeContent<P extends { type: string }>(content: string | P[]): string | P[] {
+  return typeof content === "string" ? normalizeVisualizationText(content) : normalizeParts(content);
+}
+
+function normalizeMessage(message: OcxMessage): OcxMessage {
+  if (message.role === "assistant") {
+    const content = normalizeParts(message.content);
+    return content === message.content ? message : { ...message, content };
+  }
+  const content = normalizeContent<OcxContentPart>(message.content);
+  return content === message.content ? message : { ...message, content } as OcxMessage;
+}
+
+/**
+ * Rewrite visualization spans in the conversation text a routed model reads: the system prompt,
+ * string message content, and text parts of every role. Other fields, including images, tool calls,
+ * reasoning parts, and tool definitions, are returned by reference. The context itself is returned
+ * unchanged when no text changed.
+ */
+export function normalizeVisualizationContext(context: OcxContext): OcxContext {
+  let changed = false;
+  const systemPrompt = context.systemPrompt?.map((text) => {
+    const normalized = normalizeVisualizationText(text);
+    if (normalized !== text) changed = true;
+    return normalized;
+  });
+  const messages = context.messages.map((message) => {
+    const normalized = normalizeMessage(message);
+    if (normalized !== message) changed = true;
+    return normalized;
+  });
+  if (!changed) return context;
+  return { ...context, ...(systemPrompt ? { systemPrompt } : {}), messages };
+}

package/src/server/chat-native-sse.ts

@@ -129,6 +129,11 @@ interface NativeChatSseOptions {
   translatorBudget: TranslatorBudget;
   signal: AbortSignal;
   stallTimeoutSec?: number;
+  /**
+   * The upstream is local infrastructure (loopback / private / `.local` / `.lan`); an unset
+   * `stallTimeoutSec` then resolves to disabled so a slow local model is not cut mid-turn.
+   */
+  localUpstream?: boolean;
   onFirstOutput?: () => void;
   onUsage: (usage: OcxUsage) => void;
   onTerminal?: (status: number, message?: string) => void;
@@ -157,7 +162,12 @@ export function nativeChatSse(
   let settled = false;
   let cancelled = false;
   let cancelledBySignal = false;
-  const stallMs = resolveStallTimeoutSec(options.stallTimeoutSec) * 1_000;
+  const stallSec = resolveStallTimeoutSec(options.stallTimeoutSec, { localUpstream: options.localUpstream });
+  // 0 is an explicit disabled budget (local upstream, or the operator's stallTimeoutSec: 0). Map
+  // it to an Infinity deadline so every `now >= pullDeadline` / `remaining <= 0` check stays
+  // false and the read race is skipped, instead of arming an immediate kill on the first pull.
+  const stallEnabled = stallSec > 0;
+  const stallMs = stallEnabled ? stallSec * 1_000 : Number.POSITIVE_INFINITY;
   // Count only active upstream consumption; downstream backpressure must not
   // consume the provider's inactivity allowance. Comments and empty deltas do.
   let remainingStallMs = stallMs;
@@ -332,17 +342,19 @@ export function nativeChatSse(
           let timeout: ReturnType<typeof setTimeout> | undefined;
           let read: Awaited<ReturnType<typeof reader.read>>;
           try {
-            read = await Promise.race([
-              reader.read(),
-              new Promise<never>((_, reject) => {
-                const check = () => {
-                  const remaining = pullDeadline - performance.now();
-                  if (remaining <= 0) reject(stalled);
-                  else timeout = setTimeout(check, Math.min(remaining, 2_147_483_647));
-                };
-                check();
-              }),
-            ]);
+            read = stallEnabled
+              ? await Promise.race([
+                  reader.read(),
+                  new Promise<never>((_, reject) => {
+                    const check = () => {
+                      const remaining = pullDeadline - performance.now();
+                      if (remaining <= 0) reject(stalled);
+                      else timeout = setTimeout(check, Math.min(remaining, 2_147_483_647));
+                    };
+                    check();
+                  }),
+                ])
+              : await reader.read();
           } finally {
             if (timeout !== undefined) clearTimeout(timeout);
           }