session: upstream rejects with missing 'reasoning_content' on older assistant message after model/provider switch #55096

Activity

1. opencode-agent commented on Oct 13, 2026

   

   opencode-agentBot

   on Oct 13, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report. I was able to reproduce this on 2.0.28, and it still happens on the latest dev (4ffede4).

   What I did, using a simulated OpenAI-compatible thinking model that sends reasoning back in reasoning_content:

   1. One normal turn with reasoning and a reply.
   2. A turn where the model reasons and then starts a foreground shell command, which is interrupted ("Tool execution interrupted").
   3. A follow-up message, "continue".

   In the request for step 3, the completed turn is sent with its reasoning_content. The interrupted assistant message is sent with an empty reasoning_content, and its reasoning text is moved into the normal message content. A provider that needs the reasoning of every earlier assistant message rejects that, which matches your Missing required parameter: 'messages[N].reasoning_content' error. Because the same message is sent again on every request, the session stays broken. No provider or model switch was needed, so the provider.updated / model.updated events in your log were probably a coincidence. The interrupted tool call is what triggers it.

   The recording and screenshot below show the run, and the script below reproduces it.

   Related: #38620 is the same underlying behaviour hitting Anthropic thinking, and #54693 is an open PR in this area. Starting a new session remains the workaround for now.

   recording.mp4

   

   Reproduction script (drive.ts)

   // Repro for #55096: an interrupted assistant turn (reasoning + shell tool call)
   // is replayed on the next request without its reasoning (reasoning_content),
   // which providers that require reasoning on every earlier assistant message reject.
   import { Effect, Stream } from "effect"
   import { appendFileSync, writeFileSync } from "node:fs"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   const LOG = "/workspace/repro/requests.jsonl"
   writeFileSync(LOG, "")
   
   const describe = (body: any) => {
     const msgs: any[] = body?.messages ?? body?.input ?? []
     return msgs
       .map((m, i) => ({ i, m }))
       .filter(({ m }) => m.role === "assistant")
       .map(({ i, m }) => {
         const has = typeof m.reasoning_content === "string" && m.reasoning_content.length > 0
         return `messages[${i}] reasoning_content=${has ? "present" : "MISSING"}`
       })
   }
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       tui: { recording: true },
       tools: ["shell"],
       // Make the simulated OpenAI-compatible model behave like a DeepSeek/Kimi-style
       // thinking model on Zen: reasoning is carried in `reasoning_content`.
       config: {
         providers: {
           simulation: {
             models: { "gpt-sim-model": { compatibility: { reasoningField: "reasoning_content" } } },
           },
         },
       } as any,
     },
     ({ ui, llm, tools }) =>
       Effect.gen(function* () {
         const shells = yield* tools.control("shell")
         yield* llm.serve((request, index) => {
           appendFileSync(LOG, JSON.stringify({ index, url: request.url, body: request.body }) + "\n")
           // Turn 1: a normal completed reasoning turn (control).
           if (index === 0)
             return Stream.make(Llm.reasoning("The user says hi."), Llm.text("Hello!"))
           // Turn 2: reasoning + a foreground shell call that will be interrupted.
           if (index === 1)
             return Stream.make(
               Llm.reasoning("I should wait for the build with a sleep command."),
               Llm.toolCall({ index: 0, id: "call_sleep", name: "shell", input: { command: "Start-Sleep 600", description: "wait" } }),
               Llm.finish("tool-calls"),
             )
           const lines = describe(request.body)
           const missing = lines.some((l) => l.includes("MISSING"))
           return Stream.make(
             Llm.reasoning("Checking history."),
             Llm.text(
               (missing
                 ? "UPSTREAM WOULD REJECT: Missing required parameter reasoning_content. "
                 : "OK: every assistant message has reasoning_content. ") + lines.join("; "),
             ),
           )
         })
         yield* ui.submit("hi")
         yield* ui.waitFor("Hello!")
         yield* ui.submit("Run the build and wait for it")
         const shell = yield* shells.take("call_sleep")
         yield* shell.progress("Sleeping...\n")
         yield* Effect.sleep(1500)
         // Interrupt the turn while the foreground shell is running.
         yield* ui.press("escape")
         yield* Effect.sleep(300)
         yield* ui.press("escape")
         yield* Effect.sleep(2000)
         yield* ui.screenshot("interrupted")
         yield* ui.submit("continue")
         yield* ui.waitFor("reasoning_content", { timeout: 20000 } as any)
         yield* Effect.sleep(1000)
         yield* ui.screenshot("result")
       }),
   )

   Run it with opencode-drive: opencode-drive run ./drive.ts. It drives opencode from your PATH; set OC_DEV to the path of an OpenCode checkout to run that from source instead.
