dsh-plugin-subscription-oauth 0.6.0 → 0.6.1

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.6.1",
   "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",