@swarmclawai/swarmclaw 1.9.35 → 1.9.38

package/src/lib/server/messages/message-repository.test.ts

@@ -68,3 +68,125 @@ test('appendMessage notifies both generic and per-session message topics', () =>
   assert.deepEqual(output.genericTopics, ['messages'])
   assert.deepEqual(output.sessionTopics, ['messages:sess-notify'])
 })
+
+test('lazy migration compacts legacy session message blobs after table persistence', () => {
+  const output = runWithTempDataDir<{
+    returnedTexts: string[]
+    secondReadTexts: string[]
+    blobMessageCount: number
+    messageCount: number
+    lastMessageText: string | null
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+
+    storage.saveSessions({
+      'sess-legacy-blob': {
+        id: 'sess-legacy-blob',
+        name: 'Legacy blob session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages: [
+          { role: 'user', text: 'first legacy prompt', time: 1 },
+          { role: 'assistant', text: 'first legacy reply', time: 2 },
+          { role: 'user', text: 'second legacy prompt', time: 3 },
+        ],
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+      },
+    })
+
+    const returned = repo.getMessages('sess-legacy-blob')
+    const secondRead = repo.getMessages('sess-legacy-blob')
+    const stored = storage.loadSessions()['sess-legacy-blob']
+
+    console.log(JSON.stringify({
+      returnedTexts: returned.map((message) => message.text),
+      secondReadTexts: secondRead.map((message) => message.text),
+      blobMessageCount: Array.isArray(stored.messages) ? stored.messages.length : -1,
+      messageCount: stored.messageCount,
+      lastMessageText: stored.lastMessageSummary?.text || null,
+    }))
+  `, { prefix: 'swarmclaw-message-repo-compact-' })
+
+  assert.deepEqual(output.returnedTexts, [
+    'first legacy prompt',
+    'first legacy reply',
+    'second legacy prompt',
+  ])
+  assert.deepEqual(output.secondReadTexts, output.returnedTexts)
+  assert.equal(output.blobMessageCount, 0)
+  assert.equal(output.messageCount, 3)
+  assert.equal(output.lastMessageText, 'second legacy prompt')
+})
+
+test('bulk migration reports compaction for table-backed legacy blobs', () => {
+  const output = runWithTempDataDir<{
+    result: {
+      migrated: number
+      compacted: number
+      skipped: number
+      total: number
+    }
+    blobMessageCount: number
+    messageCount: number
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+
+    const messages = [
+      { role: 'user', text: 'stale blob prompt', time: 10 },
+      { role: 'assistant', text: 'stale blob reply', time: 20 },
+    ]
+
+    storage.saveSessions({
+      'sess-table-backed-blob': {
+        id: 'sess-table-backed-blob',
+        name: 'Table backed blob session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+      },
+    })
+
+    const db = storage.getDb()
+    const insert = db.prepare('INSERT INTO session_messages (session_id, seq, data) VALUES (?, ?, ?)')
+    messages.forEach((message, index) => {
+      insert.run('sess-table-backed-blob', index, JSON.stringify(message))
+    })
+
+    const result = repo.migrateAllSessions()
+    const stored = storage.loadSessions()['sess-table-backed-blob']
+
+    console.log(JSON.stringify({
+      result,
+      blobMessageCount: Array.isArray(stored.messages) ? stored.messages.length : -1,
+      messageCount: stored.messageCount,
+    }))
+  `, { prefix: 'swarmclaw-message-repo-migrate-report-' })
+
+  assert.equal(output.result.migrated, 0)
+  assert.equal(output.result.compacted, 1)
+  assert.equal(output.result.skipped, 1)
+  assert.equal(output.result.total, 1)
+  assert.equal(output.blobMessageCount, 0)
+  assert.equal(output.messageCount, 2)
+})

package/src/lib/server/messages/message-repository.ts

@@ -86,6 +86,38 @@ function summarizeForMeta(message: Message): Message {
   }
 }
 
+function getLastAssistantAt(messages: Message[]): number | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant' && typeof messages[i].time === 'number') {
+      return messages[i].time
+    }
+  }
+  return null
+}
+
+function compactDeprecatedBlobMessages(
+  sessionId: string,
+  persistedCount: number,
+  lastMsg: Message | null,
+  lastAssistantAt: number | null,
+): boolean {
+  let compacted = false
+  patchSession(sessionId, (current) => {
+    if (!current) return null
+    const blobCount = Array.isArray(current.messages) ? current.messages.length : 0
+    if (blobCount === 0) return current
+    if (persistedCount < blobCount) return current
+
+    current.messages = []
+    current.messageCount = persistedCount
+    current.lastMessageSummary = lastMsg ? summarizeForMeta(lastMsg) : null
+    if (lastAssistantAt !== null) current.lastAssistantAt = lastAssistantAt
+    compacted = true
+    return current
+  })
+  return compacted
+}
+
 // ---------------------------------------------------------------------------
 // Session metadata sync — keeps messageCount / lastMessageSummary on the blob
 // ---------------------------------------------------------------------------
