fix: send the product User-Agent on provider registry and catalog fetches

.changeset/registry-fetch-user-agent.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Send the kimi-code-cli User-Agent on provider registry (api.json) and model catalog fetches, so registries can identify the client version.

apps/kimi-code/src/cli/sub/provider.ts

@@ -35,7 +35,7 @@ import {
 } from '@moonshot-ai/kimi-code-sdk';
 import type { Command } from 'commander';
 
-import { createKimiCodeHostIdentity } from '#/cli/version';
+import { createKimiCodeHostIdentity, createKimiCodeUserAgent } from '#/cli/version';
 
 interface WritableLike {
   write(chunk: string): boolean;
@@ -99,7 +99,7 @@ export async function handleProviderAdd(
 
   let entries: Awaited<ReturnType<typeof fetchCustomRegistry>>;
   try {
-    entries = await fetchCustomRegistry(source);
+    entries = await fetchCustomRegistry(source, { userAgent: createKimiCodeUserAgent() });
   } catch (error) {
     const suffix = error instanceof CustomRegistryApiError ? ` (HTTP ${String(error.status)})` : '';
     deps.stderr.write(`Failed to fetch registry${suffix}: ${errorMessage(error)}\n`);
@@ -398,7 +398,7 @@ export async function handleCatalogAdd(
 
 async function loadCatalogOrExit(deps: ProviderDeps, url: string): Promise<Catalog> {
   try {
-    return await fetchCatalog(url);
+    return await fetchCatalog(url, { userAgent: createKimiCodeUserAgent() });
   } catch (error) {
     const suffix = error instanceof CatalogFetchError ? ` (HTTP ${String(error.status)})` : '';
     deps.stderr.write(`Failed to fetch catalog from ${url}${suffix}: ${errorMessage(error)}\n`);

apps/kimi-code/src/cli/version.ts

@@ -7,7 +7,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 
-import { createKimiDefaultHeaders, type KimiHostIdentity } from '@moonshot-ai/kimi-code-oauth';
+import { createKimiDefaultHeaders, createKimiUserAgent, type KimiHostIdentity } from '@moonshot-ai/kimi-code-oauth';
 
 import { CLI_USER_AGENT_PRODUCT } from '#/constant/app';
 
@@ -55,6 +55,14 @@ export function createKimiCodeHostIdentity(version = getVersion()): KimiHostIden
   };
 }
 
+/**
+ * Product User-Agent (`kimi-code-cli/<version>`) for ad-hoc outbound fetches
+ * that don't go through the provider pipeline (registry / catalog imports).
+ */
+export function createKimiCodeUserAgent(version = getVersion()): string {
+  return createKimiUserAgent(createKimiCodeHostIdentity(version));
+}
+
 export function buildKimiDefaultHeaders(version: string): Record<string, string> {
   return createKimiDefaultHeaders({
     homeDir: getDataDir(),

apps/kimi-code/src/tui/commands/provider.ts

@@ -16,6 +16,7 @@ import {
   type ThinkingEffort,
 } from '@moonshot-ai/kimi-code-sdk';
 
+import { createKimiCodeUserAgent } from '#/cli/version';
 import { ChoicePickerComponent } from '../components/dialogs/choice-picker';
 import {
   CustomRegistryImportDialogComponent,
@@ -160,7 +161,10 @@ async function handleCatalogProviderAdd(host: SlashCommandHost): Promise<void> {
   const spinner = host.showLoginProgressSpinner(`Fetching catalog from ${DEFAULT_CATALOG_URL}`);
   let catalog: Catalog | undefined;
   try {
-    catalog = await fetchCatalog(DEFAULT_CATALOG_URL, controller.signal);
+    catalog = await fetchCatalog(DEFAULT_CATALOG_URL, {
+      signal: controller.signal,
+      userAgent: createKimiCodeUserAgent(),
+    });
     spinner.stop({ ok: true, label: 'Catalog loaded.' });
   } catch (error) {
     if (controller.signal.aborted) {
@@ -276,7 +280,7 @@ async function handleCustomRegistryAddViaDialog(host: SlashCommandHost): Promise
 
   let entries: Awaited<ReturnType<typeof fetchCustomRegistry>>;
   try {
-    entries = await fetchCustomRegistry(source);
+    entries = await fetchCustomRegistry(source, { userAgent: createKimiCodeUserAgent() });
   } catch (error) {
     host.showError(`Failed to import registry: ${formatErrorMessage(error)}`);
     return false;

apps/kimi-code/src/tui/controllers/auth-flow.ts

@@ -1,4 +1,7 @@
 import type { CreateSessionOptions, KimiHarness, Session } from '@moonshot-ai/kimi-code-sdk';
+
+import { createKimiCodeUserAgent } from '#/cli/version';
+
 import type { SkillListSession } from '../commands';
 
 import { OAUTH_LOGIN_REQUIRED_STARTUP_NOTICE } from '../constant/kimi-tui';
@@ -173,6 +176,7 @@ export class AuthFlowController {
           const tokenProvider = host.harness.auth.resolveOAuthTokenProvider(providerName, oauthRef);
           return tokenProvider.getAccessToken();
         },
+        userAgent: createKimiCodeUserAgent(),
       },
       { scope },
     );

apps/kimi-code/src/tui/utils/refresh-providers.ts

@@ -17,6 +17,8 @@ export interface RefreshProviderHost {
   removeProvider(providerId: string): Promise<KimiConfig>;
   setConfig(patch: KimiConfigPatch): Promise<KimiConfig>;
   resolveOAuthToken(providerName: string, oauthRef?: OAuthRef): Promise<string>;
+  /** Product User-Agent sent on custom-registry (api.json) fetches. */
+  readonly userAgent?: string;
 }
 
 export type { ProviderChange, RefreshProviderOptions, RefreshProviderScope, RefreshResult };
@@ -37,6 +39,7 @@ export async function refreshAllProviderModels(
       setConfig: (patch) => host.setConfig(patch as unknown as KimiConfigPatch),
       resolveOAuthToken: (providerName, oauthRef) =>
         host.resolveOAuthToken(providerName, oauthRef as unknown as OAuthRef),
+      userAgent: host.userAgent,
     },
     options,
   );

apps/kimi-code/test/cli/version.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it } from 'vitest';
 
 import {
   buildKimiDefaultHeaders,
+  createKimiCodeUserAgent,
   getHostPackageJsonPath,
   getHostPackageRoot,
   getVersion,
@@ -25,4 +26,8 @@ describe('cli version helpers', () => {
 
     expect(headers['User-Agent']).toBe('kimi-code-cli/1.2.3');
   });
+
+  it('builds the product user-agent for ad-hoc fetches', () => {
+    expect(createKimiCodeUserAgent('1.2.3')).toBe('kimi-code-cli/1.2.3');
+  });
 });

packages/agent-core-v2/src/app/modelCatalog/modelCatalogService.ts

@@ -32,6 +32,7 @@ import { IConfigService } from '#/app/config/config';
 import { ErrorCodes, Error2 } from '#/errors';
 import { IEventService } from '#/app/event/event';
 import { IModelService, MODELS_SECTION, type ModelAlias } from '#/app/model/model';
+import { IHostRequestHeaders } from '#/app/model/hostRequestHeaders';
 import {
   IProviderService,
   type OAuthRef,
@@ -66,6 +67,7 @@ export class ModelCatalogService implements IModelCatalogService {
     @IConfigService private readonly config: IConfigService,
     @IOAuthService private readonly oauth: IOAuthService,
     @IEventService private readonly events: IEventService,
+    @IHostRequestHeaders private readonly hostRequestHeaders: IHostRequestHeaders,
   ) {}
 
   async listModels(): Promise<readonly ModelCatalogItem[]> {
@@ -151,6 +153,9 @@ export class ModelCatalogService implements IModelCatalogService {
       removeProvider: (providerId) => this.removeProviderForRefresh(providerId),
       setConfig: (patch) => this.applyRefreshPatch(patch),
       resolveOAuthToken: (providerName, oauthRef) => this.resolveOAuthToken(providerName, oauthRef),
+      // Mirrors ModelResolverService: only the User-Agent leaves the host, so
+      // device identity never reaches third-party registry endpoints.
+      userAgent: this.hostRequestHeaders.headers['User-Agent'],
     };
   }
 

packages/agent-core-v2/test/app/modelCatalog/modelCatalog.test.ts

@@ -22,6 +22,7 @@ import { MODEL_CATALOG_SECTION } from '#/app/modelCatalog/configSection';
 import { IModelCatalogService } from '#/app/modelCatalog/modelCatalog';
 import { ModelCatalogService } from '#/app/modelCatalog/modelCatalogService';
 import { IModelService, type ModelAlias } from '#/app/model/model';
+import { HostRequestHeaders, IHostRequestHeaders } from '#/app/model/hostRequestHeaders';
 import { ModelService } from '#/app/model/modelService';
 import { IProviderService, type ProviderConfig } from '#/app/provider/provider';
 import { ProviderService } from '#/app/provider/providerService';
@@ -118,6 +119,10 @@ describe('ModelCatalogService', () => {
         reg.define(IModelService, ModelService);
         reg.define(IProviderService, ProviderService);
         reg.define(IModelCatalogService, ModelCatalogService);
+        reg.defineInstance(
+          IHostRequestHeaders,
+          new HostRequestHeaders({ 'User-Agent': 'kimi-code-cli/test' }),
+        );
       },
     });
   });
@@ -314,4 +319,43 @@ describe('ModelCatalogService', () => {
     expect(maxInFlight).toBe(1);
     expect(fetchMock).toHaveBeenCalledTimes(2);
   });
+
+  it('refreshProviderModels sends the host User-Agent on custom-registry fetches', async () => {
+    backing.providers = {
+      acme: {
+        type: 'openai',
+        apiKey: 'sk-acme',
+        source: {
+          kind: 'apiJson',
+          url: 'https://registry.example.test/api.json',
+          apiKey: 'sk-registry',
+        },
+      },
+    };
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(
+          JSON.stringify({
+            acme: {
+              id: 'acme',
+              name: 'Acme',
+              api: 'https://acme.example.test/v1',
+              type: 'openai',
+              models: { m1: { id: 'm1', name: 'M1' } },
+            },
+          }),
+          { headers: { 'Content-Type': 'application/json' } },
+        ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    await catalog().refreshProviderModels({ scope: 'all' });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://registry.example.test/api.json',
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'User-Agent': 'kimi-code-cli/test' }),
+      }),
+    );
+  });
 });

