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,