dsh-grok-subscription 1.0.8 → 1.0.11

package/README.en.md

@@ -25,7 +25,7 @@ Models, reasoning effort, and weekly quota all stay inside DSH.
 
 ## Three-step start
 
-1. **Install the plugin.** Run the command below; to select a candidate version, enter the full `package@version`, for example `dsh-grok-subscription@1.0.8`.
+1. **Install the plugin.** Run the command below; to select a candidate version, enter the full `package@version`, for example `dsh-grok-subscription@1.0.10`.
 
    ```sh
    dsh plugin --profile web add BaronCyrus/dsh-grok-subscription
@@ -91,7 +91,7 @@ dsh plugin --profile web add BaronCyrus/dsh-grok-subscription
 You can also install the version published on npm:
 
 ```sh
-dsh plugin --profile web add dsh-grok-subscription@1.0.8
+dsh plugin --profile web add dsh-grok-subscription@1.0.10
 ```
 
 DSH handles target selection, the profile lock, dependency resolution, and bundle activation.
@@ -146,7 +146,8 @@ Restart DSH manually afterwards, then:
 - Settings can show the used and remaining percentages the backend reports, and says so plainly instead of guessing when the read fails;
 - Supports CLI login, device-code login, pull from the Grok CLI, and logout;
 - Renews the access token automatically: near the end of its 6-hour life, or on a 401, it runs the official `grok` CLI and retries once, so a session never lapses mid-use; the chat model list refreshes whenever sign-in state changes;
-- When subscription routing is unavailable it reports an error instead of silently switching to another paid route.
+- When subscription routing is unavailable it reports an error instead of silently switching to another paid route;
+- Prefix caching follows xAI's automatic prompt-cache semantics: one DSH session keeps a stable `prompt_cache_key`, tool definitions stay in a stable order, and the fallback adapter preserves and replays `reasoning.encrypted_content` unchanged. Server-side eviction can still miss, and the plugin never invents a hit rate.
 
 ### Composer quota
 

package/README.md

@@ -25,7 +25,7 @@
 
 ## 三步开始
 
-1. **安装插件**：在终端运行下面的命令；指定候选版本时填写完整的 `包名@版本`，例如 `dsh-grok-subscription@1.0.8`。
+1. **安装插件**：在终端运行下面的命令；指定候选版本时填写完整的 `包名@版本`，例如 `dsh-grok-subscription@1.0.10`。
 
    ```sh
    dsh plugin --profile web add BaronCyrus/dsh-grok-subscription
@@ -91,7 +91,7 @@ dsh plugin --profile web add BaronCyrus/dsh-grok-subscription
 也可以按 npm 上的已发布版本安装：
 
 ```sh
-dsh plugin --profile web add dsh-grok-subscription@1.0.8
+dsh plugin --profile web add dsh-grok-subscription@1.0.10
 ```
 
 目标选择、profile 锁、依赖解析和 bundle 激活均由 DSH 负责。
@@ -146,7 +146,8 @@ dsh --profile web --dump-config
 - 设置页可查看服务端返回的用量与剩余百分比，失败时明确提示而不是显示猜测值；
 - 支持 CLI 登录、设备码登录、从 Grok CLI 拉取和登出；登录状态变化后 Chat 模型列表自动刷新；
 - access token 到期自动续期：临近 6 小时有效期或收到 401 时，调用官方 `grok` CLI 刷新会话并重试一次，不会中途要求手动重新登录；
-- 订阅路由不可用时明确报错，不会静默切换到其他付费路由。
+- 订阅路由不可用时明确报错，不会静默切换到其他付费路由；
+- 前缀缓存按 xAI 的自动缓存语义优化：同一 DSH 会话使用稳定的 `prompt_cache_key`，工具定义保持稳定顺序，回退适配器会保存并原样回放 `reasoning.encrypted_content`。缓存仍可能因服务端逐出而失效，插件不虚构命中率。
 
 ### 输入框额度
 

package/lib/client.js

