ltcai 11.7.0 → 12.0.0

package/latticeai/models/router/catalog.py

@@ -64,6 +64,6 @@ def parse_model_ref(model_id: str) -> tuple[str, str]:
             return provider, model
         if provider in {"local_mlx", "mlx"}:
             return "local_mlx", model
-    if model_id.startswith("local_mlx:"):
-        return "local_mlx", model_id.split(":", 1)[1]  # pragma: no cover — dead: a "local_mlx:" ref always has a ":" and returned above
+    # No trailing ``local_mlx:`` case: such a ref contains a colon, so it was
+    # already answered by the branch above.
     return "local_mlx", model_id

package/latticeai/models/router/generation.py

@@ -10,7 +10,7 @@ mistaken for the model's answer.
 import asyncio
 import base64
 import io
-from typing import Any, AsyncIterator, Optional
+from typing import Any, AsyncIterator, List, Optional
 
 from PIL import Image
 
@@ -18,17 +18,105 @@ from latticeai.core.quiet import quiet
 
 from ._contract import RouterCore as _Core
 from .branding import SYSTEM_PROMPT, _compose_system, normalize_branding
+
+
+def _system_for(context, cite_sources: bool) -> str:
+    """The system prompt for one completion.
+
+    ``cite_sources`` is what tells the two kinds of **caller** apart, and
+    v12.0.0 added it because nothing did.
+
+    A *chat* caller sends retrieved passages, and gets this product's own
+    system prompt with the Context block and
+    :data:`~latticeai.models.router.branding.CITATION_INSTRUCTION` appended.
+    :func:`_compose_system` used to do that for any non-empty context, which is
+    right there and wrong for the agent seam, whose context is the loop's own
+    executor prompt: every agent turn was being told its instructions were
+    "retrieved sources" to "cite inline as [1], [2]". A large model ignores
+    that. A small one obeys it — the acid-test 0.5B wrote
+    ``[1] 인사말을 쓸 예시 코드: …`` into a file, and a 2B answered a tool call
+    with the citation instruction itself.
+
+    A *worker* caller sends **its own whole prompt**, and gets exactly that.
+    Same fact, one flag: a context that is not a corpus is an instruction, and
+    an instruction the caller wrote is the only instruction that turn should
+    carry. Until now the chat persona was still prepended to it, so six lines
+    of "You are Lattice AI … You are a Vision-Language Model … Be concise" sat
+    in front of every guided micro-turn — including the one that asks a model to
+    write a file's contents. Small models answer the nearest instruction: a live
+    2B asked to summarise a README wrote "I am a local AI assistant that can run
+    on Apple Silicon" into the file, and a gemma-4-e2b opened two of its three
+    files with "Identity: Lattice AI (Vision-Language Model on Apple Silicon)".
+    Nothing leaked verbatim; the *subject* leaked, which is the same defect one
+    paraphrase further on. The document path has always worked this way — its
+    own system prompt replaces the chat identity entirely — so this is the
+    existing rule reaching the second caller that has a prompt of its own.
+
+    Both agent prompts still say who they are (``You are the executor of an
+    agent loop``) and every guided block still carries the run's own answer
+    language, so nothing the loop depends on is being removed — only a second,
+    competing identity. Branding normalisation is untouched: it runs over the
+    context here and over every generated string on the way out.
+
+    A worker call with **no** context still gets the product prompt. A bare
+    completion carrying no instruction at all is the one case where the identity
+    is the only thing there is to say.
+    """
+    context = normalize_branding(context)
+    if cite_sources:
+        return _compose_system(SYSTEM_PROMPT, context)
+    return context or SYSTEM_PROMPT
 from .catalog import CloudModel
 from .errors import ModelStreamError, _stream_failure
