@devries-cameron20 / t3code Mirror · read-only / commits / 907ff258e0
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 09:45 UTC

fix(provider-opencode): goal turns end when OpenCode pauses the goal silently (#37894)

Julius Marminge committed Nov 16, 2026 at 20:27 UTC 907ff258e07bdbfd5d659ca6c32aded1ffda2500
2 files changed +111 -32
apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
+76 -6
@@ -8074,12 +8074,13 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
8074 );
8075
8076 it.effect.each([
8077 - { status: "complete", reconnect: false },
8078 - { status: "paused", reconnect: false },
8079 - { status: "complete", reconnect: true },
8077 + { status: "complete", reconnect: false, silent: false },
8078 + { status: "paused", reconnect: false, silent: false },
8079 + { status: "complete", reconnect: true, silent: false },
8080 + { status: "paused", reconnect: false, silent: true },
8081 ] as const)(
8081 - "keeps an OpenCode goal turn open until $status, with reconnect $reconnect",
8082 - ({ status, reconnect }) =>
8082 + "keeps an OpenCode goal turn open until $status, with reconnect $reconnect and silent $silent",
8083 + ({ status, reconnect, silent }) =>
8084 Effect.gen(function* () {
8085 const recovered = reconnected({ [SESSION]: { type: "running" } });
8086 const { runtime, thread } = yield* resumed(
@@ -8092,6 +8093,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
8093 reply("session.command", null),
8094 event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("active") }),
8095 event("session.execution.succeeded", { sessionID: SESSION }),
8096 + out("rpc.call", "<any>"),
8097 + reply("rpc.call", { output: nativeGoal(silent ? status : "active") }),
8098 ...(status === "complete"
8099 ? reconnect
8100 ? [
@@ -8104,7 +8107,14 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
8107 ]
8108 : [event("session.execution.started", { sessionID: SESSION })]
8109 : []),
8107 - event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal(status) }),
8110 + ...(silent
8111 + ? []
8112 + : [
8113 + event("rpc.opencode.goal.changed", {
8114 + sessionID: SESSION,
8115 + goal: nativeGoal(status),
8116 + }),
8117 + ]),
8118 ...(status === "complete"
8119 ? [
8120 event("session.text.ended", {
@@ -8251,6 +8261,64 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
8261 }),
8262 );
8263
8264 + it.effect("a goal refresh that reconnect supersedes leaves the turn to reconnect's read", () =>
8265 + Effect.gen(function* () {
8266 + const gate = makeProviderReplayGate(["before-reconnect", "reconnect-reading"]);
8267 + const recovered = reconnected({ [SESSION]: { type: "running" } });
8268 + const elsewhere = { sessionID: "ses_elsewhere", goal: null };
8269 + const { runtime, thread } = yield* resumed(
8270 + [
8271 + out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "<any>" }),
8272 + promptAccepted,
8273 + event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("active") }),
8274 + event("session.execution.succeeded", { sessionID: SESSION }),
8275 + out("rpc.call", "<any>"),
8276 + reply("rpc.call", "<hang>"),
8277 + event("rpc.opencode.goal.changed", elsewhere, "before-reconnect"),
8278 + ...recovered.slice(0, 2),
8279 + out("rpc.call", "<any>"),
8280 + event("rpc.opencode.goal.changed", elsewhere, "reconnect-reading"),
8281 + reply("rpc.call", { output: nativeGoal("active") }),
8282 + ...emptyShellInventory,
8283 + ...recovered.slice(2),
8284 + ...noOpenRequests,
8285 + event("session.execution.started", { sessionID: SESSION }),
8286 + event("session.text.ended", {
8287 + sessionID: SESSION,
8288 + assistantMessageID: "msg_goal_final",
8289 + ordinal: 0,
8290 + text: "Final goal output",
8291 + }),
8292 + event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("complete") }),
8293 + event("session.execution.succeeded", { sessionID: SESSION }),
8294 + ],
8295 + { version: "2.2.5", replayGate: gate },
8296 + );
8297 + const events = yield* runtime.events.pipe(
8298 + Stream.takeUntil((e) => e.type === "turn.terminal"),
8299 + Stream.runCollect,
8300 + Effect.forkScoped,
8301 + );
8302 + yield* runtime.startTurn(turnInput(thread));
8303 + yield* Effect.promise(() => gate.waitForReached("before-reconnect"));
8304 + yield* TestClock.adjust("3 seconds");
8305 + gate.release("before-reconnect");
8306 + yield* Effect.promise(() => gate.waitForReached("reconnect-reading"));
8307 + yield* TestClock.adjust("2 seconds");
8308 + gate.release("reconnect-reading");
8309 + const collected = yield* Fiber.join(events);
8310 + assert.isTrue(
8311 + collected.some(
8312 + (e) =>
8313 + e.type === "turn_item.updated" &&
8314 + e.turnItem.type === "assistant_message" &&
8315 + e.turnItem.text === "Final goal output",
8316 + ),
8317 + );
8318 + assert.deepInclude(collected.at(-1), { type: "turn.terminal", status: "completed" });
8319 + }),
8320 + );
8321 +
8322 it.effect.each([
8323 { initial: "active", recovered: "paused" },
8324 { initial: "paused", recovered: "active" },
@@ -8273,6 +8341,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
8341 reply("rpc.call", { output: recovered === "unreadable" ? {} : nativeGoal(recovered) }),
8342 ...(recovered === "active"
8343 ? [
8344 + out("rpc.call", "<any>"),
8345 + reply("rpc.call", { output: nativeGoal("active") }),
8346 event("session.execution.started", { sessionID: SESSION }),
8347 event("session.text.ended", {
8348 sessionID: SESSION,
packages/provider-opencode/src/server/v2/adapter.ts
+35 -26
@@ -1052,9 +1052,11 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1052 input: { sessionID: state.sessionId },
1053 });
1054 const goal = yield* decodeGoal(result.output);
1055 - yield* lock.withPermit(
1055 + return yield* lock.withPermit(
1056 Effect.gen(function* () {
1057 - if (state.goalRevision === revision) yield* updateGoal(state, goal);
1057 + if (state.goalRevision !== revision) return false;
1058 + yield* updateGoal(state, goal);
1059 + return true;
1060 }),
1061 );
1062 });
@@ -3182,6 +3184,9 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
3184 ) {
3185 if (end.status === "completed" && (turn.steers.size > 0 || goalHoldsTurn(state))) {
3186 turn.heldEnd = end;
3187 + // OpenCode can pause a goal without telling this server, such as another process's
3188 + // restart sweep, so confirm the goal is still active before waiting on it.
3189 + if (goalHoldsTurn(state) && !state.goalRefreshing) yield* refreshGoal(state);
3190 return;
3191 }
3192 yield* finishTurn(state, end);
@@ -3192,6 +3197,33 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
3197 ? finishTurn(state, turn.heldEnd)
3198 : Effect.void;
3199
3200 + // Holds a goal turn until OpenCode's goal is read again; a failed read releases it.
3201 + const refreshGoal = Effect.fnUntraced(function* (state: ThreadState) {
3202 + state.goalFresh = false;
3203 + state.goalRefreshing = true;
3204 + state.goalRevision += 1;
3205 + const revision = state.goalRevision;
3206 + yield* Effect.forkIn(
3207 + readGoal(state).pipe(
3208 + Effect.timeout(INVENTORY_TIMEOUT),
3209 + Effect.catch(() =>
3210 + Effect.logWarning("Could not refresh OpenCode goal state.").pipe(Effect.as(false)),
3211 + ),
3212 + Effect.flatMap((applied) =>
3213 + lock.withPermit(
3214 + Effect.gen(function* () {
3215 + if (state.goalRevision === revision) state.goalRefreshing = false;
3216 + // A newer goal event or a reconnect's read owns settlement now.
3217 + else if (!applied) return;
3218 + if (state.active !== undefined) yield* endIfSettled(state, state.active);
3219 + }),
3220 + ),
3221 + ),
3222 + ),
3223 + sessionScope,
3224 + );
3225 + });
3226 +
3227 const handleEvent = Effect.fnUntraced(function* (event: OpenCode2Client.OpenCode2StreamEvent) {
3228 if (event.type === "shell.created") {
3229 const sessionId = stringField(event.data.info.metadata, "sessionID");
@@ -3353,33 +3385,10 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
3385 if (!supportsNativeGoals()) return;
3386 const goal = yield* decodeGoal(event.data["goal"]).pipe(Effect.result);
3387 if (goal._tag === "Failure") {
3356 - state.goalFresh = false;
3357 - state.goalRefreshing = true;
3358 - state.goalRevision += 1;
3359 - const revision = state.goalRevision;
3388 yield* Effect.logWarning(
3389 "Could not decode an OpenCode goal update; refreshing its state.",
3390 );
3363 - yield* Effect.forkIn(
3364 - readGoal(state).pipe(
3365 - Effect.timeout(INVENTORY_TIMEOUT),
3366 - Effect.catch(() =>
3367 - Effect.logWarning(
3368 - "Could not refresh OpenCode goal state after an unreadable update.",
3369 - ),
3370 - ),
3371 - Effect.ensuring(
3372 - lock.withPermit(
3373 - Effect.gen(function* () {
3374 - if (state.goalRevision === revision) state.goalRefreshing = false;
3375 - if (state.active !== undefined) yield* endIfSettled(state, state.active);
3376 - }),
3377 - ),
3378 - ),
3379 - ),
3380 - sessionScope,
3381 - );
3382 - return;
3391 + return yield* refreshGoal(state);
3392 }
3393 yield* updateGoal(state, goal.success);
3394 if (state.active !== undefined) yield* endIfSettled(state, state.active);