@swarmclawai/swarmclaw 1.9.37 → 1.9.38

package/README.md

@@ -84,7 +84,7 @@ Available for macOS (Apple Silicon & Intel), Windows, and Linux (AppImage + .deb
 The release workflow supports Developer ID signing and notarization when Apple
 credentials are configured. If a macOS build is still ad-hoc signed, first
 launch may need one manual approval:
-- **macOS:** right-click the app in Finder → **Open** → **Open** to bypass Gatekeeper. If macOS instead reports *"SwarmClaw is damaged and can't be opened"* (common when the dmg was quarantined by Safari), strip the quarantine attribute and relaunch:
+- **macOS:** signed/notarized releases publish both `.dmg` and `.zip`; unsigned fallback releases publish `.zip` only to avoid the damaged unsigned DMG path. Right-click the app in Finder → **Open** → **Open** to bypass Gatekeeper. If macOS instead reports *"SwarmClaw is damaged and can't be opened"* (common when a downloaded app was quarantined by Safari), strip the quarantine attribute and relaunch:
   ```bash
   xattr -dr com.apple.quarantine /Applications/SwarmClaw.app
   ```
@@ -151,6 +151,15 @@ openclaw skills install swarmclaw
 
 [Browse on ClawHub](https://clawhub.ai/waydelyle/swarmclaw)
 
+## v1.9.38 Highlights
+
+PR integration release for provider catalog coverage, OpenRouter context meters, and safer unsigned macOS desktop artifacts.
+
+- **TokenMix provider.** Added TokenMix as a built-in OpenAI-compatible provider with setup metadata, starter-agent defaults, and provider health checks.
+- **OpenRouter context meters.** Chat context status now uses cached OpenRouter model metadata when available so routed model context windows display accurately.
+- **macOS unsigned artifact fallback.** Desktop releases publish zip-only macOS artifacts when signing/notarization inputs are missing, avoiding the unsigned DMG damaged-app path.
+- **Regression coverage.** Added targeted tests for TokenMix setup, OpenRouter context metadata caching, and macOS target selection.
+
 ## v1.9.37 Highlights
 
 Theme and memory-pressure release for lighter UI preferences and leaner chat history storage.
@@ -479,6 +488,15 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.38 Highlights
+
+PR integration release for provider catalog coverage, OpenRouter context meters, and safer unsigned macOS desktop artifacts.
+
+- **TokenMix provider.** Added TokenMix as a built-in OpenAI-compatible provider with setup metadata, starter-agent defaults, and provider health checks.
+- **OpenRouter context meters.** Chat context status now uses cached OpenRouter model metadata when available so routed model context windows display accurately.
+- **macOS unsigned artifact fallback.** Desktop releases publish zip-only macOS artifacts when signing/notarization inputs are missing, avoiding the unsigned DMG damaged-app path.
+- **Regression coverage.** Added targeted tests for TokenMix setup, OpenRouter context metadata caching, and macOS target selection.
+
 ### v1.9.37 Highlights
 
 Theme and memory-pressure release for lighter UI preferences and leaner chat history storage.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.37",
+  "version": "1.9.38",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package/src/app/api/chats/[id]/context-status/route.ts

@@ -3,6 +3,7 @@ import { getSession } from '@/lib/server/sessions/session-repository'
 import { getMessages } from '@/lib/server/messages/message-repository'
 import { getContextStatus } from '@/lib/server/context-manager'
 import { notFound } from '@/lib/server/collection-helpers'
+import { ensureOpenRouterModelContextCache } from '@/lib/server/openrouter-model-context'
 
 const SYSTEM_PROMPT_TOKEN_ESTIMATE = 2000
 
@@ -11,6 +12,7 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const session = getSession(id)
   if (!session) return notFound()
   const messages = getMessages(id)
+  await ensureOpenRouterModelContextCache(session.provider as string)
   const status = getContextStatus(
     messages,
     SYSTEM_PROMPT_TOKEN_ESTIMATE,

package/src/app/api/chats/context-status-route.test.ts

@@ -66,3 +66,62 @@ test('GET /api/chats/[id]/context-status returns token usage summary', () => {
   assert.ok(['ok', 'warning', 'critical'].includes(output.strategy))
   assert.equal(output.missingStatus, 404)
 })
+
+test('GET /api/chats/[id]/context-status uses OpenRouter model metadata context window', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    contextWindow: number
+  }>(`
+    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 },
+    }))
+
+    globalThis.fetch = async () => {
+      throw new Error('route should use seeded OpenRouter model metadata cache')
+    }
+
+    const storageMod = await import('./src/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const routeMod = await import('./src/app/api/chats/[id]/context-status/route')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+    const route = routeMod.default || routeMod
+
+    const now = Date.now()
+    storage.saveSessions({
+      sess_ctx_openrouter: {
+        id: 'sess_ctx_openrouter',
+        name: 'OpenRouter context status test',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openrouter',
+        model: 'minimax/minimax-m3',
+        claudeSessionId: null,
+        messages: [],
+        createdAt: now,
+        lastActiveAt: now,
+      },
+    })
+
+    repo.appendMessage('sess_ctx_openrouter', { role: 'user', text: 'hello world', time: now })
+
+    const response = await route.GET(
+      new Request('http://local/api/chats/sess_ctx_openrouter/context-status'),
+      { params: Promise.resolve({ id: 'sess_ctx_openrouter' }) },
+    )
+    const payload = await response.json()
+
+    console.log(JSON.stringify({
+      status: response.status,
+      contextWindow: payload.contextWindow,
+    }))
+  `, { prefix: 'swarmclaw-context-status-route-' })
+
+  assert.equal(output.status, 200)
+  assert.equal(output.contextWindow, 524_288)
+  assert.notEqual(output.contextWindow, 8_192)
+})

package/src/app/api/setup/check-provider/route.test.ts

@@ -161,3 +161,15 @@ test('POST returns provider diagnostics with normalized LM Studio targets and re
     globalThis.fetch = originalFetch
   }
 })
