dsh-plugin-subscription-oauth 0.8.13 → 0.8.15

package/lib/providers/kimi.js

@@ -15,6 +15,9 @@ import { streamProviderResponses, accountPoolHooks } from './responses-stream.js
 import { fallbackEntry, findEntry, resolveCatalog } from './catalog.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
 import { prepareMoonshotTool } from '../translate/moonshot-schema.js';
+import { isImageModel, isFastVariant, baseModelOf, FastVariantIndex } from './grok.js';
+/** Model ids that are clearly not chat models. */
+const NON_CHAT_ID = /(?:^|[-_/])(?:image|video|imagine|embed|embedding|whisper|tts|vision-only)/i;
 /**
  * Coerce one decoded credential entry into a Kimi session.
  * @param value - decoded JSON value for one account.
@@ -129,6 +132,16 @@ export class KimiAdapter extends LlmAdapter {
     options;
     /** Live catalog ids seen this session, used to accept renamed models. */
     discovered;
+    /** Image-generation model id, when discovery reported one. */
+    imageModel;
+    /**
+     * Fast-variant wire id per picker row, for the composer's quick-mode button.
+     *
+     * Seeded from the curated aliases — `kimi-for-coding-highspeed` is one — so the button
+     * exists before any discovery run, and then updated from the live catalog, which is
+     * the authority on what this account actually serves.
+     */
+    fastVariants = new FastVariantIndex();
     /** Ids the user added by hand, cached so the sync catalog can name them. */
     userAddedIds = [];
     /** Tools already reported as flattened, so each is stated once. */
