studiorelay 0.3.0__py3-none-any.whl

kimibridge/compatibility/parameters.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from kimibridge.compatibility.profiles import KIMI_PROFILE, ProviderProfile
+
+UNSUPPORTED_PARAMETERS = {
+    "metadata",
+    "parallel_tool_calls",
+    "store",
+}
+
+
+def normalize_parameters(
+    payload: dict[str, Any],
+    mode: str = "compatible",
+    profile: ProviderProfile | None = None,
+) -> dict[str, Any]:
+    if mode in {"passthrough", "strict"}:
+        return deepcopy(payload)
+
+    active_profile = profile or KIMI_PROFILE
+    keys_to_remove = active_profile.unsupported_parameters if active_profile else UNSUPPORTED_PARAMETERS
+
+    normalized = deepcopy(payload)
+    for key in keys_to_remove:
+        normalized.pop(key, None)
+    return normalized

kimibridge/compatibility/pipeline.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+from kimibridge.compatibility.model_aliases import normalize_model_aliases
+from kimibridge.compatibility.parameters import normalize_parameters
+from kimibridge.compatibility.profiles import (
+    ProviderProfile,
+    detect_provider,
+    get_provider_profile,
+)
+from kimibridge.compatibility.roles import normalize_roles
+
+
+VALID_MODES = {"compatible", "passthrough", "strict"}
+
+
+def normalize_request(
+    payload: dict[str, Any],
+    mode: str = "compatible",
+    provider: str | ProviderProfile | None = None,
+    base_url: str | None = None,
+    headers: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    if mode not in VALID_MODES:
+        raise ValueError(f"Unsupported compatibility mode: {mode}")
+
+    if isinstance(provider, ProviderProfile):
+        profile = provider
+    else:
+        profile = detect_provider(
+            model=payload.get("model") if isinstance(payload, dict) else None,
+            base_url=base_url,
+            configured_provider=provider,
+            headers=headers,
+        )
+
+    normalized = normalize_roles(payload, mode=mode, profile=profile)
+    normalized = normalize_parameters(normalized, mode=mode, profile=profile)
+    if mode != "passthrough":
+        normalized = normalize_model_aliases(normalized, profile=profile)
+    return normalized

kimibridge/compatibility/profiles.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class ProviderProfile:
+    name: str
+    supports_developer_role: bool = False
+    developer_role_target: str = "system"
+    supported_roles: frozenset[str] = frozenset({"system", "user", "assistant", "tool"})
+    unsupported_parameters: frozenset[str] = frozenset()
+    default_base_url: str = ""
+    default_models: tuple[dict[str, Any], ...] = ()
+
+
+KIMI_PROFILE = ProviderProfile(
+    name="kimi",
+    supports_developer_role=False,
+    developer_role_target="system",
+    supported_roles=frozenset({"system", "user", "assistant", "tool"}),
+    unsupported_parameters=frozenset({"metadata", "parallel_tool_calls", "store"}),
+    default_base_url="https://api.moonshot.ai",
+    default_models=(
+        {"id": "kimi-k3", "object": "model", "owned_by": "moonshot"},
+        {"id": "kimi-latest", "object": "model", "owned_by": "moonshot"},
+        {"id": "kimi-k1.5", "object": "model", "owned_by": "moonshot"},
+        {"id": "kimi-k2", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-auto", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-8k", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-32k", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-128k", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-8k-vision-preview", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-32k-vision-preview", "object": "model", "owned_by": "moonshot"},
+        {"id": "moonshot-v1-128k-vision-preview", "object": "model", "owned_by": "moonshot"},
+    ),
+)
+
+DEEPSEEK_PROFILE = ProviderProfile(
+    name="deepseek",
+    supports_developer_role=False,
+    developer_role_target="system",
+    supported_roles=frozenset({"system", "user", "assistant", "tool", "latest_reminder"}),
+    unsupported_parameters=frozenset({"metadata", "store"}),
+    default_base_url="https://api.deepseek.com",
+    default_models=(
+        {"id": "deepseek-flash", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-v4-pro", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-chat", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-reasoner", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-v3", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-v3-pro", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-r1", "object": "model", "owned_by": "deepseek"},
+        {"id": "deepseek-coder", "object": "model", "owned_by": "deepseek"},
+    ),
+)
+
+OPENAI_PROFILE = ProviderProfile(
+    name="openai",
+    supports_developer_role=True,
+    developer_role_target="developer",
+    supported_roles=frozenset({"system", "developer", "user", "assistant", "tool", "function"}),
+    unsupported_parameters=frozenset(),
+    default_base_url="https://api.openai.com",
+    default_models=(
+        {"id": "gpt-4o", "object": "model", "owned_by": "openai"},
+        {"id": "gpt-4o-mini", "object": "model", "owned_by": "openai"},
+        {"id": "o1", "object": "model", "owned_by": "openai"},
+        {"id": "o3-mini", "object": "model", "owned_by": "openai"},
+    ),
+)
+
+GENERIC_PROFILE = ProviderProfile(
+    name="generic",
+    supports_developer_role=False,
+    developer_role_target="system",
+    supported_roles=frozenset({"system", "user", "assistant", "tool"}),
+    unsupported_parameters=frozenset({"metadata", "parallel_tool_calls", "store"}),
+    default_base_url="",
+    default_models=(
+        {"id": "default-model", "object": "model", "owned_by": "generic"},
+    ),
+)
+
+PROFILES: dict[str, ProviderProfile] = {
+    "kimi": KIMI_PROFILE,
+    "moonshot": KIMI_PROFILE,
+    "deepseek": DEEPSEEK_PROFILE,
+    "openai": OPENAI_PROFILE,
+    "generic": GENERIC_PROFILE,
+}
+
+
+def get_provider_profile(name_or_alias: str | None) -> ProviderProfile:
+    if not name_or_alias:
+        return KIMI_PROFILE
+    key = name_or_alias.strip().lower()
+    return PROFILES.get(key, GENERIC_PROFILE)
+
+
+def detect_provider(
+    model: str | None = None,
+    base_url: str | None = None,
+    configured_provider: str | None = None,
+    headers: dict[str, str] | None = None,
+) -> ProviderProfile:
+    """
+    Detect provider profile based on explicit headers, upstream base URL heuristic,
+    model name heuristic, or configuration.
+    """
+    if headers:
+        for k, v in headers.items():
+            if k.lower() in {"x-bridge-provider", "x-provider"}:
+                return get_provider_profile(v)
+
+    if model:
+        m = model.lower()
+        if "deepseek" in m:
+            return DEEPSEEK_PROFILE
+        if "kimi" in m or "moonshot" in m:
+            return KIMI_PROFILE
+        if m.startswith("gpt-") or m.startswith("o1") or m.startswith("o3"):
+            return OPENAI_PROFILE
+
+    if base_url:
+        u = base_url.lower()
+        if "deepseek.com" in u:
+            return DEEPSEEK_PROFILE
+        if "moonshot.ai" in u:
+            return KIMI_PROFILE
+        if "openai.com" in u:
+            return OPENAI_PROFILE
+
+    if configured_provider and configured_provider.lower() not in {"auto", "default", "all"}:
+        return get_provider_profile(configured_provider)
+
+    return KIMI_PROFILE