woozlit 2.3.0 → 2.3.1

package/test/session/goal.test.ts

@@ -1,106 +0,0 @@
-/**
- * Unit tests for the per-session goal stop-condition service (session/goal.ts).
- *
- * Covers the state machine (set / get / clear / bumpReact) — the deterministic
- * logic that drives the main runLoop's goal gate. The judge model call
- * (Goal.evaluate) is exercised by the integration path in prompt.ts and the live
- * headless harness; it converts the conversation to native model messages (tool
- * calls/results/images preserved) rather than flattening to text.
- */
-
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { Goal } from "../../src/session/goal"
-import { SessionID } from "../../src/session/schema"
-import { Log } from "../../src/util"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const ses = SessionID.make("ses_goal_test")
-
-function runGoal<A>(dir: string, fn: (goal: Goal.Interface) => Effect.Effect<A>) {
-  return Instance.provide({
-    directory: dir,
-    fn: () =>
-      Effect.runPromise(
-        Effect.gen(function* () {
-          const goal = yield* Goal.Service
-          return yield* fn(goal)
-        }).pipe(Effect.scoped, Effect.provide(Goal.defaultLayer)),
-      ),
-  })
-}
-
-describe("Goal state machine", () => {
-  test("set then get returns the condition with react=0", async () => {
-    await using tmp = await tmpdir({})
-    const got = await runGoal(tmp.path, (goal) =>
-      Effect.gen(function* () {
-        yield* goal.set(ses, "tests pass")
-        return yield* goal.get(ses)
-      }),
-    )
-    expect(got?.condition).toBe("tests pass")
-    expect(got?.react).toBe(0)
-  })
-
-  test("get with no goal returns undefined", async () => {
-    await using tmp = await tmpdir({})
-    const got = await runGoal(tmp.path, (goal) => goal.get(ses))
-    expect(got).toBeUndefined()
-  })
-
-  test("clear removes the goal", async () => {
-    await using tmp = await tmpdir({})
-    const got = await runGoal(tmp.path, (goal) =>
-      Effect.gen(function* () {
-        yield* goal.set(ses, "build green")
-        yield* goal.clear(ses)
-        return yield* goal.get(ses)
-      }),
-    )
-    expect(got).toBeUndefined()
-  })
-
-  test("bumpReact increments and is reflected in get", async () => {
-    await using tmp = await tmpdir({})
-    const result = await runGoal(tmp.path, (goal) =>
-      Effect.gen(function* () {
-        yield* goal.set(ses, "x")
-        const first = yield* goal.bumpReact(ses)
-        const second = yield* goal.bumpReact(ses)
-        const current = yield* goal.get(ses)
-        return { first, second, current: current?.react }
-      }),
-    )
-    expect(result.first).toBe(1)
-    expect(result.second).toBe(2)
-    expect(result.current).toBe(2)
-  })
-
-  test("bumpReact with no active goal returns 0", async () => {
-    await using tmp = await tmpdir({})
-    const n = await runGoal(tmp.path, (goal) => goal.bumpReact(ses))
-    expect(n).toBe(0)
-  })
-
-  test("set resets react back to 0", async () => {
-    await using tmp = await tmpdir({})
-    const got = await runGoal(tmp.path, (goal) =>
-      Effect.gen(function* () {
-        yield* goal.set(ses, "a")
-        yield* goal.bumpReact(ses)
-        yield* goal.set(ses, "b")
-        return yield* goal.get(ses)
-      }),
-    )
-    expect(got?.condition).toBe("b")
-    expect(got?.react).toBe(0)
-  })
-})

package/test/session/instruction.test.ts

