@swarmclawai/swarmclaw 1.9.18 → 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,24 @@ 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.
+
+- **Multi-block scrubbing.** Repeated internal metadata payloads are stripped in one pass instead of stopping after the first block.
+- **Malformed prelude cleanup.** When a validated internal block is followed by a malformed internal fragment, the leftover prelude is removed before user-facing text is delivered.
+- **Shared finalizer path.** Post-stream finalization now uses the same metadata scrubber as the chat UI, keeping stored, streamed, and connector-visible output aligned.
+- **Regression coverage.** Tests cover repeated classifier-shape blocks, malformed follow-on fragments, and false-positive protection for malformed text without a prior validated strip.
+
 ### v1.9.18 Highlights
 
 Schedule preflight release: schedules now show server-backed timing forecasts before save, with timezone-aware cron previews and warnings for risky drafts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.18",
+  "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/chat-execution/post-stream-finalization.test.ts

@@ -33,6 +33,28 @@ describe('stripLeakedClassificationJson', () => {
     assert.equal(cleaned.includes('taskIntent'), false)
   })
 
+  it('strips multiple leaked classification JSON blocks', () => {
+    const input = `${VALID_LEAK}\n${VALID_LEAK}\nTask created and delegated.`
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, true)
+    assert.equal(cleaned, 'Task created and delegated.')
+  })
+
+  it('strips a malformed internal prelude after a validated leaked block', () => {
+    const malformedPrelude = [
+      '{',
+      '  "taskIntent": "research",',
+      '  "isBroadGoal":{',
+      '  false,',
+      '  "isLightweightDirectChat": false,',
+      '}',
+    ].join('\n')
+    const input = `${VALID_LEAK}\n${malformedPrelude}\nAll five research bundles reviewed.`
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, true)
+    assert.equal(cleaned, 'All five research bundles reviewed.')
+  })
+
   it('leaves normal assistant text untouched', () => {
     const input = 'Your favorite color is blue.'
     const { cleaned, stripped } = stripLeakedClassificationJson(input)

package/src/lib/server/chat-execution/post-stream-finalization.ts

@@ -8,6 +8,7 @@
 import type { KnowledgeRetrievalTrace, Session, UsageRecord } from '@/types'
 import { log } from '@/lib/server/logger'
 import type { ChatTurnState } from '@/lib/server/chat-execution/chat-turn-state'
+import { stripAllInternalMetadata } from '@/lib/strip-internal-metadata'
 
 const TAG = 'post-stream'
 import { extractSuggestions } from '@/lib/server/suggestions'
@@ -20,7 +21,6 @@ import {
   shouldForceExternalServiceSummary,
 } from '@/lib/server/chat-execution/chat-streaming-utils'
 import {
-  MessageClassificationSchema,
   type MessageClassification,
 } from '@/lib/server/chat-execution/message-classifier'
 import {
@@ -28,48 +28,9 @@ import {
 } from '@/lib/server/chat-execution/stream-continuation'
 import { buildForcedExternalServiceSummary } from '@/lib/server/chat-execution/prompt-builder'
 
-// ---------------------------------------------------------------------------
-// Classification JSON leak detection — strips MessageClassification objects
-// that some models echo verbatim into their response text. Candidate JSON
-// substrings are found by brace-matching, then validated against the actual
-// MessageClassificationSchema — the single source of truth for what a
-// classifier object looks like.
-// ---------------------------------------------------------------------------
-
-/** Returns the index just past the balanced `}` for the `{` at `start`, or -1. */
-function findBalancedObjectEnd(text: string, start: number): number {
-  let depth = 0
-  let inString = false
-  let escape = false
-  for (let i = start; i < text.length; i++) {
-    const ch = text[i]
-    if (escape) { escape = false; continue }
-    if (inString) {
-      if (ch === '\\') escape = true
-      else if (ch === '"') inString = false
-      continue
-    }
-    if (ch === '"') inString = true
-    else if (ch === '{') depth += 1
-    else if (ch === '}') {
-      depth -= 1
-      if (depth === 0) return i + 1
-    }
-  }
-  return -1
-}
-
 export function stripLeakedClassificationJson(text: string): { cleaned: string; stripped: boolean } {
-  for (let i = text.indexOf('{'); i !== -1; i = text.indexOf('{', i + 1)) {
-    const end = findBalancedObjectEnd(text, i)
-    if (end === -1) break
-    let parsed: unknown
-    try { parsed = JSON.parse(text.slice(i, end)) } catch { continue }
-    if (!MessageClassificationSchema.safeParse(parsed).success) continue
-    log.warn(TAG, 'Stripped leaked classification JSON from model output')
-    return { cleaned: (text.slice(0, i) + text.slice(end)).trimStart(), stripped: true }
-  }
-  return { cleaned: text, stripped: false }
+  const cleaned = stripAllInternalMetadata(text)
+  return { cleaned, stripped: cleaned !== text }
 }
 
 // StreamAgentChatResult is defined inline to avoid circular dependency with stream-agent-chat.ts
@@ -174,9 +135,10 @@ export async function finalizeStreamResult(opts: FinalizeStreamResultOpts): Prom
     }
   }
 
-  // Strip leaked classification JSON from model output (e.g. `{ "isDeliverableTask": true, ... }`)
+  // Strip leaked internal metadata from model output (e.g. `{ "isDeliverableTask": true, ... }`)
   const leakResult = stripLeakedClassificationJson(state.fullText)
   if (leakResult.stripped) {
+    log.warn(TAG, 'Stripped leaked internal metadata from model output')
     state.fullText = leakResult.cleaned
     // Emit a reset so the frontend re-renders with the cleaned text
     write(`data: ${JSON.stringify({ t: 'reset', text: leakResult.cleaned })}\n\n`)

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/lib/strip-internal-metadata.test.ts

@@ -64,6 +64,41 @@ describe('stripInternalJson', () => {
     assert.doesNotMatch(result, /isDeliverableTask/)
     assert.match(result, /\{ "foo": "bar" \}/)
   })
+
+  it('removes multiple leading internal JSON blocks', () => {
+    const input = [
+      '{ "isDeliverableTask": true, "confidence": 0.9 }',
+      '{ "factsUpsert": [], "questionsUpsert": [] }',
+      'All queued work is complete.',
+    ].join('\n')
+    assert.equal(stripInternalJson(input), 'All queued work is complete.')
+  })
+
+  it('removes a malformed internal prelude only after a strict leading strip', () => {
+    const input = [
+      '{ "isDeliverableTask": true, "confidence": 0.9 }',
+      '{',
+      '  "taskIntent": "research",',
+      '  "isBroadGoal":{',
+      '  false,',
+      '  "isLightweightDirectChat": false,',
+      '}',
+      'All queued work is complete.',
+    ].join('\n')
+    assert.equal(stripInternalJson(input), 'All queued work is complete.')
+  })
+
+  it('preserves malformed internal-looking text without a strict leading strip', () => {
+    const input = [
+      '{',
+      '  "taskIntent": "research",',
+      '  "isBroadGoal":{',
+      '  false,',
+      '}',
+      'Visible answer.',
+    ].join('\n')
+    assert.equal(stripInternalJson(input), input)
+  })
 })
 
 // ---------------------------------------------------------------------------

