@swarmclawai/swarmclaw 1.9.19 → 1.9.21

package/src/lib/providers/openai-compatible-endpoint.ts

@@ -0,0 +1,67 @@
+const DEFAULT_LM_STUDIO_ENDPOINT = 'http://127.0.0.1:1234/v1'
+
+const OPENAI_COMPATIBLE_ENDPOINT_SUFFIXES = [
+  '/chat/completions',
+  '/responses',
+  '/models',
+  '/completions',
+  '/embeddings',
+]
+
+function clean(value: string | null | undefined): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function trimTrailingSlashes(value: string): string {
+  let output = value
+  while (output.endsWith('/') && output.length > 1) output = output.slice(0, -1)
+  return output
+}
+
+function toUrl(value: string): URL | null {
+  const trimmed = clean(value)
+  if (!trimmed) return null
+  try {
+    return new URL(trimmed)
+  } catch {
+    try {
+      return new URL(`http://${trimmed}`)
+    } catch {
+      return null
+    }
+  }
+}
+
+function stripKnownEndpointPath(pathname: string): string {
+  let path = trimTrailingSlashes(pathname || '/')
+  const lower = path.toLowerCase()
+  for (const suffix of OPENAI_COMPATIBLE_ENDPOINT_SUFFIXES) {
+    if (lower === suffix || lower.endsWith(suffix)) {
+      path = path.slice(0, path.length - suffix.length)
+      break
+    }
+  }
+  path = trimTrailingSlashes(path)
+  return path || '/'
+}
+
+export function normalizeOpenAiCompatibleV1Endpoint(
+  input: string | null | undefined,
+  fallback = DEFAULT_LM_STUDIO_ENDPOINT,
+): string {
+  const parsed = toUrl(clean(input) || fallback) || toUrl(fallback)
+  if (!parsed) return trimTrailingSlashes(clean(input) || fallback)
+
+  const cleanedPath = stripKnownEndpointPath(parsed.pathname)
+  parsed.pathname = cleanedPath.toLowerCase().endsWith('/v1')
+    ? cleanedPath
+    : `${cleanedPath === '/' ? '' : cleanedPath}/v1`
+  parsed.search = ''
+  parsed.hash = ''
+  return trimTrailingSlashes(parsed.toString())
+}
+
+export function normalizeLmStudioEndpoint(input?: string | null): string {
+  return normalizeOpenAiCompatibleV1Endpoint(input, DEFAULT_LM_STUDIO_ENDPOINT)
+}
+

package/src/lib/providers/openai.ts

@@ -7,6 +7,7 @@ import {
   createReasoningContentMetadata,
   shouldUseDeepSeekReasoningBridge,
 } from '@/lib/providers/deepseek-reasoning-chat-openai'
+import { normalizeLmStudioEndpoint, normalizeOpenAiCompatibleV1Endpoint } from '@/lib/providers/openai-compatible-endpoint'
 
 const TAG = 'provider-openai'
 
@@ -58,7 +59,11 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
         let fullResponse = ''
 
         // Support custom base URLs for custom providers
