dsh-plugin-subscription-oauth 0.6.0 → 0.7.0

package/lib/auth/ccswitch.d.ts

@@ -24,13 +24,38 @@ export interface CcSwitchBalance {
     /** Whether the account reports itself as usable. */
     available: boolean;
 }
+/**
+ * Query the balance endpoint some OpenAI-compatible providers expose at `{base}/v1/usage`.
+ *
+ * huanling is one: it answers `GET {base}/v1/usage` with `{ remaining, unit, … }`, which is
+ * the figure cc-switch shows for it. This is the provider's own shape, not cc-switch's
+ * `balance_infos`, so it is read separately. The base has any trailing `/v1` stripped before
+ * the path is added, so both `https://api.huanling.icu` and `https://api.huanling.icu/v1`
+ * resolve to the same `{base}/v1/usage`.
+ *
+ * @param input - the provider's API key and base URL.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export declare function queryUsageBalance(input: {
+    apiKey: string;
+    baseUrl: string;
+    fetchFn?: FetchFn;
+}): Promise<CcSwitchBalance | undefined>;
 /**
  * Query one provider's balance the way cc-switch does.
  *
- * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * cc-switch reads a DeepSeek-compatible provider's balance with `GET <base>/user/balance`
+ * and a bearer API key. For the official DeepSeek that base is `api.deepseek.com`, so the
+ * path is effectively hardcoded there; for a provider the user added through a custom
+ * endpoint (like huanling), the same path is read against that provider's own base URL,
+ * which is the only place its balance can live.
+ *
+ * @param input - the provider's API key and base URL.
  * @returns the balance, or undefined when the provider did not answer with one.
  */
 export declare function queryCcSwitchBalance(input: {
     apiKey: string;
+    /** The provider's own base URL; `https://api.deepseek.com` for the official one. */
+    baseUrl: string;
     fetchFn?: FetchFn;
 }): Promise<CcSwitchBalance | undefined>;

package/lib/auth/ccswitch.js

@@ -23,18 +23,75 @@ function num(value) {
         return value.trim();
     return undefined;
 }
