@darthph0enix/commandcode-go-opencode-provider 0.5.0

package/src/model-sync.ts

@@ -0,0 +1,345 @@
+import { existsSync, readFileSync, realpathSync, renameSync, writeFileSync } from "fs"
+import { dirname, join } from "path"
+import { fileURLToPath } from "url"
+import { resolveApiKey } from "./auth.js"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PACKAGE_ROOT = join(__dirname, "..")
+const BUNDLED_MODELS = join(PACKAGE_ROOT, "models.json")
+const CACHE_MODELS = join(PACKAGE_ROOT, "models.cache.json")
+
+export interface ModelEntry {
+  id: string
+  name: string
+  tier: "premium" | "open-source"
+  reasoning: boolean
+  tool_call: boolean
+  attachment?: boolean
+  modalities?: {
+    input: string[]
+    output: string[]
+  }
+  reasoningEfforts?: string[]
+  variants?: Record<string, Record<string, unknown>>
+  cost: { input: number; output: number; cache_read?: number; cache_write?: number }
+  limit: { context: number; output: number }
+}
+
+interface ApiModel {
+  id: string
+  name?: string
+  context_length?: number
+}
+
+export interface SyncResult {
+  models: ModelEntry[]
+  source: string
+}
+
+export function loadCachedModels(file: string): ModelEntry[] | null {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf-8"))
+    if (Array.isArray(parsed) && parsed.length > 0) return parsed as ModelEntry[]
+  } catch {
+    // intentionally silent: unreadable or malformed cache is ignored
+  }
+  return null
+}
+
+function writeAtomic(file: string, data: string) {
+  const tmp = `${file}.${process.pid}.tmp`
+  writeFileSync(tmp, data)
+  renameSync(tmp, file)
+}
+
+// Locate the model catalog bundled with the installed Command Code CLI.
+// The catalog is the vendor-maintained list for the same API endpoint this
+// provider talks to, so it is the most accurate metadata source available.
+function findModelsMd(): string | null {
+  const explicit = process.env.COMMANDCODE_MODELS_MD
+  if (explicit && existsSync(explicit)) return explicit
+
+  const dirs = (process.env.PATH ?? "").split(":").filter(Boolean)
+  for (const dir of dirs) {
+    for (const name of ["cmd", "command-code"]) {
+      const bin = join(dir, name)
+      if (!existsSync(bin)) continue
+      let target = bin
+      try {
+        target = realpathSync(bin)
+      } catch {
+        // keep unresolved path
+      }
+      const candidates = [
+        join(dirname(target), "bundled", "command-code-knowledge", "reference", "models.md"),
+        join(dirname(target), "..", "dist", "bundled", "command-code-knowledge", "reference", "models.md"),
+        join(dir, "..", "lib", "node_modules", "command-code", "dist", "bundled", "command-code-knowledge", "reference", "models.md"),
+      ]
+      for (const candidate of candidates) {
+        if (existsSync(candidate)) return candidate
+      }
+    }
+  }
+  return null
+}
+
+function findCliMjs(): string | null {
+  const dirs = (process.env.PATH ?? "").split(":").filter(Boolean)
+  for (const dir of dirs) {
+    for (const name of ["cmd", "command-code", "commandcode"]) {
+      const bin = join(dir, name)
+      if (!existsSync(bin)) continue
+      let target = bin
+      try {
+        target = realpathSync(bin)
+      } catch {}
+      const candidates = [
+        join(dirname(target), "..", "dist", "cli.mjs"),
+        join(dir, "..", "lib", "node_modules", "command-code", "dist", "cli.mjs"),
+        join(dirname(target), "cli.mjs"),
+      ]
+      for (const c of candidates) {
+        if (existsSync(c)) return c
+      }
+    }
+  }
+  return null
+}
+
+function extractCliMetadata(): { modalities: Map<string, string[]>; efforts: Map<string, string[]> } {
+  const modalities = new Map<string, string[]>()
+  const efforts = new Map<string, string[]>()
+  try {
+    const cliPath = findCliMjs()
+    if (cliPath && existsSync(cliPath)) {
+      const content = readFileSync(cliPath, "utf-8")
+      const m = content.match(/(\$L=\{[^;]+);/)
+      if (m) {
+        const text = m[1].replace(/^\$L=/, "")
+        const regex = /id:\s*"([^"]+)"/g
+        let match: RegExpExecArray | null
+        while ((match = regex.exec(text)) !== null) {
+          const id = match[1].toLowerCase()
+          const start = match.index
+          const slice = text.slice(start, start + 350)
+          const modMatch = slice.match(/inputModalities:\s*(\[[^\]]*\])/)
+          if (modMatch) {
+            try {
+              modalities.set(id, JSON.parse(modMatch[1].replace(/'/g, '"')))
+            } catch {}
+          }
+          const effMatch = slice.match(/reasoningEfforts:\s*(\[[^\]]*\])/)
+          if (effMatch) {
+            try {
+              efforts.set(id, JSON.parse(effMatch[1].replace(/'/g, '"')))
+            } catch {}
+          }
+        }
+      }
+    }
+  } catch {}
+  return { modalities, efforts }
+}
+
+function isVisionModelFallback(id: string): boolean {
+  const lower = id.toLowerCase()
+  return (
+    lower.includes("v4.1") ||
+    lower.includes("vision") ||
+    lower.includes("27b") ||
+    lower.includes("kimi-k2") ||
+    lower.includes("minimax-m3") ||
+    lower.includes("step-3.7") ||
+    lower.includes("inkling") ||
+    lower.includes("sonnet") ||
+    lower.includes("opus") ||
+    lower.includes("haiku") ||
+    lower.includes("fable") ||
+    lower.includes("gpt-5") ||
+    lower.includes("gpt-6") ||
+    lower.includes("gemini")
+  )
+}
+
+function parseContext(raw: string): number | null {
+  const match = /^([\d.]+)\s*([MK])$/i.exec(raw.trim())
+  if (!match) return null
+  const value = Number(match[1]) * (match[2].toUpperCase() === "M" ? 1_000_000 : 1_000)
+  return Number.isFinite(value) && value > 0 ? Math.round(value) : null
+}
+
+function parseCost(raw: string): ModelEntry["cost"] | null {
+  const match = /^\$([\d.]+)\s*\/\s*\$([\d.]+)(?:\s*·\s*cache\s*\$([\d.]+))?(?:\s*\(write\s*\$([\d.]+)\))?/i.exec(
+    raw.trim(),
+  )
+  if (!match) return null
+  const cost: ModelEntry["cost"] = { input: Number(match[1]), output: Number(match[2]) }
+  if (match[3] !== undefined) cost.cache_read = Number(match[3])
+  if (match[4] !== undefined) cost.cache_write = Number(match[4])
+  return cost
+}
+
+export function parseModelsMd(text: string, hints: Map<string, ModelEntry>): ModelEntry[] {
+  const entries: ModelEntry[] = []
+  const { modalities: modalitiesMap, efforts: effortsMap } = extractCliMetadata()
+  let section = ""
+  for (const line of text.split(/\r?\n/)) {
+    const heading = /^##\s+(.+?)\s*$/.exec(line)
+    if (heading) {
+      section = heading[1]
+      continue
+    }
+    if (!line.startsWith("| `")) continue
+
+    const cells = line.split("|").slice(1, -1).map((cell) => cell.trim())
+    if (cells.length < 5) continue
+
+    const id = cells[0].replace(/`/g, "").trim()
+    if (!id) continue
+    const hint = hints.get(id.toLowerCase())
+    const context = parseContext(cells[2]) ?? (hint?.limit.context || 200000)
+    const cost = parseCost(cells[4]) ?? hint?.cost ?? { input: 0, output: 0 }
+    const minPlan = cells[5] ? cells[5].trim() : ""
+    const planBadge = minPlan ? ` [${minPlan.replace(" and above", "+")}]` : ""
+    const displayName = `${cells[1]}${planBadge}`
+
+    // Dynamically resolve reasoning efforts from vendor CLI catalog ($L in cli.mjs) or models.md
+    const rawEfforts = cells[3]?.trim()
+    let effortsList: string[] = []
+    if (rawEfforts && rawEfforts !== "—" && rawEfforts !== "-") {
+      effortsList = rawEfforts.split(",").map((s) => s.trim()).filter(Boolean)
+    }
+    const cliEfforts = effortsMap.get(id.toLowerCase())
+    if (cliEfforts && cliEfforts.length > 0) {
+      effortsList = cliEfforts
+    }
+
+    const variants: Record<string, Record<string, unknown>> = {}
+    for (const effort of effortsList) {
+      variants[effort] = {
+        reasoning_effort: effort,
+        reasoningEffort: effort,
+        effort: effort,
+      }
+    }
+
+    const cliMods = modalitiesMap.get(id.toLowerCase())
+    const hasVision = cliMods ? cliMods.includes("image") : isVisionModelFallback(id)
+    const inputMods = cliMods ?? (hasVision ? ["text", "image"] : ["text"])
+
+    entries.push({
+      id,
+      name: displayName,
+      tier: section.toLowerCase() === "open source" ? "open-source" : "premium",
+      reasoning: effortsList.length > 0,
+      reasoningEfforts: effortsList.length > 0 ? effortsList : undefined,
+      variants: Object.keys(variants).length > 0 ? variants : undefined,
+      tool_call: true,
+      attachment: inputMods.some((m) => m !== "text"),
+      modalities: {
+        input: inputMods,
+        output: ["text"],
+      },
+      cost,
+      limit: { context, output: hint?.limit.output ?? 65536 },
+    })
+  }
+  return entries
+}
+
+async function fetchApiModels(): Promise<ApiModel[] | null> {
+  const apiKey = resolveApiKey({})
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), 4000)
+  try {
+    const response = await fetch("https://api.commandcode.ai/provider/v1/models", {
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      signal: controller.signal,
+    })
+    if (!response.ok) return null
+    const payload = (await response.json()) as { data?: ApiModel[] }
+    return Array.isArray(payload?.data) ? payload.data : null
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+function mergeApiModels(entries: ModelEntry[], api: ApiModel[]): ModelEntry[] {
+  const seen = new Map(entries.map((entry) => [entry.id.toLowerCase(), entry]))
+  for (const model of api) {
+    if (!model?.id) continue
+    const key = model.id.toLowerCase()
+    const existing = seen.get(key)
+    if (existing) {
+      if (model.context_length && (!existing.limit.context || existing.limit.context <= 0)) {
+        existing.limit.context = model.context_length
+      }
+      continue
+    }
+    const entry: ModelEntry = {
+      id: model.id,
+      name: model.name?.trim() || model.id.split("/").pop() || model.id,
+      tier: "open-source",
+      reasoning: true,
+      tool_call: true,
+      cost: { input: 0, output: 0 },
+      limit: { context: model.context_length && model.context_length > 0 ? model.context_length : 200000, output: 65536 },
+    }
+    entries.push(entry)
+    seen.set(key, entry)
+  }
+  return entries
+}
+
+// Build the model list fresh on every opencode instance start:
+//   1. CLI-bundled catalog (vendor-maintained, refreshed by `cmd update`)
+//   2. Command Code's public model endpoint (picks up brand-new models)
+//   3. last synced cache, then the bundled snapshot as an offline fallback.
+export async function loadSyncedModels(): Promise<SyncResult> {
+  const bundled = loadCachedModels(BUNDLED_MODELS)
+  const cached = loadCachedModels(CACHE_MODELS)
+  const hints = new Map<string, ModelEntry>()
+  for (const entry of [...(cached ?? []), ...(bundled ?? [])]) hints.set(entry.id.toLowerCase(), entry)
+
+  let docModels: ModelEntry[] | null = null
+  try {
+    const modelsMd = findModelsMd()
+    if (modelsMd) {
+      const parsed = parseModelsMd(readFileSync(modelsMd, "utf-8"), hints)
+      if (parsed.length >= 5) docModels = parsed
+    }
+  } catch {
+    // intentionally silent: fall through to the API or cache
+  }
+
+  const apiModels = await fetchApiModels()
+
+  let models: ModelEntry[] | null = null
+  let source = ""
+  if (docModels?.length) {
+    models = mergeApiModels(docModels, apiModels ?? [])
+    source = apiModels?.length ? "cli-catalog+api" : "cli-catalog"
+  } else if (apiModels?.length) {
+    models = mergeApiModels([], apiModels)
+    source = "api"
+  }
+
+  if (!models?.length) {
+    models = cached ?? bundled ?? []
+    source = cached ? "cache" : "bundled"
+  }
+
+  if (!models.length) throw new Error("Command Code model catalog unavailable (no CLI, API, cache, or bundled list)")
+
+  if (source !== "cache" && source !== "bundled") {
+    try {
+      writeAtomic(CACHE_MODELS, JSON.stringify(models, null, 2) + "\n")
+    } catch {
+      // intentionally silent: cache is best-effort
+    }
+  }
+
+  return { models, source }
+}

package/src/model.ts

@@ -0,0 +1,159 @@
+import type {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3StreamResult,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3Content,
+  LanguageModelV3Usage,
+  LanguageModelV3FinishReason,
+} from "@ai-sdk/provider"
+import { buildRequest } from "./convert.js"
+import { parseStreamEvents } from "./stream.js"
+
+const DEFAULT_BASE_URL = "https://api.commandcode.ai"
+// x-command-code-version must match the Command Code CLI version for API compatibility
+const CC_VERSION = "1.54.0"
+
+export interface CommandCodeModelOptions {
+  apiKey: string
+  baseURL?: string
+  headers?: Record<string, string>
+}
+
+export class CommandCodeLanguageModel implements LanguageModelV3 {
+  readonly specificationVersion = "v3" as const
+  readonly provider = "commandcode"
+  readonly modelId: string
+  supportedUrls: Record<string, RegExp[]> = {}
+
+  private opts: CommandCodeModelOptions
+
+  constructor(modelId: string, opts: CommandCodeModelOptions) {
+    this.modelId = modelId
+    this.opts = opts
+  }
+
+  private get baseURL(): string {
+    return this.opts.baseURL ?? DEFAULT_BASE_URL
+  }
+
+  private buildHeaders(): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.opts.apiKey}`,
+      "x-command-code-version": CC_VERSION,
+      "x-cli-environment": "production",
+      "x-project-slug": "opencode",
+      ...this.opts.headers,
+    }
+  }
+
+  async doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult> {
+    const body = buildRequest(this.modelId, options)
+    const requestBody = JSON.stringify(body)
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(new Error("Request timed out after 5 minutes")), 300_000)
+    const userSignal = options.abortSignal
+    if (userSignal) {
+      const onAbort = () => controller.abort(userSignal.reason)
+      userSignal.addEventListener("abort", onAbort, { once: true })
+    }
+
+    try {
+      const response = await fetch(`${this.baseURL}/alpha/generate`, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: requestBody,
+        signal: controller.signal,
+      })
+
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => "")
+        let errorMessage = `Command Code API error: ${response.status} ${response.statusText}`
+        try {
+          const parsed = JSON.parse(errorBody)
+          if (parsed.error?.message) errorMessage = parsed.error.message
+          else if (parsed.message) errorMessage = parsed.message
+        } catch {
+          // intentionally silent: error body is not JSON
+        }        throw new Error(`${errorMessage} [model=${this.modelId}]`)
+      }
+
+      if (!response.body) {
+        throw new Error(`Command Code API returned no body [model=${this.modelId}]`)
+      }
+
+      const responseHeaders: Record<string, string> = {}
+      response.headers.forEach((v, k) => {
+        responseHeaders[k] = v
+      })
+
+      return {
+        stream: parseStreamEvents(response.body as ReadableStream<Uint8Array>),
+        request: { body: requestBody },
+        response: { headers: responseHeaders },
+      }
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  async doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult> {
+    const { stream } = await this.doStream(options)
+
+    const textParts: string[] = []
+    const reasoningParts: string[] = []
+    const content: LanguageModelV3Content[] = []
+    let finishReason: LanguageModelV3FinishReason = { unified: "stop", raw: "stop" }
+    let usage: LanguageModelV3Usage = {
+      inputTokens: { total: undefined, noCache: undefined, cacheRead: undefined, cacheWrite: undefined },
+      outputTokens: { total: undefined, text: undefined, reasoning: undefined },
+    }
+
+    const reader = stream.getReader()
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        switch (value.type) {
+          case "text-delta":
+            textParts.push(value.delta)
+            break
+          case "reasoning-delta":
+            reasoningParts.push(value.delta)
+            break
+          case "tool-call":
+            content.push({
+              type: "tool-call",
+              toolCallId: value.toolCallId,
+              toolName: value.toolName,
+              input: value.input,
+            })
+            break
+          case "finish":
+            finishReason = value.finishReason
+            usage = value.usage
+            break
+        }
+      }
+    } finally {
+      reader.releaseLock()
+      stream.cancel()
+    }
+
+    const text = textParts.join("")
+    if (text) content.unshift({ type: "text", text })
+
+    const reasoning = reasoningParts.join("")
+    if (reasoning) content.unshift({ type: "reasoning", text: reasoning })
+
+    return {
+      content,
+      finishReason,
+      usage,
+      warnings: [],
+    }
+  }
+}