@@ -139,18 +171,14 @@ function lazyMigrateSession(sessionId: string): Message[] | null {
       ins.run(sessionId, i, JSON.stringify(messages[i]))
     }
 
-    // Compute metadata on the blob (keep messages intact for backward compat)
+    // Compute metadata before compacting deprecated blob storage.
     const lastMsg = messages[messages.length - 1]
-    let lastAssistantAt: number | null = null
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (messages[i].role === 'assistant' && typeof messages[i].time === 'number') {
-        lastAssistantAt = messages[i].time
-        break
-      }
-    }
+    const lastAssistantAt = getLastAssistantAt(messages)
+    const persistedCount = rowCount(sessionId)
 
     patchSession(sessionId, (current) => {
       if (!current) return null
+      current.messages = persistedCount >= messages.length ? [] : current.messages
       current.messageCount = messages.length
       current.lastMessageSummary = lastMsg ? summarizeForMeta(lastMsg) : null
       if (lastAssistantAt !== null && typeof current.lastAssistantAt !== 'number') {
@@ -183,6 +211,7 @@ export function getMessages(sessionId: string): Message[] {
       const m = parseMsg(row.data)
       if (m) out.push(m)
     }
+    compactDeprecatedBlobMessages(sessionId, out.length, out[out.length - 1] || null, getLastAssistantAt(out))
     return out
   }, { sessionId })
 }