+/**
+ * Query the balance endpoint some OpenAI-compatible providers expose at `{base}/v1/usage`.
+ *
+ * huanling is one: it answers `GET {base}/v1/usage` with `{ remaining, unit, … }`, which is
+ * the figure cc-switch shows for it. This is the provider's own shape, not cc-switch's
+ * `balance_infos`, so it is read separately. The base has any trailing `/v1` stripped before
+ * the path is added, so both `https://api.huanling.icu` and `https://api.huanling.icu/v1`
+ * resolve to the same `{base}/v1/usage`.
+ *
+ * @param input - the provider's API key and base URL.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export async function queryUsageBalance(input) {
+    const fetchFn = input.fetchFn ?? proxiedFetch;
+    const base = input.baseUrl.replace(/\/+$/, '').replace(/\/v1$/i, '');
+    const url = `${base}/v1/usage`;
+    let response;
+    try {
+        response = await fetchFn(url, {
+            headers: { authorization: `Bearer ${input.apiKey}`, accept: 'application/json' },
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch {
+        return undefined;
+    }
+    if (!response.ok)
+        return undefined;
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof payload !== 'object' || payload === null)
+        return undefined;
+    const record = payload;
+    const total = num(record.remaining);
+    if (total === undefined)
+        return undefined;
+    const currency = typeof record.unit === 'string' && record.unit.trim() !== '' ? record.unit.trim() : 'USD';
+    return {
+        currency,
+        total,
+        available: record.isValid !== false && record.is_active !== false,
+    };
+}
 /**
  * Query one provider's balance the way cc-switch does.
  *
- * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * cc-switch reads a DeepSeek-compatible provider's balance with `GET <base>/user/balance`
+ * and a bearer API key. For the official DeepSeek that base is `api.deepseek.com`, so the
+ * path is effectively hardcoded there; for a provider the user added through a custom
+ * endpoint (like huanling), the same path is read against that provider's own base URL,
+ * which is the only place its balance can live.
+ *
+ * @param input - the provider's API key and base URL.
  * @returns the balance, or undefined when the provider did not answer with one.
  */
 export async function queryCcSwitchBalance(input) {
     const fetchFn = input.fetchFn ?? proxiedFetch;
+    // Resolve `<base>/user/balance` without doubling or dropping the path: a base that
+    // already ends in `/v1` keeps it, since that is the path the OpenAI-compatible wire
+    // uses and the balance endpoint lives beside it.
+    const url = `${input.baseUrl.replace(/\/+$/, '')}/user/balance`;
     let response;
     try {
-        // cc-switch's exact request shape: hardcoded URL, bearer auth, 15 s timeout.
-        response = await fetchFn('https://api.deepseek.com/user/balance', {
+        response = await fetchFn(url, {
             headers: { authorization: `Bearer ${input.apiKey}`, accept: 'application/json' },
             signal: AbortSignal.timeout(15_000),
         });

package/lib/auth/rpc.d.ts

@@ -16,6 +16,8 @@ export type CredentialResolver = (ref: string) => Promise<string | undefined>;
 export interface BalanceContext {
     /** The credential reference each provider id's balance query uses. */
     readonly credentialRefs: Readonly<Record<string, string>>;
+    /** The base URL each provider id's balance query reads, when it is not DeepSeek's own. */
+    readonly baseUrls: Readonly<Record<string, string>>;
     /** Resolve one credential reference to its key. */
     readonly resolveCredential?: CredentialResolver;
     /**

package/lib/auth/rpc.js

@@ -1,5 +1,5 @@
 import { BAD_REQUEST, ProviderError } from '../errors.js';
-import { queryCcSwitchBalance } from './ccswitch.js';
+import { queryCcSwitchBalance, queryUsageBalance } from './ccswitch.js';
 import { readDeepSeekBalance } from './deepseek-balance.js';
 import { RPC_ENDPOINTS, RPC_PREFIX } from '../protocol.js';
 /** Wrap a value as a successful envelope result. */
@@ -165,11 +165,12 @@ async function runEndpoint(registry, endpoint, payload, balance) {
             return await readDeepSeekBalance(balance?.resolveDeepSeekAccount?.(), client);
         }
         case 'ccswitch-balance': {
-            // A non-subscription provider's balance, by cc-switch's query. The caller names
-            // the provider; the configured map turns that into the credential reference the
-            // provider's profile uses, and the host's credential service resolves it. No
-            // entry, no key, or a key the provider does not answer for means no balance —
-            // never a fabricated zero.
+            // A non-subscription provider's balance, by cc-switch's query against the provider's
+            // own base URL. The caller names the provider; the configured map turns that into
+            // the credential reference the provider's profile uses and the base URL that profile
+            // connects to, and the host's credential service resolves the reference. No entry,
+            // no key, or a key the provider does not answer for means no balance — never a
+            // fabricated zero.
             const provider = requiredProvider(payload, endpoint);
             const credentialRef = balance?.credentialRefs[provider];
             if (credentialRef === undefined || balance?.resolveCredential === undefined)
@@ -177,7 +178,12 @@ async function runEndpoint(registry, endpoint, payload, balance) {
             const apiKey = await balance.resolveCredential(credentialRef);
             if (apiKey === undefined)
                 return undefined;
-            return await queryCcSwitchBalance({ apiKey });
+            const baseUrl = balance?.baseUrls[provider] ?? 'https://api.deepseek.com';
+            // A provider that answers the OpenAI-compatible `/v1/usage` (the shape cc-switch's
+            // custom template reads, `{ remaining, unit }`) is asked that first; one that
+            // answers the DeepSeek `balance_infos` shape is asked that as a fallback.
+            return await queryUsageBalance({ apiKey, baseUrl })
+                ?? await queryCcSwitchBalance({ apiKey, baseUrl });
         }
         case 'reload':
             return registry.reload();

package/lib/index.d.ts

@@ -45,16 +45,22 @@ export interface Config {
      */
     auto?: boolean;
     /**
-     * The credential reference a non-subscription provider's balance query uses, by
-     * provider id.
+     * The balance source a non-subscription provider uses, by provider id.
      *
      * A provider that is not a subscription this plugin serves has no usage windows to
      * meter, so the chip shows its balance instead — read by cc-switch's query, which needs
-     * the provider's API key. The provider's profile names that key by reference
-     * (`apiKeyEnv`), and the host's credential service resolves the name; this map is the
-     * one place a provider id is tied to that reference. A provider with no entry, or
-     * whose key does not resolve, gets no balance and the chip stays silent.
+     * the provider's API key and its own base URL (the balance endpoint lives beside the
+     * provider's OpenAI-compatible wire, not on DeepSeek's). Each entry names the
+     * credential reference the provider's profile uses (`apiKeyEnv`) and the base URL that
+     * profile connects to; the host's credential service resolves the reference. A provider
+     * with no entry, or whose key does not resolve, gets no balance and the chip stays
+     * silent.
      */
+    balanceSources?: Record<string, {
+        credentialRef: string;
+        baseUrl: string;
+    }>;
+    /** @deprecated Use {@link balanceSources}, which carries the base URL too. */
     balanceCredentialRefs?: Record<string, string>;
 }
 /** Configuration schema, with the config file's own defaults applied. */

package/lib/index.js

@@ -42,6 +42,8 @@ export const Config = z.object({
     defaultModel: z.string().default(KIMI_DEFAULT_MODEL),
     extraModels: z.array(z.string()).default([]),
     auto: z.boolean().default(true),
+    balanceSources: z.dict(z.object({ credentialRef: z.string(), baseUrl: z.string() })).default({}),
+    balanceCredentialRefs: z.dict(z.string()).default({}),
 });
 /**
  * Register every configured provider route, its credential store, and — when
@@ -188,13 +190,18 @@ export function apply(ctx, config = {}) {
         handles.set(route.id, handle);
         ctx.effect(() => () => handle(), `${name}: ${route.id} provider route`);
     }
-    // A non-subscription provider's balance is read by cc-switch's query, which needs the
-    // provider's API key. The provider's profile names that key by reference (`apiKeyEnv`),
-    // and the configured map ties a provider id to that reference; the host's credential
-    // service resolves it. The map lives in server config because that is where the rest
-    // of the plugin's wiring is, and the client learns a provider's balance by id, never
-    // by its credential reference.
-    const credentialRefs = config.balanceCredentialRefs ?? {};
+    // A non-subscription provider's balance is read by cc-switch's query against the
+    // provider's own base URL (the balance endpoint lives beside its OpenAI-compatible
+    // wire, not on DeepSeek's), which needs the provider's API key. Each configured source
+    // names the credential reference the provider's profile uses (`apiKeyEnv`) and the base
+    // URL that profile connects to; the host's credential service resolves the reference.
+    const balanceSources = config.balanceSources ?? {};
+    const credentialRefs = { ...config.balanceCredentialRefs };
+    const baseUrls = {};
+    for (const [provider, source] of Object.entries(balanceSources)) {
+        credentialRefs[provider] = source.credentialRef;
+        baseUrls[provider] = source.baseUrl;
+    }
     // The DeepSeek account's balance is read on the node half through the host's
     // `deepseekAccount` service; the browser reaches it through the plugin's own RPC, the
     // same channel as the rest of the chip's data. The service is read lazily, per request
@@ -202,6 +209,7 @@ export function apply(ctx, config = {}) {
     // without it still serves every other endpoint, and the balance endpoint answers nothing.
     const balanceContext = {
         credentialRefs,
+        baseUrls,
         resolveDeepSeekAccount: () => {
             try {
                 return ctx.get('deepseekAccount');
@@ -213,7 +221,20 @@ export function apply(ctx, config = {}) {
         resolveCredential: async (ref) => {
             try {
                 const credentials = ctx.get('credentials');
-                return (await credentials?.resolve?.(ref))?.value;
+                const hit = await credentials?.resolve?.(ref);
+                // The resolve answer is `{ value, source }`; an env-var source may name the var
+                // rather than carry the value, so both are considered before giving up.
+                if (typeof hit === 'object' && hit !== null) {
+                    const record = hit;
+                    if (typeof record.value === 'string' && record.value.trim() !== '')
+                        return record.value;
+                    if (typeof record.source === 'string') {
+                        const fromEnv = process.env[record.source];
+                        if (typeof fromEnv === 'string' && fromEnv.trim() !== '')
+                            return fromEnv;
+                    }
+                }
+                return undefined;
             }
             catch {
                 return undefined;

package/lib/providers/kimi.d.ts

@@ -95,7 +95,15 @@ export declare class KimiAdapter extends LlmAdapter {
     private discovered;
     /** Ids the user added by hand, cached so the sync catalog can name them. */
     private userAddedIds;
+    /** Tools already reported as flattened, so each is stated once. */
+    private readonly flattenedTools;
     constructor(options: KimiAdapterOptions);
+    /**
+     * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
+     * ceiling. A declaration too large to send keeps its arguments, and that is
+     * reported once per tool rather than on every turn.
+     */
+    private moonshotTools;
     providerInfo(provider: string): LlmProviderInfo;
     providerRetryPolicy(): undefined;
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;

package/lib/providers/kimi.js

@@ -14,7 +14,7 @@ import { idleWatchdog, httpLlmError, isMissingOrInvalidCredential, mapFetchFailu
 import { streamProviderResponses } from './responses-stream.js';
 import { fallbackEntry, findEntry, resolveCatalog } from './catalog.js';
 import { streamResponses, toResponsesInput, toResponsesTools } from '../translate/responses.js';
-import { moonshotToolParameters } from '../translate/moonshot-schema.js';
+import { prepareMoonshotTool } from '../translate/moonshot-schema.js';
 /**
  * Coerce one decoded credential entry into a Kimi session.
  * @param value - decoded JSON value for one account.
@@ -131,10 +131,31 @@ export class KimiAdapter extends LlmAdapter {
     discovered;
     /** 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. */
+    flattenedTools = new Set();
     constructor(options) {
         super();
         this.options = options;
     }
+    /**
+     * Tool schemas in the shape Moonshot accepts: no `$ref`, and under its size
+     * ceiling. A declaration too large to send keeps its arguments, and that is
+     * reported once per tool rather than on every turn.
+     */
+    moonshotTools(tools) {
+        return tools.map((tool) => {
+            const prepared = prepareMoonshotTool(tool.parameters);
+            if (prepared.preparedAs !== 'as-declared' && !this.flattenedTools.has(tool.name)) {
+                this.flattenedTools.add(tool.name);
+                this.options.onWarn?.(prepared.preparedAs === 'flattened'
+                    ? `kimi: ${tool.name} declares an argument schema larger than the endpoint accepts; `
+                        + 'its arguments are described without their nested structure'
+                    : `kimi: ${tool.name} declares an argument schema larger than the endpoint accepts; `
+                        + 'it is offered as an unrestricted object');
+            }
+            return { ...tool, parameters: prepared.parameters };
+        });
+    }
     providerInfo(provider) {
         return { id: provider, name: KIMI_PROVIDER_NAME };
     }
@@ -311,7 +332,11 @@ export class KimiAdapter extends LlmAdapter {
             input: resolved.input,
             ...options.tools === undefined || options.tools.length === 0
                 ? {}
-                : { tools: toResponsesTools(options.tools, moonshotToolParameters), tool_choice: 'auto', parallel_tool_calls: true },
+                : {
+                    tools: toResponsesTools(this.moonshotTools(options.tools)),
+                    tool_choice: 'auto',
+                    parallel_tool_calls: true,
+                },
             ...options.maxTokens === undefined ? {} : { max_output_tokens: options.maxTokens },
             ...options.reasoningEffort === undefined
                 ? {}

package/lib/translate/moonshot-schema.d.ts

@@ -1,31 +1,54 @@
 /**
  * Tool-schema preparation for the Moonshot wire (Kimi Code).
  *
- * Moonshot validates `tools[].function.parameters` with its own JSON-Schema
- * reader, and that reader cannot settle a `$ref` that carries sibling
- * keywords: instead of intersecting the two, it re-expands the node, so the
- * whole request is refused with
- * `detected infinite recursion without termination condition`. The harness
- * forwards tool schemas exactly as their owner declared them, and the MCP
- * tools REA registers use that shape heavily —
- * `{"$ref": "#/$defs/__schema12", "description": "..."}` — 153 of 170 tools
- * carried at least one such node, and the first one Moonshot reached killed
- * every Kimi request that included a tool.
+ * Moonshot validates `tools[].function.parameters` with its own reader, and
+ * that reader expands every `$ref` before it measures or checks the schema. The
+ * harness forwards each tool's schema exactly as its owner declared it, and
+ * every MCP tool REA registers holds its shapes in a `$defs` block that its
+ * properties reference, so Kimi refused the whole request with
+ * `tools.function.parameters is not a valid moonshot flavored json schema`.
  *
- * A `$ref` that stands alone is accepted, and so is keeping `$defs` for it, so
- * only the offending nodes are rewritten: the referenced schema is inlined
- * under the node's own keywords (JSON Schema 2020-12 applies both, and the
- * node's own keywords win on a conflict), which leaves the wire schema with
- * standalone references only. Resolution is bounded by the reference stack, so
- * a real cycle ends by dropping the `$ref` and keeping the sibling keywords
- * rather than recursing.
+ * Live probes against `api.kimi.com` measured both edges of that reader:
+ *
+ * - a `$ref` whose target itself holds `$ref`s is refused as
+ *   `detected infinite recursion without termination condition` — the failing
+ *   tool reported the node `properties.actions` and, once that node was
+ *   inlined so its reference stood alone, the deeper `properties.actions.items`.
+ *   A one-level reference is accepted; a chain is not.
+ * - the expanded schema has a size ceiling between 80,081 B (accepted) and
+ *   124,389 B (refused). `compare_web_captures` declares 57,175 B of shared
+ *   definitions but expands past 153,000 B, so it was refused even as declared.
+ *
+ * So this module sends no references at all — every local pointer is replaced
+ * by the definition it names, and the document keywords that only existed to
+ * hold them (`$defs`, `$schema`, `$id`, `definitions`) are dropped. A pointer
+ * that re-enters itself cannot be inlined, and there the referencing node keeps
+ * its own keywords instead of recursing. A tool whose expanded schema still
+ * exceeds the ceiling is flattened in steps — the arguments with their prose,
+ * then the arguments alone, then an unrestricted object — so that one oversized
+ * tool costs its own detail rather than the whole request.
  *
  * @module dsh-plugin-subscription-oauth/translate/moonshot-schema
  */
+/** How much of a declaration a schema too large to send had to give up. */
+export type MoonshotPreparation = 
+/** Sent as declared, with its references inlined. */
+'as-declared'
+/** Only the arguments: names, types, choices, `required`, and prose while it fits. */
+ | 'flattened'
+/** An unrestricted object, because even the arguments did not fit. */
+ | 'permissive';
+/** One prepared tool schema together with what had to be done to it. */
+export interface MoonshotToolSchema {
+    /** The schema to send. */
+    parameters: Record<string, unknown>;
+    /** What the declaration had to give up to fit. */
+    preparedAs: MoonshotPreparation;
+}
 /**
  * Prepare one tool's parameters for Moonshot.
  *
  * @param parameters - the tool's declared argument schema.
- * @returns a detached schema whose `$ref` nodes carry no sibling keywords.
+ * @returns the schema to send and what it had to give up to fit the endpoint.
  */
-export declare function moonshotToolParameters(parameters: Record<string, unknown>): Record<string, unknown>;
+export declare function prepareMoonshotTool(parameters: Record<string, unknown>): MoonshotToolSchema;

package/lib/translate/moonshot-schema.js

@@ -1,27 +1,47 @@
 /**
  * Tool-schema preparation for the Moonshot wire (Kimi Code).
  *
- * Moonshot validates `tools[].function.parameters` with its own JSON-Schema
- * reader, and that reader cannot settle a `$ref` that carries sibling
- * keywords: instead of intersecting the two, it re-expands the node, so the
- * whole request is refused with
- * `detected infinite recursion without termination condition`. The harness
- * forwards tool schemas exactly as their owner declared them, and the MCP
- * tools REA registers use that shape heavily —
- * `{"$ref": "#/$defs/__schema12", "description": "..."}` — 153 of 170 tools
- * carried at least one such node, and the first one Moonshot reached killed
- * every Kimi request that included a tool.
+ * Moonshot validates `tools[].function.parameters` with its own reader, and
+ * that reader expands every `$ref` before it measures or checks the schema. The
+ * harness forwards each tool's schema exactly as its owner declared it, and
+ * every MCP tool REA registers holds its shapes in a `$defs` block that its
+ * properties reference, so Kimi refused the whole request with
+ * `tools.function.parameters is not a valid moonshot flavored json schema`.
  *
- * A `$ref` that stands alone is accepted, and so is keeping `$defs` for it, so
- * only the offending nodes are rewritten: the referenced schema is inlined
- * under the node's own keywords (JSON Schema 2020-12 applies both, and the
- * node's own keywords win on a conflict), which leaves the wire schema with
- * standalone references only. Resolution is bounded by the reference stack, so
- * a real cycle ends by dropping the `$ref` and keeping the sibling keywords
- * rather than recursing.
+ * Live probes against `api.kimi.com` measured both edges of that reader:
+ *
+ * - a `$ref` whose target itself holds `$ref`s is refused as
+ *   `detected infinite recursion without termination condition` — the failing
+ *   tool reported the node `properties.actions` and, once that node was
+ *   inlined so its reference stood alone, the deeper `properties.actions.items`.
+ *   A one-level reference is accepted; a chain is not.
+ * - the expanded schema has a size ceiling between 80,081 B (accepted) and
+ *   124,389 B (refused). `compare_web_captures` declares 57,175 B of shared
+ *   definitions but expands past 153,000 B, so it was refused even as declared.
+ *
+ * So this module sends no references at all — every local pointer is replaced
+ * by the definition it names, and the document keywords that only existed to
+ * hold them (`$defs`, `$schema`, `$id`, `definitions`) are dropped. A pointer
+ * that re-enters itself cannot be inlined, and there the referencing node keeps
+ * its own keywords instead of recursing. A tool whose expanded schema still
+ * exceeds the ceiling is flattened in steps — the arguments with their prose,
+ * then the arguments alone, then an unrestricted object — so that one oversized
+ * tool costs its own detail rather than the whole request.
  *
  * @module dsh-plugin-subscription-oauth/translate/moonshot-schema
  */
+/** Keywords that describe the schema document rather than the values it accepts. */
+const DOCUMENT_KEYS = new Set(['$schema', '$id', '$defs', 'definitions']);
+/** Root keywords a flattened schema keeps. */
+const ROOT_KEYS = ['type', 'description', 'required', 'additionalProperties', 'minProperties', 'maxProperties'];
+/**
+ * Largest expanded schema the endpoint is asked to take, in bytes.
+ *
+ * Measured rather than assumed: 80,081 B was accepted and 124,389 B was refused
+ * with `At path 'root': schema exceeds maximum allowed size`. This sits below
+ * both so a schema this plugin sends has room to spare.
+ */
+const SIZE_BUDGET = 64 * 1024;
 /** True for a plain object usable as a schema node. */
 function object(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -43,7 +63,7 @@ function pointed(root, ref) {
     return node;
 }
 /**
- * Rewrite one node so every `$ref` left on the wire stands alone.
+ * Replace every reference reachable from one node with what it names.
  *
  * @param node - the node to rewrite.
  * @param root - the tool's root schema, which local pointers resolve against.
@@ -56,26 +76,67 @@ function inline(node, root, refs) {
     if (!object(node))
         return node;
     const { $ref, ...siblings } = node;
-    if (typeof $ref !== 'string') {
-        return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, inline(value, root, refs)]));
+    if (typeof $ref === 'string') {
+        // A repeated pointer, or one that names nothing local, cannot be inlined:
+        // the node's own keywords are all that is left.
+        const target = refs.has($ref) ? undefined : pointed(root, $ref);
+        return object(target)
+            ? inline({ ...target, ...siblings }, root, new Set([...refs, $ref]))
+            : inline(siblings, root, refs);
     }
-    // A standalone reference is exactly what Moonshot expects, so it stays as is
-    // and keeps its `$defs` entry.
-    if (Object.keys(siblings).length === 0)
-        return { $ref };
-    // A repeated pointer, or one that is not a local object, cannot be inlined:
-    // the sibling keywords are all that is left to terminate on.
-    const target = refs.has($ref) ? undefined : pointed(root, $ref);
-    return object(target)
-        ? inline({ ...target, ...siblings }, root, new Set([...refs, $ref]))
-        : inline(siblings, root, refs);
+    return Object.fromEntries(Object.entries(node)
+        .filter(([key]) => !DOCUMENT_KEYS.has(key))
+        .map(([key, value]) => [key, inline(value, root, refs)]));
+}
+/**
+ * Keep only what a model needs to call the tool: the root's own keywords, and
+ * each argument's name, type, value choices and — while the budget allows —
+ * its description.
+ *
+ * @param schema - an already inlined schema.
+ * @param prose - whether descriptions are worth their bytes.
+ * @returns the flattened schema.
+ */
+function flatten(schema, prose) {
+    const out = {};
+    for (const key of ROOT_KEYS) {
+        if (Object.hasOwn(schema, key) && (prose || key !== 'description'))
+            out[key] = schema[key];
+    }
+    if (!object(schema.properties))
+        return out;
+    out.properties = Object.fromEntries(Object.entries(schema.properties).map(([name, property]) => {
+        const node = object(property) ? property : {};
+        const reduced = {};
+        if (typeof node.type === 'string')
+            reduced.type = node.type;
+        if (Array.isArray(node.enum))
+            reduced.enum = node.enum;
+        if (prose && typeof node.description === 'string')
+            reduced.description = node.description;
+        return [name, reduced];
+    }));
+    return out;
+}
+/** Bytes the endpoint measures once it has expanded every reference. */
+function expandedBytes(schema) {
+    return Buffer.byteLength(JSON.stringify(schema));
 }
 /**
  * Prepare one tool's parameters for Moonshot.
  *
  * @param parameters - the tool's declared argument schema.
- * @returns a detached schema whose `$ref` nodes carry no sibling keywords.
+ * @returns the schema to send and what it had to give up to fit the endpoint.
  */
-export function moonshotToolParameters(parameters) {
-    return inline(parameters, parameters, new Set());
+export function prepareMoonshotTool(parameters) {
+    const inlined = inline(parameters, parameters, new Set());
+    if (expandedBytes(inlined) <= SIZE_BUDGET)
+        return { parameters: inlined, preparedAs: 'as-declared' };
+    const documented = flatten(inlined, true);
+    if (expandedBytes(documented) <= SIZE_BUDGET)
+        return { parameters: documented, preparedAs: 'flattened' };
+    const bare = flatten(inlined, false);
+    if (expandedBytes(bare) <= SIZE_BUDGET)
+        return { parameters: bare, preparedAs: 'flattened' };
+    return { parameters: { type: 'object', additionalProperties: true }, preparedAs: 'permissive' };
 }

package/lib/translate/responses.d.ts

@@ -53,11 +53,9 @@ export declare function toResponsesInput(messages: readonly RequestMessage[], sy
  * than letting the endpoint normalize every schema into strict mode.
  *
  * @param tools - the request's tool schemas.
- * @param prepare - an endpoint-specific rewrite of one parameters schema, for
- * a route whose JSON-Schema reader refuses the schema as declared.
  * @returns `tools` array entries.
  */
-export declare function toResponsesTools(tools: readonly ToolSchema[], prepare?: (parameters: Record<string, unknown>) => Record<string, unknown>): Record<string, unknown>[];
+export declare function toResponsesTools(tools: readonly ToolSchema[]): Record<string, unknown>[];
 /** The `usage` object of a completed response. */
 export interface ResponsesUsage {
     input_tokens?: number;

package/lib/translate/responses.js

@@ -124,16 +124,14 @@ export async function toResponsesInput(messages, system, resolveImage) {
  * than letting the endpoint normalize every schema into strict mode.
  *
  * @param tools - the request's tool schemas.
- * @param prepare - an endpoint-specific rewrite of one parameters schema, for
- * a route whose JSON-Schema reader refuses the schema as declared.
  * @returns `tools` array entries.
  */
-export function toResponsesTools(tools, prepare) {
+export function toResponsesTools(tools) {
     return tools.map((tool) => ({
         type: 'function',
         name: tool.name,
         description: tool.description,
-        parameters: prepare === undefined ? tool.parameters : prepare(tool.parameters),
+        parameters: tool.parameters,
         strict: false,
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "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",