mirror of
https://github.com/ranxianglei/billion-context.git
synced 2026-11-23 01:58:16 +08:00
(content clusters continued across delta turns) and give the lane what it was
designed to receive — the host's own session-scoped message ids.
What was wrong with the premise: opencode 2.x was assumed to expose no host
ids ("weakest of the four host seams"). It does: ctx.session.hook("context")
fires immediately before EVERY provider-request assembly carrying the full
{ id, role, content }[] conversation plus sessionID (verified live on
@opencode/cli 2.0.4, anthropic AND openai-compatible providers). V1 keeps
its experimental.chat.messages.transform seam as before; both now feed one
per-session store. With real ids riding, byte-identical repeated prompts get
distinct vouched ids (msg_r1 vs msg_r2), so the server-side pin creates one
row per occurrence and the collision class of #5741 disappears at the root.
Changes:
- opencode-v2.ts: register the "context" hook in createOpencodeV2Setup
(shared by V1+V2 hosts; try/catch — hosts without the seam keep the
documented id-less degrade; never fail startup over it)
- opencode-msgids.ts: deriveEntry now proves BOTH event shapes onto the wire
1:1 with semantic part tokens (text bytes; tool call/result anchored by
provider tool-use id, not input bytes; reasoning↔thinking; media↔image);
host role "tool" normalizes to wire "user"; bookkeeping parts skip; ANY
unrecognized shape still drops the whole field (宁可降级不可错位)
- tests/opencode-msgids.test.ts: tool-session end-to-end through the V2 seam,
the #5741 repeated-prompt scenario (distinct fresh ids per occurrence),
reasoning/thinking alignment, unknown-part and duplicate-id degrade paths
Server side needed NO changes: the claimed-set validation and pin remap
landed with #5742/#5743 already. continueContentClusters stays as the
fallback path for hosts/turns without a usable harvest.
Verified: tsc --noEmit clean; opencode-incremental/msgids/rolling-marks,
incremental-content-clusters, msgid-pin/algebra/lane-flow, dsh/pi-msgids,
incremental-lane, issue5403 fastpath, pins-wire-id-mints all green.
(cherry picked from commit 2fa9dc47cc)
439 lines
24 KiB
TypeScript
439 lines
24 KiB
TypeScript
// #4491 host wiring (opencode) — msgIds on incremental-lane turns.
|
|
//
|
|
// Stakes (all unit-level over the two seams the wiring owns, harness shaped
|
|
// like tests/opencode-incremental.test.ts):
|
|
// 1. ids flow end to end: the V1 `experimental.chat.messages.transform`
|
|
// harvest lands on the planned turn body aligned 1:1 with the wire
|
|
// messages — seed carries the full list, the post-ack delta carries
|
|
// only the delta's ids (sliced in lockstep with the messages);
|
|
// 2. all-or-nothing: one message without a usable id (or with a part that
|
|
// cannot be proven to lower 1:1) drops the whole msgIds field;
|
|
// 3. V2 shape — the dispatch fires with no V1 hook ever having run
|
|
// (http.request sees only the wire) → no msgIds field, degrade safe.
|
|
import { after, test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { createServer } from "node:http";
|
|
import type { AddressInfo } from "node:net";
|
|
|
|
process.env.NODE_TEST_CONTEXT = "1";
|
|
|
|
const { maybeIncrementalOpencode, opencodeIncrementalOnResponse, __resetOpencodeIncrementalForTests, createV1ServerHooks } = await import("../src/agent/opencode-native.ts");
|
|
const { __resetIncrementalClientForTests } = await import("../src/agent/incremental-client.ts");
|
|
const { __resetOpencodeMsgIdsForTests, harvestOpencodeMsgIds, deriveOpencodeEntry } = await import("../src/agent/opencode-msgids.ts");
|
|
import type { V2HttpRequestEvent, V2State } from "../src/agent/opencode-v2.ts";
|
|
|
|
const MODEL_URL = "https://api.anthropic.com/v1/messages";
|
|
|
|
async function fakeLane(): Promise<{ base: string; close: () => Promise<void> }> {
|
|
const srv = createServer((req, res) => {
|
|
if (req.method === "GET" && req.url === "/__bili/plugin/turn") {
|
|
res.writeHead(200, { "content-type": "application/json" });
|
|
res.end(JSON.stringify({ ok: true, protocol: 1, feature: "pluginIncrementalTurns", enabled: true, storage: "unified" }));
|
|
return;
|
|
}
|
|
res.writeHead(404); res.end("{}");
|
|
});
|
|
await new Promise<void>((r) => srv.listen(0, "127.0.0.1", r));
|
|
const { port } = srv.address() as AddressInfo;
|
|
return { base: `http://127.0.0.1:${port}`, close: () => new Promise<void>((r) => srv.close(() => r())) };
|
|
}
|
|
|
|
function fakeEvent(body: unknown, sid: string): { e: V2HttpRequestEvent; url: string } {
|
|
const req = new Request(MODEL_URL, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json", authorization: "Bearer sk-test" },
|
|
body: JSON.stringify(body),
|
|
});
|
|
const e = { request: req, sessionID: sid } as unknown as V2HttpRequestEvent;
|
|
return { e, url: req.url };
|
|
}
|
|
|
|
function state(base: string): V2State {
|
|
return { proxyBase: base } as unknown as V2State;
|
|
}
|
|
|
|
/** The outgoing headers of a swapped Request, normalized exactly like
|
|
* native-intercept's outgoingHeadersOf does for a Request-object input. */
|
|
function headersOf(req: Request): Record<string, string> {
|
|
const out: Record<string, string> = {};
|
|
for (const [k, v] of req.headers) out[k.toLowerCase()] = v;
|
|
return out;
|
|
}
|
|
|
|
async function plannedBody(e: V2HttpRequestEvent): Promise<Record<string, unknown>> {
|
|
return JSON.parse(await (e.request as Request).clone().json().then((j) => JSON.stringify(j))) as Record<string, unknown>;
|
|
}
|
|
|
|
/** opencode 1.x messages.transform fire: host messages {info, parts}. */
|
|
function hostMessage(id: string, role: "user" | "assistant", text: string, sid: string): { info: { id: string; role: string; sessionID: string }; parts: unknown[] } {
|
|
return { info: { id, role, sessionID: sid }, parts: [{ type: "text", text }] };
|
|
}
|
|
|
|
const wmsg = (role: string, text: string) => ({ role, content: [{ type: "text", text }] });
|
|
|
|
const lanes: { close: () => Promise<void> }[] = [];
|
|
after(async () => {
|
|
for (const l of lanes) await l.close();
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
});
|
|
|
|
test("opencode msgids: V1 harvest rides the turn body 1:1 — seed full, delta sliced", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const hooks = createV1ServerHooks(() => lane.base, {}, {});
|
|
|
|
const sid = "ses_msgid_1";
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [hostMessage("msg_u1", "user", "hello", sid)] });
|
|
const t1 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: [wmsg("user", "hello")] }, sid);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
const body1 = await plannedBody(t1.e);
|
|
assert.equal((body1.messages as unknown[]).length, 1, "seed swap happened");
|
|
assert.deepEqual(body1.msgIds, ["msg_u1"], "seed carries the harvested id aligned 1:1 with the wire message");
|
|
assert.equal((t1.e.request as Request).headers.get("x-bili-plugin-turn"), "1", "marker still stamped");
|
|
|
|
opencodeIncrementalOnResponse(t1.url, new Response("{}", { status: 200, headers: { "x-bili-applied-seq": "1" } }), headersOf(t1.e.request as Request));
|
|
|
|
// next turn: the host re-fires the transform with the settled history —
|
|
// the streaming-settled assistant arrives under its own id
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [
|
|
hostMessage("msg_u1", "user", "hello", sid),
|
|
hostMessage("msg_a1", "assistant", "hi there", sid),
|
|
hostMessage("msg_u2", "user", "next", sid),
|
|
] });
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: [wmsg("user", "hello"), wmsg("assistant", "hi there"), wmsg("user", "next")] }, sid);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.equal((body2.messages as unknown[]).length, 2, "delta turn rides only the suffix");
|
|
assert.deepEqual(body2.msgIds, ["msg_a1", "msg_u2"], "delta msgIds sliced in lockstep with the delta messages");
|
|
});
|
|
|
|
test("opencode msgids: one unusable message drops the whole field (all-or-nothing)", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const hooks = createV1ServerHooks(() => lane.base, {}, {});
|
|
const sid = "ses_msgid_2";
|
|
|
|
// a message without a host id → no msgIds at all (never mis-align)
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [
|
|
hostMessage("msg_u1", "user", "hello", sid),
|
|
{ info: { role: "assistant", sessionID: sid }, parts: [{ type: "text", text: "hi" }] },
|
|
hostMessage("msg_u2", "user", "next", sid),
|
|
] });
|
|
const t1 = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [wmsg("user", "hello"), wmsg("assistant", "hi"), wmsg("user", "next")] }, sid);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
const body1 = await plannedBody(t1.e);
|
|
assert.equal((body1.messages as unknown[]).length, 3, "seed swap happened");
|
|
assert.equal("msgIds" in body1, false, "a missing id drops the field for the whole turn");
|
|
|
|
// a tool-bearing part cannot be proven to lower 1:1 → same degradation
|
|
const sid2 = "ses_msgid_2b";
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [
|
|
hostMessage("msg_t1", "assistant", "calling", sid2),
|
|
{ info: { id: "msg_t2", role: "assistant", sessionID: sid2 }, parts: [{ type: "tool", tool: "bash", state: {} }] },
|
|
] });
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [wmsg("assistant", "calling"), { role: "user", content: [{ type: "tool_result", tool_use_id: "t", content: "out" }] }] }, sid2);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.equal("msgIds" in body2, false, "non-text parts degrade the turn to content-derived identities");
|
|
});
|
|
|
|
test("opencode msgids: V2 shape (no V1 hook fired) carries no msgIds — degrade safe", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const sid = "ses_msgid_3";
|
|
|
|
// http.request sees only the wire: no harvest exists for this session
|
|
const msgs1 = [{ role: "user", content: "hello opencode" }];
|
|
const t1 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: msgs1 }, sid);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
const body1 = await plannedBody(t1.e);
|
|
assert.equal((body1.messages as unknown[]).length, 1, "seed swap happened");
|
|
assert.equal("msgIds" in body1, false, "V2-shaped seed carries no msgIds");
|
|
|
|
opencodeIncrementalOnResponse(t1.url, new Response("{}", { status: 200, headers: { "x-bili-applied-seq": "1" } }), headersOf(t1.e.request as Request));
|
|
|
|
const msgs2 = [...msgs1, { role: "assistant", content: "hi" }, { role: "user", content: "next" }];
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: msgs2 }, sid);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.equal((body2.messages as unknown[]).length, 2, "delta planned");
|
|
assert.equal("msgIds" in body2, false, "V2-shaped delta carries no msgIds either");
|
|
});
|
|
|
|
test("opencode msgids: content drift between harvest and wire degrades instead of mis-aligning", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const hooks = createV1ServerHooks(() => lane.base, {}, {});
|
|
const sid = "ses_msgid_4";
|
|
|
|
// the wire text differs from the harvested parts → ids would mis-align
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [hostMessage("msg_u1", "user", "hello", sid)] });
|
|
const t1 = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [wmsg("user", "hello EDITED")] }, sid);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
const body1 = await plannedBody(t1.e);
|
|
assert.equal((body1.messages as unknown[]).length, 1, "seed swap happened");
|
|
assert.equal("msgIds" in body1, false, "drifted content never inherits an id it cannot prove");
|
|
opencodeIncrementalOnResponse(t1.url, new Response("{}", { status: 200, headers: { "x-bili-applied-seq": "1" } }), headersOf(t1.e.request as Request));
|
|
|
|
// cache_control on the wire is transport-only — alignment must survive it
|
|
const sid2 = "ses_msgid_4b";
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [hostMessage("msg_c1", "user", "cached", sid2)] });
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [{ role: "user", content: [{ type: "text", text: "cached", cache_control: { type: "ephemeral" } }] }] }, sid2);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.deepEqual(body2.msgIds, ["msg_c1"], "cache_control markers do not break the 1:1 proof");
|
|
});
|
|
|
|
test("opencode msgids: a single-flight-blocked turn does not burn its ids (#4491/#3378)", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const hooks = createV1ServerHooks(() => lane.base, {}, {});
|
|
|
|
const sid = "ses_guard_burn";
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [hostMessage("msg_u1", "user", "hello", sid)] });
|
|
const t1 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: [wmsg("user", "hello")] }, sid);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
assert.equal((t1.e.request as Request).headers.get("x-bili-plugin-turn"), "1", "seed converted, left UN-acked");
|
|
|
|
// While the seed is still pending, the next turn hits the single-flight
|
|
// guard: the request must ride the normal pipeline untouched — and the
|
|
// blocked attempt must NOT claim this turn's ids.
|
|
await hooks["experimental.chat.messages.transform"]?.({}, { messages: [
|
|
hostMessage("msg_u1", "user", "hello", sid),
|
|
hostMessage("msg_a1", "assistant", "hi there", sid),
|
|
hostMessage("msg_u2", "user", "next", sid),
|
|
] });
|
|
const wire2 = { model: "claude-test", max_tokens: 512, system: "be terse", messages: [wmsg("user", "hello"), wmsg("assistant", "hi there"), wmsg("user", "next")] };
|
|
const t2b = fakeEvent(wire2, sid);
|
|
await maybeIncrementalOpencode(t2b.e, s);
|
|
assert.equal((t2b.e.request as Request).headers.get("x-bili-plugin-turn"), null, "guard: blocked attempt rides the normal pipeline");
|
|
assert.deepEqual(await plannedBody(t2b.e), JSON.parse(JSON.stringify(wire2)), "body untouched by the blocked attempt");
|
|
|
|
// The seed acks; the host retries the same turn — the delta ids must
|
|
// still ride (a burned claim would silently drop the whole field).
|
|
opencodeIncrementalOnResponse(t1.url, new Response("{}", { status: 200, headers: { "x-bili-applied-seq": "1" } }), headersOf(t1.e.request as Request));
|
|
const t2 = fakeEvent(wire2, sid);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.deepEqual(body2.msgIds, ["msg_a1", "msg_u2"], "blocked attempt did not burn the delta ids");
|
|
});
|
|
|
|
// ── #5743 redo: REAL host ids from both seams (V2 "context" event shapes,
|
|
// tool sessions, the #5741 repeated-prompt scenario). The host message
|
|
// shapes below mirror live 2.0.4 captures (anthropic provider): role
|
|
// user/assistant/tool, content parts text / tool-call / tool-result.
|
|
|
|
function ctxMessage(id: string, role: string, content: unknown[]): { id: string; role: string; content: unknown[] } {
|
|
return { id, role, content };
|
|
}
|
|
|
|
/** Simulate one `ctx.session.hook("context")` fire (V2 seam). */
|
|
function fireContext(sid: string, messages: unknown[]): void {
|
|
harvestOpencodeMsgIds(sid, messages);
|
|
}
|
|
|
|
test("opencode msgids: V2 context seam carries real ids through a TOOL session", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const sid = "ses_v2ctx_1";
|
|
|
|
// Turn 1: user asks, assistant calls read(), the result comes back as a
|
|
// host role-"tool" message carrying an ERROR result.
|
|
fireContext(sid, [
|
|
ctxMessage("msg_vu1", "user", [{ type: "text", text: "read README.md" }]),
|
|
]);
|
|
const t1 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: [
|
|
{ role: "user", content: [{ type: "text", text: "read README.md" }] },
|
|
{ role: "assistant", content: [
|
|
{ type: "text", text: "Reading." },
|
|
{ type: "tool_use", id: "toolu_1", name: "read", input: { path: "README.md" }, cache_control: { type: "ephemeral" } },
|
|
] },
|
|
{ role: "user", content: [
|
|
{ type: "tool_result", tool_use_id: "toolu_1", content: "{\"error\":{}}", is_error: true, cache_control: { type: "ephemeral" } },
|
|
] },
|
|
] }, sid);
|
|
// NOTE: fired BEFORE the request assembled — order inside the handler:
|
|
// context first, http.request after; the seed below replans against this
|
|
// latest fire exactly like the live hook does.
|
|
fireContext(sid, [
|
|
ctxMessage("msg_vu1", "user", [{ type: "text", text: "read README.md" }]),
|
|
ctxMessage("msg_va1", "assistant", [
|
|
{ type: "text", text: "Reading." },
|
|
{ type: "tool-call", id: "toolu_1", name: "read", input: { path: "README.md" }, providerExecuted: false },
|
|
]),
|
|
ctxMessage("msg_vt1", "tool", [
|
|
{ type: "tool-result", id: "toolu_1", name: "read", result: { type: "error", value: { error: {} } }, providerExecuted: false },
|
|
]),
|
|
]);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
const body1 = await plannedBody(t1.e);
|
|
assert.deepEqual(body1.msgIds, ["msg_vu1", "msg_va1", "msg_vt1"],
|
|
"seed rides REAL host ids — text, tool-call (assistant), tool-result (host role \"tool\" normalized to wire \"user\"); error flag matched via is_error");
|
|
|
|
opencodeIncrementalOnResponse(t1.url, new Response("{}", { status: 200, headers: { "x-bili-applied-seq": "1" } }), headersOf(t1.e.request as Request));
|
|
|
|
// Turn 2: assistant settles on text; the delta must carry exactly its
|
|
// own fresh id, sliced in lockstep with the suffix messages.
|
|
fireContext(sid, [
|
|
ctxMessage("msg_vu1", "user", [{ type: "text", text: "read README.md" }]),
|
|
ctxMessage("msg_va1", "assistant", [
|
|
{ type: "text", text: "Reading." },
|
|
{ type: "tool-call", id: "toolu_1", name: "read", input: { path: "README.md" }, providerExecuted: false },
|
|
]),
|
|
ctxMessage("msg_vt1", "tool", [
|
|
{ type: "tool-result", id: "toolu_1", name: "read", result: { type: "error", value: { error: {} } }, providerExecuted: false },
|
|
]),
|
|
ctxMessage("msg_va2", "assistant", [{ type: "text", text: "It failed: missing file." }]),
|
|
ctxMessage("msg_vu2", "user", [{ type: "text", text: "ok thanks" }]),
|
|
]);
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "be terse", messages: [
|
|
{ role: "user", content: [{ type: "text", text: "read README.md" }] },
|
|
{ role: "assistant", content: [
|
|
{ type: "text", text: "Reading." },
|
|
{ type: "tool_use", id: "toolu_1", name: "read", input: { path: "README.md" }, cache_control: { type: "ephemeral" } },
|
|
] },
|
|
{ role: "user", content: [
|
|
{ type: "tool_result", tool_use_id: "toolu_1", content: "{\"error\":{}}", is_error: true, cache_control: { type: "ephemeral" } },
|
|
] },
|
|
{ role: "assistant", content: [{ type: "text", text: "It failed: missing file." }] },
|
|
{ role: "user", content: [{ type: "text", text: "ok thanks" }] },
|
|
] }, sid);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.equal((body2.messages as unknown[]).length, 2, "delta rides only the suffix");
|
|
assert.deepEqual(body2.msgIds, ["msg_va2", "msg_vu2"], "delta rides ONLY the fresh host ids");
|
|
});
|
|
|
|
test("opencode msgids: #5741 repeated-prompt turns get DISTINCT real ids", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
const sid = "ses_repeat_1";
|
|
|
|
// Turn 1: prompt "go" → ids r1/a1.
|
|
fireContext(sid, [ctxMessage("msg_r1", "user", [{ type: "text", text: "go" }])]);
|
|
const w1 = { model: "claude-test", max_tokens: 512, system: "s", messages: [{ role: "user", content: [{ type: "text", text: "go" }] }] };
|
|
const t1 = fakeEvent(w1, sid);
|
|
await maybeIncrementalOpencode(t1.e, s);
|
|
assert.deepEqual((await plannedBody(t1.e)).msgIds, ["msg_r1"]);
|
|
opencodeIncrementalOnResponse(t1.url, new Response("{}", { status: 200, headers: { "x-bili-applied-seq": "1" } }), headersOf(t1.e.request as Request));
|
|
|
|
// Turn 2: the BYTE-IDENTICAL prompt resends — opencode mints a FRESH id
|
|
// for it. With derived content hashes both occurrences would collide;
|
|
// the client must vouch the SECOND id so the lane pins a second row.
|
|
fireContext(sid, [
|
|
ctxMessage("msg_r1", "user", [{ type: "text", text: "go" }]),
|
|
ctxMessage("msg_a1", "assistant", [{ type: "text", text: "done" }]),
|
|
ctxMessage("msg_r2", "user", [{ type: "text", text: "go" }]),
|
|
]);
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, system: "s", messages: [
|
|
{ role: "user", content: [{ type: "text", text: "go" }] },
|
|
{ role: "assistant", content: [{ type: "text", text: "done" }] },
|
|
{ role: "user", content: [{ type: "text", text: "go" }] },
|
|
] }, sid);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
const body2 = await plannedBody(t2.e);
|
|
assert.equal((body2.messages as unknown[]).length, 2,
|
|
"delta covers the acked prompt's reply plus the repeated prompt itself");
|
|
assert.deepEqual(body2.msgIds, ["msg_a1", "msg_r2"],
|
|
"the repeated prompt vouches its OWN fresh id (msg_r2) — never collides with the pinned msg_r1 row");
|
|
});
|
|
|
|
test("opencode msgids: reasoning↔thinking aligns; noise parts skip; unknown parts degrade", async () => {
|
|
__resetIncrementalClientForTests();
|
|
__resetOpencodeIncrementalForTests();
|
|
__resetOpencodeMsgIdsForTests();
|
|
const lane = await fakeLane();
|
|
lanes.push(lane);
|
|
const s = state(lane.base);
|
|
|
|
// reasoning part ↔ thinking block; v1 bookkeeping parts carry no wire block
|
|
const sid = "ses_think_1";
|
|
fireContext(sid, [
|
|
ctxMessage("msg_h1", "assistant", [
|
|
{ type: "reasoning", text: "hmm…" },
|
|
{ type: "text", text: "answer" },
|
|
]),
|
|
]);
|
|
let t = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [
|
|
{ role: "assistant", content: [
|
|
{ type: "thinking", thinking: "hmm…", signature: "sig" },
|
|
{ type: "text", text: "answer" },
|
|
] },
|
|
] }, sid);
|
|
await maybeIncrementalOpencode(t.e, s);
|
|
assert.deepEqual((await plannedBody(t.e)).msgIds, ["msg_h1"], "reasoning part proves onto the thinking block positionally");
|
|
|
|
// an UNRECOGNIZED part type must drop the field (never guess)
|
|
const sid2 = "ses_unknown_1";
|
|
fireContext(sid2, [
|
|
ctxMessage("msg_k1", "user", [{ type: "source-url", url: "https://example.com" }]),
|
|
]);
|
|
const t2 = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [
|
|
{ role: "user", content: [{ type: "text", text: "whatever" }] },
|
|
] }, sid2);
|
|
await maybeIncrementalOpencode(t2.e, s);
|
|
assert.equal("msgIds" in (await plannedBody(t2.e)), false, "unknown part types degrade to content-derived identities");
|
|
|
|
// duplicate ids drop the whole field even when every position otherwise aligns
|
|
const sid3 = "ses_dup_1";
|
|
fireContext(sid3, [
|
|
ctxMessage("msg_d1", "user", [{ type: "text", text: "a" }]),
|
|
ctxMessage("msg_d1", "assistant", [{ type: "text", text: "b" }]),
|
|
]);
|
|
const t3 = fakeEvent({ model: "claude-test", max_tokens: 512, messages: [
|
|
{ role: "user", content: [{ type: "text", text: "a" }] },
|
|
{ role: "assistant", content: [{ type: "text", text: "b" }] },
|
|
] }, sid3);
|
|
await maybeIncrementalOpencode(t3.e, s);
|
|
assert.equal("msgIds" in (await plannedBody(t3.e)), false, "duplicate ids can never ride");
|
|
});
|
|
|
|
test("opencode msgids: deriveOpencodeEntry unit-level normalization", () => {
|
|
const e1 = deriveOpencodeEntry(ctxMessage("msg_x1", "tool", [
|
|
{ type: "tool-result", id: "toolu_9", name: "bash", result: { type: "error", value: "boom" }, providerExecuted: false },
|
|
]));
|
|
assert.equal(e1.shape?.role, "user", "host role \"tool\" normalizes to wire \"user\"");
|
|
assert.deepEqual(e1.shape?.toks, [`r\u0000toolu_9\u00001`], "tool-result anchored by id + error flag");
|
|
|
|
const e2 = deriveOpencodeEntry({ info: { id: "msg_y1", role: "assistant", sessionID: "s" }, parts: [
|
|
{ type: "step-start" },
|
|
{ type: "text", text: "hi" },
|
|
{ type: "tool", tool: "bash", callID: "call_7", state: { status: "running" } },
|
|
{ type: "snapshot", snapshot: "abc" },
|
|
] });
|
|
assert.deepEqual(e2.shape?.toks, [`t\u0000hi`, `c\u0000call_7\u0000bash`], "v1 bookkeeping parts (step-start/snapshot) skip; tool part anchors by callID+name");
|
|
|
|
assert.equal(deriveOpencodeEntry({ info: { role: "system" }, parts: [] }).shape, null, "non-conversation roles poison the entry only");
|
|
assert.equal(deriveOpencodeEntry({ id: "not-a-host-id", role: "user", content: [] }).id, "", "foreign-shaped ids stay unusable");
|
|
});
|