@toddzheng024/dscode-bundle 0.7.13 → 0.7.14

package/plugins/grok/models.mjs

@@ -0,0 +1,129 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// dscode: the Grok model catalog. The subscription rail serves its models from the same
+// CLI proxy the official `grok` client uses, and that listing carries what a harness needs:
+// the context window, the reasoning detents (xhigh/high/medium/low, which are DSCODE effort
+// ids already), the backend-search flag and the compaction threshold. One table, kept for a
+// day in DSH_HOME, backs /model, compaction and the status line.
+
+export const GROK_MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models";
+/** How long a first model lookup waits for the listing before answering without it. */
+export const GROK_MODELS_TIMEOUT_MS = 10_000;
+/** How long a failed listing (or an unusable cache file) waits before the next attempt. */
+export const GROK_MODELS_RETRY_MS = 10 * 60 * 1000;
+const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const FILE = "grok-models.json";
+const VERSION = 1;
+/** Reasoning detents DSCODE names; the wire spells them the same way through this route. */
+export const GROK_EFFORTS = Object.freeze(["low", "medium", "high", "xhigh"]);
+/** Media models the chat route must not offer to an agent. */
+const NON_CHAT = /(?:imagine|video|image|audio|vision-gen)/i;
+let table = { fetchedAt: 0, models: {} };
+let cacheReadAt = 0;
+let attemptedAt = 0, pending;
+
+const positive = value => Number.isSafeInteger(value) && value > 0 ? value : undefined;
+
+/**
+ * Models from one `/models` body of the Grok CLI proxy, or of the public api.x.ai listing.
+ * @returns `{ [id]: { name, description?, contextWindow?, maxOutput?, efforts?, defaultEffort?,
+ *   backendSearch?, compactThresholdPercent?, compactionAtTokens? } }`
+ */
+export function parseGrokModels(body) {
+  const models = {};
+  for (const model of Array.isArray(body?.data) ? body.data : []) {
+    const id = typeof model?.id === "string" ? model.id : typeof model?.model === "string" ? model.model : undefined;
+    if (id === undefined || id.length === 0 || NON_CHAT.test(id)) continue;
+    const efforts = (Array.isArray(model.reasoning_efforts) ? model.reasoning_efforts : [])
+      .map(entry => typeof entry === "string" ? entry : entry?.id)
+      .filter(level => GROK_EFFORTS.includes(level));
+    const named = efforts.length > 0 ? GROK_EFFORTS.filter(level => efforts.includes(level)) : undefined;
+    const defaultEffort = typeof model.reasoning_effort === "string" && GROK_EFFORTS.includes(model.reasoning_effort) ? model.reasoning_effort : undefined;
+    const contextWindow = positive(model.context_window) ?? positive(model.context_length);
+    models[id] = {
+      name: typeof model.name === "string" && model.name.length > 0 ? model.name : id,
+      ...typeof model.description === "string" && model.description.length > 0 ? { description: model.description } : {},
+      ...contextWindow === undefined ? {} : { contextWindow },
+      ...positive(model.max_completion_tokens) === undefined ? {} : { maxOutput: positive(model.max_completion_tokens) },
+      ...named === undefined ? {} : { efforts: named }, ...defaultEffort === undefined ? {} : { defaultEffort },
+      ...model.supports_backend_search === true ? { backendSearch: true } : {},
+      ...positive(model.auto_compact_threshold_percent) === undefined ? {} : { compactThresholdPercent: positive(model.auto_compact_threshold_percent) },
+      ...model.compaction_at_tokens === true ? { compactionAtTokens: true } : {},
+    };
+  }
+  return models;
+}
+
+/** One model entry, or undefined when the table does not list it. */
+export function grokModel(id) {
+  return Object.hasOwn(table.models, id) ? table.models[id] : undefined;
+}
+
+/** Every listed model as `[id, entry]` pairs, in listing order. */
+export function listGrokModels() {
+  return Object.entries(table.models);
+}
+
+/** Replace the table (and forget the last attempt); for tests and cache loads. */
+export function setGrokModels(models, fetchedAt = Date.now()) {
+  table = { fetchedAt, models };
+  cacheReadAt = 0;
+  attemptedAt = 0;
+}
+
+/** The headers the official CLI sends; the proxy answers a request without them with its generic API rail. */
+export function grokCliHeaders(token, version) {
+  return { authorization: "Bearer " + token, accept: "application/json", "x-xai-token-auth": "xai-grok-cli", "x-grok-client-version": version };
+}
+
+/**
+ * Load the cached table, then refetch it once it is a day old. A failure keeps the last
+ * table and waits ten minutes before trying again; never throws.
+ */
+export async function refreshGrokModels({ home, token, version = "1.0.34", fetch: fetchImpl = globalThis.fetch, now = Date.now() } = {}) {
+  const path = home ? join(home, FILE) : undefined;
+  if (table.fetchedAt === 0 && path && now - cacheReadAt >= GROK_MODELS_RETRY_MS) {
+    cacheReadAt = now;
+    try {
+      const cached = JSON.parse(readFileSync(path, "utf8"));
+      if (cached?.version === VERSION && Number.isFinite(cached.fetchedAt) && cached.models && typeof cached.models === "object") table = { fetchedAt: cached.fetchedAt, models: cached.models };
+    } catch { /* no usable cache */ }
+  }
+  if (now - table.fetchedAt < MAX_AGE_MS || now - attemptedAt < GROK_MODELS_RETRY_MS || token === undefined || typeof fetchImpl !== "function") return table;
+  if (pending) return pending;
+  attemptedAt = now;
+  pending = (async () => {
+    try {
+      const response = await fetchImpl(GROK_MODELS_URL, { headers: grokCliHeaders(token, version) });
+      if (!response.ok) return table;
+      const models = parseGrokModels(await response.json());
+      if (Object.keys(models).length === 0) return table;
+      table = { fetchedAt: now, models };
+      if (path) {
+        mkdirSync(home, { recursive: true });
+        writeFileSync(path + ".tmp", JSON.stringify({ version: VERSION, ...table }));
+        renameSync(path + ".tmp", path);
+      }
+      return table;
+    } catch {
+      return table;
+    } finally {
+      pending = undefined;
+    }
+  })();
+  return pending;
+}
+
+/**
+ * The table before a model lookup: an empty one waits up to `timeoutMs` for the listing,
+ * a stale one refreshes in the background.
+ */
+export async function ensureGrokModels({ timeoutMs = GROK_MODELS_TIMEOUT_MS, ...options } = {}) {
+  const refresh = refreshGrokModels(options);
+  if (Object.keys(table.models).length > 0) return table;
+  let timer;
+  await Promise.race([refresh, new Promise(resolve => { timer = setTimeout(resolve, timeoutMs); timer.unref?.(); })]);
+  clearTimeout(timer);
+  return table;
+}

