Model Resolution

resolve_model

resolve_model(model_name: str, *, api_key: str) -> Model

Resolve a 'provider:model_id' string into a pydantic-ai Model.

Parameters:

Name	Type	Description	Default
model_name	str	In 'provider:model_id' format (e.g. 'openai:gpt-4.1').	required
api_key	str	API key passed to the provider constructor.	required

Raises:

Type	Description
ValueError	If the format is invalid or the provider is unknown.

Source code in orqest/utils/llm_model.py

def resolve_model(model_name: str, *, api_key: str) -> Model:
    """Resolve a 'provider:model_id' string into a pydantic-ai Model.

    Args:
        model_name: In 'provider:model_id' format (e.g. 'openai:gpt-4.1').
        api_key: API key passed to the provider constructor.

    Raises:
        ValueError: If the format is invalid or the provider is unknown.
    """
    if ":" not in model_name:
        raise ValueError(
            f"Model name {model_name!r} must use 'provider:model_id' format "
            f"(e.g., 'openai:gpt-4.1'). Update your LLM_MODEL environment variable."
        )

    provider_prefix, model_id = model_name.split(":", maxsplit=1)
    if not model_id:
        raise ValueError(
            f"Model name {model_name!r} has an empty model ID after the colon."
        )

    registry = _build_registry()
    entry = registry.get(provider_prefix)
    if entry is None:
        supported = ", ".join(sorted(registry))
        raise ValueError(
            f"Unknown provider {provider_prefix!r} in {model_name!r}. "
            f"Supported: {supported}"
        )

    model_cls, provider_cls = entry
    return model_cls(model_name=model_id, provider=provider_cls(api_key=api_key))

Reasoning

resolve_reasoning_settings

resolve_reasoning_settings(
    provider: str,
    effort: ReasoningEffort,
    *,
    base: ModelSettings | None = None,
) -> dict

Translate a unified :data:ReasoningEffort into provider-specific settings.

Parameters:

Name	Type	Description	Default
provider	str	A provider prefix ('openai', 'anthropic', …), a 'provider:model_id' string, or a pydantic-ai Model.system value (e.g. 'google-gla'). Only the provider segment is used.	required
effort	ReasoningEffort	One of 'minimal' | 'low' | 'medium' | 'high'.	required
base	ModelSettings | None	Existing ModelSettings, consulted (never mutated) so the translator can avoid clobbering an explicit max_tokens.	None

Returns:

Type	Description
dict	A dict of provider-specific ModelSettings keys to merge into the
dict	agent's model_settings.

Raises:

Type	Description
ValueError	If effort is invalid or the provider is unknown.

Source code in orqest/utils/reasoning.py

def resolve_reasoning_settings(
    provider: str,
    effort: ReasoningEffort,
    *,
    base: ModelSettings | None = None,
) -> dict:
    """Translate a unified :data:`ReasoningEffort` into provider-specific settings.

    Args:
        provider: A provider prefix (``'openai'``, ``'anthropic'``, …), a
            ``'provider:model_id'`` string, or a pydantic-ai ``Model.system``
            value (e.g. ``'google-gla'``). Only the provider segment is used.
        effort: One of ``'minimal'`` | ``'low'`` | ``'medium'`` | ``'high'``.
        base: Existing ``ModelSettings``, consulted (never mutated) so the
            translator can avoid clobbering an explicit ``max_tokens``.

    Returns:
        A dict of provider-specific ``ModelSettings`` keys to merge into the
        agent's ``model_settings``.

    Raises:
        ValueError: If ``effort`` is invalid or the provider is unknown.

    """
    if effort not in _VALID_EFFORTS:
        raise ValueError(
            f"Unknown reasoning effort {effort!r}. "
            f"Valid: {', '.join(_VALID_EFFORTS)}."
        )

    # Accept 'provider:model', 'google-gla', or a bare prefix — all collapse
    # to the registry key (e.g. 'google-gla' / 'google:gemini-pro' → 'google').
    key = provider.split(":", 1)[0].split("-", 1)[0]
    translator = _TRANSLATORS.get(key)
    if translator is None:
        supported = ", ".join(sorted(_TRANSLATORS))
        raise ValueError(
            f"Reasoning is not supported for provider {key!r}. "
            f"Supported: {supported}."
        )

    return translator(effort, base or {})