package/src/stream.ts

@@ -0,0 +1,188 @@
+import type { LanguageModelV3StreamPart, LanguageModelV3Usage, LanguageModelV3FinishReason } from "@ai-sdk/provider"
+
+type RawEvent = Record<string, unknown> & { type: string }
+
+function mapFinishReason(raw: string): LanguageModelV3FinishReason["unified"] {
+  switch (raw) {
+    case "stop":
+    case "end_turn":
+      return "stop"
+    case "tool_calls":
+    case "tool-calls":
+      return "tool-calls"
+    case "length":
+    case "max_tokens":
+    case "max-tokens":
+    case "max_output_tokens":
+      return "length"
+    case "content_filter":
+      return "content-filter"
+    default:
+      return "other"
+  }
+}
+
+function mapUsage(raw: Record<string, unknown>): LanguageModelV3Usage {
+  const inputDetails = (raw.inputTokenDetails ?? raw.input_token_details ?? {}) as Record<string, unknown>
+  const outputDetails = (raw.outputTokenDetails ?? raw.output_token_details ?? {}) as Record<string, unknown>
+  return {
+    inputTokens: {
+      total: typeof raw.inputTokens === "number" ? raw.inputTokens : typeof raw.prompt_tokens === "number" ? raw.prompt_tokens : undefined,
+      noCache: typeof inputDetails.noCacheTokens === "number" ? inputDetails.noCacheTokens : undefined,
+      cacheRead: typeof inputDetails.cacheReadTokens === "number" ? inputDetails.cacheReadTokens : undefined,
+      cacheWrite: typeof inputDetails.cacheWriteTokens === "number" ? inputDetails.cacheWriteTokens : undefined,
+    },
+    outputTokens: {
+      total: typeof raw.outputTokens === "number" ? raw.outputTokens : typeof raw.completion_tokens === "number" ? raw.completion_tokens : undefined,
+      text: typeof outputDetails.textTokens === "number" ? outputDetails.textTokens : undefined,
+      reasoning: typeof outputDetails.reasoningTokens === "number" ? outputDetails.reasoningTokens : undefined,
+    },
+  }
+}
+
+function toStreamPart(event: RawEvent): LanguageModelV3StreamPart | null {
+  switch (event.type) {
+    case "start":
+      return { type: "stream-start", warnings: [] }
+
+    case "text-start":
+      return { type: "text-start", id: event.id as string }
+    case "text-delta":
+      return { type: "text-delta", id: event.id as string, delta: (event.text ?? event.delta ?? "") as string }
+    case "text-end":
+      return { type: "text-end", id: event.id as string }
+
+    case "reasoning-start":
+      return { type: "reasoning-start", id: event.id as string }
+    case "reasoning-delta":
+      return { type: "reasoning-delta", id: event.id as string, delta: (event.text ?? event.delta ?? "") as string }
+    case "reasoning-end":
+      return { type: "reasoning-end", id: event.id as string }
+
+    case "tool-input-start":
+      return {
+        type: "tool-input-start",
+        id: event.id as string,
+        toolName: event.toolName as string,
+        dynamic: event.dynamic as boolean | undefined,
+      }
+    case "tool-input-delta":
+      return { type: "tool-input-delta", id: event.id as string, delta: (event.delta ?? "") as string }
+    case "tool-input-end":
+      return { type: "tool-input-end", id: event.id as string }
+
+    case "tool-call": {
+      const input = event.input ?? event.args ?? event.arguments
+      return {
+        type: "tool-call",
+        toolCallId: (event.toolCallId ?? event.id ?? "") as string,
+        toolName: event.toolName as string,
+        input: typeof input === "string" ? input : JSON.stringify(input ?? {}),
+      }
+    }
+
+    case "finish-step": {
+      const usage = event.usage ?? event.totalUsage ?? {}
+      const rawReason = (event.finishReason ?? event.rawFinishReason ?? "stop") as string
+      return {
+        type: "finish",
+        finishReason: { unified: mapFinishReason(rawReason), raw: rawReason },
+        usage: mapUsage(typeof usage === "object" && usage !== null ? (usage as Record<string, unknown>) : {}),
+      }
+    }
+
+    case "finish":
+      return null
+
+    case "response-metadata":
+      return {
+        type: "response-metadata",
+        id: event.id as string | undefined,
+        modelId: event.modelId as string | undefined,
+      }
+
+    case "error":
+      return { type: "error", error: event.error ?? event.message ?? "Unknown error" }
+
+    default:
+      return null
+  }
+}
+
+// Assumes line-delimited JSON over SSE: one JSON object per `data:` line.
+// Multi-line `data:` fields are not supported — the buffer splits on `\n`.
+export function parseStreamEvents(body: ReadableStream<Uint8Array>): ReadableStream<LanguageModelV3StreamPart> {
+  const reader = body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ""
+
+  return new ReadableStream<LanguageModelV3StreamPart>({
+    async pull(controller) {
+      try {
+        while (true) {
+          const lines = buffer.split("\n")
+          // Strip trailing \r from Windows-style \r\n line endings
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i]
+            if (line !== undefined && line.endsWith("\r")) lines[i] = line.slice(0, -1)
+          }
+          buffer = lines.pop() ?? ""
+
+          for (const line of lines) {
+            const trimmed = line.trim()
+            if (!trimmed || trimmed.startsWith(":") || trimmed === "[DONE]") continue
+
+            let jsonStr = trimmed
+            if (jsonStr.startsWith("data: ")) jsonStr = jsonStr.slice(6)
+            if (jsonStr.startsWith("data:")) jsonStr = jsonStr.slice(5)
+            if (!jsonStr || jsonStr === "[DONE]") continue
+
+            let parsed: RawEvent
+            try {
+              parsed = JSON.parse(jsonStr)
+            } catch {
+              // intentionally silent: skip malformed SSE lines
+              continue
+            }
+
+            if (typeof parsed !== "object" || parsed === null || typeof parsed.type !== "string") continue
+
+            const part = toStreamPart(parsed)
+            if (part) controller.enqueue(part)
+          }
+
+          const { done, value } = await reader.read()
+          if (done) {
+            if (buffer.trim()) {
+              const trimmed = buffer.trim()
+              if (trimmed && trimmed !== "[DONE]" && !trimmed.startsWith(":")) {
+                let jsonStr = trimmed
+                if (jsonStr.startsWith("data: ")) jsonStr = jsonStr.slice(6)
+                if (jsonStr.startsWith("data:")) jsonStr = jsonStr.slice(5)
+                try {
+                  const parsed = JSON.parse(jsonStr)
+                  if (typeof parsed === "object" && parsed !== null && typeof parsed.type === "string") {
+                    const part = toStreamPart(parsed)
+                    if (part) controller.enqueue(part)
+                  }
+                } catch {
+                  // intentionally silent: skip malformed final buffer
+                }
+              }
+            }
+            controller.close()
+            return
+          }
+
+          buffer += decoder.decode(value, { stream: true })
+        }
+      } catch (err) {
+        controller.enqueue({ type: "error", error: err })
+        controller.close()
+      }
+    },
+    cancel() {
+      reader.cancel()
+    },
+  })
+}