Auto review fails every tool call when the session model routes through OpenCode Go

[xiaojueshi]

Auto review fails every tool call when the session model routes through OpenCode Go

Environment

• DeepSeek Harness 0.2.1-rc.2 (nightly, macOS arm64)
• Permission preset: Auto review (/permission auto), approval policy ask
• Session model: opencode-go/deepseek-v4.1-flash (OpenCode Go subscription, base URL https://opencode.ai/zen/go/v1)

Symptom

With Auto selected, every native tool call is cancelled before its body executes:

Error: Auto review of tool "bash" failed; its body was not executed: auto-review:
reviewer ended with error INVALID_REQUEST: 400: {"type":"MissingSessionID","message":
"Request is missing x-opencode-session and cannot be routed efficiently. Please see
https://opencode.ai/docs/go/#where-can-i-use-it"}

Switching permission to never (or a non-Auto preset) makes the exact same call succeed.

Root cause

OpenCode Go requires x-opencode-session on inference requests. pi-ai's opencode-go
provider injects that header via withOpenCodeSessionHeader(), but only when the call
supplies options.sessionId (@earendil-works/pi-ai/dist/providers/opencode-headers.js).

Ordinary agent-loop requests pass sessionId, and so do auxiliary calls such as
compaction (packages/compaction/compaction-basic/src/summarizer.ts) and session titles
(packages/session/session-title-llm/src/index.ts). The Auto reviewer does not:
classifyRisk() in packages/experimental/auto-review/src/index.ts builds its
GenerateOptions without sessionId, so the header is never added and OpenCode Go
rejects the request with 400 MissingSessionID.

Transport requirement (reproduced directly)

POST https://opencode.ai/zen/go/v1/chat/completions
model: deepseek-v4.1-flash

without x-opencode-session → HTTP 400 {"type":"MissingSessionID", ...}
with    x-opencode-session: <any string> → HTTP 200 chat completion

Suggested fix

Pass the Session identity on the reviewer request, matching the existing auxiliary-call
convention:

     }],
     temperature: 0,
+    // The review travels the Session's own provider route, so it carries the
+    // Session identity an ordinary call does. Transports that key per-request
+    // routing on it (OpenCode Go requires `x-opencode-session`) reject an
+    // identity-free request.
+    sessionId: agent.session.id,
     signal,
   })

Add a regression assertion to packages/experimental/auto-review/tests/auto-review.e2e.ts
so every reviewed call must record the Session identity it sent:

 import {
   createUserMessage, isAgentLoopRequest, ToolCallId,
+  type GenerateOptions,
   type StreamChunk,
 } from '@deepseek-ai/dsh-llm'
@@
   const observations: Observation[] = []
+  const reviewerSessions: GenerateOptions['sessionId'][] = []
   let reviewCalls = 0
@@
       reviewCalls += 1
+      // The reviewer request must carry the Session identity: transports such
+      // as OpenCode Go key per-request routing on it and reject an anonymous call.
+      reviewerSessions.push(options.sessionId)
       expect(options.provider === PROVIDER && options.model === mainAgent.options.model).toBe(true)
@@
   return {
     observations,
+    reviewerSessions,
     postToolInputs,
@@
       expect(runner.calls() - calls, `${id}: reviewer count`).toBe(1)
+      // Every reviewed call must present the Session identity to the provider.
+      expect(runner.reviewerSessions.at(-1), `${id}: reviewer session`).toBe(agent.id)
       const observed = runner.observations.at(-1)

Verification

Targeted suite (no API key needed; the deterministic reviewer fixtures are keyless):

pnpm exec vitest run --config vitest.e2e.config.ts packages/experimental/auto-review/tests/auto-review.e2e.ts

• Negative control (regression assertion kept, source fix reverted):
  Tests 1 failed | 2 passed (3) —
  AssertionError: L01: reviewer session: expected undefined to be '<uuid>'
• With the fix: Test Files 1 passed (1), Tests 3 passed (3).
• oxlint on both changed files: 0 warnings, 0 errors.
• pnpm run typecheck: 5 gates passed, 0 failed.

Impact

Only the experimental Auto preset combined with a model route that requires
per-request session routing (pi-ai wraps both OpenCode provider routes, opencode / OpenCode Zen
and opencode-go, with this header). Other providers are unaffected.
User-side workarounds: choose a non-Auto preset, or pin a literal
headers.x-opencode-session on the provider route (at the cost of per-session routing).

Patch

diff --git a/packages/experimental/auto-review/src/index.ts b/packages/experimental/auto-review/src/index.ts
index d4975b54..916741ab 100644
--- a/packages/experimental/auto-review/src/index.ts
+++ b/packages/experimental/auto-review/src/index.ts
@@ -630,6 +630,11 @@ async function classifyRisk(
       content: [{ type: 'text', text: reviewUserText(snapshot) }],
     }],
     temperature: 0,