packages/agent-core/src/services/modelCatalog/modelCatalogService.ts

@@ -150,6 +150,7 @@ export class ModelCatalogService
       setConfig: (patch) => this.core.rpc.setKimiConfig(patch as Record<string, unknown>),
       resolveOAuthToken: (providerName, oauthRef) =>
         this._resolveOAuthToken(providerName, oauthRef),
+      userAgent: this.core.kimiRequestHeaders?.['User-Agent'],
     };
   }
 

packages/agent-core/test/services/model-catalog-service.test.ts

@@ -439,4 +439,52 @@ describe('ModelCatalogService', () => {
     expect(result.unchanged).toEqual([KIMI_CODE_PROVIDER_NAME]);
     expect(published).toEqual([]);
   });
+
+  it('sends the host User-Agent on custom-registry fetches', async () => {
+    const configRef: { current: KimiConfig } = {
+      current: {
+        providers: {
+          acme: {
+            type: 'openai',
+            apiKey: 'sk-acme',
+            source: {
+              kind: 'apiJson',
+              url: 'https://registry.example.test/api.json',
+              apiKey: 'sk-registry',
+            },
+          },
+        },
+        models: {},
+      },
+    };
+    const { core } = makeCore(configRef);
+    (core as { kimiRequestHeaders?: Record<string, string> }).kimiRequestHeaders = {
+      'User-Agent': 'kimi-code-cli/test',
+    };
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(
+          JSON.stringify({
+            acme: {
+              id: 'acme',
+              name: 'Acme',
+              api: 'https://acme.example.test/v1',
+              type: 'openai',
+              models: { m1: { id: 'm1', name: 'M1' } },
+            },
+          }),
+        ),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+    const svc = ModelCatalogService._createForTest(makeEnv(), core, authFacade());
+
+    await svc.refreshProviderModels();
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://registry.example.test/api.json',
+      expect.objectContaining({
+        headers: expect.objectContaining({ 'User-Agent': 'kimi-code-cli/test' }),
+      }),
+    );
+  });
 });