@@ -26,6 +26,7 @@ __export(client_exports, {
   RPC_CALL_TIMEOUT_MS: () => RPC_CALL_TIMEOUT_MS,
   SectionBoundary: () => SectionBoundary,
   UsagePanel: () => UsagePanel,
+  VersionCard: () => VersionCard,
   apply: () => apply,
   callRpc: () => callRpc,
   inject: () => inject,
@@ -38,7 +39,7 @@ var import_react2 = require("react");
 var zh = {
   nav: "Grok \u8BA2\u9605",
   title: "Grok \u8BA2\u9605",
-  subtitle: "\u7528 SuperGrok / X Premium\uFF08Grok Build\uFF09\u4F1A\u8BDD\uFF0C\u800C\u4E0D\u662F XAI_API_KEY\u3002\xB7 1.0.8",
+  subtitle: "\u7528 SuperGrok / X Premium\uFF08Grok Build\uFF09\u4F1A\u8BDD\uFF0C\u800C\u4E0D\u662F XAI_API_KEY\u3002\xB7 1.0.11",
   signedIn: "\u5DF2\u767B\u5F55",
   signedOut: "\u672A\u767B\u5F55",
   account: "\u8D26\u6237",
@@ -90,12 +91,31 @@ var zh = {
   composerQuotaDetails: "\u6BCF\u5468\u989D\u5EA6",
   composerQuotaRemaining: "\u6BCF\u5468\u989D\u5EA6 \u5269\u4F59 {remaining}%",
   composerQuotaResets: "\u91CD\u7F6E\u4E8E {reset}",
-  composerQuotaResetUnknown: "\u91CD\u7F6E\u65F6\u95F4\u672A\u77E5"
+  composerQuotaResetUnknown: "\u91CD\u7F6E\u65F6\u95F4\u672A\u77E5",
+  versionTitle: "\u63D2\u4EF6\u7248\u672C",
+  versionCurrent: "\u5F53\u524D\u7248\u672C",
+  versionLatest: "\u6700\u65B0\u7248\u672C",
+  versionCheck: "\u68C0\u67E5\u66F4\u65B0",
+  versionChecking: "\u6B63\u5728\u68C0\u67E5\u66F4\u65B0\u2026",
+  versionFailed: "\u65E0\u6CD5\u68C0\u67E5\u6700\u65B0\u7248\u672C\u3002",
+  versionUpToDate: "\u5DF2\u662F\u6700\u65B0\u7248\u672C\u3002",
+  versionAvailable: "\u53D1\u73B0\u65B0\u7248\u672C v{version}\u3002",
+  versionLinked: "\u5F53\u524D\u4E3A\u672C\u5730\u5F00\u53D1\u5B89\u88C5\uFF0C\u8BF7\u5728\u63D2\u4EF6\u4ED3\u5E93\u62C9\u53D6\u6700\u65B0\u4EE3\u7801\u5E76\u91CD\u65B0\u6784\u5EFA\u3002",
+  versionManual: "\u8BF7\u5728\u7EC8\u7AEF\u8FD0\u884C dsh plugin --profile web add dsh-grok-subscription@latest \u5B8C\u6210\u66F4\u65B0\u3002",
+  versionUpdate: "\u66F4\u65B0\u63D2\u4EF6",
+  versionUpdating: "\u6B63\u5728\u66F4\u65B0\u2026",
+  versionUpdateFailed: "\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u6216\u5728\u7EC8\u7AEF\u624B\u52A8\u66F4\u65B0\u3002",
+  versionUpdated: "\u5DF2\u66F4\u65B0\u5230 v{version}\u3002",
+  versionUpdatedHint: "\u65B0\u7248\u672C\u9700\u8981\u91CD\u542F DSH \u670D\u52A1\u624D\u80FD\u5B8C\u5168\u751F\u6548\uFF1B\u4EC5\u5237\u65B0\u754C\u9762\u4E0D\u4F1A\u66F4\u65B0\u5BBF\u4E3B\u8FDB\u7A0B\u4E2D\u5DF2\u52A0\u8F7D\u7684\u63D2\u4EF6\u3002",
+  versionRestart: "\u91CD\u542F DSH \u670D\u52A1",
+  versionRestartHint: "\u63D2\u4EF6\u65E0\u6CD5\u5B89\u5168\u5730\u91CD\u542F\u5BBF\u4E3B\u8FDB\u7A0B\uFF1A\u8BF7\u5728\u8FD0\u884C DSH \u7684\u7EC8\u7AEF\u6309 Ctrl+C \u7ED3\u675F\u8FDB\u7A0B\uFF0C\u518D\u91CD\u65B0\u8FD0\u884C dsh web\u3002",
+  versionRefresh: "\u5237\u65B0\u754C\u9762",
+  versionLater: "\u7A0D\u540E"
 };
 var en = {
   nav: "Grok Subscription",
   title: "Grok Subscription",
-  subtitle: "Use a SuperGrok / X Premium (Grok Build) session, not XAI_API_KEY. \xB7 1.0.8",
+  subtitle: "Use a SuperGrok / X Premium (Grok Build) session, not XAI_API_KEY. \xB7 1.0.11",
   signedIn: "Signed in",
   signedOut: "Signed out",
   account: "Account",
@@ -147,7 +167,26 @@ var en = {
   composerQuotaDetails: "Weekly quota",
   composerQuotaRemaining: "Weekly quota \xB7 {remaining}% left",
   composerQuotaResets: "Resets {reset}",
-  composerQuotaResetUnknown: "Reset time unknown"
+  composerQuotaResetUnknown: "Reset time unknown",
+  versionTitle: "Plugin version",
+  versionCurrent: "Current version",
+  versionLatest: "Latest version",
+  versionCheck: "Check for updates",
+  versionChecking: "Checking for updates\u2026",
+  versionFailed: "Could not check the latest version.",
+  versionUpToDate: "You are on the latest version.",
+  versionAvailable: "A new version v{version} is available.",
+  versionLinked: "Installed from a local checkout; pull and rebuild the plugin repository to update.",
+  versionManual: "Run dsh plugin --profile web add dsh-grok-subscription@latest in a terminal to update.",
+  versionUpdate: "Update plugin",
+  versionUpdating: "Updating\u2026",
+  versionUpdateFailed: "The update failed. Try again or update manually in a terminal.",
+  versionUpdated: "Updated to v{version}.",
+  versionUpdatedHint: "The new version takes full effect after a DSH restart; refreshing the page alone does not reload the plugin inside the host process.",
+  versionRestart: "Restart DSH",
+  versionRestartHint: "The plugin cannot safely restart its host process: press Ctrl+C in the terminal running DSH, then run dsh web again.",
+  versionRefresh: "Refresh page",
+  versionLater: "Later"
 };
 
 // src/rpc-contract.js
@@ -160,7 +199,9 @@ var RPC_ENDPOINTS = Object.freeze([
   "logout",
   "catalog/refresh",
   "usage",
-  "usage/refresh"
+  "usage/refresh",
+  "plugin/version",
+  "plugin/update"
 ]);
 function createRpcClient(transport) {
   return Object.freeze({
@@ -620,7 +661,7 @@ function formatPercent(value) {
   const rounded = Math.round(value * 10) / 10;
   return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
 }
-async function callRpc(rpc, endpoint, payload = {}) {
+async function callRpc(rpc, endpoint, payload = {}, timeoutMs = RPC_CALL_TIMEOUT_MS) {
   const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
   let timer;
   try {
@@ -632,7 +673,7 @@ async function callRpc(rpc, endpoint, payload = {}) {
         } catch {
         }
         reject(new Error(`Request timed out after ${RPC_CALL_TIMEOUT_MS}ms`));
-      }, RPC_CALL_TIMEOUT_MS);
+      }, timeoutMs);
     });
     return unwrap(await Promise.race([call, timeout]));
   } finally {
@@ -687,6 +728,90 @@ function DiagnosticsRows({ diagnostics, t }) {
     ] })
   ] });
 }
