@devries-cameron20 / t3code-1 / commits / fb915ca6c0
Fork 0

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,