kimaki 0.26.0 → 0.28.0

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

@@ -1,12 +1,22 @@
 // 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 {
+  formatCandidateRef,
+  PROVIDER_ID as SUBROUTER_PROVIDER_ID,
+  resolveLiveModel,
+} from '@subrouter/cli'
+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 +68,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 +95,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 +117,272 @@ 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. */
+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 })}`
+}
+
+/** Subrouter presets resolve to the live cooldown-aware candidate. */
+export async function resolveDisplayedModelName({
+  providers,
+  providerID,
+  modelID,
+  sessionID,
+}: {
+  providers: ProviderModelLookup[]
+  providerID?: string
+  modelID?: string
+  sessionID?: string
+}): Promise<string | undefined> {
+  if (providerID === SUBROUTER_PROVIDER_ID && modelID) {
+    const candidate = await resolveLiveModel({ preset: modelID, sessionID }).catch((e) => {
+      sessionLogger.warn(
+        `[MODEL] Failed to resolve subrouter candidate for ${modelID}:`,
+        e instanceof Error ? e.message : e,
+      )
+      return null
+    })
+    if (candidate) return `${modelID} (${formatCandidateRef(candidate)})`
+  }
+  return getProviderModelName({ providers, providerID, modelID })
+}
+
+export async function resolveDisplayedModelId({
+  providers,
+  providerID,
+  modelID,
+  sessionID,
+}: {
+  providers: ProviderModelLookup[]
+  providerID?: string
+  modelID?: string
+  sessionID?: string
+}): Promise<string | undefined> {
+  return formatDisplayedModelId({
+    providerID,
+    modelID,
+    name: await resolveDisplayedModelName({ providers, providerID, modelID, sessionID }),
+  })
+}
+
+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 +439,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}`,

package/src/session-handler/opencode-session-event-log.ts

@@ -16,6 +16,35 @@ export function isOpencodeSessionEventLogEnabled(): boolean {
   return process.env['KIMAKI_LOG_OPENCODE_SESSION_EVENTS'] === '1'
 }
 
+function sessionIdFromEventProperties(properties: OpenCodeEvent['properties']): string | undefined {
+  if (!properties || typeof properties !== 'object') {
+    return undefined
+  }
+  const sessionID = Reflect.get(properties, 'sessionID')
+  if (typeof sessionID === 'string') {
+    return sessionID
+  }
+  const info = Reflect.get(properties, 'info')
+  if (info && typeof info === 'object') {
+    const id = Reflect.get(info, 'id')
+    if (typeof id === 'string') {
+      return id
+    }
+    const infoSessionId = Reflect.get(info, 'sessionID')
+    if (typeof infoSessionId === 'string') {
+      return infoSessionId
+    }
+  }
+  const part = Reflect.get(properties, 'part')
+  if (part && typeof part === 'object') {
+    const partSessionId = Reflect.get(part, 'sessionID')
+    if (typeof partSessionId === 'string') {
+      return partSessionId
+    }
+  }
+  return undefined
+}
+
 export function getOpencodeEventSessionId(event: OpenCodeEvent): string | undefined {
   switch (event.type) {
     case 'message.updated':
@@ -40,7 +69,8 @@ export function getOpencodeEventSessionId(event: OpenCodeEvent): string | undefi
     case 'session.deleted':
       return event.properties.info.id
     default:
-      return undefined
+      // session.next.* and later SDK events put sessionID on properties.
+      return sessionIdFromEventProperties(event.properties)
   }
 }
 

package/src/session-handler/thread-ingress.test.ts

