dsh-llm-xai-oauth 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cyjyyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# dsh-llm-xai-oauth
+
+Use a SuperGrok / X Premium subscription as a **native DeepSeek Harness LLM provider**. No xAI API key. Reuses the OAuth tokens already on the machine.
+
+中文：[README.zh.md](README.zh.md)。Companion TUI: [dsh-ssh-tui](https://github.com/cyjyyd/dsh-ssh-tui).
+
+## What this is
+
+DeepSeek Harness already has an official DeepSeek route and a generic `llm-pi-ai` catalog. The catalog can *advertise* `xai`, but it cannot refresh a SuperGrok OAuth token or talk to the Grok subscription proxy. This plugin fills that gap:
+
+- Registers the live `xai` adapter route (`grok-4.6` / `grok-4.5`（订阅实时目录；静态回退仍含 grok-4.3）)
+- Searches `~/.grok-bridge/auth.json`, `~/.grok/auth.json`, and a small set of `~/.config` / `~/.local/share` locations
+- If nothing reusable is found, starts the xAI device-code login on a TTY and writes `~/.grok-bridge/auth.json`
+- Once a usable token exists, sets `agent-default-model` to `xai` / `grok-4.6` unless that section is already on `xai`
+- Refreshes the access token five minutes before expiry
+- Calls `https://cli-chat-proxy.grok.com/v1/chat/completions` with the same Bearer + `x-grok-client-*` headers grok-bridge uses
+- Streams text, reasoning, tool calls, and usage through the same harness seam as DeepSeek official
+
+`/model`, the Models page, and `agent-default-model` then treat Grok like any other provider.
+
+On start the plugin first searches the machine for a reusable token. If none is found and the process has a TTY, it runs the xAI device-code login, then writes `agent-default-model` so dsh uses SuperGrok.
+
+## Install
+
+Requires Node.js ≥ 22.19 and a DeepSeek Harness CLI (`dsh`) that can load profile bundles.
+
+On a remote SSH box, install this next to [dsh-ssh-tui](https://github.com/cyjyyd/dsh-ssh-tui) so `/model` can switch onto SuperGrok without a browser.
+
+```bash
+# any profile: tui / web / headless. The CLI pulls npm.
+dsh plugin --profile tui add dsh-llm-xai-oauth
+dsh plugin --profile web add dsh-llm-xai-oauth
+dsh plugin --profile headless add dsh-llm-xai-oauth
+```
+
+Local checkout:
+
+```bash
+git clone https://github.com/cyjyyd/dsh-llm-xai-oauth.git
+cd dsh-llm-xai-oauth
+bash scripts/install.sh tui
+```
+
+GitHub still works if you want a checkout instead of the registry:
+
+```bash
+dsh plugin --profile tui add github:cyjyyd/dsh-llm-xai-oauth
+```
+
+The bundle patch inserts `id: llm-xai-oauth`. Confirm with:
+
+```bash
+dsh --profile tui --dump-config | grep llm-xai-oauth
+```
+
+## Login
+
+The plugin does this itself when dsh starts:
+
+1. Search the machine for a reusable SuperGrok token (grok-bridge, Grok CLI, then common config dirs).
+2. If none is found and the process has a TTY, print the device-code URL / user code and wait for `auth.x.ai`.
+3. Write `~/.grok-bridge/auth.json` (`0600`) and set `$DSH_HOME/settings.yaml` `agent-default-model` to `xai` / `grok-4.6` if that section is not already on `xai`. A later login always writes the SuperGrok default.
+
+If grok-bridge or the official Grok CLI already logged in, step 1 succeeds and **no browser dance runs**. Headless / CI hosts without a TTY skip the prompt; set `DSH_XAI_OAUTH_NO_LOGIN=1` to skip it even on a TTY.
+
+To log in ahead of time, from a machine that can open `auth.x.ai`:
+
+```bash
+cd dsh-llm-xai-oauth
+npm install
+npm run login
+# force a new device-code even when a token already exists:
+node lib/login.js --force
+```
+
+That starts the xAI device-code flow, writes `~/.grok-bridge/auth.json` (`0600`), and later requests refresh through `https://auth.x.ai/oauth2/token`.
+
+Override client / endpoints only when xAI changes them:
+
+| Env | Default |
+| --- | --- |
+| `GROK_OAUTH_CLIENT_ID` | `b1a00492-073a-47ea-816f-4c329264a828` |
+| `GROK_OAUTH_SCOPE` | `openid profile email offline_access grok-cli:access api:access` |
+| `GROK_OAUTH_BASE` | `https://auth.x.ai` |
+| `GROK_UPSTREAM_BASE` | `https://cli-chat-proxy.grok.com/v1` |
+| `HTTPS_PROXY` | honored for both refresh and chat |
+| `DSH_XAI_OAUTH_NO_LOGIN` | skip the startup device-code prompt |
+| `GROK_BRIDGE_NO_BROWSER` | print the URL instead of opening a browser |
+
+## Use it
+
+```yaml
+# $DSH_HOME/settings.yaml
+agent-default-model:
+  provider: xai
+  model: grok-4.6
+  reasoningEffort: high
+```
+
+Or pick the route at launch / in TUI:
+
+```bash
+dsh --profile tui --provider xai --model grok-4.6
+dsh --profile headless "Reply with exactly: xai-harness-ok. Do not use tools."
+```
+
+The plugin also queries `GET {baseURL}/models` with the SuperGrok OAuth token at startup. The live listing currently returns `grok-4.6` (off / low / medium / high / **xhigh**) and `grok-4.5` (off / low / medium / high). `/model` in dsh-ssh-tui reads that adapter catalog.
+
+Default catalog (advisory; the adapter still accepts a `grok-*` id the proxy serves):
+
+| Model | Context | Output cap | Reasoning efforts |
+| --- | --- | --- | --- |
+| `grok-4.6` | 500K | 64K | off / low / medium / high / xhigh |
+| `grok-4.5` | 500K | 64K | off / low / medium / high |
+| `grok-4.3` | 1M | 30K | off / low / medium / high |
+
+`max` in a DeepSeek-style picker maps to `xhigh`.
+
+Optional plugin settings live under `llm-xai-oauth:` (`baseURL`, `reasoningEffort`, `models`, retry / idle timeout). Change them without restarting; the next request re-resolves.
+
+## What it is not
+
+- Not an xAI API-key provider. Metered `api.x.ai` stays on the generic catalog if you ever add an API key there.
+- Not a Codex / Claude / Copilot aggregator. Those belong in other plugins.
+- Not a Web “one-click login” settings card. Device login is CLI / TTY; token reuse is the point for SSH / headless machines.
+- Does not register `registerConfigurableProviders('xai')`, because `llm-pi-ai` already advertises that catalog key. This package owns the **live adapter route**.
+
+## Layout
+
+```text
+src/index.ts        Cordis plugin: search / login / register the xai route
+src/bootstrap.ts    local token search, device login, dsh default model
+src/discover.ts     bounded home/config token search
+src/login-flow.ts   xAI device-code prompt
+src/dsh-defaults.ts write agent-default-model
+src/adapter.ts      fetch + SSE chat-completions adapter
+src/oauth.ts        load / refresh / device-code
+src/serialize.ts    harness messages → Grok wire body
+src/translate.ts    SSE → harness StreamChunks
+cordis.patch.yml    profile bundle insert
+```
+
+## License
+
+MIT

package/README.zh.md

@@ -0,0 +1,115 @@
+# dsh-llm-xai-oauth
+
+把 SuperGrok / X Premium 订阅接到 DeepSeek Harness，当成**原生 LLM 提供商**用。不需要 xAI API Key。复用本机已经登录过的 OAuth token。
+
+English: [README.md](README.md)。配套 TUI：[dsh-ssh-tui](https://github.com/cyjyyd/dsh-ssh-tui)。
+
+## 它解决什么
+
+Harness 自带 DeepSeek 官方路由，以及通用的 `llm-pi-ai` 目录。目录可以*展示* `xai`，但不能刷新 SuperGrok 的 OAuth token，也不能打 Grok 订阅代理。这个插件补上这一段：
+
+- 注册真正可调用的 `xai` 路由（`grok-4.6` / `grok-4.5`（订阅实时目录；静态回退仍含 grok-4.3））
+- 启动时先搜本机 token：`~/.grok-bridge/auth.json`、`~/.grok/auth.json`，以及 `~/.config` / `~/.local/share` 下常见位置
+- 找不到可用 token 且当前是 TTY 时，走 xAI device-code 登录，写回 `~/.grok-bridge/auth.json`
+- 拿到可用 token 后自动把 `agent-default-model` 设成 `xai` / `grok-4.6`（已经是 `xai` 时不改用户选的 grok 模型和思考强度）
+- 过期前 5 分钟自动 refresh
+- 用和 grok-bridge 相同的 Bearer + `x-grok-client-*` 头调用 `https://cli-chat-proxy.grok.com/v1/chat/completions`
+- 文本、思考、工具调用、usage 走和 DeepSeek 官方一样的 harness 流式协议
+
+之后 `/model`、Models 页、`agent-default-model` 都会把 Grok 当成普通提供商。
+
+刻意做窄：不替换内置 xAI catalog 卡片，不做全订阅登录台，不另建一份 token 仓库。
+
+## 安装
+
+需要 Node.js ≥ 22.19，以及能加载 profile bundle 的 `dsh` CLI。
+
+远程 SSH 机器上请和 [dsh-ssh-tui](https://github.com/cyjyyd/dsh-ssh-tui) 一起装，这样 `/model` 能切到 SuperGrok，不必再走浏览器登录。
+
+```bash
+dsh plugin --profile tui add dsh-llm-xai-oauth
+dsh plugin --profile web add dsh-llm-xai-oauth
+dsh plugin --profile headless add dsh-llm-xai-oauth
+```
+
+本地仓库：
+
+```bash
+git clone https://github.com/cyjyyd/dsh-llm-xai-oauth.git
+cd dsh-llm-xai-oauth
+bash scripts/install.sh tui
+```
+
+仍可用 GitHub 源，不必走 npm：
+
+```bash
+dsh plugin --profile tui add github:cyjyyd/dsh-llm-xai-oauth
+```
+
+bundle patch 会插入 `id: llm-xai-oauth`。确认：
+
+```bash
+dsh --profile tui --dump-config | grep llm-xai-oauth
+```
+
+## 登录
+
+插件启动时自己做这三步：
+
+1. 在本机搜可复用的 SuperGrok token（grok-bridge、Grok CLI，再扫常见 config 目录）。
+2. 找不到、且 stdin/stdout 是 TTY，就打印 device-code 链接和用户码，等 `auth.x.ai` 授权。
+3. 把 token 写到 `~/.grok-bridge/auth.json`（`0600`），并在 `agent-default-model` 还不是 `xai` 时写成 `xai` / `grok-4.6`。新登录会强制写成 SuperGrok 默认。
+
+本机已经用 grok-bridge 或官方 Grok CLI 登录过，第 1 步就会命中，**不会再弹浏览器**。没有 TTY 的 headless / CI 不会提示登录；TTY 上也可以设 `DSH_XAI_OAUTH_NO_LOGIN=1` 跳过。
+
+提前登录（能打开 `auth.x.ai` 的机器上）：
+
+```bash
+cd dsh-llm-xai-oauth
+npm install
+npm run login
+# 即使已有 token 也强制再走一遍 device-code：
+node lib/login.js --force
+```
+
+这会走 xAI device-code，把 token 写到 `~/.grok-bridge/auth.json`（权限 `0600`），之后的请求通过 `https://auth.x.ai/oauth2/token` refresh。
+
+## 使用
+
+```yaml
+# $DSH_HOME/settings.yaml
+agent-default-model:
+  provider: xai
+  model: grok-4.6
+  reasoningEffort: high
+```
+
+或启动时指定：
+
+```bash
+dsh --profile tui --provider xai --model grok-4.6
+dsh --profile headless "Reply with exactly: xai-harness-ok. Do not use tools."
+```
+
+默认目录（仅作选择器展示；代理实际能提供的 `grok-*` 仍可请求）：
+
+| 模型 | 上下文 | 输出上限 | 思考强度 |
+| --- | --- | --- | --- |
+| `grok-4.6` | 500K | 64K | off / low / medium / high / xhigh |
+| `grok-4.5` | 500K | 64K | off / low / medium / high |
+| `grok-4.3` | 1M | 30K | off / low / medium / high |
+
+DeepSeek 风格选择器里的 `max` 会映射成 `xhigh`。
+
+可选配置在 `llm-xai-oauth:`（`baseURL`、`reasoningEffort`、`models`、重试 / 空闲超时）。改完不用重启，下一次请求再生效。
+
+## 它不是什么
+
+- 不是 xAI API Key 提供商。计量接口 `api.x.ai` 仍走通用 catalog。
+- 不是 Codex / Claude / Copilot 聚合器。
+- 不是 Web「一键登录」设置页。TTY device login + 复用本机 token，是给 SSH / headless 用的。
+- 不会 `registerConfigurableProviders('xai')`，因为 `llm-pi-ai` 已经占用了这个目录名。本包只拥有**实际调用路由**。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# First-class xAI/Grok OAuth provider. Registers the `xai` LLM route so
+# `/model`, the Models page, and agent-default-model can select Grok the
+# same way they select DeepSeek official.
+- insert:
+    - id: llm-xai-oauth
+      name: dsh-llm-xai-oauth

package/lib/adapter.js

@@ -0,0 +1,379 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/**
+ * Direct-fetch xAI/Grok adapter. Connection facts and the OAuth access token
+ * resolve once per request, matching dsh-llm-deepseek so configuration and
+ * token refresh reach the next call without a restart.
+ */
+import { attributionHeaders, contentHasImage, CONTEXT_WINDOW_EXCEEDED_CODE, isContextWindowExceededError, isQuotaExceededError, LlmAdapter, LlmError, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { idleWatchdog, timeoutOf } from '@deepseek-ai/dsh-timeout';
+import { fetch as undiciFetch } from 'undici';
+import { serializeRequest } from './serialize.js';
+import { parseSse } from './sse.js';
+import { translate } from './translate.js';
+import { proxyDispatcher } from './oauth.js';
+export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300_000;
+export const DEFAULT_CONTEXT_WINDOW = 500_000;
+export const DEFAULT_MAX_TOKENS = 64_000;
+const STREAM_IDLE_TIMEOUT_CODE = 'LLM_STREAM_IDLE_TIMEOUT';
+const EFFORT_NAMES = {
+    off: 'Off',
+    low: 'Low',
+    medium: 'Medium',
+    high: 'High',
+    xhigh: 'Extra high',
+};
+function modelInfo(provider, model) {
+    return {
+        provider,
+        id: model.id,
+        name: model.name ?? model.id,
+        ...model.description === undefined ? {} : { description: model.description },
+        inputModalities: [...(model.inputModalities ?? ['text'])],
+    };
+}
+const KNOWN_EFFORTS = new Set(['off', 'low', 'medium', 'high', 'xhigh']);
+function asEffort(value) {
+    return typeof value === 'string' && KNOWN_EFFORTS.has(value)
+        ? value
+        : undefined;
+}
+function numberField(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function stringField(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+}
+/** Parse one SuperGrok / OpenAI-compatible model listing into a catalog entry. */
+export function catalogModelFromListing(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    const id = stringField(record.id) ?? stringField(record.model);
+    if (id === undefined)
+        return undefined;
+    const effortsRaw = Array.isArray(record.reasoning_efforts) ? record.reasoning_efforts : [];
+    const efforts = [];
+    let listedDefault;
+    for (const item of effortsRaw) {
+        if (typeof item === 'string') {
+            const effort = asEffort(item);
+            if (effort !== undefined && !efforts.includes(effort))
+                efforts.push(effort);
+            continue;
+        }
+        if (item === null || typeof item !== 'object')
+            continue;
+        const entry = item;
+        const effort = asEffort(entry.id) ?? asEffort(entry.value);
+        if (effort === undefined)
+            continue;
+        if (!efforts.includes(effort))
+            efforts.push(effort);
+        if (entry.default === true)
+            listedDefault = effort;
+    }
+    if (efforts.length > 0 && !efforts.includes('off'))
+        efforts.unshift('off');
+    const defaultEffort = listedDefault
+        ?? asEffort(record.reasoning_effort)
+        ?? (efforts.includes('high') ? 'high' : efforts.find(effort => effort !== 'off'));
+    return {
+        id,
+        ...stringField(record.name) === undefined ? {} : { name: stringField(record.name) },
+        ...stringField(record.description) === undefined ? {} : { description: stringField(record.description) },
+        ...numberField(record.context_window) === undefined ? {} : { contextWindow: numberField(record.context_window) },
+        ...numberField(record.max_tokens) === undefined && numberField(record.max_output_tokens) === undefined
+            ? {}
+            : { maxTokens: numberField(record.max_tokens) ?? numberField(record.max_output_tokens) },
+        inputModalities: ['text', 'image'],
+        ...efforts.length === 0 ? {} : { reasoningEfforts: efforts },
+        ...defaultEffort === undefined ? {} : { defaultEffort },
+    };
+}
+/** Merge a live `/models` listing over the static fallback catalog. */
+export function mergeXaiCatalog(fallback, listed) {
+    if (listed.length === 0)
+        return [...fallback];
+    const byId = new Map();
+    for (const model of listed)
+        byId.set(model.id, model);
+    for (const model of fallback) {
+        const live = byId.get(model.id);
+        if (live === undefined)
+            continue;
+        byId.set(model.id, {
+            ...model,
+            ...live,
+            reasoningEfforts: live.reasoningEfforts ?? model.reasoningEfforts,
+            defaultEffort: live.defaultEffort ?? model.defaultEffort,
+            contextWindow: live.contextWindow ?? model.contextWindow,
+            maxTokens: live.maxTokens ?? model.maxTokens,
+            name: live.name ?? model.name,
+        });
+    }
+    return [...byId.values()];
+}
+function collectImageRefs(blocks, refs) {
+    for (const block of blocks) {
+        if (block.type === 'image')
+            refs.set(block.attachment.attachmentId, block.attachment);
+        else if (block.type === 'tool-result')
+            collectImageRefs(block.content, refs);
+    }
+}
+function providerRetryAfterMs(value) {
+    if (value === null)
+        return undefined;
+    if (/^\d+$/.test(value)) {
+        const delay = Number(value) * 1_000;
+        return Number.isFinite(delay) && delay > 0 ? delay : undefined;
+    }
+    const delay = Date.parse(value) - Date.now();
+    return Number.isFinite(delay) && delay > 0 ? delay : undefined;
+}
+function requestId(headers) {
+    const value = headers.get('x-request-id') ?? headers.get('x-grok-request-id');
+    return value === null || value.length === 0 ? undefined : ProviderRequestId(value);
+}
+export function httpErrorCode(status, error) {
+    if (status === 401 || status === 403)
+        return 'AUTH';
+    const detail = [error?.code, error?.type, error?.message].filter(Boolean).join(' ');
+    if (isQuotaExceededError(detail))
+        return QUOTA_EXCEEDED_CODE;
+    if (status === 429)
+        return 'RATE_LIMIT';
+    if (status === 400) {
+        if (isContextWindowExceededError(detail))
+            return CONTEXT_WINDOW_EXCEEDED_CODE;
+        return 'INVALID_REQUEST';
+    }
+    if (status >= 500)
+        return 'SERVER';
+    return `HTTP_${status}`;
+}
+export class XaiAdapter extends LlmAdapter {
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    providerInfo(provider) {
+        return { id: provider, name: 'xAI (Grok OAuth)' };
+    }
+    providerRetryPolicy(_provider) {
+        return this.config.options().retryPolicy;
+    }
+    catalog() {
+        const live = this.config.liveCatalog?.();
+        const fallback = this.config.options().models;
+        return live === undefined || live.length === 0 ? fallback : live;
+    }
+    listModels(provider) {
+        return Promise.resolve(this.catalog().map(model => modelInfo(provider, model)));
+    }
+    resolveModel(provider, model, _signal) {
+        const connection = this.config.options();
+        const configured = this.catalog().find(entry => entry.id === model);
+        const contextWindow = configured?.contextWindow ?? connection.defaultContextWindow;
+        const efforts = configured?.reasoningEfforts ?? ['off', 'low', 'medium', 'high', 'xhigh'];
+        const defaultEffort = configured?.defaultEffort
+            ?? connection.defaults.reasoningEffort
+            ?? 'high';
+        const selected = efforts.includes(defaultEffort) ? defaultEffort : efforts[0];
+        return Promise.resolve({
+            ...configured === undefined
+                ? { provider, id: model, name: model, inputModalities: ['text', 'image'] }
+                : modelInfo(provider, configured),
+            context: { contextWindow },
+            defaultMaxTokens: configured?.maxTokens ?? connection.maxTokens,
+            reasoning: {
+                efforts: efforts.map(id => ({ id: ReasoningEffortId(id), name: EFFORT_NAMES[id] ?? id })),
+                ...selected === undefined ? {} : { defaultEffort: ReasoningEffortId(selected) },
+            },
+        });
+    }
+    async *stream(options) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const connection = this.config.options();
+            const accessToken = await this.config.resolveAccessToken(connection);
+            const consumer = new AbortController();
+            const upstream = options.signal === undefined
+                ? consumer.signal
+                : AbortSignal.any([options.signal, consumer.signal]);
+            const watchdog = __addDisposableResource(env_1, idleWatchdog(upstream, connection.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE), false);
+            const images = await this.resolveImages(options, connection);
+            const iterator = this.request(options, watchdog.signal, connection, accessToken, images, () => { watchdog.pulse(); })[Symbol.asyncIterator]();
+            let exhausted = false;
+            try {
+                while (true) {
+                    const result = await watchdog.next(iterator);
+                    if (result.done) {
+                        exhausted = true;
+                        return;
+                    }
+                    yield result.value;
+                }
+            }
+            catch (error) {
+                if (timeoutOf(watchdog.signal, STREAM_IDLE_TIMEOUT_CODE) !== undefined) {
+                    throw new LlmError(`xAI stream idle timeout after ${connection.streamIdleTimeoutMs}ms`, 'TIMEOUT', { cause: error });
+                }
+                if (options.signal?.aborted) {
+                    throw new LlmError('xAI request aborted by caller', 'ABORTED', { cause: error });
+                }
+                if (error instanceof LlmError)
+                    throw error;
+                throw new LlmError(`xAI API stream from ${connection.baseURL} failed`, 'TRANSPORT', { cause: error });
+            }
+            finally {
+                consumer.abort('xAI stream consumer stopped');
+                if (!exhausted && iterator.return !== undefined) {
+                    try {
+                        await iterator.return();
+                    }
+                    catch {
+                        // The consumer controller already owns termination.
+                    }
+                }
+            }
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    async resolveImages(options, connection) {
+        const hasImage = options.messages.some(message => contentHasImage(message.content));
+        if (!hasImage)
+            return new Map();
+        const configured = connection.models.find(entry => entry.id === options.model);
+        const modalities = configured?.inputModalities ?? ['text', 'image'];
+        if (!modalities.includes('image')) {
+            throw new LlmError(`xAI model "${options.model}" does not support image input`, 'UNSUPPORTED_CONTENT');
+        }
+        const attachments = this.config.resolveAttachments?.();
+        if (attachments === undefined) {
+            throw new LlmError('xAI image input requires the durable attachment service', 'UNSUPPORTED_CONTENT');
+        }
+        const refs = new Map();
+        for (const message of options.messages)
+            collectImageRefs(message.content, refs);
+        const images = new Map();
+        for (const ref of refs.values()) {
+            const stored = await attachments.readImage(ref, options.signal);
+            images.set(ref.attachmentId, Buffer.from(stored.data).toString('base64'));
+        }
+        return images;
+    }
+    async *request(options, signal, connection, accessToken, images, onComment) {
+        const body = serializeRequest(options, connection.defaults, images);
+        const payload = JSON.stringify(body);
+        const headers = {
+            authorization: `Bearer ${accessToken}`,
+            'content-type': 'application/json',
+            accept: 'text/event-stream',
+            'x-grok-client-version': connection.clientVersion,
+            'x-grok-client-mode': connection.clientMode,
+            ...attributionHeaders(),
+            ...options.sessionId !== undefined
+                ? { 'x-deepseek-harness-session-id': String(options.sessionId) }
+                : {},
+        };
+        const dispatcher = proxyDispatcher();
+        let response;
+        try {
+            response = await undiciFetch(`${connection.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers,
+                body: payload,
+                signal,
+                ...dispatcher === undefined ? {} : { dispatcher },
+            });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            throw new LlmError(`xAI API request to ${connection.baseURL} failed`, 'TRANSPORT', { cause: error });
+        }
+        if (!response.ok) {
+            let message = `xAI API error (HTTP ${response.status})`;
+            let providerError;
+            try {
+                const parsed = await response.json();
+                providerError = parsed.error;
+                if (providerError?.message)
+                    message = providerError.message;
+            }
+            catch {
+                // Keep the HTTP status as the failure identity.
+            }
+            const delay = providerRetryAfterMs(response.headers.get('retry-after'));
+            const id = requestId(response.headers);
+            throw new LlmError(message, httpErrorCode(response.status, providerError), {
+                status: response.status,
+                ...delay === undefined ? {} : { providerRetryAfterMs: delay },
+                ...id === undefined ? {} : { requestId: id },
+            });
+        }
+        if (!response.body)
+            throw new LlmError('xAI API returned no response body', 'EMPTY_RESPONSE');
+        yield* translate(parseSse(response.body, onComment));
+    }
+}
+//# sourceMappingURL=adapter.js.map