Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

fix(studio): improve model settings and private connection tests (#6177)

yufengd16ce2bb6526
diff --git a/openviking/server/model_connection_test.py b/openviking/server/model_connection_test.py
new file mode 100644
index 000000000..7ad10fc5f
--- /dev/null
+++ b/openviking/server/model_connection_test.py
@@ -0,0 +1,112 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+"""Ephemeral Studio probes using the same adapters as normal model calls."""
+
+import asyncio
+import contextlib
+import time
+
+from openviking.models.model_error import model_error_kind
+from openviking_cli.utils.config.embedding_config import EmbeddingConfig
+from openviking_cli.utils.config.vlm_config import VLMConfig
+
+VLM_PROVIDERS = {"openai", "azure", "volcengine", "glm", "kimi", "litellm"}
+EMBEDDING_PROVIDERS = {
+ "openai",
+ "azure",
+ "volcengine",
+ "jina",
+ "gemini",
+ "voyage",
+ "dashscope",
+ "minimax",
+ "cohere",
+ "litellm",
+}
+
+
+async def _embed_probe(settings):
+ # Some adapters discover dimensions with synchronous network I/O in __init__.
+ creation = asyncio.create_task(asyncio.to_thread(settings.get_embedder))
+ instance = None
+ try:
+ try:
+ instance = await asyncio.shield(creation)
+ except asyncio.CancelledError:
+ # A thread cannot be cancelled; close its client if it finishes late.
+ def close_late(task):
+ with contextlib.suppress(Exception):
+ task.result().close()
+
+ creation.add_done_callback(close_late)
+ raise
+ result = await instance.embed_async("connection test")
+ return bool(result.dense_vector or result.sparse_vector)
+ finally:
+ if instance is not None:
+ with contextlib.suppress(Exception):
+ instance.close()
+
+
+async def probe_model(kind, config, fallback, thinking=None, mode="dense"):
+ """Never publish the draft, use failover, or expose provider error payloads."""
+ started = time.monotonic()
+ instance = None
+ provider = str(config.get("provider") or "").lower()
+ providers = VLM_PROVIDERS if kind == "vlm" else EMBEDDING_PROVIDERS
+ if provider not in providers:
+ return {"ok": False, "code": "unsupported"}
+ try:
+ if kind == "vlm":
+ parent = {
+ **fallback,
+ "credentials": [config],
+ "backup": None,
+ "max_retries": 0,
+ "timeout": 20,
+ }
+ if thinking is not None:
+ parent["thinking"] = thinking
+ settings = VLMConfig.model_validate(parent)
+ instance = settings.get_vlm_instance()
+ result = await asyncio.wait_for(
+ instance.get_completion_async(prompt="Reply only OK."), timeout=25
+ )
+ valid = (
+ bool(result.strip())
+ if isinstance(result, str)
+ else bool(
+ getattr(result, "content", None) or getattr(result, "reasoning_content", None)
+ )
+ )
+ else:
+ settings = EmbeddingConfig.model_validate(
+ {
+ mode: {**fallback, "credentials": [config]},
+ "max_retries": 0,
+ }
+ )
+ valid = await asyncio.wait_for(_embed_probe(settings), timeout=25)
+ if not valid:
+ return {"ok": False, "code": "invalidResponse"}
+ return {"ok": True, "ms": round((time.monotonic() - started) * 1000)}
+ except (asyncio.TimeoutError, TimeoutError):
+ return {"ok": False, "code": "timeout"}
+ except (ValueError, SystemExit):
+ return {"ok": False, "code": "invalid_request"}
+ except Exception as error:
+ kind = model_error_kind(error)
+ code = kind.value if kind is not None else "failed"
+ # Never return raw SDK messages: these can contain credentials or response bodies.
+ return {
+ "ok": False,
+ "code": {
+ "transient_network_error": "network",
+ "transient_service_error": "failed",
+ "unknown": "failed",
+ }.get(code, code),
+ }
+ finally:
+ if instance is not None:
+ with contextlib.suppress(Exception):
+ instance.close()
diff --git a/openviking/server/routers/admin.py b/openviking/server/routers/admin.py
index afe7d357c..3993c9f14 100644
--- a/openviking/server/routers/admin.py
+++ b/openviking/server/routers/admin.py
@@ -4,7 +4,7 @@
import asyncio
from collections.abc import Mapping
-from typing import Any, Optional
+from typing import Any, Literal, Optional
from fastapi import APIRouter, BackgroundTasks, Body, Depends, Path, Query, Request
from fastapi import Response as HTTPResponse
@@ -798,6 +798,30 @@ async def patch_account_configuration(
)
+class ModelConnectionTestRequest(BaseModel):
+ kind: Literal["vlm", "embedding"]
+ config: dict[str, Any]
+ fallback: dict[str, Any] = Field(default_factory=dict)
+ thinking: bool | None = None
+ mode: Literal["dense", "sparse", "hybrid"] = "dense"
+
+
[email protected]("/configuration/test-model", include_in_schema=False)
+@require_auth_root
+async def test_model_configuration(
+ body: ModelConnectionTestRequest,
+ request: Request,
+ response: HTTPResponse,
+ ctx: RequestContext = Depends(get_request_context),
+):
+ """Private Studio operation; drafts are never saved or installed at runtime."""
+ from openviking.server.model_connection_test import probe_model
+
+ response.headers["Cache-Control"] = "no-store"
+ result = await probe_model(body.kind, body.config, body.fallback, body.thinking, body.mode)
+ return Response(status="ok", result=result)
+
+
@router.get("/configuration")
@require_auth_root
async def get_cluster_configuration(
diff --git a/tests/server/test_admin_api.py b/tests/server/test_admin_api.py
index 24bc46195..4bd89262c 100644
--- a/tests/server/test_admin_api.py
+++ b/tests/server/test_admin_api.py
@@ -3637,3 +3637,83 @@ async def test_server_restart_unsupported_or_invalid_file_does_not_stop(
)
assert response.status_code == 400
stopped.assert_not_called()
+
+
+def private_probe_config(monkeypatch, tmp_path):
+ from openviking_cli.utils.config.open_viking_config import (
+ OpenVikingConfig,
+ OpenVikingConfigSingleton,
+ )
+
+ config = OpenVikingConfig.from_dict(
+ {
+ "storage": {"workspace": str(tmp_path)},
+ "vlm": {"provider": "openai", "model": "test-model", "api_key": "test-key"},
+ "embedding": {
+ "dense": {
+ "provider": "openai",
+ "model": "embedding",
+ "api_key": "test-key",
+ "dimension": 8,
+ }
+ },
+ }
+ )
+ monkeypatch.setattr(OpenVikingConfigSingleton, "_instance", config)
+
+
+async def test_private_model_probe_requires_authentication(
+ private_probe_config, lightweight_admin_client, monkeypatch
+):
+ probe = AsyncMock(return_value={"ok": True, "ms": 1})
+ monkeypatch.setattr("openviking.server.model_connection_test.probe_model", probe)
+ response = await lightweight_admin_client.post(
+ "/api/v1/admin/configuration/test-model",
+ json={"kind": "vlm", "config": {"provider": "openai"}},
+ )
+ assert response.status_code == 401
+ probe.assert_not_awaited()
+
+
+async def test_private_model_probe_is_hidden_and_root_only(
+ private_probe_config, lightweight_admin_app, lightweight_admin_client, monkeypatch
+):
+ from openviking.server.auth import get_request_context
+
+ probe = AsyncMock(return_value={"ok": True, "ms": 1})
+ monkeypatch.setattr("openviking.server.model_connection_test.probe_model", probe)
+ schema = lightweight_admin_app.openapi()
+ assert "/api/v1/admin/configuration/test-model" not in schema["paths"]
+ assert "ModelConnectionTestRequest" not in schema.get("components", {}).get("schemas", {})
+ for role in (Role.ADMIN, Role.USER):
+ lightweight_admin_app.dependency_overrides[get_request_context] = lambda role=role: (
+ RequestContext(user=UserIdentifier("default", "default"), role=role)
+ )
+ response = await lightweight_admin_client.post(
+ "/api/v1/admin/configuration/test-model",
+ json={"kind": "vlm", "config": {"provider": "openai"}},
+ )
+ assert response.status_code == 403
+ probe.assert_not_awaited()
+
+
+async def test_private_model_probe_passes_draft_without_saving(
+ private_probe_config, lightweight_admin_client, monkeypatch
+):
+ probe = AsyncMock(return_value={"ok": True, "ms": 12})
+ monkeypatch.setattr("openviking.server.model_connection_test.probe_model", probe)
+ body = {
+ "kind": "vlm",
+ "config": {"provider": "openai", "api_key": "draft-secret"},
+ "fallback": {"model": "o3"},
+ "thinking": True,
+ }
+ response = await lightweight_admin_client.post(
+ "/api/v1/admin/configuration/test-model", headers={"X-API-Key": ROOT_KEY}, json=body
+ )
+ assert response.status_code == 200
+ assert response.headers["cache-control"] == "no-store"
+ assert response.json()["result"] == {"ok": True, "ms": 12}
+ assert "draft-secret" not in response.text
+ probe.assert_awaited_once_with("vlm", body["config"], body["fallback"], True, "dense")
diff --git a/tests/server/test_model_connection_test.py b/tests/server/test_model_connection_test.py
new file mode 100644
index 000000000..d76328934
--- /dev/null
+++ b/tests/server/test_model_connection_test.py
@@ -0,0 +1,227 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+import asyncio
+import threading
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from openviking.models.model_error import ModelError, ModelErrorKind
+from openviking.server.model_connection_test import probe_model
+
+
+def vlm(monkeypatch):
+ instance = Mock(get_completion_async=AsyncMock(return_value="OK"))
+ factory = Mock(return_value=instance)
+ monkeypatch.setattr(
+ "openviking_cli.utils.config.vlm_config.VLMConfig.get_vlm_instance", factory
+ )
+ return instance
+
+
+async def test_vlm_probe_uses_one_draft_credential_and_closes(vlm, monkeypatch):
+ captured = []
+ from openviking_cli.utils.config.vlm_config import VLMConfig
+
+ def build(settings):
+ captured.append(settings)
+ return vlm
+
+ monkeypatch.setattr(VLMConfig, "get_vlm_instance", build)
+ fallback = {
+ "model": "o3",
+ "max_tokens": 4096,
+ "credentials": [{"provider": "openai", "api_key": "other"}],
+ }
+ result = await probe_model("vlm", {"provider": "openai", "api_key": "draft"}, fallback, True)
+ assert result["ok"]
+ assert len(captured[0].credentials) == 1
+ assert captured[0].credentials[0].api_key == "draft"
+ assert captured[0].thinking is True
+ assert captured[0].max_tokens == 4096
+ assert fallback["credentials"][0]["api_key"] == "other"
+ vlm.close.assert_called_once()
+
+
+async def test_probe_redacts_provider_errors(vlm):
+ vlm.get_completion_async.side_effect = ModelError(
+ ModelErrorKind.AUTHENTICATION_ERROR, "secret-token"
+ )
+ result = await probe_model(
+ "vlm", {"provider": "openai", "api_key": "secret-token"}, {"model": "o3"}
+ )
+ assert result == {"ok": False, "code": "authentication_error"}
+ assert "secret-token" not in str(result)
+ vlm.close.assert_called_once()
+
+
+async def test_probe_timeout_closes_model(vlm):
+ vlm.get_completion_async.side_effect = TimeoutError()
+ assert await probe_model(
+ "vlm", {"provider": "openai", "api_key": "draft"}, {"model": "o3"}
+ ) == {"ok": False, "code": "timeout"}
+ vlm.close.assert_called_once()
+
+
+async def test_probe_deadline_cancels_request_and_closes(vlm, monkeypatch):
+ wait_for = asyncio.wait_for
+ monkeypatch.delattr(asyncio, "timeout", raising=False)
+
+ async def short_deadline(request, timeout):
+ assert timeout == 25
+ return await wait_for(request, timeout=0.001)
+
+ async def pending(**kwargs):
+ await asyncio.Event().wait()
+
+ monkeypatch.setattr(asyncio, "wait_for", short_deadline)
+ vlm.get_completion_async.side_effect = pending
+ assert await probe_model(
+ "vlm", {"provider": "openai", "api_key": "draft"}, {"model": "o3"}
+ ) == {"ok": False, "code": "timeout"}
+ vlm.close.assert_called_once()
+
+
+ "provider", ["jina", "gemini", "voyage", "dashscope", "minimax", "cohere", "litellm"]
+)
+async def test_embedding_api_key_providers_use_existing_adapter(provider, monkeypatch):
+ instance = Mock(
+ embed_async=AsyncMock(return_value=Mock(dense_vector=[0.1], sparse_vector=None))
+ )
+
+ def build(settings):
+ assert settings.dense.credentials[0].provider == provider
+ assert settings.dense.credentials[0].api_key == "draft"
+ assert settings.max_retries == 0
+ return instance
+
+ monkeypatch.setattr(
+ "openviking_cli.utils.config.embedding_config.EmbeddingConfig.get_embedder", build
+ )
+ assert (
+ await probe_model(
+ "embedding",
+ {"provider": provider, "api_key": "draft"},
+ {"model": "test-model", "dimension": 1},
+ )
+ )["ok"]
+ instance.embed_async.assert_awaited_once_with("connection test")
+ instance.close.assert_called_once()
+
+
+async def test_keyless_embedding_uses_single_server_adapter(monkeypatch):
+ instance = Mock(
+ embed_async=AsyncMock(return_value=Mock(dense_vector=[0.1], sparse_vector=None))
+ )
+
+ def build(settings):
+ assert len(settings.dense.credentials) == 1
+ assert settings.dense.credentials[0].api_base == "http://localhost:8080/v1"
+ return instance
+
+ monkeypatch.setattr(
+ "openviking_cli.utils.config.embedding_config.EmbeddingConfig.get_embedder", build
+ )
+ result = await probe_model(
+ "embedding",
+ {"provider": "openai", "api_base": "http://localhost:8080/v1"},
+ {"model": "local", "dimension": 1},
+ )
+ assert result["ok"]
+ instance.close.assert_called_once()
+
+
+async def test_unknown_provider_does_not_initialize_model(vlm):
+ assert await probe_model("vlm", {"provider": "unknown"}, {}) == {
+ "ok": False,
+ "code": "unsupported",
+ }
+ vlm.get_completion_async.assert_not_awaited()
+
+
+async def test_empty_completion_is_not_reported_as_connected(vlm):
+ vlm.get_completion_async.return_value = ""
+ result = await probe_model("vlm", {"provider": "openai", "api_key": "draft"}, {"model": "o3"})
+ assert result == {"ok": False, "code": "invalidResponse"}
+ vlm.close.assert_called_once()
+
+
+async def test_cancelled_probe_releases_instance(vlm):
+ vlm.get_completion_async.side_effect = asyncio.CancelledError()
+ with pytest.raises(asyncio.CancelledError):
+ await probe_model("vlm", {"provider": "openai", "api_key": "draft"}, {"model": "o3"})
+ vlm.close.assert_called_once()
+
+
+async def test_minimax_dimension_discovery_does_not_block_event_loop(monkeypatch):
+ from openviking.models.embedder.base import EmbedResult
+ from openviking.models.embedder.minimax_embedders import MinimaxDenseEmbedder
+
+ loop = asyncio.get_running_loop()
+ started = asyncio.Event()
+ release = threading.Event()
+ requests = []
+
+ def post(*args, **kwargs):
+ requests.append(threading.get_ident())
+ loop.call_soon_threadsafe(started.set)
+ assert release.wait(2), "event loop blocked during dimension discovery"
+ return Mock(json=lambda: {"base_resp": {"status_code": 0}, "vectors": [[0.1]]})
+
+ monkeypatch.setattr("requests.Session.post", post)
+ embedding = AsyncMock(return_value=EmbedResult(dense_vector=[0.1]))
+ monkeypatch.setattr(MinimaxDenseEmbedder, "embed_async", embedding)
+ task = asyncio.create_task(
+ probe_model("embedding", {"provider": "minimax", "api_key": "draft"}, {"model": "embo-01"})
+ )
+ try:
+ await asyncio.wait_for(started.wait(), 1)
+ assert len(requests) == 1
+ assert requests[0] != threading.get_ident()
+ assert not task.done()
+ finally:
+ release.set()
+ assert (await task)["ok"]
+ embedding.assert_awaited_once_with("connection test", is_query=False)
+
+
[email protected]("cancel", [False, True])
+async def test_unfinished_embedding_initialization_closes_late_client(monkeypatch, cancel):
+ loop = asyncio.get_running_loop()
+ started = asyncio.Event()
+ closed = asyncio.Event()
+ release = threading.Event()
+ instance = Mock(embed_async=AsyncMock(), close=Mock(side_effect=closed.set))
+ wait_for = asyncio.wait_for
+
+ def build(settings):
+ loop.call_soon_threadsafe(started.set)
+ assert release.wait(2)
+ return instance
+
+ async def short_deadline(request, timeout):
+ return await wait_for(request, timeout=0.02 if timeout == 25 else timeout)
+
+ monkeypatch.setattr(
+ "openviking_cli.utils.config.embedding_config.EmbeddingConfig.get_embedder", build
+ )
+ monkeypatch.setattr(asyncio, "wait_for", short_deadline)
+ task = asyncio.create_task(
+ probe_model("embedding", {"provider": "minimax", "api_key": "draft"}, {"model": "embo-01"})
+ )
+ try:
+ await wait_for(started.wait(), 1)
+ if cancel:
+ task.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await task
+ else:
+ assert await wait_for(task, 1) == {"ok": False, "code": "timeout"}
+ instance.close.assert_not_called()
+ finally:
+ release.set()
+ await wait_for(closed.wait(), 1)
+ instance.close.assert_called_once()
+ instance.embed_async.assert_not_awaited()
diff --git a/web-studio/src/i18n/locales/en/workspace.ts b/web-studio/src/i18n/locales/en/workspace.ts
index 87dc0853f..1da6c0843 100644
--- a/web-studio/src/i18n/locales/en/workspace.ts
+++ b/web-studio/src/i18n/locales/en/workspace.ts
@@ -910,6 +910,35 @@ const workspace = {
dense: 'Dense',
sparse: 'Sparse',
hybrid: 'Hybrid',
+ connectionTest: {
+ action: 'Test connection',
+ testing: 'Testing…',
+ hint: 'Sends a small model request from the OpenViking server and may incur usage. Does not save the draft or switch running models.',
+ unsupported: 'Connection testing is unavailable for this provider.',
+ success: 'Connected: model returned a valid result ({{ms}} ms).',
+ network:
+ 'The OpenViking server could not reach the model service. Check the URL, network or TLS.',
+ timeout:
+ 'Test timed out after 25 seconds. Check the network and model response time.',
+ invalidResponse: 'The model service did not return a valid result.',
+ invalid_request: 'Invalid model configuration or request parameters.',
+ authentication_error:
+ 'The model service rejected the API key. Check whether it is correct or expired.',
+ permission_denied: 'This key cannot access the selected model.',
+ rate_limit_error: 'Model service rate limit reached. Retry later.',
+ quota_exhausted:
+ 'Model service quota exhausted. Check the plan or balance.',
+ model_not_found: 'Model or endpoint not found. Check the model ID.',
+ failed:
+ 'Could not complete the test. Check the connection configuration and retry.',
+ input_too_large: 'The model service rejected the input size.',
+ content_safety:
+ 'The model service content policy rejected the request.',
+ },
+ dragToReorder: 'Drag to reorder {{model}}',
+ dragHint: 'Drag to reorder, or use the up and down arrow keys.',
+ thinkingHint:
+ 'Shared by all VLM models. Requires model/provider support; takes effect after saving and restarting.',
priority: 'Order',
preferred: 'Preferred',
backup: 'Backup',
diff --git a/web-studio/src/i18n/locales/zh-CN/workspace.ts b/web-studio/src/i18n/locales/zh-CN/workspace.ts
index 438d138ca..06d32d44a 100644
--- a/web-studio/src/i18n/locales/zh-CN/workspace.ts
+++ b/web-studio/src/i18n/locales/zh-CN/workspace.ts
@@ -873,6 +873,30 @@ const workspace = {
dense: '稠密向量',
sparse: '稀疏向量',
hybrid: '混合向量',
+ connectionTest: {
+ action: '测试连接',
+ testing: '测试中…',
+ hint: '由 OpenViking 服务端发送一次简短模型请求,可能产生少量用量;不会保存配置或切换当前运行模型。',
+ unsupported: '暂不支持此服务提供商的连接测试。',
+ success: '连接成功,模型已返回有效结果({{ms}} ms)。',
+ network: 'OpenViking 服务端无法连接模型服务,请检查地址、网络或证书。',
+ timeout: '测试超过 25 秒,请检查网络及模型响应速度。',
+ invalidResponse: '模型服务没有返回有效结果。',
+ invalid_request: '模型配置或请求参数不正确,请检查后重试。',
+ authentication_error:
+ '模型服务拒绝了 API Key,请检查 Key 是否正确或已失效。',
+ permission_denied: '此 Key 无权调用指定模型。',
+ rate_limit_error: '模型服务触发限流,请稍后重试。',
+ quota_exhausted: '模型服务额度不足,请检查套餐或余额。',
+ model_not_found: '找不到指定模型或接入点,请检查模型 ID。',
+ failed: '未能完成测试,请检查连接配置后重试。',
+ input_too_large: '模型服务拒绝了输入大小。',
+ content_safety: '请求被模型服务的内容策略拒绝。',
+ },
+ dragToReorder: '拖动调整 {{model}} 的顺序',
+ dragHint: '拖动排序,也可使用键盘上下方向键。',
+ thinkingHint:
+ '此开关由所有 VLM 模型共用,需要模型及服务提供商支持;保存并重启服务后生效。',
priority: '顺序',
preferred: '首选',
backup: '备用',
diff --git a/web-studio/src/routes/settings/-components/connection-profiles.tsx b/web-studio/src/routes/settings/-components/connection-profiles.tsx
index fc221d5fd..e287a089b 100644
--- a/web-studio/src/routes/settings/-components/connection-profiles.tsx
+++ b/web-studio/src/routes/settings/-components/connection-profiles.tsx
@@ -12,6 +12,13 @@ import {
DialogTitle,
} from '#/components/ui/dialog'
import { Input } from '#/components/ui/input'
+import {
+ Select,
+ SelectContent,
+ SelectItem,
+ SelectTrigger,
+ SelectValue,
+} from '#/components/ui/select'
import { Field, FieldLabel } from '#/components/ui/field'
import { useAppConnection } from '#/hooks/use-app-connection'
import { createRandomUuid } from '#/lib/browser-crypto'
@@ -224,8 +231,8 @@ export function ConnectionProfilesList() {
if (!open) setDraft(null)
}}
>
- <DialogContent>
- <DialogHeader>
+ <DialogContent className="sm:max-w-lg">
+ <DialogHeader className="pr-8">
<DialogTitle>
{t(
profiles.some((p) => p.id === draft?.id)
@@ -233,49 +240,61 @@ export function ConnectionProfilesList() {
: 'profiles.add',
)}
</DialogTitle>
- <DialogDescription>{t('profiles.saveHint')}</DialogDescription>
+ <DialogDescription className="text-xs leading-relaxed">
+ {t('profiles.saveHint')}
+ </DialogDescription>
</DialogHeader>
{draft && (
- <form onSubmit={save} className="grid gap-4">
- <Field>
+ <form onSubmit={save} className="grid gap-5">
+ <Field className="gap-2">
<FieldLabel htmlFor="profile-name">
{t('profiles.name')}
</FieldLabel>
<Input
id="profile-name"
+ className="h-10"
required
value={draft.name}
onChange={(e) => setDraft({ ...draft, name: e.target.value })}
{...PLAIN_INPUT_PROPS}
/>
</Field>
- <Field>
+ <Field className="gap-2">
<FieldLabel htmlFor="profile-provider">
{t('serviceType')}
</FieldLabel>
- <select
- id="profile-provider"
- className="h-9 w-full rounded-md border border-input bg-background px-3 text-sm"
+ <Select
value={draft.connection.serviceSelection}
- onChange={(e) =>
+ items={[
+ { value: 'opensource', label: t('providers.opensource') },
+ { value: 'volcengine', label: t('providers.volcengine') },
+ ]}
+ onValueChange={(value) => {
+ if (value !== 'opensource' && value !== 'volcengine') return
setDraft({
...draft,
connection: {
...draft.connection,
- serviceSelection: e.target.value as
- | 'opensource'
- | 'volcengine',
+ serviceSelection: value,
},
})
- }
+ }}
>
- <option value="opensource">
- {t('providers.opensource')}
- </option>
- <option value="volcengine">
- {t('providers.volcengine')}
- </option>
- </select>
+ <SelectTrigger
+ id="profile-provider"
+ className="w-full data-[size=default]:h-10"
+ >
+ <SelectValue />
+ </SelectTrigger>
+ <SelectContent align="start">
+ <SelectItem value="opensource">
+ {t('providers.opensource')}
+ </SelectItem>
+ <SelectItem value="volcengine">
+ {t('providers.volcengine')}
+ </SelectItem>
+ </SelectContent>
+ </Select>
</Field>
{PROFILE_FIELDS.filter(
(field) =>
@@ -284,12 +303,13 @@ export function ConnectionProfilesList() {
field === 'apiKey',
).map((key) => {
return (
- <Field key={key}>
+ <Field key={key} className="gap-2">
<FieldLabel htmlFor={`profile-${key}`}>
{t(`profiles.fields.${key}`)}
</FieldLabel>
<Input
id={`profile-${key}`}
+ className="h-10"
required={key === 'baseUrl'}
type={
key === 'apiKey' || key === 'adminApiKey'
@@ -316,7 +336,7 @@ export function ConnectionProfilesList() {
{error}
</p>
)}
- <div className="flex justify-end gap-2">
+ <div className="flex justify-end gap-2 border-t pt-4">
<Button
type="button"
variant="outline"
diff --git a/web-studio/src/routes/settings/-components/model-connection-test.tsx b/web-studio/src/routes/settings/-components/model-connection-test.tsx
new file mode 100644
index 000000000..6c173d959
--- /dev/null
+++ b/web-studio/src/routes/settings/-components/model-connection-test.tsx
@@ -0,0 +1,131 @@
+import * as React from 'react'
+import { Loader2Icon, PlugZapIcon } from 'lucide-react'
+import { useTranslation } from 'react-i18next'
+import { useAppConnection } from '#/hooks/use-app-connection'
+import { Button } from '#/components/ui/button'
+import {
+ ModelTestError,
+ supportsModelTest,
+ testModelConnection,
+} from '../-lib/model-connection-test'
+import type { ModelConfig, ModelKind } from '../-lib/config-file-api'
+
+export function ModelConnectionTest({
+ kind,
+ config,
+ fallback,
+ thinking,
+ mode,
+ disabled,
+}: {
+ kind: ModelKind
+ config: ModelConfig
+ fallback: ModelConfig
+ thinking?: boolean
+ mode?: string
+ disabled: boolean
+}) {
+ const { t } = useTranslation('settings')
+ const { connection, serverMode } = useAppConnection()
+ const [result, setResult] = React.useState<{
+ code: string
+ ms?: number
+ } | null>(null)
+ const [testing, setTesting] = React.useState(false)
+ const active = React.useRef<AbortController | null>(null)
+ React.useEffect(() => {
+ setResult(null)
+ setTesting(false)
+ return () => {
+ active.current?.abort()
+ active.current = null
+ }
+ }, [
+ kind,
+ config,
+ fallback,
+ thinking,
+ mode,
+ connection.baseUrl,
+ connection.adminApiKey,
+ connection.apiKey,
+ connection.accountId,
+ connection.userId,
+ serverMode,
+ ])
+ const supported = supportsModelTest(kind, config.provider)
+ async function test() {
+ if (testing || disabled || !supported) return
+ const controller = new AbortController()
+ active.current = controller
+ setTesting(true)
+ setResult(null)
+ const timer = setTimeout(() => {
+ controller.abort(new DOMException('Timed out', 'TimeoutError'))
+ }, 30_000)
+ try {
+ const ms = await testModelConnection({
+ connection,
+ trusted: serverMode === 'trusted',
+ mode,
+ kind,
+ config,
+ fallback,
+ thinking,
+ signal: controller.signal,
+ })
+ if (!controller.signal.aborted) setResult({ code: 'success', ms })
+ } catch (error) {
+ if (active.current !== controller) return
+ if (
+ controller.signal.aborted &&
+ controller.signal.reason instanceof DOMException &&
+ controller.signal.reason.name === 'TimeoutError'
+ )
+ setResult({ code: 'timeout' })
+ else if (!controller.signal.aborted)
+ setResult(
+ error instanceof ModelTestError
+ ? { code: error.code }
+ : { code: 'failed' },
+ )
+ } finally {
+ clearTimeout(timer)
+ if (active.current === controller) setTesting(false)
+ }
+ }
+ return (
+ <div className="grid gap-2 border-t pt-4">
+ <div>
+ <Button
+ type="button"
+ variant="outline"
+ disabled={disabled || testing || !supported}
+ onClick={() => void test()}
+ >
+ {testing ? <Loader2Icon className="animate-spin" /> : <PlugZapIcon />}
+ {t(
+ testing
+ ? 'models.connectionTest.testing'
+ : 'models.connectionTest.action',
+ )}
+ </Button>
+ </div>
+ <p className="text-xs text-muted-foreground">
+ {t(
+ supported
+ ? 'models.connectionTest.hint'
+ : 'models.connectionTest.unsupported',
+ )}
+ </p>
+ {result && (
+ <p
+ role={result.code === 'success' ? 'status' : 'alert'}
+ className={`break-all text-sm ${result.code === 'success' ? 'text-emerald-700 dark:text-emerald-400' : 'text-destructive'}`}
+ >
+ {t(`models.connectionTest.${result.code}`, { ms: result.ms })}
+ </p>
+ )}
+ </div>
+ )
+}
diff --git a/web-studio/src/routes/settings/-components/server-configuration.test.tsx b/web-studio/src/routes/settings/-components/server-configuration.test.tsx
index 323891dc6..5a9615009 100644
--- a/web-studio/src/routes/settings/-components/server-configuration.test.tsx
+++ b/web-studio/src/routes/settings/-components/server-configuration.test.tsx
@@ -1,6 +1,7 @@
// @vitest-environment jsdom
import {
cleanup,
+ createEvent,
act,
fireEvent,
render,
@@ -25,6 +26,7 @@ const state = vi.hoisted(() => ({
save: vi.fn(),
preview: vi.fn(),
restart: vi.fn(),
+ testModel: vi.fn(),
copy: vi.fn(),
}))
vi.mock('#/components/code-editor', () => ({
@@ -58,6 +60,7 @@ vi.mock('../-lib/config-file-api', async (importOriginal) => ({
save: state.save,
preview: state.preview,
restart: state.restart,
+ testModel: state.testModel,
}),
}))
vi.mock('#/hooks/use-app-connection', () => ({
@@ -1110,3 +1113,242 @@ it.each(['volcengine', 'unknown'])(
client.clear()
},
)
+
+it('drags VLM models into priority order and preserves complete credentials on save', async () => {
+ mount()
+ await screen.findByText('model-a')
+ const handles = section('vlmType').getAllByRole('button', {
+ name: 'models.dragToReorder',
+ })
+ const transfer = {
+ setData: vi.fn(),
+ setDragImage: vi.fn(),
+ effectAllowed: '',
+ dropEffect: '',
+ }
+ const row = handles[1].closest('[data-model-row]')!
+ expect(row.getAttribute('draggable')).toBe('true')
+ const start = createEvent.dragStart(row, { dataTransfer: transfer })
+ Object.defineProperties(start, {
+ clientX: { value: 20 },
+ clientY: { value: 10 },
+ })
+ fireEvent(row, start)
+ expect(transfer.setDragImage).toHaveBeenCalledWith(row, 20, 10)
+ fireEvent.dragOver(handles[0], { dataTransfer: transfer })
+ expect(state.preview).not.toHaveBeenCalled()
+ expect(
+ handles[0].closest('[data-drop-target]')?.getAttribute('data-drop-target'),
+ ).toBe('before')
+ fireEvent.drop(handles[0], { dataTransfer: transfer })
+ await waitFor(() => expect(state.preview).toHaveBeenCalledTimes(1))
+ fireEvent.click(screen.getByRole('button', { name: 'models.saveAll' }))
+ await waitFor(() => expect(state.save).toHaveBeenCalledTimes(1))
+ const saved = JSON.parse(state.save.mock.calls[0][0])
+ expect(saved.vlm.credentials).toEqual([...language.credentials].reverse())
+ expect(saved.embedding).toEqual(file.embedding)
+})
+
+it('cancels a drag without changing the draft and supports keyboard reordering', async () => {
+ mount()
+ await screen.findByText('model-a')
+ const handles = section('vlmType').getAllByRole('button', {
+ name: 'models.dragToReorder',
+ })
+ const transfer = {
+ setData: vi.fn(),
+ setDragImage: vi.fn(),
+ effectAllowed: '',
+ dropEffect: '',
+ }
+ fireEvent.dragStart(handles[0], { dataTransfer: transfer })
+ fireEvent.dragOver(handles[1], { dataTransfer: transfer })
+ fireEvent.dragEnd(handles[0], { dataTransfer: transfer })
+ fireEvent.drop(handles[1], { dataTransfer: transfer })
+ expect(state.preview).not.toHaveBeenCalled()
+ fireEvent.keyDown(handles[0], { key: 'ArrowUp' })
+ expect(state.preview).not.toHaveBeenCalled()
+ fireEvent.keyDown(handles[1], { key: 'ArrowUp' })
+ await waitFor(() => expect(state.preview).toHaveBeenCalledTimes(1))
+ expect(state.preview.mock.calls[0][1].vlm.credentials).toEqual(
+ [...language.credentials].reverse(),
+ )
+})
+
+it.each(['addModel', 'edit'])(
+ 'edits the shared thinking setting from the VLM %s dialog',
+ async (action) => {
+ mount()
+ await screen.findByText('model-a')
+ fireEvent.click(
+ section('vlmType').getAllByRole('button', {
+ name: `models.${action}`,
+ })[0],
+ )
+ expect(screen.getByText('models.thinkingHint')).toBeTruthy()
+ fireEvent.click(
+ screen.getByRole('switch', { name: 'models.fields.thinking' }),
+ )
+ if (action === 'addModel') {
+ fireEvent.change(screen.getByLabelText('models.fields.model'), {
+ target: { value: 'new-model' },
+ })
+ fireEvent.change(screen.getByLabelText('models.fields.api_key'), {
+ target: { value: 'new-key' },
+ })
+ }
+ await apply()
+ fireEvent.click(screen.getByRole('button', { name: 'models.saveAll' }))
+ await waitFor(() => expect(state.save).toHaveBeenCalledTimes(1))
+ const saved = JSON.parse(state.save.mock.calls[0][0])
+ expect(saved.vlm.thinking).toBe(true)
+ expect(saved.vlm.credentials.slice(0, 2)).toEqual(language.credentials)
+ expect(
+ saved.vlm.credentials.every((item: ModelConfig) => !('thinking' in item)),
+ ).toBe(true)
+ },
+)
+
+it('discards thinking changes when the model dialog is cancelled', async () => {
+ mount()
+ await screen.findByText('model-a')
+ fireEvent.click(
+ section('vlmType').getAllByRole('button', { name: 'models.edit' })[0],
+ )
+ fireEvent.click(
+ screen.getByRole('switch', { name: 'models.fields.thinking' }),
+ )
+ fireEvent.click(screen.getByRole('button', { name: 'models.dismiss' }))
+ expect(state.preview).not.toHaveBeenCalled()
+ expect(screen.queryByRole('button', { name: 'models.saveAll' })).toBeNull()
+})
+
+it('reorders only the selected embedding group and blocks drag while validation is pending', async () => {
+ const payload = structuredClone(data)
+ payload.models.embedding.config.dense.credentials.push({
+ id: 'embed-backup',
+ provider: 'openai',
+ api_key: 'backup-key',
+ api_base: 'https://backup.example.com',
+ })
+ mount(payload)
+ await screen.findByText('model-a')
+ let finish!: (value: unknown) => void
+ state.preview.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finish = resolve
+ }),
+ )
+ const embedding = section('embeddingType')
+ const handles = embedding.getAllByRole('button', {
+ name: 'models.dragToReorder',
+ })
+ const transfer = {
+ setData: vi.fn(),
+ setDragImage: vi.fn(),
+ effectAllowed: '',
+ dropEffect: '',
+ }
+ // A drag from another model list must not be accepted here.
+ fireEvent.dragStart(
+ section('vlmType').getAllByRole('button', {
+ name: 'models.dragToReorder',
+ })[0],
+ { dataTransfer: transfer },
+ )
+ fireEvent.drop(handles[1], { dataTransfer: transfer })
+ expect(state.preview).not.toHaveBeenCalled()
+ fireEvent.dragEnd(
+ section('vlmType').getAllByRole('button', {
+ name: 'models.dragToReorder',
+ })[0],
+ )
+ fireEvent.dragStart(handles[1], { dataTransfer: transfer })
+ fireEvent.drop(handles[0], { dataTransfer: transfer })
+ await waitFor(() => expect(state.preview).toHaveBeenCalledTimes(1))
+ const changed = state.preview.mock.calls[0][1].embedding
+ expect(changed.dense.credentials).toEqual(
+ [...payload.models.embedding.config.dense.credentials].reverse(),
+ )
+ expect(state.preview.mock.calls[0][1].vlm).toBeUndefined()
+ for (const handle of section('vlmType').getAllByRole('button', {
+ name: 'models.dragToReorder',
+ })) {
+ expect(handle.hasAttribute('disabled')).toBe(true)
+ fireEvent.keyDown(handle, { key: 'ArrowDown' })
+ }
+ expect(state.preview).toHaveBeenCalledTimes(1)
+ await act(async () => {
+ finish({ content, models: data.models })
+ })
+})
+
+it('tests an unsaved draft on the server without previewing or saving and clears stale results', async () => {
+ mount()
+ state.testModel.mockResolvedValue({ ok: true, ms: 12 })
+ await screen.findByText('model-a')
+ fireEvent.click(
+ section('vlmType').getAllByRole('button', { name: 'models.edit' })[0],
+ )
+ fireEvent.change(screen.getByLabelText('models.fields.model'), {
+ target: { value: 'unsaved-model' },
+ })
+ fireEvent.click(
+ screen.getByRole('button', { name: 'models.connectionTest.action' }),
+ )
+ await screen.findByText('models.connectionTest.success')
+ expect(state.testModel.mock.calls[0][0].config.model).toBe('unsaved-model')
+ expect(state.preview).not.toHaveBeenCalled()
+ expect(state.save).not.toHaveBeenCalled()
+ fireEvent.change(screen.getByLabelText('models.fields.api_base'), {
+ target: { value: 'https://changed.example/v1' },
+ })
+ expect(screen.queryByText('models.connectionTest.success')).toBeNull()
+})
+it('cancels a pending server probe when the dialog closes', async () => {
+ mount()
+ let signal: AbortSignal | undefined
+ state.testModel.mockImplementation((_draft, incoming: AbortSignal) => {
+ signal = incoming
+ return new Promise((_resolve, reject) =>
+ incoming.addEventListener('abort', () => reject(incoming.reason)),
+ )
+ })
+ await screen.findByText('model-a')
+ fireEvent.click(
+ section('vlmType').getAllByRole('button', { name: 'models.edit' })[0],
+ )
+ fireEvent.click(
+ screen.getByRole('button', { name: 'models.connectionTest.action' }),
+ )
+ await screen.findByRole('button', { name: 'models.connectionTest.testing' })
+ fireEvent.click(screen.getByRole('button', { name: 'models.dismiss' }))
+ expect(signal?.aborted).toBe(true)
+})
+it('shows safe model authentication failures from the server', async () => {
+ mount()
+ state.testModel.mockResolvedValue({ ok: false, code: 'authentication_error' })
+ await screen.findByText('model-a')
+ fireEvent.click(
+ section('vlmType').getAllByRole('button', { name: 'models.edit' })[0],
+ )
+ fireEvent.click(
+ screen.getByRole('button', { name: 'models.connectionTest.action' }),
+ )
+ await screen.findByText('models.connectionTest.authentication_error')
+ expect(state.save).not.toHaveBeenCalled()
+})
+
+it('keeps model row controls clickable without starting a drag', async () => {
+ mount()
+ const model = await screen.findByRole('button', {
+ name: 'model-a',
+ exact: true,
+ })
+ const transfer = { setData: vi.fn(), setDragImage: vi.fn() }
+ expect(fireEvent.dragStart(model, { dataTransfer: transfer })).toBe(false)
+ expect(transfer.setDragImage).not.toHaveBeenCalled()
+ fireEvent.click(model)
+ expect(await screen.findByRole('dialog')).toBeTruthy()
+})
diff --git a/web-studio/src/routes/settings/-components/server-configuration.tsx b/web-studio/src/routes/settings/-components/server-configuration.tsx
index b5611f970..6dda2cf53 100644
--- a/web-studio/src/routes/settings/-components/server-configuration.tsx
+++ b/web-studio/src/routes/settings/-components/server-configuration.tsx
@@ -2,6 +2,7 @@ import * as React from 'react'
import { toast } from 'sonner'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import {
+ GripVerticalIcon,
ArrowUpIcon,
ArrowDownIcon,
EyeIcon,
@@ -51,6 +52,7 @@ import {
TooltipTrigger,
} from '#/components/ui/tooltip'
import { ModelFields, bindingFields, providers } from './model-fields'
+import { ModelConnectionTest } from './model-connection-test'
import {
createConfigFileApi,
embeddingModes,
@@ -108,6 +110,9 @@ type RowProps = {
onEdit: () => void
onDelete: () => void
onMove: (index: number) => void
+ dragHandle: React.ReactNode
+ dropProps: React.HTMLAttributes<HTMLDivElement>
+ dropTarget?: 'before' | 'after'
}
function ModelRow({
value,
@@ -119,6 +124,9 @@ function ModelRow({
onEdit,
onDelete,
onMove,
+ dragHandle,
+ dropProps,
+ dropTarget,
}: RowProps) {
const { t } = useTranslation('settings')
const ordered = count > 1
@@ -127,11 +135,21 @@ function ModelRow({
)
return (
<div
- className={`grid min-w-0 items-start gap-2 border-b bg-background py-3 text-sm md:items-center ${ordered ? 'grid-cols-[32px_minmax(0,1fr)] md:grid-cols-[32px_minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px]' : 'grid-cols-[0px_minmax(0,1fr)] gap-x-0 md:grid-cols-[minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px] md:gap-x-2'}`}
+ {...dropProps}
+ data-model-row=""
+ data-drop-target={dropTarget}
+ className={`grid min-w-0 items-start gap-2 border-b bg-background py-3 data-[drop-target]:bg-accent data-[drop-target=before]:shadow-[inset_0_2px_0_var(--primary)] data-[drop-target=after]:shadow-[inset_0_-2px_0_var(--primary)] text-sm md:items-center ${ordered ? 'grid-cols-[56px_minmax(0,1fr)] md:grid-cols-[56px_minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px]' : 'grid-cols-[0px_minmax(0,1fr)] gap-x-0 md:grid-cols-[minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px] md:gap-x-2'}`}
>
- <span className={ordered ? 'text-xs text-muted-foreground' : 'md:hidden'}>
+ <div
+ className={
+ ordered
+ ? 'flex items-center gap-1 text-xs text-muted-foreground'
+ : 'md:hidden'
+ }
+ >
+ {ordered && dragHandle}
{ordered ? index + 1 : null}
- </span>
+ </div>
<div className="min-w-0">
<div className="flex flex-wrap items-center gap-2">
<button
@@ -246,9 +264,13 @@ function ModelList({
onDelete: (index: number) => void
}) {
const { t } = useTranslation('settings')
+ const [drag, setDrag] = React.useState<{ from: number; to: number } | null>(
+ null,
+ )
const ids = values.map((value, index) => `${group}-${value.id || index}`)
function move(from: number, to: number) {
- if (from < 0 || to < 0 || to >= values.length || from === to) return
+ if (disabled || from < 0 || to < 0 || to >= values.length || from === to)
+ return
const reordered = [...values]
const [moved] = reordered.splice(from, 1)
reordered.splice(to, 0, moved)
@@ -261,7 +283,7 @@ function ModelList({
return (
<div className="min-w-0">
<div
- className={`hidden gap-2 border-b pb-2 text-xs text-muted-foreground md:grid ${values.length > 1 ? 'grid-cols-[32px_minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px]' : 'grid-cols-[minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px]'}`}
+ className={`hidden gap-2 border-b pb-2 text-xs text-muted-foreground md:grid ${values.length > 1 ? 'grid-cols-[56px_minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px]' : 'grid-cols-[minmax(0,1.4fr)_100px_minmax(0,1.4fr)_80px_104px]'}`}
>
{values.length > 1 && <span>{t('models.priority')}</span>}
<span>{t('models.listModel')}</span>
@@ -273,6 +295,70 @@ function ModelList({
{values.map((value, index) => (
<ModelRow
key={ids[index]}
+ dropProps={{
+ draggable: !disabled && values.length > 1,
+ onDragStart: (event) => {
+ const control = (event.target as Element).closest(
+ 'button, a, input, select, textarea',
+ )
+ if (
+ disabled ||
+ (control && !control.hasAttribute('data-model-drag-handle'))
+ ) {
+ event.preventDefault()
+ return
+ }
+ const row = event.currentTarget
+ const bounds = row.getBoundingClientRect()
+ event.dataTransfer.effectAllowed = 'move'
+ event.dataTransfer.setData('text/plain', ids[index])
+ event.dataTransfer.setDragImage(
+ row,
+ event.clientX - bounds.left,
+ event.clientY - bounds.top,
+ )
+ setDrag({ from: index, to: index })
+ },
+ onDragEnd: () => setDrag(null),
+ onDragOver: (event) => {
+ if (disabled || !drag) return
+ event.preventDefault()
+ event.dataTransfer.dropEffect = 'move'
+ if (drag.to !== index) setDrag({ ...drag, to: index })
+ },
+ onDrop: (event) => {
+ if (disabled || !drag) return
+ event.preventDefault()
+ move(drag.from, index)
+ setDrag(null)
+ },
+ }}
+ dropTarget={
+ !disabled && drag?.to === index && drag.from !== index
+ ? drag.from > index
+ ? 'before'
+ : 'after'
+ : undefined
+ }
+ dragHandle={
+ <button
+ type="button"
+ data-model-drag-handle=""
+ disabled={disabled}
+ aria-label={t('models.dragToReorder', {
+ model: String(value.model || fallback.model || index + 1),
+ })}
+ title={t('models.dragHint')}
+ className="flex size-6 shrink-0 cursor-grab items-center justify-center rounded hover:bg-muted focus-visible:outline-2 focus-visible:outline-ring active:cursor-grabbing disabled:cursor-default"
+ onKeyDown={(event) => {
+ if (event.key !== 'ArrowUp' && event.key !== 'ArrowDown') return
+ event.preventDefault()
+ move(index, index + (event.key === 'ArrowUp' ? -1 : 1))
+ }}
+ >
+ <GripVerticalIcon className="size-4" />
+ </button>
+ }
value={value}
fallback={fallback}
index={index}
@@ -294,6 +380,7 @@ type Editor = {
value: ModelConfig
readonly: boolean
settings: boolean
+ thinking?: boolean
}
const titles: Record<EditableModelKind, string> = {
vlm: 'models.vlmType',
@@ -444,8 +531,9 @@ export function ServerConfigurationEditor() {
kind: EditableModelKind,
mode: string | undefined,
values: ModelConfig[],
+ shared: ModelConfig = {},
) {
- const config = current(kind)
+ const config = { ...current(kind), ...shared }
change(
kind,
mode
@@ -481,6 +569,8 @@ export function ServerConfigurationEditor() {
readonly,
settings,
value: structuredClone(value),
+ thinking:
+ kind === 'vlm' && !settings ? config.thinking === true : undefined,
})
}
function dismissEditor() {
@@ -505,13 +595,18 @@ export function ServerConfigurationEditor() {
if (index === undefined) values.push(next)
else values[index] = next
const config = current(kind)
+ const shared =
+ kind === 'vlm' && editor.thinking !== (config.thinking === true)
+ ? { thinking: editor.thinking }
+ : {}
if (!mode && !config.model)
change(kind, {
...config,
+ ...shared,
model: String(next.model || ''),
credentials: values,
})
- else reorder(kind, mode, values)
+ else reorder(kind, mode, values, shared)
}
}
function dismissConfirmation() {
@@ -1035,6 +1130,40 @@ export function ServerConfigurationEditor() {
setEditor({ ...editor, value })
}}
/>
+ {editor.kind === 'vlm' && !editor.settings && (
+ <div className="grid gap-2 border-t pt-4">
+ <ModelFields
+ prefix="shared-vlm"
+ fields={[{ key: 'thinking', type: 'toggle' }]}
+ value={{ thinking: editor.thinking }}
+ readOnly={editor.readonly || pending}
+ onChange={(value) => {
+ if (!pending)
+ setEditor({
+ ...editor,
+ thinking: value.thinking === true,
+ })
+ }}
+ />
+ <p className="text-xs text-muted-foreground">
+ {t('models.thinkingHint')}
+ </p>
+ </div>
+ )}
+ {!editor.settings && (
+ <ModelConnectionTest
+ mode={editor.mode}
+ kind={editor.kind}
+ config={editor.value}
+ fallback={
+ editor.mode
+ ? object(current(editor.kind)[editor.mode])
+ : current(editor.kind)
+ }
+ thinking={editor.thinking}
+ disabled={pending}
+ />
+ )}
{editor.kind === 'embedding' && editor.settings && (
<>
<p className="text-xs text-muted-foreground">
diff --git a/web-studio/src/routes/settings/-lib/config-file-api.test.ts b/web-studio/src/routes/settings/-lib/config-file-api.test.ts
index 2435f67bb..29b49157a 100644
--- a/web-studio/src/routes/settings/-lib/config-file-api.test.ts
+++ b/web-studio/src/routes/settings/-lib/config-file-api.test.ts
@@ -180,3 +180,45 @@ it('accepts a verbatim file draft with a UTF-8 BOM', () => {
true,
)
})
+
+it('uses the ROOT transport and abort signal for private model tests', async () => {
+ const requests: InternalAxiosRequestConfig[] = []
+ vi.spyOn(axios, 'create').mockReturnValue(
+ axios.create({
+ adapter: async (config) => {
+ requests.push(config)
+ return {
+ status: 200,
+ statusText: 'OK',
+ headers: {},
+ config,
+ data: { status: 'ok', result: { ok: true, ms: 12 } },
+ }
+ },
+ }),
+ )
+ const controller = new AbortController()
+ const api = createConfigFileApi(
+ {
+ baseUrl: 'http://localhost:1933',
+ accountId: 'default',
+ userId: 'default',
+ adminApiKey: 'root-key',
+ apiKey: 'user-key',
+ },
+ false,
+ )
+ await api.testModel(
+ {
+ kind: 'vlm',
+ config: { provider: 'volcengine', api_key: 'model-key' },
+ fallback: {},
+ },
+ controller.signal,
+ )
+ expect(requests[0].url).toBe(
+ 'http://localhost:1933/api/v1/admin/configuration/test-model',
+ )
+ expect(requests[0].headers.get('X-API-Key')).toBe('root-key')
+ expect(requests[0].signal).toBe(controller.signal)
+})
diff --git a/web-studio/src/routes/settings/-lib/config-file-api.ts b/web-studio/src/routes/settings/-lib/config-file-api.ts
index 05f014b26..a6561b62b 100644
--- a/web-studio/src/routes/settings/-lib/config-file-api.ts
+++ b/web-studio/src/routes/settings/-lib/config-file-api.ts
@@ -136,6 +136,25 @@ export function createConfigFileApi(
})
const url = '/api/v1/admin/configuration'
return {
+ testModel: (
+ body: {
+ kind: ModelKind
+ config: ModelConfig
+ fallback: ModelConfig
+ thinking?: boolean
+ mode?: string
+ },
+ signal: AbortSignal,
+ ) =>
+ getOvResult<{ ok: boolean; code?: string; ms?: number }>(
+ client.post({
+ url: `${url}/test-model`,
+ headers: { 'Content-Type': 'application/json' },
+ body,
+ signal,
+ timeout: 30_000,
+ }),
+ ),
restart: (revision: string) =>
getOvResult<RestartStatus>(
client.post({
diff --git a/web-studio/src/routes/settings/-lib/model-connection-test.test.ts b/web-studio/src/routes/settings/-lib/model-connection-test.test.ts
new file mode 100644
index 000000000..74b2945fb
--- /dev/null
+++ b/web-studio/src/routes/settings/-lib/model-connection-test.test.ts
@@ -0,0 +1,53 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { supportsModelTest, testModelConnection } from './model-connection-test'
+
+const state = vi.hoisted(() => ({ test: vi.fn() }))
+vi.mock('./config-file-api', () => ({
+ createConfigFileApi: () => ({ testModel: state.test }),
+}))
+afterEach(() => vi.resetAllMocks())
+const connection = {
+ baseUrl: 'http://server',
+ adminApiKey: 'root',
+ apiKey: 'user',
+ accountId: 'default',
+ userId: 'default',
+}
+const draft = {
+ connection,
+ trusted: false,
+ kind: 'vlm' as const,
+ config: { provider: 'volcengine', api_key: 'model-secret' },
+ fallback: { model: 'inherited' },
+ signal: new AbortController().signal,
+}
+it('delegates the unchanged draft to the private admin transport', async () => {
+ state.test.mockResolvedValue({ ok: true, ms: 42 })
+ expect(await testModelConnection(draft)).toBe(42)
+ expect(state.test).toHaveBeenCalledWith(
+ { kind: 'vlm', config: draft.config, fallback: draft.fallback },
+ draft.signal,
+ )
+})
+it('exposes only the structured failure code', async () => {
+ state.test.mockResolvedValue({
+ ok: false,
+ code: 'authentication_error',
+ message: 'sensitive server payload',
+ })
+ await expect(testModelConnection(draft)).rejects.toMatchObject({
+ code: 'authentication_error',
+ })
+})
+
+it.each([
+ 'jina',
+ 'gemini',
+ 'voyage',
+ 'dashscope',
+ 'minimax',
+ 'cohere',
+ 'litellm',
+])('enables connection testing for the %s embedding adapter', (provider) =>
+ expect(supportsModelTest('embedding', provider)).toBe(true),
+)
diff --git a/web-studio/src/routes/settings/-lib/model-connection-test.ts b/web-studio/src/routes/settings/-lib/model-connection-test.ts
new file mode 100644
index 000000000..3afc14686
--- /dev/null
+++ b/web-studio/src/routes/settings/-lib/model-connection-test.ts
@@ -0,0 +1,50 @@
+import { createConfigFileApi } from './config-file-api'
+import type { ModelConfig, ModelKind } from './config-file-api'
+import type { ConnectionDraft } from '#/hooks/use-app-connection'
+
+export class ModelTestError extends Error {
+ constructor(public readonly code: string) {
+ super(code)
+ }
+}
+export function supportsModelTest(kind: ModelKind, provider: unknown) {
+ return (
+ kind === 'vlm'
+ ? ['openai', 'volcengine', 'azure', 'glm', 'kimi', 'litellm']
+ : [
+ 'openai',
+ 'azure',
+ 'volcengine',
+ 'jina',
+ 'gemini',
+ 'voyage',
+ 'dashscope',
+ 'minimax',
+ 'cohere',
+ 'litellm',
+ ]
+ ).includes(String(provider || '').toLowerCase())
+}
+
+export async function testModelConnection({
+ connection,
+ trusted,
+ signal,
+ ...draft
+}: {
+ connection: ConnectionDraft
+ trusted: boolean
+ kind: ModelKind
+ config: ModelConfig
+ fallback: ModelConfig
+ thinking?: boolean
+ mode?: string
+ signal: AbortSignal
+}) {
+ const result = await createConfigFileApi(connection, trusted).testModel(
+ draft,
+ signal,
+ )
+ if (!result.ok) throw new ModelTestError(result.code || 'failed')
+ return result.ms ?? 0
+}
diff --git a/web-studio/src/routes/settings/route.tsx b/web-studio/src/routes/settings/route.tsx
index db0e8322c..2ba7d2f3a 100644
--- a/web-studio/src/routes/settings/route.tsx
+++ b/web-studio/src/routes/settings/route.tsx
@@ -481,6 +481,16 @@ function ConnectionSettingsPanel() {
? resolveConfiguredServiceProvider(draft.baseUrl)
: draft.serviceSelection
}
+ items={[
+ {
+ value: 'opensource',
+ label: t('studio:providers.opensource'),
+ },
+ {
+ value: 'volcengine',
+ label: t('studio:providers.volcengine'),
+ },
+ ]}
onValueChange={(value) =>
selectServiceType(value as 'opensource' | 'volcengine')
}