@allbluecn/web-app 0.12.0 → 0.12.3

package/src/server/ai-gateway/code-mode/vm-driver.ts

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import vm from "node:vm"
+
+import {
+  wrapCode,
+  type ExecutionResult,
+  type IsolateConfig,
+  type IsolateContext,
+  type IsolateDriver,
+  type NormalizedError,
+  type ToolBinding,
+} from "@tanstack/ai-code-mode"
+
+/**
+ * node:vm 实现的 IsolateDriver —— 零原生依赖，生产可用。
+ *
+ * 存在原因：`@tanstack/ai-isolate-node` 依赖 isolated-vm 原生 addon，
+ * isolated-vm 6.2.0 不带 prebuilds、必须源码编译；托管运行时的工具链无法保证
+ * 编译成功（本机 macOS 27 实测 `fatal error: 'memory' file not found`），导致
+ * 编排模式在线上恒为不可用。node:vm 是 Node 内建模块，无需编译，任何 Node
+ * 运行时（Vercel / self-hosted / desktop sidecar）均可用。
+ *
+ * 安全边界与官方 isolated-vm driver 对齐，取舍已注明：
+ * - 干净上下文：不注入 require / process / Buffer / module / setTimeout / fetch，
+ *   沙箱内只有 JS 标准内建与白名单工具函数。isolated-vm isolate 同样默认无计时器。
+ * - CPU 炸弹：runInContext 的运行参数 timeout 按 CPU 时间中止同步死循环。
+ * - 墙钟超时：async 代码的 await 链需额外 Promise.race 兜底。
+ *   等价取舍：node:vm 无法在运行中终止 vm 上下文，超时后后台代码理论上仍可继续
+ *   占用 CPU；用 MAX_TOOL_CALLS_PER_RUN 限制工具调用次数作实际边界（无限 async
+ *   循环必然反复调用白名单工具，超预算即抛错终止）。isolated-vm 可 terminate
+ *   isolate，这是唯一实质弱化点。
+ */
+
+const DEFAULT_TIMEOUT_MS = 30_000
+
+export const MAX_TOOL_CALLS_PER_RUN = 64
+
+function normalizeError(error: unknown): NormalizedError {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      code: (error as { code?: string }).code,
+    }
+  }
+  return { name: "Error", message: String(error) }
+}
+
+function formatLogArgs(args: unknown[]): string {
+  return args
+    .map((arg) => (typeof arg === "object" && arg !== null ? JSON.stringify(arg) : String(arg)))
+    .join(" ")
+}
+
+type LogSink = (line: string) => void
+
+function buildConsole(sink: LogSink) {
+  return {
+    log: (...args: unknown[]) => sink(formatLogArgs(args)),
+    error: (...args: unknown[]) => sink(`ERROR: ${formatLogArgs(args)}`),
+    warn: (...args: unknown[]) => sink(`WARN: ${formatLogArgs(args)}`),
+    info: (...args: unknown[]) => sink(`INFO: ${formatLogArgs(args)}`),
+  }
+}
+
+/**
+ * 唯一的 vm 脚本执行入口。
+ *
+ * ⚠ 结构性防护：`vm.Script` 的 timeout 只写在构造器中会被**完全忽略**，
+ * 同步死循环永不中止并挂死宿主进程（实测 Node 24.19：构造器 timeout 挂死，
+ * 运行参数 timeout 在设定毫秒数准确抛错）。因此 timeout 只允许从这里下发，
+ * 禁止在其他地方直接调用 `Script#runInContext`——那样等于关掉 CPU 炸弹保护。
+ */
+function runInVmContext(
+  script: vm.Script,
+  context: vm.Context,
+  timeout: number,
+): unknown {
+  return script.runInContext(context, { timeout })
+}
+
+class VmIsolateContext implements IsolateContext {
+  private readonly context: vm.Context
+  private readonly logs: string[] = []
+  private readonly timeout: number
+  private callsThisRun = 0
+  private disposed = false
+
+  constructor(bindings: Map<string, ToolBinding>, timeout: number) {
+    this.timeout = timeout
+
+    const sandbox: Record<string, unknown> = { console: buildConsole(this.captureLog) }
+    for (const [name, binding] of bindings) {
+      sandbox[name] = this.buildToolFn(binding)
+    }
+    this.context = vm.createContext(sandbox)
+  }
+
+  private readonly captureLog: LogSink = (line) => {
+    this.logs.push(line)
+  }
+
+  private readonly buildToolFn = (binding: ToolBinding) =>
+    async (args: unknown) => {
+      if (this.disposed) throw new Error("Context has been disposed")
+      this.callsThisRun += 1
+      if (this.callsThisRun > MAX_TOOL_CALLS_PER_RUN) {
+        throw new Error(`工具调用次数超过上限（${MAX_TOOL_CALLS_PER_RUN}）`)
+      }
+      return await binding.execute(args ?? {})
+    }
+
+  async execute<T = unknown>(code: string): Promise<ExecutionResult<T>> {
+    if (this.disposed) {
+      return {
+        success: false,
+        error: { name: "DisposedError", message: "Context has been disposed" },
+        logs: [],
+      }
+    }
+
+    this.logs.length = 0
+    this.callsThisRun = 0
+
+    try {
+      const script = new vm.Script(wrapCode(code))
+      const value = await new Promise<unknown>((resolve, reject) => {
+        const timer = setTimeout(
+          () => reject(new Error(`编排程序执行超时（${this.timeout}ms）`)),
+          this.timeout,
+        )
+        Promise.resolve(runInVmContext(script, this.context, this.timeout)).then(
+          (result) => {
+            clearTimeout(timer)
+            resolve(result)
+          },
+          (err) => {
+            clearTimeout(timer)
+            reject(err)
+          },
+        )
+      })
+
+      let parsed: unknown
+      if (typeof value === "string") {
+        try {
+          parsed = JSON.parse(value)
+        } catch {
+          parsed = value
+        }
+      } else {
+        parsed = value
+      }
+
+      return { success: true, value: parsed as T, logs: [...this.logs] }
+    } catch (error) {
+      return { success: false, error: normalizeError(error), logs: [...this.logs] }
+    }
+  }
+
+  async dispose(): Promise<void> {
+    this.disposed = true
+  }
+}
+
+class VmIsolateDriver implements IsolateDriver {
+  constructor(private readonly defaultTimeout = DEFAULT_TIMEOUT_MS) {}
+
+  async createContext(config: IsolateConfig): Promise<IsolateContext> {
+    const timeout = config.timeout ?? this.defaultTimeout
+    return new VmIsolateContext(new Map(Object.entries(config.bindings)), timeout)
+  }
+}
+
+export function createVmIsolateDriver(options?: {
+  timeout?: number
+  memoryLimit?: number
+}): IsolateDriver {
+  return new VmIsolateDriver(options?.timeout ?? DEFAULT_TIMEOUT_MS)
+}

