@swarmclawai/swarmclaw 1.9.19 → 1.9.20

package/README.md

@@ -182,7 +182,7 @@ Full hosted deployment guides live at https://swarmclaw.ai/docs/deployment
 
 ## Core Capabilities
 
-- **Providers**: 23 built-in — Claude Code CLI, Codex CLI, OpenCode CLI, Gemini CLI, Copilot CLI, Cursor Agent CLI, Qwen Code CLI, Goose, Anthropic, OpenAI, OpenRouter, Google Gemini, DeepSeek, Groq, Together, Mistral, xAI, Fireworks, Nebius, DeepInfra, Ollama, OpenClaw, and Hermes Agent, plus compatible custom endpoints.
+- **Providers**: 24+ built-in — Claude Code CLI, Codex CLI, OpenCode CLI, Gemini CLI, Copilot CLI, Cursor Agent CLI, Qwen Code CLI, Goose, Anthropic, OpenAI, OpenRouter, Google Gemini, DeepSeek, Groq, Together, Mistral, xAI, Fireworks, Nebius, DeepInfra, Ollama, LM Studio, OpenClaw, and Hermes Agent, plus compatible custom endpoints.
 - **OpenRouter**: <img src="public/provider-logos/openrouter.png" alt="OpenRouter logo" width="20" height="20" /> Use OpenRouter as a first-class built-in provider with its standard OpenAI-compatible endpoint and routed model IDs such as `openai/gpt-4.1-mini`.
 - **Hermes Agent**: <img src="public/provider-logos/hermes-agent.png" alt="Hermes Agent logo" width="20" height="20" /> Connect Hermes through its OpenAI-compatible API server, locally or through a reachable remote `/v1` endpoint.
 - **Delegation**: built-in delegation to Claude Code, Codex CLI, OpenCode CLI, Gemini CLI, Cursor Agent CLI, Qwen Code CLI, and native SwarmClaw subagents.
@@ -407,6 +407,15 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.20 Highlights
+
+Provider reliability release: local OpenAI-compatible runtimes now get safer endpoint handling, clearer setup, and first-class LM Studio support.
+
+- **LM Studio provider.** LM Studio is available in setup, provider settings, agent editing, model discovery, and connection checks with an optional API key.
+- **Endpoint normalization.** LM Studio and OpenAI-compatible OpenAI overrides normalize bare hosts like `http://127.0.0.1:1234` to `/v1` before calling models or chat completions.
+- **Provider switch isolation.** Switching an agent from a local endpoint back to a fixed cloud provider clears stale per-agent endpoints and fallback keys.
+- **Manual model flow.** Provider model saves now preserve explicit empty endpoint resets and optional-key providers can be tested without creating a credential.
+
 ### v1.9.19 Highlights
 
 Output hygiene release: final assistant responses now use the shared internal metadata scrubber before persistence, UI reset, connector delivery, and completion hooks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.19",
+  "version": "1.9.20",
   "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/setup/check-provider/route.ts

@@ -5,6 +5,7 @@ import { getDeviceId, wsConnect, rpcOnConnectedGateway } from '@/lib/providers/o
 import { isCliProviderId } from '@/lib/providers/cli-provider-metadata'
 import { checkCliProviderReady } from '@/lib/server/cli-provider-readiness'
 import { OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
+import { normalizeLmStudioEndpoint, normalizeOpenAiCompatibleV1Endpoint } from '@/lib/providers/openai-compatible-endpoint'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 import { normalizeOllamaSetupEndpoint, normalizeOpenClawUrl, parseErrorMessage } from './helpers'
 
@@ -70,6 +71,7 @@ async function checkOpenAiCompatible(
       DeepInfra: 'deepseek-ai/DeepSeek-R1-0528',
       OpenRouter: 'openai/gpt-4.1-mini',
       'Hermes Agent': 'hermes-agent',
+      'LM Studio': 'local-model',
     }
     testModel = fallbacks[providerName] || 'gpt-4o-mini'
   }