@@ -1,387 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import path from "path"
-import { Effect } from "effect"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-import { Instruction } from "../../src/session/instruction"
-import type { MessageV2 } from "../../src/session/message-v2"
-import { Instance } from "../../src/project/instance"
-import { MessageID, PartID, SessionID } from "../../src/session/schema"
-import { Global } from "../../src/global"
-import { tmpdir } from "../fixture/fixture"
-
-const run = <A>(effect: Effect.Effect<A, any, Instruction.Service>) =>
-  Effect.runPromise(effect.pipe(Effect.provide(Instruction.defaultLayer)))
-
-function loaded(filepath: string): MessageV2.WithParts[] {
-  const sessionID = SessionID.make("session-loaded-1")
-  const messageID = MessageID.make("message-loaded-1")
-
-  return [
-    {
-      info: {
-        id: messageID,
-        sessionID,
-        role: "user",
-        time: { created: 0 },
-        agent: "build",
-        model: {
-          providerID: ProviderID.make("anthropic"),
-          modelID: ModelID.make("claude-sonnet-4-20250514"),
-        },
-      },
-      parts: [
-        {
-          id: PartID.make("part-loaded-1"),
-          messageID,
-          sessionID,
-          type: "tool",
-          callID: "call-loaded-1",
-          tool: "read",
-          state: {
-            status: "completed",
-            input: {},
-            output: "done",
-            title: "Read",
-            metadata: { loaded: [filepath] },
-            time: { start: 0, end: 1 },
-          },
-        },
-      ],
-    },
-  ]
-}
-
-describe("Instruction.resolve", () => {
-  test("returns empty when AGENTS.md is at project root (already in systemPaths)", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Root Instructions")
-        await Bun.write(path.join(dir, "src", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const system = yield* svc.systemPaths()
-              expect(system.has(path.join(tmp.path, "AGENTS.md"))).toBe(true)
-
-              const results = yield* svc.resolve(
-                [],
-                path.join(tmp.path, "src", "file.ts"),
-                MessageID.make("message-test-1"),
-              )
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
-    })
-  })
-
-  test("returns AGENTS.md from subdirectory (not in systemPaths)", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const system = yield* svc.systemPaths()
-              expect(system.has(path.join(tmp.path, "subdir", "AGENTS.md"))).toBe(false)
-
-              const results = yield* svc.resolve(
-                [],
-                path.join(tmp.path, "subdir", "nested", "file.ts"),
-                MessageID.make("message-test-2"),
-              )
-              expect(results.length).toBe(1)
-              expect(results[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-            }),
-          ),
-        ),
-    })
-  })
-
-  test("doesn't reload AGENTS.md when reading it directly", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "AGENTS.md")
-              const system = yield* svc.systemPaths()
-              expect(system.has(filepath)).toBe(false)
-
-              const results = yield* svc.resolve([], filepath, MessageID.make("message-test-3"))
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
-    })
-  })
-
-  test("does not reattach the same nearby instructions twice for one message", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-1")
-
-              const first = yield* svc.resolve([], filepath, id)
-              const second = yield* svc.resolve([], filepath, id)
-
-              expect(first).toHaveLength(1)
-              expect(first[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-              expect(second).toEqual([])
-            }),
-          ),
-        ),
-    })
-  })
-
-  test("clear allows nearby instructions to be attached again for the same message", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-2")
-
-              const first = yield* svc.resolve([], filepath, id)
-              yield* svc.clear(id)
-              const second = yield* svc.resolve([], filepath, id)
-
-              expect(first).toHaveLength(1)
-              expect(second).toHaveLength(1)
-              expect(second[0].filepath).toBe(path.join(tmp.path, "subdir", "AGENTS.md"))
-            }),
-          ),
-        ),
-    })
-  })
-
-  test("skips instructions already reported by prior read metadata", async () => {
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "subdir", "AGENTS.md"), "# Subdir Instructions")
-        await Bun.write(path.join(dir, "subdir", "nested", "file.ts"), "const x = 1")
-      },
-    })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: () =>
-        run(
-          Instruction.Service.use((svc) =>
-            Effect.gen(function* () {
-              const agents = path.join(tmp.path, "subdir", "AGENTS.md")
-              const filepath = path.join(tmp.path, "subdir", "nested", "file.ts")
-              const id = MessageID.make("message-claim-3")
-
-              const results = yield* svc.resolve(loaded(agents), filepath, id)
-              expect(results).toEqual([])
-            }),
-          ),
-        ),
-    })
-  })
-
-  test.todo("fetches remote instructions from config URLs via HttpClient", () => {})
-})
-
-describe("Instruction.system", () => {
-  test("loads both project and global AGENTS.md when both exist", async () => {
-    const originalConfigDir = process.env["WOOZLIT_CODE_CONFIG_DIR"]
-    delete process.env["WOOZLIT_CODE_CONFIG_DIR"]
-
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Project Instructions")
-      },
-    })
-
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(projectTmp.path, "AGENTS.md"))).toBe(true)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-
-                const rules = (yield* svc.system()).content
-                expect(rules).toHaveLength(2)
-                expect(rules).toContain(
-                  `Instructions from: ${path.join(projectTmp.path, "AGENTS.md")}\n# Project Instructions`,
-                )
-                expect(rules).toContain(
-                  `Instructions from: ${path.join(globalTmp.path, "AGENTS.md")}\n# Global Instructions`,
-                )
-              }),
-            ),
-          ),
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-      if (originalConfigDir === undefined) {
-        delete process.env["WOOZLIT_CODE_CONFIG_DIR"]
-      } else {
-        process.env["WOOZLIT_CODE_CONFIG_DIR"] = originalConfigDir
-      }
-    }
-  })
-})
-
-describe("Instruction.systemPaths WOOZLIT_CODE_CONFIG_DIR", () => {
-  let originalConfigDir: string | undefined
-
-  beforeEach(() => {
-    originalConfigDir = process.env["WOOZLIT_CODE_CONFIG_DIR"]
-  })
-
-  afterEach(() => {
-    if (originalConfigDir === undefined) {
-      delete process.env["WOOZLIT_CODE_CONFIG_DIR"]
-    } else {
-      process.env["WOOZLIT_CODE_CONFIG_DIR"] = originalConfigDir
-    }
-  })
-
-  test("prefers WOOZLIT_CODE_CONFIG_DIR AGENTS.md over global when both exist", async () => {
-    await using profileTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Profile Instructions")
-      },
-    })
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir()
-
-    process.env["WOOZLIT_CODE_CONFIG_DIR"] = profileTmp.path
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(true)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(false)
-              }),
-            ),
-          ),
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-    }
-  })
-
-  test("falls back to global AGENTS.md when WOOZLIT_CODE_CONFIG_DIR has no AGENTS.md", async () => {
-    await using profileTmp = await tmpdir()
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir()
-
-    process.env["WOOZLIT_CODE_CONFIG_DIR"] = profileTmp.path
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(profileTmp.path, "AGENTS.md"))).toBe(false)
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-              }),
-            ),
-          ),
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-    }
-  })
-
-  test("uses global AGENTS.md when WOOZLIT_CODE_CONFIG_DIR is not set", async () => {
-    await using globalTmp = await tmpdir({
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "AGENTS.md"), "# Global Instructions")
-      },
-    })
-    await using projectTmp = await tmpdir()
-
-    delete process.env["WOOZLIT_CODE_CONFIG_DIR"]
-    const originalGlobalConfig = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-
-    try {
-      await Instance.provide({
-        directory: projectTmp.path,
-        fn: () =>
-          run(
-            Instruction.Service.use((svc) =>
-              Effect.gen(function* () {
-                const paths = yield* svc.systemPaths()
-                expect(paths.has(path.join(globalTmp.path, "AGENTS.md"))).toBe(true)
-              }),
-            ),
-          ),
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = originalGlobalConfig
-    }
-  })
-})

