Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

31.9 KB
Raw Blame
//! JSON-RPC E2E tests for the embeddings domain.
//!
//! Spins up the core HTTP router against a temp workspace and exercises the
//! `openhuman.embeddings_*` controller surface end-to-end. No real Voyage /
//! OpenAI / Cohere calls are made — tests either use the "none" noop provider
//! or assert error shapes from providers that require live credentials.
//!
//! Run with: `cargo test -p openhuman-cli --test in_process_all`

use crate::env_guard::env_lock_async;
use crate::env_guard::EnvVarGuard;
use crate::rpc_auth::{ensure_rpc_auth, rpc_token};
use std::net::SocketAddr;
use std::path::Path;
use std::sync::{Arc, Mutex};
use std::time::Duration;

use axum::extract::State;
use axum::http::header::AUTHORIZATION;
use axum::routing::post;
use axum::{Json, Router};
use serde_json::{json, Value};
use tempfile::tempdir;

use openhuman_rpc::server::build_core_http_router;

// ── Auth / token setup ────────────────────────────────────────────────────────

// ── Env-var guard (RAII restore) ──────────────────────────────────────────────

// ── Minimal config writer ─────────────────────────────────────────────────────

fn write_min_config(config_dir: &Path) {
    std::fs::create_dir_all(config_dir).expect("mkdir for embeddings e2e config");
    let cfg = r#"api_url = "http://127.0.0.1:1"
default_model = "e2e-mock-model"
default_temperature = 0.7
chat_onboarding_completed = true

[secrets]
encrypt = false
"#;
    std::fs::write(config_dir.join("config.toml"), cfg).expect("write embeddings e2e config.toml");
}

// ── HTTP server helpers ───────────────────────────────────────────────────────

async fn serve_on_ephemeral() -> (
    SocketAddr,
    tokio::task::JoinHandle<Result<(), std::io::Error>>,
) {
    ensure_rpc_auth();
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind ephemeral port");
    let addr = listener.local_addr().expect("local_addr");
    let app = build_core_http_router(false);
    let handle = tokio::spawn(async move { axum::serve(listener, app).await });
    (addr, handle)
}

#[derive(Clone, Default)]
struct MockEmbeddingState {
    requests: Arc<Mutex<Vec<Value>>>,
    auth_headers: Arc<Mutex<Vec<Option<String>>>>,
}

async fn mock_openai_embeddings(
    State(state): State<MockEmbeddingState>,
    headers: axum::http::HeaderMap,
    Json(body): Json<Value>,
) -> Json<Value> {
    // Return exactly one embedding per input, like a real OpenAI-compatible
    // server — the client rejects a count mismatch (`openai embed count
    // mismatch`), and the save-time verification probe sends a single
    // `"connection test"` input while the real embed sends two. Captured before
    // `body` is moved into the request log below.
    let input_len = match body.get("input") {
        Some(Value::Array(items)) => items.len().max(1),
        _ => 1,
    };

    state
        .requests
        .lock()
        .expect("mock requests lock")
        .push(body);
    state
        .auth_headers
        .lock()
        .expect("mock auth headers lock")
        .push(
            headers
                .get(AUTHORIZATION)
                .and_then(|value| value.to_str().ok())
                .map(ToOwned::to_owned),
        );

    // Index 0 → [0.1,0.2,0.3], every other index → [0.4,0.5,0.6], so the
    // two-input embed assertion (`vectors[1][2] ≈ 0.6`) still holds.
    let data: Vec<Value> = (0..input_len)
        .map(|i| {
            let embedding = if i == 0 {
                [0.1, 0.2, 0.3]
            } else {
                [0.4, 0.5, 0.6]
            };
            json!({ "object": "embedding", "index": i, "embedding": embedding })
        })
        .collect();

    Json(json!({
        "object": "list",
        "data": data,
        "model": "mock-embedding-model"
    }))
}

async fn serve_mock_embeddings() -> (
    String,
    MockEmbeddingState,
    tokio::task::JoinHandle<Result<(), std::io::Error>>,
) {
    let state = MockEmbeddingState::default();
    let router = Router::new()
        .route("/v1/embeddings", post(mock_openai_embeddings))
        .with_state(state.clone());
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind mock embedding server");
    let addr = listener.local_addr().expect("mock embedding local_addr");
    let join = tokio::spawn(async move { axum::serve(listener, router).await });
    (format!("http://{addr}"), state, join)
}

