kimaki 0.26.0 → 0.27.0

package/src/session-handler/model-utils.test.ts

@@ -0,0 +1,415 @@
+// Tests for model ID parsing, cached provider.list wrapping, and validation.
+
+import { afterEach, describe, expect, test } from 'vitest'
+import { InvalidModelError } from '../errors.js'
+import {
+  clearModelListCache,
+  formatDisplayedModelId,
+  getProviderModelName,
+  listModels,
+  parseModelId,
+  resolveDisplayedModelId,
+  validateCliModelOption,
+  validateModelId,
+  validateModelIdAgainstList,
+  type ListedModel,
+} from './model-utils.js'
+
+const listed: ListedModel[] = [
+  {
+    providerID: 'anthropic',
+    modelID: 'claude-opus-4-6',
+    name: 'Claude Opus 4.6',
+    connected: true,
+  },
+  {
+    providerID: 'anthropic',
+    modelID: 'claude-sonnet-4-6',
+    name: 'Claude Sonnet 4.6',
+    connected: true,
+  },
+  {
+    providerID: 'openai',
+    modelID: 'gpt-5.4',
+    name: 'GPT-5.4',
+    connected: false,
+  },
+]
+
+afterEach(() => {
+  clearModelListCache()
+})
+
+describe('getProviderModelName', () => {
+  const providers = [
+    {
+      id: 'subrouter',
+      models: {
+        build: { name: 'build (claude-opus-4-6)' },
+        default: { name: 'default' },
+      },
+    },
+    {
+      id: 'deterministic-provider',
+      models: {
+        'deterministic-v2': { name: 'deterministic-v2' },
+      },
+    },
+  ]
+
+  test('uses the sdk display name when subrouter adds the live model', () => {
+    expect(
+      getProviderModelName({
+        providers,
+        providerID: 'subrouter',
+        modelID: 'build',
+      }),
+    ).toMatchInlineSnapshot(`"build (claude-opus-4-6)"`)
+  })
+
+  test('falls back to the model id when name is missing', () => {
+    expect(
+      getProviderModelName({
+        providers: [{ id: 'subrouter', models: { build: {} } }],
+        providerID: 'subrouter',
+        modelID: 'build',
+      }),
+    ).toMatchInlineSnapshot(`"build"`)
+  })
+
+  test('returns undefined when provider or model is missing', () => {
+    expect(
+      getProviderModelName({
+        providers,
+        providerID: 'subrouter',
+        modelID: 'missing',
+      }),
+    ).toBeUndefined()
+    expect(
+      getProviderModelName({
+        providers,
+        providerID: 'openai',
+        modelID: 'gpt-5.4',
+      }),
+    ).toBeUndefined()
+    expect(
+      getProviderModelName({
+        providers,
+      }),
+    ).toBeUndefined()
+  })
+})
+
+describe('formatDisplayedModelId', () => {
+  test('keeps provider/id when the sdk name matches the model id', () => {
+    expect(
+      formatDisplayedModelId({
+        providerID: 'deterministic-provider',
+        modelID: 'deterministic-v2',
+        name: 'deterministic-v2',
+      }),
+    ).toMatchInlineSnapshot(`"deterministic-provider/deterministic-v2"`)
+  })
+
+  test('uses the sdk name so subrouter live model shows in parentheses', () => {
+    expect(
+      formatDisplayedModelId({
+        providerID: 'subrouter',
+        modelID: 'build',
+        name: 'build (claude-opus-4-6)',
+      }),
+    ).toMatchInlineSnapshot(`"subrouter/build (claude-opus-4-6)"`)
+  })
+
+  test('falls back to provider/id when name is missing', () => {
+    expect(
+      formatDisplayedModelId({
+        providerID: 'subrouter',
+        modelID: 'build',
+      }),
+    ).toMatchInlineSnapshot(`"subrouter/build"`)
+  })
+
+  test('keeps provider/id when sdk name is a pretty label', () => {
+    expect(
+      formatDisplayedModelId({
+        providerID: 'anthropic',
+        modelID: 'claude-opus-4-6',
+        name: 'Claude Opus 4.6',
+      }),
+    ).toMatchInlineSnapshot(`"anthropic/claude-opus-4-6"`)
+  })
+})
+
+describe('resolveDisplayedModelId', () => {
+  test('uses subrouter sdk name with parentheses', () => {
+    expect(
+      resolveDisplayedModelId({
+        providers: [
+          {
+            id: 'subrouter',
+            models: { build: { name: 'build (claude-opus-4-6)' } },
+          },
+        ],
+        providerID: 'subrouter',
+        modelID: 'build',
+      }),
+    ).toMatchInlineSnapshot(`"subrouter/build (claude-opus-4-6)"`)
+  })
+})
+
+describe('parseModelId', () => {
+  test('splits provider/model', () => {
+    expect(parseModelId('anthropic/claude-opus-4-6')).toMatchInlineSnapshot(`
+      {
+        "modelID": "claude-opus-4-6",
+        "providerID": "anthropic",
+      }
+    `)
+  })
+
+  test('keeps slashes inside the model id', () => {
+    expect(parseModelId('opencode/glm-5/free')).toMatchInlineSnapshot(`
+      {
+        "modelID": "glm-5/free",
+        "providerID": "opencode",
+      }
+    `)
+  })
+
+  test('rejects missing slash, empty provider, and empty model', () => {
+    expect(parseModelId('claude-opus-4-6')).toBeUndefined()
+    expect(parseModelId('/claude-opus-4-6')).toBeUndefined()
+    expect(parseModelId('anthropic/')).toBeUndefined()
+    expect(parseModelId('')).toBeUndefined()
+  })
+})
+
+describe('validateModelIdAgainstList', () => {
+  test('accepts a connected listed model', () => {
+    expect(
+      validateModelIdAgainstList({
+        model: 'anthropic/claude-opus-4-6',
+        models: listed,
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "modelID": "claude-opus-4-6",
+        "providerID": "anthropic",
+      }
+    `)
+  })
+
+  test('rejects bad format', () => {
+    const result = validateModelIdAgainstList({
+      model: 'claude-opus-4-6',
+      models: listed,
+    })
+    expect(result).toBeInstanceOf(InvalidModelError)
+    if (result instanceof InvalidModelError) {
+      expect(result.model).toBe('claude-opus-4-6')
+      expect(result.reason).toContain('provider/model')
+    }
+  })
+
+  test('rejects unknown model and lists siblings', () => {
+    const result = validateModelIdAgainstList({
+      model: 'anthropic/does-not-exist',
+      models: listed,
+    })
+    expect(result).toBeInstanceOf(InvalidModelError)
+    if (result instanceof InvalidModelError) {
+      expect(result.message).toContain('anthropic/does-not-exist')
+      expect(result.message).toContain('anthropic/claude-opus-4-6')
+      expect(result.message).toContain('anthropic/claude-sonnet-4-6')
+    }
+  })
+
+  test('rejects disconnected provider', () => {
+    const result = validateModelIdAgainstList({
+      model: 'openai/gpt-5.4',
+      models: listed,
+    })
+    expect(result).toBeInstanceOf(InvalidModelError)
+    if (result instanceof InvalidModelError) {
+      expect(result.message).toContain('not connected')
+      expect(result.message).toContain('openai')
+    }
+  })
+})
+
+function fakeGetClient(options?: {
+  calls?: { count: number }
+  failOnce?: boolean
+}) {
+  let failed = false
+  return () => ({
+    provider: {
+      list: async () => {
+        if (options?.calls) options.calls.count += 1
+        if (options?.failOnce && !failed) {
+          failed = true
+          throw new Error('provider.list failed')
+        }
+        return {
+          data: {
+            all: [
+              {
+                id: 'anthropic',
+                models: {
+                  'claude-opus-4-6': { name: 'Claude Opus 4.6' },
+                },
+              },
+            ],
+            connected: ['anthropic'],
+            default: {},
+          },
+        }
+      },
+    },
+  })
+}
+
+describe('listModels', () => {
+  test('returns listed models from provider.list', async () => {
+    const models = await listModels({
+      getClient: fakeGetClient() as never,
+      directory: '/tmp/project-a',
+    })
+    expect(models).not.toBeInstanceOf(Error)
+    if (models instanceof Error) throw models
+    expect(models).toMatchInlineSnapshot(`
+      [
+        {
+          "connected": true,
+          "modelID": "claude-opus-4-6",
+          "name": "Claude Opus 4.6",
+          "providerID": "anthropic",
+        },
+      ]
+    `)
+  })
+
+  test('memoizes provider.list per directory', async () => {
+    const calls = { count: 0 }
+    const getClient = fakeGetClient({ calls }) as never
+    const first = await listModels({ getClient, directory: '/tmp/project-a' })
+    const second = await listModels({ getClient, directory: '/tmp/project-a' })
+    expect(first).not.toBeInstanceOf(Error)
+    expect(second).not.toBeInstanceOf(Error)
+    expect(calls.count).toBe(1)
+  })
+
+  test('does not share cache across directories', async () => {
+    const calls = { count: 0 }
+    const getClient = fakeGetClient({ calls }) as never
+    const first = await listModels({ getClient, directory: '/tmp/project-a' })
+    const second = await listModels({ getClient, directory: '/tmp/project-b' })
+    expect(first).not.toBeInstanceOf(Error)
+    expect(second).not.toBeInstanceOf(Error)
+    expect(calls.count).toBe(2)
+  })
+
+  test('does not cache failed fetches', async () => {
+    const calls = { count: 0 }
+    const getClient = fakeGetClient({ calls, failOnce: true }) as never
+    const first = await listModels({ getClient, directory: '/tmp/project-a' })
+    expect(first).toBeInstanceOf(Error)
+    const second = await listModels({ getClient, directory: '/tmp/project-a' })
+    expect(second).not.toBeInstanceOf(Error)
+    expect(calls.count).toBe(2)
+  })
+
+  test('does not restore a pending result after the cache is cleared', async () => {
+    const calls = { count: 0 }
+    const firstResponse = Promise.withResolvers<{
+      data: {
+        all: Array<{ id: string; models: Record<string, { name: string }> }>
+        connected: string[]
+        default: Record<string, string>
+      }
+    }>()
+    const getClient = (() => ({
+      provider: {
+        list: () => {
+          calls.count += 1
+          if (calls.count === 1) return firstResponse.promise
+          return Promise.resolve({
+            data: {
+              all: [{ id: 'openai', models: { 'gpt-5.5': { name: 'GPT-5.5' } } }],
+              connected: ['openai'],
+              default: {},
+            },
+          })
+        },
+      },
+    })) as never
+
+    const pending = listModels({ getClient, directory: '/tmp/project-a' })
+    clearModelListCache()
+    firstResponse.resolve({
+      data: {
+        all: [
+          {
+            id: 'anthropic',
+            models: { 'claude-opus-4-6': { name: 'Claude Opus 4.6' } },
+          },
+        ],
+        connected: ['anthropic'],
+        default: {},
+      },
+    })
+    await pending
+
+    const refreshed = await listModels({ getClient, directory: '/tmp/project-a' })
+    expect({ calls: calls.count, refreshed }).toMatchInlineSnapshot(`
+      {
+        "calls": 2,
+        "refreshed": [
+          {
+            "connected": true,
+            "modelID": "gpt-5.5",
+            "name": "GPT-5.5",
+            "providerID": "openai",
+          },
+        ],
+      }
+    `)
+  })
+})
+
+describe('validateCliModelOption', () => {
+  test('skips empty model', async () => {
+    expect(await validateCliModelOption({ model: undefined })).toBeUndefined()
+    expect(await validateCliModelOption({ model: '' })).toBeUndefined()
+  })
+
+  test('rejects bad format without starting opencode', async () => {
+    const result = await validateCliModelOption({ model: 'claude-opus-4-6' })
+    expect(result).toBeInstanceOf(InvalidModelError)
+  })
+})
+
+describe('validateModelId', () => {
+  test('validates against the cached list', async () => {
+    const getClient = fakeGetClient() as never
+    const ok = await validateModelId({
+      model: 'anthropic/claude-opus-4-6',
+      getClient,
+      directory: '/tmp/project-a',
+    })
+    expect(ok).toMatchInlineSnapshot(`
+      {
+        "modelID": "claude-opus-4-6",
+        "providerID": "anthropic",
+      }
+    `)
+
+    const bad = await validateModelId({
+      model: 'anthropic/missing',
+      getClient,
+      directory: '/tmp/project-a',
+    })
+    expect(bad).toBeInstanceOf(InvalidModelError)
+  })
+})

package/src/session-handler/model-utils.ts

@@ -1,12 +1,17 @@
 // Model resolution utilities.
 // getDefaultModel resolves the default model from OpenCode when no user preference is set.
+// listModels wraps provider.list() with a per-directory memoized cache.
 
 import fs from 'node:fs'
 import path from 'node:path'
 import { xdgState } from 'xdg-basedir'
 import * as errore from 'errore'
-import { OpenCodeSdkError } from '../errors.js'
-import { type initializeOpencodeForDirectory } from '../opencode.js'
+import type { OpencodeClient, Provider } from '@opencode-ai/sdk/v2'
+import { InvalidModelError, OpenCodeSdkError } from '../errors.js'
+import {
+  initializeOpencodeForDirectory,
+  subscribeOpencodeServerLifecycle,
+} from '../opencode.js'
 import { createLogger, LogPrefix } from '../logger.js'
 import type { ScheduledTaskScheduleKind } from '../database.js'
 
@@ -58,7 +63,7 @@ function getRecentModelsFromTuiState(): Array<{
 /**
  * Parse a model string in format "provider/model" into providerID and modelID.
  */
-function parseModelString(
+export function parseModelId(
   model: string,
 ): { providerID: string; modelID: string } | undefined {
   const [providerID, ...modelParts] = model.split('/')
@@ -85,7 +90,7 @@ function getModelFromProjectConfig({
     if (!parsed.model) {
       return undefined
     }
-    return parseModelString(parsed.model)
+    return parseModelId(parsed.model)
   })
   if (result instanceof Error) return undefined
   return result
@@ -107,6 +112,245 @@ function isModelValid(
   return isConnected && !!modelExists
 }
 
+export type ListedModel = {
+  providerID: string
+  modelID: string
+  name: string
+  connected: boolean
+}
+
+type ProviderModelLookup = {
+  id: string
+  models?: Record<string, { name?: string } | undefined>
+}
+
+/** SDK display name from provider.list. Subrouter sets this to `build (claude-opus-4-6)`. */
+export function getProviderModelName({
+  providers,
+  providerID,
+  modelID,
+}: {
+  providers: ProviderModelLookup[]
+  providerID?: string
+  modelID?: string
+}): string | undefined {
+  if (!providerID || !modelID) return undefined
+  const provider = providers.find((p) => p.id === providerID)
+  const model = provider?.models?.[modelID]
+  if (!model) return undefined
+  if (typeof model.name === 'string' && model.name.trim()) return model.name
+  return modelID
+}
+
+/** Use the SDK name only when it is the model id, or the model id plus `(live-model)`. */
+export function displayedModelLabel({
+  modelID,
+  name,
+}: {
+  modelID: string
+  name?: string
+}): string {
+  if (name && (name === modelID || name.startsWith(`${modelID} (`))) return name
+  return modelID
+}
+
+export function formatDisplayedModelId({
+  providerID,
+  modelID,
+  name,
+}: {
+  providerID?: string
+  modelID?: string
+  name?: string
+}): string | undefined {
+  if (!providerID || !modelID) return undefined
+  return `${providerID}/${displayedModelLabel({ modelID, name })}`
+}
+
+export function resolveDisplayedModelId({
+  providers,
+  providerID,
+  modelID,
+}: {
+  providers: ProviderModelLookup[]
+  providerID?: string
+  modelID?: string
+}): string | undefined {
+  return formatDisplayedModelId({
+    providerID,
+    modelID,
+    name: getProviderModelName({ providers, providerID, modelID }),
+  })
+}
+
+type ModelListCacheEntry =
+  | { status: 'pending'; promise: Promise<ListedModel[] | OpenCodeSdkError> }
+  | { status: 'ready'; value: ListedModel[] }
+
+const modelListCache = new Map<string, ModelListCacheEntry>()
+
+export function clearModelListCache() {
+  modelListCache.clear()
+}
+
+subscribeOpencodeServerLifecycle(() => {
+  clearModelListCache()
+})
+
+function flattenProviderModels({
+  providers,
+  connected,
+}: {
+  providers: Provider[]
+  connected: string[]
+}): ListedModel[] {
+  const connectedSet = new Set(connected)
+  const models: ListedModel[] = []
+  for (const provider of providers) {
+    const isConnected = connectedSet.has(provider.id)
+    for (const [modelID, model] of Object.entries(provider.models)) {
+      models.push({
+        providerID: provider.id,
+        modelID,
+        name: model.name || modelID,
+        connected: isConnected,
+      })
+    }
+  }
+  return models
+}
+
+export async function listModels({
+  getClient,
+  directory,
+}: {
+  getClient: () => OpencodeClient
+  directory?: string
+}): Promise<ListedModel[] | OpenCodeSdkError> {
+  const cacheKey = directory ?? ''
+  const cached = modelListCache.get(cacheKey)
+  if (cached?.status === 'ready') return cached.value
+  if (cached?.status === 'pending') return cached.promise
+
+  const promise = (async () => {
+    const providersResponse = await getClient()
+      .provider.list({ directory })
+      .catch((e) => new OpenCodeSdkError({ operation: 'provider.list', cause: e }))
+    if (providersResponse instanceof Error) return providersResponse
+    if (!providersResponse.data) {
+      return new OpenCodeSdkError({ operation: 'provider.list' })
+    }
+    return flattenProviderModels({
+      providers: providersResponse.data.all,
+      connected: providersResponse.data.connected,
+    })
+  })()
+
+  modelListCache.set(cacheKey, { status: 'pending', promise })
+  const result = await promise
+  const current = modelListCache.get(cacheKey)
+  const ownsCacheEntry = current?.status === 'pending' && current.promise === promise
+  if (result instanceof Error) {
+    if (ownsCacheEntry) modelListCache.delete(cacheKey)
+    return result
+  }
+  if (ownsCacheEntry) modelListCache.set(cacheKey, { status: 'ready', value: result })
+  return result
+}
+
+export function validateModelIdAgainstList({
+  model,
+  models,
+}: {
+  model: string
+  models: ListedModel[]
+}): { providerID: string; modelID: string } | InvalidModelError {
+  const parsed = parseModelId(model)
+  if (!parsed) {
+    return new InvalidModelError({
+      model,
+      reason: 'expected provider/model, for example anthropic/claude-opus-4-6',
+    })
+  }
+
+  const match = models.find((candidate) => {
+    return (
+      candidate.providerID === parsed.providerID &&
+      candidate.modelID === parsed.modelID
+    )
+  })
+  if (!match) {
+    const siblings = models
+      .filter((candidate) => candidate.providerID === parsed.providerID)
+      .map((candidate) => `${candidate.providerID}/${candidate.modelID}`)
+    if (siblings.length > 0) {
+      return new InvalidModelError({
+        model,
+        reason: `unknown model. Similar: ${siblings.slice(0, 8).join(', ')}`,
+      })
+    }
+    const connectedProviders = [
+      ...new Set(
+        models.filter((candidate) => candidate.connected).map((candidate) => {
+          return candidate.providerID
+        }),
+      ),
+    ]
+    const connectedHint = connectedProviders.length
+      ? ` Connected providers: ${connectedProviders.join(', ')}`
+      : ''
+    return new InvalidModelError({
+      model,
+      reason: `unknown provider ${parsed.providerID}.${connectedHint}`,
+    })
+  }
+  if (!match.connected) {
+    return new InvalidModelError({
+      model,
+      reason: `provider ${parsed.providerID} is not connected`,
+    })
+  }
+  return parsed
+}
+
+export async function validateModelId({
+  model,
+  getClient,
+  directory,
+}: {
+  model: string
+  getClient: () => OpencodeClient
+  directory?: string
+}): Promise<
+  { providerID: string; modelID: string } | InvalidModelError | OpenCodeSdkError
+> {
+  const models = await listModels({ getClient, directory })
+  if (models instanceof Error) return models
+  return validateModelIdAgainstList({ model, models })
+}
+
+export async function validateCliModelOption({
+  model,
+  directory,
+}: {
+  model: string | undefined
+  directory?: string
+}) {
+  if (!model) return
+  const parsed = parseModelId(model)
+  if (!parsed) {
+    return new InvalidModelError({
+      model,
+      reason: 'expected provider/model, for example anthropic/claude-opus-4-6',
+    })
+  }
+  if (!directory) return parsed
+
+  const getClient = await initializeOpencodeForDirectory(directory)
+  if (getClient instanceof Error) return getClient
+  return validateModelId({ model, getClient, directory })
+}
+
 /**
  * Get the default model from OpenCode when no user preference is set.
  * Priority (matches OpenCode TUI behavior):
@@ -163,7 +407,7 @@ export async function getDefaultModel({
   const configResponse = await getClient().config.get({ directory })
     .catch((e) => new OpenCodeSdkError({ operation: 'config.get', cause: e }))
   if (!(configResponse instanceof Error) && configResponse.data?.model) {
-    const configModel = parseModelString(configResponse.data.model)
+    const configModel = parseModelId(configResponse.data.model)
     if (configModel && isModelValid(configModel, connected, providers)) {
       sessionLogger.log(
         `[MODEL] Using config model: ${configModel.providerID}/${configModel.modelID}`,