@@ -0,0 +1,54 @@
+// Unit tests for the per-thread Discord arrival FIFO.
+// /plan-agent and a follow-up message must keep Discord order.
+
+import { describe, expect, test } from 'vitest'
+import {
+  reserveThreadIngress,
+  runInThreadIngressSlot,
+  waitForCurrentThreadIngress,
+} from './thread-session-runtime.js'
+
+describe('thread ingress FIFO', () => {
+  test('later waiters stay behind an unreleased earlier slot', async () => {
+    const first = reserveThreadIngress('thread-fifo')
+    const second = reserveThreadIngress('thread-fifo')
+    const order: string[] = []
+
+    const firstWork = runInThreadIngressSlot(first, async () => {
+      await waitForCurrentThreadIngress()
+      order.push('first-write')
+      first.release()
+      await new Promise((resolve) => setTimeout(resolve, 20))
+      order.push('first-work')
+    })
+
+    const secondWork = runInThreadIngressSlot(second, async () => {
+      await waitForCurrentThreadIngress()
+      order.push('second')
+      second.release()
+    })
+
+    await Promise.all([firstWork, secondWork])
+    expect(order).toEqual(['first-write', 'second', 'first-work'])
+  })
+
+  test('runInThreadIngressSlot releases after a thrown callback', async () => {
+    const first = reserveThreadIngress('thread-fifo-throw')
+    const second = reserveThreadIngress('thread-fifo-throw')
+    const order: string[] = []
+
+    const firstWork = runInThreadIngressSlot(first, async () => {
+      await waitForCurrentThreadIngress()
+      order.push('first')
+      throw new Error('boom')
+    }).catch(() => {})
+
+    const secondWork = runInThreadIngressSlot(second, async () => {
+      await waitForCurrentThreadIngress()
+      order.push('second')
+    })
+
+    await Promise.all([firstWork, secondWork])
+    expect(order).toEqual(['first', 'second'])
+  })
+})

package/src/session-handler/thread-runtime-state.ts