package/plugins/grok/status.mjs

@@ -0,0 +1,28 @@
+import { grokAuthState, minutesLeft } from "./auth.mjs";
+import { grokSubscriptionNow, readGrokSubscription } from "./billing.mjs";
+
+// dscode: one snapshot for the two surfaces that show the Grok rail: the /login grok panel and
+// the provider list. The live process value wins; a state file written by another process (a
+// second DSCODE on the same Mac) is the fallback, so a panel opened before the first refresh
+// still shows the last known window.
+
+/**
+ * @returns `{ status: { kind, expiresIn? }, subscription? }`; `kind` is the local login state
+ *   (`ready`, `expired`, `missing`, `malformed`) and `expiresIn` is minutes on a ready login.
+ */
+export function grokStatusSnapshot({ home = process.env.DSH_HOME, now = Date.now() } = {}) {
+  const auth = grokAuthState({ now });
+  const stored = grokSubscriptionNow() ?? (home === undefined ? undefined : readGrokSubscription(home));
+  return {
+    status: { kind: auth.kind, ...auth.kind === "ready" ? { expiresIn: minutesLeft(auth.credential, now) } : {} },
+    ...stored === undefined ? {} : { subscription: stored },
+  };
+}
+
+/** One line for the provider list: the login state, not a key name. */
+export function grokStatusText(snapshot = grokStatusSnapshot()) {
+  if (snapshot.status.kind === "ready") return "grok login detected";
+  if (snapshot.status.kind === "expired") return "grok login expired · run grok login";
+  if (snapshot.status.kind === "malformed") return "grok login file unreadable · run grok login";
+  return "no grok login · run grok login";
+}

package/plugins/grok/wire.mjs

