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.exampleindex 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_nimPROVIDER_RATE_LIMIT=40PROVIDER_RATE_WINDOW=60@@ -13,6 +13,9 @@ NVIDIA_NIM_API_KEY=""# OpenRouter ConfigOPENROUTER_API_KEY=""+# LM Studio Config (local provider, no API key required)+LM_STUDIO_BASE_URL="http://localhost:1234/v1"+# Telegram ConfigTELEGRAM_BOT_TOKEN=""diff --git a/README.md b/README.mdindex 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[](https://opensource.org/licenses/MIT)[](https://www.python.org/downloads/)@@ -12,7 +12,7 @@[](https://github.com/astral-sh/ruff)[](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-hereMODEL=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.pyindex 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 _providerdiff --git a/config/settings.py b/config/settings.pyindex 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 modelmodel: str = "moonshotai/kimi-k2-thinking"diff --git a/providers/__init__.py b/providers/__init__.pyindex 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 LMStudioProviderfrom .nvidia_nim import NvidiaNimProviderfrom .open_router import OpenRouterProviderfrom .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__.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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 bodydiff --git a/tests/conftest.py b/tests/conftest.pyindex 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.fixturedef mock_cli_session():session = MagicMock(spec=CLISession)diff --git a/tests/test_dependencies.py b/tests/test_dependencies.pyindex abe91d8f..bb4d8953 100644--- a/tests/test_dependencies.py+++ b/tests/test_dependencies.py@@ -1,6 +1,7 @@import pytestfrom unittest.mock import AsyncMock, MagicMock, patchfrom api.dependencies import get_provider, get_settings, cleanup_provider+from providers.lmstudio import LMStudioProviderfrom providers.nvidia_nim import NvidiaNimProviderfrom providers.open_router import OpenRouterProviderfrom config.nim import NimSettings@@ -14,6 +15,7 @@ def _make_mock_settings(**overrides):mock.provider_rate_limit = 40mock.provider_rate_window = 60mock.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.asyncioasync def test_get_provider_unknown_type():"""Test that unknown provider_type raises ValueError."""diff --git a/tests/test_lmstudio.py b/tests/test_lmstudio.pynew file mode 100644index 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