@@ -43,6 +43,8 @@ export type QueuedMessage = {
   // Set by --agent/--model/--permission flags on kimaki send or slash commands.
   agent?: string
   model?: string
+  // Thinking-level variant from `/xxx-agent variant:`.
+  variant?: string
   // Raw permission rule strings ("tool:action" or "tool:pattern:action").
   // Parsed and merged into session permissions on creation.
   permissions?: string[]
@@ -183,6 +185,7 @@ export function setSessionUsername(threadId: string, username: string): void {
 }
 
 export function setSessionUserId(threadId: string, userId: string): void {
+  if (!userId) return
   updateThread(threadId, (t) => {
     if (t.sessionUserId) {
       return t

package/src/session-handler/thread-session-runtime-summary.test.ts

@@ -0,0 +1,169 @@
+import type {
+  Event as OpenCodeEvent,
+  Message as OpenCodeMessage,
+  Part,
+} from '@opencode-ai/sdk/v2'
+import { describe, expect, test } from 'vitest'
+import type { EventBufferEntry, EventBufferEvent } from './event-stream-state.js'
+import { ThreadSessionRuntime } from './thread-session-runtime.js'
+
+type RuntimeInternals = {
+  state?: { sessionId: string }
+  eventBuffer: EventBufferEntry[]
+  partBuffer: Map<string, Map<string, Part>>
+  compactEventForEventBuffer: (event: EventBufferEvent) => EventBufferEvent | undefined
+  flushBufferedParts: () => Promise<void>
+  handleMessageUpdated: (message: OpenCodeMessage) => Promise<void>
+  handlePartUpdated: (part: Part) => Promise<void>
+  handleNaturalAssistantCompletion: () => Promise<void>
+  handleMainPart: (part: Part) => Promise<void>
+  handleSubtaskPart: (part: Part) => Promise<void>
+}
+
+function summaryMessageEvent({
+  sessionId,
+  messageId,
+}: {
+  sessionId: string
+  messageId: string
+}): OpenCodeEvent {
+  return {
+    id: `evt_${messageId}`,
+    type: 'message.updated',
+    properties: {
+      sessionID: sessionId,
+      info: {
+        id: messageId,
+        sessionID: sessionId,
+        role: 'assistant',
+        parentID: 'msg_user',
+        time: { created: 2, completed: 3 },
+        modelID: 'compaction-model',
+        providerID: 'test-provider',
+        mode: 'compaction',
+        agent: 'compaction',
+        path: { cwd: '/test', root: '/test' },
+        cost: 1,
+        tokens: {
+          input: 10,
+          output: 1,
+          reasoning: 0,
+          cache: { read: 0, write: 0 },
+        },
+        finish: 'stop',
+        summary: true,
+      },
+    },
+  }
+}
+
+function summaryTextPart({
+  sessionId,
+  messageId,
+}: {
+  sessionId: string
+  messageId: string
+}): Part {
+  return {
+    id: `prt_${messageId}`,
+    sessionID: sessionId,
+    messageID: messageId,
+    type: 'text',
+    text: 'internal compaction summary must not reach Discord',
+    time: { start: 2, end: 3 },
+  }
+}
+
+describe('ThreadSessionRuntime compaction summary routing', () => {
+  test('drops summary message parts before fallback buffering or completion', async () => {
+    const sessionId = 'ses_main'
+    const messageId = 'msg_summary_embedded_parts'
+    const event = summaryMessageEvent({ sessionId, messageId })
+    if (event.type !== 'message.updated') {
+      throw new Error('Expected summary message event')
+    }
+    const message = {
+      ...event.properties.info,
+      parts: [summaryTextPart({ sessionId, messageId })],
+    } as unknown as OpenCodeMessage
+    const runtime = Object.create(ThreadSessionRuntime.prototype) as RuntimeInternals
+    Object.defineProperty(runtime, 'state', {
+      value: { sessionId },
+      configurable: true,
+    })
+    runtime.eventBuffer = [{ event, timestamp: 1 }]
+    runtime.partBuffer = new Map()
+    runtime.flushBufferedParts = async () => {
+      throw new Error('Summary message must not flush parts')
+    }
+    runtime.handleNaturalAssistantCompletion = async () => {
+      throw new Error('Summary message must not complete the Discord turn')
+    }
+
+    await runtime.handleMessageUpdated(message)
+
+    expect(runtime.partBuffer.size).toBe(0)
+  })
+
+  test.each([
+    ['main session', 'ses_main'],
+    ['subagent session', 'ses_child'],
+  ])('preserves summary identity and drops %s parts before buffering', async (_, sessionId) => {
+    const messageId = `msg_summary_${sessionId}`
+    const runtime = Object.create(ThreadSessionRuntime.prototype) as RuntimeInternals
+    const compacted = runtime.compactEventForEventBuffer(
+      summaryMessageEvent({ sessionId, messageId }),
+    )
+
+    expect(compacted?.type).toBe('message.updated')
+    if (!compacted || compacted.type !== 'message.updated') {
+      throw new Error('Expected compacted summary message event')
+    }
+    expect(compacted.properties.info.summary).toBe(true)
+
+    runtime.eventBuffer = [{ event: compacted, timestamp: 1 }]
+    runtime.partBuffer = new Map()
+
+    await runtime.handlePartUpdated(summaryTextPart({ sessionId, messageId }))
+
+    expect(runtime.partBuffer.size).toBe(0)
+  })
+
+  test.each([
+    ['main session', 'ses_main'],
+    ['subagent session', 'ses_child'],
+  ])('holds %s parts until summary identity arrives, then drops them', async (_, sessionId) => {
+    const messageId = `msg_summary_unknown_${sessionId}`
+    const runtime = Object.create(ThreadSessionRuntime.prototype) as RuntimeInternals
+    Object.defineProperty(runtime, 'state', {
+      value: { sessionId: 'ses_main' },
+      configurable: true,
+    })
+    runtime.eventBuffer = []
+    runtime.partBuffer = new Map()
+    runtime.handleMainPart = async () => {
+      throw new Error('Unknown summary parts must not render')
+    }
+    runtime.handleSubtaskPart = async () => {
+      throw new Error('Unknown summary parts must not render')
+    }
+    runtime.flushBufferedParts = async () => {
+      throw new Error('Summary message must not flush parts')
+    }
+    runtime.handleNaturalAssistantCompletion = async () => {
+      throw new Error('Summary message must not complete the Discord turn')
+    }
+
+    await runtime.handlePartUpdated(summaryTextPart({ sessionId, messageId }))
+
+    expect(runtime.partBuffer.get(messageId)?.size).toBe(1)
+
+    const event = summaryMessageEvent({ sessionId, messageId })
+    if (event.type !== 'message.updated') {
+      throw new Error('Expected summary message event')
+    }
+    await runtime.handleMessageUpdated(event.properties.info)
+
+    expect(runtime.partBuffer.size).toBe(0)
+  })
+})