pi-provider-kimi-code 0.6.13 → 0.6.14

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## [0.6.14] - 2026-11-15
+
+### Changed
+
+- Upgraded `@earendil-works/pi-ai` / `pi-coding-agent` / `pi-tui` to `^1.5.0`. This resolves all npm audit findings (undici, minimatch, brace-expansion advisories) and picks up pi's streaming and rendering performance fixes.
+- Tool parameter schemas (`moonshot_search`, `moonshot_fetch`, `kimi_datasource`) now use `@earendil-works/pi-schema` builders instead of TypeBox, following pi 1.5.0's migration. The generated JSON Schema is unchanged.
+
+### Security
+
+- Device-code login now rejects verification URLs that are not `http:`/`https:`, mirroring pi 1.5.0's fix for built-in OAuth providers. A malicious or buggy authorization server can no longer hand pi a `file:` or custom-scheme URL to open.
+
+### Added
+
+- The `/kimi-coding` settings dialog now reports pi as blocked on user input (OSC 7501 program status) while it is open, so supporting terminals show the correct waiting state.
+- This changelog: pi 1.5.0 shows extension update notes on the next launch after an update.
+- The `/kimi-settings` dialog now exposes **Keep thinking** (`model.thinkingKeep`: `default` / `all` / `last` / `none`), controlling the `thinking.keep` value sent to the Kimi API — i.e. how much reasoning history the server retains across turns. The wire and config plumbing already existed; this makes it adjustable without editing JSON.
+- `kimi_datasource` now syncs its data-source catalog from the official plugin marketplace (`/coding/v1/plugins/marketplace`) with a lazy 24h disk cache (`~/.kimi-code/kimi-datasource-catalog.json`). The bundled snapshot moves from 12 to 35 sources (adds `china_*`, `who`/`fao`/`oecd`/`fred`, `chembl`/`pubchem`/`pdb`/`uniprot` and other science sources, `dongcai`/`cls`/`finance_research`), `data_source_name` is no longer a closed enum so server-side additions are never rejected by a stale client schema, and unknown names trigger one forced catalog refresh before being rejected with the current source list.
+- Model discovery now prefers the unified `/models` schema (`limit.context`, `reasoning.type`/`reasoning.effort.valid`/`default`, `modalities.input`) that the official kimi-code client switched to in #4209, keeping the legacy flat fields (`context_length`, `supports_reasoning`, `think_efforts`, ...) as fallback while the server still sends both.
+- Kimi's hard quota exhaustion (HTTP 429 with `exceeded_current_quota_error`) is now rewritten into actionable guidance — it is not a transient rate limit and retries will keep failing — pointing at `/kimi-settings` for usage, mirroring upstream kimi-code #4477/#4703. Plain transient 429s are untouched.

package/index.ts