@@ -0,0 +1,268 @@
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, LlmError, QUOTA_EXCEEDED_CODE, isContextWindowExceededError, isQuotaExceededError, textOnlyImageText } from "@deepseek-ai/dsh-llm";
+import { ultraRequest } from "../ultra/policy.mjs";
+import { GROK_EFFORTS } from "./models.mjs";
+
+// dscode: xAI chat completions on the wire. The subscription route speaks plain OpenAI
+// chat completions — structured `tool_calls`, `reasoning_content` deltas and a usage block
+// that reports cache reads and reasoning tokens — so this module is the small, pure half of
+// the adapter: request bodies, SSE payloads and the translation into harness stream chunks.
+
+export const PROVIDER = "grok";
+/** `replayState.response.kind` for responses this adapter produced. */
+export const REPLAY_KIND = "dscode-grok";
+/** DeepSeek-style DSCODE detents, spelled the way xAI accepts them. */
+const WIRE_EFFORT = Object.freeze({ off: "none", minimal: "low", low: "low", medium: "medium", high: "high", xhigh: "xhigh", max: "xhigh", ultra: "xhigh" });
+const NAMES = { off: "Off", minimal: "Minimal", low: "Low", medium: "Medium", high: "High", xhigh: "XHigh", max: "Max", ultra: "Ultra" };
+export const ULTRA_DESCRIPTION = "DSCODE: top reasoning plus deliberate subagent collaboration; higher total token use.";
+
+/** Display metadata for one harness effort id. */
+export function effortInfo(id) {
+  return { id, name: NAMES[id] ?? id, ...id === "ultra" ? { description: ULTRA_DESCRIPTION } : {} };
+}
+
+/** The wire spelling for a harness effort, or undefined when the route cannot express it. */
+export function wireEffort(id) {
+  return WIRE_EFFORT[id];
+}
+
+/** A title needs no deliberation: the lowest detent the model offers. */
+function titleEffort(entry) {
+  const levels = entry?.efforts ?? GROK_EFFORTS;
+  return GROK_EFFORTS.find(level => levels.includes(level)) ?? levels[0];
+}
+
+const textOf = blocks => blocks.filter(block => block.type === "text").map(block => block.text).join("");
+
+/** Image blocks this route cannot send as images degrade to their text handle. */
+function contentText(blocks) {
+  const parts = [];
+  for (const block of blocks) {
+    if (block.type === "text" && block.text.length > 0) parts.push(block.text);
+    else if (block.type === "image") parts.push(textOnlyImageText(block.attachment));
+  }
+  return parts.join("\n");
+}
+
+function serializeAssistant(message) {
+  const text = textOf(message.content);
+  const calls = message.content.filter(block => block.type === "tool-call")
+    .map(block => ({ id: block.id, type: "function", function: { name: block.name, arguments: block.arguments } }));
+  if (text.length === 0 && calls.length === 0) return undefined;
+  return { role: "assistant", content: text, ...calls.length > 0 ? { tool_calls: calls } : {} };
+}
+
+/**
+ * Harness history as chat messages: tool results become `tool` messages, everything else
+ * keeps its role. Reasoning is deliberately not replayed — xAI takes the assistant text and
+ * its tool calls, and replayed thinking buys nothing here.
+ */
+export function serializeMessages(messages, { system } = {}) {
+  const wire = [];
+  if (typeof system === "string" && system.length > 0) wire.push({ role: "system", content: system });
+  for (const message of messages) {
+    if (message.role === "system") {
+      const text = textOf(message.content);
+      if (text.length > 0) wire.push({ role: "system", content: text });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const entry = serializeAssistant(message);
+      if (entry !== undefined) wire.push(entry);
+      continue;
+    }
+    const results = message.content.filter(block => block.type === "tool-result");
+    const parts = contentText(message.content.filter(block => block.type !== "tool-result"));
+    if (parts.length > 0 || results.length === 0) wire.push({ role: "user", content: parts });
+    for (const result of results) wire.push({ role: "tool", tool_call_id: result.toolCallId, content: contentText(result.content) || "(no output)" });
+  }
+  return wire;
+}
+
+/**
+ * The chat-completions body for one harness request.
+ * @param options - harness request; @param context - `{ entry }`, the model entry from the catalog.
+ */
+export function requestBody(options, { entry } = {}) {
+  const effort = options.purpose === "session-title" ? titleEffort(entry) : options.reasoningEffort;
+  const spell = effort === undefined ? undefined : wireEffort(effort);
+  if (effort !== undefined && spell === undefined) throw new LlmError(`Grok does not offer reasoning effort "${effort}"`, "UNSUPPORTED_REASONING_EFFORT");
+  const messages = ultraRequest(options, serializeMessages(options.messages, { system: options.system }));
+  const tools = (options.tools ?? []).filter(tool => tool.name !== "workflow" && tool.name !== "ralph")
+    .map(tool => ({ type: "function", function: { name: tool.name, description: tool.description, parameters: tool.parameters } }));
+  return {
+    model: options.model,
+    messages,
+    stream: true,
+    // The usage block of a streamed response arrives on its own final chunk only when asked.
+    stream_options: { include_usage: true },
+    ...tools.length > 0 ? { tools } : {},
+    ...spell === undefined ? {} : { reasoning_effort: spell },
+    ...options.maxTokens === undefined ? {} : { max_tokens: options.maxTokens },
+    ...options.temperature === undefined ? {} : { temperature: options.temperature },
+    ...options.stop === undefined ? {} : { stop: options.stop },
+  };
+}
+
+/**
+ * Harness failure code for an xAI error.
+ * @param status - HTTP status of a rejected request; undefined for an error inside a 200 stream.
+ * @param error - the provider `error` object (`message`, optional `code`).
+ */
+export function errorCode(status, error) {
+  const code = Number.isInteger(status) ? status : Number(error?.code);
+  const detail = typeof error?.message === "string" ? error.message : "";
+  if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
+  if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+  if (code === 401 || code === 403) return "AUTH";
+  if (code === 402) return QUOTA_EXCEEDED_CODE;
+  if (code === 429) return "RATE_LIMIT";
+  if (code === 408 || code === 504) return "TIMEOUT";
+  if (code >= 500) return "SERVER";
+  if (code >= 400) return "INVALID_REQUEST";
+  return "SERVER";
+}
+
+/** Human-readable message for an xAI error object. */
+export function errorMessage(error, fallback) {
+  return typeof error?.message === "string" && error.message.length > 0 ? error.message : fallback;
+}
+
+/** Retry-After as milliseconds (seconds or an HTTP date), when valid. */
+export function retryAfterMs(value) {
+  if (value === null || value === undefined) return undefined;
+  const delay = /^\d+$/.test(value) ? Number(value) * 1e3 : Date.parse(value) - Date.now();
+  return Number.isFinite(delay) && delay > 0 ? delay : undefined;
+}
+
+/** SSE `data:` payloads from a response body, skipping `:` keep-alive comments. */
+export async function* sseData(body, onActivity) {
+  const decoder = new TextDecoder();
+  let buffer = "", data = [];
+  const lines = function* (final) {
+    let newline;
+    while ((newline = buffer.indexOf("\n")) >= 0 || final && buffer.length > 0) {
+      let line = newline >= 0 ? buffer.slice(0, newline) : buffer;
+      buffer = newline >= 0 ? buffer.slice(newline + 1) : "";
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      if (line === "") {
+        const payload = data.join("\n");
+        if (payload.trim() !== "") yield payload;
+        data = [];
+      } else if (line.startsWith("data:")) data.push(line.slice(line.startsWith("data: ") ? 6 : 5));
+    }
+  };
+  for await (const chunk of body) {
+    onActivity?.();
+    buffer += decoder.decode(chunk, { stream: true });
+    yield* lines(false);
+  }
+  buffer += decoder.decode();
+  yield* lines(true);
+  const tail = data.join("\n");
+  if (tail.trim() !== "") yield tail;
+}
+
+/** Map xAI usage to disjoint harness counts (`prompt_tokens` includes the cache reads). */
+export function mapUsage(usage) {
+  const valid = value => Number.isSafeInteger(value) && value >= 0;
+  const prompt = usage?.prompt_tokens, completion = usage?.completion_tokens;
+  if (!valid(prompt) || !valid(completion)) return undefined;
+  const read = valid(usage.prompt_tokens_details?.cached_tokens) ? usage.prompt_tokens_details.cached_tokens : 0;
+  const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+  return {
+    inputTokens: Math.max(0, prompt - read),
+    outputTokens: completion,
+    totalTokens: prompt + completion,
+    ...read > 0 ? { cacheReadTokens: read } : {},
+    ...valid(reasoning) && reasoning > 0 ? { reasoningTokens: reasoning } : {},
+  };
+}
+
+function closeBlock(block) {
+  if (block.kind === "tool-call") return { type: "tool-call", id: block.callId ?? "", name: block.name ?? "", arguments: block.text };
+  return { type: block.kind, text: block.text };
+}
+
+function finishReason(reason, blocks) {
+  if (reason === "length") return { kind: "max-tokens" };
+  if (reason === "content_filter") return { kind: "error", failure: { message: "xAI stopped the response for content filtering", code: "CONTENT_FILTER" } };
+  if (reason === "tool_calls" || blocks.some(block => block.kind === "tool-call") && (reason === undefined || reason === "stop")) return { kind: "tool-calls" };
+  if (reason === undefined || reason === null || reason === "stop") return blocks.length === 0 ? { kind: "error", failure: { message: "model returned a completed response with no content", code: EMPTY_RESPONSE_CODE } } : { kind: "stop" };
+  return { kind: "error", failure: { message: `model stopped: ${reason}`, code: String(reason).toUpperCase() } };
+}
+
+/**
+ * Translate SSE payloads into harness chunks. Block ends, usage and the finish are held
+ * until `[DONE]`; an error inside the stream throws with its routed code.
+ */
+export async function* translate(payloads, { model }) {
+  let nextIndex = 0, textBlock, reasoningBlock, finish, usage, id;
+  const tools = new Map();
+  const order = [];
+  const open = kind => {
+    const block = { index: nextIndex++, kind, text: "" };
+    order.push(block);
+    return block;
+  };
+  for await (const payload of payloads) {
+    if (payload === "[DONE]") {
+      for (const block of order) yield { type: "block-end", index: block.index, block: closeBlock(block) };
+      if (usage) yield { type: "usage", usage };
+      const reason = finishReason(finish, order);
+      const succeeded = reason.kind === "stop" || reason.kind === "tool-calls" || reason.kind === "max-tokens";
+      yield {
+        type: "finish", reason,
+        ...succeeded ? { replayState: { response: { kind: REPLAY_KIND, version: 1, model, ...id === undefined ? {} : { id } }, blocks: order.map(block => ({ type: block.kind })) } } : {},
+      };
+      return;
+    }
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      throw new LlmError(`malformed xAI stream payload: ${payload.slice(0, 120)}`, "MALFORMED_RESPONSE");
+    }
+    if (chunk?.error) {
+      const status = Number.isInteger(chunk.error.code) ? chunk.error.code : undefined;
+      throw new LlmError(errorMessage(chunk.error, "xAI stream error"), errorCode(undefined, chunk.error), status === undefined ? {} : { status });
+    }
+    if (typeof chunk?.id === "string") id ??= chunk.id;
+    for (const choice of chunk?.choices ?? []) {
+      const delta = choice.delta ?? {};
+      const reasoning = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
+      if (reasoning.length > 0) {
+        if (!reasoningBlock) {
+          reasoningBlock = open("reasoning");
+          yield { type: "block-start", index: reasoningBlock.index, blockType: "reasoning" };
+        }
+        reasoningBlock.text += reasoning;
+        yield { type: "reasoning-delta", index: reasoningBlock.index, text: reasoning };
+      }
+      if (typeof delta.content === "string" && delta.content.length > 0) {
+        if (!textBlock) {
+          textBlock = open("text");
+          yield { type: "block-start", index: textBlock.index, blockType: "text" };
+        }
+        textBlock.text += delta.content;
+        yield { type: "text-delta", index: textBlock.index, text: delta.content };
+      }
+      for (const call of Array.isArray(delta.tool_calls) ? delta.tool_calls : []) {
+        const key = call.index ?? call.id;
+        let block = tools.get(key);
+        if (!block) {
+          block = open("tool-call");
+          tools.set(key, block);
+          yield { type: "block-start", index: block.index, blockType: "tool-call" };
+        }
+        if (typeof call.id === "string" && call.id.length > 0) block.callId = call.id;
+        if (typeof call.function?.name === "string" && call.function.name.length > 0) block.name = call.function.name;
+        const fragment = typeof call.function?.arguments === "string" ? call.function.arguments : "";
+        block.text += fragment;
+        yield { type: "tool-call-delta", index: block.index, id: block.callId ?? "", ...block.name === undefined ? {} : { name: block.name }, argumentsDelta: fragment };
+      }
+      if (typeof choice.finish_reason === "string") finish = choice.finish_reason;
+    }
+    if (chunk?.usage) usage = mapUsage(chunk.usage) ?? usage;
+  }
+  throw new LlmError("xAI stream ended without [DONE]", "TRANSPORT");
+}

