@devries-cameron20 / t3code-1 / commits / 151d5f817c
Fork 0

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

fix(opencode): show questions asked while OpenCode wakes a session on its own (#32434)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Nov 10, 2026 at 08:31 UTC 151d5f817c6a5beb647f73fc64ffa171443fb043
2 files changed +113 -3
apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
+108
@@ -4931,6 +4931,114 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
4931 }).pipe(Effect.scoped, Effect.provide(IdAllocator.layer)),
4932 );
4933
4934 + it.effect("shows a question asked while OpenCode wakes for a background reply", () =>
4935 + Effect.gen(function* () {
4936 + const OTHER = "ses_other00000000000000000000";
4937 + const gate = makeProviderReplayGate(["continued"]);
4938 + const offered =
4939 + yield* Deferred.make<ProviderContinuationRequests.ProviderContinuationRequest>();
4940 + const { runtime, thread } = yield* resumed(
4941 + [
4942 + out("session.get", { sessionID: OTHER }),
4943 + replyData("session.get", sessionInfo({ id: OTHER })),
4944 + out("permission.list", { sessionID: OTHER }),
4945 + replyData("permission.list", []),
4946 + out("session.form.list", { sessionID: OTHER }),
4947 + replyData("session.form.list", []),
4948 + ...backgroundLaunch(CHILD),
4949 + event("session.execution.succeeded", { sessionID: SESSION }),
4950 + event("session.execution.succeeded", { sessionID: CHILD }),
4951 + childReport("msg_report", "CHILD_OK"),
4952 + event("session.execution.started", { sessionID: SESSION }),
4953 + event("session.inbox.delivered", { sessionID: SESSION, inboxID: "msg_report" }),
4954 + event("form.created", { form: colorForm }),
4955 + // Handled after the form, so its update proves the form reached the adapter.
4956 + event("session.model.selected", {
4957 + sessionID: OTHER,
4958 + model: { providerID: "opencode", id: "big-pickle", variant: "none" },
4959 + }),
4960 + // Released once the continuation started, so its update follows the replay.
4961 + event(
4962 + "session.model.selected",
4963 + {
4964 + sessionID: OTHER,
4965 + model: { providerID: "opencode", id: "big-pickle", variant: "thinking" },
4966 + },
4967 + "continued",
4968 + ),
4969 + out("session.form.reply", {
4970 + sessionID: SESSION,
4971 + formID: colorForm.id,
4972 + answer: { q0: "Red" },
4973 + }),
4974 + reply("session.form.reply", null),
4975 + event("session.execution.succeeded", { sessionID: SESSION }),
4976 + ],
4977 + { replayGate: gate },
4978 + ).pipe(
4979 + Effect.provideService(ProviderContinuationRequests.ProviderContinuationRequests, {
4980 + offer: (request) => Deferred.succeed(offered, request).pipe(Effect.asVoid),
4981 + take: Effect.never,
4982 + }),
4983 + );
4984 + yield* runtime.resumeThread({
4985 + providerThread: {
4986 + ...thread,
4987 + id: ProviderThreadId.make("provider-thread:opencode2-adapter:other"),
4988 + nativeThreadRef: { driver: OPENCODE_PROVIDER, nativeId: OTHER, strength: "strong" },
4989 + },
4990 + threadId,
4991 + modelSelection: bigPickle,
4992 + runtimePolicy: policy(),
4993 + });
4994 + const collected: Array<ProviderAdapter.ProviderAdapterV2Event> = [];
4995 + const formSeen = yield* Deferred.make<void>();
4996 + const replayed = yield* Deferred.make<void>();
4997 + const ended = yield* Deferred.make<void>();
4998 + const otherVariant = (event: ProviderAdapter.ProviderAdapterV2Event) =>
4999 + event.type === "provider_thread.updated" &&
5000 + event.providerThread.nativeThreadRef?.nativeId === OTHER
5001 + ? event.providerThread.nativeMetadata?.modelSelection?.options?.[0]?.value
5002 + : undefined;
5003 + yield* runtime.events.pipe(
5004 + Stream.tap((event) =>
5005 + Effect.gen(function* () {
5006 + collected.push(event);
5007 + if (otherVariant(event) === "none") yield* Deferred.succeed(formSeen, undefined);
5008 + if (otherVariant(event) === "thinking") yield* Deferred.succeed(replayed, undefined);
5009 + if (collected.filter((entry) => entry.type === "turn.terminal").length === 2) {
5010 + yield* Deferred.succeed(ended, undefined);
5011 + }
5012 + }),
5013 + ),
5014 + Stream.runDrain,
5015 + Effect.forkScoped,
5016 + );
5017 + yield* runtime.startTurn(withLineage(thread));
5018 + const offer = yield* Deferred.await(offered);
5019 + yield* Deferred.await(formSeen);
5020 + yield* runtime.startTurn(continuationTurn(thread, offer));
5021 + gate.release("continued");
5022 + yield* Deferred.await(replayed);
5023 + const requests = collected.flatMap((event) =>
5024 + event.type === "runtime_request.updated" && event.runtimeRequest.status === "pending"
5025 + ? [event.runtimeRequest]
5026 + : [],
5027 + );
5028 + assert.deepEqual(
5029 + requests.map((request) => request.nativeRequestRef?.nativeId),
5030 + [colorForm.id],
5031 + );
5032 + yield* runtime.respondToRuntimeRequest({
5033 + requestId: requests[0]!.id,
5034 + answers: { q0: "Red" },
5035 + });
5036 + yield* Deferred.await(ended);
5037 + const last = collected.findLast((event) => event.type === "turn.terminal");
5038 + assert.equal(last?.type === "turn.terminal" ? last.status : undefined, "completed");
5039 + }).pipe(Effect.scoped),
5040 + );
5041 +
5042 it.effect("ends a follow-up turn a steer joined exactly once", () =>
5043 Effect.gen(function* () {
5044 const reportText = `<subagent sessionID="${CHILD}" state="completed" description="Sleep">\nCHILD_OK\n</subagent>`;
packages/provider-opencode/src/server/v2/adapter.ts
+5 -3
@@ -1994,9 +1994,11 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1994 const sessionOfEvent = (event: OpenCode2Client.OpenCode2StreamEvent) =>
1995 event.type === "unreadable.execution.ended" || event.type === "unreadable.execution.started"
1996 ? event.sessionID
1997 - : "sessionID" in event.data && typeof event.data.sessionID === "string"
1998 - ? event.data.sessionID
1999 - : undefined;
1997 + : event.type === "form.created"
1998 + ? event.data.form.sessionID
1999 + : "sessionID" in event.data && typeof event.data.sessionID === "string"
2000 + ? event.data.sessionID
2001 + : undefined;
2002
2003 const executionEnd = (type: string) =>
2004 type === "session.execution.succeeded" ||