@@ -224,204 +224,225 @@ async function openSettingsMenu(
   let scope: KimiConfigScope = projectTrusted ? "project" : "home";
   let dirty = false;
 
-  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
-    const settingsTheme = buildSettingsTheme(theme);
-
-    let list: SettingsList;
-
-    const toolLabel = (toolName: KimiToolName) => {
-      if (toolName === "moonshot_search") return "Search tool";
-      if (toolName === "moonshot_fetch") return "Fetch tool";
-      return "Real-world data API";
-    };
-
-    const formatToolMenuValue = (toolName: KimiToolName) => {
-      const tool = drafts[scope].tools[toolName];
-      if (!tool.enabled) return "disabled";
-      return tool.default_collapsed ? "enabled without preview" : "enabled with preview";
-    };
-
-    const refreshDisplays = () => {
-      scopeItem.description = formatScopeDescription(scope, ctx.cwd);
-      for (const toolName of KIMI_TOOL_NAMES) {
-        list.updateValue(toolName, formatToolMenuValue(toolName));
-      }
-      list.updateValue("protocol", drafts[scope].protocol);
-      list.updateValue("region", formatRegionValue(drafts[scope].region));
-      list.updateValue("uploadThreshold", formatByteSize(drafts[scope].uploads.thresholdBytes));
-    };
-
-    const save = () => {
-      if (scope === "project" && !projectTrusted) {
-        ctx.ui.notify("Project config cannot be saved until the project is trusted.", "warning");
-        return;
-      }
-      try {
-        saveScopeKimiCodeConfig(scope, ctx.cwd, drafts[scope]);
-        applyEffectiveKimiRuntimeConfig(pi, state, ctx.cwd, {
-          updateActiveTools: true,
-          projectTrusted: scope === "project" ? true : projectTrusted,
-        });
-        dirty = true;
-      } catch (error: unknown) {
-        ctx.ui.notify((error as Error).message, "error");
-      }
-    };
-
-    const onChange = (id: string, newValue: string) => {
-      if (id === "scope") {
-        scope = newValue as KimiConfigScope;
-        refreshDisplays();
-        return;
-      }
-      if (id === "protocol") {
-        drafts[scope].protocol = newValue as KimiCodeConfig["protocol"];
-        list.updateValue(id, newValue);
-        save();
-        return;
-      }
-      if (id === "region") {
-        drafts[scope].region = newValue === "auto" ? null : (newValue as KimiRegion);
-        list.updateValue(id, newValue);
-        save();
-        return;
-      }
-      if (id === "uploadThreshold") {
-        const bytes = parseByteSizeInput(newValue);
-        if (bytes === undefined || bytes <= 0) {
-          ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
+  await ctx.ui.custom<void>(
+    (tui, theme, _keybindings, done) => {
+      const settingsTheme = buildSettingsTheme(theme);
+
+      let list: SettingsList;
+
+      const toolLabel = (toolName: KimiToolName) => {
+        if (toolName === "moonshot_search") return "Search tool";
+        if (toolName === "moonshot_fetch") return "Fetch tool";
+        return "Real-world data API";
+      };
+
+      const formatToolMenuValue = (toolName: KimiToolName) => {
+        const tool = drafts[scope].tools[toolName];
+        if (!tool.enabled) return "disabled";
+        return tool.default_collapsed ? "enabled without preview" : "enabled with preview";
+      };
+
+      const refreshDisplays = () => {
+        scopeItem.description = formatScopeDescription(scope, ctx.cwd);
+        for (const toolName of KIMI_TOOL_NAMES) {
+          list.updateValue(toolName, formatToolMenuValue(toolName));
+        }
+        list.updateValue("protocol", drafts[scope].protocol);
+        list.updateValue("region", formatRegionValue(drafts[scope].region));
+        list.updateValue("uploadThreshold", formatByteSize(drafts[scope].uploads.thresholdBytes));
+        list.updateValue("thinkingKeep", drafts[scope].model.thinkingKeep ?? "default");
+      };
+
+      const save = () => {
+        if (scope === "project" && !projectTrusted) {
+          ctx.ui.notify("Project config cannot be saved until the project is trusted.", "warning");
           return;
         }
-        drafts[scope].uploads.thresholdBytes = bytes;
-        list.updateValue(id, formatByteSize(bytes));
-        save();
-        return;
-      }
-      const toolMatch = /^(?<tool>.+):(?<field>enabled|collapsed)$/.exec(id);
-      if (toolMatch?.groups) {
-        const toolName = toolMatch.groups.tool as KimiToolName;
-        const field = toolMatch.groups.field as "enabled" | "collapsed";
-        if (field === "enabled") {
-          drafts[scope].tools[toolName].enabled = newValue === "true";
-        } else {
-          drafts[scope].tools[toolName].default_collapsed = newValue !== "true";
+        try {
+          saveScopeKimiCodeConfig(scope, ctx.cwd, drafts[scope]);
+          applyEffectiveKimiRuntimeConfig(pi, state, ctx.cwd, {
+            updateActiveTools: true,
+            projectTrusted: scope === "project" ? true : projectTrusted,
+          });
+          dirty = true;
+        } catch (error: unknown) {
+          ctx.ui.notify((error as Error).message, "error");
         }
-        list.updateValue(toolName, formatToolMenuValue(toolName));
-        save();
-      }
-    };
-
-    const scopeItem: SettingItem = {
-      id: "scope",
-      label: "Config scope",
-      description: projectTrusted
-        ? formatScopeDescription(scope, ctx.cwd)
-        : "Project config disabled until the project is trusted; editing home config only",
-      currentValue: scope,
-      values: projectTrusted ? ["project", "home"] : ["home"],
-    };
+      };
 
-    const items: SettingItem[] = [scopeItem];
-    for (const toolName of KIMI_TOOL_NAMES) {
-      items.push({
-        id: toolName,
-        label: toolLabel(toolName),
-        description: `Configure ${toolName} registration and preview defaults`,
-        currentValue: formatToolMenuValue(toolName),
-        submenu: (_current, submenuDone) =>
-          new SettingsList(
-            [
-              {
-                id: `${toolName}:enabled`,
-                label: "Enabled",
-                description: `Register ${toolName} at session start`,
-                currentValue: String(drafts[scope].tools[toolName].enabled),
-                values: ["true", "false"],
-              },
-              {
-                id: `${toolName}:collapsed`,
-                label: "Show preview",
-                description: `Show ${toolName} result previews by default`,
-                currentValue: String(!drafts[scope].tools[toolName].default_collapsed),
-                values: ["true", "false"],
-              },
-            ],
-            2,
-            settingsTheme,
-            onChange,
-            () => submenuDone(),
-          ),
-      });
-    }
-    items.push({
-      id: "protocol",
-      label: "Protocol",
-      description: "API protocol for Kimi requests",
-      currentValue: drafts[scope].protocol,
-      values: ["openai", "anthropic", "responses"],
-    });
-    items.push({
-      id: "region",
-      label: "Region",
-      description: "Managed deployment region (auto follows KIMI_CODE_REGION / default)",
-      currentValue: formatRegionValue(drafts[scope].region),
-      values: ["auto", "mainland-cn", "global"],
-    });
-    items.push({
-      id: "uploadThreshold",
-      label: "Upload threshold",
-      description: "Max size for inline file uploads",
-      currentValue: formatByteSize(drafts[scope].uploads.thresholdBytes),
-      submenu: (_current, submenuDone) => {
-        const input = new Input();
-        input.setValue(formatByteSize(drafts[scope].uploads.thresholdBytes));
-        input.onSubmit = (value) => {
-          const bytes = parseByteSizeInput(value);
+      const onChange = (id: string, newValue: string) => {
+        if (id === "scope") {
+          scope = newValue as KimiConfigScope;
+          refreshDisplays();
+          return;
+        }
+        if (id === "protocol") {
+          drafts[scope].protocol = newValue as KimiCodeConfig["protocol"];
+          list.updateValue(id, newValue);
+          save();
+          return;
+        }
+        if (id === "region") {
+          drafts[scope].region = newValue === "auto" ? null : (newValue as KimiRegion);
+          list.updateValue(id, newValue);
+          save();
+          return;
+        }
+        if (id === "uploadThreshold") {
+          const bytes = parseByteSizeInput(newValue);
           if (bytes === undefined || bytes <= 0) {
             ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
-            submenuDone();
             return;
           }
-          submenuDone(formatByteSize(bytes));
-        };
-        input.onEscape = () => submenuDone();
-        return input;
-      },
-    });
+          drafts[scope].uploads.thresholdBytes = bytes;
+          list.updateValue(id, formatByteSize(bytes));
+          save();
+          return;
+        }
+        if (id === "thinkingKeep") {
+          drafts[scope].model.thinkingKeep =
+            newValue === "default" ? null : (newValue as KimiCodeConfig["model"]["thinkingKeep"]);
+          list.updateValue(id, newValue);
+          save();
+          return;
+        }
+        const toolMatch = /^(?<tool>.+):(?<field>enabled|collapsed)$/.exec(id);
+        if (toolMatch?.groups) {
+          const toolName = toolMatch.groups.tool as KimiToolName;
+          const field = toolMatch.groups.field as "enabled" | "collapsed";
+          if (field === "enabled") {
+            drafts[scope].tools[toolName].enabled = newValue === "true";
+          } else {
+            drafts[scope].tools[toolName].default_collapsed = newValue !== "true";
+          }
+          list.updateValue(toolName, formatToolMenuValue(toolName));
+          save();
+        }
+      };
+
+      const scopeItem: SettingItem = {
+        id: "scope",
+        label: "Config scope",
+        description: projectTrusted
+          ? formatScopeDescription(scope, ctx.cwd)
+          : "Project config disabled until the project is trusted; editing home config only",
+        currentValue: scope,
+        values: projectTrusted ? ["project", "home"] : ["home"],
+      };
+
+      const items: SettingItem[] = [scopeItem];
+      for (const toolName of KIMI_TOOL_NAMES) {
+        items.push({
+          id: toolName,
+          label: toolLabel(toolName),
+          description: `Configure ${toolName} registration and preview defaults`,
+          currentValue: formatToolMenuValue(toolName),
+          submenu: (_current, submenuDone) =>
+            new SettingsList(
+              [
+                {
+                  id: `${toolName}:enabled`,
+                  label: "Enabled",
+                  description: `Register ${toolName} at session start`,
+                  currentValue: String(drafts[scope].tools[toolName].enabled),
+                  values: ["true", "false"],
+                },
+                {
+                  id: `${toolName}:collapsed`,
+                  label: "Show preview",
+                  description: `Show ${toolName} result previews by default`,
+                  currentValue: String(!drafts[scope].tools[toolName].default_collapsed),
+                  values: ["true", "false"],
+                },
+              ],
+              2,
+              settingsTheme,
+              onChange,
+              () => submenuDone(),
+            ),
+        });
+      }
+      items.push({
+        id: "protocol",
+        label: "Protocol",
+        description: "API protocol for Kimi requests",
+        currentValue: drafts[scope].protocol,
+        values: ["openai", "anthropic", "responses"],
+      });
+      items.push({
+        id: "region",
+        label: "Region",
+        description: "Managed deployment region (auto follows KIMI_CODE_REGION / default)",
+        currentValue: formatRegionValue(drafts[scope].region),
+        values: ["auto", "mainland-cn", "global"],
+      });
+      items.push({
+        id: "thinkingKeep",
+        label: "Keep thinking",
+        description:
+          "thinking.keep sent to the Kimi API: how much reasoning history the server should retain across turns",
+        currentValue: drafts[scope].model.thinkingKeep ?? "default",
+        values: ["default", "all", "last", "none"],
+      });
+      items.push({
+        id: "uploadThreshold",
+        label: "Upload threshold",
+        description: "Max size for inline file uploads",
+        currentValue: formatByteSize(drafts[scope].uploads.thresholdBytes),
+        submenu: (_current, submenuDone) => {
+          const input = new Input();
+          input.setValue(formatByteSize(drafts[scope].uploads.thresholdBytes));
+          input.onSubmit = (value) => {
+            const bytes = parseByteSizeInput(value);
+            if (bytes === undefined || bytes <= 0) {
+              ctx.ui.notify("Upload threshold must be a positive size, for example 2 MiB", "error");
+              submenuDone();
+              return;
+            }
+            submenuDone(formatByteSize(bytes));
+          };
+          input.onEscape = () => submenuDone();
+          return input;
+        },
+      });
 
-    list = new SettingsList(items, items.length, settingsTheme, onChange, () => done(), {
-      enableSearch: true,
-    });
+      list = new SettingsList(items, items.length, settingsTheme, onChange, () => done(), {
+        enableSearch: true,
+      });
 
-    return {
-      items,
-      onChange,
-      render(width: number) {
-        const usageLines = usage.split("\n").map((line) => truncateToWidth(`  ${line}`, width));
-        return [
-          truncateToWidth(
-            theme.fg("accent", theme.bold(`Kimi settings (provider v${PROVIDER_VERSION})`)),
-            width,
-          ),
-          "",
-          truncateToWidth(theme.fg("accent", theme.bold("Kimi account")), width),
-          truncateToWidth(`  ${account}`, width),
-          "",
-          truncateToWidth(theme.fg("accent", theme.bold("Kimi usage")), width),
-          ...usageLines,
-          "",
-          ...list.render(width),
-        ];
-      },
-      handleInput(data: string) {
-        list.handleInput?.(data);
-        tui.requestRender();
-      },
-      invalidate() {
-        list.invalidate();
-      },
-    };
-  });
+      return {
+        items,
+        onChange,
+        render(width: number) {
+          const usageLines = usage.split("\n").map((line) => truncateToWidth(`  ${line}`, width));
+          return [
+            truncateToWidth(
+              theme.fg("accent", theme.bold(`Kimi settings (provider v${PROVIDER_VERSION})`)),
+              width,
+            ),
+            "",
+            truncateToWidth(theme.fg("accent", theme.bold("Kimi account")), width),
+            truncateToWidth(`  ${account}`, width),
+            "",
+            truncateToWidth(theme.fg("accent", theme.bold("Kimi usage")), width),
+            ...usageLines,
+            "",
+            ...list.render(width),
+          ];
+        },
+        handleInput(data: string) {
+          list.handleInput?.(data);
+          tui.requestRender();
+        },
+        invalidate() {
+          list.invalidate();
+        },
+      };
+    },
+    {
+      blocked: { kind: "question", message: "Kimi settings" },
+    },
+  );
 
   if (dirty) await ctx.reload();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.13",
+  "version": "0.6.14",
   "description": "Kimi Code models (K3, K2.8, HighSpeed) in Pi: OAuth shared login with kimi-code CLI, file uploads, and Kimi-native tools",
   "keywords": [
     "ai-provider",
@@ -41,7 +41,8 @@
     "index.ts",
     "src",
     "package.json",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "scripts": {
@@ -55,23 +56,24 @@
     "pre-commit": "prek run"
   },
   "dependencies": {
+    "@earendil-works/pi-schema": "^1.5.0",
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.99.2",
-    "@earendil-works/pi-coding-agent": "^0.99.2",
-    "@earendil-works/pi-tui": "^0.99.2",
-    "@j178/prek": "^0.5.2",
-    "@types/node": "^24.0.0",
+    "@earendil-works/pi-ai": "^1.5.0",
+    "@earendil-works/pi-coding-agent": "^1.5.0",
+    "@earendil-works/pi-tui": "^1.5.0",
+    "@j178/prek": "^0.5.10",
+    "@types/node": "^24.19.2",
     "@types/proper-lockfile": "^4.1.4",
-    "oxfmt": "^0.67.0",
-    "oxlint": "^1.82.0",
+    "oxfmt": "^0.77.0",
+    "oxlint": "^1.92.0",
     "typescript": "^5.9.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-ai": ">=1.5.0",
+    "@earendil-works/pi-coding-agent": ">=1.5.0",
+    "@earendil-works/pi-tui": ">=1.5.0"
   },
   "pi": {
     "extensions": [

package/src/constants.ts

@@ -133,7 +133,7 @@ export function getDefaultBaseUrl(
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.13";
+export const PROVIDER_VERSION = "0.6.14";
 
 export const KIMI_CODE_USER_AGENT = `pi-provider-kimi-code/${PROVIDER_VERSION}`;
 export const KIMI_PLATFORM = "pi";

package/src/errors.ts

@@ -0,0 +1,31 @@
+// Kimi error-message classification, mirroring upstream kimi-code #4477 /
+// #4703: quota exhaustion is a hard limit with explicit non-retryability, not
+// a transient rate limit — say so instead of letting the raw 429 body read
+// like something a retry would fix.
+
+const QUOTA_ERROR_CODE = "exceeded_current_quota_error";
+
+/**
+ * Detect Kimi's structured quota error in a flattened error message
+ * (status line + JSON body). Both markers are required to avoid matching
+ * unrelated 429 rate limits, which ARE transient.
+ */
+export function isKimiQuotaExhaustedMessage(message: unknown): boolean {
+  const text = String(message ?? "").toLowerCase();
+  return text.includes(QUOTA_ERROR_CODE) && /\b429\b/.test(text);
+}
+
+/**
+ * Rewrite a raw upstream error into actionable text. Returns the input
+ * unchanged when nothing applies.
+ */
+export function improveKimiErrorMessage(message: string): string {
+  if (!isKimiQuotaExhaustedMessage(message)) return message;
+  return (
+    "Kimi Code quota exhausted (HTTP 429, exceeded_current_quota_error). " +
+    "This is a hard quota limit, not a transient rate limit — retrying will " +
+    "keep failing until the quota window resets. Run /kimi-settings to check " +
+    "your current usage. " +
+    `Original error: ${message}`
+  );
+}

package/src/models.ts

@@ -184,6 +184,13 @@ interface KimiServerModel {
   supports_thinking_type?: unknown;
   protocol?: unknown;
   think_efforts?: unknown;
+  // Unified schema (upstream kimi-code #4209). The server currently sends
+  // both shapes; the official client already reads ONLY these fields, so
+  // prefer them and treat the flat legacy fields above as fallback.
+  limit?: unknown;
+  reasoning?: unknown;
+  modalities?: unknown;
+  tools?: unknown;
 }
 
 function parseSupportsThinkingType(value: unknown): "only" | "no" | "both" | undefined {
@@ -221,28 +228,89 @@ function parseThinkEfforts(value: unknown): {
   };
 }
 
+// Unified `reasoning` object: { type: "only" | "both" | "none", effort: {
+// valid: [...], default } }. A missing object means the legacy flat fields
+// decide; a present object always wins (type "none" clears a stale thinking
+// default, matching upstream's three-state mapping to internal "no").
+function parseUnifiedReasoning(value: unknown): {
+  readonly matched: boolean;
+  readonly supportsThinkingType?: "only" | "no" | "both";
+  readonly supportsReasoning?: boolean;
+  readonly supportEfforts?: string[];
+  readonly defaultEffort?: string;
+} {
+  if (!isRecord(value)) return { matched: false };
+  const rawType = value.type;
+  const supportsThinkingType =
+    rawType === "only" || rawType === "both" ? rawType : rawType === "none" ? "no" : undefined;
+  const effort = isRecord(value.effort) ? value.effort : undefined;
+  const supportEfforts = Array.isArray(effort?.valid)
+    ? effort.valid.filter((e): e is string => typeof e === "string" && !!e)
+    : undefined;
+  const rawDefault =
+    typeof effort?.default === "string" && effort.default ? effort.default : undefined;
+  // A default not listed in valid is dropped, same as upstream.
+  const defaultEffort =
+    rawDefault && supportEfforts && !supportEfforts.includes(rawDefault) ? undefined : rawDefault;
+  return {
+    matched: true,
+    ...(supportsThinkingType ? { supportsThinkingType } : {}),
+    supportsReasoning: supportsThinkingType !== undefined && supportsThinkingType !== "no",
+    ...(supportEfforts && supportEfforts.length > 0 ? { supportEfforts } : {}),
+    ...(defaultEffort ? { defaultEffort } : {}),
+  };
+}
+
+function parseInputModalities(value: unknown): {
+  supportsImageIn?: boolean;
+  supportsVideoIn?: boolean;
+} {
+  if (!isRecord(value) || !Array.isArray(value.input)) return {};
+  const input = value.input;
+  return {
+    supportsImageIn: input.includes("image"),
+    supportsVideoIn: input.includes("video"),
+  };
+}
+
 function parseKimiModelMetadata(model: KimiServerModel): KimiModelMetadata | undefined {
   if (typeof model.id !== "string" || !model.id) return undefined;
   const metadata: KimiModelMetadata = { wireModelId: model.id };
   if (typeof model.display_name === "string") metadata.modelDisplay = model.display_name;
-  if (typeof model.context_length === "number" && model.context_length > 0) {
+  // Unified limit.context wins over legacy context_length.
+  const limit = isRecord(model.limit) ? model.limit : undefined;
+  if (typeof limit?.context === "number" && limit.context > 0) {
+    metadata.contextLength = limit.context;
+  } else if (typeof model.context_length === "number" && model.context_length > 0) {
     metadata.contextLength = model.context_length;
   }
-  const thinkingType = parseSupportsThinkingType(model.supports_thinking_type);
-  if (thinkingType) {
-    metadata.supportsThinkingType = thinkingType;
-  } else if (typeof model.supports_reasoning === "boolean") {
-    metadata.supportsReasoning = model.supports_reasoning;
-  }
-  if (typeof model.supports_image_in === "boolean") {
-    metadata.supportsImageIn = model.supports_image_in;
+  const unifiedReasoning = parseUnifiedReasoning(model.reasoning);
+  if (unifiedReasoning.matched) {
+    const { matched: _, ...fields } = unifiedReasoning;
+    Object.assign(metadata, fields);
+  } else {
+    const thinkingType = parseSupportsThinkingType(model.supports_thinking_type);
+    if (thinkingType) {
+      metadata.supportsThinkingType = thinkingType;
+    } else if (typeof model.supports_reasoning === "boolean") {
+      metadata.supportsReasoning = model.supports_reasoning;
+    }
+    Object.assign(metadata, parseThinkEfforts(model.think_efforts));
   }
-  if (typeof model.supports_video_in === "boolean") {
-    metadata.supportsVideoIn = model.supports_video_in;
+  const modalities = parseInputModalities(model.modalities);
+  if (modalities.supportsImageIn !== undefined) {
+    metadata.supportsImageIn = modalities.supportsImageIn;
+    metadata.supportsVideoIn = modalities.supportsVideoIn;
+  } else {
+    if (typeof model.supports_image_in === "boolean") {
+      metadata.supportsImageIn = model.supports_image_in;
+    }
+    if (typeof model.supports_video_in === "boolean") {
+      metadata.supportsVideoIn = model.supports_video_in;
+    }
   }
   const protocol = parseKimiCatalogProtocol(model.protocol);
   if (protocol) metadata.protocol = protocol;
-  Object.assign(metadata, parseThinkEfforts(model.think_efforts));
   return metadata;
 }