package/plugins/i18n/messages.mjs

@@ -40,7 +40,7 @@ export const MESSAGES = {
     'language.set': 'language → {name}', 'language.title': '/language — interface language', 'language.currentMark': 'current', 'language.unknown': 'Unknown language "{value}". Choose en, zh-CN, zh-TW, ja, ko or es.',
     'language.saveFailed': 'language save failed: {error}',
     'doctor.logs.new': 'Only warnings/errors since this TUI version started are recorded.',
-    'footer.current': 'current', 'footer.average': 'average', 'footer.context': 'context', 'footer.cache': 'cache hit', 'composer.placeholder': 'type a message', 'composer.shellMode': '! shell mode · esc exits',
+    'footer.current': 'current', 'footer.average': 'average', 'footer.context': 'context', 'footer.cache': 'cache hit', 'footer.grokUsed': 'used', 'footer.grokResets': 'resets', 'composer.placeholder': 'type a message', 'composer.shellMode': '! shell mode · esc exits',
     'compaction.running': 'Compacting context, please wait', 'compaction.confirm.title': 'Switching to {model} will compact the conversation',
     'compaction.confirm.usage': 'context {used} ≥ compaction threshold {threshold} ({window} × {ratio})', 'compaction.confirm.next': 'the next step compacts older history first',
     'compaction.confirm.overflow': 'it already exceeds the {window} window: the next request compacts and retries', 'compaction.confirm.hint': 'y switch · n/esc back',
@@ -68,7 +68,7 @@ export const MESSAGES = {
     'language.set': '语言 → {name}', 'language.title': '/language — 界面语言', 'language.currentMark': '当前', 'language.unknown': '未知语言 "{value}"。可选 en、zh-CN、zh-TW、ja、ko、es。',
     'language.saveFailed': '语言设置保存失败：{error}',
     'doctor.logs.new': '仅记录新版 TUI 启动后的 warning/error。',
-    'footer.current': '当前', 'footer.average': '平均', 'footer.context': '上下文', 'footer.cache': '缓存命中', 'composer.placeholder': '输入消息', 'composer.shellMode': '! shell 模式 · esc 退出',
+    'footer.current': '当前', 'footer.average': '平均', 'footer.context': '上下文', 'footer.cache': '缓存命中', 'footer.grokUsed': '已用', 'footer.grokResets': '重置', 'composer.placeholder': '输入消息', 'composer.shellMode': '! shell 模式 · esc 退出',
     'compaction.running': '正在压缩上下文，请稍后', 'compaction.confirm.title': '切换到 {model} 会触发自动压缩',
     'compaction.confirm.usage': '当前上下文 {used} ≥ 压缩阈值 {threshold}（{window} × {ratio}）', 'compaction.confirm.next': '下一步开始前会先压缩较早的对话',
     'compaction.confirm.overflow': '已超出新模型的 {window} 上下文窗口：下一次请求会先压缩再重试', 'compaction.confirm.hint': 'y 确认切换 · n/esc 返回',
@@ -96,7 +96,7 @@ export const MESSAGES = {
     'language.set': '語言 → {name}', 'language.title': '/language — 介面語言', 'language.currentMark': '目前', 'language.unknown': '未知語言 "{value}"。可選 en、zh-CN、zh-TW、ja、ko、es。',
     'language.saveFailed': '語言設定儲存失敗：{error}',
     'doctor.logs.new': '僅記錄新版 TUI 啟動後的 warning/error。',
-    'footer.current': '目前', 'footer.average': '平均', 'footer.context': '上下文', 'footer.cache': '快取命中', 'composer.placeholder': '輸入訊息', 'composer.shellMode': '! shell 模式 · esc 離開',
+    'footer.current': '目前', 'footer.average': '平均', 'footer.context': '上下文', 'footer.cache': '快取命中', 'footer.grokUsed': '已用', 'footer.grokResets': '重置', 'composer.placeholder': '輸入訊息', 'composer.shellMode': '! shell 模式 · esc 離開',
     'compaction.running': '正在壓縮上下文，請稍候', 'compaction.confirm.title': '切換到 {model} 會觸發自動壓縮',
     'compaction.confirm.usage': '目前上下文 {used} ≥ 壓縮閾值 {threshold}（{window} × {ratio}）', 'compaction.confirm.next': '下一步開始前會先壓縮較早的對話',
     'compaction.confirm.overflow': '已超出新模型的 {window} 上下文視窗：下一次請求會先壓縮再重試', 'compaction.confirm.hint': 'y 確認切換 · n/esc 返回',
@@ -124,7 +124,7 @@ export const MESSAGES = {
     'language.set': '言語 → {name}', 'language.title': '/language — 表示言語', 'language.currentMark': '現在', 'language.unknown': '不明な言語 "{value}"。en、zh-CN、zh-TW、ja、ko、es から選んでください。',
     'language.saveFailed': '言語設定の保存に失敗しました：{error}',
     'doctor.logs.new': 'この TUI バージョンの起動以降の warning/error のみ記録されています。',
-    'footer.current': '現在', 'footer.average': '平均', 'footer.context': 'コンテキスト', 'footer.cache': 'キャッシュヒット', 'composer.placeholder': 'メッセージを入力', 'composer.shellMode': '! shell モード · esc で終了',
+    'footer.current': '現在', 'footer.average': '平均', 'footer.context': 'コンテキスト', 'footer.cache': 'キャッシュヒット', 'footer.grokUsed': '使用', 'footer.grokResets': 'リセット', 'composer.placeholder': 'メッセージを入力', 'composer.shellMode': '! shell モード · esc で終了',
     'compaction.running': 'コンテキストを圧縮しています。しばらくお待ちください', 'compaction.confirm.title': '{model} に切り替えると自動圧縮が実行されます',
     'compaction.confirm.usage': '現在のコンテキスト {used} ≥ 圧縮しきい値 {threshold}（{window} × {ratio}）', 'compaction.confirm.next': '次のステップの前に古い履歴を圧縮します',
     'compaction.confirm.overflow': '新しいモデルの {window} ウィンドウを超えています。次のリクエストで圧縮して再試行します', 'compaction.confirm.hint': 'y 切り替え · n/esc 戻る',
@@ -152,7 +152,7 @@ export const MESSAGES = {
     'language.set': '언어 → {name}', 'language.title': '/language — 인터페이스 언어', 'language.currentMark': '현재', 'language.unknown': '알 수 없는 언어 "{value}". en, zh-CN, zh-TW, ja, ko, es 중에서 선택하세요.',
     'language.saveFailed': '언어 설정 저장 실패: {error}',
     'doctor.logs.new': '이 TUI 버전 시작 이후의 warning/error만 기록됩니다.',
-    'footer.current': '현재', 'footer.average': '평균', 'footer.context': '컨텍스트', 'footer.cache': '캐시 적중', 'composer.placeholder': '메시지를 입력하세요', 'composer.shellMode': '! shell 모드 · esc 종료',
+    'footer.current': '현재', 'footer.average': '평균', 'footer.context': '컨텍스트', 'footer.cache': '캐시 적중', 'footer.grokUsed': '사용', 'footer.grokResets': '재설정', 'composer.placeholder': '메시지를 입력하세요', 'composer.shellMode': '! shell 모드 · esc 종료',
     'compaction.running': '컨텍스트를 압축하는 중입니다. 잠시만 기다려 주세요', 'compaction.confirm.title': '{model}(으)로 전환하면 자동 압축이 실행됩니다',
     'compaction.confirm.usage': '현재 컨텍스트 {used} ≥ 압축 임계값 {threshold} ({window} × {ratio})', 'compaction.confirm.next': '다음 단계 전에 이전 대화를 먼저 압축합니다',
     'compaction.confirm.overflow': '새 모델의 {window} 창을 이미 넘었습니다. 다음 요청에서 압축한 뒤 재시도합니다', 'compaction.confirm.hint': 'y 전환 · n/esc 뒤로',
@@ -180,7 +180,7 @@ export const MESSAGES = {
     'language.set': 'idioma → {name}', 'language.title': '/language — idioma de la interfaz', 'language.currentMark': 'actual', 'language.unknown': 'Idioma desconocido "{value}". Elige en, zh-CN, zh-TW, ja, ko o es.',
     'language.saveFailed': 'no se pudo guardar el idioma: {error}',
     'doctor.logs.new': 'Solo se registran los warnings/errores desde que arrancó esta versión del TUI.',
-    'footer.current': 'actual', 'footer.average': 'promedio', 'footer.context': 'contexto', 'footer.cache': 'éxitos de caché', 'composer.placeholder': 'escribe un mensaje', 'composer.shellMode': '! modo shell · esc sale',
+    'footer.current': 'actual', 'footer.average': 'promedio', 'footer.context': 'contexto', 'footer.cache': 'éxitos de caché', 'footer.grokUsed': 'usado', 'footer.grokResets': 'reinicia', 'composer.placeholder': 'escribe un mensaje', 'composer.shellMode': '! modo shell · esc sale',
     'compaction.running': 'Compactando el contexto, espera un momento', 'compaction.confirm.title': 'Cambiar a {model} compactará la conversación',
     'compaction.confirm.usage': 'contexto {used} ≥ umbral de compactación {threshold} ({window} × {ratio})', 'compaction.confirm.next': 'el siguiente paso compacta antes el historial antiguo',
     'compaction.confirm.overflow': 'ya supera la ventana de {window}: la siguiente petición compacta y reintenta', 'compaction.confirm.hint': 'y cambiar · n/esc volver',

package/plugins/providers/catalog.mjs

@@ -7,6 +7,8 @@ export const PROVIDERS = Object.freeze([
   { id: 'deepseek-official', name: 'DeepSeek', aliases: ['deepseek', 'deepseek-official', 'official'], credentialRef: 'DEEPSEEK_API_KEY', defaultModel: 'deepseek-flash' },
   // The optional management key reads account data only; it cannot call models.
   { id: 'openrouter', name: 'OpenRouter', aliases: ['openrouter', 'open-router'], credentialRef: 'OPENROUTER_API_KEY', managementRef: 'OPENROUTER_MANAGEMENT_KEY', defaultModel: 'deepseek/deepseek-v4-flash' },
+  // The Grok subscription rail: the token is the local 'grok login', read-only (plugins/grok).
+  { id: 'grok', name: 'Grok', aliases: ['grok', 'xai', 'x-ai'], credentialRef: 'GROK_CLI_TOKEN', defaultModel: 'grok-4.6' },
 ]);
 
 // The pi-ai adapter served OpenRouter until 0.7.6, from this settings section.

package/plugins/session-metrics/view.mjs

@@ -2,6 +2,7 @@ import { readMetrics } from './store.mjs';
 import { t } from '../i18n/messages.mjs';
 import { estimateCost, peakEmoji } from './pricing.mjs';
 import { balanceNow, trustedNow } from './balance.mjs';
+import { grokSubscriptionNow } from '../grok/billing.mjs';
 import { sessionAverageTps } from './rate.mjs';
 import { providerOfHeader } from '../providers/catalog.mjs';
 let source;
@@ -58,6 +59,28 @@ export function displayWidth(text) {
   for (const char of text) width += ZERO_WIDTH.test(char) ? 0 : WIDE.test(char) ? 2 : 1;
   return width;
 }
+/**
+ * The money slot for the Grok subscription rail: a plan has credits and a reset time, not a
+ * bill. The percentage is optional (the server omits it for a period without usage), and an
+ * unread window shows the tier alone instead of a wrong number.
+ */
+export function grokFooterFact(subscription, locale = 'en', now = Date.now()) {
+  const parts = [subscription?.tier ?? 'Grok'];
+  const used = subscription?.usedPercent;
+  if (Number.isFinite(used)) parts.push((Number.isInteger(used) ? String(used) : used.toFixed(1)) + '% ' + t(locale, 'footer.grokUsed'));
+  const reset = resetStamp(subscription?.periodEnd, now);
+  if (reset !== undefined) parts.push(t(locale, 'footer.grokResets') + ' ' + reset);
+  return parts.join(' · ');
+}
+
+/** Local `MM-DD HH:MM` for a reset time, or undefined when the window is unknown or past. */
+function resetStamp(iso, now) {
+  const at = Date.parse(typeof iso === 'string' ? iso : '');
+  if (!Number.isFinite(at) || at <= now) return undefined;
+  const pad = value => String(value).padStart(2, '0');
+  const date = new Date(at);
+  return pad(date.getMonth() + 1) + '-' + pad(date.getDate()) + ' ' + pad(date.getHours()) + ':' + pad(date.getMinutes());
+}
 export function formatFooter(metrics, context, columns = 80, rates, locale = 'en', header = '', provider = providerOfHeader(header) ?? 'deepseek-official') {
   const label = key => t(locale, key);
   const ctx = Number.isFinite(context) ? `${Math.round(context)}%` : '--';
@@ -65,7 +88,7 @@ export function formatFooter(metrics, context, columns = 80, rates, locale = 'en
   // The balance belongs to the provider the header names; only DeepSeek's official route bills by a peak window.
   const balance = balanceNow(provider);
   const spend = metrics.unknown && metrics.cost === 0 ? '--' : `$${metrics.cost.toFixed(2)}${metrics.unknown ? '+' : ''}${metrics.pending ? '…' : ''}`;
-  const dollars = `${spend} / ${balance === null ? '$--' : '$' + balance.toFixed(2)}${provider === 'deepseek-official' ? ' ' + peakEmoji(trustedNow()) : ''}`;
+  const dollars = provider === 'grok' ? grokFooterFact(grokSubscriptionNow(), locale) : `${spend} / ${balance === null ? '$--' : '$' + balance.toFixed(2)}${provider === 'deepseek-official' ? ' ' + peakEmoji(trustedNow()) : ''}`;
   const base = rates ? [
     `${label('footer.current')}: ${Number.isFinite(rates.current) ? '~' + rates.current.toFixed(1) : '--'} tps`,
     `${label('footer.average')}: ${Number.isFinite(rates.average) ? rates.average.toFixed(1) : '--'} tps`,