opencode-cache-engine 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-cache-engine",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "private": false,
   "description": "Provider-aware prompt-cache optimization and telemetry for OpenCode",
   "keywords": [

package/src/cache-engine.ts

@@ -56,16 +56,13 @@ import {
 //                         history stable, and INSTRUMENT preserved-thinking
 //                         integrity (duplicate/reorder/modified reasoning). No
 //                         invented cache key (Z.ai exposes none).
-//   MiMo-V2.6          -> prefix stability + OpenRouter session affinity. The
-//                         safe env-block relocation is applied (stabilizeSystem)
-//                         and provider switches within a session are diagnosed.
-//                         MiMo caching is provider-managed implicit context
-//                         caching; no cache key/breakpoint/TTL is invented. The
-//                         OpenRouter sticky-session id is derived but currently
-//                         NOT injected: this runtime's OpenRouter request
-//                         adapter forwards only usage/reasoning/prompt_cache_key
-//                         and exposes no top-level `session_id` path (verified
-//                         against the installed runtime; see README).
+//   MiMo-V2.6          -> prefix stability + provider diagnostics. The safe
+//                         env-block relocation is applied (stabilizeSystem).
+//                         For actual OpenRouter requests only, chat.headers
+//                         adds the deterministic x-session-id unless an
+//                         explicit case-insensitive value already exists in
+//                         model/plugin headers. No MiMo cache key/breakpoint/
+//                         TTL is invented.
 //
 // The engine remains conservative: it observes, hashes, compares, records,
 // appends a compaction continuation template, and (for GPT-5.6 only) injects
@@ -141,7 +138,13 @@ const emptyShape = (): Shape => ({
   toolCount: null,
 })
 
-type ChatParamsModel = { providerID: string; id?: string; api?: { id?: string; npm?: string }; name?: string }
+type ChatParamsModel = {
+  providerID: string
+  id?: string
+  api?: { id?: string; npm?: string }
+  headers?: Record<string, string>
+  name?: string
+}
 
 export const CacheEngine: Plugin = async ({ client, directory }) => {
   const cfg = loadConfig({ configPath: DEFAULT_CONFIG_PATH, env: process.env })
@@ -478,6 +481,30 @@ export const CacheEngine: Plugin = async ({ client, directory }) => {
     // GPT cache. Compaction requests (agent === "compaction") for the same root
     // use a deterministic separate namespace (<root>:compact) so a compaction
     // cache write never interferes with the useful live-session cache.
+    //
+    // MiMo-V2.6 + OpenRouter session affinity. Gate on the actual OpenCode
+    // provider identity as well as the detected family; a matching model slug
+    // on a direct endpoint is not sufficient. The runtime merges model.headers
+    // before this hook's output, so preserve a case-insensitive user/model or
+    // earlier-plugin x-session-id rather than silently overwriting it. Otherwise
+    // add the deterministic ID derived from the logical OpenCode session.
+    "chat.headers": async (input, output) => {
+      try {
+        const model = input.model as unknown as ChatParamsModel
+        const providerID = String(model?.providerID ?? "")
+        if (providerID !== "openrouter" || detectPolicy(model) !== POLICY_MIMO26) return
+
+        const hasSessionIDHeader = (headers?: Record<string, string>) =>
+          Object.keys(headers ?? {}).some((name) => name.toLowerCase() === "x-session-id")
+        if (hasSessionIDHeader(model?.headers) || hasSessionIDHeader(output.headers)) return
+
+        const sessionID = mimoSessionIdFor(input.sessionID)
+        if (sessionID) output.headers["x-session-id"] = sessionID
+      } catch (e) {
+        rec.record({ kind: "telemetry-error", ts: Date.now(), error: String(e) })
+      }
+    },
+
     "chat.params": async (input, output) => {
       try {
         const info = rememberModel(input.sessionID, input.model as unknown as ChatParamsModel)

package/test/cache-engine.test.mjs

@@ -9,6 +9,7 @@
 
 import { test } from "node:test"
 import assert from "node:assert/strict"
+import { execFileSync } from "node:child_process"
 import { mkdtempSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir, tmpdir } from "node:os"
 import { join } from "node:path"
@@ -1007,3 +1008,116 @@ test("MiMo policy performs no tool mutation (fingerprints are pure inputs)", ()
   // semantic fingerprint stays order-insensitive regardless of the policy
   assert.equal(toolFingerprint([...TOOLS].reverse()), before.sem)
 })
+
+// ===========================================================================
+// MiMo/OpenRouter session affinity (real chat.headers hook, no model calls)
+// ===========================================================================
+
+async function runMiMoHeaderHookProbe() {
+  const home = mkdtempSync(join(tmpdir(), "ce-mimo-headers-"))
+  const pluginURL = new URL("../src/cache-engine.ts", import.meta.url).href
+  const coreURL = new URL("../src/cache-engine-core.mjs", import.meta.url).href
+  const script = `
+    import assert from "node:assert/strict"
+    const { CacheEngine } = await import(${JSON.stringify(pluginURL)})
+    const { mimoSessionIdFor } = await import(${JSON.stringify(coreURL)})
+    const client = {
+      app: { log: async () => ({}) },
+      session: { get: async () => ({ data: { parentID: null } }) },
+      tool: { list: async () => ({ data: [] }) },
+    }
+    const hooks = await CacheEngine({ client, directory: process.env.HOME })
+    assert.equal(typeof hooks["chat.headers"], "function")
+    const invoke = async (model, sessionID, existingHeaders = {}) => {
+      const output = { headers: { ...existingHeaders } }
+      const headersRef = output.headers
+      await hooks["chat.headers"]({
+        sessionID,
+        agent: "build",
+        model,
+        provider: { id: model.providerID },
+        message: { id: "msg", sessionID, role: "user", content: "probe" },
+      }, output)
+      return { headers: output.headers, sameObject: output.headers === headersRef, modelHeaders: model.headers }
+    }
+    const mimoOpenRouter = {
+      providerID: "openrouter",
+      id: "xiaomi/mimo-v2.6-flash",
+      api: { id: "xiaomi/mimo-v2.6-flash" },
+      headers: {},
+    }
+    const stable1 = await invoke(mimoOpenRouter, "ses_same", { "User-Agent": "preserve-me", "x-custom": "also-preserve" })
+    const stable2 = await invoke(mimoOpenRouter, "ses_same")
+    const different = await invoke(mimoOpenRouter, "ses_other")
+    const direct = await invoke({ ...mimoOpenRouter, providerID: "xiaomi" }, "ses_direct", { "User-Agent": "preserve-me" })
+    const unknown = await invoke({ ...mimoOpenRouter, providerID: "unknown-provider" }, "ses_unknown")
+    const missingProvider = await invoke({ ...mimoOpenRouter, providerID: undefined }, "ses_missing_provider")
+    const glm = await invoke({ providerID: "openrouter", id: "z-ai/glm-5.3", api: { id: "z-ai/glm-5.3" }, headers: {} }, "ses_glm")
+    const configured = await invoke({
+      ...mimoOpenRouter,
+      headers: { "X-Session-Id": "user-configured-value" },
+    }, "ses_configured")
+    const earlierPlugin = await invoke(mimoOpenRouter, "ses_plugin", { "X-SESSION-ID": "earlier-plugin-value" })
+    const result = {
+      stable1,
+      stable2,
+      different,
+      direct,
+      unknown,
+      missingProvider,
+      glm,
+      configured,
+      configuredModelHeaders: configured.modelHeaders,
+      earlierPlugin,
+      expectedSame: mimoSessionIdFor("ses_same"),
+      expectedOther: mimoSessionIdFor("ses_other"),
+    }
+    assert.equal(configured.headers["x-session-id"], undefined)
+    assert.equal(earlierPlugin.headers["X-SESSION-ID"], "earlier-plugin-value")
+    process.stdout.write(JSON.stringify(result))
+  `
+  const stdout = execFileSync(process.execPath, ["--experimental-strip-types", "--input-type=module", "-e", script], {
+    cwd: process.cwd(),
+    env: { ...process.env, HOME: home },
+    encoding: "utf8",
+  })
+  return JSON.parse(stdout.trim())
+}
+
+let miMoHeaderProbe
+const miMoHeaderResults = async () => (miMoHeaderProbe ??= runMiMoHeaderHookProbe())
+
+test("MiMo/OpenRouter attaches the existing deterministic MiMo session ID", async () => {
+  const result = await miMoHeaderResults()
+  assert.equal(result.stable1.headers["x-session-id"], result.expectedSame)
+  assert.equal(result.stable1.sameObject, true)
+  assert.deepEqual(result.stable1.headers["User-Agent"], "preserve-me")
+  assert.deepEqual(result.stable1.headers["x-custom"], "also-preserve")
+})
+
+test("MiMo/OpenRouter session ID is stable across turns and distinct across sessions", async () => {
+  const result = await miMoHeaderResults()
+  assert.equal(result.stable2.headers["x-session-id"], result.stable1.headers["x-session-id"])
+  assert.equal(result.different.headers["x-session-id"], result.expectedOther)
+  assert.notEqual(result.different.headers["x-session-id"], result.stable1.headers["x-session-id"])
+})
+
+test("MiMo direct and unknown providers do not receive x-session-id", async () => {
+  const result = await miMoHeaderResults()
+  assert.equal(result.direct.headers["x-session-id"], undefined)
+  assert.equal(result.unknown.headers["x-session-id"], undefined)
+  assert.equal(result.missingProvider.headers["x-session-id"], undefined)
+  assert.deepEqual(result.direct.headers, { "User-Agent": "preserve-me" })
+})
+
+test("MiMo affinity preserves existing x-session-id values case-insensitively", async () => {
+  const result = await miMoHeaderResults()
+  assert.equal(result.configured.headers["x-session-id"], undefined)
+  assert.deepEqual(result.configuredModelHeaders, { "X-Session-Id": "user-configured-value" })
+  assert.deepEqual(result.earlierPlugin.headers, { "X-SESSION-ID": "earlier-plugin-value" })
+})
+
+test("MiMo-only affinity does not add x-session-id to GLM/OpenRouter", async () => {
+  const result = await miMoHeaderResults()
+  assert.equal(result.glm.headers["x-session-id"], undefined)
+})

package/.opencode/opencode.json

@@ -1,6 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    "opencode-cache-engine"
-  ]
-}

package/.opencode/tui.json

@@ -1,5 +0,0 @@
-{
-  "plugin": [
-    "opencode-cache-engine"
-  ]
-}