@@ -136,6 +149,28 @@ export class KimiAdapter extends LlmAdapter {
     constructor(options) {
         super();
         this.options = options;
+        this.seedCuratedFastVariants();
+    }
+    /**
+     * Record the fast variants the curated catalog already names as aliases.
+     *
+     * The alias is the recognition: `kimi-for-coding-highspeed` is stated as an accepted
+     * id of `kimi-for-coding`, so the route can offer the quick-mode button without
+     * waiting for a live list that may never name it. A row a live catalog already paired
+     * keeps that pairing, so this only fills the gaps.
+     */
+    seedCuratedFastVariants() {
+        for (const entry of KIMI_MODELS) {
+            for (const alias of entry.aliases ?? []) {
+                // Every alias of one row maps back to that row, so a variant whose own prefix
+                // names another alias (`kimi-k2.7-code-highspeed`) still pairs with the row.
+                this.fastVariants.note(alias, (base) => this.entryFor(base)?.id ?? base);
+            }
+        }
+    }
+    /** The fast pair one picker id belongs to, from either side. */
+    fastPairOf(id) {
+        return this.fastVariants.pairOf(id);
     }
     /**
      * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
@@ -171,13 +206,33 @@ export class KimiAdapter extends LlmAdapter {
             return [];
         await this.syncUserModels();
         const hidden = await this.hidden();
-        return resolveCatalog(this.catalog(), [], hidden).entries.map((entry) => ({
-            provider: KIMI_PROVIDER_ID,
-            id: entry.id,
-            name: entry.name,
-            ...entry.description === undefined ? {} : { description: entry.description },
-            ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
-        }));
+        // A fast variant is not a picker row, but the host validates a GUI selection
+        // against the exact list `listModels` returns, so the variant must appear there
+        // or selecting it is refused with `session/model-unavailable`. The picker's
+        // menu collapses entries that share one `group` value into a single choice,
+        // so the variant rides with its base id as the group: the host can name and
+        // select it, and the picker still shows one row per model.
+        const imageless = this.catalog().filter((entry) => !isImageModel(entry.id));
+        const listed = resolveCatalog(imageless, [], hidden).entries.flatMap((entry) => {
+            const fast = this.fastVariants.variantOf(entry.id);
+            const base = {
+                provider: KIMI_PROVIDER_ID,
+                id: entry.id,
+                name: entry.name,
+                ...entry.description === undefined ? {} : { description: entry.description },
+                ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
+            };
+            return fast === undefined ? [base] : [base, { provider: KIMI_PROVIDER_ID, id: fast, name: entry.name, group: entry.id, description: 'Fast variant', ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities } }];
+        });
+        return listed;
+    }
+    /** The image-generation model id, when discovery reported one. */
+    imageModelId() {
+        return this.imageModel;
+    }
+    /** The fast/lightspeed variant wire id for a picker row. */
+    fastVariant(baseId) {
+        return this.fastVariants.variantOf(baseId);
     }
     /** The ids the picker must currently omit. */
     async hidden() {
@@ -211,9 +266,13 @@ export class KimiAdapter extends LlmAdapter {
             };
         }
         const reasoning = reasoningInfo(entry);
+        // A fast variant is a wire id of its own — the button switches to it and back, so the
+        // selection must keep that id — while an ordinary alias is just another spelling of
+        // the row and resolves onto it.
+        const pair = this.fastVariants.pairOf(model);
         return {
             provider: KIMI_PROVIDER_ID,
-            id: entry.id,
+            id: pair !== undefined && pair.wireId === model ? model : entry.id,
             name: entry.name,
             ...entry.description === undefined ? {} : { description: entry.description },
             ...entry.inputModalities === undefined ? {} : { inputModalities: entry.inputModalities },
@@ -414,9 +473,30 @@ export class KimiAdapter extends LlmAdapter {
                 return undefined;
             }
             const payload = await response.json();
-            const ids = (payload.data ?? [])
+            const allIds = (payload.data ?? [])
                 .map((entry) => entry.id)
                 .filter((id) => typeof id === 'string' && id.length > 0);
+            // Image models are never picker rows: they are agent-called, always on.
+            this.imageModel = allIds.find((id) => isImageModel(id));
+            // Fast/lightspeed variants ride with their base row: they share the row's
+            // visibility switch and are reached by the composer's quick-mode button, not a
+            // separate row. The live list is the authority on what this account serves, so
+            // it is recorded first, and each variant pairs with the longest listed prefix
+            // of its own name — a provider that names its variants after the base model
+            // pairs them with no curated map at all.
+            this.fastVariants.clear();
+            for (const id of allIds) {
+                this.fastVariants.noteListed(id);
+            }
+            for (const id of allIds) {
+                const base = this.fastVariants.pair(id);
+                this.fastVariants.note(id, () => base ?? this.entryFor(baseModelOf(id))?.id ?? baseModelOf(id));
+            }
+            this.seedCuratedFastVariants();
+            const ids = allIds
+                .filter((id) => !NON_CHAT_ID.test(id))
+                .map((id) => (isFastVariant(id) ? this.fastVariants.pair(id) ?? baseModelOf(id) : id))
+                .filter((id, index, list) => list.indexOf(id) === index);
             if (ids.length === 0) {
                 this.options.onWarn?.('Kimi model discovery returned an empty catalog; using the built-in catalog');
                 return undefined;

package/lib/translate/antigravity.js

@@ -25,7 +25,7 @@ import { parseSse } from './sse.js';
 export function antigravityReasoning(model) {
     const ids = model.startsWith('claude-') ? ['high']
         : model.startsWith('gpt-oss-') ? ['medium']
-            : model.startsWith('gemini-3.1-pro') || model === 'gemini-pro-agent' ? ['low', 'high']
+            : model.startsWith('gemini-3.1-pro') || model === 'gemini-pro' || model === 'gemini-pro-agent' ? ['low', 'high']
                 : /^gemini-(?:2\.5|3)/.test(model) ? ['low', 'medium', 'high'] : [];
     const fixed = /^gemini-.*-(low|medium|high)$/.exec(model)?.[1];
     const efforts = fixed !== undefined && ids.includes(fixed) ? [fixed] : ids;
@@ -59,10 +59,10 @@ export function antigravityThinking(model, effort, maxTokens) {
         budget = 1024;
     else if (model.startsWith('gpt-oss-'))
         budget = 8192;
-    else if (model.startsWith('gemini-3.1-pro') || model === 'gemini-pro-agent') {
+    else if (model.startsWith('gemini-3.1-pro') || model === 'gemini-pro' || model === 'gemini-pro-agent') {
         budget = effort === 'high' ? 10001 : 1001;
     }
-    else if (model.startsWith('gemini-3.5-flash') || model === 'gemini-3-flash-agent') {
+    else if (model.startsWith('gemini-3.5-flash') || model === 'gemini-3-flash' || model === 'gemini-3-flash-agent') {
         budget = effort === 'high' ? 10000 : effort === 'medium' ? 4000 : 1000;
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.8.13",
+  "version": "0.8.15",
   "description": "Use subscription accounts as DeepSeek Harness LLM providers — Kimi Code (OAuth device flow), Grok / X Premium (OIDC + PKCE), Google Antigravity (Google OAuth + Cloud Code Assist) and GLM / BigModel (ZCode's browser sign-in) — with per-model visibility, drag-to-reorder Auto fallback and plan quotas from the web Settings page",
   "license": "MIT",
   "author": "EricFL1998",