fix(moonshot): Add verified Kimi effort metadata (#1796)

* Add verified Kimi effort metadata

Add kimi-k2.7-code to the Kimi Code gateway catalog and the direct Moonshot catalog, ordered newest/highest first.

Annotate Moonshot and Kimi Code Kimi models with context/output limits, reasoning capabilities, and reasoning_effort metadata limited to the verified low/medium/high levels.

Add runtime metadata, effort resolution, and provider override tests covering catalog order, qualified aliases, stale xhigh clamping, and Kimi Code request serialization.

Validation run locally: bun run build; bun run smoke; bun run check; bun run test:provider; bun run typecheck; bun run integrations:check; py -3.13 -m pytest -q -p no:cacheprovider python/tests; bun run typecheck:type-tests; bun run test:provider-recommendation; bun run security:pr-scan; focused effort/runtime/client/providerConfig tests; git diff --check.

* Fix Kimi K2.7 PR review findings

Clamp Kimi K2.7 max output metadata to 32,768 for Kimi Code, direct Moonshot, and Atlas Cloud so runtime limits do not advertise the context window as a generation cap.

Update the Moonshot runtime metadata assertion to the corrected cap and keep Hicap's separate K2.7 cap unchanged.

Restore globalThis.fetch in the Kimi Code providerOverride test with try/finally to avoid cross-test leakage.

Validation: bun test --feature=UNATTENDED_RETRY src/integrations/runtimeMetadata.test.ts src/services/api/client.test.ts src/utils/effort.codex.test.ts; bun run integrations:check; bun run build; bun run test:provider; bun run typecheck; git diff --check; bun run check.

* Fix Moonshot K2.6 and K2.5 output caps

Raise direct Moonshot Kimi K2.6 and K2.5 max output metadata from the default token count to the provider context-budget ceiling.

Add runtime metadata assertions so direct Moonshot K2.6 and K2.5 keep the 262,144 output cap while K2.7 Code remains capped at 32,768.

Validation: bun test --feature=UNATTENDED_RETRY src/integrations/runtimeMetadata.test.ts; bun run integrations:check; bun run typecheck; git diff --check; bun run build.

* Clamp Atlas Kimi K2.7 effort levels

Remove xhigh from the Atlas Cloud moonshotai/kimi-k2.7-code metadata so the gateway no longer advertises an unverified effort level for that model.

Update providerOverride and effort metadata tests to cover the exact Atlas K2.7 path and assert stale xhigh settings clamp to high.

Validation: bun test --feature=UNATTENDED_RETRY src/services/api/client.test.ts src/utils/effort.codex.test.ts src/integrations/runtimeMetadata.test.ts; git diff --check; bun run integrations:check; bun run typecheck; bun run build.

* Address Kimi metadata review findings
This commit is contained in:
JATMN
2026-06-27 11:25:06 +08:00
committed by GitHub
parent 6f794f4185
commit 13cf30afa4
7 changed files with 321 additions and 51 deletions
+3 -3
View File
@@ -52,9 +52,9 @@ export default defineGateway({
{ id: 'google/gemini-3.1-flash-lite', apiName: 'google/gemini-3.1-flash-lite', modelDescriptorId: 'google/gemini-3.1-flash-lite', label: 'Gemini 3.1 Flash Lite', contextWindow: 1_048_576, maxOutputTokens: 65_536 },
{ id: 'xai/grok-4.3', apiName: 'xai/grok-4.3', aliases: ['grok-4.3', 'grok-4.3-latest', 'grok-latest', 'grok-4', 'grok-3'], modelDescriptorId: 'grok-4.3', label: 'Grok 4.3', contextWindow: 1_000_000, maxOutputTokens: 32_768, capabilities: { supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], wireFormat: 'reasoning_effort' } },
{ id: 'xai/grok-build-0.1', apiName: 'xai/grok-build-0.1', aliases: ['grok-build-0.1', 'grok-code-fast-1', 'grok-code-fast', 'grok-code-fast-1-0825'], modelDescriptorId: 'xai/grok-build-0.1', label: 'Grok Build 0.1', contextWindow: 256_000, maxOutputTokens: 64_000, capabilities: { supportsReasoning: false }, transportOverrides: { openaiShim: { removeBodyFields: ['reasoning_effort'] } } },
{ id: 'moonshotai/kimi-k2.7-code', apiName: 'moonshotai/kimi-k2.7-code', aliases: ['kimi-k2.7-code'], modelDescriptorId: 'kimi-k2.7-code', label: 'Kimi K2.7 Code', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], wireFormat: 'reasoning_effort' } },
{ id: 'moonshotai/kimi-k2.6', apiName: 'moonshotai/kimi-k2.6', aliases: ['kimi-k2.6'], modelDescriptorId: 'kimi-k2.6', label: 'Kimi K2.6', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], wireFormat: 'reasoning_effort' } },
{ id: 'moonshotai/kimi-k2.5', apiName: 'moonshotai/kimi-k2.5', aliases: ['kimi-k2.5'], modelDescriptorId: 'kimi-k2.5', label: 'Kimi K2.5', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], wireFormat: 'reasoning_effort' } },
{ id: 'moonshotai/kimi-k2.7-code', apiName: 'moonshotai/kimi-k2.7-code', aliases: ['kimi-k2.7-code'], modelDescriptorId: 'kimi-k2.7-code', label: 'Kimi K2.7 Code', contextWindow: 262_144, maxOutputTokens: 32_768, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
{ id: 'moonshotai/kimi-k2.6', apiName: 'moonshotai/kimi-k2.6', aliases: ['kimi-k2.6'], modelDescriptorId: 'kimi-k2.6', label: 'Kimi K2.6', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
{ id: 'moonshotai/kimi-k2.5', apiName: 'moonshotai/kimi-k2.5', aliases: ['kimi-k2.5'], modelDescriptorId: 'kimi-k2.5', label: 'Kimi K2.5', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
{ id: 'zai-org/glm-5.2', apiName: 'zai-org/glm-5.2', aliases: ['glm-5.2'], modelDescriptorId: 'glm-5.2', label: 'GLM 5.2', contextWindow: 202_752, maxOutputTokens: 202_752, capabilities: { supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], wireFormat: 'reasoning_effort' } },
{ id: 'zai-org/glm-5.1', apiName: 'zai-org/glm-5.1', aliases: ['glm-5.1'], modelDescriptorId: 'glm-5.1', label: 'GLM 5.1', contextWindow: 202_752, maxOutputTokens: 202_752, capabilities: { supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], wireFormat: 'reasoning_effort' } },
{ id: 'zai-org/glm-5', apiName: 'zai-org/glm-5', aliases: ['glm-5'], modelDescriptorId: 'glm-5', label: 'GLM 5', contextWindow: 202_752, maxOutputTokens: 202_752, capabilities: { supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high', 'xhigh'], wireFormat: 'reasoning_effort' } },
+2 -1
View File
@@ -33,7 +33,8 @@ export default defineGateway({
catalog: {
source: 'static',
models: [
{ id: 'kimi-for-coding', apiName: 'kimi-for-coding', label: 'Kimi for Coding', modelDescriptorId: 'kimi-for-coding' },
{ id: 'kimi-k2.7-code', apiName: 'kimi-k2.7-code', aliases: ['moonshotai/kimi-k2.7-code'], label: 'Kimi K2.7 Code', modelDescriptorId: 'kimi-k2.7-code', contextWindow: 262_144, maxOutputTokens: 32_768, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
{ id: 'kimi-for-coding', apiName: 'kimi-for-coding', label: 'Kimi for Coding', modelDescriptorId: 'kimi-for-coding', contextWindow: 262_144, maxOutputTokens: 32_768, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
],
},
usage: { supported: false },
+121
View File
@@ -184,6 +184,127 @@ describe('resolveOpenAIShimRuntimeContext - Z.AI GLM-5.2', () => {
})
})
describe('resolveOpenAIShimRuntimeContext - Moonshot and Kimi Code catalog metadata', () => {
it('uses Moonshot direct catalog order, limits, and reasoning controls', () => {
expect(
resolveModelRuntimeLimits({
model: 'kimi-k2.7-code',
baseUrl: 'https://api.moonshot.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
}),
).toEqual({ contextWindow: 262_144, maxOutputTokens: 32_768 })
expect(
resolveModelRuntimeLimits({
model: 'kimi-k2.6',
baseUrl: 'https://api.moonshot.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
}),
).toEqual({ contextWindow: 262_144, maxOutputTokens: 262_144 })
expect(
resolveModelRuntimeLimits({
model: 'kimi-k2.5',
baseUrl: 'https://api.moonshot.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
}),
).toEqual({ contextWindow: 262_144, maxOutputTokens: 262_144 })
const result = resolveOpenAIShimRuntimeContext({
model: 'kimi-k2.7-code',
baseUrl: 'https://api.moonshot.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
})
expect(result.routeId).toBe('moonshot')
expect(result.descriptor?.catalog?.models?.map(model => model.id)).toEqual([
'kimi-k2.7-code',
'kimi-k2.6',
'kimi-k2.5',
])
expect(result.catalogEntry?.id).toBe('kimi-k2.7-code')
expect(result.catalogEntry?.aliases).toContain('moonshotai/kimi-k2.7-code')
expect(result.catalogEntry?.reasoning?.levels).toEqual(['low', 'medium', 'high'])
expect(result.catalogEntry?.reasoning?.defaultLevel).toBe('medium')
expect(result.openaiShimConfig.maxTokensField).toBe('max_tokens')
expect(result.openaiShimConfig.removeBodyFields).toContain('store')
const qualified = resolveOpenAIShimRuntimeContext({
model: 'moonshotai/kimi-k2.7-code',
baseUrl: 'https://api.moonshot.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
})
expect(qualified.routeId).toBe('moonshot')
expect(qualified.catalogEntry?.id).toBe('kimi-k2.7-code')
expect(qualified.catalogEntry?.reasoning?.levels).toEqual(['low', 'medium', 'high'])
})
it('uses Kimi Code gateway catalog limits and reasoning controls', () => {
expect(
resolveModelRuntimeLimits({
model: 'kimi-for-coding',
baseUrl: 'https://api.kimi.com/coding/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
}),
).toEqual({ contextWindow: 262_144, maxOutputTokens: 32_768 })
const result = resolveOpenAIShimRuntimeContext({
model: 'kimi-for-coding',
baseUrl: 'https://api.kimi.com/coding/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
})
expect(result.routeId).toBe('kimi-code')
expect(result.descriptor?.catalog?.models?.map(model => model.id)).toEqual([
'kimi-k2.7-code',
'kimi-for-coding',
])
expect(result.catalogEntry?.id).toBe('kimi-for-coding')
expect(result.catalogEntry?.reasoning?.levels).toEqual(['low', 'medium', 'high'])
expect(result.catalogEntry?.reasoning?.defaultLevel).toBe('medium')
expect(result.openaiShimConfig.maxTokensField).toBe('max_tokens')
expect(result.openaiShimConfig.removeBodyFields).toContain('store')
const k27 = resolveOpenAIShimRuntimeContext({
model: 'kimi-k2.7-code',
baseUrl: 'https://api.kimi.com/coding/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
})
expect(k27.routeId).toBe('kimi-code')
expect(k27.catalogEntry?.id).toBe('kimi-k2.7-code')
expect(k27.catalogEntry?.reasoning?.levels).toEqual(['low', 'medium', 'high'])
const qualified = resolveOpenAIShimRuntimeContext({
model: 'moonshotai/kimi-k2.7-code',
baseUrl: 'https://api.kimi.com/coding/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
})
expect(qualified.routeId).toBe('kimi-code')
expect(qualified.catalogEntry?.id).toBe('kimi-k2.7-code')
expect(qualified.catalogEntry?.reasoning?.levels).toEqual(['low', 'medium', 'high'])
})
it('uses Atlas Cloud catalog limits for Moonshot Kimi K2.7 Code', () => {
expect(
resolveModelRuntimeLimits({
model: 'moonshotai/kimi-k2.7-code',
baseUrl: 'https://api.atlascloud.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
}),
).toEqual({ contextWindow: 262_144, maxOutputTokens: 32_768 })
const result = resolveOpenAIShimRuntimeContext({
model: 'moonshotai/kimi-k2.7-code',
baseUrl: 'https://api.atlascloud.ai/v1',
processEnv: { CLAUDE_CODE_USE_OPENAI: '1' },
})
expect(result.routeId).toBe('atlas-cloud')
expect(result.catalogEntry?.id).toBe('moonshotai/kimi-k2.7-code')
expect(result.catalogEntry?.reasoning?.levels).toEqual(['low', 'medium', 'high'])
expect(result.catalogEntry?.reasoning?.defaultLevel).toBe('medium')
})
})
describe('resolveOpenAIShimRuntimeContext - Hicap catalog metadata', () => {
it('uses Hicap static model limits and per-model shim overrides', () => {
expect(
+4 -3
View File
@@ -5,7 +5,7 @@ export default defineVendor({
label: 'Moonshot AI',
classification: 'openai-compatible',
defaultBaseUrl: 'https://api.moonshot.ai/v1',
defaultModel: 'kimi-k2.5',
defaultModel: 'kimi-k2.7-code',
requiredEnvVars: ['MOONSHOT_API_KEY'],
setup: {
requiresAuth: true,
@@ -34,8 +34,9 @@ export default defineVendor({
catalog: {
source: 'static',
models: [
{ id: 'kimi-k2.5', apiName: 'kimi-k2.5', label: 'Kimi K2.5' },
{ id: 'kimi-k2.6', apiName: 'kimi-k2.6', label: 'Kimi K2.6' },
{ id: 'kimi-k2.7-code', apiName: 'kimi-k2.7-code', aliases: ['moonshotai/kimi-k2.7-code'], label: 'Kimi K2.7 Code', modelDescriptorId: 'kimi-k2.7-code', contextWindow: 262_144, maxOutputTokens: 32_768, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
{ id: 'kimi-k2.6', apiName: 'kimi-k2.6', aliases: ['moonshotai/kimi-k2.6'], label: 'Kimi K2.6', modelDescriptorId: 'kimi-k2.6', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
{ id: 'kimi-k2.5', apiName: 'kimi-k2.5', aliases: ['moonshotai/kimi-k2.5'], label: 'Kimi K2.5', modelDescriptorId: 'kimi-k2.5', contextWindow: 262_144, maxOutputTokens: 262_144, capabilities: { supportsVision: true, supportsFunctionCalling: true, supportsJsonMode: true, supportsReasoning: true }, reasoning: { mode: 'levels', levels: ['low', 'medium', 'high'], defaultLevel: 'medium', wireFormat: 'reasoning_effort' } },
],
},
usage: { supported: false },
+105 -42
View File
@@ -1527,58 +1527,121 @@ test('providerOverride clamps stale effort against metadata levels', async () =>
})
test('providerOverride Atlas Kimi metadata emits top-level reasoning_effort and clamps unsupported levels', async () => {
let requestBody: Record<string, unknown> | undefined
const originalFetch = globalThis.fetch
globalThis.fetch = (async (_input, init) => {
requestBody = JSON.parse(String(init?.body))
try {
globalThis.fetch = (async (_input, init) => {
requestBody = JSON.parse(String(init?.body))
return new Response(
JSON.stringify({
id: 'chatcmpl-provider-override-atlas-kimi',
model: 'moonshotai/kimi-k2.6',
choices: [
{
message: {
role: 'assistant',
content: 'ok',
return new Response(
JSON.stringify({
id: 'chatcmpl-provider-override-atlas-kimi',
model: 'moonshotai/kimi-k2.7-code',
choices: [
{
message: {
role: 'assistant',
content: 'ok',
},
finish_reason: 'stop',
},
finish_reason: 'stop',
],
usage: {
prompt_tokens: 8,
completion_tokens: 3,
total_tokens: 11,
},
}),
{
headers: {
'Content-Type': 'application/json',
},
],
usage: {
prompt_tokens: 8,
completion_tokens: 3,
total_tokens: 11,
},
}),
{
headers: {
'Content-Type': 'application/json',
},
)
}) as FetchType
const client = (await getAnthropicClient({
maxRetries: 0,
effortValue: 'xhigh',
providerOverride: {
model: 'moonshotai/kimi-k2.7-code',
baseURL: 'https://api.atlascloud.ai/v1',
apiKey: 'atlas-test-key',
},
)
}) as FetchType
})) as unknown as ShimClient
const client = (await getAnthropicClient({
maxRetries: 0,
effortValue: 'xhigh',
providerOverride: {
model: 'moonshotai/kimi-k2.6',
baseURL: 'https://api.atlascloud.ai/v1',
apiKey: 'atlas-test-key',
},
})) as unknown as ShimClient
await client.beta.messages.create({
model: 'unused',
system: 'test system',
messages: [{ role: 'user', content: 'hello' }],
max_tokens: 64,
stream: false,
})
await client.beta.messages.create({
model: 'unused',
system: 'test system',
messages: [{ role: 'user', content: 'hello' }],
max_tokens: 64,
stream: false,
})
expect(requestBody?.reasoning_effort).toBe('xhigh')
expect(requestBody?.reasoning_effort).toBe('high')
} finally {
globalThis.fetch = originalFetch
}
})
test('providerOverride Kimi Code clamps unsupported xhigh effort to high', async () => {
let requestBody: Record<string, unknown> | undefined
const originalFetch = globalThis.fetch
try {
globalThis.fetch = (async (_input, init) => {
requestBody = JSON.parse(String(init?.body))
return new Response(
JSON.stringify({
id: 'chatcmpl-provider-override-kimi-code',
model: 'kimi-for-coding',
choices: [
{
message: {
role: 'assistant',
content: 'ok',
},
finish_reason: 'stop',
},
],
usage: {
prompt_tokens: 8,
completion_tokens: 3,
total_tokens: 11,
},
}),
{
headers: {
'Content-Type': 'application/json',
},
},
)
}) as FetchType
const client = (await getAnthropicClient({
maxRetries: 0,
effortValue: 'xhigh',
providerOverride: {
model: 'kimi-for-coding',
baseURL: 'https://api.kimi.com/coding/v1',
apiKey: 'kimi-test-key',
},
})) as unknown as ShimClient
await client.beta.messages.create({
model: 'unused',
system: 'test system',
messages: [{ role: 'user', content: 'hello' }],
max_tokens: 64,
stream: false,
})
expect(requestBody?.reasoning_effort).toBe('high')
} finally {
globalThis.fetch = originalFetch
}
})
test('providerOverride Atlas Grok Build does not send reasoning effort', async () => {
let requestBody: Record<string, unknown> | undefined
+85 -1
View File
@@ -409,6 +409,86 @@ test('explicit reasoning metadata enables model-level effort without provider-wi
expect(resolveAppliedEffort('xai/grok-build-0.1', 'high')).toBeUndefined()
})
test('Moonshot direct and Kimi Code catalogs expose verified reasoning controls', async () => {
const moonshotVendor = (await import('../integrations/vendors/moonshot.js')).default
const kimiCodeGateway = (await import('../integrations/gateways/kimi-code.js')).default
expect(moonshotVendor.catalog?.models?.map(model => model.id)).toEqual([
'kimi-k2.7-code',
'kimi-k2.6',
'kimi-k2.5',
])
for (const { routeId, model, entries } of [
{ routeId: 'moonshot', model: 'kimi-k2.6', entries: moonshotVendor.catalog?.models ?? [] },
{ routeId: 'kimi-code', model: 'kimi-for-coding', entries: kimiCodeGateway.catalog?.models ?? [] },
{ routeId: 'kimi-code', model: 'kimi-k2.7-code', entries: kimiCodeGateway.catalog?.models ?? [] },
{ routeId: 'kimi-code', model: 'moonshotai/kimi-k2.7-code', entries: kimiCodeGateway.catalog?.models ?? [] },
]) {
const {
getAvailableEffortLevels,
getDefaultEffortForModel,
modelSupportsEffort,
modelSupportsWireEffort,
resolveAppliedEffort,
resolveModelReasoningControl,
} = await importFreshEffortModule({
provider: 'openai',
supportsCodexReasoningEffort: false,
routeId,
catalogEntries: entries,
})
expect(resolveModelReasoningControl(model)).toMatchObject({
supportsReasoning: true,
controllable: true,
source: 'metadata',
levels: ['low', 'medium', 'high'],
defaultLevel: 'medium',
wireFormat: 'reasoning_effort',
})
expect(modelSupportsEffort(model)).toBe(true)
expect(modelSupportsWireEffort(model)).toBe(true)
expect(getAvailableEffortLevels(model)).toEqual(['low', 'medium', 'high'])
expect(getDefaultEffortForModel(model)).toBe('medium')
expect(resolveAppliedEffort(model, undefined)).toBe('medium')
expect(resolveAppliedEffort(model, 'xhigh')).toBe('high')
expect(resolveAppliedEffort(model, 'max')).toBe('high')
}
const {
getAvailableEffortLevels,
resolveAppliedEffort,
resolveModelReasoningControl,
} = await importFreshEffortModule({
provider: 'openai',
supportsCodexReasoningEffort: false,
routeId: 'moonshot',
catalogEntries: moonshotVendor.catalog?.models ?? [],
})
expect(resolveModelReasoningControl('kimi-k2.7-code')).toMatchObject({
supportsReasoning: true,
controllable: true,
source: 'metadata',
levels: ['low', 'medium', 'high'],
defaultLevel: 'medium',
wireFormat: 'reasoning_effort',
})
expect(getAvailableEffortLevels('kimi-k2.7-code')).toEqual(['low', 'medium', 'high'])
expect(resolveAppliedEffort('kimi-k2.7-code', 'xhigh')).toBe('high')
expect(resolveAppliedEffort('kimi-k2.7-code', 'max')).toBe('high')
expect(resolveModelReasoningControl('moonshotai/kimi-k2.7-code')).toMatchObject({
supportsReasoning: true,
controllable: true,
source: 'metadata',
levels: ['low', 'medium', 'high'],
defaultLevel: 'medium',
wireFormat: 'reasoning_effort',
})
expect(getAvailableEffortLevels('moonshotai/kimi-k2.7-code')).toEqual(['low', 'medium', 'high'])
expect(resolveAppliedEffort('moonshotai/kimi-k2.7-code', 'xhigh')).toBe('high')
})
test('Atlas Cloud catalog exposes only verified reasoning controls for exact models', async () => {
const atlasGateway = (await import('../integrations/gateways/atlas-cloud.js')).default
const {
@@ -429,6 +509,7 @@ test('Atlas Cloud catalog exposes only verified reasoning controls for exact mod
controllable: true,
source: 'metadata',
levels: ['low', 'medium', 'high', 'xhigh'],
defaultLevel: 'medium',
wireFormat: 'reasoning_effort',
})
expect(getAvailableEffortLevels('moonshotai/kimi-k2.5')).toEqual([
@@ -444,6 +525,7 @@ test('Atlas Cloud catalog exposes only verified reasoning controls for exact mod
controllable: true,
source: 'metadata',
levels: ['low', 'medium', 'high', 'xhigh'],
defaultLevel: 'medium',
wireFormat: 'reasoning_effort',
})
expect(getAvailableEffortLevels('moonshotai/kimi-k2.6')).toEqual([
@@ -551,11 +633,13 @@ test('Atlas Cloud catalog exposes only verified reasoning controls for exact mod
supportsReasoning: true,
controllable: true,
source: 'metadata',
levels: ['low', 'medium', 'high', 'xhigh'],
levels: ['low', 'medium', 'high'],
defaultLevel: 'medium',
wireFormat: 'reasoning_effort',
})
expect(modelSupportsEffort('moonshotai/kimi-k2.7-code')).toBe(true)
expect(modelSupportsWireEffort('moonshotai/kimi-k2.7-code')).toBe(true)
expect(resolveAppliedEffort('moonshotai/kimi-k2.7-code', 'xhigh')).toBe('high')
expect(resolveModelReasoningControl('xai/grok-build-0.1')).toMatchObject({
supportsReasoning: false,
+1 -1
View File
@@ -1708,7 +1708,7 @@ describe('getProviderPresetDefaults', () => {
expect(defaults.name).toBe('Moonshot AI - API')
expect(defaults.baseUrl).toBe('https://api.moonshot.ai/v1')
expect(defaults.model).toBe('kimi-k2.5')
expect(defaults.model).toBe('kimi-k2.7-code')
})
test('deepseek preset defaults to DeepSeek V4 Pro', async () => {
const { getProviderPresetDefaults } = await importFreshProviderProfileModules()