+
+test('POST rejects TokenMix setup checks without an API key', async () => {
+  const res = await POST(new Request('http://localhost/api/setup/check-provider', {
+    method: 'POST',
+    body: JSON.stringify({ provider: 'tokenmix' }),
+  }))
+  const payload = await res.json()
+
+  assert.equal(res.status, 200)
+  assert.equal(payload.ok, false)
+  assert.equal(payload.message, 'TokenMix API key is required.')
+})

package/src/app/api/setup/check-provider/route.ts

@@ -501,6 +501,12 @@ export async function POST(req: Request) {
         const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
         return NextResponse.json(result)
       }
+      case 'tokenmix': {
+        if (!apiKey) return NextResponse.json({ ok: false, message: 'TokenMix API key is required.' })
+        const info = OPENAI_COMPATIBLE_DEFAULTS.tokenmix
+        const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
+        return NextResponse.json(result)
+      }
       case 'anthropic': {
         if (!apiKey) return NextResponse.json({ ok: false, message: 'Anthropic API key is required.' })
         const result = await checkAnthropic(apiKey, endpoint, model)

package/src/lib/providers/index.ts

@@ -128,6 +128,29 @@ export const PROVIDERS: Record<string, BuiltinProviderConfig> = {
       },
     },
   },
+  tokenmix: {
+    id: 'tokenmix',
+    name: 'TokenMix',
+    models: [
+      'claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5',
+      'gpt-5.4', 'gpt-5.4-mini',
+      'gemini-2.5-pro', 'gemini-2.5-flash',
+      'deepseek-chat', 'deepseek-reasoner',
+      'qwen-max',
+    ],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.tokenmix.ai/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.tokenmix.ai/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
   anthropic: {
     id: 'anthropic',
     name: 'Anthropic',

package/src/lib/server/context-manager.ts

@@ -2,6 +2,7 @@ import type { Message, Session } from '@/types'
 import { getMemoryDb } from '@/lib/server/memory/memory-db'
 import { extractFactsFromMessages, ensureRunContext, pruneRunContext } from '@/lib/server/run-context'
 import { getSession, saveSession } from '@/lib/server/sessions/session-repository'
+import { getCachedOpenRouterContextWindow } from '@/lib/server/openrouter-model-context'
 
 import { repairTranscriptConsistency } from './transcript-repair'
 
@@ -97,6 +98,9 @@ const PROVIDER_DEFAULT_WINDOWS: Record<string, number> = {
 
 /** Get context window size for a model, falling back to provider default */
 export function getContextWindowSize(provider: string, model: string): number {
+  const openRouterContext = getCachedOpenRouterContextWindow(provider, model)
+  if (openRouterContext) return openRouterContext
+
   return PROVIDER_CONTEXT_WINDOWS[model]
     || PROVIDER_DEFAULT_WINDOWS[provider]
     || 8_192

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/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')

package/src/lib/setup-defaults.ts

@@ -86,6 +86,19 @@ export const SETUP_PROVIDERS: SetupProviderOption[] = [
     icon: 'R',
     modelLibraryUrl: 'https://openrouter.ai/models',
   },
+  {
+    id: 'tokenmix',
+    name: 'TokenMix',
+    description: 'One OpenAI-compatible API relay for Claude, OpenAI, Gemini, DeepSeek, Qwen, and other hosted models.',
+    requiresKey: true,
+    supportsEndpoint: false,
+    defaultEndpoint: 'https://api.tokenmix.ai/v1',
+    keyUrl: 'https://tokenmix.ai',
+    keyLabel: 'tokenmix.ai',
+    badge: 'Catalog',
+    icon: 'T',
+    modelLibraryUrl: 'https://tokenmix.ai/models',
+  },
   {
     id: 'openclaw',
     name: 'OpenClaw',
@@ -781,6 +794,13 @@ export const DEFAULT_AGENTS = {
     model: 'anthropic/claude-sonnet-4.6',
     tools: STARTER_AGENT_TOOLS,
   },
+  tokenmix: {
+    name: 'TokenMix Agent',
+    description: 'A helpful assistant powered through TokenMix.',
+    systemPrompt: SWARMCLAW_ASSISTANT_PROMPT,
+    model: 'claude-sonnet-4-6',
+    tools: STARTER_AGENT_TOOLS,
+  },
   google: {
     name: 'Gemini',
     description: 'A helpful Gemini-powered assistant.',

package/src/types/provider.ts

@@ -1,4 +1,4 @@
-export type ProviderType = 'claude-cli' | 'codex-cli' | 'opencode-cli' | 'opencode-web' | 'gemini-cli' | 'copilot-cli' | 'droid-cli' | 'cursor-cli' | 'qwen-code-cli' | 'goose' | 'aider-cli' | 'amp-cli' | 'augment-cli' | 'adal-cli' | 'bob-cli' | 'cline-cli' | 'codebuddy-cli' | 'command-code-cli' | 'continue-cli' | 'cortex-cli' | 'crush-cli' | 'deepagents-cli' | 'firebender-cli' | 'iflow-cli' | 'junie-cli' | 'kilo-code-cli' | 'kimi-cli' | 'kode-cli' | 'mcpjam-cli' | 'mistral-vibe-cli' | 'mux-cli' | 'neovate-cli' | 'openhands-cli' | 'pochi-cli' | 'qoder-cli' | 'replit-cli' | 'roo-code-cli' | 'trae-cn-cli' | 'warp-cli' | 'windsurf-cli' | 'zencoder-cli' | 'openai' | 'openrouter' | 'ollama' | 'anthropic' | 'openclaw' | 'hermes' | 'lmstudio' | 'google' | 'deepseek' | 'groq' | 'together' | 'mistral' | 'xai' | 'fireworks' | 'nebius' | 'deepinfra'
+export type ProviderType = 'claude-cli' | 'codex-cli' | 'opencode-cli' | 'opencode-web' | 'gemini-cli' | 'copilot-cli' | 'droid-cli' | 'cursor-cli' | 'qwen-code-cli' | 'goose' | 'aider-cli' | 'amp-cli' | 'augment-cli' | 'adal-cli' | 'bob-cli' | 'cline-cli' | 'codebuddy-cli' | 'command-code-cli' | 'continue-cli' | 'cortex-cli' | 'crush-cli' | 'deepagents-cli' | 'firebender-cli' | 'iflow-cli' | 'junie-cli' | 'kilo-code-cli' | 'kimi-cli' | 'kode-cli' | 'mcpjam-cli' | 'mistral-vibe-cli' | 'mux-cli' | 'neovate-cli' | 'openhands-cli' | 'pochi-cli' | 'qoder-cli' | 'replit-cli' | 'roo-code-cli' | 'trae-cn-cli' | 'warp-cli' | 'windsurf-cli' | 'zencoder-cli' | 'openai' | 'openrouter' | 'tokenmix' | 'ollama' | 'anthropic' | 'openclaw' | 'hermes' | 'lmstudio' | 'google' | 'deepseek' | 'groq' | 'together' | 'mistral' | 'xai' | 'fireworks' | 'nebius' | 'deepinfra'
 export type ProviderId = ProviderType | (string & {})
 
 export interface ProviderInfo {