-        const baseUrl = session.apiEndpoint || PROVIDER_DEFAULTS.openai
+        const baseUrl = session.provider === 'lmstudio'
+          ? normalizeLmStudioEndpoint(session.apiEndpoint)
+          : session.provider === 'openai'
+            ? normalizeOpenAiCompatibleV1Endpoint(session.apiEndpoint, PROVIDER_DEFAULTS.openai)
+            : session.apiEndpoint || PROVIDER_DEFAULTS.openai
         const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`
 
         // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware

package/src/lib/server/build-llm.test.ts

@@ -263,6 +263,42 @@ test('buildChatModel uses a reasoning_content-preserving bridge for DeepSeek', (
   assert.equal(completionBridge.completions?.constructor?.name, 'DeepSeekReasoningChatOpenAICompletions')
 })
 
+test('buildChatModel ignores stale per-agent endpoints for fixed cloud providers', () => {
+  const llm = buildChatModel({
+    provider: 'deepseek',
+    model: 'deepseek-chat',
+    apiKey: 'deepseek-key',
+    apiEndpoint: 'http://127.0.0.1:1234/v1',
+  }) as ChatOpenAI
+
+  assert.equal(llm.model, 'deepseek-chat')
+  assert.equal(llm.clientConfig?.baseURL, 'https://api.deepseek.com/v1')
+})
+
+test('buildChatModel normalizes OpenAI-compatible OpenAI overrides to the v1 API', () => {
+  const llm = buildChatModel({
+    provider: 'openai',
+    model: 'google/gemma-4-e4b',
+    apiKey: 'local-key',
+    apiEndpoint: 'http://10.2.0.2:1234',
+  }) as ChatOpenAI
+
+  assert.equal(llm.model, 'google/gemma-4-e4b')
+  assert.equal(llm.clientConfig?.baseURL, 'http://10.2.0.2:1234/v1')
+})
+
+test('buildChatModel normalizes LM Studio base URLs to the OpenAI-compatible v1 API', () => {
+  const llm = buildChatModel({
+    provider: 'lmstudio',
+    model: 'google/gemma-4-e4b',
+    apiKey: 'lm-studio-key',
+    apiEndpoint: 'http://10.2.0.2:1234',
+  }) as ChatOpenAI
+
+  assert.equal(llm.model, 'google/gemma-4-e4b')
+  assert.equal(llm.clientConfig?.baseURL, 'http://10.2.0.2:1234/v1')
+})
+
 test('buildChatModel uses Ollama Cloud only when explicit cloud mode is selected', () => {
   saveCredentials({
     'cred-1': {

package/src/lib/server/build-llm.ts

@@ -74,7 +74,15 @@ export function buildChatModel(opts: {
   const resolvedApiKey = apiKey ?? resolveApiKeyFromCredential(resolvedCredentialId)
   const providers = getProviderList()
   const providerInfo = providers.find((p) => p.id === provider)
-  const endpointRaw = apiEndpoint || providerInfo?.defaultEndpoint || null
+  const endpointRaw = provider === 'ollama'
+    ? apiEndpoint || providerInfo?.defaultEndpoint || null
+    : resolveProviderApiEndpoint({
+      provider,
+      model,
+      ollamaMode: ollamaMode ?? null,
+      credentialId: resolvedCredentialId,
+      apiEndpoint,
+    }) || providerInfo?.defaultEndpoint || null
   const endpoint = provider === 'openclaw'
     ? normalizeOpenClawEndpoint(endpointRaw)
     : endpointRaw

package/src/lib/server/provider-diagnostics.test.ts

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import {
+  createProviderDiagnostics,
+  sanitizeProviderDiagnosticTarget,
+  sanitizeProviderDiagnosticText,
+} from './provider-diagnostics'
+
+test('provider diagnostics records sanitized ordered steps', () => {
+  const diagnostics = createProviderDiagnostics()
+  diagnostics.pass('Endpoint resolved', { target: 'http://user:pass@127.0.0.1:1234/v1/models?token=sk-secret' })
+  diagnostics.fail('Chat failed', { detail: 'Malformed token sk-abc123456789 provided', durationMs: 12.4 })
+
+  const steps = diagnostics.toJSON()
+  assert.equal(steps.length, 2)
+  assert.deepEqual(
+    steps.map((step) => step.id),
+    ['diag-1', 'diag-2'],
+  )
+  assert.equal(steps[0].status, 'pass')
+  assert.equal(steps[0].target, 'http://127.0.0.1:1234/v1/models')
+  assert.equal(steps[1].detail, 'Malformed token sk-... provided')
+  assert.equal(steps[1].durationMs, 12)
+})
+
+test('sanitizeProviderDiagnosticText redacts common provider token prefixes', () => {
+  assert.equal(
+    sanitizeProviderDiagnosticText('bad keys: sk-test123 gsk_live456 hf_token789 AIzaSySecret'),
+    'bad keys: sk-... gsk_... hf_... AIza...',
+  )
+})
+
+test('sanitizeProviderDiagnosticTarget removes credentials, query, and hash from URLs', () => {
+  assert.equal(
+    sanitizeProviderDiagnosticTarget('https://user:secret@example.com/v1/models?api_key=sk-secret#frag'),
+    'https://example.com/v1/models',
+  )
+})

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

@@ -0,0 +1,114 @@
+import type { ProviderDiagnosticStatus, ProviderDiagnosticStep } from '@/types/provider'
+
+const SECRET_PREFIXES = [
+  'sk-',
+  'sk_',
+  'gsk_',
+  'hf_',
+  'xai-',
+  'or-',
+  'pat_',
+  'ghp_',
+  'gho_',
+  'AIza',
+]
+
+const MAX_DETAIL_LENGTH = 300
+const MAX_TARGET_LENGTH = 220
+
+function isSecretBoundary(char: string | undefined): boolean {
+  if (!char) return true
+  return char === ' ' || char === '\n' || char === '\r' || char === '\t'
+    || char === '"' || char === "'" || char === '`'
+    || char === ',' || char === ';' || char === ')' || char === ']'
+    || char === '}' || char === '<' || char === '>'
+}
+
+export function sanitizeProviderDiagnosticText(value: unknown, maxLength = MAX_DETAIL_LENGTH): string {
+  const input = typeof value === 'string' ? value : String(value ?? '')
+  let out = ''
+  for (let i = 0; i < input.length;) {
+    const prefix = SECRET_PREFIXES.find((candidate) => input.startsWith(candidate, i))
+    if (!prefix) {
+      out += input[i]
+      i++
+      continue
+    }
+
+    let end = i + prefix.length
+    while (end < input.length && !isSecretBoundary(input[end]) && end - i < 160) end++
+    out += `${prefix}...`
+    i = end
+  }
+  const collapsed = out.split(/\s+/).join(' ').trim()
+  return collapsed.length > maxLength ? `${collapsed.slice(0, Math.max(0, maxLength - 1))}...` : collapsed
+}
+
+export function sanitizeProviderDiagnosticTarget(value: unknown): string {
+  const raw = sanitizeProviderDiagnosticText(value, MAX_TARGET_LENGTH)
+  try {
+    const url = new URL(raw)
+    url.username = ''
+    url.password = ''
+    url.search = ''
+    url.hash = ''
+    return sanitizeProviderDiagnosticText(url.toString(), MAX_TARGET_LENGTH)
+  } catch {
+    return raw
+  }
+}
+
+export interface ProviderDiagnostics {
+  add: (
+    label: string,
+    status: ProviderDiagnosticStatus,
+    options?: {
+      detail?: unknown
+      target?: unknown
+      durationMs?: number
+    },
+  ) => ProviderDiagnosticStep
+  pass: (label: string, options?: { detail?: unknown; target?: unknown; durationMs?: number }) => ProviderDiagnosticStep
+  warn: (label: string, options?: { detail?: unknown; target?: unknown; durationMs?: number }) => ProviderDiagnosticStep
+  fail: (label: string, options?: { detail?: unknown; target?: unknown; durationMs?: number }) => ProviderDiagnosticStep
+  toJSON: () => ProviderDiagnosticStep[]
+}
+
+export function createProviderDiagnostics(): ProviderDiagnostics {
+  const steps: ProviderDiagnosticStep[] = []
+  let sequence = 0
+
+  function add(
+    label: string,
+    status: ProviderDiagnosticStatus,
+    options: {
+      detail?: unknown
+      target?: unknown
+      durationMs?: number
+    } = {},
+  ): ProviderDiagnosticStep {
+    sequence++
+    const step: ProviderDiagnosticStep = {
+      id: `diag-${sequence}`,
+      label: sanitizeProviderDiagnosticText(label, 80),
+      status,
+    }
+    const detail = sanitizeProviderDiagnosticText(options.detail, MAX_DETAIL_LENGTH)
+    const target = sanitizeProviderDiagnosticTarget(options.target)
+    if (detail) step.detail = detail
+    if (target) step.target = target
+    if (typeof options.durationMs === 'number' && Number.isFinite(options.durationMs)) {
+      step.durationMs = Math.max(0, Math.round(options.durationMs))
+    }
+    steps.push(step)
+    return step
+  }
+
+  return {
+    add,
+    pass: (label, options) => add(label, 'pass', options),
+    warn: (label, options) => add(label, 'warn', options),
+    fail: (label, options) => add(label, 'fail', options),
+    toJSON: () => steps.map((step) => ({ ...step })),
+  }
+}

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

