feat(managed-kimi-code): route anthropic protocol via beta api

.changeset/kimi-code-custom-headers.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Add `KIMI_CODE_CUSTOM_HEADERS` for custom outbound LLM request headers and send the `User-Agent` header to non-Kimi providers. Set `KIMI_CODE_CUSTOM_HEADERS` to newline-separated `Name: Value` lines.

.changeset/managed-kimi-code-anthropic-beta-api.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Route managed Kimi Code models on the Anthropic-compatible protocol through the beta Messages API.

.changeset/turn-error-telemetry-protocol.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Add provider type and protocol attributes to turn and API error telemetry.

.changeset/web-completion-sound.md

@@ -1,5 +1,5 @@
 ---
-"@moonshot-ai/kimi-code": minor
+"@moonshot-ai/kimi-code": patch
 ---
 
 Add a completion sound and question notifications to the web UI, with separate Settings toggles for completion notifications, question notifications, and sound. Question notifications default off so question text only reaches your desktop after you opt in.

packages/agent-core/src/agent/turn/index.ts

@@ -501,6 +501,8 @@ export class TurnFlow {
           const properties: Record<string, TelemetryPropertyValue> = {
             error_type: classification.errorType,
             model: this.agent.config.model,
+            alias: this.agent.config.modelAlias,
+            ...this.requestProtocolProps(),
             retryable: summary.retryable,
             duration_ms: Date.now() - startedAt,
           };
@@ -534,6 +536,12 @@ export class TurnFlow {
         inputData: { turnId, reason: 'cancelled' },
       });
     }
+    this.agent.telemetry.track('turn_ended', {
+      reason: ended.reason,
+      duration_ms: ended.durationMs,
+      mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
+      ...this.requestProtocolProps(),
+    });
     this.agent.emitEvent(ended);
     // Release the active turn in the same frame as turn.ended for a standalone
     // turn, so the session is observably idle the instant turn.ended fires.
@@ -923,6 +931,7 @@ export class TurnFlow {
     this.agent.telemetry.track('turn_interrupted', {
       mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
       at_step: atStep,
+      ...this.requestProtocolProps(),
     });
   }
 

packages/agent-core/src/config/schema.ts

@@ -50,6 +50,10 @@ export const ModelAliasSchema = z.object({
   // model-name version inference. Needed for custom-named Anthropic endpoints
   // whose model name does not encode a parseable Claude version.
   adaptiveThinking: z.boolean().optional(),
+  // Route the Anthropic transport through the beta Messages API
+  // (`POST /v1/messages?beta=true`) instead of the standard endpoint. Used by
+  // managed Kimi Code models that declare `protocol: 'anthropic'`.
+  betaApi: z.boolean().optional(),
 });
 
 export type ModelAlias = z.infer<typeof ModelAliasSchema>;

packages/agent-core/src/services/coreProcess/coreProcess.ts

