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);