T1 — ReAct loop với finish-reason-aware exit

{`
while (true) {
  yield* status.set(sessionID, { type: "busy" })
  let msgs = yield* MessageV2.filterCompactedEffect(sessionID)

  // Guard 1: lastAssistant?.finish — model đã có response chưa?
  // Guard 2: !["tool-calls"].includes(lastAssistant.finish) — không còn tool pending?
  // Guard 3: !hasToolCalls — không có tool call nào trong current response?
  // Guard 4: lastUser.id < lastAssistant.id — assistant đã respond sau user chưa?
  if (
    lastAssistant?.finish &&
    !["tool-calls"].includes(lastAssistant.finish) &&
    !hasToolCalls &&
    lastUser.id < lastAssistant.id
  ) {
    yield* slog.info("exiting loop")
    break
  }

  step++
  const result = yield* handle.process(streamInput)
  if (result === "stop") return "break"
  if (result === "compact") yield* compaction.create(...)
}
`}

{`
step++  // tăng SAU khi check exit, không trước

const result = yield* handle.process(streamInput)
// result có thể là:
// "stop"    → user cancel hoặc error không thể recover
// "compact" → context overflow, cần compact trước khi tiếp
// undefined → normal, tiếp tục loop
`}

{`
// Mỗi yield* là một "suspension point" — Effect có thể interrupt tại đây
// nếu user cancel hoặc có lỗi unrecoverable
yield* status.set(sessionID, { type: "busy" })
yield* slog.info("loop", { step })
`}

{`
// WRONG: exit ngay khi stop, không kiểm tra tool_calls
while (true) {
  const resp = await llm.call(messages)
  if (resp.finishReason === "stop") break  // có thể bỏ rơi tool calls!
  for (const tc of resp.toolCalls) {
    messages.push(await executeToolCall(tc))
  }
}
// Nếu model trả finish_reason=stop VÀ tool_calls=[...] cùng lúc
// → tool không được chạy → model nhận context thiếu
`}

{`
// Nếu handle.process() không trả về "stop" khi doom loop detected
// → T1 tiếp tục gọi model vô hạn
const result = yield* handle.process(streamInput)
// PHẢI check:
if (result === "stop") return "break"
`}

{`
// Nếu retry không reset step → T5 sẽ wrap ALL user messages
// ngay từ step đầu, không phải chỉ step > 1
// → prompt bloated không cần thiết

// opencode: step là local variable trong runLoop scope
// mỗi session invocation bắt đầu từ 0
let step = 0
`}

{`
interface LLMResponse {
  finishReason: "stop" | "tool_calls" | "length" | "end_turn"
  toolCalls: ToolCall[]
  content: string
}

interface ToolCall {
  id: string
  name: string
  input: unknown
}

async function runFinishAwareLoop(
  messages: Message[],
  callLLM: (msgs: Message[]) => Promise<LLMResponse>,
  executeTool: (tc: ToolCall) => Promise<unknown>,
  options = { maxSteps: 50 }
) {
  let lastResponse: LLMResponse | null = null
  let step = 0

  while (true) {
    // EXIT CHECK: tất cả điều kiện phải thỏa
    const hasToolCalls = lastResponse?.toolCalls.length ?? 0 > 0
    if (
      lastResponse !== null &&
      lastResponse.finishReason !== "tool_calls" &&
      !hasToolCalls
    ) {
      break
    }

    if (step >= options.maxSteps) {
      throw new Error("Max steps exceeded — possible doom loop")
    }

    step++

    // Gọi model
    const response = await callLLM(messages)
    messages.push({ role: "assistant", content: response.content })
    lastResponse = response

    // Execute ALL tool calls — không skip ngay cả khi finishReason=stop
    if (response.toolCalls.length > 0) {
      const results = await Promise.all(
        response.toolCalls.map(async (tc) => ({
          toolCallId: tc.id,
          result: await executeTool(tc),
        }))
      )
      messages.push({ role: "tool", toolResults: results })
    }
  }

  return lastResponse
}
`}