-from .loading import _mlx_sampler, executor
+from .loading import _mlx_sampler, apply_prefix, apply_stop_strings, executor
+
+
+def _stream_until_stop(
+    model,
+    tokenizer,
+    prompt: str,
+    image,
+    max_tokens: int,
+    sampler,
+    draft_model,
+    use_vlm: bool,
+    stops: List[str],
+) -> str:
+    """Generate on the worker thread, ending at the first stop string.
+
+    The buffered backends have no stop-string argument, so honouring one means
+    driving the *streaming* backend and breaking out of it. That is the whole
+    difference between a stop string and trimming the answer afterwards: the
+    tokens past the stop are never produced, which is time a 2B model would
+    otherwise spend explaining a tool call it has already emitted.
+
+    Runs inside :data:`executor`, like every other MLX call, so the GPU stream
+    stays on one thread.
+    """
+    if use_vlm:
+        from mlx_vlm import stream_generate as vlm_stream
+
+        chunks = vlm_stream(model, tokenizer, prompt=prompt, image=image, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model, draft_kind="mtp")
+    else:
+        from mlx_lm import stream_generate as lm_stream
+
+        chunks = lm_stream(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model)
+    text = ""
+    for chunk in chunks:
+        piece = chunk.text if hasattr(chunk, "text") else (chunk[0] if isinstance(chunk, tuple) else str(chunk))
+        text += piece
+        if any(marker in text for marker in stops):
+            break
+    return apply_stop_strings(text, stops)
 
 
 class _GenerationMixin(_Core):
     """The chat generation half of :class:`LLMRouter`."""
 
-    def _build_prompt(self, message: str, context: Optional[str], tokenizer) -> str:
-        context = normalize_branding(context)
-        system = _compose_system(SYSTEM_PROMPT, context)
+    def _build_prompt(
+        self, message: str, context: Optional[str], tokenizer, cite_sources: bool = True
+    ) -> str:
+        system = _system_for(context, cite_sources)
         if hasattr(tokenizer, "apply_chat_template"):
             try:
                 msgs = [{"role": "system", "content": system}, {"role": "user", "content": message}]
@@ -37,9 +125,8 @@ class _GenerationMixin(_Core):
                 quiet()
         return f"<|im_start|>system\n{system}<|im_end|>\n<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
 
-    def _build_vlm_prompt(self, model, processor, message: str, context: Optional[str], num_images: int) -> str:
-        context = normalize_branding(context)
-        system = _compose_system(SYSTEM_PROMPT, context)
+    def _build_vlm_prompt(self, model, processor, message: str, context: Optional[str], num_images: int, cite_sources: bool = True) -> str:
+        system = _system_for(context, cite_sources)
         try:
             from mlx_vlm import apply_chat_template
 
@@ -55,7 +142,7 @@ class _GenerationMixin(_Core):
             )
         except Exception as e:
             print(f"⚠️ VLM chat template fallback: {e}")
-            return self._build_prompt(message, context, processor)
+            return self._build_prompt(message, context, processor, cite_sources)
 
     async def generate_as(
         self,
@@ -65,12 +152,35 @@ class _GenerationMixin(_Core):
         max_tokens: int = 4096,
         temperature: float = 0.2,
         image_data: Optional[str] = None,
+        stop: Optional[List[str]] = None,
+        prefix: Optional[str] = None,
+        cite_sources: bool = True,
     ) -> str:
-        """Generate with a request-scoped model without changing the default."""
+        """Generate with a request-scoped model without changing the default.
+
+        ``stop`` ends the reply at the first of the given strings. Local
+        generation switches to the streaming backend to do it, so the tokens
+        after the stop are never produced rather than merely trimmed; the cloud
+        path forwards the list to the provider, which stops server-side. Absent
+        or empty means what it always meant — generate to ``max_tokens``.
+
+        ``prefix`` **starts** the reply (v12.0.0): the characters are put in the
+        model's mouth rather than requested of it, so a caller that needs the
+        answer to begin ``{"thoughts": "`` gets that by construction instead of
+        by asking nicely and repairing the result. Locally this is a real
+        prefill — the text is appended to the templated prompt after the
+        generation marker, so the model continues from mid-token rather than
+        starting a fresh turn. The returned text always begins with it; see
+        :func:`~latticeai.models.router.loading.apply_prefix` for how the three
+        backends are reconciled.
+        """
         _selected, cached = self._model_snapshot(model_id)
         if cached is None:
             return "No model."
-        return await self._generate_cached(cached, message, context, max_tokens, temperature, image_data)
+        return await self._generate_cached(
+            cached, message, context, max_tokens, temperature, image_data, stop, prefix,
+            cite_sources,
+        )
 
     async def generate(
         self,
@@ -79,8 +189,14 @@ class _GenerationMixin(_Core):
         max_tokens: int = 4096,
         temperature: float = 0.2,
         image_data: Optional[str] = None,
+        stop: Optional[List[str]] = None,
+        prefix: Optional[str] = None,
+        cite_sources: bool = True,
     ) -> str:
