The best way to control Claude Code, Codex and more from any computer or phone
fix(opencode): pages a Code Mode script publishes now show inline (#30492)
Co-authored-by: maria-rcks <maria@kuuro.net> Co-authored-by: Julius Marminge <julius0216@outlook.com>
David Pérez committed
Nov 15, 2026 at 00:36 UTC
fb915ca6c011afb461537c50af63600987448588
5 files changed
+227
-22
apps/server/src/htmlRender/HtmlRender.test.ts
+5
@@ -242,6 +242,11 @@ describe("HtmlRender", () => {
242
const reused = yield* htmlRender.publish({ threadId, ...page });
243
yield* mcpSessions.set({ ...session, browserToolsAvailable: true });
244
expect(yield* mcpSessions.takeHtmlRender(threadId, page)).toEqual(reused);
245
+ const first = yield* htmlRender.publish({ threadId, ...page });
246
+ const second = yield* htmlRender.publish({ threadId, ...page });
247
+ expect(yield* mcpSessions.takeHtmlRender(threadId, page)).toEqual(first);
248
+ expect(yield* mcpSessions.takeHtmlRender(threadId, page)).toEqual(second);
249
+ expect(yield* mcpSessions.takeHtmlRender(threadId, page)).toBe(undefined);
250
251
yield* htmlRender.publish({ threadId, ...page });
252
yield* mcpSessions.set({
apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts
+142
@@ -43,6 +43,7 @@ import { TestClock } from "effect/testing";
43
import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
44
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
45
import { buildRuntimeInstructions } from "@t3tools/provider-core/server/runtimeInstructions";
46
+import { htmlRenderFromToolItem } from "@t3tools/shared/toolOutput";
47
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
48
import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
49
import {
@@ -4870,6 +4871,147 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => {
4871
}),
4872
);
4873
4874
+ it.effect("shows each page a Code Mode script published, whatever the script returned", () =>
4875
+ Effect.gen(function* () {
4876
+ const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
4877
+ yield* Effect.addFinalizer(() => mcpSessions.clear(threadId));
4878
+ const server = "t3-code-thread_opencode2-adapter";
4879
+ const pages = [
4880
+ { html: "<p>orbits</p>", title: "Orbits", height: 480 },
4881
+ { html: "<p>scale</p>", title: "Scale", height: 1490 },
4882
+ ];
4883
+ const references = pages.map((page, index) => ({
4884
+ attachmentId: `thread_opencode2-adapter-0000000${index}-0000-4000-8000-000000000000-html`,
4885
+ title: page.title,
4886
+ height: page.height,
4887
+ }));
4888
+ yield* Effect.forEach(pages, (page, index) =>
4889
+ mcpSessions.recordHtmlRender(threadId, page, references[index]!),
4890
+ );
4891
+ const tool = { sessionID: SESSION, assistantMessageID: "msg_assistant", id: "call-execute" };
4892
+ const { runtime, thread } = yield* resumed([
4893
+ out("session.prompt", { sessionID: SESSION, text: "<any>" }),
4894
+ promptAccepted,
4895
+ event("session.tool.input.started", { ...tool, name: "execute" }),
4896
+ event("session.tool.called", { ...tool, input: { code: "<script>" }, executed: true }),
4897
+ event(
4898
+ "session.tool.success",
4899
+ {
4900
+ ...tool,
4901
+ // The script returns the first page and discards the second.
4902
+ content: [{ type: "text", text: JSON.stringify({ htmlRender: references[0] }) }],
4903
+ metadata: {
4904
+ toolCalls: [
4905
+ { tool: "search", status: "completed", input: { query: "html" } },
4906
+ {
4907
+ tool: `${server}.html_preview`,
4908
+ status: "completed",
4909
+ input: { html: pages[0]!.html, width: 728 },
4910
+ },
4911
+ { tool: `${server}.html_render`, status: "completed", input: pages[0] },
4912
+ { tool: "t3-code-thread_other.html_render", status: "completed", input: pages[1] },
4913
+ { tool: `${server}.html_render`, status: "completed", input: pages[1] },
4914
+ ],
4915
+ truncated: false,
4916
+ },
4917
+ executed: true,
4918
+ },
4919
+ undefined,
4920
+ 2,
4921
+ ),
4922
+ event("session.execution.succeeded", { sessionID: SESSION }),
4923
+ ]);
4924
+ const events = yield* runtime.events.pipe(
4925
+ Stream.takeUntil((event) => event.type === "turn.terminal"),
4926
+ Stream.runCollect,
4927
+ Effect.forkScoped,
4928
+ );
4929
+ yield* runtime.startTurn(turnInput(thread));
4930
+ const shown = (yield* Fiber.join(events)).flatMap((event) =>
4931
+ event.type === "turn_item.updated" && event.turnItem.type === "dynamic_tool"
4932
+ ? [htmlRenderFromToolItem(event.turnItem)].filter((page) => page !== undefined)
4933
+ : [],
4934
+ );
4935
+ assert.deepEqual(shown, references);
4936
+ }).pipe(Effect.scoped),
4937
+ );
4938
+
4939
+ it.effect("keeps a script replayed after a reconnect from taking a later script's page", () =>
4940
+ Effect.gen(function* () {
4941
+ const mcpSessions = yield* McpProviderSessions.McpProviderSessions;
4942
+ yield* Effect.addFinalizer(() => mcpSessions.clear(threadId));
4943
+ const page = { html: "<p>orbits</p>", title: "Orbits", height: 480 };
4944
+ const references = [0, 1].map((index) => ({
4945
+ attachmentId: `thread_opencode2-adapter-0000000${index}-0000-4000-8000-000000000000-html`,
4946
+ title: page.title,
4947
+ height: page.height,
4948
+ }));
4949
+ yield* Effect.forEach(references, (reference) =>
4950
+ mcpSessions.recordHtmlRender(threadId, page, reference),
4951
+ );
4952
+ const metadata = {
4953
+ toolCalls: [
4954
+ {
4955
+ tool: "t3-code-thread_opencode2-adapter.html_render",
4956
+ status: "completed",
4957
+ input: page,
4958
+ },
4959
+ ],
4960
+ truncated: false,
4961
+ };
4962
+ const content = [{ type: "text", text: '"done"' }];
4963
+ const script = (id: string) => {
4964
+ const tool = { sessionID: SESSION, assistantMessageID: "msg_assistant_gap", id };
4965
+ return [
4966
+ event("session.tool.input.started", { ...tool, name: "execute" }),
4967
+ event("session.tool.called", { ...tool, input: { code: "<script>" }, executed: true }),
4968
+ event(
4969
+ "session.tool.success",
4970
+ { ...tool, content, metadata, executed: true },
4971
+ undefined,
4972
+ 2,
4973
+ ),
4974
+ ];
4975
+ };
4976
+ const { runtime, thread } = yield* resumed([
4977
+ out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "<any>" }),
4978
+ promptAccepted,
4979
+ ...script("call-first"),
4980
+ ...reconnected({ [SESSION]: { type: "running" } }, undefined, {
4981
+ content: [
4982
+ {
4983
+ type: "tool",
4984
+ id: "call-first",
4985
+ name: "execute",
4986
+ executed: true,
4987
+ state: { status: "completed", input: { code: "<script>" }, content, metadata },
4988
+ time: { created: 2, ran: 2, completed: 2 },
4989
+ },
4990
+ ],
4991
+ }),
4992
+ ...openRequests([]),
4993
+ ...script("call-second"),
4994
+ event("session.execution.succeeded", { sessionID: SESSION }),
4995
+ ]);
4996
+ const events = yield* runtime.events.pipe(
4997
+ Stream.takeUntil((event) => event.type === "turn.terminal"),
4998
+ Stream.runCollect,
4999
+ Effect.forkScoped,
5000
+ );
5001
+ yield* runtime.startTurn(turnInput(thread));
5002
+ const shown = new Map(
5003
+ (yield* Fiber.join(events)).flatMap((event) => {
5004
+ if (event.type !== "turn_item.updated" || event.turnItem.type !== "dynamic_tool") {
5005
+ return [];
5006
+ }
5007
+ const shownPage = htmlRenderFromToolItem(event.turnItem);
5008
+ return shownPage === undefined ? [] : [[event.turnItem.id, shownPage] as const];
5009
+ }),
5010
+ );
5011
+ assert.deepEqual([...shown.values()], references);
5012
+ }).pipe(Effect.scoped),
5013
+ );
5014
+
5015
it.effect("stores a shell command that exits non-zero as failed", () =>
5016
Effect.gen(function* () {
5017
const tool = { sessionID: SESSION, assistantMessageID: "msg_assistant", id: "call-exit" };
packages/provider-core/src/server/McpProviderSessions.ts
+4
@@ -96,6 +96,10 @@ const matchingPageIndex = (kept: ReadonlyArray<KeptHtmlRender>, input: PageInput
96
? [index]
97
: [],
98
);
99
+ // Identical pages are interchangeable, so repeats are taken in publish order.
100
+ if (matches.length > 1 && matches.every((index) => kept[index]!.htmlHash === htmlHash)) {
101
+ return matches[0]!;
102
+ }
103
return matches.length === 1 ? matches[0]! : -1;
104
};
105
packages/provider-opencode/src/server/toolItems.ts
+21
@@ -1,4 +1,5 @@
1
import type { OrchestrationV2TurnItem } from "@t3tools/contracts";
2
+import { HTML_RENDER_TOOL_NAME } from "@t3tools/shared/htmlRender";
3
import { resolveT3McpToolId } from "@t3tools/shared/t3McpToolPresentation";
4
import { formatReadToolLabel, formatSearchToolLabel } from "@t3tools/shared/toolActivity";
5
import {
@@ -122,6 +123,26 @@ export function openCodeCommandFailed(toolName: string, completedMetadata: unkno
123
);
124
}
125
126
+/** Code Mode reports nested calls with their input but no result, so pages are found by input. */
127
+export function openCodeCodeModeHtmlRenders(
128
+ completedMetadata: unknown,
129
+ mcpServerName: string,
130
+): ReadonlyArray<{ readonly index: number; readonly input: Record<string, unknown> }> {
131
+ if (typeof completedMetadata !== "object" || completedMetadata === null) return [];
132
+ const toolCalls = (completedMetadata as Record<string, unknown>)["toolCalls"];
133
+ if (!Array.isArray(toolCalls)) return [];
134
+ return toolCalls.flatMap((call: unknown, index) => {
135
+ if (typeof call !== "object" || call === null) return [];
136
+ const { tool, status, input } = call as Record<string, unknown>;
137
+ return tool === `${mcpServerName}.${HTML_RENDER_TOOL_NAME}` &&
138
+ status === "completed" &&
139
+ typeof input === "object" &&
140
+ input !== null
141
+ ? [{ index, input: input as Record<string, unknown> }]
142
+ : [];
143
+ });
144
+}
145
+
146
export function openCodeToolTurnItem(
147
base: ToolItemBase,
148
tool: {
packages/provider-opencode/src/server/v2/adapter.ts
+55
-22
@@ -70,6 +70,8 @@ import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderS
70
import { buildRuntimeInstructions } from "@t3tools/provider-core/server/runtimeInstructions";
71
import { t3OrchestrationSystemPrompt } from "@t3tools/provider-core/server/orchestrationInstructions";
72
import { SKILL_MENTION_PATTERN } from "@t3tools/shared/composerInlineTokens";
73
+import { HTML_RENDER_TOOL_NAME } from "@t3tools/shared/htmlRender";
74
+import { htmlRenderFromToolItem } from "@t3tools/shared/toolOutput";
75
import { compareSemverVersions } from "@t3tools/shared/semver";
76
import * as KeyedLock from "@t3tools/shared/KeyedLock";
77
import { getModelSelectionStringOptionValue, modelSelectionsEqual } from "@t3tools/shared/model";
@@ -97,7 +99,11 @@ import {
99
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
100
import { turnScopedSelectionTransition } from "@t3tools/provider-core/server/selectionTransition";
101
import { OPENCODE_PROVIDER, openCodePermissionRequestKind } from "../adapter.ts";
100
-import { openCodeCommandFailed, openCodeToolTurnItem } from "../toolItems.ts";
102
+import {
103
+ openCodeCodeModeHtmlRenders,
104
+ openCodeCommandFailed,
105
+ openCodeToolTurnItem,
106
+} from "../toolItems.ts";
107
108
const NativeGoal = Schema.NullOr(
109
Schema.Struct({
@@ -263,6 +269,8 @@ interface ActiveTurn {
269
unsent: boolean;
270
readonly steers: Set<string>;
271
readonly settledInbox: Set<string>;
272
+ // Reconnects replay finished tools, so each nested html_render takes a page only once.
273
+ readonly takenPages: Set<string>;
274
heldEnd: TurnTerminal | undefined;
275
awaitingStart: boolean;
276
/** Scope child tool IDs because model-generated IDs can repeat parent IDs. */
@@ -1368,28 +1376,52 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1376
? "failed"
1377
: status;
1378
yield* emitNode(state, turn, nativeId, "tool_call", settled, startedAt, completedAt);
1371
- yield* emit({
1372
- type: "turn_item.updated",
1373
- driver,
1374
- turnItem: openCodeToolTurnItem(
1375
- {
1376
- ...itemBase(state, turn, nativeId, settled, startedAt, completedAt, updatedAt),
1377
- ...(result?.nativeTaskId === undefined
1378
- ? {}
1379
- : { nativeItemRef: ref(result.nativeTaskId) }),
1380
- },
1381
- {
1382
- name: tool.name,
1383
- input: tool.input,
1384
- output: result?.output,
1385
- files: result?.files,
1386
- completedMetadata:
1387
- status === "completed" || result?.nativeTaskId !== undefined
1388
- ? result?.metadata
1389
- : undefined,
1379
+ const turnItem = openCodeToolTurnItem(
1380
+ {
1381
+ ...itemBase(state, turn, nativeId, settled, startedAt, completedAt, updatedAt),
1382
+ ...(result?.nativeTaskId === undefined
1383
+ ? {}
1384
+ : { nativeItemRef: ref(result.nativeTaskId) }),
1385
+ },
1386
+ {
1387
+ name: tool.name,
1388
+ input: tool.input,
1389
+ output: result?.output,
1390
+ files: result?.files,
1391
+ completedMetadata:
1392
+ status === "completed" || result?.nativeTaskId !== undefined
1393
+ ? result?.metadata
1394
+ : undefined,
1395
+ },
1396
+ );
1397
+ yield* emit({ type: "turn_item.updated", driver, turnItem });
1398
+ if (status === "running") return;
1399
+ // A script that returns the reference already renders through its own item.
1400
+ const returnedPage =
1401
+ turnItem.type === "dynamic_tool" ? htmlRenderFromToolItem(turnItem) : undefined;
1402
+ const pages = openCodeCodeModeHtmlRenders(
1403
+ result?.metadata,
1404
+ yield* mcpServerNameFor(turn.input.threadId),
1405
+ );
1406
+ for (const { index, input } of pages) {
1407
+ const pageId = `${nativeId}:${HTML_RENDER_TOOL_NAME}:${index}`;
1408
+ if (turn.takenPages.has(pageId)) continue;
1409
+ turn.takenPages.add(pageId);
1410
+ const page = yield* mcpSessions.takeHtmlRender(turn.input.threadId, input);
1411
+ if (page === undefined || page.attachmentId === returnedPage?.attachmentId) continue;
1412
+ yield* emitNode(state, turn, pageId, "tool_call", "completed", startedAt, updatedAt);
1413
+ yield* emit({
1414
+ type: "turn_item.updated",
1415
+ driver,
1416
+ turnItem: {
1417
+ ...itemBase(state, turn, pageId, "completed", startedAt, updatedAt, updatedAt),
1418
+ type: "dynamic_tool",
1419
+ toolName: `t3-code.${HTML_RENDER_TOOL_NAME}`,
1420
+ input: { title: page.title, height: page.height },
1421
+ output: { htmlRender: page },
1422
},
1391
- ),
1392
- });
1423
+ });
1424
+ }
1425
});
1426
1427
const emitCompaction = Effect.fnUntraced(function* (
@@ -1526,6 +1558,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr
1558
unsent: false,
1559
steers: new Set(),
1560
settledInbox: new Set(),
1561
+ takenPages: new Set(),
1562
heldEnd: undefined,
1563
awaitingStart: options.awaitingStart,
1564
scope: options.scope,