package/test/session/invalid-output-continuation.test.ts

@@ -1,150 +0,0 @@
-/**
- * Integration tests for T01: a `finish=stop` step with no usable output
- * (think-only = reasoning only, or empty = nothing at all) must not silently
- * break into an empty assistant. The loop nudges the model to produce a final
- * answer; once the shared continuation counter is exhausted it writes an
- * InvalidOutputError terminal instead of looping forever.
- *
- * Driven through a real Session.prompt(...) against the scripted HTTP LLM stub.
- */
-
-import path from "path"
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session"
-import { SessionPrompt } from "../../src/session/prompt"
-import { Flag } from "../../src/flag/flag"
-import { Log } from "../../src/util"
-import { tmpdir } from "../fixture/fixture"
-import {
-  startScriptedLLMServer,
-  textStopResponse,
-  emptyStopResponse,
-  reasoningStopResponse,
-} from "../lib/scripted-llm-server"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-function run<A, E>(fx: Effect.Effect<A, E, SessionPrompt.Service | Session.Service>) {
-  return Effect.runPromise(
-    fx.pipe(Effect.scoped, Effect.provide(Layer.mergeAll(SessionPrompt.defaultLayer, Session.defaultLayer))),
-  )
-}
-
-function writeConfig(dir: string, origin: string) {
-  return Bun.write(
-    path.join(dir, "WOOZLIT_CODE.json"),
-    JSON.stringify({
-      $schema: "https://opencode.ai/config.json",
-      enabled_providers: ["alibaba"],
-      provider: {
-        alibaba: { options: { apiKey: "test-key", baseURL: `${origin}/v1` } },
-      },
-      agent: { build: { model: "alibaba/qwen-plus" } },
-    }),
-  )
-}
-
-describe("invalid-output continuation — integration", () => {
-  test("empty stop step is nudged, second call produces a non-empty final assistant", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const stub = startScriptedLLMServer([{ lines: emptyStopResponse() }, { lines: textStopResponse("final answer") }])
-    try {
-      await writeConfig(tmp.path, stub.origin)
-      await Instance.provide({
-        directory: tmp.path,
-        fn: () =>
-          run(
-            Effect.gen(function* () {
-              const sessions = yield* Session.Service
-              const prompt = yield* SessionPrompt.Service
-              const session = yield* sessions.create({ title: "invalid-empty" })
-              const result = yield* prompt.prompt({
-                sessionID: session.id,
-                agent: "build",
-                parts: [{ type: "text", text: "Answer my question." }],
-              })
-              // First empty stop => nudge + continue; second call => final text.
-              expect(stub.captures.length).toBe(2)
-              expect(result.info.role).toBe("assistant")
-              if (result.info.role === "assistant") expect(result.info.error).toBeUndefined()
-              expect(result.parts.some((p) => p.type === "text" && p.text === "final answer")).toBe(true)
-            }),
-          ),
-      })
-    } finally {
-      await stub.stop()
-    }
-  })
-
-  test("think-only (reasoning only) stop step is nudged, second call produces a final assistant", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const stub = startScriptedLLMServer([
-      { lines: reasoningStopResponse("let me think about this...") },
-      { lines: textStopResponse("final answer") },
-    ])
-    try {
-      await writeConfig(tmp.path, stub.origin)
-      await Instance.provide({
-        directory: tmp.path,
-        fn: () =>
-          run(
-            Effect.gen(function* () {
-              const sessions = yield* Session.Service
-              const prompt = yield* SessionPrompt.Service
-              const session = yield* sessions.create({ title: "invalid-think-only" })
-              const result = yield* prompt.prompt({
-                sessionID: session.id,
-                agent: "build",
-                parts: [{ type: "text", text: "Answer my question." }],
-              })
-              expect(stub.captures.length).toBe(2)
-              expect(result.info.role).toBe("assistant")
-              if (result.info.role === "assistant") expect(result.info.error).toBeUndefined()
-              expect(result.parts.some((p) => p.type === "text" && p.text === "final answer")).toBe(true)
-            }),
-          ),
-      })
-    } finally {
-      await stub.stop()
-    }
-  })
-
-  test("repeated empty output exhausts the shared limit and writes InvalidOutputError", async () => {
-    await using tmp = await tmpdir({ git: true })
-    // Server repeats the last entry, so every call returns an empty stop.
-    const stub = startScriptedLLMServer([{ lines: emptyStopResponse() }])
-    try {
-      await writeConfig(tmp.path, stub.origin)
-      await Instance.provide({
-        directory: tmp.path,
-        fn: () =>
-          run(
-            Effect.gen(function* () {
-              const sessions = yield* Session.Service
-              const prompt = yield* SessionPrompt.Service
-              const session = yield* sessions.create({ title: "invalid-exhaust" })
-              const result = yield* prompt.prompt({
-                sessionID: session.id,
-                agent: "build",
-                parts: [{ type: "text", text: "Answer my question." }],
-              })
-              // limit nudges + 1 final attempt that trips the terminal error.
-              expect(stub.captures.length).toBe(Flag.WOOZLIT_CODE_INVALID_OUTPUT_CONTINUATION_LIMIT + 1)
-              expect(result.info.role).toBe("assistant")
-              if (result.info.role === "assistant") {
-                expect(result.info.error?.name).toBe("InvalidOutputError")
-              }
-            }),
-          ),
-      })
-    } finally {
-      await stub.stop()
-    }
-  })
-})

