pi-provider-kimi-code 0.6.7 → 0.6.9

package/index.ts

@@ -27,6 +27,9 @@ import {
 import { Input, SettingsList, type SettingItem, truncateToWidth } from "@earendil-works/pi-tui";
 import os from "node:os";
 
+// pi-ai <=0.79 has no "./compat"
+const piAiCompatModule = "@earendil-works/pi-ai/compat";
+
 import {
   type KimiCodeConfig,
   type KimiCodeConfigPatch,
@@ -38,11 +41,16 @@ import {
   saveProjectKimiCodeConfig,
   type KimiToolName,
 } from "./src/config.ts";
-import { PROVIDER_ID, PROVIDER_VERSION, getBaseUrl, getKimiApiType } from "./src/constants.ts";
+import {
+  KIMI_GLOBAL_FALLBACK_SOURCE_ID,
+  PROVIDER_ID,
+  PROVIDER_VERSION,
+  getBaseUrl,
+  getKimiApiType,
+} from "./src/constants.ts";
 import {
   type KimiOAuthCredentials,
   type KimiOAuthExtras,
-  applyKimiMembershipLimitsToModel,
   buildKimiModelFromConfig,
   applyKimiOAuthExtrasToModel,
   KIMI_CODING_HIGHSPEED_MODEL_ID,
@@ -51,10 +59,15 @@ import {
   KIMI_MODEL_CATALOG_VERSION,
   discoverKimiModelMetadata,
   getKimiModelMetadata,
-  isKimiModelAvailableForMembership,
+  hasKimiModelMetadata,
   resolveKimiModelConfig,
 } from "./src/models.ts";
-import { getKimiApiKey, loginKimiCode, refreshKimiCodeToken } from "./src/oauth.ts";
+import {
+  getKimiApiKey,
+  loginKimiCode,
+  refreshKimiAuthToken,
+  refreshKimiCodeToken,
+} from "./src/oauth.ts";
 import { isKimiProjectConfigApproved } from "./src/project-trust.ts";
 import {
   type KimiConfigScope,
@@ -70,8 +83,8 @@ import { buildKimiDatasourceTool } from "./src/tools/datasource.ts";
 interface KimiRuntimeState {
   cwd: string;
   config: KimiCodeConfig;
+  fallbackSourceId: string;
   modelExtras: KimiOAuthExtras;
-  membershipLevel: string | null;
   projectTrusted: boolean;
   overrides?: KimiCodeConfigPatch;
 }
@@ -143,15 +156,30 @@ function applyEffectiveKimiRuntimeConfig(
   return config;
 }
 
-async function refreshModelExtras(state: KimiRuntimeState): Promise<boolean> {
-  const token = getKimiUsageToken();
+async function refreshModelExtras(
+  state: KimiRuntimeState,
+  token = getKimiUsageToken(),
+): Promise<boolean> {
   if (!token) return false;
-  const extras = await discoverKimiModelMetadata(token, state.config.protocol);
+  const extras = await discoverKimiModelMetadata(token, state.config.protocol, {
+    refreshAccessToken: refreshKimiAuthToken,
+  });
   if (Object.keys(extras).length === 0) return false;
   Object.assign(state.modelExtras, extras);
   return true;
 }
 
+// Discovery can lose a race with a concurrent OAuth refresh: the token it
+// started with may already be dead by the time the request goes out. Retry
+// once, but only when the stored token actually changed underneath us.
+async function discoverModelExtras(state: KimiRuntimeState): Promise<boolean> {
+  const token = getKimiUsageToken();
+  if (await refreshModelExtras(state, token)) return true;
+  const refreshedToken = getKimiUsageToken();
+  if (!refreshedToken || refreshedToken === token) return false;
+  return refreshModelExtras(state, refreshedToken);
+}
+
 async function openSettingsMenu(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
@@ -167,10 +195,7 @@ async function openSettingsMenu(
   if (!modelsRefreshed && refreshedToken && refreshedToken !== modelDiscoveryToken) {
     modelsRefreshed = await refreshModelExtras(state);
   }
-  const refreshedMembershipLevel = usageSnapshot.membershipLevel ?? state.membershipLevel;
-  const membershipChanged = state.membershipLevel !== refreshedMembershipLevel;
-  state.membershipLevel = refreshedMembershipLevel;
-  if (modelsRefreshed || membershipChanged) registerKimiProvider(pi, state);
+  if (modelsRefreshed) await registerKimiProvider(pi, state);
   const usage = usageSnapshot.summary;
 
   const projectTrusted = await isKimiProjectConfigApproved(ctx, ctx.cwd);
@@ -382,74 +407,125 @@ function saveScopeKimiCodeConfig(
 function filterAvailableKimiModels<T extends { id: string }>(
   models: T[],
   extras: KimiOAuthExtras,
-  membershipLevel: string | null,
 ): T[] {
   const available =
     extras.modelCatalogVersion === KIMI_MODEL_CATALOG_VERSION && extras.modelCatalog
       ? new Set(Object.keys(extras.modelCatalog))
       : null;
-  return models.filter(
-    (model) =>
-      (!available || available.has(model.id)) &&
-      isKimiModelAvailableForMembership(model.id, membershipLevel) !== false,
-  );
+  return models.filter((model) => !available || available.has(model.id));
 }
 
-function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
-  const standardModel = applyKimiMembershipLimitsToModel(
-    applyKimiOAuthExtrasToModel(
-      buildKimiModelFromConfig(state.config.model),
-      getKimiModelMetadata(state.modelExtras, KIMI_CODING_MODEL_ID),
-    ),
-    state.membershipLevel,
-  );
-  const highSpeedModel = applyKimiMembershipLimitsToModel(
-    applyKimiOAuthExtrasToModel(
-      buildKimiModelFromConfig(state.config.model, KIMI_CODING_HIGHSPEED_MODEL_ID),
-      getKimiModelMetadata(state.modelExtras, KIMI_CODING_HIGHSPEED_MODEL_ID),
-    ),
-    state.membershipLevel,
-  );
-  const k3Model = applyKimiMembershipLimitsToModel(
+function catalogModelIds(extras: KimiOAuthExtras): string[] {
+  if (extras.modelCatalogVersion === KIMI_MODEL_CATALOG_VERSION && extras.modelCatalog) {
+    return Object.keys(extras.modelCatalog);
+  }
+  return [KIMI_CODING_MODEL_ID, KIMI_CODING_HIGHSPEED_MODEL_ID, KIMI_K3_MODEL_ID];
+}
+
+function buildKimiCatalogModels(state: KimiRuntimeState) {
+  return catalogModelIds(state.modelExtras).map((modelId) =>
     applyKimiOAuthExtrasToModel(
-      buildKimiModelFromConfig(state.config.model, KIMI_K3_MODEL_ID),
-      getKimiModelMetadata(state.modelExtras, KIMI_K3_MODEL_ID),
+      buildKimiModelFromConfig(state.config.model, modelId),
+      getKimiModelMetadata(state.modelExtras, modelId),
+      state.config.model.reasoningMap,
     ),
-    state.membershipLevel,
   );
+}
 
+// Node reports a missing subpath export (pi-ai <=0.79) and a missing package
+// with these codes. Both mean "this pi-ai has no compat layer", which is an
+// expected configuration rather than a failure worth reporting: the fallback
+// simply does not exist there.
+const MODULE_UNAVAILABLE_CODES = new Set(["ERR_MODULE_NOT_FOUND", "ERR_PACKAGE_PATH_NOT_EXPORTED"]);
+
+// Every api id this extension can hand out, not only the one for the currently
+// configured protocol: sessions persist the api id that was current when the
+// model was resolved, so a session created before a protocol switch still
+// carries the other id and would keep crashing. streamSimpleKimi routes on the
+// model's wireProtocol / the resolved runtime config and never on model.api, so
+// both ids dispatch identically.
+const KIMI_FALLBACK_APIS = [getKimiApiType("openai"), getKimiApiType("anthropic")];
+
+type PiAiApiRegistry = {
+  registerApiProvider: (
+    provider: {
+      api: string;
+      stream: typeof streamSimpleKimi;
+      streamSimple: typeof streamSimpleKimi;
+    },
+    sourceId: string,
+  ) => void;
+  unregisterApiProviders: (sourceId: string) => void;
+  getApiProvider: (api: string) => unknown;
+};
+
+async function loadPiAiApiRegistry(action: string): Promise<PiAiApiRegistry | null> {
+  try {
+    return (await import(piAiCompatModule)) as PiAiApiRegistry;
+  } catch (error: unknown) {
+    const code = (error as { code?: unknown } | undefined)?.code;
+    if (typeof code === "string" && MODULE_UNAVAILABLE_CODES.has(code)) return null;
+    console.error(
+      `[pi-provider-kimi-code] failed to ${action} the global api fallback:`,
+      error instanceof Error ? error.message : error,
+    );
+    return null;
+  }
+}
+
+let nextFallbackSourceId = 0;
+const liveFallbackSources = new Set<string>();
+
+function createKimiGlobalFallbackSourceId(): string {
+  nextFallbackSourceId += 1;
+  return `${KIMI_GLOBAL_FALLBACK_SOURCE_ID}:${nextFallbackSourceId}`;
+}
+
+async function registerKimiGlobalApiFallback(sourceId: string): Promise<void> {
+  if (!liveFallbackSources.has(sourceId)) return;
+  const registry = await loadPiAiApiRegistry("register");
+  if (!registry) return;
+  for (const api of KIMI_FALLBACK_APIS) {
+    // Never displace an entry someone else owns: this is a shared,
+    // process-wide table and the fallback only exists to fill a hole, not to
+    // win a conflict. pi-ai installs its own builtins under the same rule.
+    if (registry.getApiProvider(api)) continue;
+    registry.registerApiProvider(
+      { api, stream: streamSimpleKimi, streamSimple: streamSimpleKimi },
+      sourceId,
+    );
+  }
+}
+
+// The registry outlives each session. Remove only the entries owned by the
+// retiring runtime, then hand any holes to another live runtime.
+async function unregisterKimiGlobalApiFallback(sourceId: string): Promise<void> {
+  if (!liveFallbackSources.delete(sourceId)) return;
+  const registry = await loadPiAiApiRegistry("unregister");
+  if (!registry) return;
+  registry.unregisterApiProviders(sourceId);
+  const successor = liveFallbackSources.values().next().value;
+  if (successor) await registerKimiGlobalApiFallback(successor);
+}
+
+async function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): Promise<void> {
+  await registerKimiGlobalApiFallback(state.fallbackSourceId);
   pi.registerProvider(PROVIDER_ID, {
     baseUrl: getBaseUrl(state.config.protocol),
     apiKey: "$KIMI_API_KEY",
     api: getKimiApiType(state.config.protocol),
     streamSimple: streamSimpleKimi,
 
-    models: filterAvailableKimiModels(
-      [standardModel, highSpeedModel, k3Model],
-      state.modelExtras,
-      state.membershipLevel,
-    ),
+    models: filterAvailableKimiModels(buildKimiCatalogModels(state), state.modelExtras),
 
     oauth: {
       name: "Kimi Code (OAuth)",
       login: async (callbacks) => {
         const credentials = await loginKimiCode(callbacks);
-        const usage = await fetchKimiUsageSnapshot({
-          timeoutMs: 2500,
-          token: credentials.access,
-          refreshOnUnauthorized: false,
-        });
-        state.membershipLevel = usage.membershipLevel;
         return credentials;
       },
       refreshToken: async (credentials) => {
         const refreshed = await refreshKimiCodeToken(credentials);
-        const usage = await fetchKimiUsageSnapshot({
-          timeoutMs: 2500,
-          token: refreshed.access,
-          refreshOnUnauthorized: false,
-        });
-        state.membershipLevel = usage.membershipLevel;
         return refreshed;
       },
       getApiKey: getKimiApiKey,
@@ -460,32 +536,102 @@ function registerKimiProvider(pi: ExtensionAPI, state: KimiRuntimeState): void {
       // request payload by streamSimpleKimi.
       modifyModels: (models, cred) => {
         const extras = cred as KimiOAuthCredentials;
-        state.modelExtras = extras;
+        // Retain previously discovered extras when this credential carries
+        // none (legacy format or failed discovery): applying empty metadata
+        // would strip thinking levels the startup discovery already found.
+        if (hasKimiModelMetadata(extras)) state.modelExtras = extras;
         reloadEffectiveKimiRuntimeConfig(state, state.cwd, state.projectTrusted);
         const available =
           extras.modelCatalogVersion === KIMI_MODEL_CATALOG_VERSION && extras.modelCatalog
             ? new Set(Object.keys(extras.modelCatalog))
             : null;
-        return models
-          .filter(
-            (model) =>
-              model.provider !== PROVIDER_ID ||
-              ((!available || available.has(model.id)) &&
-                isKimiModelAvailableForMembership(model.id, state.membershipLevel) !== false),
-          )
-          .map((model) =>
-            model.provider === PROVIDER_ID
-              ? applyKimiMembershipLimitsToModel(
-                  applyKimiOAuthExtrasToModel(model, getKimiModelMetadata(extras, model.id)),
-                  state.membershipLevel,
-                )
-              : model,
+        if (!available) {
+          return [
+            ...models.filter((model) => model.provider !== PROVIDER_ID),
+            ...models
+              .filter((model) => model.provider === PROVIDER_ID)
+              .map((model) => {
+                const metadata = getKimiModelMetadata(extras, model.id);
+                if (!hasKimiModelMetadata(metadata)) return model;
+                return applyKimiOAuthExtrasToModel(
+                  model,
+                  metadata,
+                  state.config.model.reasoningMap,
+                );
+              }),
+          ];
+        }
+        const catalogModels = catalogModelIds(extras).map((modelId) => {
+          const existing = models.find(
+            (model) => model.provider === PROVIDER_ID && model.id === modelId,
           );
+          return applyKimiOAuthExtrasToModel(
+            existing ?? {
+              ...buildKimiModelFromConfig(state.config.model, modelId),
+              api: getKimiApiType(state.config.protocol),
+              provider: PROVIDER_ID,
+              baseUrl: getBaseUrl(state.config.protocol),
+            },
+            getKimiModelMetadata(extras, modelId),
+            state.config.model.reasoningMap,
+          );
+        });
+        let insertedCatalog = false;
+        return models.flatMap((model) => {
+          if (model.provider !== PROVIDER_ID) return [model];
+          if (insertedCatalog) return [];
+          insertedCatalog = true;
+          return catalogModels;
+        });
       },
     },
   });
 }
 
+// What pi throws from any `pi` method once the extension runtime behind it has
+// been retired, which is what a /reload does. Same wording on every version
+// this extension supports (0.78.1 through 0.82.0); if it ever changes, the
+// worst case is that a reload race gets logged instead of ignored.
+const STALE_EXTENSION_RUNTIME_PREFIX = "This extension ctx is stale";
+
+let pendingModelDiscovery: Promise<void> = Promise.resolve();
+
+/**
+ * Resolves once the discovery started by the most recent extension load has
+ * settled. Nothing in the runtime waits for it; it exists so tests can observe
+ * the deferred registration without polling.
+ */
+export function kimiModelDiscoverySettled(): Promise<void> {
+  return pendingModelDiscovery;
+}
+
+// pi's extension loader awaits this factory before it builds the session, and
+// the TUI only draws its first frame after that returns, so a network round
+// trip here is a stall the user sees on every launch and every /reload. The
+// stored OAuth credential already carries the last known catalog (pi replays it
+// through oauth.modifyModels), so register what the config describes right away
+// and fold the fresh metadata in when it lands.
+function startModelDiscovery(pi: ExtensionAPI, state: KimiRuntimeState): void {
+  pendingModelDiscovery = discoverModelExtras(state)
+    .then((discovered) => {
+      if (!discovered) return;
+      reloadEffectiveKimiRuntimeConfig(state, state.cwd, state.projectTrusted);
+      return registerKimiProvider(pi, state);
+    })
+    .catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error);
+      // A /reload retires this extension runtime while discovery may still be
+      // in flight, and registering against a retired runtime throws. The
+      // reloaded factory runs its own discovery, so there is nothing to redo.
+      if (message.startsWith(STALE_EXTENSION_RUNTIME_PREFIX)) return;
+      // Anything else used to surface as an extension load failure, back when
+      // this ran inside the factory. Deferring it must not make it invisible:
+      // the provider stays registered with the metadata it already had, and
+      // the user needs to know why it stopped refreshing.
+      console.error("[kimi-coding] deferred model discovery failed:", message);
+    });
+}
+
 export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
   return async (pi: ExtensionAPI) => {
     const cwd = process.cwd();
@@ -493,30 +639,22 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
       { cwd, home: os.homedir(), includeProject: false },
       overrides,
     );
-    const discoveryToken = getKimiUsageToken();
-    const [initialDiscovery, usageSnapshot] = await Promise.all([
-      discoveryToken ? discoverKimiModelMetadata(discoveryToken, config.protocol) : {},
-      fetchKimiUsageSnapshot({ timeoutMs: 2500 }),
-    ]);
-    let discovered = initialDiscovery;
-    const refreshedToken = getKimiUsageToken();
-    if (
-      Object.keys(discovered).length === 0 &&
-      refreshedToken &&
-      refreshedToken !== discoveryToken
-    ) {
-      discovered = await discoverKimiModelMetadata(refreshedToken, config.protocol);
-    }
     const state: KimiRuntimeState = {
       cwd,
       config,
-      modelExtras: discovered,
-      membershipLevel: usageSnapshot.membershipLevel,
+      fallbackSourceId: createKimiGlobalFallbackSourceId(),
+      modelExtras: {},
       projectTrusted: false,
       overrides,
     };
     reloadEffectiveKimiRuntimeConfig(state, cwd, false);
-    registerKimiProvider(pi, state);
+    liveFallbackSources.add(state.fallbackSourceId);
+    try {
+      await registerKimiProvider(pi, state);
+    } catch (error) {
+      liveFallbackSources.delete(state.fallbackSourceId);
+      throw error;
+    }
 
     registerConfiguredMoonshotTools(pi, state.config, { updateActiveTools: false });
 
@@ -526,7 +664,11 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
         updateActiveTools: true,
         projectTrusted,
       });
-      registerKimiProvider(pi, state);
+      await registerKimiProvider(pi, state);
+    });
+
+    pi.on("session_shutdown", async () => {
+      await unregisterKimiGlobalApiFallback(state.fallbackSourceId);
     });
 
     pi.registerCommand("kimi-settings", {
@@ -539,6 +681,8 @@ export function KimiCode(overrides?: KimiCodeConfigPatch): ExtensionFactory {
         await openSettingsMenu(pi, ctx, state);
       },
     });
+
+    startModelDiscovery(pi, state);
   };
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.7",
-  "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
+  "version": "0.6.9",
+  "description": "Kimi Code harness extension for Pi: shared login state, file uploads, and Kimi-native tools",
   "keywords": [
     "ai-provider",
     "coding-agent",
@@ -53,9 +53,9 @@
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.80.9",
-    "@earendil-works/pi-coding-agent": "^0.80.9",
-    "@earendil-works/pi-tui": "^0.80.9",
+    "@earendil-works/pi-ai": "^0.82.0",
+    "@earendil-works/pi-coding-agent": "^0.82.0",
+    "@earendil-works/pi-tui": "^0.82.0",
     "@j178/prek": "^0.4.4",
     "@types/node": "^24.0.0",
     "@types/proper-lockfile": "^4.1.4",

package/src/constants.ts

@@ -41,12 +41,12 @@ export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const PROVIDER_VERSION = "0.6.7";
+export const PROVIDER_VERSION = "0.6.9";
 
 // Upstream kimi-code CLI version — used in User-Agent and X-Msh-Version
 // headers to match the official client's identity. Update this when
 // syncing with https://github.com/MoonshotAI/kimi-code.
-export const KIMI_UPSTREAM_VERSION = "0.26.0";
+export const KIMI_UPSTREAM_VERSION = "0.29.1";
 export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_UPSTREAM_VERSION}`;
 export const KIMI_PLATFORM = "kimi_code_cli";
 
@@ -63,6 +63,10 @@ export const RETRYABLE_REFRESH_STATUSES = new Set([429, 500, 502, 503, 504]);
 
 export const PROVIDER_ID = "kimi-coding";
 
+// Owner tag for the entries this extension adds to pi-ai's global api-provider
+// registry, so they can be identified and removed as a group.
+export const KIMI_GLOBAL_FALLBACK_SOURCE_ID = "pi-provider-kimi-code-global-fallback";
+
 export function getOAuthHost(): string {
   const value =
     process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;

package/src/device.ts

@@ -1,10 +1,10 @@
 // Device identification: device-id persistence, Kimi Code-compatible request
 // headers, and the cross-platform device-model string. Pure helpers live near
-// the side-effecting one-shots (file IO, exec) they support.
+// the side-effecting one-shots (file IO) they support.
 
-import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import os from "node:os";
 import { dirname } from "node:path";
 
@@ -97,25 +97,68 @@ export function computeDeviceModel(input: DeviceModelInput): string {
   return `${system} ${arch}`.trim();
 }
 
-function macOsProductVersion(): string | undefined {
-  try {
-    const version = execFileSync("/usr/bin/sw_vers", ["-productVersion"], {
-      encoding: "utf-8",
-      timeout: 1000,
-    }).trim();
-    return version.length > 0 ? version : undefined;
-  } catch {
-    return undefined;
-  }
+// Where macOS keeps its product version. Upstream Kimi Code reads it through
+// Python's platform.mac_ver(), which parses this same file, so it is the same
+// source of truth as `sw_vers -productVersion` without the process spawn: a
+// spawn costs ~10ms of blocked event loop, and pi pays it again on every
+// /reload because it re-evaluates extension modules.
+const MAC_PRODUCT_VERSION_PATH = "/System/Library/CoreServices/SystemVersion.plist";
+
+// Exposed for tests. The plist is a flat XML property list, so the version sits
+// in the <string> immediately after the ProductVersion key.
+export function parseMacProductVersion(plist: string): string | undefined {
+  const match = /<key>ProductVersion<\/key>\s*<string>([^<]*)<\/string>/.exec(plist);
+  return match?.[1].trim() || undefined;
 }
 
-function getDeviceModel(): string {
-  return computeDeviceModel({
+let DEVICE_MODEL: string | undefined;
+
+function setDeviceModel(macVersion: string | undefined): string {
+  DEVICE_MODEL ??= computeDeviceModel({
     platform: process.platform,
     release: os.release(),
     arch: os.machine() || process.arch,
-    macVersion: process.platform === "darwin" ? macOsProductVersion() : undefined,
+    macVersion,
   });
+  return DEVICE_MODEL;
+}
+
+async function loadMacDeviceModel(): Promise<void> {
+  try {
+    setDeviceModel(parseMacProductVersion(await readFile(MAC_PRODUCT_VERSION_PATH, "utf-8")));
+  } catch {
+    setDeviceModel(undefined);
+  }
+}
+
+/**
+ * Settles once the module-load lookup has produced a device model. Nothing in
+ * the provider waits for it — headers stay synchronous — but tests use it to
+ * exercise the async path without racing the fallback below.
+ */
+export const deviceModelReady: Promise<void> = (() => {
+  if (process.platform !== "darwin") {
+    // Nothing to read: every other platform derives the model from os.release().
+    setDeviceModel(undefined);
+    return Promise.resolve();
+  }
+  // Read the version off the event loop at module load so the value is usually
+  // in place before anything asks for a header.
+  return loadMacDeviceModel();
+})();
+
+function getDeviceModel(): string {
+  if (DEVICE_MODEL !== undefined) return DEVICE_MODEL;
+  // A header was needed before the async read landed. Read the same file
+  // synchronously rather than reporting the kernel release, which would put a
+  // different device model on the wire than every later request. This costs
+  // ~0.02ms against the ~10ms a `sw_vers` subprocess used to cost, and both
+  // paths memoize into the same slot.
+  try {
+    return setDeviceModel(parseMacProductVersion(readFileSync(MAC_PRODUCT_VERSION_PATH, "utf-8")));
+  } catch {
+    return setDeviceModel(undefined);
+  }
 }
 
 export function getOsVersion(): string {
@@ -133,7 +176,6 @@ export function asciiHeaderValue(value: string, fallback = "unknown"): string {
   return sanitized || fallback;
 }
 
-const DEVICE_MODEL = getDeviceModel();
 let DEVICE_ID: string | null = null;
 
 function getStableDeviceId(): string {
@@ -174,7 +216,7 @@ export function getCommonHeaders(): Record<string, string> {
     "X-Msh-Platform": KIMI_PLATFORM,
     "X-Msh-Version": KIMI_UPSTREAM_VERSION,
     "X-Msh-Device-Name": os.hostname(),
-    "X-Msh-Device-Model": DEVICE_MODEL,
+    "X-Msh-Device-Model": getDeviceModel(),
     "X-Msh-Os-Version": getOsVersion(),
     "X-Msh-Device-Id": getStableDeviceId(),
   };