2.x: recovery after a reasoning-only turn that stops with length replays an empty assistant message (400 "must not be empty" on strict providers) #60292

Activity

1. opencodejr commented on Oct 29, 2026

   

   opencodejrBot

   on Oct 29, 2026

   Contributor

   More actions

   Thanks for the detailed report and the script. I could reproduce this.

   The script below is your reproduction, lightly adapted. It runs opencode run --standalone --format json against a fake OpenAI-compatible server that rejects empty assistant messages, and its first reply is reasoning only, ending with finish_reason: "length".

   • 2.2.1: the output-limit recovery request replays the truncated turn as assistant(content="", reasoning_content="thinking about it"). The request gets a 400 and the run exits 1 with provider.invalid-request: the message at position 2 with role 'assistant' must not be empty.
   • Latest dev (3eb834b): same requests, same 400, same exit code.

   Related:

   • core: standalone signed-empty reasoning turns are replayed into later requests #46881: standalone signed-empty reasoning turns replayed in v2. Same message-building filter, but a different turn shape.
   • fix(core): drop assistant turns with no provider content at the ai-sdk wire boundary #56942: open PR adding an empty-assistant guard at the AI SDK boundary. It keeps reasoning parts, so on its own it may not cover this case.
   • Aborted assistant turn persisted with zero content bricks the session: empty assistant message replayed to provider (400 "must not be empty") #37946 / Assistant messages with no provider content permanently wedge sessions on strict providers (Kimi 400 must not be empty) #53571: the same 400 in v1, reached by replaying aborted turns.

   Reproduction script (repro-empty-assistant.mjs)

   // Reproduction for anomalyco/opencode#60292 (adapted from the report).
   // A turn that streams only reasoning and ends with finish_reason "length" makes OpenCode 2.x send an
   // output-limit recovery request that replays the truncated turn as an assistant message with content "".
   // A fake OpenAI-compatible server on 127.0.0.1 stands in for a strict provider (like Kimi): it answers 400
   // when an assistant message has neither content nor tool calls.
   //
   //   node repro-empty-assistant.mjs [opencode-binary]      (default: `opencode` from PATH)
   //
   // No account or key is needed. OpenCode runs with a throwaway HOME and XDG directories.
   import { createServer } from 'node:http';
   import { spawn, execFileSync } from 'node:child_process';
   import { mkdtemp, mkdir, rm } from 'node:fs/promises';
   import { tmpdir } from 'node:os';
   import { join } from 'node:path';
   
   const bin = process.argv[2] ?? 'opencode';
   const version = execFileSync(bin, ['--version'], { encoding: 'utf8' }).trim();
   
   const text = m => typeof m.content === 'string' ? m.content : (m.content ?? []).map(p => p.text ?? '').join('');
   const emptyAssistant = m => m.role === 'assistant' && !m.tool_calls?.length && !text(m).length;
   const describe = (m, i) => m.role + (m.role === 'assistant'
     ? `(content=${JSON.stringify(m.content)}${m.reasoning_content ? `, reasoning_content=${JSON.stringify(m.reasoning_content)}` : ''})`
     : m.role === 'user' && i > 1 ? `(${JSON.stringify(text(m).slice(0, 90))}...)` : '');
   const requests = [];
   const server = createServer(async (req, res) => {
     let raw = ''; for await (const chunk of req) raw += chunk;
     const body = JSON.parse(raw || '{}');
     requests.push(body.messages);
     const send = choices => res.write(`data: ${JSON.stringify({ id: 'c', object: 'chat.completion.chunk', created: 1, model: 'fixture', choices })}\n\n`);
     const bad = body.messages.findIndex(emptyAssistant);
     if (bad >= 0) {
       res.statusCode = 400; res.setHeader('Content-Type', 'application/json');
       return res.end(JSON.stringify({ error: { type: 'invalid_request_error', message: `the message at position ${bad} with role 'assistant' must not be empty` } }));
     }
     res.setHeader('Content-Type', 'text/event-stream');
     if (requests.length === 1) { // reasoning only, then the output budget runs out
       send([{ index: 0, delta: { role: 'assistant', reasoning_content: 'thinking about it' }, finish_reason: null }]);
       send([{ index: 0, delta: {}, finish_reason: 'length' }]);
     } else {
       send([{ index: 0, delta: { role: 'assistant', content: 'done' }, finish_reason: null }]);
       send([{ index: 0, delta: {}, finish_reason: 'stop' }]);
     }
     res.write('data: [DONE]\n\n'); res.end();
   });
   await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
   
   const root = await mkdtemp(join(tmpdir(), 'opencode-repro-'));
   const project = join(root, 'project'), home = join(root, 'home');
   await mkdir(project); await mkdir(home);
   const config = { enabled_providers: ['fixture'], provider: { fixture: { npm: '@ai-sdk/openai-compatible', name: 'Fixture',
     options: { baseURL: `http://127.0.0.1:${server.address().port}/v1`, apiKey: 'not-a-key' },
     models: { fixture: { name: 'fixture', limit: { context: 32000, output: 1024 } } } } } };
   const env = { PATH: process.env.PATH, HOME: home, XDG_CONFIG_HOME: join(home, 'config'), XDG_DATA_HOME: join(home, 'data'),
     XDG_CACHE_HOME: join(home, 'cache'), XDG_STATE_HOME: join(home, 'state'), TMPDIR: root,
     OPENCODE_CONFIG_CONTENT: JSON.stringify(config), OPENCODE_DISABLE_MODELS_FETCH: 'true', OPENCODE_DISABLE_AUTOUPDATE: 'true' };
   const args = ['run', '--standalone', '--format', 'json', '--model', 'fixture/fixture', '--title', 'repro', 'Say hi.'];
   let stdout = '';
   const child = spawn(bin, args, { cwd: project, env, stdio: ['ignore', 'pipe', 'ignore'] });
   child.stdout.on('data', b => { stdout += b; });
   const code = await new Promise(resolve => child.once('close', resolve));
   
   console.log(`opencode: ${version}`);
   requests.forEach((messages, i) => {
     const bad = messages.findIndex(emptyAssistant);
     console.log(`request ${i + 1}: [${messages.map(describe).join(', ')}]${bad >= 0 ? `  -> 400, empty assistant message at position ${bad}` : ''}`);
   });
   console.log(`exit code: ${code}`);
   for (const line of stdout.split('\n').filter(Boolean)) {
     try { const e = JSON.parse(line); if (e.type === 'error') console.log(`error: ${e.error?.type}: ${e.error?.message}`); } catch {}
   }
   server.closeAllConnections(); server.close(); await rm(root, { recursive: true, force: true });

   Run it: bun repro-empty-assistant.mjs
2. opencodejr

   added

   reproduced

   on Oct 29, 2026