@devries-cameron20 / t3code-1 / commits / 9facfc5923
Fork 0

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

fix(opencode): apply the 3-minute limit to the whole v2 text generation (#23598)

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

Victor Vogel committed Oct 30, 2026 at 15:54 UTC 9facfc59230a68be71c427d708d3ee6c2ccaa2d3
2 files changed +106 -28
apps/server/src/textGeneration/OpenCode2TextGeneration.test.ts
+69
@@ -1,8 +1,11 @@
1 import { assert, it } from "@effect/vitest";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { ProviderInstanceId } from "@t3tools/contracts";
4 +import * as Deferred from "effect/Deferred";
5 import * as Effect from "effect/Effect";
6 +import * as Fiber from "effect/Fiber";
7 import * as Layer from "effect/Layer";
8 +import { TestClock } from "effect/testing";
9
10 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
11 import * as OpenCode2AdapterV2Testkit from "../orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts";
@@ -119,4 +122,70 @@ it.layer(layer)("OpenCode2TextGeneration", (it) => {
122 assert.deepEqual(failure.cause, refusal);
123 }).pipe(Effect.scoped),
124 );
125 +
126 + it.effect("times out when the prompt request and its interrupt never answer", () =>
127 + Effect.gen(function* () {
128 + const [subscribe, connected, create, created] = OPENCODE2_TITLE_GENERATION;
129 + const sessionId = "ses_f0ec85cf6ffebfalpvV2E9nocu";
130 + const prompted = yield* Deferred.make<void>();
131 + const server = yield* OpenCode2AdapterV2Testkit.replayServer(
132 + {
133 + provider: "opencode",
134 + protocol: OpenCode2AdapterV2Testkit.OPENCODE2_HTTP_PROTOCOL,
135 + version: "2.0.18",
136 + scenario: "opencode2_title_generation_stalled",
137 + entries: [
138 + subscribe!,
139 + connected!,
140 + create!,
141 + created!,
142 + {
143 + type: "expect_outbound",
144 + frame: { type: "session.prompt", input: { sessionID: sessionId, text: "<any>" } },
145 + },
146 + {
147 + type: "emit_inbound",
148 + frame: { type: "sdk.response", operation: "session.prompt", data: "<hang>" },
149 + },
150 + {
151 + type: "expect_outbound",
152 + frame: { type: "session.interrupt", input: { sessionID: sessionId } },
153 + },
154 + {
155 + type: "emit_inbound",
156 + frame: { type: "sdk.response", operation: "session.interrupt", data: "<hang>" },
157 + },
158 + {
159 + type: "expect_outbound",
160 + frame: { type: "session.remove", input: { sessionID: sessionId } },
161 + },
162 + {
163 + type: "emit_inbound",
164 + frame: { type: "sdk.response", operation: "session.remove", data: null },
165 + },
166 + { type: "runtime_exit", status: "success" },
167 + ],
168 + },
169 + { onPrompt: () => Deferred.doneUnsafe(prompted, Effect.void) },
170 + );
171 + const textGeneration = yield* OpenCode2TextGeneration.make().pipe(
172 + Effect.provideService(OpenCode2Server.OpenCode2Server, server),
173 + );
174 + const generation = yield* textGeneration
175 + .generateThreadTitle({
176 + cwd: process.cwd(),
177 + message: "fix the login redirect loop after oauth",
178 + modelSelection: {
179 + instanceId: ProviderInstanceId.make("opencode"),
180 + model: "opencode/big-pickle",
181 + },
182 + })
183 + .pipe(Effect.flip, Effect.forkScoped);
184 + yield* Deferred.await(prompted);
185 + yield* TestClock.adjust("3 minutes");
186 + yield* TestClock.adjust("5 seconds");
187 + const failure = yield* Fiber.join(generation);
188 + assert.equal(failure.detail, "OpenCode did not finish generating in time.");
189 + }).pipe(Effect.scoped),
190 + );
191 });
packages/provider-opencode/src/server/v2/textGeneration.ts
+37 -28
@@ -112,38 +112,47 @@ const runOnServer = Effect.fn("Opencode2TextGeneration.runOnServer")(function* (
112 ),
113 Effect.forkScoped,
114 );
115 - const session = yield* client.session.create({
116 - title: `T3 Code ${input.operation}`,
117 - location: Location.PublicRef.make({ directory: AbsolutePath.make(input.cwd) }),
118 - model: Model.Ref.make({
119 - providerID: Provider.ID.make(parsed.providerID),
120 - id: Model.ID.make(parsed.modelID),
121 - ...(variant === undefined ? {} : { variant: Model.VariantID.make(variant) }),
122 - }),
123 - permissions: GENERATION_PERMISSIONS,
124 - });
125 - sessionId = session.id;
126 - yield* Effect.addFinalizer(() =>
127 - client.session
128 - .remove({ sessionID: session.id })
129 - .pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: true })),
130 - );
131 - const images = (input.attachments ?? []).flatMap((attachment) => {
132 - if (attachment.type !== "image") return [];
133 - const path = resolveAttachmentPath(attachment);
134 - return path === null ? [] : [{ uri: `file://${path}`, name: attachment.name }];
135 - });
136 - yield* client.session.prompt({
137 - sessionID: session.id,
138 - text: input.prompt,
139 - ...(images.length === 0 ? {} : { files: images }),
115 + // The limit covers creating the session and sending the prompt as well, since
116 + // either request can stall while the event stream stays connected.
117 + const generate = Effect.gen(function* () {
118 + const session = yield* client.session.create({
119 + title: `T3 Code ${input.operation}`,
120 + location: Location.PublicRef.make({ directory: AbsolutePath.make(input.cwd) }),
121 + model: Model.Ref.make({
122 + providerID: Provider.ID.make(parsed.providerID),
123 + id: Model.ID.make(parsed.modelID),
124 + ...(variant === undefined ? {} : { variant: Model.VariantID.make(variant) }),
125 + }),
126 + permissions: GENERATION_PERMISSIONS,
127 + });
128 + sessionId = session.id;
129 + yield* Effect.addFinalizer(() =>
130 + client.session
131 + .remove({ sessionID: session.id })
132 + .pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: true })),
133 + );
134 + const images = (input.attachments ?? []).flatMap((attachment) => {
135 + if (attachment.type !== "image") return [];
136 + const path = resolveAttachmentPath(attachment);
137 + return path === null ? [] : [{ uri: `file://${path}`, name: attachment.name }];
138 + });
139 + yield* client.session.prompt({
140 + sessionID: session.id,
141 + text: input.prompt,
142 + ...(images.length === 0 ? {} : { files: images }),
143 + });
144 + return yield* Deferred.await(outcome);
145 });
141 - const result = yield* Deferred.await(outcome).pipe(
146 + const result = yield* generate.pipe(
147 Effect.timeoutOrElse({
148 duration: GENERATION_TIMEOUT,
149 orElse: () =>
145 - client.session.interrupt({ sessionID: Session.ID.make(session.id) }).pipe(
146 - Effect.ignore,
150 + (sessionId === undefined
151 + ? Effect.void
152 + : client.session
153 + .interrupt({ sessionID: Session.ID.make(sessionId) })
154 + .pipe(Effect.timeout("5 seconds"), Effect.ignore)
155 + ).pipe(
156 Effect.as<Outcome>({
157 _tag: "failed",
158 detail: "OpenCode did not finish generating in time.",