async fn post_json_rpc(rpc_base: &str, id: i64, method: &str, params: Value) -> Value {
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(30))
        .build()
        .expect("build reqwest client");
    let body = json!({
        "jsonrpc": "2.0",
        "id": id,
        "method": method,
        "params": params
    });
    let url = format!("{}/rpc", rpc_base.trim_end_matches('/'));
    let resp = client
        .post(&url)
        .header(AUTHORIZATION, format!("Bearer {}", rpc_token()))
        .json(&body)
        .send()
        .await
        .unwrap_or_else(|e| panic!("POST {url}: {e}"));
    assert!(
        resp.status().is_success(),
        "HTTP error {} calling {}",
        resp.status(),
        method
    );
    resp.json::<Value>()
        .await
        .unwrap_or_else(|e| panic!("deserialize json for {method}: {e}"))
}

// ── Assertion helpers ─────────────────────────────────────────────────────────

fn assert_no_rpc_error<'a>(v: &'a Value, ctx: &str) -> &'a Value {
    if let Some(err) = v.get("error") {
        panic!("{ctx}: unexpected JSON-RPC error: {err}");
    }
    v.get("result")
        .unwrap_or_else(|| panic!("{ctx}: missing 'result' field in: {v}"))
}

// ── Test scaffolding: set up HOME + OPENHUMAN_WORKSPACE then start RPC server ─

async fn setup_embeddings_test() -> (
    String,
    tempfile::TempDir,
    (EnvVarGuard, EnvVarGuard, EnvVarGuard, EnvVarGuard),
    tokio::task::JoinHandle<Result<(), std::io::Error>>,
) {
    let tmp = tempdir().expect("tempdir");
    let home = tmp.path().to_path_buf();
    let openhuman_home = home.join(".openhuman");

    write_min_config(&openhuman_home);
    // Also write user-local config so that post-login config loads succeed.
    write_min_config(&openhuman_home.join("users").join("local"));

    let home_guard = EnvVarGuard::set_to_path("HOME", &home);
    let workspace_guard = EnvVarGuard::unset("OPENHUMAN_WORKSPACE");
    let backend_guard = EnvVarGuard::unset("BACKEND_URL");
    let vite_guard = EnvVarGuard::unset("VITE_BACKEND_URL");

    let (addr, join) = serve_on_ephemeral().await;
    let rpc_base = format!("http://{addr}");

    (
        rpc_base,
        tmp,
        (home_guard, workspace_guard, backend_guard, vite_guard),
        join,
    )
}

