dsh-plugin-subscriptions 0.2.0 → 0.3.1

package/lib/providers/grok.js

@@ -3,7 +3,7 @@
  * auth.x.ai with the Grok CLI client id, and streaming against the xAI
  * Responses-style endpoint.
  */
-import { attributionHeaders, EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
+import { attributionHeaders, EMPTY_RESPONSE_CODE, errorChain, LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
 import { decodeJwtPayload } from '../auth/jwt.js';
 import { resolveImages } from '../translate/resolved.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
@@ -276,28 +276,110 @@ function grokModalities(id) {
     return /code|embed/i.test(id) ? ['text'] : ['text', 'image'];
 }
 /**
- * The /v1/models list also serves generation models that cannot chat
- * (grok-imagine-image*, grok-imagine-video*) and embedding models; the picker
- * must not offer them. Heuristic over the id substring, verified against the
- * live catalog (grok-build-0.1 and the grok-4 family pass).
+ * The Grok Build CLI chat proxy's model catalog — the only grok endpoint that
+ * advertises reasoning capability. The `api.x.ai/v1/models` and
+ * `/v1/language-models` payloads carry pricing, context, and aliases only, so
+ * effort metadata must come from here (the same source the official CLI's
+ * picker uses).
  */
-function isChatModel(id) {
-    return !/imagine|image-|video|embed/i.test(id);
+export const GROK_CLI_MODELS_URL = 'https://cli-chat-proxy.grok.com/v1/models';
+/** Map one CLI catalog entry's reasoning fields, or undefined when unsupported. */
+function grokCliReasoning(entry) {
+    if (entry.supports_reasoning_effort !== true)
+        return undefined;
+    const efforts = (entry.reasoning_efforts ?? [])
+        .filter(level => typeof level.value === 'string' && level.value.length > 0)
+        .map(level => ({
+        id: ReasoningEffortId(level.value),
+        name: typeof level.label === 'string' && level.label.length > 0 ? level.label : level.value,
+        ...typeof level.description === 'string' && level.description.length > 0
+            ? { description: level.description }
+            : {},
+    }));
+    if (efforts.length === 0)
+        return undefined;
+    // The per-entry `default` flags are unreliable (the live catalog marks
+    // several levels default at once), so the top-level `reasoning_effort`
+    // field is the trusted default.
+    const defaultEffort = typeof entry.reasoning_effort === 'string'
+        && efforts.some(effort => effort.id === ReasoningEffortId(entry.reasoning_effort))
+        ? ReasoningEffortId(entry.reasoning_effort)
+        : undefined;
+    return { efforts, ...defaultEffort === undefined ? {} : { defaultEffort } };
 }
 /**
- * Fetch the live grok model list.
+ * Fetch the CLI catalog and index its per-model metadata by model id.
  * @param session - the stored session (used as-is; never refreshed here).
  * @param fetchFn - fetch implementation (injectable for tests).
- * @returns discovered chat models in endpoint order (id doubles as the name).
+ * @returns model id → contributed metadata.
  */
-export async function fetchGrokModels(session, fetchFn = fetch) {
-    const response = await fetchFn(GROK_MODELS_URL, {
+export async function fetchGrokCliCatalog(session, fetchFn = fetch) {
+    const response = await fetchFn(GROK_CLI_MODELS_URL, {
         headers: {
             'authorization': `Bearer ${session.accessToken}`,
+            // The proxy only honors bearer tokens presented as the Grok CLI.
+            'x-xai-token-auth': 'xai-grok-cli',
             'accept': 'application/json',
             ...attributionHeaders(),
         },
     });
+    if (!response.ok)
+        throw await oauthEndpointError(response, 'grok CLI catalog');
+    const payload = await response.json();
+    if (!Array.isArray(payload.data))
+        throw new Error('grok CLI catalog returned no data array');
+    const catalog = new Map();
+    for (const entry of payload.data) {
+        if (typeof entry.id !== 'string' || entry.id.length === 0)
+            continue;
+        const reasoning = grokCliReasoning(entry);
+        catalog.set(entry.id, {
+            ...typeof entry.name === 'string' && entry.name.length > 0 ? { name: entry.name } : {},
+            ...typeof entry.description === 'string' && entry.description.length > 0
+                ? { description: entry.description }
+                : {},
+            ...typeof entry.context_window === 'number' && entry.context_window > 0
+                ? { contextWindow: entry.context_window }
+                : {},
+            ...reasoning === undefined ? {} : { reasoning },
+        });
+    }
+    return catalog;
+}
+/**
+ * The /v1/models list also serves generation models that cannot chat
+ * (grok-imagine-image*, grok-imagine-video*) and embedding models; the picker
+ * must not offer them. Heuristic over the id substring, verified against the
+ * live catalog (grok-build-0.1 and the grok-4 family pass).
+ */
+function isChatModel(id) {
+    return !/imagine|image-|video|embed/i.test(id);
+}
+/**
+ * Fetch the live grok model list, enriched with the CLI catalog's per-model
+ * metadata (display name, context window, reasoning efforts). The api.x.ai
+ * list stays authoritative for which models exist; the CLI catalog is
+ * enrichment only, so its failure degrades to a plain list instead of taking
+ * discovery down — models it does not cover simply expose no efforts.
+ * @param session - the stored session (used as-is; never refreshed here).
+ * @param fetchFn - fetch implementation (injectable for tests).
+ * @param onWarn - warning sink for a failed CLI catalog fetch.
+ * @returns discovered chat models in endpoint order.
+ */
+export async function fetchGrokModels(session, fetchFn = fetch, onWarn) {
+    const [response, cliCatalog] = await Promise.all([
+        fetchFn(GROK_MODELS_URL, {
+            headers: {
+                'authorization': `Bearer ${session.accessToken}`,
+                'accept': 'application/json',
+                ...attributionHeaders(),
+            },
+        }),
+        fetchGrokCliCatalog(session, fetchFn).catch((error) => {
+            onWarn?.(`grok CLI catalog fetch failed; reasoning efforts are unavailable (${errorChain(error)})`);
+            return undefined;
+        }),
+    ]);
     if (!response.ok)
         throw await oauthEndpointError(response, 'grok models');
     const payload = await response.json();
@@ -311,7 +393,7 @@ export async function fetchGrokModels(session, fetchFn = fetch) {
         if (!isChatModel(entry.id))
             continue;
         seen.add(entry.id);
-        discovered.push({ id: entry.id, name: entry.id });
+        discovered.push({ id: entry.id, name: entry.id, ...cliCatalog?.get(entry.id) });
     }
     // An empty catalog from a 200 response is treated as a discovery failure so
     // the adapter falls back to the static catalog instead of vanishing from
@@ -323,10 +405,15 @@ export async function fetchGrokModels(session, fetchFn = fetch) {
 /** Grok wire adapter: one instance serves the `grok` provider route. */
 export class GrokAdapter extends LlmAdapter {
     options;
-    catalog = new ModelCatalogCache();
+    catalog;
     constructor(options) {
         super();
         this.options = options;
+        this.catalog = new ModelCatalogCache(options.catalogStore);
+    }
+    /** Discovery fetcher: resolves the session through the refresh-aware path. */
+    async fetchCatalog() {
+        return fetchGrokModels(await this.options.tokens.session(), this.options.fetchFn, this.options.onWarn);
     }
     providerInfo(provider) {
         return { id: provider, name: 'Grok (Subscription)' };
@@ -350,11 +437,12 @@ export class GrokAdapter extends LlmAdapter {
             // The fetcher runs only on a cache miss, and resolves the session
             // through the refresh-aware path so an expired access token renews here
             // instead of failing discovery into the static fallback.
-            const discovered = await this.catalog.get(async () => fetchGrokModels(await this.options.tokens.session(), this.options.fetchFn));
+            const discovered = await this.catalog.get(() => this.fetchCatalog());
             return discovered.map(model => ({
                 provider,
                 id: model.id,
                 name: model.name,
+                ...model.description === undefined ? {} : { description: model.description },
                 inputModalities: grokModalities(model.id),
             }));
         }
@@ -370,20 +458,36 @@ export class GrokAdapter extends LlmAdapter {
             return this.staticModels(provider);
         }
     }
-    resolveModel(provider, model) {
-        const discovered = this.options.discovery
-            ? this.catalog.cached()?.find(entry => entry.id === model)
-            : undefined;
+    /**
+     * The discovered entry for one model. Resolved through the cache's
+     * stale-while-revalidate path: capability metadata must stay stable across
+     * a long conversation — a session that selected a reasoning effort calls
+     * this on EVERY step, and forgetting the efforts just because the TTL
+     * lapsed mid-turn would fail the call with UNSUPPORTED_REASONING_EFFORT
+     * before provider I/O.
+     */
+    async discovered(model) {
+        if (!this.options.discovery)
+            return undefined;
+        const models = await this.catalog.resolve(() => this.fetchCatalog());
+        return models?.find(entry => entry.id === model);
+    }
+    async resolveModel(provider, model) {
+        const discovered = await this.discovered(model);
         const configured = this.options.models.find(entry => entry.id === model);
-        return Promise.resolve({
+        return {
             provider,
             id: model,
             name: discovered?.name ?? configured?.name ?? model,
+            ...discovered?.description === undefined ? {} : { description: discovered.description },
             inputModalities: configured?.inputModalities ?? grokModalities(model),
-            context: { contextWindow: configured?.contextWindow ?? GROK_CONTEXT_WINDOW },
+            context: { contextWindow: discovered?.contextWindow ?? configured?.contextWindow ?? GROK_CONTEXT_WINDOW },
             defaultMaxTokens: configured?.maxTokens ?? GROK_DEFAULT_MAX_TOKENS,
-            // No reasoning metadata: effort selection is not exposed for grok.
-        });
+            // Efforts come from the discovered CLI catalog; models it does not
+            // cover expose none, so the harness rejects explicit efforts before
+            // provider I/O instead of the API 400ing.
+            ...discovered?.reasoning === undefined ? {} : { reasoning: discovered.reasoning },
+        };
     }
     async *stream(options) {
         const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
@@ -422,6 +526,11 @@ export class GrokAdapter extends LlmAdapter {
             tool_choice: 'auto',
             parallel_tool_calls: true,
             ...options.maxTokens !== undefined ? { max_output_tokens: options.maxTokens } : {},
+            // The harness only passes an effort the resolved model advertised (the
+            // CLI catalog's), so this never reaches a model that rejects it.
+            ...options.reasoningEffort !== undefined
+                ? { reasoning: { effort: String(options.reasoningEffort) } }
+                : {},
             store: false,
             stream: true,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscriptions",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Use ChatGPT (Codex), Claude, and Grok (X Premium) subscriptions as DeepSeek Harness LLM providers, with OAuth login from the web Settings page",
   "license": "MIT",
   "repository": {
@@ -48,12 +48,6 @@
       ]
     }
   },
-  "scripts": {
-    "build": "tsc && tsdown",
-    "test": "tsc -p tsconfig.test.json && node --test lib-test/test/",
-    "prepare": "tsdown -c tsdown.prepare.config.ts",
-    "prepublishOnly": "pnpm build && pnpm test"
-  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-attachment": "^0.1.0-rc.5",
@@ -81,5 +75,9 @@
     "react": "^18.2.0",
     "tsdown": "^0.15.0",
     "typescript": "^5.8.0"
+  },
+  "scripts": {
+    "build": "tsc && tsdown",
+    "test": "tsc -p tsconfig.test.json && node --test lib-test/test/"
   }
-}
+}