2. opencode-agent

   added

   reproduced

   on Oct 13, 2026
3. JonnieDoe commented on Nov 3, 2026

   

   JonnieDoe

   on Nov 3, 2026

   More actions

   Same error on v2.2.5 (macOS 27.2.0 arm64, tmux/zsh, channel: latest), this time at messages[20]:

   Error: Missing required parameter: 'messages[20].reasoning_content'. This model needs the reasoning of every earlier assistant message: send back the 'reasoning_content' returned with that message. If 'reasoning_content' is not available, consider starting a new session or conversation history.
   

   Provider: custom OpenAI-compatible endpoint (reflection.ai, via @ai-sdk/openai-compatible), model Beam-1.0-501B-A23B — a thinking model served with DeepSeek-style reasoning_content semantics.
   Context:

   • No deliberate turn interruption and no mid-session model/provider switch were involved; the error appeared during ordinary chat/tool use, so the offending message may come from another path that drops reasoning_content (e.g. aborted/errored turns, compaction). Trigger unclear.
   • The session became unusable: every subsequent request failed with the same error. Starting a new session fixed it (matches the documented workaround).
   • Plugins active in the affected session: opencode-mem, @dietrichgebert/ponytail, superpowers, oh-my-opencode-slim, envsitter-guard (local), @tarquinen/opencode-dcp, @openchamber/opencode-claude.
4. rekram1-node

   self-assigned this

   on Nov 13, 2026
5. opencode-agent commented on Nov 13, 2026

   

   opencode-agentBot

   on Nov 13, 2026 – with OpenCode Agent

   Contributor

   More actions

   @CTKiet2006 @JonnieDoe thanks both, and sorry this bricks the session.

   Workaround: tell OpenCode the model needs reasoning_content sent back on every earlier assistant message. Add a compatibility block to the model in opencode.jsonc:

   @CTKiet2006 (built-in opencode provider). Put in the model ID you were using:

   {
     "providers": {
       "opencode": {
         "models": {
           "<model-id>": {
             "compatibility": {
               "reasoningField": "reasoning_content",
               "requireReasoning": true
             }
           }
         }
       }
     }
   }

   @JonnieDoe (custom reflection.ai endpoint). Add it to the model you already have, or to the provider so it covers every model there:

   {
     "providers": {
       "reflection": {
         "package": "@ai-sdk/openai-compatible",
         // ...your existing settings
         "models": {
           "Beam-1.0-501B-A23B": {
             "compatibility": {
               "reasoningField": "reasoning_content",
               "requireReasoning": true
             }
           }
         }
       }
     }
   }

   With this set, OpenCode always sends reasoning_content on earlier assistant messages, even ones that have no reasoning stored.

   If it still fails after that, please send:

   • @CTKiet2006: the exact model ID, and an export (opencode export <sessionID>) or just the assistant message at the failing index, with anything sensitive removed. We mainly want to know whether that message has a reasoning part and whether it was the interrupted turn.
   • @JonnieDoe: whether it still happens with plugins disabled, especially @tarquinen/opencode-dcp, since it prunes context and could strip reasoning from old messages. Also the message at messages[20] if it happens again.
   • Both: whether the failing request had "reasoning_content": "" (an empty string) on that message or no field at all. That tells us whether the provider rejects an empty value, which decides the fix on our side.