package/src/lib/strip-internal-metadata.ts

@@ -25,6 +25,9 @@ const INTERNAL_JSON_KEYS = [
 
 export const INTERNAL_KEY_RE = new RegExp(`"(?:${INTERNAL_JSON_KEYS.join('|')})"`)
 
+const TaskIntentLikeSchema = z.enum(['coding', 'research', 'browsing', 'outreach', 'scheduling', 'general']).optional()
+const WorkTypeLikeSchema = z.enum(['coding', 'research', 'writing', 'review', 'operations', 'general']).optional()
+
 const WorkingStatePatchLikeSchema = z.object({
   factsUpsert: z.array(z.unknown()).optional(),
   artifactsUpsert: z.array(z.unknown()).optional(),
@@ -37,13 +40,15 @@ const WorkingStatePatchLikeSchema = z.object({
 }).passthrough()
 
 const MessageClassificationLikeSchema = z.object({
-  taskIntent: z.string().optional(),
+  taskIntent: TaskIntentLikeSchema,
   isLightweightDirectChat: z.boolean().optional(),
   isDeliverableTask: z.boolean().optional(),
   isBroadGoal: z.boolean().optional(),
   hasHumanSignals: z.boolean().optional(),
+  hasSignificantEvent: z.boolean().optional(),
   explicitToolRequests: z.array(z.unknown()).optional(),
   isResearchSynthesis: z.boolean().optional(),
+  workType: WorkTypeLikeSchema,
   confidence: z.number().optional(),
 }).passthrough()
 
@@ -104,6 +109,13 @@ function objectIsInternalMetadata(obj: Record<string, unknown>): boolean {
   return false
 }
 
+function isDistinctiveInternalKey(key: string): boolean {
+  for (const { distinctiveKeys } of INTERNAL_PAYLOAD_RULES) {
+    if (distinctiveKeys.includes(key)) return true
+  }
+  return false
+}
+
 function findBalancedJsonObjectEnd(text: string, start: number): number {
   if (text.charAt(start) !== '{') return -1
   let depth = 0
@@ -130,6 +142,109 @@ function findBalancedJsonObjectEnd(text: string, start: number): number {
   return -1
 }
 
+function parseQuotedKeyAt(text: string, start: number): { key: string; end: number } | null {
+  if (text.charAt(start) !== '"') return null
+  let key = ''
+  let escaped = false
+  for (let i = start + 1; i < text.length; i += 1) {
+    const c = text.charAt(i)
+    if (escaped) {
+      key += c
+      escaped = false
+      continue
+    }
+    if (c === '\\') {
+      escaped = true
+      continue
+    }
+    if (c !== '"') {
+      key += c
+      continue
+    }
+    let cursor = i + 1
+    while (cursor < text.length && /\s/.test(text.charAt(cursor))) cursor += 1
+    if (text.charAt(cursor) !== ':') return null
+    return { key, end: cursor + 1 }
+  }
+  return null
+}
+
+function lineHasDistinctiveInternalKey(line: string): boolean {
+  for (let i = 0; i < line.length; i += 1) {
+    const parsed = parseQuotedKeyAt(line, i)
+    if (!parsed) continue
+    if (isDistinctiveInternalKey(parsed.key)) return true
+    i = parsed.end - 1
+  }
+  return false
+}
+
+function startsWithJsonLiteral(text: string, value: string): boolean {
+  if (!text.startsWith(value)) return false
+  const next = text.charAt(value.length)
+  return next === '' || next === ',' || next === '}' || next === ']' || /\s/.test(next)
+}
+
+function isMalformedJsonFragmentLine(line: string): boolean {
+  const trimmed = line.trim()
+  if (!trimmed) return true
+  const first = trimmed.charAt(0)
+  if (first === '{' || first === '}' || first === '[' || first === ']' || first === '"' || first === ',' || first === ':') {
+    return true
+  }
+  if (startsWithJsonLiteral(trimmed, 'true')) return true
+  if (startsWithJsonLiteral(trimmed, 'false')) return true
+  if (startsWithJsonLiteral(trimmed, 'null')) return true
+  if (trimmed.startsWith('...')) return true
+  return false
+}
+
+function findInlineVisibleTextAfterClosingBrace(line: string): number {
+  for (let i = 0; i < line.length; i += 1) {
+    if (line.charAt(i) !== '}') continue
+    let cursor = i + 1
+    while (cursor < line.length && /\s/.test(line.charAt(cursor))) cursor += 1
+    const next = line.charAt(cursor)
+    if (!next || next === ',' || next === '}' || next === ']') continue
+    return i + 1
+  }
+  return -1
+}
+
+function findMalformedInternalPreludeEnd(text: string): number {
+  let leading = 0
+  while (leading < text.length && /\s/.test(text.charAt(leading))) leading += 1
+  if (text.charAt(leading) !== '{') return -1
+
+  let cursor = leading
+  let sawDistinctiveKey = false
+  let consumedEnd = -1
+  while (cursor < text.length) {
+    const newlineAt = text.indexOf('\n', cursor)
+    const lineEnd = newlineAt === -1 ? text.length : newlineAt
+    const line = text.slice(cursor, lineEnd)
+    if (lineHasDistinctiveInternalKey(line)) sawDistinctiveKey = true
+
+    if (!isMalformedJsonFragmentLine(line)) {
+      return sawDistinctiveKey && consumedEnd > leading ? consumedEnd : -1
+    }
+
+    const inlineEnd = sawDistinctiveKey ? findInlineVisibleTextAfterClosingBrace(line) : -1
+    if (inlineEnd >= 0) return cursor + inlineEnd
+
+    consumedEnd = newlineAt === -1 ? lineEnd : lineEnd + 1
+    cursor = consumedEnd
+  }
+
+  return -1
+}
+
+function stripMalformedInternalPreludeAfterStrictStrip(text: string): string {
+  const end = findMalformedInternalPreludeEnd(text)
+  if (end < 0) return text
+  return text.slice(end).trimStart()
+}
+
 /**
  * Remove top-level `{ ... }` blocks that contain known internal classification keys.
  * Handles nested and multi-line JSON. Only strips blocks where at least one
@@ -137,6 +252,7 @@ function findBalancedJsonObjectEnd(text: string, start: number): number {
  */
 export function stripInternalJson(text: string): string {
   let out = text || ''
+  let removedLeadingInternalJson = false
   for (let guard = 0; guard < 32; guard += 1) {
     let removed = false
     for (let i = 0; i < out.length; i += 1) {
@@ -152,12 +268,16 @@ export function stripInternalJson(text: string): string {
       }
       if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) continue
       if (!objectIsInternalMetadata(parsed as Record<string, unknown>)) continue
+      if (!out.slice(0, i).trim()) removedLeadingInternalJson = true
       out = (out.slice(0, i).replace(/\s+$/, '') + ' ' + out.slice(end).replace(/^\s+/, '')).trim()
       removed = true
       break
     }
     if (!removed) break
   }
+  if (removedLeadingInternalJson) {
+    out = stripMalformedInternalPreludeAfterStrictStrip(out)
+  }
   return out
 }
 

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 {