// ── Tests ─────────────────────────────────────────────────────────────────────

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_get_settings_returns_catalog() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    let resp = post_json_rpc(&rpc_base, 1, "openhuman.embeddings_get_settings", json!({})).await;
    let result = assert_no_rpc_error(&resp, "embeddings_get_settings");

    // Unwrap one more layer if the controller wraps in {result: ...}
    let inner = result.get("result").unwrap_or(result);

    // Required top-level fields
    assert!(
        inner.get("provider").is_some(),
        "get_settings result missing 'provider': {inner}"
    );
    assert!(
        inner.get("model").is_some(),
        "get_settings result missing 'model': {inner}"
    );
    assert!(
        inner.get("dimensions").is_some(),
        "get_settings result missing 'dimensions': {inner}"
    );

    // `effective_provider` must survive serialization to the wire, not just
    // exist on the handler's return value (#5402). The frontend budget warning
    // gates on this field: if it silently stopped being emitted, the hook would
    // fall back to `provider` — which is exactly the stale value that produced
    // the false "memory has stopped growing" alarm for local-embeddings users.
    let effective = inner
        .get("effective_provider")
        .and_then(Value::as_str)
        .unwrap_or_else(|| panic!("get_settings result missing 'effective_provider': {inner}"));
    assert!(
        [
            "ollama",
            "custom",
            "cloud",
            "none",
            "unconfigured",
            "unknown"
        ]
        .contains(&effective),
        "effective_provider must be one of the documented slugs, got {effective:?}"
    );

    // Provider catalog
    let providers = inner
        .get("providers")
        .and_then(Value::as_array)
        .unwrap_or_else(|| panic!("get_settings result missing 'providers' array: {inner}"));
    assert!(
        providers.len() >= 5,
        "expected at least 5 providers in catalog, got {}: {providers:?}",
        providers.len()
    );

    // Each entry has the required fields
    for entry in providers.iter() {
        for field in &["slug", "label", "requires_api_key", "models"] {
            assert!(
                entry.get(field).is_some(),
                "provider entry missing '{field}': {entry}"
            );
        }
    }

    // Managed provider should not require an API key
    let managed = providers
        .iter()
        .find(|e| e.get("slug").and_then(Value::as_str) == Some("managed"))
        .expect("catalog must include 'managed' provider");
    assert_eq!(
        managed.get("requires_api_key").and_then(Value::as_bool),
        Some(false),
        "managed provider must not require an API key"
    );

    // Voyage provider requires a key
    let voyage = providers
        .iter()
        .find(|e| e.get("slug").and_then(Value::as_str) == Some("voyage"))
        .expect("catalog must include 'voyage' provider");
    assert_eq!(
        voyage.get("requires_api_key").and_then(Value::as_bool),
        Some(true),
        "voyage provider must require an API key"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_update_settings_switches_provider() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    // Switch to "none" (noop) which has 0 dimensions.
    let update = post_json_rpc(
        &rpc_base,
        2,
        "openhuman.embeddings_update_settings",
        json!({ "provider": "none" }),
    )
    .await;
    let update_result = assert_no_rpc_error(&update, "embeddings_update_settings");
    let inner = update_result.get("result").unwrap_or(update_result);

    assert_eq!(
        inner.get("provider").and_then(Value::as_str),
        Some("none"),
        "update_settings should return provider=none: {inner}"
    );

    // Subsequent get_settings should reflect the change
    let get = post_json_rpc(&rpc_base, 3, "openhuman.embeddings_get_settings", json!({})).await;
    let get_result = assert_no_rpc_error(&get, "embeddings_get_settings after update");
    let get_inner = get_result.get("result").unwrap_or(get_result);

    assert_eq!(
        get_inner.get("provider").and_then(Value::as_str),
        Some("none"),
        "get_settings after update should show provider=none: {get_inner}"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_update_settings_dimension_change_applies_without_a_wipe() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    // First set provider to voyage (a provider that supports multiple dims)
    let _ = post_json_rpc(
        &rpc_base,
        10,
        "openhuman.embeddings_update_settings",
        json!({ "provider": "voyage", "model": "voyage-3-large", "dimensions": 1024 }),
    )
    .await;

    // Memory v2 keeps no local vector store, so there is nothing to wipe: a
    // dimension change applies directly and never returns a wipe sentinel.
    let resp = post_json_rpc(
        &rpc_base,
        11,
        "openhuman.embeddings_update_settings",
        json!({ "dimensions": 512 }),
    )
    .await;
    let result = assert_no_rpc_error(&resp, "update_settings dimension change");
    let inner = result.get("result").unwrap_or(result);
    assert!(
        inner.get("error").is_none(),
        "a dimension change must not return an error sentinel: {inner}"
    );
    assert_eq!(
        inner.get("dimensions").and_then(Value::as_u64),
        Some(512),
        "the new dimensions are applied: {inner}"
    );

    // The retired wipe confirmation is no longer a parameter.
    let stale = post_json_rpc(
        &rpc_base,
        12,
        "openhuman.embeddings_update_settings",
        json!({ "dimensions": 256, "confirm_wipe": true }),
    )
    .await;
    assert!(
        stale.get("error").is_some(),
        "confirm_wipe is an unknown param now: {stale}"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_set_and_clear_api_key() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    // Store a key for voyage
    let set_resp = post_json_rpc(
        &rpc_base,
        20,
        "openhuman.embeddings_set_api_key",
        json!({ "provider": "voyage", "api_key": "voy-test-1234" }),
    )
    .await;
    let set_result = assert_no_rpc_error(&set_resp, "embeddings_set_api_key");
    let set_inner = set_result.get("result").unwrap_or(set_result);
    assert_eq!(
        set_inner.get("stored").and_then(Value::as_bool),
        Some(true),
        "set_api_key should report stored=true: {set_inner}"
    );

    // get_settings should now show has_api_key=true for voyage
    let get_resp = post_json_rpc(
        &rpc_base,
        21,
        "openhuman.embeddings_get_settings",
        json!({}),
    )
    .await;
    let get_result = assert_no_rpc_error(&get_resp, "get_settings after set_api_key");
    let get_inner = get_result.get("result").unwrap_or(get_result);
    let providers = get_inner
        .get("providers")
        .and_then(Value::as_array)
        .expect("providers array missing");
    let voyage = providers
        .iter()
        .find(|e| e.get("slug").and_then(Value::as_str) == Some("voyage"))
        .expect("voyage provider missing from catalog");
    assert_eq!(
        voyage.get("has_api_key").and_then(Value::as_bool),
        Some(true),
        "voyage should report has_api_key=true after storing key: {voyage}"
    );

    // Clear the key
    let clear_resp = post_json_rpc(
        &rpc_base,
        22,
        "openhuman.embeddings_clear_api_key",
        json!({ "provider": "voyage" }),
    )
    .await;
    let clear_result = assert_no_rpc_error(&clear_resp, "embeddings_clear_api_key");
    let clear_inner = clear_result.get("result").unwrap_or(clear_result);
    assert_eq!(
        clear_inner.get("cleared").and_then(Value::as_bool),
        Some(true),
        "clear_api_key should report cleared=true: {clear_inner}"
    );

    // has_api_key should be false again
    let get2_resp = post_json_rpc(
        &rpc_base,
        23,
        "openhuman.embeddings_get_settings",
        json!({}),
    )
    .await;
    let get2_result = assert_no_rpc_error(&get2_resp, "get_settings after clear_api_key");
    let get2_inner = get2_result.get("result").unwrap_or(get2_result);
    let providers2 = get2_inner
        .get("providers")
        .and_then(Value::as_array)
        .expect("providers array missing after clear");
    let voyage2 = providers2
        .iter()
        .find(|e| e.get("slug").and_then(Value::as_str) == Some("voyage"))
        .expect("voyage missing after clear");
    assert_eq!(
        voyage2.get("has_api_key").and_then(Value::as_bool),
        Some(false),
        "voyage should report has_api_key=false after clearing key: {voyage2}"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_test_connection_with_none_provider() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    // Switch to "none" so test_connection uses the noop provider (no network).
    let _ = post_json_rpc(
        &rpc_base,
        30,
        "openhuman.embeddings_update_settings",
        json!({ "provider": "none" }),
    )
    .await;

    let resp = post_json_rpc(
        &rpc_base,
        31,
        "openhuman.embeddings_test_connection",
        json!({}),
    )
    .await;
    let result = assert_no_rpc_error(&resp, "embeddings_test_connection none");
    let inner = result.get("result").unwrap_or(result);

    // The noop provider's embed() returns an empty vec, which causes the
    // test_connection result to show success=false with an "Empty embedding
    // result" error — that's acceptable. What we assert is that the call
    // completes without a JSON-RPC level error and returns a structured body.
    assert!(
        inner.get("success").is_some(),
        "test_connection should return a 'success' field: {inner}"
    );
    assert!(
        inner.get("provider").is_some(),
        "test_connection should return a 'provider' field: {inner}"
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_embed_with_none_returns_empty_vectors() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    // Switch to noop so embed() doesn't require network.
    let _ = post_json_rpc(
        &rpc_base,
        40,
        "openhuman.embeddings_update_settings",
        json!({ "provider": "none" }),
    )
    .await;

    let resp = post_json_rpc(
        &rpc_base,
        41,
        "openhuman.embeddings_embed",
        json!({ "inputs": ["hello", "world"] }),
    )
    .await;
    let result = assert_no_rpc_error(&resp, "embeddings_embed none");
    let inner = result.get("result").unwrap_or(result);

    // The inert TinyAgents adapter preserves input cardinality with empty vectors.
    assert_eq!(
        inner.get("count").and_then(Value::as_u64),
        Some(2),
        "noop provider should preserve input count: {inner}"
    );
    assert_eq!(
        inner.get("dimensions").and_then(Value::as_u64),
        Some(0),
        "noop provider should return dimensions=0: {inner}"
    );
    let vectors = inner
        .get("vectors")
        .and_then(Value::as_array)
        .expect("embed result must include 'vectors' array: {inner}");
    assert_eq!(vectors, &vec![json!([]), json!([])]);
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_embed_with_custom_openai_endpoint_round_trips_vectors_and_api_key() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;
    let (mock_base, mock_state, mock_join) = serve_mock_embeddings().await;

    let set_key = post_json_rpc(
        &rpc_base,
        45,
        "openhuman.embeddings_set_api_key",
        json!({ "provider": "custom", "api_key": "custom-embedding-key" }),
    )
    .await;
    assert_no_rpc_error(&set_key, "embeddings_set_api_key custom");

    let update = post_json_rpc(
        &rpc_base,
        46,
        "openhuman.embeddings_update_settings",
        json!({
            "provider": "custom",
            "custom_endpoint": mock_base,
            "model": "mock-embedding-model",
            "dimensions": 3
        }),
    )
    .await;
    let update_result = assert_no_rpc_error(&update, "embeddings_update_settings custom");
    let update_inner = update_result.get("result").unwrap_or(update_result);
    let expected_provider = format!("custom:{mock_base}");
    assert_eq!(
        update_inner.get("provider").and_then(Value::as_str),
        Some(expected_provider.as_str())
    );

    let embed = post_json_rpc(
        &rpc_base,
        47,
        "openhuman.embeddings_embed",
        json!({ "inputs": ["first custom text", "second custom text"] }),
    )
    .await;
    let embed_result = assert_no_rpc_error(&embed, "embeddings_embed custom");
    let inner = embed_result.get("result").unwrap_or(embed_result);

    assert_eq!(
        inner.get("provider").and_then(Value::as_str),
        Some("custom")
    );
    assert_eq!(
        inner.get("model").and_then(Value::as_str),
        Some("mock-embedding-model")
    );
    assert_eq!(inner.get("count").and_then(Value::as_u64), Some(2));
    assert_eq!(inner.get("dimensions").and_then(Value::as_u64), Some(3));
    let last_component = inner
        .pointer("/vectors/1/2")
        .and_then(Value::as_f64)
        .expect("second vector third component");
    assert!(
        (last_component - 0.6).abs() < 0.000_001,
        "expected f32-roundtripped component near 0.6, got {last_component}"
    );

    let requests = mock_state.requests.lock().expect("mock requests lock");
    // Two hits: (0) the save-time connectivity probe update_settings now runs
    // against custom endpoints (TAURI-RUST-5JR prevention), (1) the real embed.
    assert_eq!(
        requests.len(),
        2,
        "expected one save-time probe + one embed call"
    );
    assert_eq!(
        requests[0].pointer("/input/0").and_then(Value::as_str),
        Some("connection test"),
        "first call must be the save-time validation probe"
    );
    assert_eq!(
        requests[1].get("model").and_then(Value::as_str),
        Some("mock-embedding-model")
    );
    assert_eq!(
        requests[1].pointer("/input/0").and_then(Value::as_str),
        Some("first custom text")
    );
    drop(requests);

    let auth_headers = mock_state
        .auth_headers
        .lock()
        .expect("mock auth headers lock");
    assert_eq!(
        auth_headers.first().and_then(|value| value.as_deref()),
        Some("Bearer custom-embedding-key")
    );

    mock_join.abort();
}

/// A mock "OpenAI-compatible" host that has NO embeddings route — every POST to
/// `/v1/embeddings` 404s, exactly like a chat-only provider (DeepSeek) does.
async fn serve_mock_embeddings_no_api(
) -> (String, tokio::task::JoinHandle<Result<(), std::io::Error>>) {
    async fn not_found() -> (axum::http::StatusCode, &'static str) {
        (axum::http::StatusCode::NOT_FOUND, "Not Found")
    }
    let router = Router::new().route("/v1/embeddings", post(not_found));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
        .await
        .expect("bind no-api mock server");
    let addr = listener.local_addr().expect("no-api mock local_addr");
    let join = tokio::spawn(async move { axum::serve(listener, router).await });
    (format!("http://{addr}"), join)
}

/// TAURI-RUST-5JR prevention: `update_settings` must probe a custom endpoint
/// and REFUSE to persist one that has no embeddings API (404), returning
/// `EMBEDDINGS_ENDPOINT_NO_API` and leaving the stored provider unchanged — so
/// the 404-on-every-re-embed Sentry flood can never be configured.
#[tokio::test(flavor = "multi_thread")]
async fn embeddings_update_settings_rejects_endpoint_with_no_embeddings_api() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;
    let (mock_base, mock_join) = serve_mock_embeddings_no_api().await;

    // Snapshot the provider before the rejected save.
    let before = post_json_rpc(
        &rpc_base,
        80,
        "openhuman.embeddings_get_settings",
        json!({}),
    )
    .await;
    let before_result = assert_no_rpc_error(&before, "get_settings before");
    let before_inner = before_result.get("result").unwrap_or(before_result);
    let before_provider = before_inner
        .get("provider")
        .and_then(Value::as_str)
        .unwrap_or_default()
        .to_string();

    let update = post_json_rpc(
        &rpc_base,
        81,
        "openhuman.embeddings_update_settings",
        json!({
            "provider": "custom",
            "custom_endpoint": mock_base,
            "model": "mock-embedding-model",
            "dimensions": 3
        }),
    )
    .await;
    let update_result = assert_no_rpc_error(&update, "update_settings no-api endpoint");
    let update_inner = update_result.get("result").unwrap_or(update_result);
    assert_eq!(
        update_inner.get("error").and_then(Value::as_str),
        Some("EMBEDDINGS_ENDPOINT_NO_API"),
        "a no-embeddings endpoint must be rejected, not saved: {update_inner}"
    );

    // The stored provider must be unchanged — nothing was persisted.
    let after = post_json_rpc(
        &rpc_base,
        82,
        "openhuman.embeddings_get_settings",
        json!({}),
    )
    .await;
    let after_result = assert_no_rpc_error(&after, "get_settings after");
    let after_inner = after_result.get("result").unwrap_or(after_result);
    assert_eq!(
        after_inner.get("provider").and_then(Value::as_str),
        Some(before_provider.as_str()),
        "provider must be unchanged after a rejected save: {after_inner}"
    );

    mock_join.abort();
}

#[tokio::test(flavor = "multi_thread")]
async fn removed_legacy_alias_inference_embed_is_unknown() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    // The `openhuman.inference_embed` alias was removed (bfeab2f655); the
    // canonical method is `openhuman.embeddings_embed`. A caller still on the
    // old name must get "method not found", not a silent reroute.
    let resp = post_json_rpc(
        &rpc_base,
        51,
        "openhuman.inference_embed",
        json!({ "inputs": [] }),
    )
    .await;
    let message = resp
        .pointer("/error/message")
        .and_then(Value::as_str)
        .unwrap_or_default();
    assert!(
        message.contains("unknown method"),
        "the removed inference_embed alias must stay unknown: {resp}"
    );
}

/// #4056 / #5859: a Custom endpoint whose NATIVE vector width differs from the
/// width the user guessed must still verify, and the width that gets persisted
/// must be the endpoint's, not the guess.
///
/// This is the half of the change no existing test could observe.
/// `embeddings_embed_with_custom_openai_endpoint_round_trips_vectors_and_api_key`
/// configures `dimensions: 3` against a mock that returns 3-wide vectors, so
/// "honoured the guess" and "discovered the native width" produce the same
/// number and its `dimensions == 3` assertion cannot tell them apart. Here the
/// two are deliberately different: the guess is the product default (1024) and
/// the endpoint returns 3.
///
/// Before the probe was made dimension-agnostic, the save-time verification
/// enforced the guessed width, so every reachable, valid endpoint whose native
/// size was not the guess failed verification — the whole of #4056. After it,
/// `final_probe_dims` adopts the returned length for any model outside the
/// `text-embedding-3-*` family (`mock-embedding-model` is one), which is also
/// what keeps the live embed path's length guard from rejecting later embeds.
#[tokio::test(flavor = "multi_thread")]
async fn embeddings_update_settings_adopts_custom_endpoint_native_dimension() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;
    let (mock_base, _mock_state, mock_join) = serve_mock_embeddings().await;

    let update = post_json_rpc(
        &rpc_base,
        90,
        "openhuman.embeddings_update_settings",
        json!({
            "provider": "custom",
            "custom_endpoint": mock_base,
            "model": "mock-embedding-model",
            // The guess. The mock returns 3-wide vectors, so this is wrong on
            // purpose — it is the product default a user would never edit.
            "dimensions": 1024
        }),
    )
    .await;
    let update_result = assert_no_rpc_error(&update, "embeddings_update_settings native dims");
    let update_inner = update_result.get("result").unwrap_or(update_result);

    // 1. The save is NOT rejected. A mismatched guess used to fail verification.
    assert_eq!(
        update_inner.get("error").and_then(Value::as_str),
        None,
        "a reachable endpoint whose native width differs from the guess must \
         still verify, not be refused: {update_inner}"
    );
    let expected_provider = format!("custom:{mock_base}");
    assert_eq!(
        update_inner.get("provider").and_then(Value::as_str),
        Some(expected_provider.as_str()),
        "the custom provider must be persisted: {update_inner}"
    );

    // 2. The width that survives is the endpoint's 3, not the guessed 1024.
    let after = post_json_rpc(
        &rpc_base,
        91,
        "openhuman.embeddings_get_settings",
        json!({}),
    )
    .await;
    let after_result = assert_no_rpc_error(&after, "get_settings after native-dim save");
    let after_inner = after_result.get("result").unwrap_or(after_result);
    assert_eq!(
        after_inner.get("dimensions").and_then(Value::as_u64),
        Some(3),
        "the probe must adopt the endpoint's native vector width (3), not the \
         guessed 1024: {after_inner}"
    );

    mock_join.abort();
}

/// The retained Custom profile must survive config loading and JSON-RPC
/// serialization while another provider is active. The UI depends on this
/// field to reopen the populated form after a reload in Disabled mode.
#[tokio::test(flavor = "multi_thread")]
async fn embeddings_get_settings_returns_retained_custom_profile_while_disabled() {
    let _lock = env_lock_async().await;
    let (rpc_base, tmp, _guards, _join) = setup_embeddings_test().await;
    for config_path in [
        tmp.path().join(".openhuman").join("config.toml"),
        tmp.path()
            .join(".openhuman")
            .join("users")
            .join("local")
            .join("config.toml"),
    ] {
        let config = std::fs::read_to_string(&config_path).expect("read test config");
        let config = config.replace(
            "\n[secrets]",
            r#"
embeddings_provider = "none"

[custom_embeddings]
endpoint = "https://embeddings.example.com/v1"
model = "remembered-embedding-model"
dimensions = 2048

[memory]
embedding_provider = "none"
embedding_model = "remembered-embedding-model"
embedding_dimensions = 2048

[secrets]"#,
        );
        std::fs::write(&config_path, config).expect("write retained Custom profile");
    }

    let get = post_json_rpc(
        &rpc_base,
        100,
        "openhuman.embeddings_get_settings",
        json!({}),
    )
    .await;
    let get_result = assert_no_rpc_error(&get, "get settings after disabling custom");
    let get_inner = get_result.get("result").unwrap_or(get_result);
    let retained = get_inner
        .get("custom_settings")
        .unwrap_or_else(|| panic!("missing retained custom settings: {get_inner}"));

    assert_eq!(
        get_inner.get("provider").and_then(Value::as_str),
        Some("none")
    );
    assert_eq!(
        retained.get("endpoint").and_then(Value::as_str),
        Some("https://embeddings.example.com/v1")
    );
    assert_eq!(
        retained.get("model").and_then(Value::as_str),
        Some("remembered-embedding-model")
    );
    assert_eq!(
        retained.get("dimensions").and_then(Value::as_u64),
        Some(2048)
    );
}

#[tokio::test(flavor = "multi_thread")]
async fn embeddings_controllers_reject_missing_required_params() {
    let _lock = env_lock_async().await;
    let (rpc_base, _tmp, _guards, _join) = setup_embeddings_test().await;

    for (id, method) in [
        (40, "openhuman.embeddings_set_api_key"),
        (41, "openhuman.embeddings_clear_api_key"),
        (42, "openhuman.embeddings_embed"),
    ] {
        let resp = post_json_rpc(&rpc_base, id, method, json!({})).await;
        assert!(
            resp.get("error").is_some(),
            "{method} should reject missing required params: {resp}"
        );
    }
}