`llm`¶

Full name: tenets.models.llm

llm¶

LLM pricing and limits.

Centralized reference for model pricing and token limits. Values are best-effort and can be overridden at runtime.

Functions¶

get_model_pricing¶

Python

get_model_pricing(model: Optional[str]) -> ModelPricing

Return pricing for a model or a conservative default.

PARAMETER	DESCRIPTION
`model`	Model name (e.g., "gpt-4o", "claude-3-opus"). If None or unknown, returns a zero-cost placeholder suitable for dry runs. TYPE:`Optional[str]`

RETURNS	DESCRIPTION
`ModelPricing`	Pricing per 1K input and output tokens. TYPE:`ModelPricing`

Source code in tenets/models/llm.py

Python

def get_model_pricing(model: Optional[str]) -> ModelPricing:
    """Return pricing for a model or a conservative default.

    Args:
        model: Model name (e.g., "gpt-4o", "claude-3-opus"). If None or
            unknown, returns a zero-cost placeholder suitable for dry runs.

    Returns:
        ModelPricing: Pricing per 1K input and output tokens.
    """
    if not model:
        return ModelPricing(0.0, 0.0)
    return _PRICING.get(model, ModelPricing(0.0, 0.0))

get_model_limits¶

Python

get_model_limits(model: Optional[str]) -> ModelLimits

Return token limits for a model or a conservative default.

PARAMETER	DESCRIPTION
`model`	Model name. If None or unknown, returns a safe default budget. TYPE:`Optional[str]`

RETURNS	DESCRIPTION
`ModelLimits`	Maximum context and output tokens. TYPE:`ModelLimits`

Source code in tenets/models/llm.py

Python

def get_model_limits(model: Optional[str]) -> ModelLimits:
    """Return token limits for a model or a conservative default.

    Args:
        model: Model name. If None or unknown, returns a safe default budget.

    Returns:
        ModelLimits: Maximum context and output tokens.
    """
    if not model:
        return ModelLimits(max_context=100_000, max_output=4_096)
    return _LIMITS.get(model, ModelLimits(max_context=100_000, max_output=4_096))

estimate_cost¶

Python

estimate_cost(input_tokens: int, output_tokens: int, model: Optional[str]) -> dict[str, float]

Estimate API cost for a given token usage and model.

PARAMETER	DESCRIPTION
`input_tokens`	Number of prompt/input tokens. TYPE:`int`
`output_tokens`	Expected number of completion/output tokens. TYPE:`int`
`model`	Target model name used to look up pricing. TYPE:`Optional[str]`

RETURNS	DESCRIPTION
`dict`	Cost breakdown with keys: input_tokens, output_tokens, TYPE:`dict[str, float]`
`dict[str, float]`	input_cost, output_cost, total_cost.

Source code in tenets/models/llm.py

Python

def estimate_cost(input_tokens: int, output_tokens: int, model: Optional[str]) -> dict[str, float]:
    """Estimate API cost for a given token usage and model.

    Args:
        input_tokens: Number of prompt/input tokens.
        output_tokens: Expected number of completion/output tokens.
        model: Target model name used to look up pricing.

    Returns:
        dict: Cost breakdown with keys: input_tokens, output_tokens,
        input_cost, output_cost, total_cost.
    """
    p = get_model_pricing(model)
    input_cost = (input_tokens / 1000.0) * p.input_per_1k
    output_cost = (output_tokens / 1000.0) * p.output_per_1k
    total = input_cost + output_cost
    return {
        "input_tokens": input_tokens,
        "output_tokens": output_tokens,
        "input_cost": round(input_cost, 6),
        "output_cost": round(output_cost, 6),
        "total_cost": round(total, 6),
    }

list_supported_models¶

Python

list_supported_models() -> list[dict[str, object]]

List known models with provider, limits, and pricing.

RETURNS	DESCRIPTION
`list[dict[str, object]]`	A list of dicts: name, provider, context_tokens, input_price, output_price

Source code in tenets/models/llm.py

Python

def list_supported_models() -> list[dict[str, object]]:
    """List known models with provider, limits, and pricing.

    Returns:
        A list of dicts: name, provider, context_tokens, input_price, output_price
    """
    out: list[dict[str, object]] = []
    for name, pricing in _PRICING.items():
        limits = _LIMITS.get(name, get_model_limits(None))
        out.append(
            {
                "name": name,
                "provider": _infer_provider(name),
                "context_tokens": limits.max_context,
                "input_price": pricing.input_per_1k,
                "output_price": pricing.output_per_1k,
            }
        )
    # Sort by provider then name
    out.sort(key=lambda m: (m["provider"], m["name"]))
    return out