package/test/session/last-message-info.test.ts

@@ -1,47 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { computeLastMessageInfo } from "../../src/session/last-message-info"
-
-describe("computeLastMessageInfo", () => {
-  test("assistant with finish=tool-calls", () => {
-    const msgs = [{ role: "assistant", finish: "tool-calls" }]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "assistant", finish: "tool-calls" })
-  })
-
-  test("assistant with finish=stop", () => {
-    const msgs = [{ role: "assistant", finish: "stop" }]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "assistant", finish: "stop" })
-  })
-
-  test("assistant with no finish defaults to stop", () => {
-    const msgs = [{ role: "assistant" }]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "assistant", finish: "stop" })
-  })
-
-  test("assistant with unknown finish defaults to stop", () => {
-    const msgs = [{ role: "assistant", finish: "unknown" }]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "assistant", finish: "stop" })
-  })
-
-  test("tool result at tail", () => {
-    const msgs = [{ role: "tool" }]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "tool" })
-  })
-
-  test("user message at tail", () => {
-    const msgs = [{ role: "user" }]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "user" })
-  })
-
-  test("only inspects last message", () => {
-    const msgs = [
-      { role: "user" },
-      { role: "assistant", finish: "stop" },
-      { role: "user" },
-    ]
-    expect(computeLastMessageInfo(msgs)).toEqual({ role: "user" })
-  })
-
-  test("empty array returns undefined", () => {
-    expect(computeLastMessageInfo([])).toBeUndefined()
-  })
-})