refactor(kosong)!: drop the select_tools capability spelling entirely

No catalogued model or shipped configuration ever used the capability,
so there is nothing to migrate: remove the deprecated select_tools
field/config-string acceptance and the hasDynamicallyLoadedTools compat
helper. dynamically_loaded_tools is the only spelling — read directly
where consumed. The select_tools builtin tool and the tool-select flag
keep their names (client-side mechanism vocabulary).

Author: fengchenchen

.changeset/dynamically-loaded-tools-capability.md

@@ -4,4 +4,4 @@
 "@moonshot-ai/kimi-code-sdk": patch
 ---
 
-Rename the dynamic tool loading model capability to its canonical name `dynamically_loaded_tools` (the model-level ability to accept message-level tool declarations). The previous `select_tools` spelling — which named the client-side mechanism rather than the model capability — remains fully supported as a deprecated alias in model alias `capabilities` config and in catalog entries, so no configuration changes are required. The SDK's catalog-to-alias mapping now emits the canonical name.
+Rename the dynamic tool loading model capability to `dynamically_loaded_tools` (the model-level ability to accept message-level tool declarations). The previous `select_tools` spelling — which named the client-side mechanism rather than the model capability — is removed outright: no catalogued model or shipped configuration ever used it, so there is nothing to migrate. Model alias `capabilities` config, catalog entries, and the SDK's catalog-to-alias mapping all use the new name.

apps/kimi-code/scripts/update-catalog.mjs