package/src/server/ai-gateway/connectivity-check.ts

@@ -38,6 +38,7 @@ type AdapterKind =
   | "grok"
   | "openrouter"
   | "ollama"
+  | "mistral"
 
 const REQUEST_TIMEOUT_MS = 15_000
 
@@ -45,7 +46,7 @@ const REQUEST_TIMEOUT_MS = 15_000
  * 连通性检查：按 adapterKind 发起轻量级真实请求验证 API Key + BaseURL 可用性。
  * 参考 lobehub 连通性检查思路——直接 fetch provider REST API（不走 SDK），
  * 对不同 adapter 用对应的探活端点：
- *   - OpenAI 兼容系（openai/openai-compatible/groq/grok）：GET {base}/v1/models
+ *   - OpenAI 兼容系（openai/openai-compatible/groq/grok/mistral）：GET {base}/v1/models
  *   - anthropic：GET {base}/v1/models（x-api-key header）
  *   - gemini：GET {base}/v1beta/models?key=
  *   - openrouter：GET {base}/key/info
@@ -83,6 +84,7 @@ async function runCheck(kind: AdapterKind, params: CheckParams): Promise<void> {
     case "openai-compatible":
     case "groq":
     case "grok":
+    case "mistral":
       await getOk(`${ensureV1(base)}/models`, {
         headers: { Authorization: `Bearer ${apiKey}` },
       })

package/src/server/ai-gateway/durability/__tests__/pg-stream.test.ts

@@ -0,0 +1,343 @@
+import { afterAll, describe, expect, it } from "vitest"
+import type { UpsertableStreamDurability } from "@tanstack/ai"
+import { prisma } from "@allbluecn/database"
+import { pgStreamDurabilityFactory } from "../pg-stream"
+
+/**
+ * PG StreamDurability 真库测试（P3 任务 4）。
+ *
+ * 覆盖 stream-durability.d.ts 契约注释里的每条硬约束：snapshot 绝不等待且空 run
+ * 返回 []、append 每 chunk 恰好一个 offset 且顺序一致、upsert 的全批校验
+ * （拒绝外来/未铸造/批内重复/稀疏空洞/覆盖终态行）、read 的 tail 语义、
+ * close 写终态标记行且幂等。
+ *
+ * ⚠ 官方 testkit 的 runJournalConformance / runTakeoverConformance 经 .d.ts 实测
+ * 是**沙箱 journal** 语义（config 要求 createHandle + SandboxHandle），属于任务 6
+ * 的 defineSandbox 装配层，不适用于本 StreamDurability adapter——StreamDurability
+ * 契约的官方 conformance 套件不存在，故本文件自写覆盖。
+ *
+ * AiStreamChunk 表无 FK（runId 是裸 String），测试无需准备 User/Thread 前置数据。
+ *
+ *   psql -h localhost -U allblue -d allblue -c "\dt" | grep ai_stream_chunks
+ *   npx vitest run --project unit src/server/ai-gateway/durability/__tests__/pg-stream.test.ts
+ */
+
+type C = Parameters<UpsertableStreamDurability["append"]>[0][number]
+
+const RUN_PREFIX = "pg-stream-test:"
+const usedRunIds = new Set<string>()
+
+function runId(name: string): string {
+  const id = `${RUN_PREFIX}${name}-${crypto.randomUUID()}`
+  usedRunIds.add(id)
+  return id
+}
+
+function req(url = "http://localhost/api/chat", headers: Record<string, string> = {}): Request {
+  return new Request(url, { headers })
+}
+
+function mkChunk(delta: string): C {
+  return JSON.parse(JSON.stringify({ type: "TEXT_MESSAGE_CONTENT", messageId: "m", delta })) as C
+}
+
+describe.skipIf(
+  !process.env.DATABASE_URL || process.env.DATABASE_PROVIDER === "sqlite",
+)("PG StreamDurability（真库）", () => {
+    afterAll(async () => {
+      if (usedRunIds.size > 0) {
+        await prisma.aiStreamChunk.deleteMany({
+          where: { runId: { in: [...usedRunIds] } },
+        }).catch(() => {})
+      }
+    })
+
+    it("append 返回与 chunk 数量一致的 offset，read('-1') 顺序一致", async () => {
+      const rid = runId("append-read")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+
+      const chunks = [mkChunk("a"), mkChunk("b"), mkChunk("c")]
+      const offsets = await d.append(chunks)
+      expect(offsets).toHaveLength(3)
+      expect(offsets[0] < offsets[1] && offsets[1] < offsets[2]).toBe(true)
+
+      // 先 close：read 靠终态标记行终止 tail，未 close 的 log 会持续 poll。
+      await d.close()
+
+      const replay = [...(await collect(d.read("-1")))]
+      expect(replay.map((r) => r.offset)).toEqual(offsets)
+      expect(replay.map((r) => (r.chunk as { delta: string }).delta)).toEqual(["a", "b", "c"])
+    })
+
+    it("read 用具体 offset 只回放其后部分", async () => {
+      const rid = runId("read-from")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      const offsets = await d.append([mkChunk("a"), mkChunk("b"), mkChunk("c")])
+      await d.close()
+
+      const tail = [...(await collect(d.read(offsets[1])))]
+      expect(tail.map((r) => r.offset)).toEqual([offsets[2]])
+    })
+
+    it("read('now') 跳过既有 chunk", async () => {
+      const rid = runId("read-now")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await d.append([mkChunk("a"), mkChunk("b")])
+      await d.close()
+
+      expect([...(await collect(d.read("now")))]).toEqual([])
+    })
+
+    it("read 在 close 写终态后终止，且终态标记行不吐出", async () => {
+      const rid = runId("read-terminal")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await d.append([mkChunk("only")])
+      await d.close()
+
+      const got = [...(await collect(d.read("-1")))]
+      expect(got.map((r) => (r.chunk as { delta: string }).delta)).toEqual(["only"])
+
+      // 终态后重读仍返回同一前缀——log 已结束，read 不会继续 poll。
+      expect([...(await collect(d.read("-1")))]).toHaveLength(1)
+    })
+
+    it("snapshot 空 run 返回空数组（不抛错、不等待）", async () => {
+      const rid = runId("snapshot-empty")
+      const adapter = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await expect(adapter.snapshot()).resolves.toEqual([])
+    })
+
+    it("snapshot 排除终态标记行，且返回新数组", async () => {
+      const rid = runId("snapshot-terminal")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await d.append([mkChunk("a"), mkChunk("b")])
+      await d.close()
+
+      const snap = await d.snapshot()
+      expect(snap).toHaveLength(2)
+      expect(JSON.stringify(snap)).not.toContain("__aiStreamTerminal")
+
+      snap.push({ offset: "999999", chunk: mkChunk("mutated") })
+      expect(await d.snapshot()).toHaveLength(2)
+    })
+
+    it("close 幂等——重复调用只落一条终态行", async () => {
+      const rid = runId("close-idempotent")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await d.append([mkChunk("a")])
+      await d.close()
+      await d.close()
+
+      const rows = await prisma.aiStreamChunk.findMany({ where: { runId: rid } })
+      expect(rows).toHaveLength(2)
+    })
+
+    it("upsert 重放同 offset 幂等替换，行数不增", async () => {
+      const rid = runId("upsert-replay")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      const offsets = await d.append([mkChunk("a"), mkChunk("b")])
+
+      const result = await d.upsert([
+        { offset: offsets[0], chunk: mkChunk("A") },
+        { offset: offsets[1], chunk: mkChunk("B") },
+      ])
+      expect(result).toEqual(offsets)
+
+      expect(await prisma.aiStreamChunk.count({ where: { runId: rid } })).toBe(2)
+      const snap = await d.snapshot()
+      expect(snap.map((r) => (r.chunk as { delta: string }).delta)).toEqual(["A", "B"])
+      await d.close()
+    })
+
+    it("upsert 拒绝外来 offset 形态", async () => {
+      const rid = runId("upsert-foreign")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      for (const bad of ["-1", "now", "abc", "1.5", "", " 12", "-12"]) {
+        await expect(
+          d.upsert([{ offset: bad, chunk: mkChunk("x") }]),
+        ).rejects.toThrow(/拒绝外来 offset/)
+      }
+    })
+
+    it("upsert 拒绝未铸造 offset（本 adapter 从未写过）", async () => {
+      const rid = runId("upsert-never-minted")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await expect(
+        d.upsert([{ offset: "999999999", chunk: mkChunk("x") }]),
+      ).rejects.toThrow(/拒绝未铸造 offset/)
+      expect(await prisma.aiStreamChunk.count({ where: { runId: rid } })).toBe(0)
+    })
+
+    it("upsert 拒绝批内重复 offset，且不部分落库", async () => {
+      const rid = runId("upsert-dup")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      const [o0, o1] = await d.append([mkChunk("a"), mkChunk("b")])
+
+      await expect(
+        d.upsert([
+          { offset: o0, chunk: mkChunk("A") },
+          { offset: o0, chunk: mkChunk("B") },
+          { offset: o1, chunk: mkChunk("C") },
+        ]),
+      ).rejects.toThrow(/拒绝批内重复/)
+
+      const snap = await d.snapshot()
+      expect(snap.map((r) => (r.chunk as { delta: string }).delta)).toEqual(["a", "b"])
+      await d.close()
+    })
+
+    it("upsert 拒绝稀疏空洞", async () => {
+      const rid = runId("upsert-hole")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      const offsets = await d.append([mkChunk("a"), mkChunk("b"), mkChunk("c")])
+
+      await expect(
+        d.upsert([
+          { offset: offsets[0], chunk: mkChunk("A") },
+          { offset: offsets[2], chunk: mkChunk("C") },
+        ]),
+      ).rejects.toThrow(/拒绝稀疏空洞/)
+
+      const snap = await d.snapshot()
+      expect(snap.map((r) => (r.chunk as { delta: string }).delta)).toEqual(["a", "b", "c"])
+      await d.close()
+    })
+
+    it("upsert 拒绝覆盖终态标记行", async () => {
+      const rid = runId("upsert-terminal")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await d.append([mkChunk("a")])
+      await d.close()
+
+      const terminalRow = await prisma.aiStreamChunk.findFirst({
+        where: { runId: rid },
+        orderBy: { id: "desc" },
+      })
+      expect(terminalRow).not.toBeNull()
+      await expect(
+        d.upsert([{ offset: String(terminalRow!.id), chunk: mkChunk("hijack") }]),
+      ).rejects.toThrow(/拒绝覆盖终态标记行/)
+    })
+
+    it("resumeAdapter 无 X-Run-Id 时 chunk 落 fallback key", async () => {
+      const rid = runId("fallback-key")
+      const f = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid })
+      expect(f.fallbackRunKey).toBe(rid)
+
+      const d = f.resumeAdapter()
+      expect(d.resumeFrom()).toBeNull()
+      await d.append([mkChunk("a")])
+
+      expect(await prisma.aiStreamChunk.count({ where: { runId: rid } })).toBe(1)
+    })
+
+    it("resumeAdapter 有 X-Run-Id 时落正式 runId（官方 resolveResumeRunId 优先序）", async () => {
+      const headerRun = runId("x-header")
+      const d = pgStreamDurabilityFactory(
+        req("http://localhost/api/chat?runId=query-run", { "X-Run-Id": headerRun }),
+      ).resumeAdapter()
+      await d.append([mkChunk("a")])
+
+      expect(await prisma.aiStreamChunk.count({ where: { runId: headerRun } })).toBe(1)
+    })
+
+    it("attachToRun 把 fallback key 行收敛到正式 runId，且幂等", async () => {
+      const fallback = runId("conv-fallback")
+      const target = runId("conv-target")
+      const f = pgStreamDurabilityFactory(req(), { fallbackRunKey: fallback })
+
+      const offsets = await f.resumeAdapter().append([mkChunk("a"), mkChunk("b")])
+      expect(await prisma.aiStreamChunk.count({ where: { runId: fallback } })).toBe(2)
+
+      expect(await f.attachToRun(target)).toBe(2)
+      expect(await prisma.aiStreamChunk.count({ where: { runId: fallback } })).toBe(0)
+      expect(await prisma.aiStreamChunk.count({ where: { runId: target } })).toBe(2)
+
+      // 二次调用：无行可收敛
+      expect(await f.attachToRun(target)).toBe(0)
+
+      // 收敛后按正式 runId 可读回原 chunk
+      const snap = await f.forRun(target).snapshot()
+      expect(snap.map((r) => r.offset)).toEqual(offsets)
+    })
+
+    it("attachToRun 自身即 fallback 时无操作", async () => {
+      const rid = runId("conv-self")
+      const f = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid })
+      await f.resumeAdapter().append([mkChunk("a")])
+      expect(await f.attachToRun(rid)).toBe(0)
+      expect(await prisma.aiStreamChunk.count({ where: { runId: rid } })).toBe(1)
+    })
+
+    it("Last-Event-ID 是本 adapter 铸造的 offset 时透传，外来 cursor 降级为 from-start", async () => {
+      const rid = runId("resume-offset")
+      const f = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid })
+      const offsets = await f.resumeAdapter().append([mkChunk("a"), mkChunk("b")])
+      await f.resumeAdapter().close()
+
+      const own = pgStreamDurabilityFactory(
+        req("http://localhost/api/chat", { "Last-Event-ID": offsets[0] }),
+        { fallbackRunKey: rid },
+      ).resumeAdapter()
+      expect(own.resumeFrom()).toBe(offsets[0])
+
+      const foreign = pgStreamDurabilityFactory(
+        req("http://localhost/api/chat", { "Last-Event-ID": "memory:v1:abc:7" }),
+        { fallbackRunKey: rid },
+      ).resumeAdapter()
+      expect(foreign.resumeFrom()).toBe("-1")
+
+      const fromQuery = pgStreamDurabilityFactory(
+        req(`http://localhost/api/chat?offset=${offsets[1]}`),
+        { fallbackRunKey: rid },
+      ).resumeAdapter()
+      expect(fromQuery.resumeFrom()).toBe(offsets[1])
+
+      const noMarker = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).resumeAdapter()
+      expect(noMarker.resumeFrom()).toBeNull()
+    })
+
+    it("runId 校验：空串与含 CR/LF 直接抛错", async () => {
+      const f = pgStreamDurabilityFactory(req(), { fallbackRunKey: runId("bad-runid") })
+      expect(() => f.forRun("")).toThrow(/invalid runId/)
+      expect(() => f.forRun("a\nb")).toThrow(/invalid runId/)
+      expect(() => f.forRun("a\rb")).toThrow(/invalid runId/)
+    })
+
+    it("未提供 fallbackRunKey 时自动生成 pending:* 键并可用", async () => {
+      const f = pgStreamDurabilityFactory(req())
+      expect(f.fallbackRunKey).toBeUndefined()
+      const adapter = f.resumeAdapter()
+      const offsets = await adapter.append([mkChunk("a")])
+      expect(offsets).toHaveLength(1)
+
+      const snap = await f.resumeAdapter().snapshot()
+      expect(snap).toHaveLength(1)
+      await adapter.close()
+    })
+
+    it("AbortSignal 取消正在 tail 的 read", async () => {
+      const rid = runId("abort")
+      const d = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await d.append([mkChunk("a")])
+
+      const controller = new AbortController()
+      setTimeout(() => controller.abort(), 20)
+      await expect(collect(d.read("-1", controller.signal))).rejects.toThrow()
+    })
+
+    it("from-start join 空 log 超过首 chunk deadline 抛错（对齐 memoryStream）", async () => {
+      const rid = runId("deadline")
+      const adapter = pgStreamDurabilityFactory(req(), { fallbackRunKey: rid }).forRun(rid)
+      await expect(collect(adapter.read("-1"))).rejects.toThrow(/no chunk within/)
+    })
+  },
+)
+
+async function collect(
+  iter: AsyncIterable<{ offset: string; chunk: unknown }>,
+): Promise<Array<{ offset: string; chunk: unknown }>> {
+  const out: Array<{ offset: string; chunk: unknown }> = []
+  for await (const row of iter) out.push(row)
+  return out
+}