session: title generation request has no output limit and runs away on local thinking models #54401

Activity

1. opencode-agent commented on Oct 10, 2026

   

   opencode-agentBot

   on Oct 10, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report, it made this easy to confirm.

   I reproduced it with a fake LM Studio server that logs request bodies. The model was lmstudio/qwen3.5-4b@q4_k_m, and I sent hello once:

   • 2.0.26: the session-title request had no max_completion_tokens, max_tokens or stop. The main agent request in the same run had max_completion_tokens of about 27k.
   • Latest dev (7b3d4ce): same result.

   In the code, the output limit is only applied to the main agent request and to compaction, so title requests go out with no limit. With a thinking model, nothing stops the title request until the model's context runs out. I couldn't run a real thinking model here, so I confirmed the missing limit but not the long reasoning loop itself.

   The script below reproduces it.

   The duplicated main request on the first message is probably a separate problem; please open a separate issue for it.

   Related: #54185 (title agent replies conversationally), #53536 (think tags in auto-titles).

   Reproduction script (repro.sh)

   #!/usr/bin/env bash
   # Repro for anomalyco/opencode#54401: the session-title request has no output-token limit.
   # Starts a fake LM Studio server on 127.0.0.1:1234 that logs every
   # /v1/chat/completions body, runs one prompt, and prints which requests set a token limit.
   # Usage: ./repro.sh            (uses `opencode` from PATH)
   #        OC_DEV=/workspace/repo ./repro.sh   (runs from a source checkout)
   set -euo pipefail
   WORK=$(mktemp -d /tmp/opencode/repro54401.XXXX)
   LOG="$WORK/requests.jsonl"
   cat >"$WORK/mock.ts" <<'EOF'
   const log = process.env.LOG!
   Bun.serve({
     port: 1234, hostname: "127.0.0.1",
     async fetch(req) {
       const url = new URL(req.url)
       if (url.pathname === "/api/v1/models") return Response.json({ models: [{
         type: "llm", key: "qwen3.5-4b@q4_k_m", display_name: "Qwen3.5 4B", architecture: "qwen3",
         loaded_instances: [{ config: { context_length: 32768 } }], max_context_length: 32768,
         capabilities: { vision: false, trained_for_tool_use: true } }] })
       if (url.pathname === "/v1/models") return Response.json({ object: "list", data: [{ id: "qwen3.5-4b@q4_k_m", object: "model" }] })
       if (url.pathname === "/v1/chat/completions") {
         const body = await req.json()
         await Bun.write(Bun.file(log), (await Bun.file(log).exists() ? await Bun.file(log).text() : "") + JSON.stringify(body) + "\n")
         const isTitle = JSON.stringify(body.messages?.[0] ?? "").includes("title generator")
         const text = isTitle ? "Greeting" : "Hi there!"
         const enc = new TextEncoder()
         const chunk = (o: any) => enc.encode(`data: ${JSON.stringify(o)}\n\n`)
         const base = { id: "c1", object: "chat.completion.chunk", created: 0, model: body.model }
         return new Response(new ReadableStream({ start(c) {
           c.enqueue(chunk({ ...base, choices: [{ index: 0, delta: { role: "assistant", content: text }, finish_reason: null }] }))
           c.enqueue(chunk({ ...base, choices: [{ index: 0, delta: {}, finish_reason: "stop" }] }))
           c.enqueue(chunk({ ...base, choices: [], usage: { prompt_tokens: 10, completion_tokens: 2, total_tokens: 12 } }))
           c.enqueue(enc.encode("data: [DONE]\n\n")); c.close() } }), { headers: { "content-type": "text/event-stream" } })
       }
       return new Response("not found", { status: 404 })
     },
   })
   EOF
   LOG="$LOG" bun "$WORK/mock.ts" & MOCK=$!
   trap 'kill $MOCK 2>/dev/null' EXIT
   sleep 1
   mkdir -p "$WORK/project" && cd "$WORK/project" && git init -q
   export HOME="$WORK/home" XDG_CONFIG_HOME="$WORK/home/.config" XDG_DATA_HOME="$WORK/home/.local/share" XDG_STATE_HOME="$WORK/home/.local/state" XDG_CACHE_HOME="$WORK/home/.cache"
   mkdir -p "$XDG_CONFIG_HOME/opencode"
   echo '{ "model": "lmstudio/qwen3.5-4b@q4_k_m" }' >"$XDG_CONFIG_HOME/opencode/opencode.json"
   if [ -n "${OC_DEV:-}" ]; then
     OC=(bun --conditions=browser --preload="$OC_DEV/packages/tui/node_modules/@opentui/solid/scripts/preload.js" "$OC_DEV/packages/cli/src/index.ts")
   else OC=(opencode); fi
   "${OC[@]}" --version
   if [ -n "${OC_DEV:-}" ]; then
     # From source the spawned standalone child lacks the TUI preload, so start the server ourselves.
     OPENCODE_PASSWORD=repro "${OC[@]}" serve --port 4599 >"$WORK/serve.log" 2>&1 & SERVE=$!
     trap 'kill $MOCK $SERVE 2>/dev/null' EXIT
     for i in $(seq 60); do curl -s -o /dev/null http://127.0.0.1:4599 && break; sleep 1; done
     OPENCODE_PASSWORD=repro timeout 90 "${OC[@]}" run --server http://127.0.0.1:4599 hello || true
   else
     timeout 90 "${OC[@]}" run --standalone hello || true
   fi
   sleep 5
   echo "=== chat/completions requests ==="
   bun -e '
   for (const line of (await Bun.file(process.argv[1]).text()).trim().split("\n")) {
     const b = JSON.parse(line)
     const kind = JSON.stringify(b.messages?.[0]).includes("title generator") ? "TITLE" : "MAIN "
     console.log(kind, "max_completion_tokens=", b.max_completion_tokens, "max_tokens=", b.max_tokens, "stop=", b.stop, "reasoning_effort=", b.reasoning_effort)
   }' "$LOG"

   Run it: bash repro.sh
