A desktop coding agent with free access to frontier models.
TypeScript
import { describe, expect, test } from "bun:test";
import {
createClientV2,
createV2EventTranslationState,
translateV2Event,
} from "../src/app/lib/opencode-v2-adapter";
import { parseDynamicToolUIPart } from "../src/react-app/domains/session/sync/parse-tool-parts";
import { codeModeToolCalls } from "../src/lib/code-mode-tools";
const capturedPermissionAsked = {
id: "evt_permission_asked",
created: 1_788_548_737_221,
type: "permission.asked",
location: { directory: "/workspace" },
data: {
id: "per_child",
sessionID: "ses_child",
action: "shell",
resources: ["printf 'TOOL_RESULT_OK'"],
save: ["printf *"],
source: { type: "tool", messageID: "msg_child", id: "call_child" },
message: "Allow this command?",
},
durable: { aggregateID: "ses_child", seq: 8, version: 1 },
};
const capturedPermissionReplied = {
id: "evt_permission_replied",
created: 1_788_548_737_260,
type: "permission.replied",
location: { directory: "/workspace" },
data: { sessionID: "ses_child", requestID: "per_child", reply: "once" },
};
// Native beta-19086 fork schema: ancestry is not the new session's parentID.
const nativeForkEvent = {
type: "session.forked",
created: 1_788_548_737_221,
location: { directory: "/workspace" },
data: { sessionID: "ses_fork", parentID: "ses_source", boundary: { type: "through", messageID: "msg_source" } },
};
// Captured from 0.0.0-beta-19086 after approving one shell call with `once`.
const capturedV2ToolMessage = {
id: "msg_06e0e76b900178zSuF55n4XEPY",
time: {
created: 1_788_552_837_299,
streamed: 1_788_552_838_056,
completed: 1_788_552_838_186,
},
type: "assistant",
agent: "omnirush",
model: { id: "model", providerID: "witness", variant: "default" },
content: [
{ type: "text", text: "Running the shell.\n" },
{
type: "tool",
id: "call_captured_shell",
name: "shell",
executed: false,
state: {
status: "completed",
input: { command: "printf 'TOOL_RESULT_OK\\n'", timeout: 30_000 },
content: [
{ type: "text", text: "TOOL_RESULT_OK\n" },
{ type: "text", text: "Command exited with code 0." },
],
metadata: { status: "completed", truncated: false, exit: 0 },
},
time: {
created: 1_788_552_837_549,
ran: 1_788_552_838_052,
completed: 1_788_552_838_184,
},
},
],
finish: "tool-calls",
rawFinish: "tool_calls",
cost: 0,
tokens: {
input: 0,
output: 0,
reasoning: 0,
cache: { read: 0, write: 0 },
},
};
const capturedV2ToolEvents = [
{
id: "evt_06e0e79ad001BAvTZOqueGcqPa",
created: 1_788_552_837_549,
type: "session.tool.input.started",
data: {
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
assistantMessageID: "msg_06e0e76b900178zSuF55n4XEPY",
id: "call_captured_shell",
name: "shell",
},
},
{
id: "evt_06e0e7ba3001XQZt8DvOc8VTE1",
created: 1_788_552_838_051,
type: "session.tool.input.ended",
data: {
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
assistantMessageID: "msg_06e0e76b900178zSuF55n4XEPY",
id: "call_captured_shell",
text: "{\"command\":\"printf 'TOOL_RESULT_OK\\\\n'\",\"timeout\":30000}",
},
},
{
id: "evt_06e0e7ba4001XebEvHlJDSttDY",
created: 1_788_552_838_052,
type: "session.tool.called",
data: {
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
assistantMessageID: "msg_06e0e76b900178zSuF55n4XEPY",
id: "call_captured_shell",
input: { command: "printf 'TOOL_RESULT_OK\\n'", timeout: 30_000 },
executed: false,
},
},
{
id: "evt_06e0e7c22002P2HdF8g7Jt5EGX",
created: 1_788_552_838_178,
type: "session.tool.progress",
data: {
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
assistantMessageID: "msg_06e0e76b900178zSuF55n4XEPY",
id: "call_captured_shell",
metadata: { shellID: "sh_06e0e7c1e0017KTSezeFHBiGRk" },
},
},
{
id: "evt_06e0e7c28001BsHlyKVTMaacIe",
created: 1_788_552_838_184,
type: "session.tool.success",
data: {
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
assistantMessageID: "msg_06e0e76b900178zSuF55n4XEPY",
id: "call_captured_shell",
content: [
{ type: "text", text: "TOOL_RESULT_OK\n" },
{ type: "text", text: "Command exited with code 0." },
],
metadata: { status: "completed", truncated: false, exit: 0 },
executed: false,
},
},
];
const delay = (milliseconds: number) =>
new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
function jsonResponse(value: unknown, status = 200): Response {
return new Response(JSON.stringify(value), {
status,
headers: { "Content-Type": "application/json" },
});
}
function eventStream() {
let send = (..._events: unknown[]) => {};
let close = () => {};
let fail = (_error: Error) => {};
let cancelled = false;
const body = new ReadableStream<Uint8Array>({
start(controller) {
send = (...events) => controller.enqueue(new TextEncoder().encode(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join("")));
close = () => controller.close();
fail = (error) => controller.error(error);
},
cancel() { cancelled = true; },
});
return { response: new Response(body), send, close, fail, body, get cancelled() { return cancelled; } };
}
describe("OpenCode v2 event translation", () => {
test("preserves native retry detail and sequenced interruption reasons without claiming success", () => {
const state = createV2EventTranslationState();
expect(translateV2Event({ type: "session.retry.scheduled", durable: { seq: 12 }, data: {
sessionID: "s", assistantMessageID: "m", attempt: 3, at: 10_000, error: { message: "Rate limited" },
} }, state)).toEqual([{ type: "session.status", properties: {
sessionID: "s", sequence: 12, status: { type: "retry", attempt: 3, message: "Rate limited", next: 10_000 },
} }]);
for (const reason of ["user", "shutdown", "superseded", "future-reason"]) {
expect(translateV2Event({ type: "session.execution.interrupted", durable: { seq: 13 },
data: { sessionID: "s", reason } }, state)).toEqual([{
type: "session.execution.interrupted", properties: { sessionID: "s", reason, sequence: 13 },
}]);
}
expect(translateV2Event({ type: "session.step.started", durable: { seq: 14 }, data: { sessionID: "s" } }, state))
.toEqual([{ type: "session.execution.progress", properties: { sessionID: "s", sequence: 14 } }]);
});
test("renders an admitted user message before execution using its persisted identity", () => {
const state = createV2EventTranslationState();
const admitted = {
type: "session.inbox.enqueued",
created: 1_788_657_600_000,
location: { directory: "/workspace" },
data: {
sessionID: "ses_upgrade",
inboxID: "msg_user",
item: { type: "user", payload: { text: "hi" }, delivery: "steer" },
},
};
const expected = [
{ type: "message.updated", properties: { info: {
id: "msg_user", sessionID: "ses_upgrade", role: "user", time: { created: admitted.created },
} } },
{ type: "message.part.updated", properties: { part: {
id: "msg_user:0", messageID: "msg_user", sessionID: "ses_upgrade", type: "text", text: "hi",
} } },
];
expect(translateV2Event(admitted, state)).toEqual(expected);
// A replay must update the same message and part, not create another row.
expect(translateV2Event(admitted, state)).toEqual(expected);
expect(translateV2Event({
type: "session.inbox.cancelled", data: { sessionID: "ses_upgrade", inboxID: "msg_user" },
}, state)).toEqual([
{ type: "message.removed", properties: { sessionID: "ses_upgrade", messageID: "msg_user" } },
]);
expect(translateV2Event({ ...admitted, data: {
...admitted.data, item: { type: "synthetic", payload: { text: "Internal instructions" }, delivery: "steer" },
} }, state)).toBeNull();
});
test("uses the created envelope timestamp for an untitled session", () => {
const created = 1_788_548_737_221;
const event = {
type: "session.created",
created,
location: { directory: "/workspace" },
data: { sessionID: "ses_new" },
};
expect(translateV2Event(event, createV2EventTranslationState())).toEqual([{
type: "session.created",
properties: {
info: {
id: "ses_new",
slug: "ses_new",
projectID: "v2",
directory: "/workspace",
title: `New session - ${new Date(created).toISOString()}`,
version: "v2",
time: { created, updated: created },
},
},
}]);
expect(event.data).toEqual({ sessionID: "ses_new" });
});
test.each(["Named session", "Untitled session", ""])("translates rename %j as a title-only patch", (title) => {
expect(translateV2Event({
type: "session.renamed",
created: 1_788_548_737_260,
location: { directory: "/workspace" },
data: { sessionID: "ses_named", title },
}, createV2EventTranslationState())).toEqual([{
type: "session.updated",
properties: { info: { id: "ses_named", title } },
}]);
});
test("does not turn an incomplete rename into a generated title", () => {
expect(translateV2Event({
type: "session.renamed",
data: { sessionID: "ses_named" },
}, createV2EventTranslationState())).toBeNull();
});
test("uses one stable text part id from start through the cumulative end update", () => {
const state = createV2EventTranslationState();
expect(translateV2Event({
type: "session.text.started",
data: {
sessionID: "ses_1",
assistantMessageID: "msg_1",
textID: "txt_1",
timestamp: 10,
},
}, state)).toEqual([
{
type: "message.updated",
properties: {
info: {
id: "msg_1",
sessionID: "ses_1",
role: "assistant",
time: { created: 10 },
},
},
},
{
type: "message.part.updated",
properties: {
part: {
id: "msg_1:0",
messageID: "msg_1",
sessionID: "ses_1",
type: "text",
text: "",
},
},
},
]);
expect(translateV2Event({
type: "session.text.delta",
data: { sessionID: "ses_1", textID: "txt_1", delta: "Hello " },
}, state)).toEqual([{
type: "message.part.delta",
properties: {
sessionID: "ses_1",
messageID: "msg_1",
partID: "msg_1:0",
field: "text",
delta: "Hello ",
},
}]);
translateV2Event({
type: "session.text.delta",
data: { sessionID: "ses_1", textID: "txt_1", delta: "world" },
}, state);
expect(translateV2Event({
type: "session.text.ended",
data: { sessionID: "ses_1", textID: "txt_1" },
}, state)).toEqual([{
type: "message.part.updated",
properties: {
part: {
id: "msg_1:0",
messageID: "msg_1",
sessionID: "ses_1",
type: "text",
text: "Hello world",
},
},
}]);
});
test("uses event-provided ordinals to keep same-message text parts distinct", () => {
const state = createV2EventTranslationState();
const firstStarted = translateV2Event({
type: "session.text.started",
data: { sessionID: "ses_ordinal", assistantMessageID: "msg_ordinal", ordinal: 0 },
}, state);
const secondStarted = translateV2Event({
type: "session.text.started",
data: { sessionID: "ses_ordinal", assistantMessageID: "msg_ordinal", ordinal: 1 },
}, state);
expect(firstStarted?.[1]).toMatchObject({
type: "message.part.updated",
properties: { part: { id: "msg_ordinal:0" } },
});
expect(secondStarted?.[1]).toMatchObject({
type: "message.part.updated",
properties: { part: { id: "msg_ordinal:1" } },
});
const delta = translateV2Event({
type: "session.text.delta",
data: { sessionID: "ses_ordinal", assistantMessageID: "msg_ordinal", ordinal: 1, delta: "second" },
}, state);
expect(delta).toEqual([{
type: "message.part.delta",
properties: {
sessionID: "ses_ordinal",
messageID: "msg_ordinal",
partID: "msg_ordinal:1",
field: "text",
delta: "second",
},
}]);
expect(delta).not.toEqual(expect.arrayContaining([
expect.objectContaining({ properties: expect.objectContaining({ partID: "msg_ordinal:0" }) }),
]));
});
test("translates captured v2 text lifecycle events through explicit execution success", () => {
const state = createV2EventTranslationState();
const captured = [
{ type: "session.text.started", data: { sessionID: "s", assistantMessageID: "m", ordinal: 0 } },
{ type: "session.text.delta", data: { sessionID: "s", assistantMessageID: "m", ordinal: 0, delta: "hello world" } },
{ type: "session.text.ended", data: { sessionID: "s", assistantMessageID: "m", ordinal: 0, text: "hello world" } },
{ type: "session.execution.succeeded", data: { sessionID: "s" } },
];
const translated = captured.flatMap((event) => translateV2Event(event, state) ?? []);
expect(translated).toEqual([
{
type: "message.updated",
properties: {
info: {
id: "m",
sessionID: "s",
role: "assistant",
time: { created: expect.any(Number) },
},
},
},
{
type: "message.part.updated",
properties: {
part: { id: "m:0", messageID: "m", sessionID: "s", type: "text", text: "" },
},
},
{
type: "message.part.delta",
properties: {
sessionID: "s",
messageID: "m",
partID: "m:0",
field: "text",
delta: "hello world",
},
},
{
type: "message.part.updated",
properties: {
part: { id: "m:0", messageID: "m", sessionID: "s", type: "text", text: "hello world" },
},
},
{ type: "session.execution.succeeded", properties: { sessionID: "s", sequence: undefined } },
]);
});
test("translates the captured v2 shell lifecycle using the bash presentation", () => {
const state = createV2EventTranslationState();
const translated = capturedV2ToolEvents.flatMap((event) => translateV2Event(event, state) ?? []);
const command = { command: "printf 'TOOL_RESULT_OK\\n'", timeout: 30_000 };
expect(translated).toEqual([
{
type: "message.updated",
properties: {
info: {
id: "msg_06e0e76b900178zSuF55n4XEPY",
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
role: "assistant",
time: { created: 1_788_552_837_549 },
},
},
},
{
type: "message.part.updated",
properties: {
part: {
id: "call_captured_shell",
messageID: "msg_06e0e76b900178zSuF55n4XEPY",
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
type: "tool",
callID: "call_captured_shell",
tool: "bash",
state: { status: "pending", input: {}, raw: "" },
},
},
},
{
type: "message.part.updated",
properties: {
part: expect.objectContaining({
id: "call_captured_shell",
state: {
status: "pending",
input: command,
raw: "{\"command\":\"printf 'TOOL_RESULT_OK\\\\n'\",\"timeout\":30000}",
},
}),
},
},
{
type: "message.part.updated",
properties: {
part: expect.objectContaining({
id: "call_captured_shell",
state: {
status: "running",
input: command,
title: "bash",
metadata: {},
time: { start: 1_788_552_838_052 },
},
}),
},
},
{
type: "message.part.updated",
properties: {
part: expect.objectContaining({
id: "call_captured_shell",
state: {
status: "running",
input: command,
title: "bash",
metadata: { shellID: "sh_06e0e7c1e0017KTSezeFHBiGRk" },
time: { start: 1_788_552_838_052 },
},
}),
},
},
{
type: "message.part.updated",
properties: {
part: {
id: "call_captured_shell",
messageID: "msg_06e0e76b900178zSuF55n4XEPY",
sessionID: "ses_f91f18e25ffeiB1huO0Hascs8b",
type: "tool",
callID: "call_captured_shell",
tool: "bash",
state: {
status: "completed",
input: command,
output: "TOOL_RESULT_OK\n\nCommand exited with code 0.",
title: "bash",
metadata: { status: "completed", truncated: false, exit: 0 },
time: { start: 1_788_552_838_052, end: 1_788_552_838_184 },
},
},
},
},
]);
});
test.each(["text", "reasoning"])("isolates %s streams by session, message, kind, and ordinal", (kind) => {
const state = createV2EventTranslationState();
for (const sessionID of ["ses_one", "ses_two"]) {
for (const assistantMessageID of ["msg_one", "msg_two"]) {
for (const streamKind of ["text", "reasoning"]) {
translateV2Event({
type: `session.${streamKind}.started`, created: 10,
data: { sessionID, assistantMessageID, ordinal: 0 },
}, state);
}
}
}
const identity = { sessionID: "ses_one", assistantMessageID: "msg_one", ordinal: 0 };
const id = kind === "text" ? "msg_one:0" : "msg_one:reasoning:0";
expect(translateV2Event({
type: `session.${kind}.delta`, data: { ...identity, delta: "only this part" },
}, state)).toEqual([{
type: "message.part.delta",
properties: { sessionID: "ses_one", messageID: "msg_one", partID: id, field: "text", delta: "only this part" },
}]);
for (const unmatched of [
{ ...identity, assistantMessageID: "msg_missing" },
{ ...identity, ordinal: 9 },
{ ...identity, sessionID: "ses_missing" },
{ sessionID: "ses_one", [`${kind}ID`]: "missing" },
{ sessionID: "ses_one", [`${kind}Id`]: "missing" },
{ sessionID: "ses_one", assistantMessageID: "msg_one" },
{ sessionID: "ses_one", assistantMessageID: "" },
{ sessionID: "ses_one", messageID: null },
]) {
expect(translateV2Event({ type: `session.${kind}.delta`, data: { ...unmatched, delta: "WRONG" } }, state)).toBeNull();
expect(translateV2Event({ type: `session.${kind}.ended`, data: { ...unmatched, text: "WRONG" } }, state)).toBeNull();
}
for (const sessionID of ["ses_one", "ses_two"]) {
for (const assistantMessageID of ["msg_one", "msg_two"]) {
for (const streamKind of ["text", "reasoning"]) {
expect(translateV2Event({
type: `session.${streamKind}.ended`, created: 20,
data: { sessionID, assistantMessageID, ordinal: 0 },
}, state)).toMatchObject([{
properties: { part: {
sessionID, messageID: assistantMessageID, type: streamKind,
text: sessionID === "ses_one" && assistantMessageID === "msg_one" && streamKind === kind ? "only this part" : "",
} },
}]);
}
}
}
});
test("keeps legacy aliases and kind-local counters without letting tools consume text ordinals", () => {
const state = createV2EventTranslationState();
const identity = { sessionID: "ses_legacy", assistantMessageID: "msg_legacy" };
translateV2Event({ type: "session.tool.input.started", data: { ...identity, id: "call_first", name: "shell" } }, state);
for (const ordinal of [0, 1]) {
for (const kind of ["reasoning", "text"]) {
const id = `msg_legacy:${kind === "reasoning" ? "reasoning:" : ""}${ordinal}`;
const started = {
type: `session.next.${kind}.started`, created: 10,
data: { ...identity, [`${kind}ID`]: `shared_${ordinal}` },
};
expect(translateV2Event(started, state)?.[1]).toMatchObject({ properties: { part: { id, text: "" } } });
translateV2Event({ type: `session.next.${kind}.delta`, data: { sessionID: identity.sessionID, delta: "legacy" } }, state);
// Replayed starts must not reset accumulated text or advance the counter.
expect(translateV2Event(started, state)?.[1]).toMatchObject({ properties: { part: { id, text: "legacy" } } });
expect(translateV2Event({
type: `session.next.${kind}.ended`, created: 20,
data: { sessionID: identity.sessionID, [`${kind}ID`]: `shared_${ordinal}` },
}, state)).toMatchObject([{ properties: { part: { id, text: "legacy" } } }]);
expect(translateV2Event({
type: `session.next.${kind}.delta`,
data: { ...identity, assistantMessageID: "msg_other", [`${kind}ID`]: `shared_${ordinal}`, delta: "WRONG" },
}, state)).toBeNull();
expect(translateV2Event({
type: `session.next.${kind}.delta`,
data: { ...identity, ordinal: 9, [`${kind}ID`]: `shared_${ordinal}`, delta: "WRONG" },
}, state)).toBeNull();
}
}
});
test("preserves execution failure for sequenced terminal handling", () => {
const state = createV2EventTranslationState();
expect(translateV2Event({
type: "session.execution.failed",
properties: { sessionID: "ses_2", error: { message: "provider failed" } },
}, state)).toEqual([
{
type: "session.execution.failed",
properties: {
sessionID: "ses_2",
sequence: undefined,
error: { name: "UnknownError", data: { message: "provider failed" } },
},
},
]);
});
test("a failed execution keeps the provider's HTTP status for the auto retry", () => {
expect(translateV2Event({
type: "session.execution.failed",
properties: { sessionID: "ses_2", error: { type: "provider.invalid-request", message: "This chat runs on gpt-6-astra.", status: 400 } },
}, createV2EventTranslationState())?.[0]?.properties).toMatchObject({
error: { name: "UnknownError", data: { message: "This chat runs on gpt-6-astra.", statusCode: 400 } },
});
});
test("translates captured permission events for the child session while preserving busy and idle", () => {
const state = createV2EventTranslationState();
const translated = [
{ type: "session.execution.started", data: { sessionID: "ses_child" } },
capturedPermissionAsked,
capturedPermissionReplied,
{ type: "session.execution.succeeded", data: { sessionID: "ses_child" } },
].flatMap((event) => translateV2Event(event, state) ?? []);
expect(translated).toEqual([
{ type: "session.execution.started", properties: { sessionID: "ses_child", sequence: undefined } },
{
type: "permission.asked",
properties: {
id: "per_child",
sessionID: "ses_child",
action: "shell",
resources: ["printf 'TOOL_RESULT_OK'"],
save: ["printf *"],
metadata: { message: "Allow this command?" },
source: { type: "tool", messageID: "msg_child", callID: "call_child" },
},
},
{
type: "permission.replied",
properties: { sessionID: "ses_child", requestID: "per_child", reply: "once" },
},
{ type: "session.execution.succeeded", properties: { sessionID: "ses_child", sequence: undefined } },
]);
});
});
describe("OpenCode v2 client compatibility", () => {
test.each([0, 1_788_548_737_221])("archives (archived=%i) through the server's own flag on the session PATCH", async (archived) => {
const originalFetch = globalThis.fetch;
const sent: Array<{ method: string; path: string; body: unknown }> = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
sent.push({ method: request.method, path: new URL(request.url).pathname, body: request.method === "PATCH" ? await request.json() : null });
return jsonResponse({ data: { id: "ses_archive", title: "Keep", time: { created: 1, ...(archived ? { archived } : {}) } } });
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.update({ sessionID: "ses_archive", title: "Renamed", time: { archived } });
expect(result.data?.time.archived).toBe(archived || undefined);
expect(sent[0]).toEqual({ method: "PATCH", path: "/opencode2/api/session/ses_archive", body: { title: "Renamed", archived: archived || null } });
} finally {
globalThis.fetch = originalFetch;
}
});
test.each([true, false])("returns the actual native interrupt acknowledgement %s", async (interrupted) => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async (input) => {
expect(input instanceof Request && input.url.endsWith("/api/session/s/interrupt")).toBe(true);
return jsonResponse({ interrupted });
};
try {
expect((await createClientV2("http://opencode.test/opencode2", undefined, {}).session.abort({ sessionID: "s" })).data)
.toBe(interrupted);
} finally { globalThis.fetch = originalFetch; }
});
test("rejects a malformed native interrupt acknowledgement", async () => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async () => jsonResponse({ data: {} });
try {
const result = await createClientV2("http://opencode.test/opencode2", undefined, {}).session.abort({ sessionID: "s" });
expect(result.data).toBeUndefined();
expect(result.error).toEqual({ name: "InvalidV2InterruptResponse" });
} finally { globalThis.fetch = originalFetch; }
});
test("saved native instruction updates stay out of the visible conversation", async () => {
const originalFetch = globalThis.fetch;
const notice = "New skills are available in addition to those previously listed.";
globalThis.fetch = async () => jsonResponse({ data: [
{ id: "msg_idle", type: "idle", outcome: "succeeded", time: { created: 6 } },
{ id: "msg_switch", type: "model-switched", model: { id: "m", providerID: "p" }, time: { created: 5 } },
{ id: "msg_answer", type: "assistant", content: [{ type: "text", text: "The current report code." }], time: { created: 4 } },
{ id: "msg_user", type: "user", text: notice, time: { created: 3 } },
{ id: "msg_synthetic", type: "synthetic", text: "Internal context", time: { created: 2 } },
{ id: "msg_system", type: "system", text: notice, time: { created: 1 } },
] });
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_skills" });
expect(result.data?.map(message => message.info.id)).toEqual(["msg_user", "msg_answer"]);
expect(result.data?.[0]?.parts).toMatchObject([{ type: "text", text: notice }]);
} finally { globalThis.fetch = originalFetch; }
});
test("Code Mode keeps the same child identities through progress, replay, and saved history", async () => {
const state = createV2EventTranslationState();
const data = { sessionID: "ses_code", assistantMessageID: "msg_code", id: "execute-code" };
const toolCalls = [
{ tool: "omnirush-cloud.search_capabilities", status: "completed", input: { query: "Slack" } },
{ tool: "omnirush-cloud.execute_capability", status: "running", input: { name: "mcp:connection:list_channels" } },
];
translateV2Event({ type: "session.tool.input.started", data: { ...data, name: "execute" } }, state);
translateV2Event({ type: "session.tool.called", data: { ...data, input: { code: "recorded code" } } }, state);
const progress = { type: "session.tool.progress", data: { ...data, metadata: { toolCalls } } };
const expected = [{ type: "message.part.updated", properties: { part: {
id: "execute-code", callID: "execute-code", tool: "execute", metadata: { omnirushV2CodeMode: true },
state: { status: "running", metadata: { toolCalls } },
} } }];
expect(translateV2Event(progress, state)).toMatchObject(expected);
expect(translateV2Event(progress, state)).toMatchObject(expected);
const completedCalls = toolCalls.map(call => ({ ...call, status: "completed" }));
expect(translateV2Event({ type: "session.tool.success", data: {
...data, metadata: { toolCalls: completedCalls }, content: [{ type: "text", text: "Combined result" }],
} }, state)).toMatchObject([{ properties: { part: { id: "execute-code", state: {
output: "Combined result", metadata: { toolCalls: completedCalls },
} } } }]);
const originalFetch = globalThis.fetch;
globalThis.fetch = async () => jsonResponse({ data: [{
id: "msg_code", type: "assistant", time: { created: 1, completed: 2 },
content: [{ id: "execute-code", type: "tool", name: "execute", time: { created: 1, completed: 2 }, state: {
status: "completed", input: { code: "recorded code" }, metadata: { toolCalls: completedCalls },
content: [{ type: "text", text: "Combined result" }],
} }],
}] });
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_code" });
const saved = result.data?.[0]?.parts[0];
if (saved?.type !== "tool") throw new Error("Missing saved execute part");
const ui = parseDynamicToolUIPart(saved);
if (!ui) throw new Error("Missing execute UI part");
expect(codeModeToolCalls(ui)?.map(call => [call.toolCallId, call.toolName, call.state])).toEqual([
["execute-code:call:0", "omnirush-cloud_search_capabilities", "output-available"],
["execute-code:call:1", "omnirush-cloud_execute_capability", "output-available"],
]);
expect(ui).toMatchObject({ output: "Combined result" });
} finally { globalThis.fetch = originalFetch; }
});
test("hydrates mixed native content with the same text and reasoning IDs as streaming", async () => {
const originalFetch = globalThis.fetch;
// beta19086 schema: each kind has its own ordinal; reasoning time is optional.
const message = {
id: "msg_mixed", type: "assistant", time: { created: 5, completed: 90 },
error: { type: "unknown", message: "partial turn failed" },
content: [
{ type: "reasoning", text: "First thought", time: { created: 10, completed: 20 } },
{ ...capturedV2ToolMessage.content[1] },
{ type: "text", text: "First answer" },
{ type: "reasoning", text: "Second thought", time: { created: 40, completed: 50 } },
{ type: "text", text: "Second answer" },
{ type: "reasoning", text: "Unfinished thought" },
],
};
globalThis.fetch = async () => jsonResponse({ data: [message] });
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_mixed" });
const parts = result.data?.[0]?.parts;
expect(parts?.map((part) => part.id)).toEqual([
"msg_mixed:reasoning:0", "call_captured_shell", "msg_mixed:0",
"msg_mixed:reasoning:1", "msg_mixed:1", "msg_mixed:reasoning:2",
]);
expect(result.data?.[0]?.info.error).toEqual({ name: "UnknownError", data: { message: "partial turn failed" } });
expect(parts?.[5]).toEqual({
id: "msg_mixed:reasoning:2", sessionID: "ses_mixed", messageID: "msg_mixed",
type: "reasoning", text: "Unfinished thought", time: { start: 5 },
});
const state = createV2EventTranslationState();
const identity = { sessionID: "ses_mixed", assistantMessageID: "msg_mixed" };
translateV2Event({ type: "session.tool.input.started", data: { ...identity, id: "call_captured_shell", name: "shell" } }, state);
for (const [kind, ordinal, text, start, end, index] of [
["reasoning", 0, "First thought", 10, 20, 0],
["text", 0, "First answer", 30, 35, 2],
["reasoning", 1, "Second thought", 40, 50, 3],
["text", 1, "Second answer", 60, 70, 4],
] as const) {
const data = { ...identity, ordinal };
const started = translateV2Event({ type: `session.${kind}.started`, created: start, data }, state);
expect(started?.[0]).toMatchObject({ properties: { info: { time: { created: start } } } });
expect(started?.[1]).toMatchObject({ properties: { part: { id: parts?.[index]?.id, type: kind, text: "" } } });
translateV2Event({ type: `session.${kind}.delta`, data: { ...data, delta: "partial" } }, state);
const ended = { type: `session.${kind}.ended`, created: end, data: { ...data, text } };
expect(translateV2Event(ended, state)).toEqual([{ type: "message.part.updated", properties: { part: parts?.[index] } }]);
expect(translateV2Event(ended, state)).toEqual([{ type: "message.part.updated", properties: { part: parts?.[index] } }]);
}
} finally {
globalThis.fetch = originalFetch;
}
});
test("maps native file results to stable per-call attachments in live and hydrated completed tools", async () => {
const originalFetch = globalThis.fetch;
const content = [
{ type: "text", text: "Created files" },
{ type: "file", uri: "file:///workspace/report.pdf", mime: "application/pdf", name: "report.pdf" },
{ type: "text", text: "Two outputs" },
{ type: "file", uri: "data:image/png;base64,AA==", mime: "image/png" },
];
const tools = ["call_one", "call_two"].map((id) => ({
type: "tool", id, name: "export_report",
state: { status: "completed", input: {}, content, metadata: { files: 2 } },
time: { created: 10, ran: 20, completed: 30 },
}));
globalThis.fetch = async () => jsonResponse({ data: [{ id: "msg_files", type: "assistant", time: { created: 5 }, content: tools }] });
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_files" });
const state = createV2EventTranslationState();
for (const [index, tool] of tools.entries()) {
const identity = { sessionID: "ses_files", assistantMessageID: "msg_files", id: tool.id };
translateV2Event({ type: "session.tool.input.started", created: 10, data: { ...identity, name: tool.name } }, state);
translateV2Event({ type: "session.tool.called", created: 20, data: { ...identity, input: {}, executed: false } }, state);
const completed = translateV2Event({
type: "session.tool.success", created: 30, data: { ...identity, content, metadata: { files: 2 }, executed: false },
}, state);
expect(completed).toEqual([{ type: "message.part.updated", properties: { part: result.data?.[0]?.parts[index] } }]);
expect(result.data?.[0]?.parts[index]).toMatchObject({ state: {
output: "Created files\nTwo outputs",
attachments: [
{ id: `${tool.id}:file:0`, sessionID: "ses_files", messageID: "msg_files", type: "file", url: content[1]?.uri, mime: "application/pdf", filename: "report.pdf" },
{ id: `${tool.id}:file:1`, sessionID: "ses_files", messageID: "msg_files", type: "file", url: content[3]?.uri, mime: "image/png" },
],
} });
// Repeated completion retains IDs, including identical URIs on distinct calls.
expect(translateV2Event({
type: "session.tool.success", created: 30, data: { ...identity, content },
}, state)).toEqual(completed);
}
} finally {
globalThis.fetch = originalFetch;
}
});
test.each(["subagent", "task", "custom_subagent"])("normalizes only native subagent fields, not %s lookalikes", async (name) => {
const originalFetch = globalThis.fetch;
const input = { agent: "explore", prompt: "Inspect workspace", description: "Workspace inspection", extra: { keep: true } };
const metadata = { sessionID: "ses_child", status: "working", extra: ["keep"] };
const expectedInput = name === "subagent" ? { ...input, subagent_type: "explore" } : input;
const expectedMetadata = name === "subagent" ? { ...metadata, sessionId: "ses_child" } : metadata;
const expectedTool = name === "subagent" ? "task" : name;
const error = { type: "unknown", message: "child failed" };
const content = [{ type: "text", text: "Child result" }];
const states = [
{ status: "streaming", input: JSON.stringify(input) },
{ status: "running", input, metadata },
{ status: "completed", input, metadata, content },
{ status: "error", input, metadata, error },
];
globalThis.fetch = async () => jsonResponse({ data: states.map((state) => ({
id: "msg_parent", type: "assistant", time: { created: 5 },
content: [{ type: "tool", id: "call_child", name, state, time: { created: 10, ran: 20, completed: 30 } }],
})).reverse() });
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_parent" });
for (const [index, message] of (result.data ?? []).entries()) {
expect(message.parts[0]).toMatchObject({
tool: expectedTool, state: { input: expectedInput, ...(index > 0 ? { metadata: expectedMetadata } : {}) },
});
}
const state = createV2EventTranslationState();
const identity = { sessionID: "ses_parent", assistantMessageID: "msg_parent", id: "call_child" };
translateV2Event({ type: "session.tool.input.started", created: 10, data: { ...identity, name } }, state);
for (const type of ["session.tool.input.delta", "session.tool.input.ended"]) {
expect(translateV2Event({ type, data: { ...identity, delta: JSON.stringify(input), text: JSON.stringify(input) } }, state))
.toEqual([{ type: "message.part.updated", properties: { part: result.data?.[0]?.parts[0] } }]);
}
expect(translateV2Event({ type: "session.tool.called", created: 20, data: { ...identity, input, executed: false } }, state))
.toMatchObject([{ properties: { part: { tool: expectedTool, state: { input: expectedInput, status: "running" } } } }]);
expect(translateV2Event({ type: "session.tool.progress", created: 25, data: { ...identity, metadata } }, state))
.toEqual([{ type: "message.part.updated", properties: { part: result.data?.[1]?.parts[0] } }]);
expect(translateV2Event({ type: "session.tool.success", created: 30, data: { ...identity, metadata, content, executed: false } }, state))
.toEqual([{ type: "message.part.updated", properties: { part: result.data?.[2]?.parts[0] } }]);
expect(translateV2Event({ type: "session.tool.failed", created: 30, data: { ...identity, metadata, error, executed: false } }, state))
.toEqual([{ type: "message.part.updated", properties: { part: result.data?.[3]?.parts[0] } }]);
expect(result.data?.[3]?.parts[0]).toMatchObject({ state: { error: "child failed" } });
expect(input).not.toHaveProperty("subagent_type");
expect(metadata).not.toHaveProperty("sessionId");
} finally {
globalThis.fetch = originalFetch;
}
});
test("preserves existing compatibility fields on native subagent inputs and metadata", async () => {
const originalFetch = globalThis.fetch;
const input = { agent: "explore", subagent_type: "manual", custom: { agent: "unchanged" } };
const metadata = { sessionID: "ses_native", sessionId: "ses_manual", custom: { sessionID: "unchanged" } };
globalThis.fetch = async () => jsonResponse({ data: [{
id: "msg_parent", type: "assistant", time: { created: 10 },
content: [{ type: "tool", id: "call_child", name: "subagent", time: { created: 10, ran: 20 }, state: { status: "running", input, metadata } }],
}] });
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_parent" });
expect(result.data?.[0]?.parts[0]).toMatchObject({ tool: "task", state: { input, metadata } });
const state = createV2EventTranslationState();
const identity = { sessionID: "ses_parent", assistantMessageID: "msg_parent", id: "call_child" };
translateV2Event({ type: "session.tool.input.started", created: 10, data: { ...identity, name: "subagent" } }, state);
translateV2Event({ type: "session.tool.called", created: 20, data: { ...identity, input, executed: false } }, state);
expect(translateV2Event({ type: "session.tool.progress", data: { ...identity, metadata } }, state))
.toEqual([{ type: "message.part.updated", properties: { part: result.data?.[0]?.parts[0] } }]);
} finally {
globalThis.fetch = originalFetch;
}
});
test("maps only missing and empty native titles to stable read-time placeholders", async () => {
const originalFetch = globalThis.fetch;
const created = 1_788_548_737_221;
const time = { created, updated: created + 100 };
const sessions = [
{ id: "ses_missing", created },
{ id: "ses_empty", title: "", time },
{ id: "ses_literal", title: "Untitled session", time },
{ id: "ses_named", title: "Named session", time },
];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.method === "GET" && request.url.endsWith("/api/session")) {
return jsonResponse({ data: sessions });
}
const session = sessions.find((item) => request.url.endsWith(`/api/session/${item.id}`));
if (request.method === "GET" && session) return jsonResponse({ data: session });
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.list();
const placeholder = `New session - ${new Date(created).toISOString()}`;
expect(result.data?.map((session) => session.title)).toEqual([
placeholder, placeholder, "Untitled session", "Named session",
]);
for (const session of result.data ?? []) {
const fetched = await client.session.get({ sessionID: session.id });
expect(fetched.data).toEqual(session);
}
expect(result.data?.[1]?.time).toEqual(time);
} finally {
globalThis.fetch = originalFetch;
}
});
test.each([undefined, "", "Named session", "Untitled session"])("forwards only the provided title %j when creating a session", async (title) => {
const originalFetch = globalThis.fetch;
const bodies: unknown[] = [];
const created = 1_788_548_737_221;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.method === "POST" && request.url.endsWith("/api/session")) {
bodies.push(await request.json());
return jsonResponse({ data: { id: "ses_new", title, created } });
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.create({ title });
expect(bodies).toEqual([{
location: { directory: "/workspace" },
...(title === undefined ? {} : { title }),
}]);
expect(result.data?.title).toBe(title || `New session - ${new Date(created).toISOString()}`);
} finally {
globalThis.fetch = originalFetch;
}
});
test("retains native assistant errors even when a failed turn has text and a completion time", async () => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.method === "GET" && new URL(request.url).pathname.endsWith("/api/session/ses_failed/message")) {
return jsonResponse({ data: [{
id: "msg_failed",
type: "assistant",
time: { created: 10, completed: 20 },
content: [{ type: "text", text: "Partial response" }],
error: { type: "unknown", message: "provider unavailable" },
}] });
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_failed" });
expect(result.data).toEqual([{
info: {
id: "msg_failed",
sessionID: "ses_failed",
role: "assistant",
time: { created: 10, completed: 20 },
error: { name: "UnknownError", data: { message: "provider unavailable" } },
},
parts: [{
id: "msg_failed:0",
messageID: "msg_failed",
sessionID: "ses_failed",
type: "text",
text: "Partial response",
}],
}]);
} finally {
globalThis.fetch = originalFetch;
}
});
test("maps active v2 sessions to busy compatibility statuses", async () => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.method === "GET" && request.url.endsWith("/api/session/active")) {
return jsonResponse({ data: { ses_active: { type: "running" } } });
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.status();
expect(result.data).toEqual({ ses_active: { type: "busy" } });
} finally {
globalThis.fetch = originalFetch;
}
});
test("maps captured v2 message content and presents shell tool parts as bash", async () => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.method === "GET" && new URL(request.url).pathname.endsWith("/api/session/ses_tool/message")) {
return jsonResponse({ data: [capturedV2ToolMessage] });
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.messages({ sessionID: "ses_tool" });
expect(result.data).toEqual([{
info: {
id: "msg_06e0e76b900178zSuF55n4XEPY",
sessionID: "ses_tool",
role: "assistant",
time: { created: 1_788_552_837_299, completed: 1_788_552_838_186 },
},
parts: [
{
id: "msg_06e0e76b900178zSuF55n4XEPY:0",
messageID: "msg_06e0e76b900178zSuF55n4XEPY",
sessionID: "ses_tool",
type: "text",
text: "Running the shell.\n",
},
{
id: "call_captured_shell",
messageID: "msg_06e0e76b900178zSuF55n4XEPY",
sessionID: "ses_tool",
type: "tool",
callID: "call_captured_shell",
tool: "bash",
state: {
status: "completed",
input: { command: "printf 'TOOL_RESULT_OK\\n'", timeout: 30_000 },
output: "TOOL_RESULT_OK\n\nCommand exited with code 0.",
title: "bash",
metadata: { status: "completed", truncated: false, exit: 0 },
time: { start: 1_788_552_838_052, end: 1_788_552_838_184 },
},
},
],
}]);
} finally {
globalThis.fetch = originalFetch;
}
});
test("waits for native prompt admission and returns its actual response without waiting for execution", async () => {
const originalFetch = globalThis.fetch;
const admission = Promise.withResolvers<Response>();
const dispatched = Promise.withResolvers<Request>();
const response = new Response(null, { status: 204, headers: { "X-Admission": "accepted" } });
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/model")) return jsonResponse({ data: {} });
if (request.url.endsWith("/prompt")) {
dispatched.resolve(request);
return admission.promise;
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
let settled = false;
const pending = client.session.promptAsync({
sessionID: "ses_prompt",
model: { providerID: "witness", modelID: "model" },
parts: [{ type: "text", text: "hello" }],
}).finally(() => { settled = true; });
const request = await dispatched.promise;
await delay(10);
expect(settled).toBe(false);
expect(await request.clone().json()).toEqual({ text: "hello" });
admission.resolve(response);
const result = await pending;
expect(result.error).toBeUndefined();
expect(result.response).toBe(response);
expect(result.response.status).toBe(204);
expect(result.request.url).toBe(request.url);
} finally {
admission.resolve(response);
globalThis.fetch = originalFetch;
}
});
test("workspace streams reject foreign and unscoped permission events", async () => {
const originalFetch = globalThis.fetch;
const events = [
{ ...capturedPermissionAsked, location: undefined, data: { ...capturedPermissionAsked.data, sessionID: "ses_unscoped" } },
{ ...capturedPermissionAsked, location: { directory: "/other" }, data: { ...capturedPermissionAsked.data, sessionID: "ses_foreign" } },
capturedPermissionAsked,
];
globalThis.fetch = async () => new Response(
events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""),
{ headers: { "Content-Type": "text/event-stream" } },
);
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace/", {});
const subscription = await client.event.subscribe();
const next = await subscription.stream.next();
expect(next.value).toMatchObject({ type: "permission.asked", properties: { sessionID: "ses_child" } });
await subscription.stream.return(undefined);
} finally {
globalThis.fetch = originalFetch;
}
});
test("discovers external forks from authoritative sessions once, without fetching foreign events or the source", async () => {
const originalFetch = globalThis.fetch;
const requests: Request[] = [];
const info = {
id: "ses_fork", title: "Source (fork #1)", slug: "fork-slug", projectID: "project",
location: { directory: "/workspace/" }, version: "native",
time: { created: 100, updated: 200 },
fork: { sessionID: "ses_source", boundary: nativeForkEvent.data.boundary },
};
const events = [
{ ...nativeForkEvent, location: undefined, data: { ...nativeForkEvent.data, sessionID: "ses_unscoped" } },
{ ...nativeForkEvent, location: { directory: "/other" }, data: { ...nativeForkEvent.data, sessionID: "ses_foreign" } },
nativeForkEvent, nativeForkEvent, capturedPermissionAsked,
];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
requests.push(request);
return request.url.endsWith("/api/event")
? new Response(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""))
: jsonResponse({ data: info });
};
try {
const client = createClientV2("http://opencode.test/workspace/owned/opencode2", "/workspace", { token: "fixture-token" });
const subscription = await client.event.subscribe();
const received = [];
for await (const event of subscription.stream) received.push(event);
expect(received).toHaveLength(2);
expect(received.find((event) => event.type === "session.created")).toEqual({ type: "session.created", properties: { info: {
id: info.id, title: info.title, slug: info.slug, projectID: info.projectID,
directory: info.location.directory, version: info.version, time: info.time,
} } });
expect(received[0]?.type).toBe("permission.asked");
expect(requests.map((request) => [request.method, new URL(request.url).pathname])).toEqual([
["GET", "/workspace/owned/opencode2/api/event"], ["GET", "/workspace/owned/opencode2/api/session/ses_fork"],
]);
expect(requests.every((request) => request.headers.get("Authorization") === "Bearer fixture-token")).toBe(true);
const fork = await client.session.fork({ sessionID: "ses_source", messageID: "msg_source" });
expect(fork.data?.id).toBe("ses_fork");
expect(fork.data?.parentID).toBeUndefined();
expect([requests[2]?.method, new URL(requests[2]?.url ?? "").pathname]).toEqual(["POST", "/workspace/owned/opencode2/api/session/ses_source/fork"]);
expect(await requests[2]?.json()).toEqual({ before: "msg_source" });
} finally { globalThis.fetch = originalFetch; }
});
test("held fork discovery does not block permission or text, wakes a waiting reader, and deduplicates replays", async () => {
const originalFetch = globalThis.fetch;
const source = eventStream();
const controller = new AbortController();
const lookup = Promise.withResolvers<Response>();
const requests: Request[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/event")) return source.response;
requests.push(request);
return lookup.promise;
};
try {
const subscription = await createClientV2("http://opencode.test/opencode2", "/workspace", {}).event.subscribe({}, { signal: controller.signal });
source.send(nativeForkEvent);
source.send(nativeForkEvent);
source.send(capturedPermissionAsked);
const started = Date.now();
expect((await subscription.stream.next()).value?.type).toBe("permission.asked");
const data = { sessionID: "ses_other", assistantMessageID: "msg_other", ordinal: 0 };
source.send({ type: "session.text.started", location: { directory: "/workspace" }, data });
expect((await subscription.stream.next()).value?.type).toBe("message.updated");
expect((await subscription.stream.next()).value?.type).toBe("message.part.updated");
for (let index = 0; index < 100; index += 1) {
source.send({ type: "session.text.delta", location: { directory: "/workspace" }, data: { ...data, delta: "text" } });
expect((await subscription.stream.next()).value).toMatchObject({
type: "message.part.delta", properties: { sessionID: "ses_other", delta: "text" },
});
}
expect(Date.now() - started).toBeLessThan(1_000);
expect(requests).toHaveLength(1);
expect(requests[0]?.signal.aborted).toBe(false);
const pending = subscription.stream.next();
await delay(0);
lookup.resolve(jsonResponse({ data: { id: "ses_fork", title: "Late fork", location: { directory: "/workspace" } } }));
expect((await pending).value).toMatchObject({
type: "session.created", properties: { info: { id: "ses_fork", title: "Late fork" } },
});
// Discovery must not discard the outstanding SSE read or refetch success.
source.send(nativeForkEvent);
source.send(capturedPermissionReplied);
expect((await subscription.stream.next()).value?.type).toBe("permission.replied");
expect(requests).toHaveLength(1);
await subscription.stream.return(undefined);
expect(source.cancelled).toBe(true);
expect(source.body.locked).toBe(false);
} finally {
controller.abort();
globalThis.fetch = originalFetch;
}
});
test.each(["pending", "queued"])("deletion discards %s fork discovery without affecting another lookup", async (phase) => {
const originalFetch = globalThis.fetch;
const source = eventStream();
const controller = new AbortController();
const lookup = Promise.withResolvers<Response>();
const otherLookup = Promise.withResolvers<Response>();
const requests: Request[] = [];
const info = { id: "ses_fork", title: "Deleted fork", location: { directory: "/workspace" } };
const deleted = {
type: "session.deleted", location: { directory: "/workspace" },
data: phase === "pending" ? { sessionID: "ses_fork" } : { info: { id: "ses_fork" } },
};
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/event")) return source.response;
requests.push(request);
if (request.url.endsWith("/api/session/ses_fork")) return lookup.promise;
if (request.url.endsWith("/api/session/ses_other")) return otherLookup.promise;
throw new Error(`Unexpected request: ${request.url}`);
};
try {
const subscription = await createClientV2("http://opencode.test/opencode2", "/workspace", {}).event.subscribe({}, { signal: controller.signal });
// One SSE chunk lets lookup completion queue while parsing is paused at
// the permission yield, before the matching deletion is translated.
source.send(
nativeForkEvent,
{ ...nativeForkEvent, data: { ...nativeForkEvent.data, sessionID: "ses_other" } },
{ ...deleted, location: { directory: "/other" } },
{ ...deleted, location: undefined },
capturedPermissionAsked, deleted, capturedPermissionReplied,
);
expect((await subscription.stream.next()).value?.type).toBe("permission.asked");
expect(requests).toHaveLength(2);
expect(requests.every((request) => !request.signal.aborted)).toBe(true);
if (phase === "queued") {
lookup.resolve(jsonResponse({ data: info }));
await delay(0);
}
expect((await subscription.stream.next()).value).toMatchObject({
type: "session.deleted", properties: { sessionID: "ses_fork" },
});
if (phase === "pending") expect(requests[0]?.signal.aborted).toBe(true);
expect(requests[1]?.signal.aborted).toBe(false);
expect((await subscription.stream.next()).value?.type).toBe("permission.replied");
// The deleted lookup's transport ignores cancellation and returns stale
// metadata; only the unrelated fork may still be discovered.
lookup.resolve(jsonResponse({ data: info }));
otherLookup.resolve(jsonResponse({ data: { ...info, id: "ses_other", title: "Kept fork" } }));
expect((await subscription.stream.next()).value).toMatchObject({
type: "session.created", properties: { info: { id: "ses_other", title: "Kept fork" } },
});
source.send(nativeForkEvent, capturedPermissionAsked);
expect((await subscription.stream.next()).value?.type).toBe("permission.asked");
expect(requests).toHaveLength(2);
source.close();
expect(await subscription.stream.next()).toEqual({ done: true, value: undefined });
expect(source.body.locked).toBe(false);
} finally { controller.abort(); globalThis.fetch = originalFetch; }
});
test.each(["deleted", "unavailable", "network", "missing", "wrong-id", "foreign", "unscoped", "timeout"])(
"skips a %s fork lookup, continues the stream, and allows recovery on replay", async (failure) => {
const originalFetch = globalThis.fetch;
const source = eventStream();
const controller = new AbortController();
let lookups = 0;
let lookupSignal: AbortSignal | undefined;
const info = { id: "ses_fork", title: "Recovered fork", location: { directory: "/workspace" }, time: { created: 100, updated: 200 } };
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/event")) return source.response;
lookups += 1;
if (lookups > 1) return jsonResponse({ data: info });
lookupSignal = request.signal;
if (failure === "deleted") return jsonResponse({}, 404);
if (failure === "unavailable") return jsonResponse({}, 503);
if (failure === "network") throw new TypeError("Network unavailable");
if (failure === "missing") return jsonResponse({ data: null });
if (failure === "wrong-id") return jsonResponse({ data: { ...info, id: "ses_source" } });
if (failure === "foreign") return jsonResponse({ data: { ...info, location: { directory: "/other" } } });
if (failure === "unscoped") return jsonResponse({ data: { ...info, location: undefined } });
// An IPC transport may ignore cancellation entirely.
return new Promise<Response>(() => {});
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const subscription = await client.event.subscribe({}, { signal: controller.signal });
source.send(nativeForkEvent);
source.send(capturedPermissionAsked);
const started = Date.now();
expect((await subscription.stream.next()).value?.type).toBe("permission.asked");
expect(Date.now() - started).toBeLessThan(1_000);
if (failure === "timeout") {
expect(lookupSignal?.aborted).toBe(false);
await new Promise<void>((resolve) => lookupSignal?.addEventListener("abort", () => resolve(), { once: true }));
expect(Date.now() - started).toBeLessThan(3_000);
}
// Replay after failure has settled, not while the first lookup is live.
await delay(0);
source.send(nativeForkEvent);
expect((await subscription.stream.next()).value).toMatchObject({
type: "session.created", properties: { info: { id: info.id, title: info.title } },
});
source.close();
expect(await subscription.stream.next()).toEqual({ done: true, value: undefined });
expect(source.body.locked).toBe(false);
expect(lookups).toBe(2);
} finally { controller.abort(); globalThis.fetch = originalFetch; }
},
);
test.each(["abort", "return", "read error"])("%s cleans up a waiting subscription and its fork lookup without emitting a session", async (action) => {
const originalFetch = globalThis.fetch;
const controller = new AbortController();
const source = eventStream();
const dispatched = Promise.withResolvers<Request>();
const lookup = Promise.withResolvers<Response>();
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/event")) return source.response;
dispatched.resolve(request);
return lookup.promise;
};
try {
const subscription = await createClientV2("http://opencode.test/opencode2", "/workspace", {}).event.subscribe({}, { signal: controller.signal });
source.send(nativeForkEvent);
const pending = subscription.stream.next();
const request = await dispatched.promise;
await delay(0);
if (action === "read error") {
const error = new Error("SSE read failed");
source.fail(error);
await expect(pending).rejects.toBe(error);
} else {
if (action === "abort") controller.abort();
else expect(await subscription.stream.return(undefined)).toEqual({ done: true, value: undefined });
expect(await pending).toEqual({ done: true, value: undefined });
}
expect(request.signal.aborted).toBe(true);
expect(source.cancelled).toBe(action !== "read error");
expect(source.body.locked).toBe(false);
lookup.resolve(jsonResponse({ data: { id: "ses_fork", location: { directory: "/workspace" } } }));
expect(await subscription.stream.next()).toEqual({ done: true, value: undefined });
} finally { controller.abort(); globalThis.fetch = originalFetch; }
});
test.each([400, 409, 500])("returns native prompt admission failure %i to a separate send client", async (status) => {
const originalFetch = globalThis.fetch;
const error = { name: "SessionPromptFailed", error: { message: "admission rejected", detail: { retryable: false } } };
const response = jsonResponse(error, status);
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/event")) {
return new Response("", { headers: { "Content-Type": "text/event-stream" } });
}
if (request.url.endsWith("/model")) return jsonResponse({ data: {} });
if (request.url.endsWith("/prompt")) {
return response;
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const eventClient = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const subscription = await eventClient.event.subscribe();
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.promptAsync({
sessionID: "ses_failure",
model: { providerID: "witness", modelID: "model" },
parts: [{ type: "text", text: "hello" }],
});
expect(result.response).toBe(response);
expect(result.error).toEqual(error);
expect(result.data).toBeUndefined();
expect(result.request.url).toEndWith("/api/session/ses_failure/prompt");
expect(await subscription.stream.next()).toEqual({ done: true, value: undefined });
} finally {
globalThis.fetch = originalFetch;
}
});
test("sends attachments as the engine's files", async () => {
const originalFetch = globalThis.fetch;
let sent: unknown = null;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/prompt")) sent = await request.json();
return jsonResponse({ data: {} });
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
await client.session.promptAsync({
sessionID: "ses_files",
model: { providerID: "omnirush", modelID: "gpt-6-astra" },
parts: [{ type: "text", text: "look" }, { type: "file", mime: "image/png", url: "data:image/png;base64,AA==", filename: "a.png" } as never],
});
expect(sent).toEqual({ text: "look", files: [{ uri: "data:image/png;base64,AA==", name: "a.png" }] });
} finally {
globalThis.fetch = originalFetch;
}
});
test.each(["model", "prompt"])("propagates network rejection from %s without fabricating success", async (endpoint) => {
const originalFetch = globalThis.fetch;
const failure = new TypeError("network unavailable");
const paths: string[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
paths.push(new URL(request.url).pathname);
if (request.url.endsWith(`/${endpoint}`)) throw failure;
return jsonResponse({ data: {} });
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
await expect(client.session.promptAsync({
sessionID: "ses_failure",
model: { providerID: "witness", modelID: "model" },
parts: [{ type: "text", text: "hello" }],
})).rejects.toBe(failure);
expect(paths).toHaveLength(endpoint === "model" ? 1 : 2);
} finally {
globalThis.fetch = originalFetch;
}
});
test("preserves model admission failure and does not dispatch a prompt", async () => {
const originalFetch = globalThis.fetch;
const error = { name: "ModelNotFound", data: { modelID: "missing" } };
const response = jsonResponse(error, 404);
const paths: string[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
paths.push(new URL(request.url).pathname);
return response;
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.session.promptAsync({
sessionID: "ses_failure",
model: { providerID: "witness", modelID: "missing" },
parts: [{ type: "text", text: "hello" }],
});
expect(result.response).toBe(response);
expect(result.error).toEqual(error);
expect(result.data).toBeUndefined();
expect(paths).toEqual(["/opencode2/api/session/ses_failure/model"]);
} finally {
globalThis.fetch = originalFetch;
}
});
test.each(["model", "prompt"])("propagates abort while waiting for %s admission", async (endpoint) => {
const originalFetch = globalThis.fetch;
const controller = new AbortController();
const dispatched = Promise.withResolvers<Request>();
const paths: string[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
paths.push(new URL(request.url).pathname);
if (!request.url.endsWith(`/${endpoint}`)) return jsonResponse({ data: {} });
dispatched.resolve(request);
return new Promise<Response>((_resolve, reject) => {
request.signal.addEventListener("abort", () => reject(request.signal.reason), { once: true });
});
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const pending = client.session.promptAsync({
sessionID: "ses_abort",
model: { providerID: "witness", modelID: "model" },
parts: [{ type: "text", text: "hello" }],
}, { signal: controller.signal });
const request = await dispatched.promise;
const failure = new DOMException("Cancelled admission", "AbortError");
controller.abort(failure);
await expect(pending).rejects.toBe(failure);
expect(request.signal.aborted).toBe(true);
expect(paths).toHaveLength(endpoint === "model" ? 1 : 2);
} finally {
controller.abort();
globalThis.fetch = originalFetch;
}
});
test("lists and replies to captured v2 permission requests", async () => {
const originalFetch = globalThis.fetch;
const replyBodies: unknown[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.method === "GET" && request.url.endsWith("/api/session")) {
return jsonResponse({ data: [{ id: "ses_child" }] });
}
if (request.method === "GET" && request.url.endsWith("/api/session/ses_child/permission")) {
return jsonResponse({ data: [capturedPermissionAsked.data] });
}
if (request.method === "POST" && request.url.endsWith("/api/session/ses_child/permission/per_child/reply")) {
replyBodies.push(await request.json());
return new Response(null, { status: 204 });
}
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const v2 = await client.v2.session.permission.list({ sessionID: "ses_child" });
expect(v2.data).toEqual({
data: [{
id: "per_child",
sessionID: "ses_child",
action: "shell",
resources: ["printf 'TOOL_RESULT_OK'"],
save: ["printf *"],
metadata: { message: "Allow this command?" },
source: { type: "tool", messageID: "msg_child", callID: "call_child" },
}],
});
const legacy = await client.permission.list();
expect(legacy.data).toEqual([{
id: "per_child",
sessionID: "ses_child",
permission: "shell",
patterns: ["printf 'TOOL_RESULT_OK'"],
metadata: { action: "shell", message: "Allow this command?" },
always: ["printf *"],
tool: { messageID: "msg_child", callID: "call_child" },
}]);
const legacyReply = await client.permission.reply({ requestID: "per_child", reply: "always" });
expect(legacyReply.data).toBe(true);
await client.v2.session.permission.list({ sessionID: "ses_child" });
const reply = await client.v2.session.permission.reply({
sessionID: "ses_child",
requestID: "per_child",
reply: "once",
});
expect(reply.error).toBeUndefined();
expect(reply.response.status).toBe(204);
expect(replyBodies).toEqual([{ decision: "always" }, { decision: "once" }]);
} finally {
globalThis.fetch = originalFetch;
}
});
});
test("v2 provider catalog retains display names without exposing request settings", async () => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/model")) return jsonResponse({ data: [{ id: "coding", providerID: "lpr_fixture", name: "Coding" }] });
if (request.url.endsWith("/api/provider")) return jsonResponse({ data: [{ id: "lpr_fixture", name: "Assigned Coding", settings: { apiKey: "fixture-private" } }] });
if (request.url.endsWith("/api/model/default")) return jsonResponse({ data: {} });
throw new Error(`Unexpected request: ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const result = await client.provider.list();
expect(result.data?.all[0]?.name).toBe("Assigned Coding");
expect(JSON.stringify(result.data)).not.toContain("fixture-private");
} finally {
globalThis.fetch = originalFetch;
}
});
describe("v2 question forms", () => {
const form = {
id: "frm_choice", sessionID: "ses_side", title: "Questions",
metadata: { kind: "question", tool: { messageID: "msg_side", id: "call_question" } },
fields: [
{ key: "q0", type: "string", title: "Format", description: "Which format?", custom: true,
options: [{ label: "Summary", value: "summary_value", description: "A short overview" }] },
{ key: "q1", type: "multiselect", title: "Sections", description: "Which sections?", custom: true,
options: [{ label: "Facts", value: "facts_value" }, { label: "Actions", value: "actions_value" }] },
],
};
test("maps pending, answered, and cancelled forms to the existing question UI protocol", () => {
const state = createV2EventTranslationState();
expect(translateV2Event({ type: "form.created", data: { form } }, state)).toEqual([{
type: "question.asked", properties: {
id: "frm_choice", sessionID: "ses_side", tool: { messageID: "msg_side", callID: "call_question" },
questions: [
{ header: "Format", question: "Which format?", custom: true, multiple: false,
options: [{ label: "Summary", description: "A short overview" }] },
{ header: "Sections", question: "Which sections?", custom: true, multiple: true,
options: [{ label: "Facts", description: "" }, { label: "Actions", description: "" }] },
],
},
}]);
expect(translateV2Event({ type: "form.created", data: { form: { ...form, metadata: { kind: "oauth" } } } }, state)).toBeNull();
for (const [event, expected] of [["form.replied", "question.replied"], ["form.cancelled", "question.rejected"]]) {
expect(translateV2Event({ type: event, data: { id: form.id, sessionID: form.sessionID } }, state)).toEqual([
{ type: expected, properties: { requestID: form.id, sessionID: form.sessionID } },
]);
}
});
test("an interaction client can answer a live form it never listed, preserving values and custom text", async () => {
const originalFetch = globalThis.fetch;
const writes: { method: string; path: string; body: unknown }[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
const path = new URL(request.url).pathname;
if (request.method === "GET" && path.endsWith("/api/form")) return Response.json({ data: [form] });
writes.push({ method: request.method, path, body: request.body ? await request.json() : null });
return new Response(null, { status: 204 });
};
try {
const client = createClientV2("http://owner.test/opencode2", "/workspace", {});
expect((await client.question.reply({ requestID: form.id, answers: [["Summary"], ["Facts", "Custom section"]] })).data).toBe(true);
expect(writes).toEqual([{ method: "POST", path: "/opencode2/api/session/ses_side/form/frm_choice/reply", body: {
answer: { q0: "summary_value", q1: ["facts_value", "Custom section"] },
} }]);
expect((await client.question.reject({ requestID: form.id })).data).toBe(true);
expect(writes.at(-1)).toEqual({ method: "DELETE", path: "/opencode2/api/session/ses_side/form/frm_choice", body: null });
} finally { globalThis.fetch = originalFetch; }
});
test("failed list and reply requests remain failures and do not settle another question", async () => {
const originalFetch = globalThis.fetch;
const methods: string[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
methods.push(request.method);
return Response.json({ message: "Unavailable" }, { status: 503 });
};
try {
const client = createClientV2("http://owner.test/opencode2", "/workspace", {});
expect((await client.question.reply({ requestID: form.id, answers: [["Summary"]] })).response.status).toBe(503);
expect(methods).toEqual(["GET"]);
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
return request.method === "GET" ? Response.json({ data: [form] }) : Response.json({ message: "Try again" }, { status: 503 });
};
expect((await client.question.reply({ requestID: form.id, answers: [["Summary"]] })).response.status).toBe(503);
expect((await client.question.list()).data?.map((item) => item.id)).toEqual([form.id]);
} finally { globalThis.fetch = originalFetch; }
});
test("writes session context before prompting and fails closed if it cannot be written", async () => {
const originalFetch = globalThis.fetch;
const requests: { method: string; path: string; body: unknown }[] = [];
let status = 204;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
const path = new URL(request.url).pathname;
requests.push({ method: request.method, path, body: await request.json() });
return path.includes("/instructions/") && status !== 204
? Response.json({ message: "Unavailable" }, { status }) : new Response(null, { status: 204 });
};
try {
const client = createClientV2("http://owner.test/opencode2", "/workspace", {});
const parameters = { sessionID: "ses_side", model: { providerID: "mock", modelID: "model" },
system: "Main conversation reference: ses_main", parts: [{ type: "text", text: "What is happening?" }] };
expect((await client.session.promptAsync(parameters)).response.status).toBe(204);
expect(requests.map((item) => item.method)).toEqual(["POST", "PUT", "POST"]);
expect(requests[1]).toMatchObject({ path: "/opencode2/api/experimental/session/ses_side/instructions/entries/omnirush-context", body: { value: parameters.system } });
expect(requests[2]?.body).toEqual({ text: "What is happening?" });
requests.length = 0;
await client.session.promptAsync({ ...parameters, messageID: "msg_0123456789abUIdraft00000" });
expect(requests[2]?.body).toEqual({ text: "What is happening?", id: "msg_0123456789abUIdraft00000" });
requests.length = 0; status = 503;
expect((await client.session.promptAsync(parameters)).response.status).toBe(503);
expect(requests.map((item) => item.method)).toEqual(["POST", "PUT"]);
} finally { globalThis.fetch = originalFetch; }
});
});
describe("OpenCode 2.0.32 routes", () => {
// Shapes captured from a stock 2.0.32 `opencode serve`.
const session = {
id: "ses_main", projectID: "project", title: "Main", cost: 0, location: { directory: "/workspace" },
time: { created: 1, updated: 2 }, revert: { messageID: "msg_user", snapshot: "abc", files: [] },
};
async function withRoutes(
handle: (request: Request, path: string) => Response | Promise<Response>,
run: (client: ReturnType<typeof createClientV2>, calls: { method: string; path: string; body: unknown }[]) => Promise<void>,
) {
const originalFetch = globalThis.fetch;
const calls: { method: string; path: string; body: unknown }[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
const url = new URL(request.url);
const path = url.pathname.replace("/opencode2", "") + url.search;
calls.push({ method: request.method, path, body: request.body ? await request.clone().json() : null });
return handle(request, path);
};
try { await run(createClientV2("http://owner.test/opencode2", "/workspace", {}), calls); } finally { globalThis.fetch = originalFetch; }
}
test("health reads /api/info and rename patches the session then rereads it", async () => {
await withRoutes((request, path) => path === "/api/info"
? Response.json({ version: "2.0.32", pid: 1, urls: [], paths: { tmp: "/tmp" } })
: request.method === "PATCH" ? new Response(null, { status: 204 }) : Response.json({ data: { ...session, title: "Renamed" } }),
async (client, calls) => {
expect((await client.global.health()).data).toEqual({ healthy: true, version: "2.0.32" });
const renamed = await client.session.update({ sessionID: "ses_main", title: "Renamed" });
expect(renamed.data?.title).toBe("Renamed");
expect(renamed.data?.revert).toEqual({ messageID: "msg_user", snapshot: "abc" });
expect(calls.slice(1)).toEqual([
{ method: "PATCH", path: "/api/session/ses_main", body: { title: "Renamed" } },
{ method: "GET", path: "/api/session/ses_main", body: null },
]);
});
});
test("revert stages without committing, unrevert clears, and compact, shell and command use native routes", async () => {
await withRoutes((request, path) => {
if (path.endsWith("/revert/stage")) return Response.json({ data: session.revert });
if (path.endsWith("/compact")) return Response.json({ data: { id: "msg_compact", type: "compaction" } });
if (request.method === "GET") return Response.json({ data: session });
return new Response(null, { status: 204 });
}, async (client, calls) => {
expect((await client.session.revert({ sessionID: "ses_main", messageID: "msg_user", partID: "p" })).data?.revert?.messageID).toBe("msg_user");
expect((await client.session.unrevert({ sessionID: "ses_main" })).data?.id).toBe("ses_main");
expect((await client.session.summarize({ sessionID: "ses_main", providerID: "mock", modelID: "m1" })).data).toBe(true);
expect((await client.session.shell({ sessionID: "ses_main", command: "echo hi", agent: "build" })).error).toBeUndefined();
expect((await client.session.command({ sessionID: "ses_main", command: "init", arguments: "focus", model: "mock/m1" })).error).toBeUndefined();
expect(calls).toEqual([
{ method: "POST", path: "/api/session/ses_main/revert/stage", body: { messageID: "msg_user" } },
{ method: "GET", path: "/api/session/ses_main", body: null },
{ method: "DELETE", path: "/api/session/ses_main/revert", body: null },
{ method: "GET", path: "/api/session/ses_main", body: null },
{ method: "POST", path: "/api/session/ses_main/compact", body: {} },
{ method: "POST", path: "/api/session/ses_main/shell", body: { command: "echo hi" } },
{ method: "POST", path: "/api/session/ses_main/model", body: { model: { providerID: "mock", id: "m1" } } },
{ method: "POST", path: "/api/session/ses_main/command", body: { name: "init", text: "focus" } },
]);
});
});
test("a failed native op stays a failure", async () => {
await withRoutes(() => Response.json({ message: "busy" }, { status: 409 }), async (client, calls) => {
expect((await client.session.revert({ sessionID: "ses_main", messageID: "msg_user" })).response.status).toBe(409);
expect((await client.session.command({ sessionID: "ses_main", command: "init", model: "mock/m1" })).response.status).toBe(409);
expect(calls.map((call) => call.path)).toEqual(["/api/session/ses_main/revert/stage", "/api/session/ses_main/model"]);
});
});
test("history pages newest first through cursors and returns the latest messages oldest first", async () => {
const message = (n: number) => ({ id: `msg_${n}`, type: "user", text: `m${n}`, time: { created: n } });
await withRoutes((_request, path) => {
const cursor = new URL(`http://x${path}`).searchParams.get("cursor");
const start = cursor ? Number(cursor) : 250;
const limit = Number(new URL(`http://x${path}`).searchParams.get("limit"));
const data = Array.from({ length: Math.min(limit, start) }, (_, index) => start - index === 249
? { id: "msg_idle", type: "idle", outcome: "succeeded", time: { created: 249 } } : message(start - index));
return Response.json({ data, cursor: { next: String(start - data.length) } });
}, async (client, calls) => {
const all = await client.session.messages({ sessionID: "ses_main" });
expect(all.data?.map((item) => item.info.id).slice(0, 2)).toEqual(["msg_1", "msg_2"]);
expect(all.data).toHaveLength(249);
expect(calls.map((call) => call.path)).toEqual([
"/api/session/ses_main/message?limit=200&order=desc",
"/api/session/ses_main/message?limit=200&cursor=50",
]);
calls.length = 0;
const latest = await client.session.messages({ sessionID: "ses_main", limit: 3 });
expect(latest.data?.map((item) => item.info.id)).toEqual(["msg_247", "msg_248", "msg_250"]);
expect(calls.map((call) => call.path)).toEqual([
"/api/session/ses_main/message?limit=3&order=desc",
"/api/session/ses_main/message?limit=1&cursor=247",
]);
});
});
test("a user shell message renders as one bash card and its synthetic notice stays hidden", async () => {
await withRoutes(() => Response.json({ data: [
{ id: "msg_notice", type: "synthetic", text: "<shell id=\"sh_1\" state=\"completed\" command=\"echo hi\">\nhi\n</shell>",
metadata: { source: "shell", shellID: "sh_1" }, time: { created: 3 } },
{ id: "msg_shell", type: "shell", shellID: "sh_1", command: "echo hi", status: "exited", exit: 0,
output: { output: "hi\n", cursor: 3, size: 3, truncated: false }, time: { created: 2, completed: 3 } },
] }), async (client) => {
const result = await client.session.messages({ sessionID: "ses_main" });
expect(result.data).toHaveLength(1);
expect(result.data?.[0]?.info.role).toBe("assistant");
expect(result.data?.[0]?.parts).toMatchObject([{ type: "tool", tool: "bash", callID: "sh_1",
state: { status: "completed", input: { command: "echo hi" }, output: "hi\n" } }]);
});
});
test("revert events move the session cursor", () => {
const state = createV2EventTranslationState();
expect(translateV2Event({ type: "session.revert.staged", data: { sessionID: "ses_main", revert: session.revert } }, state))
.toEqual([{ type: "session.updated", properties: { info: { id: "ses_main", revert: { messageID: "msg_user" } } } }]);
for (const type of ["session.revert.cleared", "session.revert.committed"]) {
expect(translateV2Event({ type, data: { sessionID: "ses_main", to: "msg_user" } }, state))
.toEqual([{ type: "session.updated", properties: { info: { id: "ses_main" } } }]);
}
expect(translateV2Event({ type: "permission.replied", data: { sessionID: "ses_main", requestID: "per_1", decision: "always" } }, state))
.toEqual([{ type: "permission.replied", properties: { sessionID: "ses_main", requestID: "per_1", reply: "always" } }]);
});
test.each([
["read", { path: "a.py" }, "read", { filePath: "a.py", path: "a.py" }],
["write", { path: "b.txt", content: "x" }, "write", { filePath: "b.txt", path: "b.txt", content: "x" }],
["edit", { path: "a.py", oldString: "1", newString: "2" }, "edit", { filePath: "a.py", path: "a.py" }],
["skill", { id: "pdf" }, "skill", { name: "pdf", id: "pdf" }],
["patch", { patchText: "*** Begin Patch" }, "apply_patch", { patchText: "*** Begin Patch" }],
["websearch", { query: "news" }, "websearch", { query: "news" }],
])("native %s calls render with the card's field names", (name, input, tool, expected) => {
const state = createV2EventTranslationState();
const identity = { sessionID: "ses_main", assistantMessageID: "msg_a", id: "call_1" };
translateV2Event({ type: "session.tool.input.started", data: { ...identity, name } }, state);
expect(translateV2Event({ type: "session.tool.called", created: 1, data: { ...identity, input } }, state))
.toMatchObject([{ properties: { part: { tool, state: { status: "running", input: expected } } } }]);
expect(input).not.toHaveProperty("filePath");
});
});
test("MCP status from the 2.x engine reads as the 1.x status map", async () => {
const { v2McpStatusMap } = await import("../src/app/lib/opencode-v2-adapter");
expect(v2McpStatusMap({ data: [{ name: "memory", status: { status: "connected" } }, { name: "gh", status: { status: "failed", error: "boom" } }, { name: 3 }] }))
.toEqual({ memory: { status: "connected" }, gh: { status: "failed", error: "boom" } });
expect(v2McpStatusMap(null)).toEqual({});
});
describe("OpenCode 2.0.32 workspace reads", () => {
test("agents, commands, files, vcs, projects and diffs read native routes in the 1.x shapes", async () => {
const originalFetch = globalThis.fetch;
const paths: string[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
const url = new URL(request.url);
const path = url.pathname.replace("/opencode2", "") + url.search;
paths.push(`${request.method} ${path}`);
if (url.pathname.endsWith("/api/agent")) return Response.json({ data: [
{ id: "build", name: "Build", mode: "primary", hidden: false, permissions: [], request: {}, description: "Default", model: { id: "m1", providerID: "mock" } },
{ id: "compaction", name: "Compaction", mode: "primary", hidden: true, permissions: [], request: {} },
] });
if (url.pathname.endsWith("/api/command")) return Response.json({ data: [{ name: "init" }] });
if (url.pathname.endsWith("/api/fs/find")) return Response.json({ data: [{ path: "/", type: "directory" }, { path: "src/", type: "directory" }, { path: "src/a.ts", type: "file" }] });
if (url.pathname.endsWith("/api/vcs")) return Response.json({ data: { provider: "git", branch: { current: "feat", default: "main" } } });
if (url.pathname.endsWith("/api/vcs/diff")) return Response.json({ data: [{ file: "a.ts", patch: "p", additions: 1, deletions: 0, status: "modified" }] });
if (url.pathname.endsWith("/api/project")) return Response.json([{ id: "prj", canonical: "/workspace", time: { created: 1, updated: 1, active: 1 }, sandboxes: [] }]);
if (url.pathname.endsWith("/api/location")) return Response.json({ directory: "/workspace/sub", project: { id: "prj", directory: "/workspace", canonical: "/workspace" } });
if (url.pathname.endsWith("/diff")) return Response.json({ data: [{ file: "b.ts", patch: "q", additions: 0, deletions: 1, status: "deleted" }] });
throw new Error(`Unexpected request: ${request.method} ${path}`);
};
try {
const client = createClientV2("http://owner.test/opencode2", "/workspace", {});
expect((await client.app.agents()).data).toEqual([
{ name: "build", mode: "primary", hidden: false, permission: [], options: {}, description: "Default", model: { providerID: "mock", modelID: "m1" } },
{ name: "compaction", mode: "primary", hidden: true, permission: [], options: {} },
]);
expect((await client.command.list()).data).toEqual([{ name: "init", template: "", hints: [] }]);
expect((await client.find.files({ query: "a", dirs: "true", limit: 50 })).data).toEqual(["src/", "src/a.ts"]);
expect((await client.vcs.get()).data).toEqual({ branch: "feat", default_branch: "main" });
expect((await client.vcs.diff({ mode: "git" })).data).toMatchObject([{ file: "a.ts", status: "modified" }]);
expect((await client.project.list()).data).toMatchObject([{ id: "prj", worktree: "/workspace" }]);
expect((await client.project.current()).data).toMatchObject({ id: "prj", worktree: "/workspace" });
expect((await client.path.get()).data).toEqual({ home: "", state: "", config: "", worktree: "/workspace", directory: "/workspace/sub" });
expect((await client.session.diff({ sessionID: "ses_main", messageID: "msg_user" })).data).toMatchObject([{ file: "b.ts" }]);
expect((await client.lsp.status()).data).toEqual([]);
expect((await client.provider.auth()).data).toEqual({});
expect(paths).toEqual([
"GET /api/agent", "GET /api/command", "GET /api/fs/find?query=a&limit=50", "GET /api/vcs",
"GET /api/vcs/diff?mode=working", "GET /api/project", "GET /api/location", "GET /api/location",
"GET /api/session/ses_main/diff?from=msg_user",
]);
} finally { globalThis.fetch = originalFetch; }
});
test("1.x calls the adapter does not port fail locally and never reach the engine", async () => {
const originalFetch = globalThis.fetch;
let reached = 0;
globalThis.fetch = async () => { reached += 1; return new Response(null, { status: 204 }); };
try {
const client = createClientV2("http://owner.test/workspace/w/opencode2", "/workspace", {});
const update = await client.config.update({ config: {} });
expect(update.response?.status).toBe(501);
expect(update.error).toMatchObject({ name: "UnsupportedInV2", message: "Not available on the OpenCode 2.x engine: /config" });
expect((await client.mcp.connect({ name: "x" })).response?.status).toBe(501);
expect((await client.instance.dispose()).response?.status).toBe(501);
expect(reached).toBe(0);
} finally { globalThis.fetch = originalFetch; }
});
});
test("v2 models keep their efforts so the effort picker lists them", async () => {
const originalFetch = globalThis.fetch;
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/api/model")) return jsonResponse({ data: [
{ id: "gpt-6-astra", providerID: "omnirush", name: "GPT 6 Astra", capabilities: { tools: true, input: ["text"], output: ["text"] },
variants: [{ id: "low", settings: { reasoningEffort: "low" } }, { id: "max", settings: { reasoningEffort: "max" } }] },
{ id: "plain", providerID: "omnirush", name: "Plain" },
] });
if (request.url.endsWith("/api/provider")) return jsonResponse({ data: [{ id: "omnirush", name: "OmniRush" }] });
if (request.url.endsWith("/api/model/default")) return jsonResponse({ data: {} });
throw new Error(`Unexpected request: ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const models = (await client.provider.list()).data?.all[0]?.models ?? {};
expect(models["gpt-6-astra"]?.variants).toEqual({ low: { reasoningEffort: "low" }, max: { reasoningEffort: "max" } });
expect(models["gpt-6-astra"]?.capabilities.reasoning).toBe(true);
expect(models.plain?.variants).toBeUndefined();
expect(models.plain?.capabilities.reasoning).toBe(false);
} finally {
globalThis.fetch = originalFetch;
}
});
test("a send posts the picked effort with the session model", async () => {
const originalFetch = globalThis.fetch;
const bodies: unknown[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
if (request.url.endsWith("/model")) { bodies.push(await request.json()); return new Response(null, { status: 204 }); }
if (request.url.endsWith("/prompt")) return new Response(null, { status: 204 });
throw new Error(`Unexpected request: ${request.method} ${request.url}`);
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const model = { providerID: "omnirush", modelID: "gpt-6-astra" };
await client.session.promptAsync({ sessionID: "ses_e", model, variant: "max", parts: [{ type: "text", text: "a" }] });
await client.session.promptAsync({ sessionID: "ses_e", model, parts: [{ type: "text", text: "b" }] });
expect(bodies).toEqual([
{ model: { providerID: "omnirush", id: "gpt-6-astra", variant: "max" } },
{ model: { providerID: "omnirush", id: "gpt-6-astra" } },
]);
} finally {
globalThis.fetch = originalFetch;
}
});
test("stock mode sends no context of ours with a prompt", async () => {
const originalFetch = globalThis.fetch;
const globals = globalThis as { window?: unknown };
const originalWindow = globals.window;
const paths: string[] = [];
globalThis.fetch = async (input, init) => {
const request = input instanceof Request ? input : new Request(input, init);
paths.push(new URL(request.url).pathname);
return new Response(null, { status: 204 });
};
try {
const client = createClientV2("http://opencode.test/opencode2", "/workspace", {});
const send = () => client.session.promptAsync({ sessionID: "ses_s", model: { providerID: "omnirush", modelID: "gpt-6-astra" }, system: "Time zone: UTC", parts: [{ type: "text", text: "a" }] });
await send();
expect(paths.some((path) => path.includes("/instructions/entries/omnirush-context"))).toBe(true);
paths.length = 0;
globals.window = { __OMNIRUSH_ELECTRON__: { meta: { stockMode: true } } };
await send();
expect(paths).toEqual(["/opencode2/api/session/ses_s/model", "/opencode2/api/session/ses_s/prompt"]);
} finally {
globalThis.fetch = originalFetch;
globals.window = originalWindow;
}
});