Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

Add LM Studio provider support

Alishahryar1b83be84313d9
diff --git a/.env.example b/.env.example
index 07ccf0a3..085da7a4 100644
--- a/.env.example
+++ b/.env.example
@@ -1,4 +1,4 @@
-# Provider: "nvidia_nim" | "open_router"
+# Provider: "nvidia_nim" | "open_router" | "lmstudio"
PROVIDER_TYPE=nvidia_nim
PROVIDER_RATE_LIMIT=40
PROVIDER_RATE_WINDOW=60
@@ -13,6 +13,9 @@ NVIDIA_NIM_API_KEY=""
# OpenRouter Config
OPENROUTER_API_KEY=""
+# LM Studio Config (local provider, no API key required)
+LM_STUDIO_BASE_URL="http://localhost:1234/v1"
+
# Telegram Config
TELEGRAM_BOT_TOKEN=""
diff --git a/README.md b/README.md
index 6dfc04b1..dff10b16 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
# 🚀 Free Claude Code
-### Use Claude Code for free with NVIDIA NIM or OpenRouter
+### Use Claude Code for free with NVIDIA NIM, OpenRouter, or LM Studio
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
[![Python 3.14](https://img.shields.io/badge/python-3.14-3776ab.svg?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/downloads/)
@@ -12,7 +12,7 @@
[![Code style: Ruff](https://img.shields.io/badge/code%20formatting-ruff-f5a623.svg?style=for-the-badge)](https://github.com/astral-sh/ruff)
[![Logging: Loguru](https://img.shields.io/badge/logging-loguru-4ecdc4.svg?style=for-the-badge)](https://github.com/Delgan/loguru)
-A lightweight proxy that converts Claude Code's Anthropic API requests to NVIDIA NIM or OpenRouter format.
+A lightweight proxy that converts Claude Code's Anthropic API requests to NVIDIA NIM, OpenRouter, or LM Studio format.
**40 reqs/min free** · **Provider switching** · **Telegram bot** · **VSCode & CLI**
[Quick Start](#quick-start) · [Provider Switching](#provider-switching) · [Telegram Bot](#telegram-bot-integration) · [Models](#available-models) · [Configuration](#configuration)
@@ -27,9 +27,10 @@ A lightweight proxy that converts Claude Code's Anthropic API requests to NVIDIA
### 1. Prerequisites
-1. Get an API key:
+1. Get an API key (or use LM Studio locally):
- **NVIDIA NIM**: [build.nvidia.com/settings/api-keys](https://build.nvidia.com/settings/api-keys)
- **OpenRouter**: [openrouter.ai/keys](https://openrouter.ai/keys)
+ - **LM Studio**: No API key needed — run locally with [LM Studio](https://lmstudio.ai)
2. Install [claude-code](https://github.com/anthropics/claude-code)
3. Install [uv](https://github.com/astral-sh/uv)
@@ -58,6 +59,13 @@ OPENROUTER_API_KEY=sk-or-your-key-here
MODEL=stepfun/step-3.5-flash:free
```
+Or for **LM Studio** (local, no API key):
+
+```dotenv
+PROVIDER_TYPE=lmstudio
+MODEL=lmstudio-community/qwen2.5-7b-instruct
+```
+
---
### Claude Code CLI
@@ -107,15 +115,18 @@ That's it! The Claude Code VSCode extension now uses your configured provider fo
### Provider Switching
-Switch between **NVIDIA NIM** and **OpenRouter** via `PROVIDER_TYPE`:
+Switch between **NVIDIA NIM**, **OpenRouter**, and **LM Studio** via `PROVIDER_TYPE`:
| Provider | PROVIDER_TYPE | API Key Variable | Base URL |
| ------------- | ---------------- | ---------------------- | --------------------------------- |
| NVIDIA NIM | `nvidia_nim` | `NVIDIA_NIM_API_KEY` | `integrate.api.nvidia.com/v1` |
| OpenRouter | `open_router` | `OPENROUTER_API_KEY` | `openrouter.ai/api/v1` |
+| LM Studio | `lmstudio` | (none) | `localhost:1234/v1` |
OpenRouter gives access to hundreds of models (stepfun, OpenAI, Anthropic, etc.) through a single API. Set `MODEL` to any OpenRouter model ID, e.g. `stepfun/step-3.5-flash:free`.
+LM Studio runs locally — start the server in LM Studio's Developer tab or via `lms server start`, load a model, and set `MODEL` to the model identifier (e.g. `lmstudio-community/qwen2.5-7b-instruct`).
+
---
### Telegram Bot Integration
@@ -193,13 +204,25 @@ Examples:
Browse: [openrouter.ai/models](https://openrouter.ai/models)
+### LM Studio
+
+Run models locally with [LM Studio](https://lmstudio.ai). Load a model in the Chat or Developer tab, then set `MODEL` to its identifier.
+
+Examples (native tool-use support):
+- `lmstudio-community/qwen2.5-7b-instruct`
+- `lmstudio-community/Meta-Llama-3.1-8B-Instruct-GGUF`
+- `bartowski/Ministral-8B-Instruct-2410-GGUF`
+
+Browse: [model.lmstudio.ai](https://model.lmstudio.ai)
+
## Configuration
| Variable | Description | Default |
| --------------------------------- | ------------------------------- | ----------------------------- |
-| `PROVIDER_TYPE` | Provider: `nvidia_nim` or `open_router` | `nvidia_nim` |
+| `PROVIDER_TYPE` | Provider: `nvidia_nim`, `open_router`, or `lmstudio` | `nvidia_nim` |
| `NVIDIA_NIM_API_KEY` | Your NVIDIA API key (NIM provider) | required |
| `OPENROUTER_API_KEY` | Your OpenRouter API key (OpenRouter provider) | required |
+| `LM_STUDIO_BASE_URL` | LM Studio server URL (lmstudio provider) | `http://localhost:1234/v1` |
| `MODEL` | Model to use for all requests | `stepfun-ai/step-3.5-flash` |
| `CLAUDE_WORKSPACE` | Directory for agent workspace | `./agent_workspace` |
| `ALLOWED_DIR` | Allowed directories for agent | `""` |
@@ -218,6 +241,7 @@ Browse: [openrouter.ai/models](https://openrouter.ai/models)
- **NVIDIA NIM** base URL: `https://integrate.api.nvidia.com/v1`
- **OpenRouter** base URL: `https://openrouter.ai/api/v1`
+- **LM Studio** base URL: `http://localhost:1234/v1` (configurable via `LM_STUDIO_BASE_URL`)
See [`.env.example`](.env.example) for all supported parameters.
diff --git a/api/dependencies.py b/api/dependencies.py
index 7ec3dc63..b6e72903 100644
--- a/api/dependencies.py
+++ b/api/dependencies.py
@@ -47,14 +47,26 @@ def get_provider() -> BaseProvider:
)
_provider = OpenRouterProvider(config)
logger.info("Provider initialized: %s", settings.provider_type)
+ elif settings.provider_type == "lmstudio":
+ from providers.lmstudio import LMStudioProvider
+
+ config = ProviderConfig(
+ api_key="lm-studio",
+ base_url=settings.lm_studio_base_url,
+ rate_limit=settings.provider_rate_limit,
+ rate_window=settings.provider_rate_window,
+ nim_settings=settings.nim,
+ )
+ _provider = LMStudioProvider(config)
+ logger.info("Provider initialized: %s", settings.provider_type)
else:
logger.error(
- "Unknown provider_type: '%s'. Supported: 'nvidia_nim', 'open_router'",
+ "Unknown provider_type: '%s'. Supported: 'nvidia_nim', 'open_router', 'lmstudio'",
settings.provider_type,
)
raise ValueError(
f"Unknown provider_type: '{settings.provider_type}'. "
- f"Supported: 'nvidia_nim', 'open_router'"
+ f"Supported: 'nvidia_nim', 'open_router', 'lmstudio'"
)
return _provider
diff --git a/config/settings.py b/config/settings.py
index a6f96894..294e0c0a 100644
--- a/config/settings.py
+++ b/config/settings.py
@@ -19,7 +19,7 @@ class Settings(BaseSettings):
"""Application settings loaded from environment variables."""
# ==================== Provider Selection ====================
- # Valid: "nvidia_nim" | "open_router"
+ # Valid: "nvidia_nim" | "open_router" | "lmstudio"
provider_type: str = "nvidia_nim"
# ==================== OpenRouter Config ====================
@@ -31,6 +31,12 @@ class Settings(BaseSettings):
# ==================== NVIDIA NIM Config ====================
nvidia_nim_api_key: str = ""
+ # ==================== LM Studio Config ====================
+ lm_studio_base_url: str = Field(
+ default="http://localhost:1234/v1",
+ validation_alias="LM_STUDIO_BASE_URL",
+ )
+
# ==================== Model ====================
# All Claude model requests are mapped to this single model
model: str = "moonshotai/kimi-k2-thinking"
diff --git a/providers/__init__.py b/providers/__init__.py
index cd9760fe..987589d2 100644
--- a/providers/__init__.py
+++ b/providers/__init__.py
@@ -1,6 +1,7 @@
"""Providers package - implement your own provider by extending BaseProvider."""
from .base import BaseProvider, ProviderConfig
+from .lmstudio import LMStudioProvider
from .nvidia_nim import NvidiaNimProvider
from .open_router import OpenRouterProvider
from .exceptions import (
@@ -15,6 +16,7 @@ from .exceptions import (
__all__ = [
"BaseProvider",
"ProviderConfig",
+ "LMStudioProvider",
"NvidiaNimProvider",
"OpenRouterProvider",
"ProviderError",
diff --git a/providers/lmstudio/__init__.py b/providers/lmstudio/__init__.py
new file mode 100644
index 00000000..55287e92
--- /dev/null
+++ b/providers/lmstudio/__init__.py
@@ -0,0 +1,5 @@
+"""LM Studio provider - OpenAI-compatible local API."""
+
+from .client import LMStudioProvider
+
+__all__ = ["LMStudioProvider"]
diff --git a/providers/lmstudio/client.py b/providers/lmstudio/client.py
new file mode 100644
index 00000000..dfb9f7ff
--- /dev/null
+++ b/providers/lmstudio/client.py
@@ -0,0 +1,359 @@
+"""LM Studio provider implementation."""
+
+import json
+import logging
+import uuid
+from typing import Any, AsyncIterator
+
+from loguru import logger as loguru_logger
+from openai import AsyncOpenAI
+
+from providers.base import BaseProvider, ProviderConfig
+from providers.rate_limit import GlobalRateLimiter
+from providers.nvidia_nim.errors import map_error
+from providers.nvidia_nim.utils import (
+ SSEBuilder,
+ map_stop_reason,
+ ThinkTagParser,
+ HeuristicToolParser,
+ ContentType,
+)
+
+from .request import build_request_body
+
+logger = logging.getLogger(__name__)
+
+LMSTUDIO_DEFAULT_BASE_URL = "http://localhost:1234/v1"
+
+
+class LMStudioProvider(BaseProvider):
+ """LM Studio provider using OpenAI-compatible local API."""
+
+ def __init__(self, config: ProviderConfig):
+ super().__init__(config)
+ self._api_key = config.api_key or "lm-studio"
+ self._base_url = (config.base_url or LMSTUDIO_DEFAULT_BASE_URL).rstrip("/")
+ self._global_rate_limiter = GlobalRateLimiter.get_instance(
+ rate_limit=config.rate_limit,
+ rate_window=config.rate_window,
+ )
+ self._client = AsyncOpenAI(
+ api_key=self._api_key,
+ base_url=self._base_url,
+ max_retries=0,
+ timeout=300.0,
+ )
+
+ def _build_request_body(self, request: Any) -> dict:
+ """Internal helper for tests and shared building."""
+ return build_request_body(request)
+
+ async def stream_response(
+ self,
+ request: Any,
+ input_tokens: int = 0,
+ *,
+ request_id: str | None = None,
+ ) -> AsyncIterator[str]:
+ """Stream response in Anthropic SSE format."""
+ with loguru_logger.contextualize(request_id=request_id):
+ async for event in self._stream_response_impl(
+ request, input_tokens, request_id
+ ):
+ yield event
+
+ async def _stream_response_impl(
+ self,
+ request: Any,
+ input_tokens: int,
+ request_id: str | None,
+ ) -> AsyncIterator[str]:
+ """Internal streaming implementation with context bound."""
+ message_id = f"msg_{uuid.uuid4()}"
+ sse = SSEBuilder(message_id, request.model, input_tokens)
+
+ body = self._build_request_body(request)
+ req_tag = f" request_id={request_id}" if request_id else ""
+ logger.info(
+ "LMSTUDIO_STREAM:%s model=%s msgs=%d tools=%d",
+ req_tag,
+ body.get("model"),
+ len(body.get("messages", [])),
+ len(body.get("tools", [])),
+ )
+
+ yield sse.message_start()
+
+ think_parser = ThinkTagParser()
+ heuristic_parser = HeuristicToolParser()
+
+ finish_reason = None
+ usage_info = None
+ error_occurred = False
+ error_message = ""
+
+ try:
+ stream = await self._global_rate_limiter.execute_with_retry(
+ self._client.chat.completions.create, **body, stream=True
+ )
+ async for chunk in stream:
+ if getattr(chunk, "usage", None):
+ usage_info = chunk.usage
+
+ if not chunk.choices:
+ continue
+
+ choice = chunk.choices[0]
+ delta = choice.delta
+ if delta is None:
+ continue
+
+ if choice.finish_reason:
+ finish_reason = choice.finish_reason
+ logger.debug("LMSTUDIO finish_reason: %s", finish_reason)
+
+ # Handle reasoning_content (if LM Studio adds it in future)
+ reasoning = getattr(delta, "reasoning_content", None)
+ if reasoning:
+ for event in sse.ensure_thinking_block():
+ yield event
+ yield sse.emit_thinking_delta(reasoning)
+
+ # Handle text content
+ if delta.content:
+ for part in think_parser.feed(delta.content):
+ if part.type == ContentType.THINKING:
+ for event in sse.ensure_thinking_block():
+ yield event
+ yield sse.emit_thinking_delta(part.content)
+ else:
+ filtered_text, detected_tools = heuristic_parser.feed(
+ part.content
+ )
+
+ if filtered_text:
+ for event in sse.ensure_text_block():
+ yield event
+ yield sse.emit_text_delta(filtered_text)
+
+ for tool_use in detected_tools:
+ for event in sse.close_content_blocks():
+ yield event
+
+ block_idx = sse.blocks.allocate_index()
+ if tool_use.get("name") == "Task" and isinstance(
+ tool_use.get("input"), dict
+ ):
+ tool_use["input"]["run_in_background"] = False
+ yield sse.content_block_start(
+ block_idx,
+ "tool_use",
+ id=tool_use["id"],
+ name=tool_use["name"],
+ )
+ yield sse.content_block_delta(
+ block_idx,
+ "input_json_delta",
+ json.dumps(tool_use["input"]),
+ )
+ yield sse.content_block_stop(block_idx)
+
+ # Handle native tool calls
+ if delta.tool_calls:
+ for event in sse.close_content_blocks():
+ yield event
+ for tc in delta.tool_calls:
+ tc_info = {
+ "index": tc.index,
+ "id": tc.id,
+ "function": {
+ "name": tc.function.name,
+ "arguments": tc.function.arguments,
+ },
+ }
+ for event in self._process_tool_call(tc_info, sse):
+ yield event
+
+ except Exception as e:
+ req_tag = f" request_id={request_id}" if request_id else ""
+ logger.error("LMSTUDIO_ERROR:%s %s: %s", req_tag, type(e).__name__, e)
+ mapped_e = map_error(e)
+ error_occurred = True
+ error_message = str(mapped_e)
+ logger.info(
+ "LMSTUDIO_STREAM: Emitting SSE error event for %s%s",
+ type(e).__name__,
+ req_tag,
+ )
+ for event in sse.close_content_blocks():
+ yield event
+ for event in sse.emit_error(error_message):
+ yield event
+
+ # Flush remaining content
+ remaining = think_parser.flush()
+ if remaining:
+ if remaining.type == ContentType.THINKING:
+ for event in sse.ensure_thinking_block():
+ yield event
+ yield sse.emit_thinking_delta(remaining.content)
+ else:
+ for event in sse.ensure_text_block():
+ yield event
+ yield sse.emit_text_delta(remaining.content)
+
+ for tool_use in heuristic_parser.flush():
+ for event in sse.close_content_blocks():
+ yield event
+
+ block_idx = sse.blocks.allocate_index()
+ yield sse.content_block_start(
+ block_idx,
+ "tool_use",
+ id=tool_use["id"],
+ name=tool_use["name"],
+ )
+ if tool_use.get("name") == "Task" and isinstance(
+ tool_use.get("input"), dict
+ ):
+ tool_use["input"]["run_in_background"] = False
+ yield sse.content_block_delta(
+ block_idx,
+ "input_json_delta",
+ json.dumps(tool_use["input"]),
+ )
+ yield sse.content_block_stop(block_idx)
+
+ if (
+ not error_occurred
+ and sse.blocks.text_index == -1
+ and not sse.blocks.tool_indices
+ ):
+ for event in sse.ensure_text_block():
+ yield event
+ yield sse.emit_text_delta(" ")
+
+ for event in self._flush_task_arg_buffers(sse):
+ yield event
+
+ for event in sse.close_all_blocks():
+ yield event
+
+ output_tokens = (
+ usage_info.completion_tokens
+ if usage_info and hasattr(usage_info, "completion_tokens")
+ else sse.estimate_output_tokens()
+ )
+ if usage_info and hasattr(usage_info, "prompt_tokens"):
+ provider_input = usage_info.prompt_tokens
+ if isinstance(provider_input, int):
+ logger.debug(
+ "TOKEN_ESTIMATE: our=%d provider=%d diff=%+d",
+ input_tokens,
+ provider_input,
+ provider_input - input_tokens,
+ )
+ yield sse.message_delta(map_stop_reason(finish_reason), output_tokens)
+ yield sse.message_stop()
+ yield sse.done()
+
+ def _process_tool_call(self, tc: dict, sse: Any):
+ """Process a single tool call delta and yield SSE events."""
+ tc_index = tc.get("index", 0)
+ if tc_index < 0:
+ tc_index = len(sse.blocks.tool_indices)
+
+ fn_delta = tc.get("function", {})
+ incoming_name = fn_delta.get("name")
+ if incoming_name is not None:
+ prev = sse.blocks.tool_names.get(tc_index, "")
+ if not prev:
+ sse.blocks.tool_names[tc_index] = incoming_name
+ elif prev == incoming_name:
+ pass
+ elif isinstance(prev, str) and isinstance(incoming_name, str):
+ if incoming_name.startswith(prev):
+ sse.blocks.tool_names[tc_index] = incoming_name
+ elif prev.startswith(incoming_name):
+ pass
+ else:
+ sse.blocks.tool_names[tc_index] = prev + incoming_name
+ else:
+ sse.blocks.tool_names[tc_index] = str(prev) + str(incoming_name)
+
+ if tc_index not in sse.blocks.tool_indices:
+ name = sse.blocks.tool_names.get(tc_index, "")
+ if name or tc.get("id"):
+ tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"
+ yield sse.start_tool_block(tc_index, tool_id, name)
+ sse.blocks.tool_started[tc_index] = True
+ elif not sse.blocks.tool_started.get(tc_index) and sse.blocks.tool_names.get(
+ tc_index
+ ):
+ tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"
+ name = sse.blocks.tool_names[tc_index]
+ yield sse.start_tool_block(tc_index, tool_id, name)
+ sse.blocks.tool_started[tc_index] = True
+
+ args = fn_delta.get("arguments", "")
+ if args:
+ if not sse.blocks.tool_started.get(tc_index):
+ tool_id = tc.get("id") or f"tool_{uuid.uuid4()}"
+ name = sse.blocks.tool_names.get(tc_index, "tool_call") or "tool_call"
+ yield sse.start_tool_block(tc_index, tool_id, name)
+ sse.blocks.tool_started[tc_index] = True
+
+ current_name = sse.blocks.tool_names.get(tc_index, "")
+ if current_name == "Task":
+ if not sse.blocks.task_args_emitted.get(tc_index, False):
+ buf = sse.blocks.task_arg_buffer.get(tc_index, "") + args
+ sse.blocks.task_arg_buffer[tc_index] = buf
+ try:
+ args_json = json.loads(buf)
+ except Exception:
+ return
+ if args_json.get("run_in_background") is not False:
+ logger.info(
+ "LMSTUDIO_INTERCEPT: Forcing run_in_background=False for Task %s",
+ tc.get("id")
+ or sse.blocks.tool_ids.get(tc_index, "unknown"),
+ )
+ args_json["run_in_background"] = False
+ sse.blocks.task_args_emitted[tc_index] = True
+ sse.blocks.task_arg_buffer.pop(tc_index, None)
+ yield sse.emit_tool_delta(tc_index, json.dumps(args_json))
+ return
+
+ yield sse.emit_tool_delta(tc_index, args)
+
+ def _flush_task_arg_buffers(self, sse: Any):
+ """Emit buffered Task args as a single JSON delta (best-effort)."""
+ for tool_index, buf in list(sse.blocks.task_arg_buffer.items()):
+ if sse.blocks.task_args_emitted.get(tool_index, False):
+ sse.blocks.task_arg_buffer.pop(tool_index, None)
+ continue
+
+ tool_id = sse.blocks.tool_ids.get(tool_index, "unknown")
+ out = "{}"
+ try:
+ args_json = json.loads(buf)
+ if args_json.get("run_in_background") is not False:
+ logger.info(
+ "LMSTUDIO_INTERCEPT: Forcing run_in_background=False for Task %s",
+ tool_id,
+ )
+ args_json["run_in_background"] = False
+ out = json.dumps(args_json)
+ except Exception as e:
+ prefix = buf[:120]
+ logger.warning(
+ "LMSTUDIO_INTERCEPT: Task args invalid JSON (id=%s len=%d prefix=%r): %s",
+ tool_id,
+ len(buf),
+ prefix,
+ e,
+ )
+
+ sse.blocks.task_args_emitted[tool_index] = True
+ sse.blocks.task_arg_buffer.pop(tool_index, None)
+ yield sse.emit_tool_delta(tool_index, out)
diff --git a/providers/lmstudio/request.py b/providers/lmstudio/request.py
new file mode 100644
index 00000000..32f44a66
--- /dev/null
+++ b/providers/lmstudio/request.py
@@ -0,0 +1,64 @@
+"""Request builder for LM Studio provider."""
+
+import logging
+from typing import Any, Dict
+
+from providers.nvidia_nim.utils.message_converter import AnthropicToOpenAIConverter
+
+logger = logging.getLogger(__name__)
+
+LMSTUDIO_DEFAULT_MAX_TOKENS = 81920
+
+
+def _set_if_not_none(body: Dict[str, Any], key: str, value: Any) -> None:
+ if value is not None:
+ body[key] = value
+
+
+def build_request_body(request_data: Any) -> dict:
+ """Build OpenAI-format request body from Anthropic request for LM Studio."""
+ logger.debug(
+ "LMSTUDIO_REQUEST: conversion start model=%s msgs=%d",
+ getattr(request_data, "model", "?"),
+ len(getattr(request_data, "messages", [])),
+ )
+ messages = AnthropicToOpenAIConverter.convert_messages(
+ request_data.messages, include_reasoning_for_openrouter=False
+ )
+
+ # Add system prompt
+ system = getattr(request_data, "system", None)
+ if system:
+ system_msg = AnthropicToOpenAIConverter.convert_system_prompt(system)
+ if system_msg:
+ messages.insert(0, system_msg)
+
+ body: Dict[str, Any] = {
+ "model": request_data.model,
+ "messages": messages,
+ }
+
+ max_tokens = getattr(request_data, "max_tokens", None)
+ _set_if_not_none(body, "max_tokens", max_tokens or LMSTUDIO_DEFAULT_MAX_TOKENS)
+
+ _set_if_not_none(body, "temperature", getattr(request_data, "temperature", None))
+ _set_if_not_none(body, "top_p", getattr(request_data, "top_p", None))
+
+ stop_sequences = getattr(request_data, "stop_sequences", None)
+ if stop_sequences:
+ body["stop"] = stop_sequences
+
+ tools = getattr(request_data, "tools", None)
+ if tools:
+ body["tools"] = AnthropicToOpenAIConverter.convert_tools(tools)
+ tool_choice = getattr(request_data, "tool_choice", None)
+ if tool_choice:
+ body["tool_choice"] = tool_choice
+
+ logger.debug(
+ "LMSTUDIO_REQUEST: conversion done model=%s msgs=%d tools=%d",
+ body.get("model"),
+ len(body.get("messages", [])),
+ len(body.get("tools", [])),
+ )
+ return body
diff --git a/tests/conftest.py b/tests/conftest.py
index b73845d7..e4b22729 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -44,6 +44,20 @@ def open_router_provider(provider_config):
return OpenRouterProvider(provider_config)
+def lmstudio_provider(provider_config):
+ from providers.lmstudio import LMStudioProvider
+
+ lmstudio_config = ProviderConfig(
+ api_key="lm-studio",
+ base_url="http://localhost:1234/v1",
+ rate_limit=provider_config.rate_limit,
+ rate_window=provider_config.rate_window,
+ nim_settings=provider_config.nim_settings,
+ )
+ return LMStudioProvider(lmstudio_config)
+
+
@pytest.fixture
def mock_cli_session():
session = MagicMock(spec=CLISession)
diff --git a/tests/test_dependencies.py b/tests/test_dependencies.py
index abe91d8f..bb4d8953 100644
--- a/tests/test_dependencies.py
+++ b/tests/test_dependencies.py
@@ -1,6 +1,7 @@
import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from api.dependencies import get_provider, get_settings, cleanup_provider
+from providers.lmstudio import LMStudioProvider
from providers.nvidia_nim import NvidiaNimProvider
from providers.open_router import OpenRouterProvider
from config.nim import NimSettings
@@ -14,6 +15,7 @@ def _make_mock_settings(**overrides):
mock.provider_rate_limit = 40
mock.provider_rate_window = 60
mock.open_router_api_key = "test_openrouter_key"
+ mock.lm_studio_base_url = "http://localhost:1234/v1"
mock.nim = NimSettings()
for key, value in overrides.items():
setattr(mock, key, value)
@@ -89,6 +91,19 @@ async def test_get_provider_open_router():
assert provider._api_key == "test_openrouter_key"
+async def test_get_provider_lmstudio():
+ """Test that provider_type=lmstudio returns LMStudioProvider."""
+ with patch("api.dependencies.get_settings") as mock_settings:
+ mock_settings.return_value = _make_mock_settings(provider_type="lmstudio")
+
+ provider = get_provider()
+
+ assert isinstance(provider, LMStudioProvider)
+ assert provider._base_url == "http://localhost:1234/v1"
+ assert provider._api_key == "lm-studio"
+
+
@pytest.mark.asyncio
async def test_get_provider_unknown_type():
"""Test that unknown provider_type raises ValueError."""
diff --git a/tests/test_lmstudio.py b/tests/test_lmstudio.py
new file mode 100644
index 00000000..aae4153a
--- /dev/null
+++ b/tests/test_lmstudio.py
@@ -0,0 +1,192 @@
+"""Tests for LM Studio provider."""
+
+import json
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from providers.base import ProviderConfig
+from providers.lmstudio import LMStudioProvider
+from config.nim import NimSettings
+
+
+class MockMessage:
+ def __init__(self, role, content):
+ self.role = role
+ self.content = content
+
+
+class MockRequest:
+ def __init__(self, **kwargs):
+ self.model = "lmstudio-community/qwen2.5-7b-instruct"
+ self.messages = [MockMessage("user", "Hello")]
+ self.max_tokens = 100
+ self.temperature = 0.5
+ self.top_p = 0.9
+ self.system = "System prompt"
+ self.stop_sequences = None
+ self.tools = []
+ self.extra_body = {}
+ self.thinking = MagicMock()
+ self.thinking.enabled = True
+ for k, v in kwargs.items():
+ setattr(self, k, v)
+
+
+def lmstudio_config():
+ return ProviderConfig(
+ api_key="lm-studio",
+ base_url="http://localhost:1234/v1",
+ rate_limit=10,
+ rate_window=60,
+ nim_settings=NimSettings(),
+ )
+
+
[email protected](autouse=True)
+def mock_rate_limiter():
+ """Mock the global rate limiter to prevent waiting."""
+ with patch("providers.lmstudio.client.GlobalRateLimiter") as mock:
+ instance = mock.get_instance.return_value
+ instance.wait_if_blocked = AsyncMock(return_value=False)
+
+ async def _passthrough(fn, *args, **kwargs):
+ return await fn(*args, **kwargs)
+
+ instance.execute_with_retry = AsyncMock(side_effect=_passthrough)
+ yield instance
+
+
+def lmstudio_provider(lmstudio_config):
+ return LMStudioProvider(lmstudio_config)
+
+
+def test_init(lmstudio_config):
+ """Test provider initialization."""
+ with patch("providers.lmstudio.client.AsyncOpenAI") as mock_openai:
+ provider = LMStudioProvider(lmstudio_config)
+ assert provider._api_key == "lm-studio"
+ assert provider._base_url == "http://localhost:1234/v1"
+ mock_openai.assert_called_once()
+
+
+def test_init_with_empty_api_key():
+ """Provider uses lm-studio placeholder when api_key is empty."""
+ config = ProviderConfig(
+ api_key="",
+ base_url="http://localhost:1234/v1",
+ rate_limit=10,
+ rate_window=60,
+ nim_settings=NimSettings(),
+ )
+ with patch("providers.lmstudio.client.AsyncOpenAI") as mock_openai:
+ provider = LMStudioProvider(config)
+ assert provider._api_key == "lm-studio"
+
+
+def test_build_request_body_no_extra_body(lmstudio_provider):
+ """LM Studio request body does NOT include extra_body/reasoning."""
+ req = MockRequest()
+ body = lmstudio_provider._build_request_body(req)
+
+ assert body["model"] == "lmstudio-community/qwen2.5-7b-instruct"
+ assert body["temperature"] == 0.5
+ assert len(body["messages"]) == 2 # System + User
+ assert body["messages"][0]["role"] == "system"
+ assert body["messages"][0]["content"] == "System prompt"
+
+ assert "extra_body" not in body
+
+
+def test_build_request_body_base_url_and_model(lmstudio_provider):
+ """Base URL and model are correct in provider config."""
+ assert lmstudio_provider._base_url == "http://localhost:1234/v1"
+ req = MockRequest(model="lmstudio-community/qwen2.5-7b-instruct")
+ body = lmstudio_provider._build_request_body(req)
+ assert body["model"] == "lmstudio-community/qwen2.5-7b-instruct"
+
+
+async def test_stream_response_text(lmstudio_provider):
+ """Test streaming text response."""
+ req = MockRequest()
+
+ mock_chunk1 = MagicMock()
+ mock_chunk1.choices = [
+ MagicMock(
+ delta=MagicMock(content="Hello", reasoning_content=None),
+ finish_reason=None,
+ )
+ ]
+ mock_chunk1.usage = None
+
+ mock_chunk2 = MagicMock()
+ mock_chunk2.choices = [
+ MagicMock(
+ delta=MagicMock(content=" World", reasoning_content=None),
+ finish_reason="stop",
+ )
+ ]
+ mock_chunk2.usage = MagicMock(completion_tokens=10)
+
+ async def mock_stream():
+ yield mock_chunk1
+ yield mock_chunk2
+
+ with patch.object(
+ lmstudio_provider._client.chat.completions, "create", new_callable=AsyncMock
+ ) as mock_create:
+ mock_create.return_value = mock_stream()
+
+ events = []
+ async for event in lmstudio_provider.stream_response(req):
+ events.append(event)
+
+ assert len(events) > 0
+ assert "event: message_start" in events[0]
+
+ text_content = ""
+ for e in events:
+ if "event: content_block_delta" in e and '"text_delta"' in e:
+ for line in e.splitlines():
+ if line.startswith("data: "):
+ data = json.loads(line[6:])
+ if "delta" in data and "text" in data["delta"]:
+ text_content += data["delta"]["text"]
+
+ assert "Hello World" in text_content
+
+
+async def test_stream_response_reasoning_content(lmstudio_provider):
+ """Test streaming with reasoning_content delta (if LM Studio adds support)."""
+ req = MockRequest()
+
+ mock_chunk = MagicMock()
+ mock_chunk.choices = [
+ MagicMock(
+ delta=MagicMock(content=None, reasoning_content="Thinking..."),
+ finish_reason=None,
+ )
+ ]
+ mock_chunk.usage = None
+
+ async def mock_stream():
+ yield mock_chunk
+
+ with patch.object(
+ lmstudio_provider._client.chat.completions, "create", new_callable=AsyncMock
+ ) as mock_create:
+ mock_create.return_value = mock_stream()
+
+ events = []
+ async for event in lmstudio_provider.stream_response(req):
+ events.append(event)
+
+ found_thinking = False
+ for e in events:
+ if "event: content_block_delta" in e and '"thinking_delta"' in e:
+ if "Thinking..." in e:
+ found_thinking = True
+ assert found_thinking