-        return await self.generate_as(None, message, context, max_tokens, temperature, image_data)
+        return await self.generate_as(
+            None, message, context, max_tokens, temperature, image_data, stop, prefix,
+            cite_sources,
+        )
 
     async def _generate_cached(
         self,
@@ -90,51 +206,81 @@ class _GenerationMixin(_Core):
         max_tokens: int,
         temperature: float,
         image_data: Optional[str],
+        stop: Optional[List[str]] = None,
+        prefix: Optional[str] = None,
+        cite_sources: bool = True,
     ) -> str:
         if isinstance(cached, CloudModel):
-            return await self._cloud_generate(cached, message, context, max_tokens, temperature)
+            return await self._cloud_generate(
+                cached, message, context, max_tokens, temperature, stop, prefix, cite_sources
+            )
 
         model, tokenizer, draft_model, loader_kind = self._unpack_local_cache(cached)
         use_vlm = loader_kind == "mlx_vlm"
         prompt = (
-            self._build_vlm_prompt(model, tokenizer, message, context, 1 if image_data else 0)
+            self._build_vlm_prompt(
+                model, tokenizer, message, context, 1 if image_data else 0, cite_sources
+            )
             if use_vlm
-            else self._build_prompt(message, context, tokenizer)
+            else self._build_prompt(message, context, tokenizer, cite_sources)
         )
-        
+        # The prefill. Appended *after* the chat template's generation marker,
+        # so the first sampled token continues these characters instead of
+        # opening a reply. Nothing else in the pipeline changes.
+        if prefix:
+            prompt = f"{prompt}{prefix}"
+        stops = [marker for marker in (stop or []) if marker]
+
         loop = asyncio.get_event_loop()
-        
+
         def _gen():
             import mlx.core as mx  # type: ignore[no-redef]
 
             mx.set_default_device(mx.gpu)  # type: ignore[arg-type]
+            # Decoded here, not above: base64 + PIL is CPU work, and this
+            # function is the part that runs off the event loop.
+            image = self._prep_image(image_data) if image_data else None
+            sampler = _mlx_sampler(temperature)
+            if stops:
+                return _stream_until_stop(
+                    model, tokenizer, prompt, image, max_tokens, sampler, draft_model,
+                    use_vlm, stops,
+                )
             if use_vlm:
                 from mlx_vlm import generate as vlm_gen
-                return vlm_gen(model, tokenizer, prompt=prompt, image=self._prep_image(image_data) if image_data else None, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model, draft_kind="mtp")
+                return vlm_gen(model, tokenizer, prompt=prompt, image=image, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model, draft_kind="mtp")
             from mlx_lm import generate as lm_gen
-            return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=_mlx_sampler(temperature), draft_model=draft_model)
+            return lm_gen(model, tokenizer, prompt=prompt, max_tokens=max_tokens, sampler=sampler, draft_model=draft_model)
         result = await loop.run_in_executor(executor, _gen)
         # mlx-vlm might return a GenerationResult object; extract the text
-        if hasattr(result, "text"):
-            return normalize_branding(result.text)
-        return normalize_branding(str(result))
+        text = result.text if hasattr(result, "text") else str(result)
+        return apply_prefix(prefix, normalize_branding(apply_stop_strings(text, stops)))
 
-    async def _cloud_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float) -> str:
-        context = normalize_branding(context)
-        system = _compose_system(SYSTEM_PROMPT, context)
+    async def _cloud_generate(self, cloud: CloudModel, message: str, context: Optional[str], max_tokens: int, temperature: float, stop: Optional[List[str]] = None, prefix: Optional[str] = None, cite_sources: bool = True) -> str:
+        system = _system_for(context, cite_sources)
+        stops = [marker for marker in (stop or []) if marker]
+        extra = {"stop": stops} if stops else {}
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": message},
+        ]
+        # Assistant prefill: the OpenAI-compatible way to say "continue this".
+        # Local servers (vLLM, llama.cpp, LM Studio, Ollama) honour it; a
+        # provider that does not simply reads it as context, and `apply_prefix`
+        # makes both answers the same shape for the caller.
+        if prefix:
+            messages.append({"role": "assistant", "content": prefix})
         try:
             response = await cloud.client.chat.completions.create(
                 model=cloud.model,
-                messages=[
-                    {"role": "system", "content": system},
-                    {"role": "user", "content": message},
-                ],
+                messages=messages,
                 max_tokens=max_tokens,
                 temperature=temperature,
+                **extra,
             )
         except Exception as e:
             raise RuntimeError(self._local_server_error_hint(cloud, e)) from e