packages/kap-server/src/start.ts

@@ -9,6 +9,7 @@
 
 import {
   bootstrap,
+  hostRequestHeadersSeed,
   IConfigService,
   IModelCatalogService,
   logSeed,
@@ -218,6 +219,11 @@ export async function startServer(opts: ServerStartOptions = {}): Promise<Runnin
   // the session index — all persist to disk.
   const { app: core } = bootstrap({ homeDir, configPath }, [
     ...logSeed(logging),
+    // Default host identity so outbound requests (model, WebSearch, registry
+    // refresh) carry a product User-Agent even when the embedding host did not
+    // seed its own headers. Hosts like the CLI pass full Kimi identity headers
+    // through `opts.seeds`, which override this entry (last seed wins).
+    ...hostRequestHeadersSeed({ 'User-Agent': `kimi-code-cli/${hostVersion}` }),
     ...(opts.seeds ?? []),
   ]);
 

packages/kap-server/test/boot.test.ts

@@ -6,8 +6,11 @@ import { join } from 'node:path';
 import { pino } from 'pino';
 import { afterEach, describe, expect, it } from 'vitest';
 
+import { hostRequestHeadersSeed, IHostRequestHeaders } from '@moonshot-ai/agent-core-v2';
+
 import type { LockContents } from '../src/lock';
 import { listenWithPortRetry, type RunningServer, startServer } from '../src/start';
+import { getServerVersion } from '../src/version';
 import { authedFetch } from './helpers/auth';
 
 describe('server-v2 boot', () => {
@@ -76,6 +79,32 @@ describe('server-v2 boot', () => {
     expect(oauthBody.code).toBe(0);
     expect(oauthBody.data).toBeNull();
   });
+
+  it('seeds a default product User-Agent that opts.seeds can override', async () => {
+    home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-ua-'));
+    server = await startServer({
+      host: '127.0.0.1',
+      port: 0,
+      homeDir: home,
+      logLevel: 'silent',
+    });
+    const defaults = server.core.accessor.get(IHostRequestHeaders);
+    expect(defaults.headers['User-Agent']).toBe(`kimi-code-cli/${getServerVersion()}`);
+
+    // Restart on the same homeDir with a host-provided seed; it must win over
+    // the default (the CLI passes full Kimi identity headers this way).
+    await server.close();
+    server = undefined;
+    server = await startServer({
+      host: '127.0.0.1',
+      port: 0,
+      homeDir: home,
+      logLevel: 'silent',
+      seeds: hostRequestHeadersSeed({ 'User-Agent': 'custom-host/9.9' }),
+    });
+    const overridden = server.core.accessor.get(IHostRequestHeaders);
+    expect(overridden.headers['User-Agent']).toBe('custom-host/9.9');
+  });
 });
 
 function silentLogger() {

packages/node-sdk/src/catalog.ts

@@ -23,13 +23,25 @@ export class CatalogFetchError extends Error {
   }
 }
 
-/** Fetches a models.dev-style catalog. Public endpoint, no credentials needed. */
+export interface FetchCatalogOptions {
+  readonly signal?: AbortSignal;
+  readonly fetchImpl?: typeof fetch;
+  readonly userAgent?: string;
+}
+
+/**
+ * Fetches a models.dev-style catalog. Public endpoint, no credentials needed.
+ * `userAgent` identifies the host product (e.g. `kimi-code-cli/1.2.3`); when
+ * omitted the request falls back to the runtime default (`User-Agent: node`).
+ */
 export async function fetchCatalog(
   url: string,
-  signal?: AbortSignal,
-  fetchImpl: typeof fetch = fetch,
+  options: FetchCatalogOptions = {},
 ): Promise<Catalog> {
-  const res = await fetchImpl(url, { headers: { Accept: 'application/json' }, signal });
+  const { signal, fetchImpl = fetch, userAgent } = options;
+  const headers: Record<string, string> = { Accept: 'application/json' };
+  if (userAgent !== undefined) headers['User-Agent'] = userAgent;
+  const res = await fetchImpl(url, { headers, signal });
   if (!res.ok) {
     throw new CatalogFetchError(`Failed to fetch catalog (HTTP ${res.status}).`, res.status);
   }

packages/node-sdk/src/index.ts

@@ -32,6 +32,7 @@ export type {
   Catalog,
   CatalogModel,
   CatalogProviderEntry,
+  FetchCatalogOptions,
 } from '#/catalog';
 
 export {