+    // The review travels the Session's own provider route, so it carries the
+    // Session identity an ordinary call does. Transports that key per-request
+    // routing on it (OpenCode Go requires `x-opencode-session`) reject an
+    // identity-free request.
+    sessionId: agent.session.id,
     signal,
   })
   return readDecision(ctx.llm.stream(options))
diff --git a/packages/experimental/auto-review/tests/auto-review.e2e.ts b/packages/experimental/auto-review/tests/auto-review.e2e.ts
index 04f9c613..a527a773 100644
--- a/packages/experimental/auto-review/tests/auto-review.e2e.ts
+++ b/packages/experimental/auto-review/tests/auto-review.e2e.ts
@@ -12,6 +12,7 @@ import * as FsObservationPolicy from '@deepseek-ai/dsh-fs-observation-policy'
 import { SandboxedFileSystem } from '@deepseek-ai/dsh-fs-sandbox'
 import {
   createUserMessage, isAgentLoopRequest, ToolCallId,
+  type GenerateOptions,
   type StreamChunk,
 } from '@deepseek-ai/dsh-llm'
 import * as LlmDeepSeek from '@deepseek-ai/dsh-llm-deepseek-api-key'
@@ -164,6 +165,7 @@ function orchestrate(ctx: Context, real: boolean) {
   let offeredTool = ''
   let bodyStarts = 0
   const observations: Observation[] = []
+  const reviewerSessions: GenerateOptions['sessionId'][] = []
   let reviewCalls = 0
   const postToolInputs: string[] = []
   ctx.on('tools/execute', (execution, next) => {
@@ -176,6 +178,9 @@ function orchestrate(ctx: Context, real: boolean) {
       expect(options.messages[0]).not.toHaveProperty('id')
       if (expected === undefined || mainAgent === undefined) throw new Error('Unexpected reviewer call outside a case')
       reviewCalls += 1
+      // The reviewer request must carry the Session identity: transports such
+      // as OpenCode Go key per-request routing on it and reject an anonymous call.
+      reviewerSessions.push(options.sessionId)
       expect(options.provider === PROVIDER && options.model === mainAgent.options.model).toBe(true)
       return observe(real ? next() : stream(textChunks(JSON.stringify(expected))), observations)
     }
@@ -188,6 +193,7 @@ function orchestrate(ctx: Context, real: boolean) {
   })
   return {
     observations,
+    reviewerSessions,
     postToolInputs,
     calls: () => reviewCalls,
     async action(
@@ -271,6 +277,8 @@ it('certifies eight Auto risk/authorization cases with zero retries and zero ski
       const calls = runner.calls()
       const result = await runner.action(agent, 'bash', { command, description: 'Execute the exact pending action.' }, path, prompt, expected)
       expect(runner.calls() - calls, `${id}: reviewer count`).toBe(1)
+      // Every reviewed call must present the Session identity to the provider.
+      expect(runner.reviewerSessions.at(-1), `${id}: reviewer session`).toBe(agent.id)
       const observed = runner.observations.at(-1)
       if (observed === undefined) throw new Error(`${id}: missing classification`)
       const settled = outcome(result.events, path)

[PerryLink]

The missing piece is that the review request carries no session identity, and the adapter only forwards one when it is given.

GenerateOptions has the field: sessionId?: Branded<'SessionId'> (packages/llm/llm/src/types.ts:561-564, described as the loop-stamped session identity for request routing). The pi-ai adapter forwards it into the provider call only when present:

// packages/llm/llm-pi-ai/src/adapter.ts:420
...options.sessionId === undefined ? {} : { sessionId: String(options.sessionId) },

And classifyRisk builds its request without it:

// packages/experimental/auto-review/src/index.ts:624-635
const options: GenerateOptions = deepFreeze({
  provider: snapshot.provider,
  model: snapshot.model,
  system: REVIEW_POLICY,
  messages: [{ role: 'user', content: [{ type: 'text', text: reviewUserText(snapshot) }] }],
  temperature: 0,
  signal,
})

So the reviewer runs on the session's route (:625-626) but arrives without the identity that route uses to attribute the call. For a route that requires a session header — OpenCode Go being the case here — every review request is unfixed in that respect, and since the review runs before each tool call and a failed review denies the call, the symptom is "every tool call cancelled before its body executes", which is what you are seeing.

Two fixes, and they are not equivalent:

• Pass sessionId in classifyRisk. classifyRisk already receives the agent (:617), so the session is at hand. This makes the reviewer attributable and fixes this route, but it also means review traffic shares the session's quota.
• Give auto-review its own route (the same conclusion as the persona problem in [auto-review] Reviewer reuses the persona-injected model route & history → emits prose instead of the JSON protocol → every tool call fails closed (Auto preset unusable under custom personas) #10525). A reviewer on a dedicated provider/model avoids both the session-header requirement and the persona leakage, at the cost of one more route to configure.

I verified the DSH side of the chain above. I did not verify what x-opencode-session is derived from, because that name does not appear anywhere in this repository — it belongs to the provider integration, so the mapping from sessionId to that header is outside what I can check here. If that mapping is not what the route uses, the first fix will not be enough and the second one is the only reliable option.

[xiaojueshi]

Thanks — your DSH-side description matches my finding. The unverified link is in @earendil-works/pi-ai (resolved to 1.1.0 here, i.e. this repo's patched dependency), not in this repository, which is why x-opencode-session does not appear here. The mapping is literal:

// @earendil-works/pi-ai/dist/providers/opencode-headers.js
const OPENCODE_SESSION_HEADER = "x-opencode-session";
function withSessionHeader(options) {
  if (!options?.sessionId || hasHeader(options.headers, OPENCODE_SESSION_HEADER)) return options;
  return {
    ...options,
    headers: { ...options.headers, [OPENCODE_SESSION_HEADER]: options.sessionId },
  };
}
export function withOpenCodeSessionHeader(streams) {
  return {
    ...streams,
    stream: (model, context, options) => streams.stream(model, context, withSessionHeader(options)),
    streamSimple: (model, context, options) => streams.streamSimple(model, context, withSessionHeader(options)),
  };
}

dist/providers/opencode-go.js wraps every protocol the provider exposes with it:

api: {
  "anthropic-messages": withOpenCodeSessionHeader(anthropicMessagesApi()),
  "openai-completions": withOpenCodeSessionHeader(openAICompletionsApi()),
  "openai-responses": withOpenCodeSessionHeader(openAIResponsesApi()),
}

One more link so the chain is complete: a configured route that names an installed catalog provider without overriding its protocol reuses that provider instead of rebuilding it — packages/llm/llm-pi-ai/src/provider.ts:172 (if (catalog !== undefined && spec.api === undefined) return reuseCatalogProvider(catalog, spec)), and reuseCatalogProvider delegates stream/streamSimple to the catalog provider (:156-157). The opencode-go profile in question sets only apiKeyEnv, so the wrapped implementation is exactly what dispatches.

packages/llm/llm-pi-ai/src/adapter.ts:420 forwards options.sessionId into that call, so the header value comes from GenerateOptions.sessionId and nothing else in the provider sets it (a deployment-level headers.x-opencode-session in the route profile would take precedence instead, via hasHeader). I also confirmed the transport requirement against the route itself (POST https://opencode.ai/zen/go/v1/chat/completions, deepseek-v4.1-flash): no header → 400 MissingSessionID; header present → 200. So fix 1 is sufficient for this route; no additional mapping step is missing.

On ownership: the provider requirement is legitimate, and the call site that drops the identity is in this repository's experimental auto-review package, so I read this as a DSH-side omission rather than a pi-ai defect — the other auxiliary calls here already pass the same identity.

Agreed that the two options are not equivalent. The patch in the original post is deliberately only fix 1 and mirrors how the other auxiliary calls already behave (compaction passes agent.session.id, session titles pass request.session.id). The dedicated reviewer route is likely the better long-term shape, but Auto currently follows request/header.config by design and has no reviewer-route configuration, so that reads as a feature decision rather than a regression fix; worth its own item.

On the DSH side, carrying the identity reaches only two listeners: session-checkpoint-policy flushes the session before dispatch when sessionId is present (one extra durability flush, fail-closed like any other request), and session-title ignores non-loop requests via isAgentLoopRequest. The review prompt still never enters the Session log, because no request/header event is written on this path.

On quota: with or without the identity, the review already travels the session's route and account, so the header adds attribution/routing rather than a new caller. If OpenCode Go also gates per-conversation limits on that header, review calls would count against the conversation they are deciding for — which reads as the intended accounting, though I cannot confirm that policy from the client side.

Evidence remains in the original post: the e2e suite fails without the source change (L01: reviewer session: expected undefined to be '<uuid>') and passes 3/3 with it; oxlint clean; pnpm run typecheck 5/5 gates. If the external-contribution policy changes, I'm happy to turn this into a PR.