-        return normalize_branding(response.choices[0].message.content or "")
+        return apply_prefix(prefix, normalize_branding(response.choices[0].message.content or ""))
 
     async def stream_generate_as(
         self,

package/latticeai/models/router/loading.py

@@ -25,6 +25,7 @@ import gc
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional
 
+from latticeai.core.quiet import quiet
 from latticeai.models.model_providers import (
     OPENAI_COMPATIBLE_PROVIDERS,
     PROVIDER_MODEL_CATALOG,
@@ -120,12 +121,145 @@ def ensure_mlx_runtime() -> None:
 def _mlx_sampler(temperature: float):
     """Build an MLX sampler callable for the given temperature.
 
-    Lattice v2.2 keeps local execution on MLX-VLM only. Returning ``None`` lets
-    MLX-VLM use its bundled default sampler without pulling another generation
-    package into the runtime contract.
+    Until v11.9.0 this discarded its argument and returned ``None``, which let
+    MLX pick its own default sampler. The cost was invisible and large: the
+    agent loop asks for 0.1 when it wants a tool call and 0.0 on the strict
+    verification re-ask, and **locally neither did anything**. A cloud model got
+    the deterministic re-ask it was designed around; the 2B model on this
+    machine got the same creative sampler it had on the first attempt, and the
+    "one strict retry" was one more roll of the same dice.
+
+    ``mlx_lm.sample_utils.make_sampler`` is the sampler both backends accept —
+    ``mlx_vlm`` takes the callable straight through — and it is already an
+    installed dependency of the text path. If it cannot be imported (an
+    MLX-VLM-only install, a version that moved it) the answer is the old one:
+    ``None``, the backend's default. A missing sampler must never be a failed
+    generation.
     """
-    _ = temperature
-    return
+    try:
+        from mlx_lm.sample_utils import make_sampler
+    except Exception:  # noqa: BLE001 — an absent sampler is not a failure
+        quiet("MLX sampler unavailable; using the backend default")
+        return None
+    try:
+        return make_sampler(temp=float(temperature))
+    except Exception:  # noqa: BLE001 — a signature change must not stop a run
+        quiet("MLX sampler construction failed; using the backend default")
+        return None
+
+
+def _declares_vision(model_id: str) -> bool:
+    """Whether this checkpoint's own config says it is multimodal.
+
+    Read from ``config.json`` rather than decided from the model's *name*: a
+    list of known vision families is a list that is wrong about every model
+    published after it was written, and "which models work" is exactly the
+    question this product must not answer with a hardcoded roster.
+
+    The three markers are the ones every MLX-VLM architecture carries — a
+    nested ``vision_config``, a ``vision_tower``, or an ``image_token_index``
+    for the placeholder the processor substitutes. A config that carries none
+    of them describes a text model.
+    """
+    import json as _json
+    from pathlib import Path as _Path
+
+    from .local_models import hf_model_dir
+
+    raw = str(model_id or "").strip()
+    candidates = []
+    explicit = _Path(raw).expanduser()
+    if raw and explicit.exists():
+        candidates.append(explicit / "config.json")
+    try:
+        candidates.append(hf_model_dir(raw) / "config.json")
+    except Exception as error:  # noqa: BLE001 — an unresolvable id is not a claim
+        quiet(f"vision probe skipped for {raw}: {error}")
+    for config_path in candidates:
+        try:
+            if not config_path.exists():
+                continue
+            data = _json.loads(config_path.read_text(encoding="utf-8"))
+        except Exception as error:  # noqa: BLE001 — an unreadable config is not a claim
+            quiet(f"vision probe skipped for {config_path}: {error}")
+            continue
+        if any(key in data for key in ("vision_config", "vision_tower", "image_token_index")):
+            return True
+    return False
+
+
+def _text_fallback_allowed(
+    model_id: str, target_model_id: str, model_type: Optional[str]
+) -> bool:
+    """Whether a failed multimodal load may be retried as a text load.
+
+    Every local model is routed to MLX-VLM first, because the recommended
+    defaults are multimodal. Until v12.0.0 the retry on the text path was
+    gated on the model *id* matching Gemma 4 — so a plain text model MLX-VLM
+    cannot open (a 0.5B Qwen, an AWQ checkpoint, any fine-tune with a text-only
+    architecture) failed to load at all, with MLX-LM sitting right there able
+    to open it. That is a roster deciding what runs, and the roster was one
+    family long. "Every small model works" cannot be true while loading is
+    gated on a name.
+
+    So the rule is now two rules, and the second is **additive**:
+
+    * the v11.9.0 Gemma 4 rule, unchanged — a Gemma 4 that is not the unified
+      (vision) architecture may always retry as text;
+    * and, new, **any model whose own ``config.json`` does not declare
+      vision.** Read from the checkpoint rather than decided from the name, so
+      a model published tomorrow is judged the same way as one published last
+      year.
+
+    A config that *does* declare vision is never silently downgraded: answering
+    an image request from a text-only load is worse than refusing it.
+    """
+    if lm_load is None:
+        return False
+    if (model_type or "").strip().lower() == "gemma4_unified":
+        return False
+    if _is_gemma4_model_id(model_id):
+        return True
+    return not _declares_vision(target_model_id)
+
+
+def apply_prefix(prefix: Optional[str], text: str) -> str:
+    """Guarantee ``text`` begins with ``prefix``, without doubling it.
+
+    The seam's contract for a forced prefix (v12.0.0) is one sentence: *the
+    reply starts with these characters*. How it got there differs by backend —
+    the local path really does prefill the prompt with them, so the model never
+    generated them and they have to be put back; a cloud provider handed an
+    assistant prefill message may echo them, may not, and may ignore the
+    message entirely. One normalisation covers all three, so the caller parses
+    one shape whichever answered.
+
+    Leading whitespace is dropped when the reply already carries the prefix:
+    a chat template that emits ``"\\n"`` before the continuation would otherwise
+    make ``startswith`` false for a reply that plainly does start with it.
+    """
+    if not prefix:
+        return text
+    stripped = text.lstrip()
+    if stripped.startswith(prefix):
+        return stripped
+    return f"{prefix}{text}"
+
+
+def apply_stop_strings(text: str, stop: Optional[List[str]]) -> str:
+    """Cut ``text`` at the earliest stop string, if any is present.
+
+    Shared by the buffered and streaming local paths so "where does this reply
+    end" has one answer. Empty stop strings are ignored: a caller that sends
+    ``""`` means "no stop", not "stop before the first character".
+    """
+    if not stop:
+        return text
+    cut = min(
+        (text.index(marker) for marker in stop if marker and marker in text),
+        default=-1,
+    )
+    return text if cut < 0 else text[:cut]
 
 
 class _LoadingMixin(_Core):
@@ -170,7 +304,6 @@ class _LoadingMixin(_Core):
         
         def _load():
             mx.set_default_device(mx.gpu)
-            is_gemma4 = _is_gemma4_model_id(model_id)
             model_type = _local_model_type(target_model_id) or _local_model_type(model_id)
             loader_kind = "mlx_vlm"
 
@@ -180,11 +313,19 @@ class _LoadingMixin(_Core):
                 print(f"🔄 Loading Target (VLM Mode): {target_model_id}...")
                 model, tokenizer = vlm_load(target_model_id)
             except Exception as vlm_error:
-                if not (is_gemma4 and model_type != "gemma4_unified" and lm_load is not None):
+                if not _text_fallback_allowed(model_id, target_model_id, model_type):
                     raise
-                print(f"⚠️ Gemma 4 MLX-VLM load failed; retrying MLX-LM text path: {vlm_error}")
+                print(f"⚠️ MLX-VLM load failed; retrying the MLX-LM text path: {vlm_error}")
                 print(f"🔄 Loading Target (LM Mode): {target_model_id}...")
-                model, tokenizer = lm_load(target_model_id)
+                try:
+                    model, tokenizer = lm_load(target_model_id)
+                except Exception:
+                    # The text path is a *fallback*: when it fails too, the
+                    # useful diagnosis is the first failure, from the loader
+                    # this model was routed to. Raising the second one would
+                    # tell an operator their multimodal model is not a text
+                    # model, which they knew.
+                    raise vlm_error from None
                 loader_kind = "mlx_lm"
 
             draft_model = None

package/latticeai/runtime/access_runtime.py

@@ -45,8 +45,10 @@ def build_access_runtime(
     # extend this trust to public or non-loopback bindings, even if an invalid
     # caller constructs this runtime with ``require_auth=False`` directly.
     externally_reachable = is_externally_reachable(config)
+    # One flag, not two: "authentication is required" is exactly
+    # ``not trusted_local_owner``, so deriving it separately only creates a
+    # pair that a later edit can put out of step.
     trusted_local_owner = not require_auth and not externally_reachable
-    effective_require_auth = bool(require_auth or externally_reachable)
 
     def get_user_role(email: str, users: Optional[Dict] = None) -> str:
         users = users or load_users()
@@ -128,9 +130,10 @@ def build_access_runtime(
             # shared local vaults, and Local User profile behavior compatible;
             # get_user_role() supplies the explicit owner authorization role.
             return ""
-        if effective_require_auth and not email:
-            raise http_exception(status_code=401, detail="인증이 필요합니다.")
-        return email or ""  # pragma: no cover — unreachable: trusted_local_owner is the exact complement of effective_require_auth
+        # Reaching here means the caller is not the trusted local owner and no
+        # session produced an email — i.e. authentication is required and was
+        # not supplied. There is no third outcome to fall through to.
+        raise http_exception(status_code=401, detail="인증이 필요합니다.")
 
     def require_admin(request: request_type) -> tuple[str, Dict]:
         users = load_users()

package/latticeai/runtime/brain_runtime.py

@@ -13,7 +13,16 @@ was requested.
 
 from __future__ import annotations
 
-from typing import Any, Callable, Mapping
+from typing import Any, Callable, Mapping, Optional, Tuple
+
+from latticeai.core.embedding_providers.autodetect import (
+    AUTO_PROVIDER,
+    Detection,
+    detect_embedder,
+    resolve_auto_provider,
+)
+
+_FALLBACK_NAMES = {"", "hash", "local", "fallback"}
 
 
 def build_embedder_runtime(
@@ -21,16 +30,26 @@ def build_embedder_runtime(
     config: Any,
     profile: Mapping[str, Any],
     resolve_embedder: Callable[..., Any],
+    detect: Optional[Callable[..., Detection]] = None,
 ) -> Any:
-    """Resolve the configured embedding provider once."""
+    """Resolve the configured embedding provider once.
 
-    provider = config.embedding_provider
-    model = config.embedding_model or str(profile.get("model") or "")
-    dim = config.embedding_dim or int(profile.get("dimensions") or 0)
-    if config.embedding_profile and provider in {"", "hash", "local", "fallback"}:
-        provider = str(profile.get("provider") or provider)
+    The resolution order is the product's, unchanged, with one addition at the
+    end: detection. What is on this machine is *always* looked up (so
+    ``GET /api/embeddings/status`` can say "a real embedder is right there"),
+    and it changes the resolution only when the operator asked for it with
+    ``LATTICEAI_EMBEDDING_PROVIDER=auto``. The finding rides back on the
+    resolved object as ``detected`` — an added attribute, so every existing
+    reader of ``ResolvedEmbedder`` is untouched.
+    """
+
+    provider, model, dim = _configured(config, profile)
+    detection = (detect or detect_embedder)(
+        configured_provider=provider, configured_model=model
+    )
+    provider, model, dim = resolve_auto_provider(provider, model, dim, detection)
 
-    return resolve_embedder(
+    resolved = resolve_embedder(
         provider,
         model=model,
         base_url=config.embedding_base_url,
@@ -38,8 +57,23 @@ def build_embedder_runtime(
         dim=dim,
         timeout=config.embedding_timeout,
         extra={"target": config.embedding_custom_target},
-        probe=provider not in {"", "hash", "local", "fallback"},
+        probe=provider not in _FALLBACK_NAMES,
     )
+    try:
+        resolved.detected = detection
+    except AttributeError:  # pragma: no cover - a stand-in without __dict__
+        pass
+    return resolved
+
+
+def _configured(config: Any, profile: Mapping[str, Any]) -> Tuple[str, str, int]:
+    """``(provider, model, dim)`` from configuration and the named profile."""
+    provider = config.embedding_provider
+    model = config.embedding_model or str(profile.get("model") or "")
+    dim = config.embedding_dim or int(profile.get("dimensions") or 0)
+    if config.embedding_profile and provider in _FALLBACK_NAMES | {AUTO_PROVIDER}:
+        provider = str(profile.get("provider") or provider)
+    return provider, model, dim
 
 
 __all__ = ["build_embedder_runtime"]