diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts index e4c985daa1652..cd1bdc9044a5c 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts @@ -8074,12 +8074,13 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { ); it.effect.each([ - { status: "complete", reconnect: false }, - { status: "paused", reconnect: false }, - { status: "complete", reconnect: true }, + { status: "complete", reconnect: false, silent: false }, + { status: "paused", reconnect: false, silent: false }, + { status: "complete", reconnect: true, silent: false }, + { status: "paused", reconnect: false, silent: true }, ] as const)( - "keeps an OpenCode goal turn open until $status, with reconnect $reconnect", - ({ status, reconnect }) => + "keeps an OpenCode goal turn open until $status, with reconnect $reconnect and silent $silent", + ({ status, reconnect, silent }) => Effect.gen(function* () { const recovered = reconnected({ [SESSION]: { type: "running" } }); const { runtime, thread } = yield* resumed( @@ -8092,6 +8093,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { reply("session.command", null), event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("active") }), event("session.execution.succeeded", { sessionID: SESSION }), + out("rpc.call", ""), + reply("rpc.call", { output: nativeGoal(silent ? status : "active") }), ...(status === "complete" ? reconnect ? [ @@ -8104,7 +8107,14 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { ] : [event("session.execution.started", { sessionID: SESSION })] : []), - event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal(status) }), + ...(silent + ? [] + : [ + event("rpc.opencode.goal.changed", { + sessionID: SESSION, + goal: nativeGoal(status), + }), + ]), ...(status === "complete" ? [ event("session.text.ended", { @@ -8251,6 +8261,64 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { }), ); + it.effect("a goal refresh that reconnect supersedes leaves the turn to reconnect's read", () => + Effect.gen(function* () { + const gate = makeProviderReplayGate(["before-reconnect", "reconnect-reading"]); + const recovered = reconnected({ [SESSION]: { type: "running" } }); + const elsewhere = { sessionID: "ses_elsewhere", goal: null }; + const { runtime, thread } = yield* resumed( + [ + out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "" }), + promptAccepted, + event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("active") }), + event("session.execution.succeeded", { sessionID: SESSION }), + out("rpc.call", ""), + reply("rpc.call", ""), + event("rpc.opencode.goal.changed", elsewhere, "before-reconnect"), + ...recovered.slice(0, 2), + out("rpc.call", ""), + event("rpc.opencode.goal.changed", elsewhere, "reconnect-reading"), + reply("rpc.call", { output: nativeGoal("active") }), + ...emptyShellInventory, + ...recovered.slice(2), + ...noOpenRequests, + event("session.execution.started", { sessionID: SESSION }), + event("session.text.ended", { + sessionID: SESSION, + assistantMessageID: "msg_goal_final", + ordinal: 0, + text: "Final goal output", + }), + event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("complete") }), + event("session.execution.succeeded", { sessionID: SESSION }), + ], + { version: "2.2.5", replayGate: gate }, + ); + const events = yield* runtime.events.pipe( + Stream.takeUntil((e) => e.type === "turn.terminal"), + Stream.runCollect, + Effect.forkScoped, + ); + yield* runtime.startTurn(turnInput(thread)); + yield* Effect.promise(() => gate.waitForReached("before-reconnect")); + yield* TestClock.adjust("3 seconds"); + gate.release("before-reconnect"); + yield* Effect.promise(() => gate.waitForReached("reconnect-reading")); + yield* TestClock.adjust("2 seconds"); + gate.release("reconnect-reading"); + const collected = yield* Fiber.join(events); + assert.isTrue( + collected.some( + (e) => + e.type === "turn_item.updated" && + e.turnItem.type === "assistant_message" && + e.turnItem.text === "Final goal output", + ), + ); + assert.deepInclude(collected.at(-1), { type: "turn.terminal", status: "completed" }); + }), + ); + it.effect.each([ { initial: "active", recovered: "paused" }, { initial: "paused", recovered: "active" }, @@ -8273,6 +8341,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { reply("rpc.call", { output: recovered === "unreadable" ? {} : nativeGoal(recovered) }), ...(recovered === "active" ? [ + out("rpc.call", ""), + reply("rpc.call", { output: nativeGoal("active") }), event("session.execution.started", { sessionID: SESSION }), event("session.text.ended", { sessionID: SESSION, diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts index 2d787b0c5f0b9..0072f9d1897b7 100644 --- a/packages/provider-opencode/src/server/v2/adapter.ts +++ b/packages/provider-opencode/src/server/v2/adapter.ts @@ -1052,9 +1052,11 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr input: { sessionID: state.sessionId }, }); const goal = yield* decodeGoal(result.output); - yield* lock.withPermit( + return yield* lock.withPermit( Effect.gen(function* () { - if (state.goalRevision === revision) yield* updateGoal(state, goal); + if (state.goalRevision !== revision) return false; + yield* updateGoal(state, goal); + return true; }), ); }); @@ -3182,6 +3184,9 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ) { if (end.status === "completed" && (turn.steers.size > 0 || goalHoldsTurn(state))) { turn.heldEnd = end; + // OpenCode can pause a goal without telling this server, such as another process's + // restart sweep, so confirm the goal is still active before waiting on it. + if (goalHoldsTurn(state) && !state.goalRefreshing) yield* refreshGoal(state); return; } yield* finishTurn(state, end); @@ -3192,6 +3197,33 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ? finishTurn(state, turn.heldEnd) : Effect.void; + // Holds a goal turn until OpenCode's goal is read again; a failed read releases it. + const refreshGoal = Effect.fnUntraced(function* (state: ThreadState) { + state.goalFresh = false; + state.goalRefreshing = true; + state.goalRevision += 1; + const revision = state.goalRevision; + yield* Effect.forkIn( + readGoal(state).pipe( + Effect.timeout(INVENTORY_TIMEOUT), + Effect.catch(() => + Effect.logWarning("Could not refresh OpenCode goal state.").pipe(Effect.as(false)), + ), + Effect.flatMap((applied) => + lock.withPermit( + Effect.gen(function* () { + if (state.goalRevision === revision) state.goalRefreshing = false; + // A newer goal event or a reconnect's read owns settlement now. + else if (!applied) return; + if (state.active !== undefined) yield* endIfSettled(state, state.active); + }), + ), + ), + ), + sessionScope, + ); + }); + const handleEvent = Effect.fnUntraced(function* (event: OpenCode2Client.OpenCode2StreamEvent) { if (event.type === "shell.created") { const sessionId = stringField(event.data.info.metadata, "sessionID"); @@ -3353,33 +3385,10 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr if (!supportsNativeGoals()) return; const goal = yield* decodeGoal(event.data["goal"]).pipe(Effect.result); if (goal._tag === "Failure") { - state.goalFresh = false; - state.goalRefreshing = true; - state.goalRevision += 1; - const revision = state.goalRevision; yield* Effect.logWarning( "Could not decode an OpenCode goal update; refreshing its state.", ); - yield* Effect.forkIn( - readGoal(state).pipe( - Effect.timeout(INVENTORY_TIMEOUT), - Effect.catch(() => - Effect.logWarning( - "Could not refresh OpenCode goal state after an unreadable update.", - ), - ), - Effect.ensuring( - lock.withPermit( - Effect.gen(function* () { - if (state.goalRevision === revision) state.goalRefreshing = false; - if (state.active !== undefined) yield* endIfSettled(state, state.active); - }), - ), - ), - ), - sessionScope, - ); - return; + return yield* refreshGoal(state); } yield* updateGoal(state, goal.success); if (state.active !== undefined) yield* endIfSettled(state, state.active);