@@ -312,7 +314,13 @@ export async function POST(req: Request) {
       case 'openai': {
         if (!apiKey) return NextResponse.json({ ok: false, message: 'OpenAI API key is required.' })
         const info = OPENAI_COMPATIBLE_DEFAULTS.openai
-        const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
+        const result = await checkOpenAiCompatible(
+          info.name,
+          apiKey,
+          normalizeOpenAiCompatibleV1Endpoint(endpoint || info.defaultEndpoint, info.defaultEndpoint),
+          info.defaultEndpoint,
+          model,
+        )
         return NextResponse.json(result)
       }
       case 'openrouter': {
@@ -345,6 +353,17 @@ export async function POST(req: Request) {
         const result = await checkOpenAiCompatible(info.name, apiKey, endpoint, info.defaultEndpoint, model)
         return NextResponse.json(result)
       }
+      case 'lmstudio': {
+        const info = OPENAI_COMPATIBLE_DEFAULTS.lmstudio
+        const result = await checkOpenAiCompatible(
+          info.name,
+          apiKey,
+          normalizeLmStudioEndpoint(endpoint || info.defaultEndpoint),
+          info.defaultEndpoint,
+          model,
+        )
+        return NextResponse.json(result)
+      }
       case 'ollama': {
         const result = await checkOllama({
           endpointRaw: endpoint,

package/src/components/agents/agent-sheet.tsx

@@ -50,6 +50,7 @@ const AUTO_SYNC_MODEL_PROVIDER_IDS = new Set<ProviderType>([
   'nebius',
   'deepinfra',
   'hermes',
+  'lmstudio',
   'ollama',
 ])
 const CONNECTION_TEST_TIMEOUT_MS = 40_000
@@ -745,6 +746,23 @@ export function AgentSheet() {
     if (!model) setModel('default')
   }
 
+  const applyDirectProviderSelection = (nextProviderId: string) => {
+    const nextProvider = agentSelectableProviders.find((item) => item.id === nextProviderId)
+    const nextCredentials = resolveAgentSelectableProviderCredentials(nextProviderId, credentials, providerConfigs)
+    setProvider(nextProviderId)
+    setModel(nextProvider?.models[0] || '')
+    setCredentialId(nextCredentials[0]?.id || null)
+    setFallbackCredentialIds([])
+    setGatewayProfileId(null)
+    setApiEndpoint(nextProvider?.requiresEndpoint ? nextProvider.defaultEndpoint || null : null)
+    setTestStatus('idle')
+    setTestMessage('')
+    setTestErrorCode(null)
+    setAddingKey(false)
+    setNewKeyName('')
+    setNewKeyValue('')
+  }
+
   const updateRoutingTarget = (targetId: string, patch: Partial<AgentRoutingTarget>) => {
     setRoutingTargets((current) => current.map((target) => (
       target.id === targetId
@@ -778,7 +796,8 @@ export function AgentSheet() {
 
   const handleSave = async () => {
     // For any endpoint, just ensure bare host:port gets a protocol prepended
-    let normalizedEndpoint = apiEndpoint
+    const providerAllowsAgentEndpoint = Boolean(openclawEnabled || currentProvider?.requiresEndpoint || currentProvider?.optionalEndpoint)
+    let normalizedEndpoint = providerAllowsAgentEndpoint ? apiEndpoint : null
     if (normalizedEndpoint) {
       const url = normalizedEndpoint.trim().replace(/\/+$/, '')
       normalizedEndpoint = /^(https?|wss?):\/\//i.test(url) ? url : `http://${url}`
@@ -1543,13 +1562,7 @@ export function AgentSheet() {
             return (
               <button
                 key={p.id}
-                onClick={() => {
-                  setProvider(p.id)
-                  if (!nextCredentials.some((item) => item.id === credentialId)) {
-                    setCredentialId(nextCredentials[0]?.id || null)
-                  }
-                  setGatewayProfileId(null)
-                }}
+                onClick={() => applyDirectProviderSelection(p.id)}
                 className={`relative py-3.5 px-4 rounded-[14px] text-center cursor-pointer transition-all duration-200
                   active:scale-[0.97] text-[14px] font-600 border
                   ${provider === p.id
@@ -1731,7 +1744,7 @@ export function AgentSheet() {
 
       {(currentProvider?.requiresEndpoint || currentProvider?.optionalEndpoint) && (provider !== 'ollama' || ollamaMode === 'local') && (
         <div className="mb-8">
-          <SectionLabel>{provider === 'openclaw' ? 'OpenClaw Endpoint' : provider === 'hermes' ? 'Hermes API Endpoint' : 'Endpoint'}</SectionLabel>
+          <SectionLabel>{provider === 'openclaw' ? 'OpenClaw Endpoint' : provider === 'hermes' ? 'Hermes API Endpoint' : provider === 'lmstudio' ? 'LM Studio Endpoint' : 'Endpoint'}</SectionLabel>
           <input type="text" value={apiEndpoint || ''} onChange={(e) => setApiEndpoint(e.target.value || null)} placeholder={currentProvider.defaultEndpoint || 'http://localhost:11434'} className={`${inputClass} font-mono text-[14px]`} />
           {provider === 'openclaw' && (
             <p className="text-[13px] text-text-3/70 mt-2">The URL of your OpenClaw gateway</p>
@@ -1739,6 +1752,9 @@ export function AgentSheet() {
           {provider === 'hermes' && (
             <p className="text-[13px] text-text-3/70 mt-2">Point this at the Hermes API server, usually <code className="text-text-2">http://127.0.0.1:8642/v1</code>.</p>
           )}
+          {provider === 'lmstudio' && (
+            <p className="text-[13px] text-text-3/70 mt-2">Point this at the LM Studio local server. A bare host is normalized to <code className="text-text-2">/v1</code>.</p>
+          )}
         </div>
       )}
 

package/src/components/auth/setup-wizard/step-agents.tsx

@@ -28,6 +28,7 @@ const SETUP_PROVIDERS_WITH_MODEL_DISCOVERY = new Set([
   'ollama',
   'openclaw',
   'hermes',
+  'lmstudio',
 ])
 
 /* ── Model combobox: search discovered models or type a custom one ── */

package/src/components/auth/setup-wizard/step-connect.tsx

@@ -335,6 +335,12 @@ export function StepConnect({
                 <p className="text-[12px] text-text-3">Use any reachable local or remote API-server endpoint exposed by Hermes.</p>
               </div>
             )}
+            {provider === 'lmstudio' && (
+              <div className="mt-2 space-y-0.5">
+                <p className="text-[12px] text-text-3">LM Studio&apos;s local server defaults to <code className="text-text-2">http://127.0.0.1:1234/v1</code>.</p>
+                <p className="text-[12px] text-text-3">If you paste a host without <code className="text-text-2">/v1</code>, SwarmClaw normalizes it before testing and chat.</p>
+              </div>
+            )}
           </div>
         )}
 

package/src/components/providers/provider-sheet.tsx

@@ -271,7 +271,10 @@ export function ProviderSheet() {
   const modelList = models.split(',').map((m) => m.trim()).filter(Boolean)
   const showApiKey = isBuiltin ? editingBuiltin?.requiresApiKey || editingBuiltin?.optionalApiKey : requiresApiKey
   const canDiscoverModels = Boolean(isBuiltin && editingBuiltin?.supportsModelDiscovery)
-  const showTestButton = Boolean(isBuiltin && showApiKey && credentialId)
+  const showTestButton = Boolean(
+    isBuiltin
+    && (editingBuiltin?.requiresApiKey ? credentialId : (showApiKey || editingBuiltin?.requiresEndpoint || editingBuiltin?.optionalEndpoint)),
+  )
 
   const inputClass = "w-full px-4 py-3.5 rounded-[14px] border border-white/[0.08] bg-surface text-text text-[15px] outline-none transition-all duration-200 placeholder:text-text-3/50 focus-glow"
 

package/src/features/providers/queries.ts

@@ -86,7 +86,7 @@ export function useSaveBuiltinProviderMutation() {
       await api('PUT', `/providers/${id}/models`, { models })
       return api('PUT', `/providers/${id}`, {
         isEnabled,
-        ...(baseUrl ? { baseUrl } : {}),
+        ...(typeof baseUrl === 'string' ? { baseUrl } : {}),
       })
     },
     onSuccess: async () => {

package/src/lib/providers/index.test.ts

@@ -77,6 +77,34 @@ test('builtin provider override records do not surface as custom providers', ()
   assert.equal(output.openAiCount, 1)
 })
 
+test('LM Studio is available as a first-class local OpenAI-compatible provider', () => {
+  const output = runWithTempDataDir<{
+    providerName: string | null
+    defaultEndpoint: string | null
+    requiresApiKey: boolean | null
+    optionalApiKey: boolean | null
+    supportsModelDiscovery: boolean | null
+  }>(`
+    const providersModule = await import('@/lib/providers/index')
+    const providers = providersModule.default || providersModule
+    const provider = providers.getProviderList().find((entry) => entry.id === 'lmstudio')
+
+    console.log(JSON.stringify({
+      providerName: provider?.name ?? null,
+      defaultEndpoint: provider?.defaultEndpoint ?? null,
+      requiresApiKey: provider?.requiresApiKey ?? null,
+      optionalApiKey: provider?.optionalApiKey ?? null,
+      supportsModelDiscovery: provider?.supportsModelDiscovery ?? null,
+    }))
+  `)
+
+  assert.equal(output.providerName, 'LM Studio')
+  assert.equal(output.defaultEndpoint, 'http://127.0.0.1:1234/v1')
+  assert.equal(output.requiresApiKey, false)
+  assert.equal(output.optionalApiKey, true)
+  assert.equal(output.supportsModelDiscovery, true)
+})
+
 test('custom provider resolution includes defaultEndpoint and optionalApiKey', () => {
   const output = runWithTempDataDir<{
     defaultEndpoint: string | null

package/src/lib/providers/index.ts

@@ -14,6 +14,7 @@ import { streamOpenAiChat } from './openai'
 import { streamOllamaChat } from './ollama'
 import { streamAnthropicChat } from './anthropic'
 import { streamOpenClawChat } from './openclaw'
+import { normalizeLmStudioEndpoint, normalizeOpenAiCompatibleV1Endpoint } from './openai-compatible-endpoint'
 import { errorMessage, sleep, jitteredBackoff } from '@/lib/shared-utils'
 import { classifyProviderError } from './error-classification'
 import { log } from '@/lib/server/logger'
@@ -173,6 +174,24 @@ export const PROVIDERS: Record<string, BuiltinProviderConfig> = {
       },
     },
   },
+  lmstudio: {
+    id: 'lmstudio',
+    name: 'LM Studio',
+    models: ['local-model', 'google/gemma-4-e4b'],
+    requiresApiKey: false,
+    optionalApiKey: true,
+    requiresEndpoint: true,
+    defaultEndpoint: 'http://127.0.0.1:1234/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: normalizeLmStudioEndpoint(opts.session.apiEndpoint),
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
   'opencode-cli': {
     id: 'opencode-cli',
     name: 'OpenCode CLI',
@@ -560,22 +579,29 @@ export function getProvider(id: string): BuiltinProviderConfig | null {
   if (builtin) {
     const pConfigs = loadProviderConfigs()
     const pConfig = pConfigs[id]
-    if (pConfig?.baseUrl && pConfig.baseUrl !== builtin.defaultEndpoint) {
-      const originalHandler = builtin.handler
-      return {
-        ...builtin,
-        handler: {
-          streamChat: (opts) => {
-            const patchedSession = {
-              ...opts.session,
-              apiEndpoint: opts.session.apiEndpoint || pConfig.baseUrl,
-            }
-            return originalHandler.streamChat({ ...opts, session: patchedSession })
-          },
+    const originalHandler = builtin.handler
+    return {
+      ...builtin,
+      handler: {
+        streamChat: (opts) => {
+          const configuredEndpoint = typeof pConfig?.baseUrl === 'string' && pConfig.baseUrl.trim()
+            ? normalizeProviderRuntimeEndpoint(id, pConfig.baseUrl)
+            : null
+          const sessionEndpoint = typeof opts.session.apiEndpoint === 'string' && opts.session.apiEndpoint.trim()
+            ? normalizeProviderRuntimeEndpoint(id, opts.session.apiEndpoint)
+            : null
+          const honorsAgentEndpoint = Boolean(builtin.requiresEndpoint || builtin.optionalEndpoint)
+          const apiEndpoint = honorsAgentEndpoint
+            ? sessionEndpoint || configuredEndpoint
+            : configuredEndpoint
+          const patchedSession = {
+            ...opts.session,
+            apiEndpoint: apiEndpoint || undefined,
+          }
+          return originalHandler.streamChat({ ...opts, session: patchedSession })
         },
-      }
+      },
     }
-    return builtin
   }
 
   // Check custom providers
@@ -619,6 +645,12 @@ export function getProvider(id: string): BuiltinProviderConfig | null {
   return null
 }
 
+function normalizeProviderRuntimeEndpoint(providerId: string, endpoint: string): string {
+  if (providerId === 'lmstudio') return normalizeLmStudioEndpoint(endpoint)
+  if (providerId === 'openai') return normalizeOpenAiCompatibleV1Endpoint(endpoint, 'https://api.openai.com/v1')
+  return endpoint.replace(/\/+$/, '')
+}
+
 /**
  * Stream chat with automatic failover to fallback credentials on retryable errors.
  * Falls back through fallbackCredentialIds on 401/429/500/502/503 errors.

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-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 {