2. opencode-agent

   added

   reproduced

   on Oct 10, 2026
3. pxzleo commented on Oct 16, 2026

   

   pxzleo

   on Oct 16, 2026

   More actions

   Additional real-model confirmation on OpenCode v2.0.29 on Windows, using the OpenCode executable bundled with OpenChamber. In this case, a background title consumed 36,127 completion tokens and 501.5 seconds, occupying the local backend's only inference slot while the main task waited.

   Environment and observed request

   • OpenAI-compatible backend: Strata 0.1.44.1, one inference slot.
   • Model: qwen3.8-flash-next-unsloth-ud-q5_k_xl.
   • Configured model limits: context: 262144, output: 32768; normal task reasoning variant: high.
   • The normal agent requests did carry an effective output limit of 32,768. This is specifically an auxiliary-title exception, not a claim that all v2 requests ignore limit.output.

   Observed title-request metric	Value
   Input tokens	712
   Completion tokens, including reasoning	36,127
   Backend effective maximum	261,424
   Duration	501.5 s, about 8 min 22 s
   Finish reason	stop

   The backend's effective maximum is consistent with its fallback for an omitted output limit: 262144 - 712 - 8 = 261424. Consequently, the title could exceed the configured 32,768 model output limit and still finish normally. These are completion-token counts, not the length of the visible title.

   To distinguish this from a long main-agent response, I reconciled a consistent read-only SQLite snapshot: the session's accumulated usage was 20,872 input / 120,290 output, while its 24 ordinary assistant records summed to 20,160 input / 84,163 output. The difference is exactly 712 input / 36,127 output, matching the backend request. The title implementation accounts for title usage at session level without adding an ordinary assistant reply. The request also began immediately after session creation.

   Version-specific source confirmation

   In v2.0.29 session/model-request.ts, only primary and compaction initially receive maxTokens; title and generate start with empty options. The OpenAI protocol conversion therefore has no generation limit to serialize for the unmodified title request.

   The runner starts title generation asynchronously, but application-side concurrency does not prevent slot contention: on a single-slot local server, a title that gets the slot first still delays the useful task for the full generation duration. This reproduces the impact on a GPU-backed server as well as the original CPU-only report.

   Local mitigation verification, separate from the proposed upstream PRs

   I tested a temporary user-directory session.title plugin with the actual installed v2.0.29 executable, an isolated configuration/database, and a fake OpenAI-compatible backend. It waits for the current session's agent loop to become idle, then sets maxTokens: 128 and reasoningEffort: "none" for a compatible model with an explicit supported off setting. Observed wire order and parameters:

   1. Main request: max_completion_tokens: 32768, reasoning_effort: "high".
   2. After the main response finished, title request: max_completion_tokens: 128, reasoning_effort: "none".

   For an unverified/no-off configuration, the plugin returns a short local title instead of making a title model call; the isolated test observed only the main request. This is a local mitigation test, not a test of either upstream PR.

   The bounded title budget in #54411 and lower-reasoning selection in #51939 both seem relevant. A small title-specific cap plus a provider-supported non-thinking mode would address the two causes without reducing normal task output/reasoning settings. Giving auxiliary titles lower priority is also valuable for single-slot backends. No private prompts, conversation text, credentials, or full logs are included here.
4. eatmoreduck

   added 2 commits that reference this issue on Oct 22, 2026

   fix(core): bound session title generation with a small output limit

   ...

   This issue will close once commit 843746d is merged into the 'dev' branch.

   843746d

   fix(core): size the title cap to leave room for a thinking budget

   ...

   This issue will close once commit 3f70b0d is merged into the 'dev' branch.

   3f70b0d
5. eatmoreduck

   added 2 commits that reference this issue on Nov 4, 2026

   fix(core): bound session title generation with a small output limit

   ...

   This issue will close once commit 48f4655 is merged into the 'dev' branch.

   48f4655

   fix(core): size the title cap to leave room for a thinking budget

   ...

   This issue will close once commit 1c92b93 is merged into the 'dev' branch.

   1c92b93