Skip to content

Shims API

Provider Shim

llm_rosetta.shims.provider_shim.ProviderShim dataclass 

ProviderShim(name: str, base: str, default_base_url: str | None = None, default_api_key_env: str | None = None, logo: str | None = None, model_id_field: str | None = None, from_transforms: tuple[Transform, ...] = (), to_transforms: tuple[Transform, ...] = ())

Provider identity card with optional transforms.

Attributes:

Name Type Description
name str

Canonical provider identifier (e.g. "deepseek").
base str

API standard this provider follows. Must be one of the converter type strings ("openai_chat", "anthropic", "google", "openai_responses").
default_base_url str | None

Default upstream base URL. Used by the gateway when the provider config does not specify base_url.
default_api_key_env str | None

Default environment variable name for the API key (e.g. "DEEPSEEK_API_KEY").
logo str | None

URL to the provider's logo image (SVG preferred).
model_id_field str | None

JSON field name to use as model identifier when fetching the upstream model list. Defaults to "id" when None. Useful for providers like Argo that place the actual model identifier in a non-standard field.
from_transforms tuple[Transform, ...]

Transforms applied when data comes FROM this provider (normalise dialect β†’ standard).
to_transforms tuple[Transform, ...]

Transforms applied when data goes TO this provider (standard β†’ dialect).

llm_rosetta.shims.provider_shim.register_shim 

register_shim(shim: ProviderShim) -> None

Register (or replace) a :class:ProviderShim in the global registry.

Source code in src/llm_rosetta/shims/provider_shim.py 
66
67
68
def register_shim(shim: ProviderShim) -> None:
    """Register (or replace) a :class:`ProviderShim` in the global registry."""
    _SHIM_REGISTRY[shim.name] = shim

llm_rosetta.shims.provider_shim.unregister_shim 

unregister_shim(name: str) -> ProviderShim | None

Remove and return a shim by name. Returns None if not found.

Source code in src/llm_rosetta/shims/provider_shim.py 
71
72
73
def unregister_shim(name: str) -> ProviderShim | None:
    """Remove and return a shim by name.  Returns ``None`` if not found."""
    return _SHIM_REGISTRY.pop(name, None)

llm_rosetta.shims.provider_shim.get_shim 

get_shim(name: str) -> ProviderShim | None

Look up a registered :class:ProviderShim by name.

Source code in src/llm_rosetta/shims/provider_shim.py 
76
77
78
def get_shim(name: str) -> ProviderShim | None:
    """Look up a registered :class:`ProviderShim` by *name*."""
    return _SHIM_REGISTRY.get(name)

llm_rosetta.shims.provider_shim.list_shims 

list_shims() -> list[ProviderShim]

Return all registered provider shims.

Source code in src/llm_rosetta/shims/provider_shim.py 
81
82
83
def list_shims() -> list[ProviderShim]:
    """Return all registered provider shims."""
    return list(_SHIM_REGISTRY.values())

llm_rosetta.shims.provider_shim.resolve_base 

resolve_base(name: str) -> str

Resolve a provider/shim name to its base converter type.

If name is already a known base type (e.g. "openai_chat"), it is returned unchanged. Otherwise the shim registry is consulted. If the name is not found in either, it is returned as-is (caller decides how to handle unknown names).

Source code in src/llm_rosetta/shims/provider_shim.py 
86
87
88
89
90
91
92
93
94
95
96
97
98
99
def resolve_base(name: str) -> str:
    """Resolve a provider/shim *name* to its base converter type.

    If *name* is already a known base type (e.g. ``"openai_chat"``),
    it is returned unchanged.  Otherwise the shim registry is consulted.
    If the name is not found in either, it is returned as-is (caller
    decides how to handle unknown names).
    """
    if name in _BASE_TYPES:
        return name
    shim = _SHIM_REGISTRY.get(name)
    if shim is not None:
        return shim.base
    return name

Transforms

llm_rosetta.shims.transforms.Transform module-attribute 

Transform = Callable[[dict[str, Any]], dict[str, Any]]

A pure data transformation: receives a provider body dict and returns a (possibly mutated) body dict.

llm_rosetta.shims.transforms.apply_transforms 

apply_transforms(transforms: tuple[Transform, ...], body: dict[str, Any]) -> dict[str, Any]

Apply transforms sequentially to body, returning the result.

Source code in src/llm_rosetta/shims/transforms.py 
103
104
105
106
107
108
109
def apply_transforms(
    transforms: tuple[Transform, ...], body: dict[str, Any]
) -> dict[str, Any]:
    """Apply *transforms* sequentially to *body*, returning the result."""
    for t in transforms:
        body = t(body)
    return body

llm_rosetta.shims.transforms.strip_fields 

strip_fields(*keys: str) -> Transform

Return a transform that removes keys from the body.

No-op for keys that do not exist (idempotent).

Source code in src/llm_rosetta/shims/transforms.py 
53
54
55
56
57
58
59
60
61
62
63
64
def strip_fields(*keys: str) -> Transform:
    """Return a transform that removes *keys* from the body.

    No-op for keys that do not exist (idempotent).
    """

    def _strip(body: dict[str, Any]) -> dict[str, Any]:
        for k in keys:
            body.pop(k, None)
        return body

    return _NamedTransform(_strip, f"strip_fields({', '.join(repr(k) for k in keys)})")

llm_rosetta.shims.transforms.rename_field 

rename_field(old: str, new: str) -> Transform

Return a transform that renames a top-level field.

No-op if old does not exist (idempotent).

Source code in src/llm_rosetta/shims/transforms.py 
67
68
69
70
71
72
73
74
75
76
77
78
def rename_field(old: str, new: str) -> Transform:
    """Return a transform that renames a top-level field.

    No-op if *old* does not exist (idempotent).
    """

    def _rename(body: dict[str, Any]) -> dict[str, Any]:
        if old in body:
            body[new] = body.pop(old)
        return body

    return _NamedTransform(_rename, f"rename_field({old!r}, {new!r})")

llm_rosetta.shims.transforms.set_defaults 

set_defaults(**defaults: Any) -> Transform

Return a transform that sets fields only when they are absent.

Idempotent: existing values are never overwritten.

Source code in src/llm_rosetta/shims/transforms.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def set_defaults(**defaults: Any) -> Transform:
    """Return a transform that sets fields only when they are absent.

    Idempotent: existing values are never overwritten.
    """

    def _defaults(body: dict[str, Any]) -> dict[str, Any]:
        for k, v in defaults.items():
            body.setdefault(k, v)
        return body

    return _NamedTransform(
        _defaults,
        f"set_defaults({', '.join(f'{k}={v!r}' for k, v in defaults.items())})",
    )