codemode: interrupting execute discards results of nested calls that already finished #54222

Activity

1. opencode-agent commented on Oct 9, 2026

   

   opencode-agentBot

   on Oct 9, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report. I reproduced this from source on the latest v2 (8eff035bf4, the same commit you reported).

   What I did: I registered a dynamic slow_wait tool and had the simulated model run your script through execute. The first nested call finished with waited 1s: FIRST_RESULT_42. I interrupted (Esc) while the 600s call was running, then sent a follow-up prompt.

   The recording below shows the TUI marking the first slow_wait call as finished. However, the follow-up request sends the model only this for the execute call:

   {"error":{"type":"aborted","message":"Tool execution interrupted"},"content":[]}
   

   The first result and the console.log output are both missing. A standalone test in packages/codemode gave the same result: the call hooks report the first call as success, but execute ends as a bare interruption, so logs and the finished results never reach the result. That fits your reading of execute.ts. The script below reproduces it with opencode-drive.

   recording.mp4

   

   Reproduction script (drive.ts)

   import { Effect, Stream } from "effect"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   const code = `const first = await tools.slow_wait({ seconds: 1 })
   console.log("first:", first)
   await tools.slow_wait({ seconds: 600 })
   return first`
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       tui: { recording: true, keypressOverlay: true },
     },
     ({ ui, llm, tools }) =>
       Effect.gen(function* () {
         yield* tools.attach({
           tools: [
             {
               name: "slow_wait",
               description: "Wait for the given number of seconds",
               inputSchema: { type: "object", properties: { seconds: { type: "number" } }, required: ["seconds"] },
               outputSchema: { type: "object", properties: { waited: { type: "number" } }, required: ["waited"] },
             },
           ],
         })
         const bodies: Array<unknown> = []
         yield* llm.serve((request, index) => {
           bodies.push(request.body)
           return index === 0
             ? Stream.make(Llm.toolCall({ index: 0, id: "call_exec", name: "execute", input: { code } }), Llm.finish("tool-calls"))
             : Stream.make(Llm.text("Follow-up turn."))
         })
         yield* ui.submit("Run the slow script")
         const first = yield* tools.take()
         yield* Effect.log(`first nested call: ${JSON.stringify(first.input)}`)
         yield* Effect.sleep(1000)
         yield* first.finish({ structured: { waited: 1 }, content: [{ type: "text", text: "waited 1s: FIRST_RESULT_42" }] })
         const second = yield* tools.take()
         yield* Effect.log(`second nested call: ${JSON.stringify(second.input)}`)
         yield* Effect.sleep(1500)
         yield* ui.screenshot("before-interrupt")
         yield* ui.press("escape")
         yield* Effect.sleep(300)
         yield* ui.press("escape")
         yield* Effect.sleep(2500)
         yield* ui.screenshot("after-interrupt")
         // Ask a follow-up so we can see what the model receives for the interrupted execute call.
         yield* ui.submit("What did the first call return?")
         yield* ui.waitFor("Follow-up turn.")
         yield* ui.screenshot("follow-up")
         const follow = JSON.stringify(bodies.at(-1))
         const at = follow.indexOf("call_exec", follow.indexOf("call_exec") + 1)
         const messages = (bodies.at(-1) as { messages?: Array<{ role: string; tool_call_id?: string; content?: unknown }> }).messages ?? []
         const toolMsg = JSON.stringify(messages.find((m) => m.role === "tool" && m.tool_call_id === "call_exec")?.content ?? null)
         yield* Effect.log(`execute result sent to the model on the next turn:\n${follow.slice(Math.max(0, at - 200), at + 600)}`)
         yield* Effect.log(`execute tool result contains FIRST_RESULT_42: ${toolMsg.includes("FIRST_RESULT_42")}; contains the logged "first:" line: ${toolMsg.includes("first:")}\n${toolMsg}`)
       }),
   )

   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 9, 2026