Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

fix(coding-agent): retain session identity for maintenance calls (#2266)

kt66658d2cf731
diff --git a/packages/coding-agent/.changes/eng-6009-opencode-maintenance-session.md b/packages/coding-agent/.changes/eng-6009-opencode-maintenance-session.md
new file mode 100644
index 0000000000..f0e073b2ea
--- /dev/null
+++ b/packages/coding-agent/.changes/eng-6009-opencode-maintenance-session.md
@@ -0,0 +1 @@
+- Fixed OpenCode compaction, refinement, and branch summaries failing because requests omitted the conversation identity.
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index 27badbd75b..f66e86db7a 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -7916,6 +7916,7 @@ export class AgentSession {
this.thinkingLevel,
summaryCall,
providerRetryPolicy(this.settingsManager),
+ this.sessionId,
));
}
@@ -8438,6 +8439,7 @@ export class AgentSession {
signal,
this.thinkingLevel,
providerRetryPolicy(this.settingsManager),
+ this.sessionId,
);
}
@@ -8740,6 +8742,7 @@ export class AgentSession {
headers,
signal,
this.thinkingLevel,
+ this.sessionId,
);
if (this._disposed || signal.aborted) {
throw new Error("Refinement cancelled because the session was disposed.");
@@ -12262,6 +12265,7 @@ export class AgentSession {
apiKey,
headers,
signal: this._branchSummaryAbortController.signal,
+ sessionId: this.sessionId,
customInstructions,
replaceInstructions,
reserveTokens: branchSummarySettings.reserveTokens,
diff --git a/packages/coding-agent/src/core/compaction/branch-summarization.ts b/packages/coding-agent/src/core/compaction/branch-summarization.ts
index 4088a9a4c2..af8ee00615 100644
--- a/packages/coding-agent/src/core/compaction/branch-summarization.ts
+++ b/packages/coding-agent/src/core/compaction/branch-summarization.ts
@@ -67,6 +67,8 @@ export interface GenerateBranchSummaryOptions {
apiKey: string;
/** Request headers for the model */
headers?: Record<string, string>;
+ /** Owning conversation identity for provider routing and caching. */
+ sessionId?: string;
/** Abort signal for cancellation */
signal: AbortSignal;
/** Optional custom instructions for summarization */
@@ -259,6 +261,7 @@ export async function generateBranchSummary(
model,
apiKey,
headers,
+ sessionId,
signal,
customInstructions,
replaceInstructions,
@@ -299,7 +302,7 @@ export async function generateBranchSummary(
completeSimple(
model,
{ systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages },
- { apiKey, headers, signal, maxTokens: 2048 },
+ { apiKey, headers, sessionId, signal, maxTokens: 2048 },
),
{ policy: retry, signal },
);
diff --git a/packages/coding-agent/src/core/compaction/compaction.ts b/packages/coding-agent/src/core/compaction/compaction.ts
index 1dd8bd0f3c..c3a0acafed 100644
--- a/packages/coding-agent/src/core/compaction/compaction.ts
+++ b/packages/coding-agent/src/core/compaction/compaction.ts
@@ -532,6 +532,7 @@ export async function generateSummary(
previousSummary?: string,
thinkingLevel?: ThinkingLevel,
retry?: ProviderRetryPolicy,
+ sessionId?: string,
): Promise<SummarySlice> {
const maxTokens = Math.floor(0.8 * reserveTokens);
@@ -555,8 +556,8 @@ export async function generateSummary(
const completionOptions =
model.reasoning && thinkingLevel && thinkingLevel !== "off"
- ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
- : { maxTokens, signal, apiKey, headers };
+ ? { maxTokens, signal, apiKey, headers, sessionId, reasoning: thinkingLevel }
+ : { maxTokens, signal, apiKey, headers, sessionId };
const response = await completeWithProviderRetry(
() =>
@@ -706,6 +707,7 @@ export async function compact(
thinkingLevel?: ThinkingLevel,
summaryCall: SummaryCallRunner = (call) => call(headers),
retry?: ProviderRetryPolicy,
+ sessionId?: string,
): Promise<CompactionResult> {
const {
firstKeptEntryId,
@@ -736,6 +738,7 @@ export async function compact(
previousSummary,
thinkingLevel,
retry,
+ sessionId,
),
)
: Promise.resolve<SummarySlice>({ summary: "No prior history." }),
@@ -749,6 +752,7 @@ export async function compact(
signal,
thinkingLevel,
retry,
+ sessionId,
),
),
]);
@@ -767,6 +771,7 @@ export async function compact(
previousSummary,
thinkingLevel,
retry,
+ sessionId,
),
);
slices.push(result);
@@ -806,6 +811,7 @@ async function generateTurnPrefixSummary(
signal?: AbortSignal,
thinkingLevel?: ThinkingLevel,
retry?: ProviderRetryPolicy,
+ sessionId?: string,
): Promise<SummarySlice> {
const maxTokens = Math.floor(0.5 * reserveTokens); // Smaller budget for turn prefix
const llmMessages = convertToLlm(messages);
@@ -825,8 +831,8 @@ async function generateTurnPrefixSummary(
model,
{ systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages },
model.reasoning && thinkingLevel && thinkingLevel !== "off"
- ? { maxTokens, signal, apiKey, headers, reasoning: thinkingLevel }
- : { maxTokens, signal, apiKey, headers },
+ ? { maxTokens, signal, apiKey, headers, sessionId, reasoning: thinkingLevel }
+ : { maxTokens, signal, apiKey, headers, sessionId },
),
{ policy: retry, signal },
);
diff --git a/packages/coding-agent/src/core/refinement/refinement.ts b/packages/coding-agent/src/core/refinement/refinement.ts
index 1322952cf1..5b1cb44205 100644
--- a/packages/coding-agent/src/core/refinement/refinement.ts
+++ b/packages/coding-agent/src/core/refinement/refinement.ts
@@ -926,6 +926,7 @@ export async function planRefinement(
headers?: Record<string, string>,
signal?: AbortSignal,
thinkingLevel?: ThinkingLevel,
+ sessionId?: string,
): Promise<RefinementPlan> {
const id = generateRefinementId();
if (options.rollbackId) {
@@ -982,6 +983,7 @@ export async function planRefinement(
signal,
apiKey,
headers,
+ sessionId,
},
),
{ policy: options.retry, signal },
@@ -1025,6 +1027,7 @@ export async function reviewAutoRefine(
signal?: AbortSignal,
thinkingLevel?: ThinkingLevel,
retry?: ProviderRetryPolicy,
+ sessionId?: string,
): Promise<AutoRefineReview> {
const conversationText = serializeConversation(convertToLlm(messages)).slice(-40_000);
const buildPrompt = (conversation: string): string =>
@@ -1069,6 +1072,7 @@ ${conversation}
signal,
apiKey,
headers,
+ sessionId,
},
),
{ policy: retry, signal },
@@ -1096,8 +1100,20 @@ export async function refineHarness(
headers?: Record<string, string>,
signal?: AbortSignal,
thinkingLevel?: ThinkingLevel,
+ sessionId?: string,
): Promise<RefinementResult> {
- const plan = await planRefinement(messages, state, history, model, apiKey, options, headers, signal, thinkingLevel);
+ const plan = await planRefinement(
+ messages,
+ state,
+ history,
+ model,
+ apiKey,
+ options,
+ headers,
+ signal,
+ thinkingLevel,
+ sessionId,
+ );
return applyRefinementProposal(state, plan.proposal, {
id: plan.id,
rollbackOf: plan.rollbackOf,
diff --git a/packages/coding-agent/test/suite/regressions/6009-opencode-maintenance-session.test.ts b/packages/coding-agent/test/suite/regressions/6009-opencode-maintenance-session.test.ts
new file mode 100644
index 0000000000..b7ec64f6dd
--- /dev/null
+++ b/packages/coding-agent/test/suite/regressions/6009-opencode-maintenance-session.test.ts
@@ -0,0 +1,262 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { createServer, type IncomingHttpHeaders, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { completeSimple, type FauxResponseFactory } from "@earendil-works/pi-ai";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ENV_AGENT_DIR } from "../../../src/config.js";
+import { type AutoRefineReview, type HarnessState, refineHarness } from "../../../src/core/refinement/refinement.js";
+import { createHarness, type Harness } from "../harness.js";
+
+const proposal = { summary: "No change", rationale: "Fixture", expectedOutcome: "No change", edits: [] };
+const missingSession =
+ "Error from provider (Console Go): Request is missing x-opencode-session and cannot be routed efficiently.";
+let server: Server;
+let baseUrl: string;
+let agentDir: string;
+let responseText: string;
+let transientFailures: number;
+let operation: string;
+let requests: { operation: string; headers: IncomingHttpHeaders; body: Record<string, unknown> }[];
+const harnesses: Harness[] = [];
+
+beforeEach(async () => {
+ agentDir = mkdtempSync(join(tmpdir(), "6009-agent-"));
+ vi.stubEnv(ENV_AGENT_DIR, agentDir);
+ requests = [];
+ responseText = "OK";
+ transientFailures = 0;
+ operation = "ordinary";
+ server = createServer(async (req, res) => {
+ let raw = "";
+ for await (const chunk of req) raw += chunk.toString();
+ const body = JSON.parse(raw) as Record<string, unknown>;
+ requests.push({ operation, headers: req.headers, body });
+ if (!req.headers["x-opencode-session"]) {
+ res.writeHead(400, { "content-type": "application/json" });
+ res.end(JSON.stringify({ error: { message: missingSession, type: "invalid_request_error" } }));
+ return;
+ }
+ if (transientFailures > 0) {
+ transientFailures--;
+ res.writeHead(503, { "content-type": "application/json" });
+ res.end(JSON.stringify({ error: { message: "Temporarily unavailable" } }));
+ return;
+ }
+ res.writeHead(200, { "content-type": "text/event-stream" });
+ res.write(
+ `data: ${JSON.stringify({ id: "fixture", choices: [{ index: 0, delta: { role: "assistant", content: responseText }, finish_reason: "stop" }] })}\n\n`,
+ );
+ res.end("data: [DONE]\n\n");
+ });
+ await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+ baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}/v1`;
+});
+
+afterEach(async () => {
+ while (harnesses.length) harnesses.pop()!.cleanup();
+ server.closeAllConnections();
+ await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+ vi.unstubAllEnvs();
+ rmSync(agentDir, { recursive: true, force: true });
+});
+
+async function setup(provider: string, existingSessionFile?: string, reasoning = false) {
+ const harness = await createHarness({
+ provider,
+ models: [{ id: "routing-fixture", reasoning }],
+ persistSession: true,
+ existingSessionFile,
+ settings: {
+ compaction: { enabled: false, keepRecentTokens: 1 },
+ autoRefine: { enabled: false },
+ retry: { enabled: true, maxRetries: 1, baseDelayMs: 1 },
+ },
+ });
+ harnesses.push(harness);
+ // Match createAgentSession: the low-level suite harness does not bind the Agent's ID.
+ harness.session.agent.sessionId = harness.sessionManager.getSessionId();
+ // Keep the faux provider as the suite boundary, but serialize its actual options
+ // through the real OpenAI-compatible adapter to an entirely local faux endpoint.
+ const forward: FauxResponseFactory = (context, options, _state, model) =>
+ completeSimple({ ...model, api: "openai-completions", baseUrl }, context, {
+ ...options,
+ apiKey: "fixture-not-a-real-key",
+ signal: AbortSignal.any([...(options?.signal ? [options.signal] : []), AbortSignal.timeout(5000)]),
+ });
+ harness.setResponses(Array.from({ length: 20 }, () => forward));
+ return harness;
+}
+
+async function ordinary(harness: Harness, text = "remember this request") {
+ operation = "ordinary";
+ await harness.session.prompt(text);
+ expect(harness.session.messages.at(-1)).toMatchObject({ role: "assistant", stopReason: "stop" });
+ expect(requests.at(-1)?.headers["x-opencode-session"]).toBe(harness.sessionManager.getSessionId());
+}
+
+function expectIdentity(harness: Harness, count: number) {
+ const calls = requests.filter((request) => request.operation !== "ordinary");
+ expect(calls).toHaveLength(count);
+ for (const call of calls) {
+ expect(call.headers["x-opencode-session"]).toBe(harness.sessionManager.getSessionId());
+ expect(call.headers["user-agent"]).toMatch(/^prime-agent(?:\/|$)/);
+ }
+}
+
+describe.each(["opencode", "opencode-go"])("ENG-6009 %s maintenance identity", (provider) => {
+ it("ordinary request control", async () => {
+ await ordinary(await setup(provider));
+ });
+ it("routes turn-prefix compaction", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ operation = "turn-prefix";
+ await expect(harness.session.compact()).resolves.toMatchObject({ summary: expect.stringContaining("OK") });
+ expectIdentity(harness, 1);
+ });
+ it.each(["off", "high"] as const)("routes both split-turn summaries with thinking %s", async (thinking) => {
+ const harness = await setup(provider, undefined, true);
+ harness.session.setThinkingLevel(thinking);
+ await ordinary(harness);
+ await ordinary(harness, "second request");
+ operation = "split-compaction";
+ await expect(harness.session.compact()).resolves.toMatchObject({ summary: expect.stringContaining("OK") });
+ expectIdentity(harness, 2);
+ const summaries = requests.filter((request) => request.operation === "split-compaction");
+ expect(new Set(summaries.map((request) => request.headers["idempotency-key"])).size).toBe(2);
+ expect(summaries.every((request) => request.headers["idempotency-key"])).toBe(true);
+ });
+ it("routes a history-only summary", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ harness.sessionManager.appendMessage({ role: "user", content: "retained request", timestamp: Date.now() });
+ operation = "history";
+ await expect(harness.session.compact()).resolves.toMatchObject({ summary: "OK" });
+ expectIdentity(harness, 1);
+ });
+ it("routes refinement planning", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ operation = "refinement-plan";
+ responseText = JSON.stringify(proposal);
+ await expect(harness.session.refine()).resolves.toMatchObject({ summary: "No change" });
+ expectIdentity(harness, 1);
+ });
+ it("routes the auto-refine review gate", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ operation = "refinement-review";
+ responseText = JSON.stringify({ shouldRefine: false, rationale: "No lesson" });
+ const internal = harness.session as unknown as {
+ _reviewAutoRefine(context: {
+ reason: "turn_interval";
+ turnsSinceLastReview: number;
+ }): Promise<AutoRefineReview>;
+ };
+ await expect(
+ internal._reviewAutoRefine({ reason: "turn_interval", turnsSinceLastReview: 5 }),
+ ).resolves.toMatchObject({ shouldRefine: false });
+ expectIdentity(harness, 1);
+ });
+ it("routes a tree branch summary", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ const target = harness.sessionManager.getLeafId()!;
+ await ordinary(harness, "explore a branch");
+ operation = "branch-summary";
+ await expect(harness.session.navigateTree(target, { summarize: true })).resolves.toMatchObject({
+ cancelled: false,
+ summaryEntry: { summary: expect.stringContaining("OK") },
+ });
+ expectIdentity(harness, 1);
+ });
+ it("keeps the owning session identity across a resume", async () => {
+ const original = await setup(provider);
+ await ordinary(original);
+ const resumed = await setup(provider, original.sessionManager.getSessionFile());
+ expect(resumed.session.sessionId).toBe(original.session.sessionId);
+ await ordinary(resumed, "continue resumed session");
+ operation = "resumed-compaction";
+ await resumed.session.compact();
+ expectIdentity(resumed, 2);
+ operation = "resumed-refinement";
+ responseText = JSON.stringify(proposal);
+ await resumed.session.refine();
+ expectIdentity(resumed, 3);
+ });
+ it("does not reuse another session's routing identity", async () => {
+ const first = await setup(provider);
+ await ordinary(first);
+ operation = "first-compaction";
+ await first.session.compact();
+ expectIdentity(first, 1);
+ const firstId = first.session.sessionId;
+ requests = [];
+ const second = await setup(provider);
+ expect(second.session.sessionId).not.toBe(firstId);
+ await ordinary(second);
+ operation = "second-compaction";
+ await second.session.compact();
+ expectIdentity(second, 1);
+ });
+ it("retains session and request identity when retrying a summary", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ operation = "retry-compaction";
+ transientFailures = 1;
+ await harness.session.compact();
+ expectIdentity(harness, 2);
+ const calls = requests.filter((request) => request.operation === "retry-compaction");
+ expect(calls[0].headers["idempotency-key"]).toBeTruthy();
+ expect(calls[1].headers["idempotency-key"]).toBe(calls[0].headers["idempotency-key"]);
+ expect(calls[1].body).toEqual(calls[0].body);
+ });
+ it("routes automatic compaction through the same owning session", async () => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ operation = "automatic-compaction";
+ const internal = harness.session as unknown as {
+ _runAutoCompaction(reason: "threshold", willRetry: boolean): Promise<void>;
+ };
+ await internal._runAutoCompaction("threshold", false);
+ expect(harness.eventsOfType("compaction_end").at(-1)).toMatchObject({
+ result: { summary: expect.stringContaining("OK") },
+ });
+ expectIdentity(harness, 1);
+ });
+ it.each([false, true])("forwards refineHarness identity with explicit headers=%s", async (explicit) => {
+ const harness = await setup(provider);
+ await ordinary(harness);
+ operation = "refineHarness";
+ responseText = JSON.stringify(proposal);
+ const state: HarnessState = {
+ schema: 1,
+ entries: { prompt: {}, memory: {}, skill: {}, subagent: {} },
+ refinements: [],
+ };
+ const headers: Record<string, string> = { "X-Fixture": "retained" };
+ if (explicit) headers["X-OpenCode-Session"] = "explicit-conversation";
+ const originalHeaders = { ...headers };
+ await expect(
+ refineHarness(
+ harness.session.messages,
+ state,
+ [],
+ harness.getModel(),
+ "faux-key",
+ {},
+ headers,
+ undefined,
+ undefined,
+ harness.session.sessionId,
+ ),
+ ).resolves.toMatchObject({ summary: "No change" });
+ expect(requests.at(-1)?.headers["x-opencode-session"]).toBe(
+ explicit ? "explicit-conversation" : harness.session.sessionId,
+ );
+ expect(requests.at(-1)?.headers["x-fixture"]).toBe("retained");
+ expect(headers).toEqual(originalHeaders);
+ });
+});