@@ -1,5 +1,6 @@
 import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { getProvider } from '@/lib/providers'
+import { normalizeLmStudioEndpoint, normalizeOpenAiCompatibleV1Endpoint } from '@/lib/providers/openai-compatible-endpoint'
 import { loadCredential } from '@/lib/server/credentials/credential-repository'
 import { listCredentialIdsByProvider, resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
@@ -71,8 +72,17 @@ export function resolveProviderApiEndpoint(input: {
   const provider = clean(input.provider)
   if (!provider) return null
 
-  const explicitEndpoint = normalizeProviderEndpoint(provider, input.apiEndpoint ?? null)
-  if (explicitEndpoint) return explicitEndpoint
+  const pConfigs = loadProviderConfigs()
+  const pConfig = pConfigs[provider]
+  const providerInfo = getProvider(provider)
+  const honorsAgentEndpoint = Boolean(
+    pConfig?.type === 'custom'
+    || providerInfo?.requiresEndpoint
+    || providerInfo?.optionalEndpoint,
+  )
+
+  const explicitEndpoint = normalizeRuntimeEndpoint(provider, input.apiEndpoint ?? null)
+  if (explicitEndpoint && honorsAgentEndpoint) return explicitEndpoint
 
   if (provider === 'ollama') {
     const credentialId = resolveProviderCredentialId(input)
@@ -86,15 +96,24 @@ export function resolveProviderApiEndpoint(input: {
   }
 
   // Prefer provider config's custom baseUrl over the hardcoded defaultEndpoint
-  const pConfigs = loadProviderConfigs()
-  const pConfig = pConfigs[provider]
   if (pConfig?.baseUrl) {
-    const customNormalized = normalizeProviderEndpoint(provider, pConfig.baseUrl)
+    const customNormalized = normalizeRuntimeEndpoint(provider, pConfig.baseUrl)
     if (customNormalized) return customNormalized
     return pConfig.baseUrl.replace(/\/+$/, '')
   }
 
-  const providerInfo = getProvider(provider)
   if (!providerInfo?.defaultEndpoint) return null
-  return normalizeProviderEndpoint(provider, providerInfo.defaultEndpoint) || providerInfo.defaultEndpoint.replace(/\/+$/, '')
+  return normalizeRuntimeEndpoint(provider, providerInfo.defaultEndpoint) || providerInfo.defaultEndpoint.replace(/\/+$/, '')
+}
+
+function normalizeRuntimeEndpoint(provider: string, endpoint: string | null | undefined): string | null {
+  if (provider === 'lmstudio') {
+    const value = typeof endpoint === 'string' ? endpoint.trim() : ''
+    return value ? normalizeLmStudioEndpoint(value) : null
+  }
+  if (provider === 'openai') {
+    const value = typeof endpoint === 'string' ? endpoint.trim() : ''
+    return value ? normalizeOpenAiCompatibleV1Endpoint(value, 'https://api.openai.com/v1') : null
+  }
+  return normalizeProviderEndpoint(provider, endpoint)
 }

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

@@ -129,12 +129,13 @@ describe('provider-health', () => {
     assert.ok(defaults.xai)
     assert.ok(defaults.fireworks)
     assert.ok(defaults.hermes)
+    assert.ok(defaults.lmstudio)
 
     // Each entry has name and defaultEndpoint
     for (const [key, val] of Object.entries(defaults)) {
       assert.ok(typeof val.name === 'string' && val.name.length > 0)
       assert.ok(typeof val.defaultEndpoint === 'string' && val.defaultEndpoint.length > 0)
-      if (key === 'hermes') {
+      if (key === 'hermes' || key === 'lmstudio') {
         assert.ok(val.defaultEndpoint.startsWith('http://'))
       } else {
         assert.ok(val.defaultEndpoint.startsWith('https://'))

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

@@ -3,6 +3,7 @@ import { errorMessage, hmrSingleton, jitteredBackoff } from '@/lib/shared-utils'
 import { upsertStoredItem, loadCollection } from './storage'
 import { log } from './logger'
 import { isCliProviderId } from '@/lib/providers/cli-provider-metadata'
+import { normalizeLmStudioEndpoint, normalizeOpenAiCompatibleV1Endpoint } from '@/lib/providers/openai-compatible-endpoint'
 
 const TAG = 'provider-health'
 
@@ -270,6 +271,7 @@ export const OPENAI_COMPATIBLE_DEFAULTS: Record<string, { name: string; defaultE
   nebius: { name: 'Nebius', defaultEndpoint: 'https://api.tokenfactory.nebius.com/v1' },
   deepinfra: { name: 'DeepInfra', defaultEndpoint: 'https://api.deepinfra.com/v1/openai' },
   hermes: { name: 'Hermes Agent', defaultEndpoint: 'http://127.0.0.1:8642/v1' },
+  lmstudio: { name: 'LM Studio', defaultEndpoint: 'http://127.0.0.1:1234/v1' },
 }
 
 export async function pingOpenAiCompatible(
@@ -353,7 +355,7 @@ export async function pingProvider(
   apiKey: string | undefined,
   endpoint: string | undefined,
 ): Promise<{ ok: boolean; message: string }> {
-  const OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS = new Set(['hermes'])
+  const OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS = new Set(['hermes', 'lmstudio'])
   if (isCliProviderId(provider)) return { ok: true, message: 'CLI provider - skipped.' }
 
   try {
@@ -369,7 +371,11 @@ export async function pingProvider(
     }
     // OpenAI-compatible providers (openai, google, deepseek, groq, together, mistral, xai, fireworks, custom)
     const defaults = OPENAI_COMPATIBLE_DEFAULTS[provider]
-    const resolvedEndpoint = endpoint || defaults?.defaultEndpoint
+    const resolvedEndpoint = provider === 'lmstudio'
+      ? normalizeLmStudioEndpoint(endpoint || defaults?.defaultEndpoint)
+      : provider === 'openai'
+        ? normalizeOpenAiCompatibleV1Endpoint(endpoint || defaults?.defaultEndpoint, defaults?.defaultEndpoint || 'https://api.openai.com/v1')
+        : endpoint || defaults?.defaultEndpoint
     if (!resolvedEndpoint) return { ok: false, message: `No endpoint for provider "${provider}".` }
     if (!apiKey && !OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS.has(provider)) return { ok: false, message: 'No API key configured.' }
     return await pingOpenAiCompatible(apiKey, resolvedEndpoint)

package/src/lib/server/provider-model-discovery.test.ts

@@ -218,6 +218,16 @@ test('resolveDescriptor uses OpenRouter as an OpenAI-compatible provider', () =>
   assert.equal(descriptor?.optionalApiKey, false)
 })
 
+test('resolveDescriptor normalizes OpenAI-compatible OpenAI endpoints to /v1', () => {
+  const descriptor = resolveDescriptor({
+    providerId: 'openai',
+    endpoint: 'http://10.2.0.2:1234',
+  })
+  assert.equal(descriptor?.strategy, 'openai-compatible')
+  assert.equal(descriptor?.endpoint, 'http://10.2.0.2:1234/v1')
+  assert.equal(descriptor?.requiresApiKey, true)
+})
+
 test('resolveDescriptor uses Hermes as an OpenAI-compatible provider with optional auth', () => {
   const descriptor = resolveDescriptor({
     providerId: 'hermes',
@@ -228,6 +238,17 @@ test('resolveDescriptor uses Hermes as an OpenAI-compatible provider with option
   assert.equal(descriptor?.optionalApiKey, true)
 })
 
+test('resolveDescriptor normalizes LM Studio discovery endpoints to /v1 with optional auth', () => {
+  const descriptor = resolveDescriptor({
+    providerId: 'lmstudio',
+    endpoint: 'http://10.2.0.2:1234',
+  })
+  assert.equal(descriptor?.strategy, 'openai-compatible')
+  assert.equal(descriptor?.endpoint, 'http://10.2.0.2:1234/v1')
+  assert.equal(descriptor?.requiresApiKey, false)
+  assert.equal(descriptor?.optionalApiKey, true)
+})
+
 test('resolveDescriptor disables model discovery for local CLI-backed providers without live model catalogs', () => {
   for (const providerId of ['copilot-cli', 'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose']) {
     const descriptor = resolveDescriptor({ providerId })

package/src/lib/server/provider-model-discovery.ts

@@ -4,6 +4,7 @@ import { getProviderList } from '@/lib/providers'
 import { isOllamaCloudEndpoint, resolveStoredOllamaMode } from '@/lib/ollama-mode'
 import { OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 import { resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
+import { normalizeLmStudioEndpoint, normalizeOpenAiCompatibleV1Endpoint } from '@/lib/providers/openai-compatible-endpoint'
 import type { ProviderInfo, ProviderModelDiscoveryResult } from '@/types'
 
 type DiscoveryStrategy = 'openai-compatible' | 'anthropic' | 'google' | 'ollama' | 'openclaw'
@@ -164,7 +165,11 @@ export function resolveDescriptor(input: DiscoverProviderModelsInput): Discovery
   }
 
   const openAiDefault = OPENAI_COMPATIBLE_DEFAULTS[providerId as keyof typeof OPENAI_COMPATIBLE_DEFAULTS]?.defaultEndpoint
-  const endpoint = normalizeEndpoint(input.endpoint, provider.defaultEndpoint || openAiDefault || '')
+  const endpoint = providerId === 'lmstudio'
+    ? normalizeLmStudioEndpoint(input.endpoint || provider.defaultEndpoint || openAiDefault || '')
+    : providerId === 'openai'
+      ? normalizeOpenAiCompatibleV1Endpoint(input.endpoint || provider.defaultEndpoint || openAiDefault || '', openAiDefault || 'https://api.openai.com/v1')
+      : normalizeEndpoint(input.endpoint, provider.defaultEndpoint || openAiDefault || '')
   return {
     providerId,
     providerName: provider.name,

package/src/lib/setup-defaults.ts

@@ -112,6 +112,20 @@ export const SETUP_PROVIDERS: SetupProviderOption[] = [
     icon: 'H',
     category: 'gateway',
   },
+  {
+    id: 'lmstudio',
+    name: 'LM Studio',
+    description: 'Use locally served LM Studio models through the OpenAI-compatible API.',
+    requiresKey: false,
+    supportsEndpoint: true,
+    allowMultiple: true,
+    defaultEndpoint: 'http://127.0.0.1:1234/v1',
+    optionalKey: true,
+    badge: 'Local API',
+    icon: 'L',
+    modelLibraryUrl: 'https://lmstudio.ai/docs/developer/openai-compat',
+    category: 'local',
+  },
   {
     id: 'anthropic',
     name: 'Anthropic',
@@ -851,6 +865,13 @@ export const DEFAULT_AGENTS = {
     model: 'hermes-agent',
     tools: STARTER_AGENT_TOOLS,
   },
+  lmstudio: {
+    name: 'LM Studio',
+    description: 'A local assistant running through LM Studio.',
+    systemPrompt: SWARMCLAW_ASSISTANT_PROMPT,
+    model: 'local-model',
+    tools: STARTER_AGENT_TOOLS,
+  },
   custom: {
     name: 'Custom Agent',
     description: 'An assistant powered by a custom OpenAI-compatible provider.',

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' | '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' | 'ollama' | 'anthropic' | 'openclaw' | 'hermes' | 'lmstudio' | 'google' | 'deepseek' | 'groq' | 'together' | 'mistral' | 'xai' | 'fireworks' | 'nebius' | 'deepinfra'
 export type ProviderId = ProviderType | (string & {})
 
 export interface ProviderInfo {
@@ -28,6 +28,27 @@ export interface ProviderModelDiscoveryResult {
   message?: string
 }
 
+export type ProviderDiagnosticStatus = 'pass' | 'warn' | 'fail'
+
+export interface ProviderDiagnosticStep {
+  id: string
+  label: string
+  status: ProviderDiagnosticStatus
+  detail?: string
+  target?: string
+  durationMs?: number
+}
+
+export interface ProviderCheckResult {
+  ok: boolean
+  message: string
+  normalizedEndpoint?: string
+  recommendedModel?: string
+  errorCode?: string
+  deviceId?: string
+  diagnostics?: ProviderDiagnosticStep[]
+}
+
 export interface Credential {
   id: string
   provider: string