From b6a27bdc6877c25794c050e709fe808457a5ec97 Mon Sep 17 00:00:00 2001 From: Miro Date: Mon, 21 Sep 2026 07:58:59 +0200 Subject: [PATCH] fix(kimi): discover configured models dynamically (#1873) * fix(kimi): discover configured models dynamically * fix(kimi): address dynamic model review findings Probe settlement (Major): parse `kimi provider list --json` on the child's 'close' event instead of 'exit', so stdio is fully drained first, and run the parse inside a guarded settle() helper. A parser throw previously escaped the promise from an async event callback and reached the runner's uncaughtException shutdown handler instead of listKimiModelsForCwd's catch. The helper also settles the promise exactly once across timeout, spawn error and close, names the terminating signal when there is no exit code, and tolerates a kill() that throws. Running-session discovery (Minor): add a session-scoped Kimi catalog. The shared RPC method `listKimiModels`, a CLI handler registered on the session connection with the probe cwd taken from the session metadata (never from RPC arguments), hub rpcGateway/syncEngine pass-throughs, and GET /api/sessions/:id/kimi-models gated on an active session of flavor `kimi`. SessionChat now reads the catalog from that endpoint, so an active session advertises its models even when no background runner holds the machine socket. New Session keeps the machine-scoped discovery unchanged, and model switching still goes through the existing ACP set_model path. * fix(kimi): register session model discovery before the local/remote loop The session catalog handler was registered inside the remote launcher, after ACP initialization. A session started with `hapi kimi` in local mode therefore answered the web picker's request with an unregistered-handler error, and the failed query was not retried or invalidated when remote control was taken over. The catalog is backend independent, so it is now registered in runKimi session setup alongside the other session-level handlers, using the session's working directory, and the late registration in the remote launcher is removed. This covers local, remote and resumed sessions on the same session connection. Adds cli/src/kimi/runKimi.test.ts asserting the handler is registered after bootstrap and before the loop, and that the probe cwd is the session's working directory. The launcher wiring assertion moves out of kimiRemoteLauncher.test.ts with the registration. --- cli/src/api/apiMachine.test.ts | 72 ++++++ cli/src/api/apiMachine.ts | 20 ++ cli/src/kimi/runKimi.test.ts | 105 +++++++++ cli/src/kimi/runKimi.ts | 5 + .../common/handlers/kimiModels.test.ts | 135 +++++++++++ cli/src/modules/common/handlers/kimiModels.ts | 46 ++++ cli/src/modules/common/kimiModels.test.ts | 168 +++++++++++++ cli/src/modules/common/kimiModels.ts | 223 ++++++++++++++++++ .../modules/common/kimiModelsProbe.test.ts | 175 ++++++++++++++ .../modules/common/registerCommonHandlers.ts | 2 + docs/api/client-contract/rest.md | 4 +- hub/src/sync/rpcGateway.ts | 24 ++ hub/src/sync/syncEngine.ts | 10 + hub/src/web/routes/machines.ts | 25 ++ hub/src/web/routes/sessions.test.ts | 46 ++++ hub/src/web/routes/sessions.ts | 18 ++ shared/src/agentConfig.ts | 2 +- shared/src/apiTypes.ts | 16 ++ shared/src/rpcMethods.ts | 2 + web/src/api/client.test.ts | 30 +++ web/src/api/client.ts | 13 + .../AssistantChat/modelOptions.test.ts | 18 ++ .../components/NewSession/grokModels.test.ts | 69 +++++- web/src/components/NewSession/grokModels.ts | 48 +++- web/src/components/NewSession/index.test.tsx | 100 ++++++++ web/src/components/NewSession/index.tsx | 59 ++++- .../components/NewSession/preferences.test.ts | 18 ++ web/src/components/NewSession/preferences.ts | 5 +- web/src/components/SessionChat.tsx | 21 +- web/src/hooks/queries/useKimiModelsForCwd.ts | 48 ++++ .../queries/useKimiModelsForSession.test.tsx | 108 +++++++++ .../hooks/queries/useKimiModelsForSession.ts | 38 +++ web/src/lib/query-keys.ts | 2 + web/src/types/api.ts | 2 + 34 files changed, 1664 insertions(+), 13 deletions(-) create mode 100644 cli/src/kimi/runKimi.test.ts create mode 100644 cli/src/modules/common/handlers/kimiModels.test.ts create mode 100644 cli/src/modules/common/handlers/kimiModels.ts create mode 100644 cli/src/modules/common/kimiModels.test.ts create mode 100644 cli/src/modules/common/kimiModels.ts create mode 100644 cli/src/modules/common/kimiModelsProbe.test.ts create mode 100644 web/src/hooks/queries/useKimiModelsForCwd.ts create mode 100644 web/src/hooks/queries/useKimiModelsForSession.test.tsx create mode 100644 web/src/hooks/queries/useKimiModelsForSession.ts diff --git a/cli/src/api/apiMachine.test.ts b/cli/src/api/apiMachine.test.ts index fecf5672..ccc48662 100644 --- a/cli/src/api/apiMachine.test.ts +++ b/cli/src/api/apiMachine.test.ts @@ -8,6 +8,7 @@ const listOpencodeModelsForCwdMock = vi.hoisted(() => vi.fn()) const listOpencodeModelVariantsMock = vi.hoisted(() => vi.fn()) const listGrokModelsForCwdMock = vi.hoisted(() => vi.fn()) const listCopilotModelsForCwdMock = vi.hoisted(() => vi.fn()) +const listKimiModelsForCwdMock = vi.hoisted(() => vi.fn()) const inspectCursorChatStoreMock = vi.hoisted(() => vi.fn()) vi.mock('socket.io-client', () => ({ @@ -34,6 +35,10 @@ vi.mock('../modules/common/copilotModels', () => ({ listCopilotModelsForCwd: listCopilotModelsForCwdMock })) +vi.mock('../modules/common/kimiModels', () => ({ + listKimiModelsForCwd: listKimiModelsForCwdMock +})) + vi.mock('@/cursor/cursorChatStoreStatus', () => ({ inspectCursorChatStore: inspectCursorChatStoreMock })) @@ -107,6 +112,15 @@ async function callListCopilotModels(client: ApiMachineClient, machineId: string return JSON.parse(raw) as unknown } +async function callListKimiModels(client: ApiMachineClient, machineId: string, cwd: string): Promise { + const manager = (client as unknown as { rpcHandlerManager: { handleRequest: (req: { method: string; params: string }) => Promise } }).rpcHandlerManager + const raw = await manager.handleRequest({ + method: `${machineId}:listKimiModelsForCwd`, + params: JSON.stringify({ cwd }) + }) + return JSON.parse(raw) as unknown +} + async function callCursorChatStoreStatus( client: ApiMachineClient, machineId: string, @@ -479,6 +493,64 @@ describe('ApiMachineClient listGrokModelsForCwd handler', () => { }) }) +describe('ApiMachineClient listKimiModelsForCwd handler', () => { + let workspaceRoot: string + + beforeEach(() => { + ioMock.mockReset() + listKimiModelsForCwdMock.mockReset() + workspaceRoot = mkdtempSync(join(tmpdir(), 'hapi-kimi-machine-ws-')) + }) + + afterEach(() => { + rmSync(workspaceRoot, { recursive: true, force: true }) + }) + + it('rejects cwd outside workspace roots before running the Kimi model probe', async () => { + const machine = makeMachine('kimi-machine-1') + const client = new ApiMachineClient('cli-token', machine, [workspaceRoot]) + const outsideCwd = mkdtempSync(join(tmpdir(), 'hapi-kimi-outside-')) + + try { + expect(await callListKimiModels(client, machine.id, outsideCwd)).toEqual({ + success: false, + error: 'Path is outside workspace roots' + }) + expect(listKimiModelsForCwdMock).not.toHaveBeenCalled() + } finally { + rmSync(outsideCwd, { recursive: true, force: true }) + client.shutdown() + } + }) + + it('forwards a resolved workspace cwd to the Kimi model probe', async () => { + const machine = makeMachine('kimi-machine-2') + const client = new ApiMachineClient('cli-token', machine, [workspaceRoot]) + listKimiModelsForCwdMock.mockResolvedValueOnce({ + success: true, + availableModels: [ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' }, + { modelId: 'hyper-glm-5.3-flash', name: 'charm-hyper / Hyper · GLM-5.3-Flash', provider: 'charm-hyper' } + ], + currentModelId: 'GLM-5.3-flash' + }) + + try { + expect(await callListKimiModels(client, machine.id, workspaceRoot)).toEqual({ + success: true, + availableModels: [ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' }, + { modelId: 'hyper-glm-5.3-flash', name: 'charm-hyper / Hyper · GLM-5.3-Flash', provider: 'charm-hyper' } + ], + currentModelId: 'GLM-5.3-flash' + }) + expect(listKimiModelsForCwdMock).toHaveBeenCalledWith(realpathSync.native(workspaceRoot)) + } finally { + client.shutdown() + } + }) +}) + describe('ApiMachineClient Codex transcript handlers', () => { const originalCodexHome = process.env.CODEX_HOME let workspaceRoot: string diff --git a/cli/src/api/apiMachine.ts b/cli/src/api/apiMachine.ts index c1ae191a..b342e4e8 100644 --- a/cli/src/api/apiMachine.ts +++ b/cli/src/api/apiMachine.ts @@ -49,6 +49,11 @@ import { type ListCopilotModelsForCwdRequest, type ListCopilotModelsForCwdResponse } from '../modules/common/copilotModels' +import { + listKimiModelsForCwd, + type ListKimiModelsForCwdRequest, + type ListKimiModelsForCwdResponse +} from '../modules/common/kimiModels' import type { SpawnSessionOptions, SpawnSessionResult } from '../modules/common/rpcTypes' import { applyVersionedAck } from './versionedUpdate' import { archiveLocalCodexSession, listLocalCodexSessionSummaries, listLocalCodexSessionsWithMessagesByIds } from '../modules/common/codexSessions' @@ -306,6 +311,21 @@ export class ApiMachineClient { } ) + this.rpcHandlerManager.registerHandler( + RPC_METHODS.ListKimiModelsForCwd, + async (params) => { + const rawCwd = typeof params?.cwd === 'string' ? params.cwd.trim() : '' + if (!rawCwd) return { success: false, error: 'cwd is required' } + + const resolvedCwd = await this.pathPolicy.resolveForCheck(rawCwd) + if (!this.pathPolicy.isWithinSpawnRoots(resolvedCwd)) { + return { success: false, error: 'Path is outside workspace roots' } + } + + return await listKimiModelsForCwd(resolvedCwd) + } + ) + this.rpcHandlerManager.registerHandler( RPC_METHODS.ListCodexSessions, async (params) => { diff --git a/cli/src/kimi/runKimi.test.ts b/cli/src/kimi/runKimi.test.ts new file mode 100644 index 00000000..e971be34 --- /dev/null +++ b/cli/src/kimi/runKimi.test.ts @@ -0,0 +1,105 @@ +import { describe, expect, it, vi } from 'vitest' + +const harness = vi.hoisted(() => ({ + order: [] as string[], + registered: [] as Array<{ manager: unknown; getCwd: () => string }>, + loopOptions: null as Record | null, + createSession: () => ({ + rpcHandlerManager: { registerHandler: vi.fn() }, + onUserMessage: vi.fn(), + onCancelQueuedMessage: vi.fn() + }) +})) + +vi.mock('@/modules/common/handlers/kimiModels', () => ({ + registerKimiSessionModelHandlers: (manager: unknown, getCwd: () => string) => { + harness.order.push('register-kimi-models') + harness.registered.push({ manager, getCwd }) + } +})) + +vi.mock('@/agent/sessionFactory', () => ({ + bootstrapSession: async () => { + harness.order.push('bootstrap') + return { + api: {}, + session: harness.createSession(), + sessionInfo: {}, + metadata: {}, + machineId: 'machine-1', + startedBy: 'terminal', + workingDirectory: '/work/project' + } + }, + bootstrapExistingSession: async () => { + harness.order.push('bootstrap') + return { + api: {}, + session: harness.createSession(), + sessionInfo: {}, + metadata: {}, + machineId: 'machine-1', + startedBy: 'terminal', + workingDirectory: '/work/project' + } + } +})) + +vi.mock('./loop', () => ({ + kimiLoop: async (options: Record) => { + harness.order.push('loop') + harness.loopOptions = options + } +})) + +vi.mock('@/agent/runnerLifecycle', () => ({ + createRunnerLifecycle: () => ({ + registerProcessHandlers: vi.fn(), + markCrash: vi.fn(), + setExitCode: vi.fn(), + setArchiveReason: vi.fn(), + setSessionEndReason: vi.fn(), + cleanupAndExit: async () => {} + }), + createModeChangeHandler: () => vi.fn(), + setControlledByUser: vi.fn() +})) + +vi.mock('@/claude/registerKillSessionHandler', () => ({ + registerKillSessionHandler: vi.fn() +})) +vi.mock('@/agent/localHandoff', () => ({ + registerLocalHandoffHandler: vi.fn() +})) +vi.mock('./utils/config', () => ({ + resolveKimiRuntimeConfig: () => ({ model: undefined, modelSource: 'default' }) +})) + +import { runKimi } from './runKimi' + +describe('runKimi session model discovery', () => { + it('registers the session catalog before the local/remote loop starts', async () => { + harness.order = [] + harness.registered = [] + harness.loopOptions = null + + await runKimi({ workingDirectory: '/work/project', startingMode: 'local' }) + + // A locally running session must answer the picker's request even + // though no remote launcher (and no ACP backend) exists yet. + expect(harness.order).toEqual(['bootstrap', 'register-kimi-models', 'loop']) + expect(harness.registered).toHaveLength(1) + }) + + it('probes the working directory the session was started in', async () => { + harness.order = [] + harness.registered = [] + harness.loopOptions = null + + await runKimi({ workingDirectory: '/work/other-project', startingMode: 'local' }) + + const loopOptions = harness.loopOptions as Record | null + expect(harness.registered[0]?.getCwd()).toBe('/work/other-project') + expect(loopOptions?.path).toBe('/work/other-project') + }) +}) diff --git a/cli/src/kimi/runKimi.ts b/cli/src/kimi/runKimi.ts index f148b880..e30857e0 100644 --- a/cli/src/kimi/runKimi.ts +++ b/cli/src/kimi/runKimi.ts @@ -14,6 +14,7 @@ import { PermissionModeSchema } from '@hapi/protocol/schemas'; import { formatMessageWithAttachments } from '@/utils/attachmentFormatter'; import { getInvokedCwd } from '@/utils/invokedCwd'; import { resolveKimiRuntimeConfig } from './utils/config'; +import { registerKimiSessionModelHandlers } from '@/modules/common/handlers/kimiModels'; export async function runKimi(opts: { startedBy?: 'runner' | 'terminal'; @@ -84,6 +85,10 @@ export async function runKimi(opts: { lifecycle.registerProcessHandlers(); registerKillSessionHandler(session.rpcHandlerManager, lifecycle); registerLocalHandoffHandler(session.rpcHandlerManager, lifecycle); + // Registered here, not in the remote launcher: the catalog is backend + // independent, and a session running in local mode must answer the web + // picker's request before remote control is taken over. + registerKimiSessionModelHandlers(session.rpcHandlerManager, () => workingDirectory); const syncSessionMode = () => { const sessionInstance = sessionWrapperRef.current; diff --git a/cli/src/modules/common/handlers/kimiModels.test.ts b/cli/src/modules/common/handlers/kimiModels.test.ts new file mode 100644 index 00000000..8af2c140 --- /dev/null +++ b/cli/src/modules/common/handlers/kimiModels.test.ts @@ -0,0 +1,135 @@ +import { EventEmitter } from 'node:events' +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { RPC_METHODS } from '@hapi/protocol/rpcMethods' +import type { RpcHandlerManager } from '@/api/rpc/RpcHandlerManager' + +const { spawnMock } = vi.hoisted(() => ({ spawnMock: vi.fn() })) + +vi.mock('node:child_process', () => ({ spawn: spawnMock })) +vi.mock('@/ui/logger', () => ({ + logger: { debug: vi.fn(), warn: vi.fn(), info: vi.fn() } +})) +vi.mock('@/kimi/utils/config', () => ({ + readKimiLocalConfig: () => ({ model: 'GLM-5.3-flash' }) +})) + +import { _resetKimiModelsCacheForTests } from '../kimiModels' +import { registerKimiSessionModelHandlers } from './kimiModels' + +class FakeChild extends EventEmitter { + stdout = new EventEmitter() + stderr = new EventEmitter() + kill = vi.fn() +} + +/** Real `kimi provider list --json` shape, including fields HAPI must strip. */ +const PROVIDER_PAYLOAD = JSON.stringify({ + providers: { + thehive: { + baseUrl: 'https://api.thehive.example/v1', + type: 'openai', + apiKey: 'sk-secret-thehive-key' + } + }, + models: { + 'GLM-5.3-flash': { + provider: 'thehive', + model: 'zai-org/glm-5.3-flash', + displayName: 'thehive / GLM-5.3-flash', + capabilities: ['tool_use'] + } + } +}) + +function registerSessionHandlers(cwd: string): (params: unknown) => Promise { + const handlers = new Map Promise>() + const rpcHandlerManager = { + registerHandler: (method: string, handler: (params: unknown) => Promise) => { + handlers.set(method, handler) + } + } as unknown as RpcHandlerManager + + registerKimiSessionModelHandlers(rpcHandlerManager, () => cwd) + + const handler = handlers.get(RPC_METHODS.ListKimiModels) + if (!handler) { + throw new Error(`session handler ${RPC_METHODS.ListKimiModels} was not registered`) + } + return handler +} + +beforeEach(() => { + spawnMock.mockReset() + _resetKimiModelsCacheForTests() +}) + +describe('registerKimiSessionModelHandlers', () => { + it('answers the catalog over the session connection without a runner', async () => { + const handler = registerSessionHandlers('/work/project') + const child = new FakeChild() + spawnMock.mockImplementation(() => child) + + const pending = handler(undefined) + child.stdout.emit('data', PROVIDER_PAYLOAD) + child.emit('close', 0, null) + + await expect(pending).resolves.toEqual({ + success: true, + availableModels: [{ + modelId: 'GLM-5.3-flash', + name: 'thehive / GLM-5.3-flash', + provider: 'thehive' + }], + currentModelId: 'GLM-5.3-flash' + }) + expect(spawnMock).toHaveBeenCalledWith( + 'kimi', + ['provider', 'list', '--json'], + expect.any(Object) + ) + }) + + it('returns only modelId, name and provider — never provider credentials', async () => { + const handler = registerSessionHandlers('/work/project') + const child = new FakeChild() + spawnMock.mockImplementation(() => child) + + const pending = handler(undefined) + child.stdout.emit('data', PROVIDER_PAYLOAD) + child.emit('close', 0, null) + + const response = await pending + const serialized = JSON.stringify(response) + expect(serialized).not.toContain('sk-secret-thehive-key') + expect(serialized).not.toContain('api.thehive.example') + expect(serialized).not.toContain('baseUrl') + expect(serialized).not.toContain('capabilities') + expect(serialized).not.toContain('zai-org/glm-5.3-flash') + expect(Object.keys((response as { availableModels: Array }).availableModels[0]!).sort()) + .toEqual(['modelId', 'name', 'provider']) + }) + + it('reports a malformed probe as a failed response instead of throwing', async () => { + const handler = registerSessionHandlers('/work/project') + const child = new FakeChild() + spawnMock.mockImplementation(() => child) + + const pending = handler(undefined) + child.stdout.emit('data', '{"models":') + child.emit('close', 0, null) + await expect(pending).resolves.toEqual({ + success: false, + error: 'kimi provider list produced invalid JSON output' + }) + }) + + it('scopes the probe to the session cwd and ignores cwd sent by the caller', async () => { + const handler = registerSessionHandlers('') + + await expect(handler({ cwd: '/etc' })).resolves.toEqual({ + success: false, + error: 'cwd is required' + }) + expect(spawnMock).not.toHaveBeenCalled() + }) +}) diff --git a/cli/src/modules/common/handlers/kimiModels.ts b/cli/src/modules/common/handlers/kimiModels.ts new file mode 100644 index 00000000..97d2e9f3 --- /dev/null +++ b/cli/src/modules/common/handlers/kimiModels.ts @@ -0,0 +1,46 @@ +import { logger } from '@/ui/logger' +import { RPC_METHODS } from '@hapi/protocol/rpcMethods' +import type { ListKimiModelsResponse } from '@hapi/protocol/apiTypes' +import type { RpcHandlerManager } from '@/api/rpc/RpcHandlerManager' +import { + listKimiModelsForCwd, + type ListKimiModelsForCwdRequest, + type ListKimiModelsForCwdResponse +} from '../kimiModels' +import { getErrorMessage, rpcError } from '../rpcResponses' + +export function registerKimiModelHandlers(rpcHandlerManager: RpcHandlerManager): void { + rpcHandlerManager.registerHandler( + RPC_METHODS.ListKimiModelsForCwd, + async (data) => { + try { + return await listKimiModelsForCwd(typeof data?.cwd === 'string' ? data.cwd : '') + } catch (error) { + logger.debug('Failed to list Kimi models:', error) + return rpcError(getErrorMessage(error, 'Failed to list Kimi models')) + } + } + ) +} + +/** + * Session-scoped discovery for a running Kimi session. The probe cwd is the + * session's own metadata, never an RPC argument, so this cannot be pointed at + * an arbitrary directory. + */ +export function registerKimiSessionModelHandlers( + rpcHandlerManager: RpcHandlerManager, + getCwd: () => string +): void { + rpcHandlerManager.registerHandler( + RPC_METHODS.ListKimiModels, + async () => { + try { + return await listKimiModelsForCwd(getCwd()) + } catch (error) { + logger.debug('Failed to list Kimi models:', error) + return rpcError(getErrorMessage(error, 'Failed to list Kimi models')) + } + } + ) +} diff --git a/cli/src/modules/common/kimiModels.test.ts b/cli/src/modules/common/kimiModels.test.ts new file mode 100644 index 00000000..b7b142ec --- /dev/null +++ b/cli/src/modules/common/kimiModels.test.ts @@ -0,0 +1,168 @@ +import { describe, expect, it } from 'vitest' +import { buildKimiProviderListArgs, parseKimiProviderListOutput } from './kimiModels' + +const PROVIDER_LIST_OUTPUT = JSON.stringify({ + providers: { + thehive: { + baseUrl: 'https://api.thehive.example/v1', + type: 'openai', + apiKey: 'sk-secret-thehive-key' + }, + 'charm-hyper': { + baseUrl: 'https://api.charm-hyper.example', + type: 'openai', + apiKey: 'sk-secret-charm-key' + }, + openrouter: { + baseUrl: 'https://openrouter.example/api', + type: 'openai', + apiKey: 'sk-secret-openrouter-key' + } + }, + models: { + 'GLM-5.3-flash': { + provider: 'thehive', + model: 'zai-org/glm-5.3-flash', + displayName: 'thehive / GLM-5.3-flash', + capabilities: ['tool_use', 'image_in'] + }, + 'deepseek-v4.1-flash': { + provider: 'thehive', + model: 'deepseek-ai/deepseek-v4.1-flash', + displayName: 'thehive / hive-deepseek' + }, + 'hyper-glm-5.3-flash': { + provider: 'charm-hyper', + model: 'glm-5.3-flash', + displayName: 'charm-hyper / Hyper · GLM-5.3-Flash' + }, + 'openrouter-union-alpha': { + provider: 'openrouter', + model: 'stealth/union-alpha', + displayName: 'openrouter / Union Alpha' + } + } +}) + +describe('buildKimiProviderListArgs', () => { + it('uses the provider list command in json mode', () => { + expect(buildKimiProviderListArgs()).toEqual(['provider', 'list', '--json']) + }) +}) + +describe('parseKimiProviderListOutput', () => { + it('parses the real provider list format with multiple providers', () => { + const parsed = parseKimiProviderListOutput(PROVIDER_LIST_OUTPUT) + expect(parsed.availableModels.map((model) => model.modelId)).toEqual([ + 'hyper-glm-5.3-flash', + 'openrouter-union-alpha', + 'deepseek-v4.1-flash', + 'GLM-5.3-flash' + ]) + expect(parsed.currentModelId).toBeNull() + }) + + it('keeps several models of the same provider distinct', () => { + const parsed = parseKimiProviderListOutput(PROVIDER_LIST_OUTPUT) + const thehiveModels = parsed.availableModels.filter((model) => model.provider === 'thehive') + expect(thehiveModels.map((model) => model.modelId).sort()).toEqual([ + 'GLM-5.3-flash', + 'deepseek-v4.1-flash' + ]) + }) + + it('carries provider and display name for UI labels', () => { + const parsed = parseKimiProviderListOutput(PROVIDER_LIST_OUTPUT) + const hyper = parsed.availableModels.find((model) => model.modelId === 'hyper-glm-5.3-flash') + expect(hyper).toEqual({ + modelId: 'hyper-glm-5.3-flash', + name: 'charm-hyper / Hyper · GLM-5.3-Flash', + provider: 'charm-hyper' + }) + }) + + it('never transmits secrets from the provider payload', () => { + const parsed = parseKimiProviderListOutput(PROVIDER_LIST_OUTPUT) + const serialized = JSON.stringify(parsed) + expect(serialized).not.toContain('sk-secret-thehive-key') + expect(serialized).not.toContain('sk-secret-charm-key') + expect(serialized).not.toContain('sk-secret-openrouter-key') + expect(serialized).not.toContain('api.thehive.example') + expect(serialized).not.toContain('openrouter.example') + for (const model of parsed.availableModels) { + expect(Object.keys(model).sort()).toEqual(['modelId', 'name', 'provider'].sort()) + } + }) + + it('reports the local default model as current', () => { + const parsed = parseKimiProviderListOutput(PROVIDER_LIST_OUTPUT, 'GLM-5.3-flash') + expect(parsed.currentModelId).toBe('GLM-5.3-flash') + }) + + it('parses a bare models map', () => { + const output = JSON.stringify({ + models: { + 'alias-a': { provider: 'p1', displayName: 'Model A' }, + 'alias-b': { provider: 'p2' } + } + }) + const parsed = parseKimiProviderListOutput(output) + expect(parsed.availableModels.map((model) => model.modelId).sort()).toEqual(['alias-a', 'alias-b']) + }) + + it('parses an array of model entries', () => { + const output = JSON.stringify([ + { alias: 'alias-a', displayName: 'Model A', provider: 'p1', apiKey: 'should-not-leak' }, + { modelId: 'alias-b', name: 'Model B' } + ]) + const parsed = parseKimiProviderListOutput(output) + expect(parsed.availableModels).toEqual([ + { modelId: 'alias-b', name: 'Model B' }, + { modelId: 'alias-a', name: 'Model A', provider: 'p1' } + ]) + expect(JSON.stringify(parsed)).not.toContain('should-not-leak') + }) + + it('parses providers with nested models', () => { + const output = JSON.stringify({ + providers: { + p1: { apiKey: 'secret', models: { 'alias-a': { displayName: 'Model A' } } } + } + }) + const parsed = parseKimiProviderListOutput(output) + expect(parsed.availableModels).toEqual([ + { modelId: 'alias-a', name: 'Model A', provider: undefined } + ]) + expect(JSON.stringify(parsed)).not.toContain('secret') + }) + + it('tolerates leading non-JSON output', () => { + const parsed = parseKimiProviderListOutput(`some banner\n${PROVIDER_LIST_OUTPUT}`) + expect(parsed.availableModels).toHaveLength(4) + }) + + it('falls back to the object key when no alias field exists', () => { + const output = JSON.stringify({ models: { 'key-alias': { model: 'upstream/id' } } }) + const parsed = parseKimiProviderListOutput(output) + expect(parsed.availableModels[0]?.modelId).toBe('key-alias') + // The upstream provider model id is not the alias and must not be used as value. + expect(parsed.availableModels[0]).not.toHaveProperty('modelId', 'upstream/id') + }) + + it('throws on output without JSON', () => { + expect(() => parseKimiProviderListOutput('no json here')).toThrow('no JSON output') + }) + + it('throws on invalid JSON', () => { + expect(() => parseKimiProviderListOutput('{"models":')).toThrow('invalid JSON output') + }) + + it('deduplicates models across shapes', () => { + const output = JSON.stringify({ + models: { 'alias-a': { provider: 'p1' } }, + providers: { p1: { models: { 'alias-a': { displayName: 'dup' } } } } + }) + const parsed = parseKimiProviderListOutput(output) + expect(parsed.availableModels).toHaveLength(1) + }) +}) diff --git a/cli/src/modules/common/kimiModels.ts b/cli/src/modules/common/kimiModels.ts new file mode 100644 index 00000000..9de7a6bf --- /dev/null +++ b/cli/src/modules/common/kimiModels.ts @@ -0,0 +1,223 @@ +import { spawn } from 'node:child_process' +import { getAgentLaunchCommand } from '@/agent/agentLaunchCommand' +import { asString, isObject } from '@hapi/protocol' +import type { KimiModelSummary, KimiModelsResponse } from '@hapi/protocol/apiTypes' +import { readKimiLocalConfig } from '@/kimi/utils/config' +import { logger } from '@/ui/logger' +import { getErrorMessage } from './rpcResponses' + +export interface ListKimiModelsForCwdRequest { + cwd?: string +} + +export type ListKimiModelsForCwdResponse = KimiModelsResponse + +interface CacheEntry { + expiresAt: number + response: ListKimiModelsForCwdResponse +} + +const CACHE_TTL_MS = 60_000 +const PROBE_TIMEOUT_MS = 15_000 +const cache = new Map() +const inflight = new Map>() + +export function buildKimiProviderListArgs(): string[] { + return ['provider', 'list', '--json'] +} + +/** + * Extract only the fields HAPI is allowed to transmit. Everything else in the + * `kimi provider list --json` output (api keys, base urls, upstream model ids, + * context sizes) stays on the machine. + */ +function normalizeModelEntry(entry: Record, keyAlias: string | null): KimiModelSummary | null { + const modelId = asString(entry.modelId) + ?? asString(entry.alias) + ?? asString(entry.id) + ?? keyAlias + if (!modelId) return null + const name = asString(entry.displayName) ?? asString(entry.name) ?? undefined + const provider = asString(entry.provider) ?? undefined + return { + modelId, + ...(name ? { name } : {}), + ...(provider ? { provider } : {}) + } +} + +/** + * Parse `kimi provider list --json`. Handles the real shape + * `{ providers: {...}, models: { "": { provider, displayName, ... } } }` + * plus tolerant variants: a bare `models` map, an array of model entries, and + * a `providers` map whose entries carry nested `models`. Only whitelisted + * fields are returned, so secrets in the payload can never leak through. + */ +export function parseKimiProviderListOutput( + output: string, + defaultModel?: string +): { + availableModels: KimiModelSummary[] + currentModelId: string | null +} { + const availableModels: KimiModelSummary[] = [] + const seen = new Set() + + const push = (entry: Record, keyAlias: string | null) => { + const model = normalizeModelEntry(entry, keyAlias) + if (!model || seen.has(model.modelId)) return + seen.add(model.modelId) + availableModels.push(model) + } + + const jsonStart = output.indexOf('{') + const arrayStart = output.indexOf('[') + const start = jsonStart === -1 + ? arrayStart + : arrayStart !== -1 && arrayStart < jsonStart ? arrayStart : jsonStart + if (start === -1) { + throw new Error('kimi provider list produced no JSON output') + } + let data: unknown + try { + data = JSON.parse(output.slice(start)) + } catch { + throw new Error('kimi provider list produced invalid JSON output') + } + + const collectModelMap = (value: unknown) => { + if (!isObject(value)) return + for (const [alias, entry] of Object.entries(value)) { + if (isObject(entry)) push(entry, alias) + } + } + + if (Array.isArray(data)) { + for (const entry of data) { + if (isObject(entry)) push(entry, null) + } + } else if (isObject(data)) { + collectModelMap(data.models) + if (availableModels.length === 0 && isObject(data.providers)) { + for (const providerEntry of Object.values(data.providers)) { + if (!isObject(providerEntry)) continue + if (isObject(providerEntry.models)) { + collectModelMap(providerEntry.models) + } else { + push(providerEntry, null) + } + } + } + } + + availableModels.sort((a, b) => { + const providerOrder = (a.provider ?? '').localeCompare(b.provider ?? '') + return providerOrder !== 0 ? providerOrder : a.modelId.localeCompare(b.modelId) + }) + + const currentModelId = defaultModel?.trim() || null + return { availableModels, currentModelId } +} + +function describeProbeExit(code: number | null, signal: NodeJS.Signals | null): string { + if (signal) return `kimi provider list was terminated by ${signal}` + return `kimi provider list exited with code ${code}` +} + +async function runKimiProviderListProbe(): Promise { + return await new Promise((resolve, reject) => { + const child = spawn(getAgentLaunchCommand('kimi'), buildKimiProviderListArgs(), { + env: process.env, + stdio: ['ignore', 'pipe', 'pipe'], + shell: process.platform === 'win32', + windowsHide: process.platform === 'win32' + }) + let stdout = '' + let stderr = '' + let settled = false + + // Exactly one of timeout / spawn error / close settles the probe, and + // the settling work is wrapped: a throw from an event callback would + // otherwise escape this promise and reach the runner's + // uncaughtException shutdown handler instead of the caller's catch. + const settle = (outcome: () => void) => { + if (settled) return + settled = true + clearTimeout(timeout) + try { + outcome() + } catch (error) { + reject(error) + } + } + + const timeout = setTimeout(() => { + settle(() => { + try { + child.kill('SIGTERM') + } catch (error) { + logger.debug('Failed to kill the Kimi model discovery probe:', error) + } + reject(new Error('Kimi model discovery timed out')) + }) + }, PROBE_TIMEOUT_MS) + + child.stdout?.on('data', (chunk) => { + stdout += chunk.toString() + }) + child.stderr?.on('data', (chunk) => { + stderr += chunk.toString() + }) + child.on('error', (error) => { + settle(() => reject(error)) + }) + // Parse on 'close', not 'exit': stdio must be drained first, and the + // parser runs inside settle() so malformed output rejects the probe. + child.on('close', (code, signal) => { + settle(() => { + if (code !== 0) { + reject(new Error(stderr.trim() || describeProbeExit(code, signal))) + return + } + const defaultModel = readKimiLocalConfig().model + resolve({ success: true, ...parseKimiProviderListOutput(stdout, defaultModel) }) + }) + }) + }) +} + +export async function listKimiModelsForCwd(cwd: string): Promise { + const trimmed = cwd?.trim() + if (!trimmed) return { success: false, error: 'cwd is required' } + + const cached = cache.get(trimmed) + if (cached && cached.expiresAt > Date.now()) return cached.response + + const running = inflight.get(trimmed) + if (running) return running + + const promise = (async () => { + try { + const response = await runKimiProviderListProbe() + if (response.success) { + cache.set(trimmed, { expiresAt: Date.now() + CACHE_TTL_MS, response }) + } + return response + } catch (error) { + return { + success: false, + error: getErrorMessage(error, 'Failed to discover Kimi models') + } + } finally { + inflight.delete(trimmed) + } + })() + + inflight.set(trimmed, promise) + return promise +} + +export function _resetKimiModelsCacheForTests(): void { + cache.clear() + inflight.clear() +} diff --git a/cli/src/modules/common/kimiModelsProbe.test.ts b/cli/src/modules/common/kimiModelsProbe.test.ts new file mode 100644 index 00000000..3fa9d00d --- /dev/null +++ b/cli/src/modules/common/kimiModelsProbe.test.ts @@ -0,0 +1,175 @@ +import { EventEmitter } from 'node:events' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' + +const { spawnMock, configState } = vi.hoisted(() => ({ + spawnMock: vi.fn(), + configState: { read: (() => ({ model: 'GLM-5.3-flash' })) as () => { model?: string } } +})) + +vi.mock('node:child_process', () => ({ spawn: spawnMock })) +vi.mock('@/ui/logger', () => ({ + logger: { debug: vi.fn(), warn: vi.fn(), info: vi.fn() } +})) +vi.mock('@/kimi/utils/config', () => ({ + readKimiLocalConfig: () => configState.read() +})) + +import { _resetKimiModelsCacheForTests, listKimiModelsForCwd } from './kimiModels' + +class FakeChild extends EventEmitter { + stdout = new EventEmitter() + stderr = new EventEmitter() + kill = vi.fn() +} + +const MALFORMED_OUTPUT = '{"models":' + +function startProbe(cwd: string) { + const child = new FakeChild() + spawnMock.mockImplementation(() => child) + return { child, pending: listKimiModelsForCwd(cwd) } +} + +beforeEach(() => { + spawnMock.mockReset() + configState.read = () => ({ model: 'GLM-5.3-flash' }) + _resetKimiModelsCacheForTests() +}) + +afterEach(() => { + vi.useRealTimers() +}) + +describe('Kimi provider list probe settlement', () => { + it('reports malformed JSON at exit code 0 as a failure instead of throwing out of the callback', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-malformed') + + child.stdout.emit('data', MALFORMED_OUTPUT) + child.emit('exit', 0, null) + child.emit('close', 0, null) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'kimi provider list produced invalid JSON output' + }) + }) + + it('reports missing JSON output as a failure', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-no-json') + + child.stdout.emit('data', 'no json here') + child.emit('close', 0, null) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'kimi provider list produced no JSON output' + }) + }) + + it('contains a throwing local-config read inside the probe promise', async () => { + configState.read = () => { + throw new Error('kimi config unreadable') + } + const { child, pending } = startProbe('/tmp/kimi-probe-config-throws') + + child.stdout.emit('data', JSON.stringify({ models: { 'alias-a': {} } })) + child.emit('close', 0, null) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'kimi config unreadable' + }) + }) + + it('parses stdout that arrives after exit but before close', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-late-stdout') + + child.emit('exit', 0, null) + child.stdout.emit('data', JSON.stringify({ + models: { + 'late-alias': { provider: 'p1', displayName: 'Late Model' } + } + })) + child.emit('close', 0, null) + + await expect(pending).resolves.toEqual({ + success: true, + availableModels: [{ modelId: 'late-alias', name: 'Late Model', provider: 'p1' }], + currentModelId: 'GLM-5.3-flash' + }) + }) + + it('keeps a non-zero exit a failure and prefers stderr', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-exit-1') + + child.stderr.emit('data', 'provider list unavailable\n') + child.emit('close', 1, null) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'provider list unavailable' + }) + }) + + it('keeps a non-zero exit a failure when stderr is empty', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-exit-2') + + child.emit('close', 2, null) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'kimi provider list exited with code 2' + }) + }) + + it('names the terminating signal when the probe dies without an exit code', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-signaled') + + child.emit('close', null, 'SIGKILL') + + await expect(pending).resolves.toEqual({ + success: false, + error: 'kimi provider list was terminated by SIGKILL' + }) + }) + + it('times the probe out and kills the child', async () => { + vi.useFakeTimers() + const { child, pending } = startProbe('/tmp/kimi-probe-timeout') + + await vi.advanceTimersByTimeAsync(15_000) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'Kimi model discovery timed out' + }) + expect(child.kill).toHaveBeenCalledWith('SIGTERM') + }) + + it('lets the first settlement win when an error is followed by a successful close', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-error-then-close') + + child.emit('error', new Error('spawn kimi ENOENT')) + child.stdout.emit('data', JSON.stringify({ models: { 'alias-a': {} } })) + child.emit('close', 0, null) + + await expect(pending).resolves.toEqual({ + success: false, + error: 'spawn kimi ENOENT' + }) + }) + + it('ignores a second close after the probe already settled', async () => { + const { child, pending } = startProbe('/tmp/kimi-probe-double-close') + + child.stdout.emit('data', JSON.stringify({ models: { 'alias-a': { displayName: 'A' } } })) + child.emit('close', 0, null) + child.emit('close', 1, null) + + await expect(pending).resolves.toEqual({ + success: true, + availableModels: [{ modelId: 'alias-a', name: 'A' }], + currentModelId: 'GLM-5.3-flash' + }) + }) +}) diff --git a/cli/src/modules/common/registerCommonHandlers.ts b/cli/src/modules/common/registerCommonHandlers.ts index 88f4ee2e..d00826b8 100644 --- a/cli/src/modules/common/registerCommonHandlers.ts +++ b/cli/src/modules/common/registerCommonHandlers.ts @@ -8,6 +8,7 @@ import { registerOpencodeModelVariantsHandlers } from './handlers/opencodeModelV import { registerPiModelHandlers } from './handlers/piModels' import { registerGrokModelHandlers } from './handlers/grokModels' import { registerCopilotModelHandlers } from './handlers/copilotModels' +import { registerKimiModelHandlers } from './handlers/kimiModels' import { registerDirectoryHandlers } from './handlers/directories' import { registerDifftasticHandlers } from './handlers/difftastic' import { registerFileHandlers } from './handlers/files' @@ -27,6 +28,7 @@ export function registerCommonHandlers(rpcHandlerManager: RpcHandlerManager, wor registerPiModelHandlers(rpcHandlerManager) registerGrokModelHandlers(rpcHandlerManager) registerCopilotModelHandlers(rpcHandlerManager) + registerKimiModelHandlers(rpcHandlerManager) registerFileHandlers(rpcHandlerManager, workingDirectory) registerDirectoryHandlers(rpcHandlerManager, workingDirectory) registerRipgrepHandlers(rpcHandlerManager, workingDirectory) diff --git a/docs/api/client-contract/rest.md b/docs/api/client-contract/rest.md index 247e63be..188ba740 100644 --- a/docs/api/client-contract/rest.md +++ b/docs/api/client-contract/rest.md @@ -138,10 +138,10 @@ The configuration routes in the table above respond `{ok: true}`; apply-failures | Method & path | Notes | |---|---| -| `GET /api/sessions/:id/codex-models`, `/opencode-models`, `/cursor-models`, `/grok-models`, `/copilot-models`, `/pi-models` | Active session of the matching flavor; 400 otherwise | +| `GET /api/sessions/:id/codex-models`, `/opencode-models`, `/cursor-models`, `/grok-models`, `/copilot-models`, `/kimi-models`, `/pi-models` | Active session of the matching flavor; 400 otherwise | | `GET /api/sessions/:id/opencode-reasoning-effort-options`, `/grok-reasoning-effort-options` | Same pattern | | `GET /api/machines/:id/agy-models`, `/pi-models`, `/codex-models`, `/cursor-models` | Machine-level (pre-spawn pickers). `agy-models` takes `?refresh=true` to skip the machine's cached catalog, and may answer `success: true` with an advisory `error` (see [Errors](./errors.md#rpc-wrapped-endpoints)) | -| `GET /api/machines/:id/opencode-models?cwd=`, `/grok-models?cwd=`, `/copilot-models?cwd=` | `cwd` query required (400 without) | +| `GET /api/machines/:id/opencode-models?cwd=`, `/grok-models?cwd=`, `/copilot-models?cwd=`, `/kimi-models?cwd=` | `cwd` query required (400 without) | ### Machines & spawning diff --git a/hub/src/sync/rpcGateway.ts b/hub/src/sync/rpcGateway.ts index fc4112ba..f8e74e13 100644 --- a/hub/src/sync/rpcGateway.ts +++ b/hub/src/sync/rpcGateway.ts @@ -23,6 +23,7 @@ import type { ImplementCodexPlanResult, CopilotModelsResponse, GrokModelsResponse, + KimiModelsResponse, GrokReasoningEffortResponse, ListDirectoryResponse, ListCodexSessionsRpcResponse, @@ -113,6 +114,7 @@ export type RpcListOpencodeModelsResponse = OpencodeModelsResponse export type RpcListOpencodeModelVariantsResponse = OpencodeModelVariantsResponse export type RpcListGrokModelsResponse = GrokModelsResponse export type RpcListCopilotModelsResponse = CopilotModelsResponse +export type RpcListKimiModelsResponse = KimiModelsResponse export type RpcListGrokReasoningEffortOptionsResponse = GrokReasoningEffortResponse export type RpcListOpencodeReasoningEffortOptionsResponse = OpencodeReasoningEffortResponse export type RpcListAgyModelsResponse = AgyModelsResponse @@ -484,6 +486,28 @@ export class RpcGateway { ) as RpcListCopilotModelsResponse } + async listKimiModelsForCwd(machineId: string, cwd: string): Promise { + return await this.machineRpc( + machineId, + RPC_METHODS.ListKimiModelsForCwd, + { cwd }, + MODEL_LIST_RPC_TIMEOUT_MS + ) as RpcListKimiModelsResponse + } + + /** + * Active-session Kimi discovery. The probe runs in the CLI that owns the + * session, so it works without a background runner on the machine. + */ + async listKimiModelsForSession(sessionId: string): Promise { + return await this.sessionRpc( + sessionId, + RPC_METHODS.ListKimiModels, + {}, + MODEL_LIST_RPC_TIMEOUT_MS + ) as RpcListKimiModelsResponse + } + /** Generic Pi RPC call — routes all Pi-specific session RPCs through * a single entry point instead of per-method wrappers. */ async callPiRpc(sessionId: string, method: string, params?: Record, timeoutMs?: number): Promise { diff --git a/hub/src/sync/syncEngine.ts b/hub/src/sync/syncEngine.ts index 607c26e6..56552ed8 100644 --- a/hub/src/sync/syncEngine.ts +++ b/hub/src/sync/syncEngine.ts @@ -52,6 +52,7 @@ import { type RpcListOpencodeModelVariantsResponse, type RpcListGrokModelsResponse, type RpcListCopilotModelsResponse, + type RpcListKimiModelsResponse, type RpcListGrokReasoningEffortOptionsResponse, type RpcListOpencodeReasoningEffortOptionsResponse, type RpcCursorModel, @@ -86,6 +87,7 @@ export type { RpcListOpencodeModelVariantsResponse, RpcListGrokModelsResponse, RpcListCopilotModelsResponse, + RpcListKimiModelsResponse, RpcListGrokReasoningEffortOptionsResponse, RpcListOpencodeReasoningEffortOptionsResponse, RpcCursorModel, @@ -4067,6 +4069,14 @@ export class SyncEngine { return await this.rpcGateway.listCopilotModelsForSession(sessionId) } + async listKimiModelsForCwd(machineId: string, cwd: string): Promise { + return await this.rpcGateway.listKimiModelsForCwd(machineId, cwd) + } + + async listKimiModelsForSession(sessionId: string): Promise { + return await this.rpcGateway.listKimiModelsForSession(sessionId) + } + /** Generic Pi RPC — delegates to rpcGateway.callPiRpc. */ async callPiRpc(sessionId: string, method: string, params?: Record, timeoutMs?: number): Promise { return await this.rpcGateway.callPiRpc(sessionId, method, params, timeoutMs) diff --git a/hub/src/web/routes/machines.ts b/hub/src/web/routes/machines.ts index 5a98356a..b300f0a4 100644 --- a/hub/src/web/routes/machines.ts +++ b/hub/src/web/routes/machines.ts @@ -366,6 +366,31 @@ export function createMachinesRoutes(getSyncEngine: () => SyncEngine | null): Ho } }) + app.get('/machines/:id/kimi-models', async (c) => { + const engine = getSyncEngine() + if (!engine) { + return c.json({ success: false, error: 'Not connected' }, 503) + } + + const machineId = c.req.param('id') + const machine = requireMachine(c, engine, machineId) + if (machine instanceof Response) return machine + + const cwd = (c.req.query('cwd') ?? '').trim() + if (!cwd) { + return c.json({ success: false, error: 'cwd query parameter is required' }, 400) + } + + try { + return c.json(await engine.listKimiModelsForCwd(machineId, cwd)) + } catch (error) { + return c.json({ + success: false, + error: error instanceof Error ? error.message : 'Failed to list Kimi models' + }, 500) + } + }) + app.get('/machines/:id/copilot-models', async (c) => { const engine = getSyncEngine() if (!engine) { diff --git a/hub/src/web/routes/sessions.test.ts b/hub/src/web/routes/sessions.test.ts index 8e6afbf7..f82520f7 100644 --- a/hub/src/web/routes/sessions.test.ts +++ b/hub/src/web/routes/sessions.test.ts @@ -118,6 +118,17 @@ function createApp(session: Session, opts?: { options: [{ value: 'low', name: 'Low' }], currentValue: 'low' }) + const listKimiModelsForSession = async () => ({ + success: true, + availableModels: [ + { + modelId: 'GLM-5.3-flash', + name: 'thehive / GLM-5.3-flash', + provider: 'thehive' + } + ], + currentModelId: 'GLM-5.3-flash' + }) const resumeSession = opts?.resumeSession ?? (async (sessionId: string) => ({ type: 'success', sessionId })) const reopenSession = opts?.reopenSession ?? (async (sessionId: string) => ({ type: 'success' as const, @@ -140,6 +151,7 @@ function createApp(session: Session, opts?: { listOpencodeReasoningEffortOptionsForSession, listGrokModelsForSession, listGrokReasoningEffortOptionsForSession, + listKimiModelsForSession, resumeSession, reopenSession, getCursorChatStoreStatus: opts?.getCursorChatStoreStatus ?? (async () => ({ @@ -999,6 +1011,40 @@ describe('sessions routes', () => { }) }) + it('returns the Kimi catalog for an active Kimi session over its own connection', async () => { + const session = createSession({ + metadata: { path: '/tmp/project', host: 'localhost', flavor: 'kimi' } + }) + const { app } = createApp(session) + + const response = await app.request('/api/sessions/session-1/kimi-models') + + expect(response.status).toBe(200) + expect(await response.json()).toEqual({ + success: true, + availableModels: [ + { + modelId: 'GLM-5.3-flash', + name: 'thehive / GLM-5.3-flash', + provider: 'thehive' + } + ], + currentModelId: 'GLM-5.3-flash' + }) + }) + + it('rejects kimi-models for non-Kimi sessions', async () => { + const { app } = createApp(createSession()) + + const response = await app.request('/api/sessions/session-1/kimi-models') + + expect(response.status).toBe(400) + expect(await response.json()).toEqual({ + success: false, + error: 'Kimi models are only available for Kimi sessions' + }) + }) + it('rejects opencode-reasoning-effort-options for non-OpenCode sessions', async () => { const { app } = createApp(createSession()) diff --git a/hub/src/web/routes/sessions.ts b/hub/src/web/routes/sessions.ts index dfb21d44..4fc91066 100644 --- a/hub/src/web/routes/sessions.ts +++ b/hub/src/web/routes/sessions.ts @@ -1510,6 +1510,24 @@ export function createSessionsRoutes(getSyncEngine: () => SyncEngine | null): Ho } }) + app.get('/sessions/:id/kimi-models', async (c) => { + const engine = requireSyncEngine(c, getSyncEngine) + if (engine instanceof Response) return engine + const sessionResult = requireSessionFromParam(c, engine, { requireActive: true }) + if (sessionResult instanceof Response) return sessionResult + if (sessionResult.session.metadata?.flavor !== 'kimi') { + return c.json({ success: false, error: 'Kimi models are only available for Kimi sessions' }, 400) + } + try { + return c.json(await engine.listKimiModelsForSession(sessionResult.sessionId)) + } catch (error) { + return c.json({ + success: false, + error: error instanceof Error ? error.message : 'Failed to list Kimi models' + }, 500) + } + }) + app.get('/sessions/:id/cursor-models', async (c) => { const engine = requireSyncEngine(c, getSyncEngine) if (engine instanceof Response) { diff --git a/shared/src/agentConfig.ts b/shared/src/agentConfig.ts index a5d2ce83..4db886a8 100644 --- a/shared/src/agentConfig.ts +++ b/shared/src/agentConfig.ts @@ -75,7 +75,7 @@ const BUILTIN_DESCRIPTORS: Record = { { id: 'effort', section: 'effort', kind: 'select', optionSource: 'model', availability: 'both' }, PERMISSION ), - kimi: fields(MODEL, PERMISSION), + kimi: fields({ ...MODEL, optionSource: 'directory' }, PERMISSION), opencode: fields( { ...MODEL, optionSource: 'directory' }, { id: 'effort', section: 'effort', kind: 'select', optionSource: 'model', availability: 'both' }, diff --git a/shared/src/apiTypes.ts b/shared/src/apiTypes.ts index d45fd7e4..50a707db 100644 --- a/shared/src/apiTypes.ts +++ b/shared/src/apiTypes.ts @@ -838,6 +838,22 @@ export type CopilotModelsResponse = { export type ListCopilotModelsResponse = CopilotModelsResponse +export type KimiModelSummary = { + /** Kimi model alias as used by `--model` / `session/set_model`. */ + modelId: string + name?: string + provider?: string +} + +export type KimiModelsResponse = { + success: boolean + availableModels?: KimiModelSummary[] + currentModelId?: string | null + error?: string +} + +export type ListKimiModelsResponse = KimiModelsResponse + export type GrokReasoningEffortResponse = { success: boolean options?: GrokReasoningEffortOption[] diff --git a/shared/src/rpcMethods.ts b/shared/src/rpcMethods.ts index 1ad52370..9bdb63bd 100644 --- a/shared/src/rpcMethods.ts +++ b/shared/src/rpcMethods.ts @@ -43,6 +43,8 @@ export const RPC_METHODS = { ListGrokReasoningEffortOptions: 'listGrokReasoningEffortOptions', ListCopilotModelsForCwd: 'listCopilotModelsForCwd', ListCopilotModels: 'listCopilotModels', + ListKimiModelsForCwd: 'listKimiModelsForCwd', + ListKimiModels: 'listKimiModels', ListOpencodeReasoningEffortOptions: 'listOpencodeReasoningEffortOptions', ListAgyModels: 'listAgyModels', /** Deliver one queued message into the active Pi turn (native steer). */ diff --git a/web/src/api/client.test.ts b/web/src/api/client.test.ts index 22802f26..b84d17df 100644 --- a/web/src/api/client.test.ts +++ b/web/src/api/client.test.ts @@ -329,3 +329,33 @@ describe('ApiClient error mapping', () => { expect(init?.body).toBe(JSON.stringify({ openai: 'sk-test' })) }) }) + +describe('ApiClient Kimi session model discovery', () => { + let originalFetch: typeof globalThis.fetch + let fetchMock: ReturnType + + beforeEach(() => { + originalFetch = globalThis.fetch + fetchMock = vi.fn() + globalThis.fetch = fetchMock as unknown as typeof globalThis.fetch + }) + + afterEach(() => { + globalThis.fetch = originalFetch + }) + + it('requests the running session instead of the machine kimi-models endpoint', async () => { + const catalog = { + success: true, + availableModels: [ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' } + ], + currentModelId: 'GLM-5.3-flash' + } + fetchMock.mockResolvedValueOnce(new Response(JSON.stringify(catalog), { status: 200 })) + + const api = new ApiClient('test-token') + await expect(api.getSessionKimiModels('session/1')).resolves.toEqual(catalog) + expect(fetchMock.mock.calls[0]?.[0]).toBe('/api/sessions/session%2F1/kimi-models') + }) +}) diff --git a/web/src/api/client.ts b/web/src/api/client.ts index 625aec75..5010d101 100644 --- a/web/src/api/client.ts +++ b/web/src/api/client.ts @@ -42,6 +42,7 @@ import type { FileReadResponse, GitCommandResponse, GrokModelsResponse, + KimiModelsResponse, CopilotModelsResponse, GrokReasoningEffortResponse, ListDirectoryResponse, @@ -953,6 +954,18 @@ export class ApiClient { ) } + async getMachineKimiModelsForCwd(machineId: string, cwd: string): Promise { + return await this.request( + `/api/machines/${encodeURIComponent(machineId)}/kimi-models?cwd=${encodeURIComponent(cwd)}` + ) + } + + async getSessionKimiModels(sessionId: string): Promise { + return await this.request( + `/api/sessions/${encodeURIComponent(sessionId)}/kimi-models` + ) + } + async getSessionGrokModels(sessionId: string): Promise { return await this.request( `/api/sessions/${encodeURIComponent(sessionId)}/grok-models` diff --git a/web/src/components/AssistantChat/modelOptions.test.ts b/web/src/components/AssistantChat/modelOptions.test.ts index e4cb4410..1360f04a 100644 --- a/web/src/components/AssistantChat/modelOptions.test.ts +++ b/web/src/components/AssistantChat/modelOptions.test.ts @@ -353,6 +353,24 @@ describe('getNextModelForFlavor', () => { expect(getNextModelForFlavor('kimi', null)).toBeNull() }) + it('serves dynamic Kimi options to a running session with Default and aliases', () => { + const options = getModelOptionsForFlavor('kimi', 'GLM-5.3-flash', [ + { value: null, label: 'Default' }, + { value: 'GLM-5.3-flash', label: 'thehive — thehive / GLM-5.3-flash' }, + { value: 'deepseek-v4.1-flash', label: 'thehive — thehive / hive-deepseek' } + ]) + + expect(options[0]).toEqual({ value: null, label: 'Default' }) + expect(options.map((option) => option.value)).toEqual([null, 'GLM-5.3-flash', 'deepseek-v4.1-flash']) + + // Cycling with a dynamic catalog moves through the discovered aliases. + expect(getNextModelForFlavor('kimi', 'GLM-5.3-flash', [ + { value: null, label: 'Default' }, + { value: 'GLM-5.3-flash', label: 'thehive — GLM-5.3-flash' }, + { value: 'deepseek-v4.1-flash', label: 'thehive — deepseek-v4.1-flash' } + ])).toBe('deepseek-v4.1-flash') + }) + it('keeps a cursor current model on cycle (no Claude fallback)', () => { expect(getNextModelForFlavor('cursor', 'composer-2.5')).toBe('composer-2.5') expect(getNextModelForFlavor('cursor', null)).toBeNull() diff --git a/web/src/components/NewSession/grokModels.test.ts b/web/src/components/NewSession/grokModels.test.ts index 175f1837..ae3a2037 100644 --- a/web/src/components/NewSession/grokModels.test.ts +++ b/web/src/components/NewSession/grokModels.test.ts @@ -1,5 +1,12 @@ import { describe, expect, it } from 'vitest' -import { buildGrokEffortOptions, buildGrokModelOptions, shouldEnableGrokModelDiscovery } from './grokModels' +import { + buildGrokEffortOptions, + buildGrokModelOptions, + shouldEnableGrokModelDiscovery, + buildKimiModelOptions, + buildKimiSessionModelOptions, + shouldEnableKimiModelDiscovery +} from './grokModels' describe('Grok Create-session options', () => { it('enables model discovery only for an existing cwd on the target machine', () => { @@ -40,3 +47,63 @@ describe('Grok Create-session options', () => { ]) }) }) + +describe('Kimi Create-session options', () => { + it('enables model discovery only for an existing cwd on the target machine', () => { + const args = { + agent: 'kimi' as const, + machineId: 'machine-1', + cwd: '/home/user/project', + cwdExists: true, + } + + expect(shouldEnableKimiModelDiscovery(args)).toBe(true) + expect(shouldEnableKimiModelDiscovery({ ...args, cwdExists: undefined })).toBe(false) + expect(shouldEnableKimiModelDiscovery({ ...args, agent: 'claude' })).toBe(false) + }) + + it('keeps Default and appends every discovered Kimi model with the real alias as value', () => { + const options = buildKimiModelOptions([ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' }, + { modelId: 'deepseek-v4.1-flash', name: 'thehive / hive-deepseek', provider: 'thehive' }, + { modelId: 'hyper-glm-5.3-flash', name: 'charm-hyper / Hyper · GLM-5.3-Flash', provider: 'charm-hyper' }, + { modelId: 'openrouter-union-alpha', provider: 'openrouter' } + ]) + + expect(options[0]).toEqual({ value: 'auto', label: 'Default' }) + expect(options.map((option) => option.value)).toEqual([ + 'auto', + 'GLM-5.3-flash', + 'deepseek-v4.1-flash', + 'hyper-glm-5.3-flash', + 'openrouter-union-alpha' + ]) + }) + + it('makes providers recognizable in labels', () => { + const options = buildKimiModelOptions([ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' }, + { modelId: 'openrouter-union-alpha', provider: 'openrouter' } + ]) + + expect(options[1]).toEqual({ value: 'GLM-5.3-flash', label: 'thehive — thehive / GLM-5.3-flash' }) + expect(options[2]).toEqual({ value: 'openrouter-union-alpha', label: 'openrouter — openrouter-union-alpha' }) + }) + + it('falls back to the alias when a model has no display name or provider', () => { + expect(buildKimiModelOptions([{ modelId: 'alias-only' }])).toEqual([ + { value: 'auto', label: 'Default' }, + { value: 'alias-only', label: 'alias-only' } + ]) + }) + + it('running-session options keep Default as null and aliases as values', () => { + const options = buildKimiSessionModelOptions([ + { modelId: 'GLM-5.3-flash', provider: 'thehive' }, + { modelId: 'deepseek-v4.1-flash', provider: 'thehive' } + ]) + + expect(options[0]).toEqual({ value: null, label: 'Default' }) + expect(options.map((option) => option.value)).toEqual([null, 'GLM-5.3-flash', 'deepseek-v4.1-flash']) + }) +}) diff --git a/web/src/components/NewSession/grokModels.ts b/web/src/components/NewSession/grokModels.ts index 5b800a9c..67806201 100644 --- a/web/src/components/NewSession/grokModels.ts +++ b/web/src/components/NewSession/grokModels.ts @@ -1,4 +1,4 @@ -import type { GrokModelSummary } from '@/types/api' +import type { GrokModelSummary, KimiModelSummary } from '@/types/api' import type { AgentType } from './types' export function shouldEnableGrokModelDiscovery(args: { @@ -48,3 +48,49 @@ export function buildGrokEffortOptions( })) ] } + +export function shouldEnableKimiModelDiscovery(args: { + agent: AgentType + machineId: string | null + cwd: string + cwdExists: boolean | undefined +}): boolean { + return args.agent === 'kimi' + && Boolean(args.machineId) + && args.cwd.length > 0 + && args.cwdExists === true +} + +/** + * Kimi options for the create-session selector: Default plus one entry per + * discovered provider model. `value` is always the real Kimi alias; the label + * makes the provider recognizable ("TheHive — GLM-5.3-flash"). + */ +export function buildKimiModelOptions( + availableModels: KimiModelSummary[] +): Array<{ value: string; label: string }> { + return [ + { value: 'auto', label: 'Default' }, + ...availableModels.map((model) => ({ + value: model.modelId, + label: model.provider ? `${model.provider} — ${model.name ?? model.modelId}` : (model.name ?? model.modelId) + })) + ] +} + +/** + * Options for a running Kimi session's model picker: Default (null value, + * cleared via session/set_model) plus the dynamically discovered models. + * Labels match buildKimiModelOptions so both pickers read the same. + */ +export function buildKimiSessionModelOptions( + availableModels: KimiModelSummary[] +): Array<{ value: string | null; label: string }> { + return [ + { value: null, label: 'Default' }, + ...availableModels.map((model) => ({ + value: model.modelId, + label: model.provider ? `${model.provider} — ${model.name ?? model.modelId}` : (model.name ?? model.modelId) + })) + ] +} diff --git a/web/src/components/NewSession/index.test.tsx b/web/src/components/NewSession/index.test.tsx index b5cce30e..e6d0c2ed 100644 --- a/web/src/components/NewSession/index.test.tsx +++ b/web/src/components/NewSession/index.test.tsx @@ -24,6 +24,9 @@ const mocks = vi.hoisted(() => ({ directoryExists: undefined as boolean | undefined, copilotModels: [] as Array<{ modelId: string; name?: string }>, copilotModelsLoading: false, + kimiModels: [] as Array<{ modelId: string; name?: string; provider?: string }>, + kimiModelsLoading: false, + kimiModelsError: null as string | null, opencodeModels: [] as Array<{ modelId: string; name?: string }>, opencodeCurrentModelId: null as string | null, opencodeModelsLoading: false, @@ -163,6 +166,14 @@ vi.mock('@/hooks/queries/useCopilotModelsForCwd', () => ({ error: null }) })) +vi.mock('@/hooks/queries/useKimiModelsForCwd', () => ({ + useKimiModelsForCwd: () => ({ + availableModels: mocks.kimiModels, + currentModelId: null, + isLoading: mocks.kimiModelsLoading, + error: mocks.kimiModelsError + }) +})) vi.mock('@/hooks/queries/usePiModelsForMachine', () => ({ usePiModelsForMachine: () => ({ availableModels: mocks.piModels, @@ -300,6 +311,9 @@ describe('NewSession launch preferences', () => { mocks.directoryExists = true mocks.copilotModels = [] mocks.copilotModelsLoading = false + mocks.kimiModels = [] + mocks.kimiModelsLoading = false + mocks.kimiModelsError = null mocks.opencodeModels = [{ modelId: 'provider/current', name: 'Current' }] mocks.opencodeCurrentModelId = 'provider/current' mocks.opencodeModelsLoading = false @@ -482,6 +496,92 @@ describe('NewSession launch preferences', () => { await waitFor(() => expect(screen.getByTestId('create')).toBeDisabled()) }) + it('shows dynamic Kimi models with Default for the selected directory', async () => { + mocks.kimiModels = [ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' }, + { modelId: 'deepseek-v4.1-flash', name: 'thehive / hive-deepseek', provider: 'thehive' }, + { modelId: 'hyper-glm-5.3-flash', name: 'charm-hyper / Hyper · GLM-5.3-Flash', provider: 'charm-hyper' }, + { modelId: 'openrouter-union-alpha', provider: 'openrouter' } + ] + + render( + {}} + /> + ) + + fireEvent.click(screen.getByDisplayValue('kimi')) + + await waitFor(() => { + expect(screen.getByTestId('model-options')).toHaveTextContent( + 'Default,thehive — thehive / GLM-5.3-flash,thehive — thehive / hive-deepseek,charm-hyper — charm-hyper / Hyper · GLM-5.3-Flash,openrouter — openrouter-union-alpha' + ) + }) + }) + + it('restores a remembered Kimi alias instead of resetting it to Default', async () => { + mocks.kimiModels = [ + { modelId: 'GLM-5.3-flash', provider: 'thehive' } + ] + savePreferredAgent('kimi') + savePreferredLaunchSettings('machine-1', 'kimi', { + model: 'GLM-5.3-flash', + cursorSelectedBase: 'auto', + effort: 'auto', + modelReasoningEffort: 'default' + }) + + render( + {}} + /> + ) + + await waitFor(() => { + expect(screen.getByTestId('model')).toHaveTextContent('GLM-5.3-flash') + expect(screen.getByTestId('create')).toBeEnabled() + }) + }) + + it('resets a remembered Kimi alias that the dynamic catalog no longer lists', async () => { + mocks.kimiModels = [ + { modelId: 'GLM-5.3-flash', provider: 'thehive' } + ] + savePreferredAgent('kimi') + savePreferredLaunchSettings('machine-1', 'kimi', { + model: 'retired-alias', + cursorSelectedBase: 'auto', + effort: 'auto', + modelReasoningEffort: 'default' + }) + + render( + {}} + /> + ) + + await waitFor(() => { + expect(screen.getByTestId('model')).toHaveTextContent('auto') + }) + expect(screen.getByTestId('create')).toBeEnabled() + }) + it.each([ ['model', 'gpt-5.6-sol', 'default'], ['reasoning effort', 'auto', 'xhigh'] diff --git a/web/src/components/NewSession/index.tsx b/web/src/components/NewSession/index.tsx index 0a9dbeec..4b80f7c5 100644 --- a/web/src/components/NewSession/index.tsx +++ b/web/src/components/NewSession/index.tsx @@ -13,6 +13,7 @@ import { useOpencodeModelsForCwd } from '@/hooks/queries/useOpencodeModelsForCwd import { useOpencodeModelVariants } from '@/hooks/queries/useOpencodeModelVariants' import { useGrokModelsForCwd } from '@/hooks/queries/useGrokModelsForCwd' import { useCopilotModelsForCwd } from '@/hooks/queries/useCopilotModelsForCwd' +import { useKimiModelsForCwd } from '@/hooks/queries/useKimiModelsForCwd' import { usePiModelsForMachine } from '@/hooks/queries/usePiModelsForMachine' import { useAgentAvailability } from '@/hooks/queries/useAgentAvailability' import { useSessions } from '@/hooks/queries/useSessions' @@ -57,6 +58,7 @@ import { OpencodeModelSelector } from './OpencodeModelSelector' import { EffortField } from './EffortField' import { shouldEnableOpencodeModelDiscovery } from './opencodeModelsGate' import { buildGrokEffortOptions, buildGrokModelOptions, shouldEnableGrokModelDiscovery } from './grokModels' +import { buildKimiModelOptions, shouldEnableKimiModelDiscovery } from './grokModels' import { groupModelsByProvider } from '@/components/AssistantChat/piModelGroups' import { isThinkingLevelSupported } from '@/components/AssistantChat/piThinkingLevelOptions' import { @@ -639,6 +641,21 @@ export function NewSession(props: { cwd: deferredDirectory, enabled: agent === 'copilot' && deferredDirectoryExists === true }) + const kimiModelsState = useKimiModelsForCwd({ + api: props.api, + machineId, + cwd: deferredDirectory, + enabled: shouldEnableKimiModelDiscovery({ + agent, + machineId, + cwd: deferredDirectory, + cwdExists: deferredDirectoryExists, + }) + }) + const kimiModelOptions = useMemo( + () => buildKimiModelOptions(kimiModelsState.availableModels), + [kimiModelsState.availableModels] + ) const copilotModelOptions = useMemo( () => [ { value: 'auto', label: 'Auto' }, @@ -929,6 +946,25 @@ export function NewSession(props: { deferredDirectoryExists, model ]) + useEffect(() => { + if ( + agent === 'kimi' + && deferredDirectoryExists === true + && !kimiModelsState.isLoading + && !kimiModelsState.error + && model !== 'auto' + && !kimiModelsState.availableModels.some((candidate) => candidate.modelId === model) + ) { + setModel('auto') + } + }, [ + agent, + kimiModelsState.availableModels, + kimiModelsState.error, + kimiModelsState.isLoading, + deferredDirectoryExists, + model + ]) const currentDirectoryExists = trimmedDirectory ? pathExistence[trimmedDirectory] : undefined const directoryOutsideWorkspaceRoots = trimmedDirectory @@ -1701,6 +1737,13 @@ export function NewSession(props: { deferredDirectoryExists === undefined || (deferredDirectoryExists === true && copilotModelsState.isLoading) )) + || (agent === 'kimi' + && deferredDirectory !== '' + && model !== 'auto' + && ( + deferredDirectoryExists === undefined + || (deferredDirectoryExists === true && kimiModelsState.isLoading) + )) || (agent === 'pi' && model !== 'auto' && piModelsState.isLoading) @@ -1888,20 +1931,24 @@ export function NewSession(props: { ? grokModelOptions : agent === 'copilot' ? copilotModelOptions - : agent === 'pi' - ? (showPiLaunchConfig ? piModelOptions : undefined) - : undefined + : agent === 'kimi' + ? kimiModelOptions + : agent === 'pi' + ? (showPiLaunchConfig ? piModelOptions : undefined) + : undefined } isDisabled={ isFormDisabled || (agent === 'codex' && Boolean(codexModelsState.error)) || (agent === 'grok' && Boolean(grokModelsState.error)) || (agent === 'copilot' && Boolean(copilotModelsState.error)) + || (agent === 'kimi' && Boolean(kimiModelsState.error)) || (agent === 'pi' && Boolean(piModelsState.error)) } isLoading={(agent === 'codex' && codexModelsState.isLoading) || (agent === 'grok' && grokModelsState.isLoading) || (agent === 'copilot' && copilotModelsState.isLoading) + || (agent === 'kimi' && kimiModelsState.isLoading) || (agent === 'pi' && piModelsState.isLoading)} error={agent === 'codex' && codexModelsState.error ? `${t('newSession.model.loadFailed')}: ${codexModelsState.error}` @@ -1909,8 +1956,10 @@ export function NewSession(props: { ? `${t('newSession.model.loadFailed')}: ${grokModelsState.error}` : agent === 'copilot' && copilotModelsState.error ? `${t('newSession.model.loadFailed')}: ${copilotModelsState.error}` - : agent === 'pi' && piModelsState.error - ? `${t('newSession.model.loadFailed')}: ${piModelsState.error}` + : agent === 'kimi' && kimiModelsState.error + ? `${t('newSession.model.loadFailed')}: ${kimiModelsState.error}` + : agent === 'pi' && piModelsState.error + ? `${t('newSession.model.loadFailed')}: ${piModelsState.error}` : null} onModelChange={setModel} /> diff --git a/web/src/components/NewSession/preferences.test.ts b/web/src/components/NewSession/preferences.test.ts index bf592a0f..147517f4 100644 --- a/web/src/components/NewSession/preferences.test.ts +++ b/web/src/components/NewSession/preferences.test.ts @@ -164,6 +164,24 @@ describe('NewSession preferences', () => { }) }) + it('does not reset a remembered Kimi alias against the static Default-only list', () => { + // Kimi's catalog is dynamic; validating against MODEL_OPTIONS.kimi + // (only 'auto') must not turn a saved alias back into Default before + // the real catalog arrives. + expect(resolvePreferredLaunchSettings('kimi', { + model: 'GLM-5.3-flash', + cursorSelectedBase: 'auto', + effort: 'auto', + modelReasoningEffort: 'default' + })).toEqual({ + model: 'GLM-5.3-flash', + cursorSelectedBase: 'auto', + effort: 'auto', + modelReasoningEffort: 'default', + permissionMode: 'default' + }) + }) + it('falls back when a remembered permission mode is invalid for the agent', () => { expect(resolvePreferredLaunchSettings('codex', { model: 'auto', diff --git a/web/src/components/NewSession/preferences.ts b/web/src/components/NewSession/preferences.ts index 1d308ff0..05a770a1 100644 --- a/web/src/components/NewSession/preferences.ts +++ b/web/src/components/NewSession/preferences.ts @@ -134,7 +134,10 @@ export function resolvePreferredLaunchSettings( ): PreferredLaunchSettings { const preferredModel = preferred?.model ?? 'auto' const staticModelValues = MODEL_OPTIONS[agent].map((option) => option.value) - const model = staticModelValues.length > 0 && agent !== 'codex' && agent !== 'copilot' + // Kimi's catalog is dynamic (machine discovery); validating a saved alias + // against the static list would reset it to 'auto'. The settled-catalog + // effect in NewSession validates it once the real catalog has arrived. + const model = staticModelValues.length > 0 && agent !== 'codex' && agent !== 'copilot' && agent !== 'kimi' ? resolvePreferredOptionValue(preferredModel, staticModelValues, 'auto') : preferredModel const effort = agent === 'claude' diff --git a/web/src/components/SessionChat.tsx b/web/src/components/SessionChat.tsx index 14f9ffae..e8dd5e77 100644 --- a/web/src/components/SessionChat.tsx +++ b/web/src/components/SessionChat.tsx @@ -109,6 +109,8 @@ import { buildCursorEffortPickerOptionsWithDefaultFirst } from '@/lib/cursorMode import { useOpencodeModels } from '@/hooks/queries/useOpencodeModels' import { useGrokModels } from '@/hooks/queries/useGrokModels' import { useCopilotModels } from '@/hooks/queries/useCopilotModels' +import { useKimiModelsForSession } from '@/hooks/queries/useKimiModelsForSession' +import { buildKimiSessionModelOptions } from '@/components/NewSession/grokModels' import { useGrokReasoningEffortOptions } from '@/hooks/queries/useGrokReasoningEffortOptions' import { usePiModels } from '@/hooks/queries/usePiModels' import { useOpencodeReasoningEffortOptions } from '@/hooks/queries/useOpencodeReasoningEffortOptions' @@ -1071,6 +1073,19 @@ function SessionChatInner(props: SessionChatProps) { enabled: agentFlavor === 'cursor' && props.session.active }) const sessionMachineId = props.session.metadata?.machineId ?? null + // A running session discovers its models over its own connection (kimi + // provider list --json), so this works without a background runner; + // switching itself still goes through the existing ACP setModel path. + const kimiModelsState = useKimiModelsForSession({ + api: props.api, + sessionId: props.session.id, + enabled: agentFlavor === 'kimi' && props.session.active + }) + const kimiModelOptions = useMemo(() => ( + agentFlavor === 'kimi' && kimiModelsState.availableModels.length > 0 + ? buildKimiSessionModelOptions(kimiModelsState.availableModels) + : undefined + ), [agentFlavor, kimiModelsState.availableModels]) const machineCursorModelsState = useCursorModelsForMachine({ api: props.api, machineId: sessionMachineId, @@ -2047,8 +2062,10 @@ function SessionChatInner(props: SessionChatProps) { ? grokModelOptions : agentFlavor === 'copilot' ? copilotModelOptions - : agentFlavor === 'agy' - ? agyModelOptions + : agentFlavor === 'kimi' + ? kimiModelOptions + : agentFlavor === 'agy' + ? agyModelOptions // Pi gets its provider-qualified model list from the piModels prop; // feeding piModelOptions here would make the generic Ctrl/Cmd+M // cycler (getNextModelForFlavor) post a bare modelId string, diff --git a/web/src/hooks/queries/useKimiModelsForCwd.ts b/web/src/hooks/queries/useKimiModelsForCwd.ts new file mode 100644 index 00000000..97e7ef01 --- /dev/null +++ b/web/src/hooks/queries/useKimiModelsForCwd.ts @@ -0,0 +1,48 @@ +import { useQuery } from '@tanstack/react-query' +import type { ApiClient } from '@/api/client' +import type { KimiModelSummary } from '@/types/api' +import { queryKeys } from '@/lib/query-keys' + +export function useKimiModelsForCwd(args: { + api: ApiClient | null + machineId?: string | null + cwd?: string | null + enabled?: boolean +}): { + availableModels: KimiModelSummary[] + currentModelId: string | null + isLoading: boolean + error: string | null +} { + const { api, machineId, cwd } = args + const trimmedCwd = typeof cwd === 'string' ? cwd.trim() : '' + const enabled = Boolean(args.enabled && api && machineId && trimmedCwd) + + const query = useQuery({ + queryKey: machineId && trimmedCwd + ? queryKeys.machineKimiModelsForCwd(machineId, trimmedCwd) + : ['machine-kimi-models', 'unknown', 'unknown'] as const, + queryFn: async () => { + if (!api || !machineId || !trimmedCwd) { + throw new Error('Kimi models target unavailable') + } + return await api.getMachineKimiModelsForCwd(machineId, trimmedCwd) + }, + enabled, + staleTime: 60_000, + retry: false, + }) + + return { + availableModels: query.data?.availableModels ?? [], + currentModelId: query.data?.currentModelId ?? null, + isLoading: query.isLoading, + error: query.data?.success === false + ? (query.data.error ?? 'Failed to load Kimi models') + : query.error instanceof Error + ? query.error.message + : query.error + ? 'Failed to load Kimi models' + : null, + } +} diff --git a/web/src/hooks/queries/useKimiModelsForSession.test.tsx b/web/src/hooks/queries/useKimiModelsForSession.test.tsx new file mode 100644 index 00000000..d60afa22 --- /dev/null +++ b/web/src/hooks/queries/useKimiModelsForSession.test.tsx @@ -0,0 +1,108 @@ +import { QueryClient, QueryClientProvider } from '@tanstack/react-query' +import { renderHook, waitFor } from '@testing-library/react' +import type { PropsWithChildren } from 'react' +import { describe, expect, it, vi } from 'vitest' +import type { ApiClient } from '@/api/client' +import { useKimiModelsForSession } from './useKimiModelsForSession' + +function wrapper(queryClient: QueryClient) { + return ({ children }: PropsWithChildren) => ( + {children} + ) +} + +function createQueryClient() { + return new QueryClient({ defaultOptions: { queries: { retry: false } } }) +} + +describe('useKimiModelsForSession', () => { + it('reads the catalog over the active session connection', async () => { + const getSessionKimiModels = vi.fn(async () => ({ + success: true, + availableModels: [ + { modelId: 'GLM-5.3-flash', name: 'thehive / GLM-5.3-flash', provider: 'thehive' } + ], + currentModelId: 'GLM-5.3-flash' + })) + const api = { getSessionKimiModels } as unknown as ApiClient + const queryClient = createQueryClient() + + const { result } = renderHook(() => useKimiModelsForSession({ + api, + sessionId: 'session-1', + enabled: true + }), { wrapper: wrapper(queryClient) }) + + await waitFor(() => expect(result.current.availableModels).toHaveLength(1)) + expect(getSessionKimiModels).toHaveBeenCalledWith('session-1') + expect(result.current.availableModels[0]).toEqual({ + modelId: 'GLM-5.3-flash', + name: 'thehive / GLM-5.3-flash', + provider: 'thehive' + }) + expect(result.current.currentModelId).toBe('GLM-5.3-flash') + expect(result.current.error).toBeNull() + }) + + it('surfaces a failed session probe as an error with no catalog', async () => { + const getSessionKimiModels = vi.fn(async () => ({ + success: false, + error: 'Kimi model discovery timed out' + })) + const api = { getSessionKimiModels } as unknown as ApiClient + const queryClient = createQueryClient() + + const { result } = renderHook(() => useKimiModelsForSession({ + api, + sessionId: 'session-1', + enabled: true + }), { wrapper: wrapper(queryClient) }) + + await waitFor(() => expect(result.current.error).toBe('Kimi model discovery timed out')) + expect(result.current.availableModels).toEqual([]) + expect(result.current.currentModelId).toBeNull() + }) + + it('does not probe without an active session', () => { + const getSessionKimiModels = vi.fn() + const api = { getSessionKimiModels } as unknown as ApiClient + const queryClient = createQueryClient() + + const disabled = renderHook(() => useKimiModelsForSession({ + api, + sessionId: 'session-1', + enabled: false + }), { wrapper: wrapper(queryClient) }) + const withoutSession = renderHook(() => useKimiModelsForSession({ + api, + sessionId: null, + enabled: true + }), { wrapper: wrapper(queryClient) }) + + expect(getSessionKimiModels).not.toHaveBeenCalled() + expect(disabled.result.current.availableModels).toEqual([]) + expect(withoutSession.result.current.availableModels).toEqual([]) + }) + + it('keys the cache per session', async () => { + const getSessionKimiModels = vi.fn(async (sessionId: string) => ({ + success: true, + availableModels: [{ modelId: `${sessionId}-alias` }], + currentModelId: null + })) + const api = { getSessionKimiModels } as unknown as ApiClient + const queryClient = createQueryClient() + const shared = wrapper(queryClient) + + const first = renderHook(() => useKimiModelsForSession({ + api, sessionId: 'session-1', enabled: true + }), { wrapper: shared }) + const second = renderHook(() => useKimiModelsForSession({ + api, sessionId: 'session-2', enabled: true + }), { wrapper: shared }) + + await waitFor(() => expect(first.result.current.availableModels[0]?.modelId).toBe('session-1-alias')) + await waitFor(() => expect(second.result.current.availableModels[0]?.modelId).toBe('session-2-alias')) + expect(getSessionKimiModels).toHaveBeenCalledTimes(2) + }) +}) diff --git a/web/src/hooks/queries/useKimiModelsForSession.ts b/web/src/hooks/queries/useKimiModelsForSession.ts new file mode 100644 index 00000000..017261a2 --- /dev/null +++ b/web/src/hooks/queries/useKimiModelsForSession.ts @@ -0,0 +1,38 @@ +import { useQuery } from '@tanstack/react-query' +import type { ApiClient } from '@/api/client' +import type { KimiModelSummary } from '@/types/api' +import { queryKeys } from '@/lib/query-keys' + +export function useKimiModelsForSession(args: { + api: ApiClient | null + sessionId?: string | null + enabled?: boolean +}): { + availableModels: KimiModelSummary[] + currentModelId: string | null + isLoading: boolean + error: string | null +} { + const enabled = Boolean(args.enabled && args.api && args.sessionId) + const query = useQuery({ + queryKey: args.sessionId + ? queryKeys.sessionKimiModels(args.sessionId) + : ['session-kimi-models', 'unknown'] as const, + queryFn: async () => { + if (!args.api || !args.sessionId) throw new Error('Kimi session unavailable') + return await args.api.getSessionKimiModels(args.sessionId) + }, + enabled, + staleTime: 30_000, + retry: false, + }) + + return { + availableModels: query.data?.availableModels ?? [], + currentModelId: query.data?.currentModelId ?? null, + isLoading: query.isLoading, + error: query.data?.success === false + ? (query.data.error ?? 'Failed to load Kimi models') + : query.error instanceof Error ? query.error.message : null, + } +} diff --git a/web/src/lib/query-keys.ts b/web/src/lib/query-keys.ts index 8b647432..4fff52af 100644 --- a/web/src/lib/query-keys.ts +++ b/web/src/lib/query-keys.ts @@ -32,6 +32,8 @@ export const queryKeys = { sessionGrokModels: (sessionId: string) => ['session-grok-models', sessionId] as const, sessionCopilotModels: (sessionId: string) => ['session-copilot-models', sessionId] as const, machineCopilotModelsForCwd: (machineId: string, cwd: string) => ['machine-copilot-models', machineId, cwd] as const, + machineKimiModelsForCwd: (machineId: string, cwd: string) => ['machine-kimi-models', machineId, cwd] as const, + sessionKimiModels: (sessionId: string) => ['session-kimi-models', sessionId] as const, sessionGrokReasoningEffortOptions: (sessionId: string) => ['session-grok-reasoning-effort-options', sessionId] as const, machineAgyModels: (machineId: string) => ['machine-agy-models', machineId] as const, machinePiModels: (machineId: string) => ['machine-pi-models', machineId] as const, diff --git a/web/src/types/api.ts b/web/src/types/api.ts index f94eb3f1..1b1c6610 100644 --- a/web/src/types/api.ts +++ b/web/src/types/api.ts @@ -27,6 +27,8 @@ export type { GitCommandResponse, GrokModelsResponse, GrokModelSummary, + KimiModelsResponse, + KimiModelSummary, CopilotModelsResponse, CopilotModelSummary, GrokReasoningEffortResponse,