| import { describe, expect, it } from 'vitest'; |
|
|
| import { ConfigRegistry } from '#/app/config/configService'; |
| import { ErrorCodes, Error2 } from '#/errors'; |
| import { kimiModelEnvOverlay, ENV_MODEL_ALIAS_KEY } from '#/app/kosongConfig/envOverlay'; |
| import { |
| ENV_MODEL_PROVIDER_KEY, |
| MODELS_SECTION, |
| ModelsSectionSchema, |
| modelsFromToml, |
| modelsToToml, |
| } from '#/app/kosongConfig/configSection'; |
| import { type ModelRecord } from '#/llm-adapter/model/model'; |
| import { effectiveModelConfig } from '#/llm-adapter/model/model-auth'; |
|
|
|
|
| describe('effectiveModelConfig', () => { |
| it('clamps the input cap to the effective total window without mutating the source', () => { |
| const record = { |
| provider: 'custom', |
| model: 'gpt-5', |
| maxContextSize: 128000, |
| maxInputSize: 272000, |
| }; |
|
|
| const effective = effectiveModelConfig(record); |
| expect(effective.maxInputSize).toBe(128000); |
| expect(record.maxInputSize).toBe(272000); |
|
|
| const withOverrides = { |
| provider: 'custom', |
| model: 'gpt-5', |
| maxContextSize: 400000, |
| maxInputSize: 272000, |
| overrides: { maxContextSize: 128000 }, |
| }; |
| const effectiveOverride = effectiveModelConfig(withOverrides); |
| expect(effectiveOverride.maxContextSize).toBe(128000); |
| expect(effectiveOverride.maxInputSize).toBe(128000); |
| expect(withOverrides.maxInputSize).toBe(272000); |
| }); |
|
|
| it('derives the official effort metadata from a Claude model name', () => { |
| expect( |
| effectiveModelConfig({ |
| provider: 'anthropic', |
| model: 'claude-opus-4-6', |
| maxContextSize: 200000, |
| }), |
| ).toMatchObject({ |
| capabilities: ['thinking'], |
| supportEfforts: ['low', 'medium', 'high', 'max'], |
| defaultEffort: 'high', |
| }); |
| }); |
|
|
| it('infers Anthropic effort metadata for an unknown Claude-marked model on a non-Kimi Anthropic provider', () => { |
| expect( |
| effectiveModelConfig( |
| { |
| provider: 'custom', |
| model: 'custom-claude-model', |
| maxContextSize: 200000, |
| protocol: 'anthropic', |
| }, |
| 'anthropic', |
| ), |
| ).toMatchObject({ |
| capabilities: ['thinking'], |
| supportEfforts: ['low', 'medium', 'high', 'xhigh', 'max'], |
| defaultEffort: 'high', |
| }); |
| }); |
|
|
| it('infers Anthropic effort metadata for a bare Claude family alias on a non-Kimi Anthropic provider', () => { |
| expect( |
| effectiveModelConfig( |
| { |
| provider: 'custom', |
| model: 'sonnet-latest', |
| maxContextSize: 200000, |
| protocol: 'anthropic', |
| }, |
| 'anthropic', |
| ), |
| ).toMatchObject({ |
| capabilities: ['thinking'], |
| supportEfforts: ['low', 'medium', 'high', 'xhigh', 'max'], |
| defaultEffort: 'high', |
| }); |
| }); |
|
|
| it('does not infer Anthropic effort metadata for a clearly non-Claude model on a non-Kimi Anthropic provider', () => { |
| expect( |
| effectiveModelConfig( |
| { |
| provider: 'custom', |
| model: 'custom-anthropic-model', |
| maxContextSize: 200000, |
| protocol: 'anthropic', |
| }, |
| 'anthropic', |
| ), |
| ).toEqual({ |
| provider: 'custom', |
| model: 'custom-anthropic-model', |
| maxContextSize: 200000, |
| protocol: 'anthropic', |
| }); |
| }); |
|
|
| it('does not infer Anthropic effort metadata for a Kimi provider routed through the Anthropic protocol', () => { |
| const model: ModelRecord = { |
| provider: 'managed:kimi-code', |
| model: 'kimi-for-coding', |
| maxContextSize: 262144, |
| capabilities: ['thinking', 'always_thinking'], |
| protocol: 'anthropic', |
| adaptiveThinking: true, |
| }; |
|
|
| expect(effectiveModelConfig(model, 'kimi')).toEqual(model); |
| }); |
|
|
| it('does not infer the fallback profile without provider context', () => { |
| const model: ModelRecord = { |
| provider: 'custom', |
| model: 'custom-anthropic-model', |
| maxContextSize: 200000, |
| protocol: 'anthropic', |
| }; |
|
|
| expect(effectiveModelConfig(model)).toEqual(model); |
| }); |
|
|
| it('limits an adaptive_thinking=false model to budget efforts', () => { |
| expect( |
| effectiveModelConfig( |
| { |
| provider: 'custom', |
| model: 'custom-claude-model', |
| maxContextSize: 200000, |
| protocol: 'anthropic', |
| adaptiveThinking: false, |
| }, |
| 'anthropic', |
| ), |
| ).toMatchObject({ |
| capabilities: ['thinking'], |
| supportEfforts: ['low', 'medium', 'high'], |
| defaultEffort: 'high', |
| }); |
| }); |
|
|
| it('does not infer Anthropic effort metadata for an unknown model without an Anthropic protocol', () => { |
| const model = { |
| provider: 'custom', |
| model: 'custom-anthropic-model', |
| maxContextSize: 200000, |
| }; |
|
|
| expect(effectiveModelConfig(model)).toEqual(model); |
| }); |
|
|
| it('marks official always-on models while preserving explicit effort metadata', () => { |
| expect( |
| effectiveModelConfig({ |
| provider: 'anthropic', |
| model: 'claude-fable-5', |
| maxContextSize: 200000, |
| supportEfforts: ['high', 'max'], |
| defaultEffort: 'max', |
| }), |
| ).toMatchObject({ |
| capabilities: ['always_thinking'], |
| supportEfforts: ['high', 'max'], |
| defaultEffort: 'max', |
| }); |
| }); |
| }); |
|
|
| describe('models config section', () => { |
| it('self-registers the models section schema', () => { |
| expect(new ConfigRegistry().getSection(MODELS_SECTION)).toBeDefined(); |
| }); |
| }); |
|
|
| describe('models TOML transforms', () => { |
| it('camelCases nested model overrides from TOML', () => { |
| expect( |
| modelsFromToml({ |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| max_context_size: 1000, |
| support_efforts: ['low', 'high', 'max'], |
| overrides: { |
| max_context_size: 500, |
| support_efforts: ['low', 'high'], |
| }, |
| }, |
| }), |
| ).toEqual({ |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| maxContextSize: 1000, |
| supportEfforts: ['low', 'high', 'max'], |
| overrides: { |
| maxContextSize: 500, |
| supportEfforts: ['low', 'high'], |
| }, |
| }, |
| }); |
| }); |
|
|
| it('snakeCases nested model overrides for TOML', () => { |
| expect( |
| modelsToToml( |
| { |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| maxContextSize: 1000, |
| overrides: { |
| maxContextSize: 500, |
| supportEfforts: ['low', 'high'], |
| }, |
| }, |
| }, |
| {}, |
| ), |
| ).toEqual({ |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| max_context_size: 1000, |
| overrides: { |
| max_context_size: 500, |
| support_efforts: ['low', 'high'], |
| }, |
| }, |
| }); |
| }); |
|
|
| it('deletes on-disk fields the new record carries with an explicit undefined', () => { |
| expect( |
| modelsToToml( |
| { |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| maxContextSize: 1000, |
| displayName: undefined, |
| capabilities: undefined, |
| }, |
| }, |
| { |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| max_context_size: 128000, |
| display_name: 'Old Name', |
| capabilities: ['tool_use'], |
| beta_api: true, |
| }, |
| }, |
| ), |
| ).toEqual({ |
| kimi: { |
| provider: 'p', |
| model: 'm', |
| max_context_size: 1000, |
| beta_api: true, |
| }, |
| }); |
| }); |
| }); |
|
|
| type EnvMap = Readonly<Record<string, string | undefined>>; |
|
|
| function applyKimiModelEnvOverlay( |
| env: EnvMap, |
| effective: Record<string, unknown> = {}, |
| ): { readonly changed: readonly string[]; readonly effective: Record<string, unknown> } { |
| const changed = kimiModelEnvOverlay.apply( |
| effective, |
| (name) => env[name], |
| (domain, value) => { |
| if (domain === MODELS_SECTION) return ModelsSectionSchema.parse(value); |
| return value; |
| }, |
| ); |
| return { changed, effective }; |
| } |
|
|
| function expectConfigInvalid(fn: () => unknown): void { |
| try { |
| fn(); |
| } catch (error) { |
| expect(error).toBeInstanceOf(Error2); |
| expect((error as Error2).code).toBe(ErrorCodes.CONFIG_INVALID); |
| return; |
| } |
| throw new Error('expected config.invalid'); |
| } |
|
|
| describe('kimiModelEnvOverlay', () => { |
| it('does nothing when KIMI_MODEL_NAME is absent', () => { |
| const effective = { |
| models: { |
| existing: { provider: 'p', model: 'm', maxContextSize: 1000 }, |
| }, |
| defaultModel: 'existing', |
| }; |
|
|
| const result = applyKimiModelEnvOverlay({}, effective); |
|
|
| expect(result.changed).toEqual([]); |
| expect(result.effective).toEqual(effective); |
| }); |
|
|
| it('applies request overrides when KIMI_MODEL_NAME is absent', () => { |
| const { changed, effective } = applyKimiModelEnvOverlay({ |
| KIMI_MODEL_TEMPERATURE: '0.3', |
| KIMI_MODEL_THINKING_KEEP: 'all', |
| }); |
|
|
| expect(changed).toEqual(['modelOverrides']); |
| expect(effective['modelOverrides']).toEqual({ |
| temperature: 0.3, |
| thinkingKeep: 'all', |
| }); |
| }); |
|
|
| it('synthesizes an env model alias and default model from the minimal env set', () => { |
| const { changed, effective } = applyKimiModelEnvOverlay({ |
| KIMI_MODEL_NAME: 'kimi-for-coding', |
| }); |
|
|
| expect(changed).toEqual(['models', 'providers', 'defaultModel']); |
| expect(effective['defaultModel']).toBe(ENV_MODEL_ALIAS_KEY); |
| expect(effective['models']).toEqual({ |
| [ENV_MODEL_ALIAS_KEY]: { |
| provider: ENV_MODEL_PROVIDER_KEY, |
| model: 'kimi-for-coding', |
| maxContextSize: 262144, |
| capabilities: ['image_in', 'thinking'], |
| }, |
| }); |
| expect(effective['providers']).toEqual({ |
| [ENV_MODEL_PROVIDER_KEY]: { type: 'kimi', baseUrl: 'https://api.moonshot.ai/v1' }, |
| }); |
| }); |
|
|
| it('omits baseUrl for openai so the base SDK default applies at construction', () => { |
| const { effective } = applyKimiModelEnvOverlay( |
| { KIMI_MODEL_NAME: 'env-model' }, |
| { providers: { [ENV_MODEL_PROVIDER_KEY]: { type: 'openai' } } }, |
| ); |
|
|
| expect(effective['providers']).toEqual({ |
| [ENV_MODEL_PROVIDER_KEY]: { type: 'openai' }, |
| }); |
| }); |
|
|
| it('omits baseUrl for anthropic so the SDK picks its default', () => { |
| const { effective } = applyKimiModelEnvOverlay( |
| { KIMI_MODEL_NAME: 'env-model' }, |
| { providers: { [ENV_MODEL_PROVIDER_KEY]: { type: 'anthropic' } } }, |
| ); |
|
|
| expect(effective['providers']).toEqual({ |
| [ENV_MODEL_PROVIDER_KEY]: { type: 'anthropic' }, |
| }); |
| }); |
|
|
| it('honors an explicit baseUrl over the type default', () => { |
| const { effective } = applyKimiModelEnvOverlay( |
| { KIMI_MODEL_NAME: 'env-model' }, |
| { |
| providers: { |
| [ENV_MODEL_PROVIDER_KEY]: { type: 'openai', baseUrl: 'https://api.example.com/v1' }, |
| }, |
| }, |
| ); |
|
|
| expect(effective['providers']).toEqual({ |
| [ENV_MODEL_PROVIDER_KEY]: { type: 'openai', baseUrl: 'https://api.example.com/v1' }, |
| }); |
| }); |
|
|
| it('keeps an explicit env provider type instead of the kimi default', () => { |
| const { changed, effective } = applyKimiModelEnvOverlay( |
| { KIMI_MODEL_NAME: 'env-model' }, |
| { providers: { [ENV_MODEL_PROVIDER_KEY]: { type: 'openai', baseUrl: 'http://x' } } }, |
| ); |
|
|
| expect(changed).toEqual(['models', 'defaultModel']); |
| expect(effective['providers']).toEqual({ |
| [ENV_MODEL_PROVIDER_KEY]: { type: 'openai', baseUrl: 'http://x' }, |
| }); |
| }); |
|
|
| it('preserves configured aliases while adding the env alias', () => { |
| const existing = { provider: 'p', model: 'm', maxContextSize: 1000 }; |
| const { effective } = applyKimiModelEnvOverlay( |
| { KIMI_MODEL_NAME: 'env-model' }, |
| { models: { existing } }, |
| ); |
|
|
| expect(effective['models']).toMatchObject({ |
| existing, |
| [ENV_MODEL_ALIAS_KEY]: { model: 'env-model' }, |
| }); |
| }); |
|
|
| it('maps extended model metadata and request overrides', () => { |
| const { changed, effective } = applyKimiModelEnvOverlay({ |
| KIMI_MODEL_NAME: 'env-model', |
| KIMI_MODEL_MAX_CONTEXT_SIZE: '1000000', |
| KIMI_MODEL_MAX_OUTPUT_SIZE: '8192', |
| KIMI_MODEL_CAPABILITIES: 'Image_In, thinking , tool_use', |
| KIMI_MODEL_DISPLAY_NAME: 'Custom Model', |
| KIMI_MODEL_REASONING_KEY: 'reasoning', |
| KIMI_MODEL_ADAPTIVE_THINKING: 'true', |
| KIMI_MODEL_TEMPERATURE: '0.3', |
| KIMI_MODEL_TOP_P: ' 0.95 ', |
| KIMI_MODEL_THINKING_KEEP: 'all', |
| KIMI_MODEL_MAX_COMPLETION_TOKENS: '4096', |
| KIMI_MODEL_MAX_TOKENS: '2048', |
| }); |
|
|
| expect(changed).toEqual(['models', 'providers', 'defaultModel', 'modelOverrides']); |
| expect( |
| (effective['models'] as Record<string, unknown>)[ENV_MODEL_ALIAS_KEY], |
| ).toEqual({ |
| provider: ENV_MODEL_PROVIDER_KEY, |
| model: 'env-model', |
| maxContextSize: 1000000, |
| maxOutputSize: 8192, |
| capabilities: ['image_in', 'thinking', 'tool_use'], |
| displayName: 'Custom Model', |
| reasoningKey: 'reasoning', |
| adaptiveThinking: true, |
| }); |
| expect(effective['modelOverrides']).toEqual({ |
| temperature: 0.3, |
| topP: 0.95, |
| thinkingKeep: 'all', |
| maxCompletionTokens: 4096, |
| }); |
| }); |
|
|
| it('falls back to legacy KIMI_MODEL_MAX_TOKENS for completion overrides', () => { |
| const { effective } = applyKimiModelEnvOverlay({ |
| KIMI_MODEL_NAME: 'env-model', |
| KIMI_MODEL_MAX_TOKENS: '2048', |
| }); |
|
|
| expect(effective['modelOverrides']).toEqual({ maxCompletionTokens: 2048 }); |
| }); |
|
|
| it.each([ |
| ['KIMI_MODEL_MAX_CONTEXT_SIZE', '0'], |
| ['KIMI_MODEL_MAX_CONTEXT_SIZE', '1.5'], |
| ['KIMI_MODEL_MAX_OUTPUT_SIZE', 'nope'], |
| ['KIMI_MODEL_ADAPTIVE_THINKING', 'maybe'], |
| ['KIMI_MODEL_TEMPERATURE', 'abc'], |
| ['KIMI_MODEL_TEMPERATURE', '1.2.3'], |
| ['KIMI_MODEL_TOP_P', 'NaN'], |
| ])('throws config.invalid for invalid %s=%s', (key, value) => { |
| expectConfigInvalid(() => |
| applyKimiModelEnvOverlay({ KIMI_MODEL_NAME: 'env-model', [key]: value }), |
| ); |
| }); |
|
|
| it('strips env-only model values before write-back', () => { |
| expect( |
| kimiModelEnvOverlay.strip?.( |
| 'models', |
| { |
| user: { provider: 'p', model: 'm', maxContextSize: 1000 }, |
| [ENV_MODEL_ALIAS_KEY]: { |
| provider: ENV_MODEL_PROVIDER_KEY, |
| model: 'env-model', |
| maxContextSize: 262144, |
| }, |
| }, |
| {}, |
| ), |
| ).toEqual({ |
| user: { provider: 'p', model: 'm', maxContextSize: 1000 }, |
| }); |
|
|
| expect( |
| kimiModelEnvOverlay.strip?.('defaultModel', ENV_MODEL_ALIAS_KEY, { |
| default_model: 'user', |
| }), |
| ).toBe('user'); |
| expect(kimiModelEnvOverlay.strip?.('modelOverrides', { temperature: 0.3 }, {})).toBeUndefined(); |
| }); |
|
|
| it('self-registers into ConfigRegistry without ModelService instantiation', () => { |
| const freshRegistry = new ConfigRegistry(); |
| expect(freshRegistry.listEffectiveOverlays()).toContain(kimiModelEnvOverlay); |
| }); |
| }); |
|
|