+function fillTemplate2(template, values) {
+  return Object.entries(values).reduce(
+    (text, [key, value]) => text.replaceAll(`{${key}}`, value),
+    template
+  );
+}
+function VersionCard({ call, t }) {
+  const [info, setInfo] = (0, import_react2.useState)();
+  const [loading, setLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(false);
+  const [updating, setUpdating] = (0, import_react2.useState)(false);
+  const [updateFailed, setUpdateFailed] = (0, import_react2.useState)(false);
+  const [updated, setUpdated] = (0, import_react2.useState)();
+  const [restartHint, setRestartHint] = (0, import_react2.useState)(false);
+  const generation = (0, import_react2.useRef)(0);
+  const load = (force) => {
+    const current = ++generation.current;
+    setLoading(true);
+    setError(false);
+    void call("plugin/version", { force }).then((value) => {
+      if (generation.current === current) setInfo(value);
+    }).catch(() => {
+      if (generation.current === current) setError(true);
+    }).finally(() => {
+      if (generation.current === current) setLoading(false);
+    });
+  };
+  (0, import_react2.useEffect)(() => {
+    load(false);
+    return () => {
+      generation.current += 1;
+    };
+  }, []);
+  const update = () => {
+    setUpdating(true);
+    setUpdateFailed(false);
+    void call("plugin/update").then((value) => {
+      setUpdated(value);
+      setRestartHint(false);
+    }).catch(() => setUpdateFailed(true)).finally(() => setUpdating(false));
+  };
+  const installKind = info?.install?.kind;
+  const showStatus = info !== void 0 && updated === void 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gsCard", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gsCardHead", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h3", { children: t("versionTitle") }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "gsSpacer" }),
+      updated === void 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { className: "gsBtn", type: "button", disabled: loading || updating, onClick: () => load(true), children: loading ? t("versionChecking") : t("versionCheck") }) : null
+    ] }),
+    loading && info === void 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsStatus gsStatus--busy", role: "status", children: t("versionChecking") }) : null,
+    error ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsStatus gsStatus--error", role: "alert", children: t("versionFailed") }) : null,
+    info !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gsRows", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gsRow", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: t("versionCurrent") }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gsRowValue", children: [
+          "v",
+          info.current
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gsRow", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { children: t("versionLatest") }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: "gsRowValue", children: [
+          "v",
+          info.latest
+        ] })
+      ] })
+    ] }) : null,
+    showStatus ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsStatus gsStatus--ok", role: "status", children: info.updateAvailable ? fillTemplate2(t("versionAvailable"), { version: info.latest }) : t("versionUpToDate") }) : null,
+    showStatus && info.updateAvailable && installKind === "npm" ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "gsActions", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { className: "gsBtn gsBtn--primary", type: "button", disabled: updating, onClick: update, children: updating ? t("versionUpdating") : t("versionUpdate") }) }) : null,
+    showStatus && installKind === "link" ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsHint", children: t("versionLinked") }) : null,
+    showStatus && info.updateAvailable && installKind === "unknown" ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsHint", children: t("versionManual") }) : null,
+    updateFailed ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsStatus gsStatus--error", role: "alert", children: t("versionUpdateFailed") }) : null,
+    updated !== void 0 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { role: "status", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsStatus gsStatus--ok", children: fillTemplate2(t("versionUpdated"), { version: updated.version }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsHint", children: t("versionUpdatedHint") }),
+      restartHint ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "gsHint", children: t("versionRestartHint") }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { className: "gsActions", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { className: "gsBtn", type: "button", onClick: () => setRestartHint(true), children: t("versionRestart") }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { className: "gsBtn gsBtn--primary", type: "button", onClick: () => window.location.reload(), children: t("versionRefresh") }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { className: "gsBtn", type: "button", onClick: () => setUpdated(void 0), children: t("versionLater") })
+      ] })
+    ] }) : null
+  ] });
+}
 function UsagePanel({ usage, t, usageBusy, onRefresh, signedIn }) {
   const ok = usage?.status === "ok";
   const usedNumber = ok && Number.isFinite(usage.usedPercent) ? usage.usedPercent : void 0;
@@ -877,6 +1002,18 @@ function GrokSubscriptionSection({ rpc, t }) {
         ] })
       ] })
     ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      VersionCard,