@@ -338,10 +367,16 @@ export function deleteSessionMessages(sessionId: string): void {
 // Bulk migration (for CLI / admin endpoint)
 // ---------------------------------------------------------------------------
 
-export function migrateAllSessions(): { migrated: number; skipped: number; total: number } {
+export function migrateAllSessions(): {
+  migrated: number
+  compacted: number
+  skipped: number
+  total: number
+} {
   const db = getDb()
   const rows = db.prepare('SELECT id, data FROM sessions').all() as Array<{ id: string; data: string }>
   let migrated = 0
+  let compacted = 0
   let skipped = 0
 
   for (const row of rows) {
@@ -351,16 +386,37 @@ export function migrateAllSessions(): { migrated: number; skipped: number; total
         skipped++
         continue
       }
-      if (rowCount(row.id) > 0) {
+
+      const persistedCount = rowCount(row.id)
+      if (persistedCount > 0) {
+        const persistedRows = stmts().selectAll.all(row.id) as Array<{ data: string }>
+        const persistedMessages: Message[] = []
+        for (const persistedRow of persistedRows) {
+          const message = parseMsg(persistedRow.data)
+          if (message) persistedMessages.push(message)
+        }
+        if (compactDeprecatedBlobMessages(
+          row.id,
+          persistedCount,
+          persistedMessages[persistedMessages.length - 1] || null,
+          getLastAssistantAt(persistedMessages),
+        )) {
+          compacted++
+        }
         skipped++
         continue
       }
+
       lazyMigrateSession(row.id)
       migrated++
+      const stored = loadSession(row.id)
+      if (!Array.isArray(stored?.messages) || stored.messages.length === 0) {
+        compacted++
+      }
     } catch {
       skipped++
     }
   }
 
-  return { migrated, skipped, total: rows.length }
+  return { migrated, compacted, skipped, total: rows.length }
 }

package/src/lib/server/openrouter-model-context.test.ts

@@ -0,0 +1,205 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+interface OpenRouterContextResult {
+  contextWindow: number | null
+  fetchCalls?: number
+}
+
+function runOpenRouterContextScript(script: string): OpenRouterContextResult {
+  return runWithTempDataDir<OpenRouterContextResult>(script, {
+    prefix: 'swarmclaw-openrouter-context-',
+  })
+}
+
+test('exact OpenRouter model ID returns cached context length', () => {
+  const output = runOpenRouterContextScript(`
+    const fs = await import('node:fs')
+    const path = await import('node:path')
+    const cachePath = path.join(process.env.DATA_DIR, 'openrouter-model-context.json')
+    fs.writeFileSync(cachePath, JSON.stringify({
+      loadedAt: Date.now(),
+      models: { 'minimax/minimax-m3': 524288 },
+    }))
+
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    globalThis.fetch = async () => {
+      throw new Error('fetch should not run when cache is fresh')
+    }
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'minimax/minimax-m3'),
+    }))
+  `)
+
+  assert.equal(output.contextWindow, 524_288)
+})
+
+test('top_provider.context_length is preferred over context_length', () => {
+  const output = runOpenRouterContextScript(`
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    globalThis.fetch = async () => new Response(JSON.stringify({
+      data: [{
+        id: 'provider/model-a',
+        context_length: 8192,
+        top_provider: { context_length: 131072 },
+      }],
+    }), { status: 200 })
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'provider/model-a'),
+    }))
+  `)
+
+  assert.equal(output.contextWindow, 131_072)
+})
+
+test('unique suffix match works for unprefixed model IDs', () => {
+  const output = runOpenRouterContextScript(`
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    globalThis.fetch = async () => new Response(JSON.stringify({
+      data: [{ id: 'google/gemini-2.5-pro', context_length: 1048576 }],
+    }), { status: 200 })
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'gemini-2.5-pro'),
+    }))
+  `)
+
+  assert.equal(output.contextWindow, 1_048_576)
+})
+
+test('ambiguous suffix match returns null', () => {
+  const output = runOpenRouterContextScript(`
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    globalThis.fetch = async () => new Response(JSON.stringify({
+      data: [
+        { id: 'provider-a/shared-model', context_length: 32000 },
+        { id: 'provider-b/shared-model', context_length: 64000 },
+      ],
+    }), { status: 200 })
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'shared-model'),
+    }))
+  `)
+
+  assert.equal(output.contextWindow, null)
+})
+
+test('non-OpenRouter provider returns null', () => {
+  const output = runOpenRouterContextScript(`
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openai', 'minimax/minimax-m3'),
+    }))
+  `)
+
+  assert.equal(output.contextWindow, null)
+})
+
+test('failed fetch does not throw', () => {
+  const output = runOpenRouterContextScript(`
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    let fetchCalls = 0
+    globalThis.fetch = async () => {
+      fetchCalls += 1
+      throw new Error('network down')
+    }
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'minimax/minimax-m3'),
+      fetchCalls,
+    }))
+  `)
+
+  assert.equal(output.contextWindow, null)
+  assert.equal(output.fetchCalls, 1)
+})
+
+test('timed out fetch does not throw', () => {
+  const output = runOpenRouterContextScript(`
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    let fetchCalls = 0
+    globalThis.fetch = async (_input, init) => {
+      fetchCalls += 1
+      await new Promise((_resolve, reject) => {
+        init.signal.addEventListener('abort', () => reject(init.signal.reason), { once: true })
+      })
+    }
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'minimax/minimax-m3'),
+      fetchCalls,
+    }))
+  `)
+
+  assert.equal(output.contextWindow, null)
+  assert.equal(output.fetchCalls, 1)
+})
+
+test('stale cache is ignored', () => {
+  const output = runOpenRouterContextScript(`
+    const fs = await import('node:fs')
+    const path = await import('node:path')
+    const cachePath = path.join(process.env.DATA_DIR, 'openrouter-model-context.json')
+    fs.writeFileSync(cachePath, JSON.stringify({
+      loadedAt: Date.now() - (25 * 60 * 60 * 1000),
+      models: { 'minimax/minimax-m3': 524288 },
+    }))
+
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    let fetchCalls = 0
+    globalThis.fetch = async () => {
+      fetchCalls += 1
+      throw new Error('network down')
+    }
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'minimax/minimax-m3'),
+      fetchCalls,
+    }))
+  `)
+
+  assert.equal(output.contextWindow, null)
+  assert.equal(output.fetchCalls, 1)
+})
+
+test('cache write failure does not throw', () => {
+  const output = runOpenRouterContextScript(`
+    const fs = await import('node:fs')
+    const path = await import('node:path')
+    const cachePath = path.join(process.env.DATA_DIR, 'openrouter-model-context.json')
+    fs.mkdirSync(cachePath)
+
+    const modImport = await import('./src/lib/server/openrouter-model-context')
+    const mod = modImport.default || modImport
+    globalThis.fetch = async () => new Response(JSON.stringify({
+      data: [{ id: 'provider/model-a', context_length: 65536 }],
+    }), { status: 200 })
+
+    await mod.ensureOpenRouterModelContextCache('openrouter')
+    console.log(JSON.stringify({
+      contextWindow: mod.getCachedOpenRouterContextWindow('openrouter', 'provider/model-a'),
+    }))
+  `)
+
+  assert.equal(output.contextWindow, 65_536)
+})

package/src/lib/server/openrouter-model-context.ts

@@ -0,0 +1,169 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import { fetchWithTimeout } from '@/lib/fetch-timeout'
+import { DATA_DIR } from '@/lib/server/data-dir'
+
+interface OpenRouterModelEntry {
+  id?: string
+  context_length?: number
+  top_provider?: {
+    context_length?: number
+  }
+}
+
+interface OpenRouterModelsResponse {
+  data?: OpenRouterModelEntry[]
+}
+
+interface OpenRouterModelContextCache {
+  loadedAt: number
+  models: Record<string, number>
+}
+
+const OPENROUTER_MODELS_URL = 'https://openrouter.ai/api/v1/models'
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000
+const FETCH_TIMEOUT_MS = 2_000
+const CACHE_PATH = path.join(DATA_DIR, 'openrouter-model-context.json')
+
+let cache: OpenRouterModelContextCache | null = null
+let loading: Promise<void> | null = null
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function parseModelEntry(value: unknown): OpenRouterModelEntry | null {
+  if (!isRecord(value)) return null
+
+  const entry: OpenRouterModelEntry = {}
+  if (typeof value.id === 'string') entry.id = value.id
+  if (typeof value.context_length === 'number') entry.context_length = value.context_length
+
+  if (isRecord(value.top_provider)) {
+    const topProvider: OpenRouterModelEntry['top_provider'] = {}
+    if (typeof value.top_provider.context_length === 'number') {
+      topProvider.context_length = value.top_provider.context_length
+    }
+    entry.top_provider = topProvider
+  }
+
+  return entry
+}
+
+function parseModelsResponse(value: unknown): OpenRouterModelsResponse {
+  if (!isRecord(value) || !Array.isArray(value.data)) return {}
+  return {
+    data: value.data
+      .map(parseModelEntry)
+      .filter((entry): entry is OpenRouterModelEntry => entry !== null),
+  }
+}
+
+function parseCache(value: unknown): OpenRouterModelContextCache | null {
+  if (!isRecord(value) || typeof value.loadedAt !== 'number' || !isRecord(value.models)) {
+    return null
+  }
+
+  const models: Record<string, number> = {}
+  for (const [id, contextLength] of Object.entries(value.models)) {
+    if (typeof contextLength === 'number' && Number.isFinite(contextLength) && contextLength > 0) {
+      models[id] = contextLength
+    }
+  }
+
+  return { loadedAt: value.loadedAt, models }
+}
+
+function isFreshCache(value: OpenRouterModelContextCache | null): value is OpenRouterModelContextCache {
+  return value !== null
+    && Number.isFinite(value.loadedAt)
+    && Date.now() - value.loadedAt <= CACHE_TTL_MS
+}
+
+async function readCache(): Promise<OpenRouterModelContextCache | null> {
+  try {
+    const raw = await fs.readFile(CACHE_PATH, 'utf8')
+    const parsed = parseCache(JSON.parse(raw))
+    return isFreshCache(parsed) ? parsed : null
+  } catch {
+    return null
+  }
+}
+
+async function writeCache(nextCache: OpenRouterModelContextCache): Promise<void> {
+  try {
+    await fs.mkdir(DATA_DIR, { recursive: true })
+    await fs.writeFile(CACHE_PATH, JSON.stringify(nextCache), 'utf8')
+  } catch {
+    // Best-effort cache. Runtime behavior should not depend on disk writes.
+  }
+}
+
+function buildModelContextMap(response: OpenRouterModelsResponse): Record<string, number> {
+  const models: Record<string, number> = {}
+  for (const entry of response.data || []) {
+    if (!entry.id) continue
+    const contextLength = entry.top_provider?.context_length || entry.context_length
+    if (typeof contextLength === 'number' && Number.isFinite(contextLength) && contextLength > 0) {
+      models[entry.id] = contextLength
+    }
+  }
+  return models
+}
+
+async function fetchOpenRouterModels(): Promise<OpenRouterModelContextCache | null> {
+  try {
+    const response = await fetchWithTimeout(OPENROUTER_MODELS_URL, {}, FETCH_TIMEOUT_MS)
+    if (!response.ok) return null
+
+    const payload = parseModelsResponse(await response.json())
+    return {
+      loadedAt: Date.now(),
+      models: buildModelContextMap(payload),
+    }
+  } catch {
+    return null
+  }
+}
+
+async function loadOpenRouterModelContextCache(): Promise<void> {
+  const diskCache = await readCache()
+  if (diskCache) {
+    cache = diskCache
+    return
+  }
+
+  const fetchedCache = await fetchOpenRouterModels()
+  if (!fetchedCache) return
+
+  cache = fetchedCache
+  await writeCache(fetchedCache)
+}
+
+export function getCachedOpenRouterContextWindow(provider: string, model: string): number | null {
+  if (provider !== 'openrouter' || !isFreshCache(cache)) return null
+
+  const exactMatch = cache.models[model]
+  if (exactMatch) return exactMatch
+
+  if (model.includes('/')) return null
+
+  const suffixMatches = Object.entries(cache.models)
+    .filter(([id]) => id.endsWith(`/${model}`))
+    .map(([, contextLength]) => contextLength)
+
+  return suffixMatches.length === 1 ? suffixMatches[0] : null
+}
+
+export async function ensureOpenRouterModelContextCache(provider: string): Promise<void> {
+  if (provider !== 'openrouter' || isFreshCache(cache)) return
+
+  if (!loading) {
+    loading = loadOpenRouterModelContextCache().finally(() => {
+      loading = null
+    })
+  }
+
+  await loading
+}

package/src/lib/server/provider-health.ts

@@ -261,6 +261,7 @@ async function parseErrorMessage(res: Response, fallback: string): Promise<strin
 export const OPENAI_COMPATIBLE_DEFAULTS: Record<string, { name: string; defaultEndpoint: string }> = {
   openai: { name: 'OpenAI', defaultEndpoint: 'https://api.openai.com/v1' },
   openrouter: { name: 'OpenRouter', defaultEndpoint: 'https://openrouter.ai/api/v1' },
+  tokenmix: { name: 'TokenMix', defaultEndpoint: 'https://api.tokenmix.ai/v1' },
   google: { name: 'Google Gemini', defaultEndpoint: 'https://generativelanguage.googleapis.com/v1beta/openai' },
   deepseek: { name: 'DeepSeek', defaultEndpoint: 'https://api.deepseek.com/v1' },
   groq: { name: 'Groq', defaultEndpoint: 'https://api.groq.com/openai/v1' },

package/src/lib/server/runtime/devserver-launch.ts

@@ -23,10 +23,10 @@ const NEXT_CONFIG_FILES = [
 ]
 
 function readPackageJson(dir: string): PackageJsonLike | null {
-  const pkgPath = path.join(dir, 'package.json')
-  if (!fs.existsSync(pkgPath)) return null
+  const pkgPath = path.join(/*turbopackIgnore: true*/ dir, 'package.json')
+  if (!fs.existsSync(/*turbopackIgnore: true*/ pkgPath)) return null
   try {
-    const parsed: unknown = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+    const parsed: unknown = JSON.parse(fs.readFileSync(/*turbopackIgnore: true*/ pkgPath, 'utf8'))
     return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
       ? parsed as PackageJsonLike
       : null
@@ -46,7 +46,10 @@ function hasNextScript(pkg: PackageJsonLike): boolean {
 }
 
 function hasNextConfig(dir: string): boolean {
-  return NEXT_CONFIG_FILES.some((file) => fs.existsSync(path.join(dir, file)))
+  return NEXT_CONFIG_FILES.some((file) => {
+    const configPath = path.join(/*turbopackIgnore: true*/ dir, file)
+    return fs.existsSync(/*turbopackIgnore: true*/ configPath)
+  })
 }
 
 function classifyPackageRoot(dir: string, pkg: PackageJsonLike): FrameworkKind {

package/src/lib/setup-defaults.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import { CLI_PROVIDER_METADATA } from './providers/cli-provider-metadata'
-import { DEFAULT_AGENTS, getDefaultModelForProvider } from './setup-defaults'
+import { DEFAULT_AGENTS, SETUP_PROVIDERS, getDefaultModelForProvider } from './setup-defaults'
 
 // ---------------------------------------------------------------------------
 // OpenClaw default model is empty (not 'default')
@@ -33,6 +33,15 @@ test('getDefaultModelForProvider returns non-empty for openrouter', () => {
   assert.ok(model, 'openrouter model should be truthy')
 })
 
+test('TokenMix has setup metadata and a default agent model', () => {
+  const provider = SETUP_PROVIDERS.find((candidate) => candidate.id === 'tokenmix')
+  assert.ok(provider, 'tokenmix should appear in setup providers')
+  assert.equal(provider.defaultEndpoint, 'https://api.tokenmix.ai/v1')
+  assert.equal(provider.supportsEndpoint, false)
+  assert.equal(provider.requiresKey, true)
+  assert.equal(getDefaultModelForProvider('tokenmix'), 'claude-sonnet-4-6')
+})
+
 test('getDefaultModelForProvider returns non-empty for anthropic', () => {
   const model = getDefaultModelForProvider('anthropic')
   assert.ok(model, 'anthropic model should be truthy')