@@ -24,11 +24,10 @@ const KEEP_MODEL = new Set([
   "reasoning",
   "interleaved",
   "modalities",
-  // Message-level tool declarations capability (canonical + deprecated
-  // spelling) — kosong's catalogModelToCapability reads both; stripping them
-  // here would silently disable tool-select for catalog-imported aliases.
+  // Message-level tool declarations capability — kosong's
+  // catalogModelToCapability reads it; stripping it here would silently
+  // disable tool-select for catalog-imported aliases.
   "dynamically_loaded_tools",
-  "select_tools",
 ]);
 
 function resolveOutputFile(args) {

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

@@ -6,7 +6,7 @@ import { ErrorCodes, KimiError, makeErrorPayload } from '#/errors';
 import { log } from '#/logging/logger';
 import type { Logger } from '#/logging/types';
 import type { AgentAPI, AgentEvent, KimiConfig, SDKAgentRPC, UsageStatus } from '#/rpc';
-import { generate, hasDynamicallyLoadedTools } from '@moonshot-ai/kosong';
+import { generate } from '@moonshot-ai/kosong';
 
 import type { EnabledPluginSessionStart, PluginCommandDef } from '#/plugin';
 import { expandCommandArguments } from '../plugin/commands';
@@ -236,20 +236,19 @@ export class Agent {
 
   /**
    * Single decision point for select_tools progressive disclosure. All three
-   * gates must be open: the model has the dynamically-loaded-tools capability
-   * (message-level tool declarations; the deprecated `select_tools` spelling
-   * is honored via hasDynamicallyLoadedTools), the model declares `tool_use`
-   * (a model without tool use loading tools dynamically is a contradiction),
-   * and the `tool-select` experimental flag is on. Every consumer — top-level
-   * tools[] convergence, select_tools registration, manifest announcements,
-   * projection shaping — reads this instead of re-deriving the conditions, so
-   * degradation is lossless: any closed gate reproduces the inline behavior
-   * byte-for-byte.
+   * gates must be open: the model has the `dynamically_loaded_tools`
+   * capability (message-level tool declarations), the model declares
+   * `tool_use` (a model without tool use loading tools dynamically is a
+   * contradiction), and the `tool-select` experimental flag is on. Every
+   * consumer — top-level tools[] convergence, select_tools registration,
+   * manifest announcements, projection shaping — reads this instead of
+   * re-deriving the conditions, so degradation is lossless: any closed gate
+   * reproduces the inline behavior byte-for-byte.
    */
   get toolSelectEnabled(): boolean {
     const capability = this.config.modelCapabilities;
     return (
-      hasDynamicallyLoadedTools(capability) &&
+      capability.dynamically_loaded_tools === true &&
       capability.tool_use &&
       this.experimentalFlags.enabled('tool-select')
     );

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

@@ -1,6 +1,6 @@
 import type { Logger } from '#/logging/types';
 import type { ProviderConfig as KosongProviderConfig, ModelCapability, ProviderRequestAuth } from '@moonshot-ai/kosong';
-import { APIStatusError, getModelCapability, hasDynamicallyLoadedTools, UNKNOWN_CAPABILITY } from '@moonshot-ai/kosong';
+import { APIStatusError, getModelCapability, UNKNOWN_CAPABILITY } from '@moonshot-ai/kosong';
 import { parseKimiCodeCustomHeaders } from '@moonshot-ai/kimi-code-oauth';
 import {
   effectiveModelAlias,
@@ -235,12 +235,10 @@ function resolveModelCapabilities(
     max_context_tokens: alias.maxContextSize,
     // Message-level tool declarations ("dynamically loaded tools"). Every
     // field here must be merged explicitly — a capability registered in
-    // kosong that is not forwarded here never reaches the agent. The
-    // deprecated `select_tools` spelling stays accepted in alias configs.
+    // kosong that is not forwarded here never reaches the agent.
     dynamically_loaded_tools:
       declared.has('dynamically_loaded_tools') ||
-      declared.has('select_tools') ||
-      hasDynamicallyLoadedTools(detected),
+      detected.dynamically_loaded_tools === true,
   };
 }
 

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

@@ -1095,9 +1095,6 @@ function capabilityNames(capabilities: ModelCapability | undefined): string[] {
     capabilities.thinking ? 'thinking' : undefined,
     capabilities.tool_use ? 'tool_use' : undefined,
     capabilities.dynamically_loaded_tools === true ? 'dynamically_loaded_tools' : undefined,
-    // Deliberately kept as the legacy string so tests exercising the
-    // deprecated field also exercise the deprecated declared-name path.
-    capabilities.select_tools === true ? 'select_tools' : undefined,
   ].filter((capability): capability is string => capability !== undefined);
 }
 

packages/agent-core/test/agent/tool-select.e2e.test.ts

@@ -37,18 +37,6 @@ const DISCLOSURE_CAPABILITIES = {
   dynamically_loaded_tools: true,
 } as const;
 
-// Same capability through the deprecated field name — must keep working
-// (declared as the legacy `select_tools` capability string by the harness).
-const LEGACY_DISCLOSURE_CAPABILITIES = {
-  image_in: false,
-  video_in: false,
-  audio_in: false,
-  thinking: false,
-  tool_use: true,
-  max_context_tokens: 256_000,
-  select_tools: true,
-} as const;
-
 const INLINE_PROVIDER = { type: 'kimi', apiKey: 'test-key', model: 'inline-model' } as const;
 const INLINE_CAPABILITIES = {
   image_in: false,
@@ -232,31 +220,6 @@ describe('disclosure mode — top-level convergence and announcements', () => {
     expect(JSON.stringify(call.history)).toContain(GRAFANA_TOOL);
   });
 
-  it('honors the deprecated select_tools capability spelling end to end', async () => {
-    // Declared through the harness as the legacy `select_tools` capability
-    // string; the gate, convergence, select and dispatch must all still work.
-    const callLog: Array<[string, unknown]> = [];
-    const ctx = testAgent({ experimentalFlags: toolSelectFlagOn() });
-    ctx.configure({
-      tools: ['Read', 'mcp__*'],
-      provider: DISCLOSURE_PROVIDER,
-      modelCapabilities: LEGACY_DISCLOSURE_CAPABILITIES,
-    });
-    await registerGrafana(ctx, callLog);
-    await ctx.rpc.setPermission({ mode: 'yolo' });
-    expect(ctx.agent.toolSelectEnabled).toBe(true);
-
-    ctx.mockNextResponse({ type: 'text', text: 'loading' }, selectCall('call-1', [GRAFANA_TOOL]));
-    ctx.mockNextResponse({ type: 'text', text: 'querying' }, mcpCall('call-2', 'errors'));
-    ctx.mockNextResponse({ type: 'text', text: 'done' });
-    await runTurn(ctx, 'use the tool');
-
-    const wireNames = ctx.llmCalls.at(-3)!.tools.map((t) => t.name);
-    expect(wireNames).toContain('select_tools');
-    expect(wireNames.some((n) => n.startsWith('mcp__'))).toBe(false);
-    expect(callLog).toEqual([['query_range', { query: 'errors' }]]);
-  });
-
   it('does not re-announce when the loadable set is unchanged', async () => {
     const ctx = await disclosureAgent();
     ctx.mockNextResponse({ type: 'text', text: 'one' });

packages/kosong/src/capability.ts

@@ -23,22 +23,6 @@ export interface ModelCapability {
    * message carrying `tools`.
    */
   readonly dynamically_loaded_tools?: boolean;
-  /**
-   * @deprecated Legacy alias of {@link ModelCapability.dynamically_loaded_tools}
-   * (this bit originally shipped under the client-side mechanism's tool name).
-   * Still honored everywhere via {@link hasDynamicallyLoadedTools}; write the
-   * canonical field instead.
-   */
-  readonly select_tools?: boolean;
-}
-
-/**
- * True when the model accepts message-level tool declarations. Single read
- * point for the capability so the deprecated `select_tools` spelling keeps
- * working wherever the bit is consumed.
- */
-export function hasDynamicallyLoadedTools(capability: ModelCapability): boolean {
-  return capability.dynamically_loaded_tools === true || capability.select_tools === true;
 }
 
 const UNKNOWN_CAPABILITY_MARKER = Symbol.for('moonshot-ai.kosong.UNKNOWN_CAPABILITY');
@@ -57,9 +41,6 @@ export const UNKNOWN_CAPABILITY: ModelCapability = Object.freeze(
       thinking: false,
       tool_use: false,
       max_context_tokens: 0,
-      // Only the canonical spelling in the default output shape; the
-      // deprecated `select_tools` field is accepted on input but never
-      // emitted (this object reaches RPC/SDK consumers via config snapshots).
       dynamically_loaded_tools: false,
     },
     UNKNOWN_CAPABILITY_MARKER,
@@ -78,7 +59,7 @@ export function isUnknownCapability(capability: ModelCapability): boolean {
     !capability.audio_in &&
     !capability.thinking &&
     !capability.tool_use &&
-    !hasDynamicallyLoadedTools(capability) &&
+    capability.dynamically_loaded_tools !== true &&
     capability.max_context_tokens === 0
   );
 }

packages/kosong/src/catalog.ts

@@ -15,8 +15,6 @@ export interface CatalogModelEntry {
   readonly reasoning?: boolean;
   /** Accepts message-level tool declarations (`messages[].tools`). Defaults to false. */
   readonly dynamically_loaded_tools?: boolean;
-  /** @deprecated Legacy alias of `dynamically_loaded_tools`; still accepted. */
-  readonly select_tools?: boolean;
   readonly interleaved?: boolean | { readonly field?: string };
   readonly modalities?: {
     readonly input?: readonly string[];
@@ -140,8 +138,7 @@ export function catalogModelToCapability(model: CatalogModelEntry): CatalogModel
       thinking: Boolean(model.reasoning),
       tool_use: model.tool_call ?? true,
       max_context_tokens: context,
-      dynamically_loaded_tools:
-        model.dynamically_loaded_tools === true || model.select_tools === true,
+      dynamically_loaded_tools: model.dynamically_loaded_tools === true,
     },
   };
 }

packages/kosong/src/index.ts

@@ -34,7 +34,7 @@ export { KimiChatProvider } from './providers/kimi';
 export type { ExtraBody, GenerationKwargs, KimiOptions, ThinkingConfig } from './providers/kimi';
 
 // Model capability matrix
-export { hasDynamicallyLoadedTools, isUnknownCapability, UNKNOWN_CAPABILITY } from './capability';
+export { isUnknownCapability, UNKNOWN_CAPABILITY } from './capability';
 export type { ModelCapability } from './capability';
 
 // Model catalog (models.dev-style) metadata

packages/kosong/test/select-tools.test.ts

@@ -7,11 +7,10 @@
  *     normalization and the `$` builtin branch shared with top-level tools);
  *   - `Tool.deferred` stripping in `generate()` (single strip point for every
  *     provider call — the marker itself must never reach the wire);
- *   - the `dynamically_loaded_tools` capability bit (unknown/default-off
- *     semantics, deprecated `select_tools` spelling honored).
+ *   - the `dynamically_loaded_tools` capability bit (unknown/default-off semantics).
  */
 
-import { UNKNOWN_CAPABILITY, hasDynamicallyLoadedTools, isUnknownCapability } from '#/capability';
+import { UNKNOWN_CAPABILITY, isUnknownCapability } from '#/capability';
 import { catalogModelToCapability } from '#/catalog';
 import { generate } from '#/generate';
 import { isToolDeclarationOnlyMessage } from '#/message';
@@ -337,34 +336,20 @@ describe('dynamically_loaded_tools capability bit', () => {
 
   it('defaults to false on UNKNOWN_CAPABILITY', () => {
     expect(UNKNOWN_CAPABILITY.dynamically_loaded_tools).toBe(false);
-    expect(hasDynamicallyLoadedTools(UNKNOWN_CAPABILITY)).toBe(false);
   });
 
-  it('honors both the canonical and the deprecated select_tools spelling', () => {
-    expect(
-      hasDynamicallyLoadedTools({ ...BASE_CAPABILITY, dynamically_loaded_tools: true }),
-    ).toBe(true);
-    expect(hasDynamicallyLoadedTools({ ...BASE_CAPABILITY, select_tools: true })).toBe(true);
-    expect(hasDynamicallyLoadedTools(BASE_CAPABILITY)).toBe(false);
-  });
-
-  it('a capability that only has the bit set is not "unknown" (either spelling)', () => {
+  it('a capability that only has the bit set is not "unknown"', () => {
     expect(isUnknownCapability({ ...BASE_CAPABILITY, dynamically_loaded_tools: true })).toBe(
       false,
     );
-    expect(isUnknownCapability({ ...BASE_CAPABILITY, select_tools: true })).toBe(false);
   });
 
-  it('catalog entries map both spellings onto the canonical field, defaulting to false', () => {
+  it('catalog entries map the capability, defaulting to false', () => {
     const base = { id: 'm', limit: { context: 1000 } };
     expect(catalogModelToCapability(base)?.capability.dynamically_loaded_tools).toBe(false);
     expect(
       catalogModelToCapability({ ...base, dynamically_loaded_tools: true })?.capability
         .dynamically_loaded_tools,
     ).toBe(true);
-    expect(
-      catalogModelToCapability({ ...base, select_tools: true })?.capability
-        .dynamically_loaded_tools,
-    ).toBe(true);
   });
 });