@@ -58,6 +58,8 @@ export interface ICoreProcessService {
   /** The core RPC methods. Service impls call e.g. `core.rpc.createSession(...)`. */
   readonly rpc: CoreRPC;
 
+  readonly kimiRequestHeaders?: Record<string, string> | undefined;
+
   /**
    * Resolves once `KimiCore` is fully constructed and the SDK side of the
    * in-process RPC has been bound. Repeated calls return the cached promise.

packages/agent-core/src/services/coreProcess/coreProcessService.ts

@@ -31,6 +31,8 @@ export class CoreProcessService extends Disposable implements ICoreProcessServic
    */
   public readonly rpc: CoreRPC;
 
+  public readonly kimiRequestHeaders: Record<string, string> | undefined;
+
   /**
    * The in-process `KimiCore` instance. Kept private so daemon-side code can't
    * grab it and bypass the peer-service indirection.
@@ -91,7 +93,7 @@ export class CoreProcessService extends Disposable implements ICoreProcessServic
     // synthesize from `options.identity`. Hosts that pass neither
     // (no identity, no headers) still construct — but their requests will
     // trip the 40340 guard.
-    const kimiRequestHeaders: Record<string, string> | undefined =
+    this.kimiRequestHeaders =
       options.kimiRequestHeaders ??
       CoreProcessService._defaultKimiRequestHeaders(env.homeDir, options.identity);
 
@@ -107,7 +109,7 @@ export class CoreProcessService extends Disposable implements ICoreProcessServic
       ...options,
       homeDir: env.homeDir,
       configPath: env.configPath,
-      kimiRequestHeaders,
+      kimiRequestHeaders: this.kimiRequestHeaders,
       appVersion,
       resolveOAuthTokenProvider,
     });

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

@@ -117,6 +117,7 @@ export class ModelCatalogService
       const models = await fetchManagedKimiCodeModels({
         accessToken: token,
         baseUrl: auth.baseUrl,
+        headers: this.core.kimiRequestHeaders,
       });
       if (models.length === 0) return { changed, unchanged, failed };
 

packages/agent-core/src/session/provider-manager.ts

@@ -1,6 +1,7 @@
 import type { Logger } from '#/logging/types';
 import type { ProviderConfig as KosongProviderConfig, ModelCapability, ProviderRequestAuth } from '@moonshot-ai/kosong';
 import { APIStatusError, getModelCapability, UNKNOWN_CAPABILITY } from '@moonshot-ai/kosong';
+import { parseKimiCodeCustomHeaders } from '@moonshot-ai/kimi-code-oauth';
 import type { KimiConfig, ModelAlias, OAuthRef, ProviderConfig, ProviderType } from '../config';
 import { ErrorCodes, isKimiError, KimiError } from '../errors';
 
@@ -31,6 +32,8 @@ interface ProviderManagerOptions {
   readonly kimiRequestHeaders?: Record<string, string>;
   readonly resolveOAuthTokenProvider?: OAuthTokenProviderResolver;
   readonly promptCacheKey?: string;
+  // remove before commit
+  readonly adaptiveThinkingOverride?: () => boolean | undefined;
 }
 
 type AuthorizedRequest = <T>(
@@ -110,6 +113,9 @@ export class ProviderManager implements ModelProvider {
       );
     }
 
+    // remove before commit
+    const adaptiveThinkingOverride = this.options.adaptiveThinkingOverride?.();
+    const effectiveAdaptiveThinking = adaptiveThinkingOverride ?? alias.adaptiveThinking;
     const provider = toKosongProviderConfig(
       providerConfig,
       alias.model,
@@ -118,7 +124,8 @@ export class ProviderManager implements ModelProvider {
       alias.maxOutputSize,
       alias.reasoningKey,
       this.options.promptCacheKey,
-      alias.adaptiveThinking,
+      effectiveAdaptiveThinking,
+      alias.betaApi,
     );
 
     return {
@@ -234,8 +241,10 @@ function toKosongProviderConfig(
   reasoningKey: string | undefined,
   promptCacheKey: string | undefined,
   adaptiveThinking: boolean | undefined,
+  betaApi: boolean | undefined,
 ): KosongProviderConfig {
   const effectiveType = modelProtocol === 'anthropic' ? 'anthropic' : provider.type;
+  const envCustomHeaders = parseKimiCodeCustomHeaders();
   switch (effectiveType) {
     case 'anthropic': {
       const baseUrl = providerValue(provider.baseUrl, provider.env, 'ANTHROPIC_BASE_URL');
@@ -249,10 +258,22 @@ function toKosongProviderConfig(
         apiKey: providerApiKey(provider),
         ...(maxOutputSize !== undefined ? { defaultMaxTokens: maxOutputSize } : {}),
         ...(adaptiveThinking !== undefined ? { adaptiveThinking } : {}),
+        ...(betaApi !== undefined ? { betaApi } : {}),
         // Session affinity: Anthropic's analog of OpenAI `prompt_cache_key` is
         // `metadata.user_id` on the Messages API (cache-affinity / end-user id).
         ...(promptCacheKey !== undefined ? { metadata: { user_id: promptCacheKey } } : {}),
-        ...defaultHeadersField(provider.customHeaders),
+        // When a Kimi provider is routed through the Anthropic transport
+        // (`protocol: 'anthropic'`), upstream is the managed Kimi endpoint,
+        // so align its full outbound identity headers (User-Agent + X-Msh-*)
+        // with the Kimi OpenAI transport. Plain Anthropic providers only
+        // receive the unified `User-Agent` (no `X-Msh-*` device identity),
+        // matching the other non-Kimi transports. Provider `customHeaders`
+        // still win on conflict.
+        ...defaultHeadersField(
+          provider.type === 'kimi' && modelProtocol === 'anthropic'
+            ? { ...envCustomHeaders, ...kimiRequestHeaders, ...provider.customHeaders }
+            : { ...envCustomHeaders, ...kimiUserAgentHeader(kimiRequestHeaders), ...provider.customHeaders },
+        ),
       };
     }
     case 'openai':
@@ -262,7 +283,11 @@ function toKosongProviderConfig(
         baseUrl: providerValue(provider.baseUrl, provider.env, 'OPENAI_BASE_URL'),
         apiKey: providerApiKey(provider),
         reasoningKey,
-        ...defaultHeadersField(provider.customHeaders),
+        ...defaultHeadersField({
+          ...envCustomHeaders,
+          ...kimiUserAgentHeader(kimiRequestHeaders),
+          ...provider.customHeaders,
+        }),
       };
     case 'kimi':
       return {
@@ -271,21 +296,34 @@ function toKosongProviderConfig(
         baseUrl: providerValue(provider.baseUrl, provider.env, 'KIMI_BASE_URL'),
         apiKey: providerApiKey(provider),
         generationKwargs: { prompt_cache_key: promptCacheKey },
-        ...defaultHeadersField({ ...kimiRequestHeaders, ...provider.customHeaders }),
+        ...defaultHeadersField({
+          ...envCustomHeaders,
+          ...kimiRequestHeaders,
+          ...provider.customHeaders,
+        }),
       };
     case 'google-genai':
       return {
         type: 'google-genai',
         model,
         apiKey: providerApiKey(provider),
+        ...defaultHeadersField({
+          ...envCustomHeaders,
+          ...kimiUserAgentHeader(kimiRequestHeaders),
+          ...provider.customHeaders,
+        }),
       };
     case 'openai_responses':
       return {
         type: 'openai_responses',
         model,
         baseUrl: providerValue(provider.baseUrl, provider.env, 'OPENAI_BASE_URL'),
         apiKey: providerApiKey(provider),
-        ...defaultHeadersField(provider.customHeaders),
+        ...defaultHeadersField({
+          ...envCustomHeaders,
+          ...kimiUserAgentHeader(kimiRequestHeaders),
+          ...provider.customHeaders,
+        }),
       };
     case 'vertexai': {
       const useServiceAccount = hasVertexAIServiceEnv(provider);
@@ -296,6 +334,11 @@ function toKosongProviderConfig(
         apiKey: useServiceAccount ? undefined : providerApiKey(provider),
         project: vertexAIProject(provider),
         location: vertexAILocation(provider),
+        ...defaultHeadersField({
+          ...envCustomHeaders,
+          ...kimiUserAgentHeader(kimiRequestHeaders),
+          ...provider.customHeaders,
+        }),
       };
     }
     default: {
@@ -318,6 +361,19 @@ function defaultHeadersField(
   return { defaultHeaders: { ...headers } };
 }
 
+// Extract just the `User-Agent` from the Kimi identity headers so non-Kimi
+// providers (OpenAI, Anthropic, Google, Vertex) also identify as
+// `kimi-code-cli/<version>` without leaking the `X-Msh-*` device identity
+// headers to third-party endpoints. The full `kimiRequestHeaders` set stays
+// reserved for the Kimi transport (and the Kimi-routed Anthropic transport),
+// where upstream is the managed Kimi endpoint.
+function kimiUserAgentHeader(
+  kimiRequestHeaders: Record<string, string> | undefined,
+): Record<string, string> {
+  const userAgent = kimiRequestHeaders?.['User-Agent'];
+  return userAgent === undefined ? {} : { 'User-Agent': userAgent };
+}
+
 function providerApiKey(provider: ProviderConfig): string | undefined {
   switch (provider.type) {
     case 'anthropic':

packages/agent-core/test/agent/turn.test.ts

@@ -72,6 +72,34 @@
     });
   });
 
+  it('tracks turn_ended telemetry with protocol props', async () => {
+    const records: TelemetryRecord[] = [];
+    const ctx = testAgent({ telemetry: recordingTelemetry(records) });
+    ctx.configure();
+    ctx.mockNextResponse({ type: 'text', text: 'done' });
+
+    await ctx.rpc.prompt({ input: [{ type: 'text', text: 'hi' }] });
+    await ctx.untilTurnEnd();
+
+    const started = records.find((candidate) => candidate.event === 'turn_started');
+    expect(started).toEqual({
+      event: 'turn_started',
+      properties: expect.objectContaining({ mode: 'agent', type: 'kimi', protocol: 'kimi' }),
+    });
+
+    const ended = records.find((candidate) => candidate.event === 'turn_ended');
+    expect(ended).toEqual({
+      event: 'turn_ended',
+      properties: expect.objectContaining({
+        mode: 'agent',
+        reason: 'completed',
+        type: 'kimi',
+        protocol: 'kimi',
+        duration_ms: expect.any(Number),
+      }),
+    });
+  });
+
   it('tracks duplicate tool-call detection telemetry', async () => {
     const records: TelemetryRecord[] = [];
     const ctx = testAgent({
@@ -1426,6 +1454,9 @@
     const expectedProperties: Record<string, unknown> = {
       error_type: errorType,
       model: 'mock-model',
+      alias: 'mock-model',
+      type: 'kimi',
+      protocol: 'kimi',
       retryable: expect.any(Boolean),
       duration_ms: expect.any(Number),
     };
@@ -1434,7 +1465,7 @@
     }
 
     const record = records.find((candidate) => candidate.event === 'api_error');
     expect(record).toEqual({
       event: 'api_error',
       properties: expect.objectContaining(expectedProperties),
     });

packages/agent-core/test/harness/runtime-provider.test.ts

@@ -338,6 +338,35 @@ describe('resolveRuntimeProvider maxOutputSize forwarding', () => {
     });
   });
 
+  it('forwards alias.betaApi to the anthropic provider config', () => {
+    const resolved = resolveRuntimeProvider({
+      config: {
+        ...BASE_CONFIG,
+        providers: {
+          ...BASE_CONFIG.providers,
+          anthropic: { type: 'anthropic', apiKey: 'sk-anthropic' },
+        },
+        models: {
+          ...BASE_CONFIG.models!,
+          'kimi-alias': {
+            provider: 'anthropic',
+            model: 'kimi-for-coding',
+            maxContextSize: 200000,
+            protocol: 'anthropic',
+            betaApi: true,
+          },
+        },
+      },
+      model: 'kimi-alias',
+    });
+
+    expect(resolved.provider).toMatchObject({
+      type: 'anthropic',
+      model: 'kimi-for-coding',
+      betaApi: true,
+    });
+  });
+
   it('omits adaptiveThinking when alias.adaptiveThinking is unset', () => {
     const resolved = resolveRuntimeProvider({
       config: {
@@ -453,7 +482,7 @@ describe('resolveRuntimeProvider Kimi request headers', () => {
     });
   });
 
-  it('does not apply kimiRequestHeaders to non-Kimi providers', () => {
+  it('applies only the User-Agent from kimiRequestHeaders to non-Kimi providers', () => {
     const resolved = resolveRuntimeProvider({
       config: {
         defaultModel: 'gpt-alias',
@@ -479,8 +508,16 @@ describe('resolveRuntimeProvider Kimi request headers', () => {
       type: 'openai',
       model: 'gpt-runtime',
       apiKey: 'sk-openai',
+      defaultHeaders: {
+        'User-Agent': TEST_KIMI_HEADERS['User-Agent'],
+      },
     });
-    expect('defaultHeaders' in resolved.provider).toBe(false);
+    // Device identity headers (`X-Msh-*`) stay Kimi-only — they must not leak
+    // to third-party providers.
+    const headers = (resolved.provider as { defaultHeaders?: Record<string, string> })
+      .defaultHeaders;
+    expect(headers).toBeDefined();
+    expect('X-Msh-Platform' in headers!).toBe(false);
     expect('generationKwargs' in resolved.provider).toBe(false);
   });
 });