+      {
+        t,
+        call: (endpoint, payload) => callRpc(
+          rpc,
+          endpoint,
+          payload,
+          endpoint === "plugin/update" ? 19e4 : RPC_CALL_TIMEOUT_MS
+        )
+      }
+    ),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       UsagePanel,
       {

package/lib/index.js

@@ -1,4 +1,5 @@
 // src/constants.js
+var PLUGIN_ID = "dsh-grok-subscription";
 var CORDIS_ID = "grok-subscription";
 var PROVIDER_ID = "grok-build";
 var DISPLAY_NAME = "Grok Build (subscription)";
@@ -936,6 +937,37 @@ function imageContentParts(blocks, imageParts) {
   }
   return parts;
 }
+var PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+var REPLAY_KIND = "grok-build-responses";
+var REPLAY_VERSION = 1;
+function promptCacheKey(options) {
+  const sessionId = typeof options?.sessionId === "string" ? options.sessionId.trim() : "";
+  if (!sessionId) return void 0;
+  const suffix = options.purpose === "compaction" || options.purpose === "session-title" ? `:${options.purpose}` : "";
+  const key = `grok${suffix}:${sessionId}`;
+  return key.length <= PROMPT_CACHE_KEY_MAX_LENGTH ? key : key.slice(0, PROMPT_CACHE_KEY_MAX_LENGTH);
+}
+function cacheStableTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) return [];
+  return tools.map((tool, index) => ({ tool, index })).sort((left, right) => {
+    const byName = String(left.tool?.name ?? "").localeCompare(String(right.tool?.name ?? ""));
+    return byName === 0 ? left.index - right.index : byName;
+  }).map(({ tool }) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+}
+function replayEnvelope(message) {
+  const state = message?.source?.replayState;
+  return state?.response?.kind === REPLAY_KIND && state.response.version === REPLAY_VERSION && Array.isArray(state.blocks) ? state : void 0;
+}
+function replayReasoningItem(message, contentIndex) {
+  const entry = replayEnvelope(message)?.blocks[contentIndex];
+  const item = entry?.type === "reasoning" ? entry.item : void 0;
+  return item?.type === "reasoning" && typeof item.encrypted_content === "string" && item.encrypted_content ? item : void 0;
+}
 function responsesInput(options, imageParts) {
   const input = [];
   const system = typeof options.system === "string" && options.system ? options.system : void 0;
@@ -955,7 +987,15 @@ function responsesInput(options, imageParts) {
       continue;
     }
     if (role === "assistant" && toolCalls.length) {
-      for (const block of toolCalls) {
+      const content = message.content ?? [];
+      for (let index = 0; index < content.length; index++) {
+        const block = content[index];
+        if (block?.type === "reasoning") {
+          const item = replayReasoningItem(message, index);
+          if (item) input.push(item);
+          continue;
+        }
+        if (block?.type !== "tool-call") continue;
         input.push({
           type: "function_call",
           call_id: block.id,
@@ -973,6 +1013,23 @@ function responsesInput(options, imageParts) {
       if (parts.length > 0) input.push({ role, content: parts });
       continue;
     }
+    if (role === "assistant") {
+      const content = message.content ?? [];
+      const output = [];
+      let text2 = "";
+      for (let index = 0; index < content.length; index++) {
+        const block = content[index];
+        if (block?.type === "reasoning") {
+          const item = replayReasoningItem(message, index);
+          if (item) output.push(item);
+        } else if (block?.type === "text" && block.text) {
+          text2 += block.text;
+        }
+      }
+      if (text2) output.push({ role: "assistant", content: text2 });
+      input.push(...output);
+      continue;
+    }
     const text = textOf(message.content);
     if (!text) continue;
     input.push({ role, content: text });
@@ -1022,22 +1079,18 @@ async function* streamResponsesUnsafe(options, token) {
   const body = {
     model: options.model,
     input: responsesInput(options, await collectImageParts(options, options.resolveAttachments)),
-    stream: true
+    stream: true,
+    // grok-4.7 returns ciphertext by default, but naming it keeps replay explicit
+    // for every reasoning model on this proxy.
+    include: ["reasoning.encrypted_content"]
   };
+  const cacheKey = promptCacheKey(options);
+  if (cacheKey) body.prompt_cache_key = cacheKey;
   if (typeof options.maxTokens === "number") body.max_output_tokens = options.maxTokens;
   if (typeof options.temperature === "number") body.temperature = options.temperature;
-  if (Array.isArray(options.tools) && options.tools.length) {
-    body.tools = options.tools.map((tool) => ({
-      type: "function",
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.parameters
-    }));
-  }
-  if (options.reasoningEffort) {
-    body.reasoning = { effort: options.reasoningEffort };
-    body.include = ["reasoning.encrypted_content"];
-  }
+  const tools = cacheStableTools(options.tools);
+  if (tools.length) body.tools = tools;
+  if (options.reasoningEffort) body.reasoning = { effort: options.reasoningEffort };
   const response = await fetch(RESPONSES_URL, {
     method: "POST",
     headers,
@@ -1058,6 +1111,7 @@ async function* streamResponsesUnsafe(options, token) {
   let textContent = "";
   let reasoningContent = "";
   let nextIndex = 0;
+  const emittedBlocks = [];
   const toolBlocks = /* @__PURE__ */ new Map();
   const toolNames = /* @__PURE__ */ new Map();
   let usage;
@@ -1099,6 +1153,7 @@ async function* streamResponsesUnsafe(options, token) {
       if (!delta) return;
       if (textIndex === void 0) {
         textIndex = nextIndex++;
+        emittedBlocks[textIndex] = { type: "text" };
         yield { type: "block-start", index: textIndex, blockType: "text" };
       }
       textContent += delta;
@@ -1110,6 +1165,7 @@ async function* streamResponsesUnsafe(options, token) {
       if (!delta) return;
       if (reasoningIndex === void 0) {
         reasoningIndex = nextIndex++;
+        emittedBlocks[reasoningIndex] = { type: "reasoning" };
         yield { type: "block-start", index: reasoningIndex, blockType: "reasoning" };
       }
       reasoningContent += delta;
@@ -1118,6 +1174,14 @@ async function* streamResponsesUnsafe(options, token) {
     }
     if (type === "response.output_item.added" || type === "response.output_item.done") {
       const item = payload.item;
+      if (item?.type === "reasoning" && typeof item.encrypted_content === "string" && item.encrypted_content) {
+        if (reasoningIndex === void 0) {
+          reasoningIndex = nextIndex++;
+          emittedBlocks[reasoningIndex] = { type: "reasoning" };
+          yield { type: "block-start", index: reasoningIndex, blockType: "reasoning" };
+        }
+        emittedBlocks[reasoningIndex] = { type: "reasoning", item };
+      }
       if (item?.type === "function_call") {
         learnToolName(item.id, item.name);
         learnToolName(item.call_id, item.name);
@@ -1143,6 +1207,7 @@ async function* streamResponsesUnsafe(options, token) {
           name: toolNames.get(id) ?? "tool",
           arguments: ""
         };
+        emittedBlocks[tool.index] = { type: "tool-call" };
         toolBlocks.set(id, tool);
         yield { type: "block-start", index: tool.index, blockType: "tool-call" };
       }
@@ -1160,17 +1225,38 @@ async function* streamResponsesUnsafe(options, token) {
         if (id && !toolBlocks.has(id)) {
           const tool = { index: nextIndex++, id, name: toolNames.get(id) ?? "tool", arguments: "" };
           toolBlocks.set(id, tool);
+          emittedBlocks[tool.index] = { type: "tool-call" };
           yield { type: "block-start", index: tool.index, blockType: "tool-call" };
         }
         adoptToolArguments(id, item.arguments);
       }
       const responseUsage = payload.response?.usage ?? payload.usage;
       if (responseUsage) {
+        const details = responseUsage.input_tokens_details ?? responseUsage.prompt_tokens_details ?? {};
+        const cachedTokens = finiteOr(details.cached_tokens, 0);
+        const cacheWriteTokens = finiteOr(details.cache_write_tokens, 0);
+        const promptTotal = finiteOr(
+          responseUsage.input_tokens ?? responseUsage.prompt_tokens,
+          0
+        );
+        const outputTokens = finiteOr(
+          responseUsage.output_tokens ?? responseUsage.completion_tokens,
+          0
+        );
         usage = {
-          inputTokens: finiteOr(responseUsage.input_tokens ?? responseUsage.prompt_tokens, 0),
-          outputTokens: finiteOr(responseUsage.output_tokens ?? responseUsage.completion_tokens, 0)
+          // The provider folds cache hits into the prompt count, while DSH's
+          // fields are disjoint: billed input = inputTokens + cacheRead +
+          // cacheWrite. Subtracting is what makes the host's "cache hit" figure
+          // real instead of a permanent 0%. Both cache fields stay numeric so
+          // consumers can always add them up.
+          inputTokens: Math.max(0, promptTotal - cachedTokens - cacheWriteTokens),
+          outputTokens,
+          cacheReadTokens: cachedTokens,
+          cacheWriteTokens
         };
-        usage.totalTokens = finiteOr(responseUsage.total_tokens, usage.inputTokens + usage.outputTokens);
+        const reasoningTokens = finiteOr(responseUsage.output_tokens_details?.reasoning_tokens, void 0);
+        if (reasoningTokens !== void 0) usage.reasoningTokens = reasoningTokens;
+        usage.totalTokens = finiteOr(responseUsage.total_tokens, promptTotal + outputTokens);
       }
       finish = mapFinish(payload.response?.status === "incomplete" ? "length" : "stop");
       if (toolBlocks.size) finish = { kind: "tool-calls" };
@@ -1210,7 +1296,14 @@ async function* streamResponsesUnsafe(options, token) {
     };
   }
   if (usage) yield { type: "usage", usage };
-  yield { type: "finish", reason: finish };
+  const finishChunk = { type: "finish", reason: finish };
+  if (finish.kind !== "error" && finish.kind !== "aborted" && emittedBlocks.length === nextIndex) {
+    finishChunk.replayState = {
+      response: { kind: REPLAY_KIND, version: REPLAY_VERSION },
+      blocks: emittedBlocks
+    };
+  }
+  yield finishChunk;
 }
 async function* streamResponses(options, token) {
   for await (const chunk of streamResponsesUnsafe(options, token)) {
@@ -1882,6 +1975,251 @@ function createSessionService({
   };
 }
 
+// src/plugin-version.js
+import { spawn as spawn2 } from "node:child_process";
+import { readdir, readFile, realpath } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = PLUGIN_ID;
+var NPM_REGISTRY_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var DEFAULT_VERSION_TTL_MS = 5 * 6e4;
+var DEFAULT_VERSION_TIMEOUT_MS = 1e4;
+var DEFAULT_UPDATE_TIMEOUT_MS = 18e4;
+var clone = (value) => structuredClone(value);
+function parseSemver(value) {
+  if (typeof value !== "string") return void 0;
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(value.trim());
+  if (match === null) return void 0;
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]), pre: match[4] };
+}
+function compareSemver(a, b) {
+  const left = parseSemver(a);
+  const right = parseSemver(b);
+  if (left === void 0 || right === void 0) return void 0;
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1;
+  }
+  if (left.pre === right.pre) return 0;
+  if (left.pre === void 0) return 1;
+  if (right.pre === void 0) return -1;
+  return left.pre < right.pre ? -1 : 1;
+}
+function classifySpec(spec) {
+  if (typeof spec !== "string" || spec === "") return "unknown";
+  if (/^(?:link|file):/u.test(spec)) return "link";
+  if (/^(?:\d|[~^*])/u.test(spec)) return "npm";
+  return "unknown";
+}
+var readManifest = async (path) => {
+  try {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    return parsed !== null && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+async function findInstall({ dshHome, ownPackageJsonUrl }) {
+  let ownReal;
+  try {
+    ownReal = await realpath(fileURLToPath(ownPackageJsonUrl));
+  } catch {
+    ownReal = void 0;
+  }
+  let entries = [];
+  try {
+    entries = await readdir(join4(dshHome, "profiles"), { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  const declared = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const profileDir = join4(dshHome, "profiles", entry.name);
+    const spec = (await readManifest(join4(profileDir, "package.json")))?.dependencies?.[PACKAGE_NAME];
+    if (typeof spec !== "string") continue;
+    declared.push({ profile: entry.name, spec });
+    if (ownReal === void 0) continue;
+    try {
+      const installed = await realpath(join4(profileDir, "node_modules", PACKAGE_NAME, "package.json"));
+      if (installed === ownReal) return { kind: classifySpec(spec), profile: entry.name };
+    } catch {
+    }
+  }
+  if (declared.length === 1) return { kind: classifySpec(declared[0].spec), profile: declared[0].profile };
+  return { kind: "unknown" };
+}
+function spawnRunCommand(argv, { signal, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason instanceof Error ? signal.reason : new Error("Grok plugin update aborted"));
+      return;
+    }
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(new Error("Grok plugin update timed out")), timeoutMs);
+    let settled = false;
+    const settle = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      callback(value);
+    };
+    let child;
+    try {
+      child = spawn2(argv[0], argv.slice(1), { stdio: ["ignore", "pipe", "pipe"], signal: controller.signal });
+    } catch (error) {
+      settle(reject, error);
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout = (stdout + chunk).slice(-8192);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = (stderr + chunk).slice(-8192);
+    });
+    child.on("error", (error) => settle(reject, error));
+    child.on("close", (code) => {
+      if (controller.signal.aborted) {
+        const reason = controller.signal.reason;
+        settle(reject, reason instanceof Error ? reason : new Error("Grok plugin update aborted"));
+        return;
+      }
+      settle(resolve, { code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+function createGrokPluginManager({
+  fetchImpl = globalThis.fetch,
+  runCommand = spawnRunCommand,
+  execPath = process.execPath,
+  binPath = process.argv[1],
+  env = process.env,
+  ownPackageJsonUrl = new URL("../package.json", import.meta.url),
+  registryUrl = NPM_REGISTRY_LATEST_URL,
+  now = Date.now,
+  ttlMs = DEFAULT_VERSION_TTL_MS,
+  timeoutMs = DEFAULT_VERSION_TIMEOUT_MS,
+  updateTimeoutMs = DEFAULT_UPDATE_TIMEOUT_MS
+} = {}) {
+  if (typeof fetchImpl !== "function") throw new Error("Grok plugin manager requires fetch");
+  if (typeof runCommand !== "function") throw new Error("Grok plugin manager requires runCommand");
+  const dshHome = typeof env.DSH_HOME === "string" && env.DSH_HOME !== "" ? env.DSH_HOME : join4(homedir3(), ".dsh");
+  let cached;
+  let inFlight;
+  let generation = 0;
+  let updating = false;
+  const fetchLatest = async (signal) => {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const requestSignal = signal === void 0 ? timeoutSignal : AbortSignal.any([signal, timeoutSignal]);
+    let response;
+    try {
+      response = await fetchImpl(registryUrl, {
+        headers: { Accept: "application/json" },
+        redirect: "error",
+        signal: requestSignal
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      throw new Error("Grok plugin version check failed");
+    }
+    if (!response.ok) throw new Error("Grok plugin version check failed");
+    let version;
+    try {
+      version = (await response.json())?.version;
+    } catch {
+      version = void 0;
+    }
+    if (parseSemver(version) === void 0) throw new Error("Grok plugin version check failed");
+    return version;
+  };
+  const readOwnVersion = async () => {
+    const version = (await readManifest(fileURLToPath(ownPackageJsonUrl)))?.version;
+    if (parseSemver(version) === void 0) throw new Error("Grok plugin version is unavailable");
+    return version;
+  };
+  const load = async (signal) => {
+    signal?.throwIfAborted();
+    const [current, install, latest] = await Promise.all([
+      readOwnVersion(),
+      findInstall({ dshHome, ownPackageJsonUrl }),
+      fetchLatest(signal)
+    ]);
+    return {
+      current,
+      latest,
+      updateAvailable: compareSemver(latest, current) === 1,
+      install,
+      fetchedAt: now()
+    };
+  };
+  return Object.freeze({
+    async read({ force = false, signal } = {}) {
+      signal?.throwIfAborted();
+      if (!force && cached !== void 0 && now() - cached.fetchedAt < ttlMs) return clone(cached);
+      const createPending = (requestSignal) => {
+        const observedGeneration = generation;
+        return load(requestSignal).then((value) => {
+          if (generation === observedGeneration) cached = value;
+          return value;
+        });
+      };
+      if (force) return clone(await createPending(signal));
+      const pending = inFlight ?? createPending();
+      if (inFlight === void 0) {
+        inFlight = pending;
+        const clear = () => {
+          if (inFlight === pending) inFlight = void 0;
+        };
+        void pending.then(clear, clear);
+      }
+      return clone(await (signal === void 0 ? pending : Promise.race([
+        pending,
+        new Promise((_, reject) => {
+          const onAbort = () => reject(signal.reason instanceof Error ? signal.reason : new Error("Grok plugin version check aborted"));
+          if (signal.aborted) onAbort();
+          else signal.addEventListener("abort", onAbort, { once: true });
+        })
+      ])));
+    },
+    async update({ signal } = {}) {
+      signal?.throwIfAborted();
+      if (updating) throw new Error("Grok plugin update is already running");
+      updating = true;
+      try {
+        const install = await findInstall({ dshHome, ownPackageJsonUrl });
+        if (install.kind === "link") throw new Error("Grok plugin is installed from a local checkout");
+        if (install.kind !== "npm" || install.profile === void 0) {
+          throw new Error("Grok plugin update could not find the owning profile");
+        }
+        const latest = await fetchLatest(signal);
+        const argv = binPath === void 0 ? ["dsh", "plugin", "--profile", install.profile, "add", `${PACKAGE_NAME}@${latest}`] : [execPath, binPath, "plugin", "--profile", install.profile, "add", `${PACKAGE_NAME}@${latest}`];
+        let result;
+        try {
+          result = await runCommand(argv, { signal, timeoutMs: updateTimeoutMs });
+        } catch (error) {
+          if (signal?.aborted) throw error;
+          throw new Error("Grok plugin update failed");
+        }
+        if (result.code !== 0) throw new Error("Grok plugin update failed");
+        generation += 1;
+        cached = void 0;
+        return { version: latest, profile: install.profile };
+      } finally {
+        updating = false;
+      }
+    },
+    invalidate() {
+      generation += 1;
+      cached = void 0;
+    }
+  });
+}
+
 // src/rpc-contract.js
 var RPC_ENDPOINTS = Object.freeze([
   "status",
@@ -1891,7 +2229,9 @@ var RPC_ENDPOINTS = Object.freeze([
   "logout",
   "catalog/refresh",
   "usage",
-  "usage/refresh"
+  "usage/refresh",
+  "plugin/version",
+  "plugin/update"
 ]);
 function publicResult(value) {
   return { ok: true, value };
@@ -1965,7 +2305,18 @@ function sanitizeUsage(usage) {
   }
   return out;
 }
-async function dispatch(session, endpoint, diagnostics) {
+function publicPluginVersion(value) {
+  const installKind = value?.install?.kind;
+  return {
+    current: value.current,
+    latest: value.latest,
+    updateAvailable: value.updateAvailable === true,
+    install: {
+      kind: installKind === "npm" || installKind === "link" ? installKind : "unknown"
+    }
+  };
+}
+async function dispatch(session, endpoint, diagnostics, payload, signal, pluginManager) {
   if (endpoint === "status") {
     const status = await session.status();
     return publicResult(stripSecrets({
@@ -1991,14 +2342,27 @@ async function dispatch(session, endpoint, diagnostics) {
   }
   if (endpoint === "login/cli") return publicResult(stripSecrets(await session.login({ device: false })));
   if (endpoint === "login/device") return publicResult(stripSecrets(await session.login({ device: true })));
+  if (endpoint === "plugin/version" || endpoint === "plugin/update") {
+    if (!pluginManager) return publicError(new Error("Grok plugin update is unavailable"));
+    if (endpoint === "plugin/version") {
+      return publicResult(publicPluginVersion(await pluginManager.read({
+        force: payload?.force === true,
+        signal
+      })));
+    }
+    const updated = await pluginManager.update({ signal });
+    return publicResult({ version: updated.version });
+  }
   return publicError(new Error(`Unknown Grok subscription RPC: ${endpoint}`));
 }
 function createRpcHandler(session, options = {}) {
   const timeoutMs = typeof options.timeoutMs === "number" && options.timeoutMs > 0 ? options.timeoutMs : RPC_HANDLER_TIMEOUT_MS;
-  return async function handle(endpoint, _payload, _signal) {
+  return async function handle(endpoint, payload, signal) {
     try {
+      const operation = dispatch(session, endpoint, options.diagnostics, payload, signal, options.pluginManager);
+      if (endpoint === "plugin/update") return await operation;
       return await withTimeout(
-        dispatch(session, endpoint, options.diagnostics),
+        operation,
         timeoutMs,
         `Grok subscription RPC "${endpoint}" timed out after ${timeoutMs}ms`,
         { unref: false }
@@ -2144,7 +2508,9 @@ function apply(ctx, options = {}) {
     onCatalogChange: notifyCatalogChange
   });
   const adapterState = { kind: "custom-mvp", upgraded: false };
+  const pluginManager = options.pluginManager ?? createGrokPluginManager();
   const handler = createRpcHandler(session, {
+    pluginManager,
     diagnostics: () => ({
       adapter: adapterState.upgraded ? "pi-ai" : "fallback",
       adapterKind: adapterState.kind,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-grok-subscription",
-  "version": "1.0.8",
+  "version": "1.0.11",
   "description": "Use a SuperGrok or X Premium Grok Build subscription in DeepSeek Harness",
   "type": "module",
   "main": "./lib/index.js",