multiagentos 0.4.0__py3-none-any.whl

runtime/model/config.py

@@ -0,0 +1,98 @@
+"""Load provider/model configuration from project JSON without vendor-specific branches."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from core.contracts.ai import AIProvider, ModelSpec
+from runtime.model.providers import AIProviderRegistry
+
+
+DEFAULT_CONFIG_PATH = ".multiagentos/providers.json"
+
+
+class ProviderConfigLoader:
+    """Parse a declarative provider configuration into the VYRELON registry."""
+
+    def load(
+        self,
+        path: Path,
+        registry: AIProviderRegistry | None = None,
+    ) -> AIProviderRegistry:
+        target = registry or AIProviderRegistry()
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(payload, dict):
+            raise ValueError("Provider configuration root must be an object")
+
+        providers = payload.get("providers", [])
+        if not isinstance(providers, list):
+            raise ValueError("'providers' must be a list")
+
+        for provider_data in providers:
+            provider = self._provider(provider_data)
+            if provider.id in target.list_provider_ids():
+                continue
+            target.register(provider)
+        return target
+
+    def _provider(self, value: Any) -> AIProvider:
+        if not isinstance(value, dict):
+            raise ValueError("Provider entry must be an object")
+
+        provider_id = self._required_string(value, "id")
+        kind = self._required_string(value, "kind")
+        models_data = value.get("models", [])
+        if not isinstance(models_data, list):
+            raise ValueError(f"Provider {provider_id}: 'models' must be a list")
+
+        models = tuple(
+            self._model(provider_id, item)
+            for item in models_data
+        )
+        metadata = value.get("metadata", {})
+        if not isinstance(metadata, dict):
+            raise ValueError(f"Provider {provider_id}: 'metadata' must be an object")
+
+        return AIProvider(
+            id=provider_id,
+            kind=kind,
+            models=models,
+            metadata=dict(metadata),
+        )
+
+    def _model(self, provider_id: str, value: Any) -> ModelSpec:
+        if not isinstance(value, dict):
+            raise ValueError(f"Provider {provider_id}: model entry must be an object")
+
+        model_id = self._required_string(value, "id")
+        capabilities = value.get("capabilities", [])
+        if not isinstance(capabilities, list) or not all(
+            isinstance(item, str) for item in capabilities
+        ):
+            raise ValueError(
+                f"Provider {provider_id}, model {model_id}: "
+                "'capabilities' must be a list of strings"
+            )
+
+        metadata = value.get("metadata", {})
+        if not isinstance(metadata, dict):
+            raise ValueError(
+                f"Provider {provider_id}, model {model_id}: "
+                "'metadata' must be an object"
+            )
+
+        return ModelSpec(
+            id=model_id,
+            provider_id=provider_id,
+            capabilities=frozenset(capabilities),
+            metadata=dict(metadata),
+        )
+
+    @staticmethod
+    def _required_string(value: dict[str, Any], key: str) -> str:
+        item = value.get(key)
+        if not isinstance(item, str) or not item:
+            raise ValueError(f"Configuration field '{key}' must be a non-empty string")
+        return item

runtime/model/credentials.py

@@ -0,0 +1,42 @@
+"""Environment-based credential validation for model providers."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Mapping
+
+
+@dataclass(frozen=True)
+class CredentialCheck:
+    """Non-secret result of checking one environment-backed credential."""
+
+    environment_variable: str
+    present: bool
+
+
+class EnvironmentCredentialResolver:
+    """Resolve credentials from environment variables without persisting secrets."""
+
+    def resolve(self, environment_variable: str) -> str:
+        value = os.environ.get(environment_variable)
+        if not value:
+            raise RuntimeError(
+                f"Required model credential environment variable is missing: "
+                f"{environment_variable}"
+            )
+        return value
+
+    def check(self, environment_variables: list[str]) -> tuple[CredentialCheck, ...]:
+        return tuple(
+            CredentialCheck(
+                environment_variable=name,
+                present=bool(os.environ.get(name)),
+            )
+            for name in environment_variables
+        )
+
+    def check_mapping(
+        self, header_env: Mapping[str, str]
+    ) -> tuple[CredentialCheck, ...]:
+        return self.check(list(header_env.values()))

runtime/model/factory.py

@@ -0,0 +1,82 @@
+"""Materialize generic model adapters from declarative provider configuration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from runtime.model.cli import CLIModelAdapter
+from runtime.model.http import HTTPModelAdapter
+from runtime.policy import ExecutionPolicy
+
+
+class ConfiguredAdapterFactory:
+    """Build only the provider-neutral adapters supported by MultiAgentOS."""
+
+    def build(
+        self,
+        adapter_id: str,
+        metadata: dict[str, object],
+        policy: ExecutionPolicy | None = None,
+    ):
+        kind = str(metadata.get("adapter_kind", adapter_id))
+        effective_policy = policy or ExecutionPolicy()
+
+        if kind == "cli":
+            command = metadata.get("command")
+            if not isinstance(command, list) or not all(
+                isinstance(part, str) and part for part in command
+            ):
+                raise ValueError(
+                    f"CLI adapter {adapter_id} requires metadata.command as a non-empty list"
+                )
+            timeout = metadata.get("timeout", 300)
+            if not isinstance(timeout, (int, float)) or timeout <= 0:
+                raise ValueError(f"CLI adapter {adapter_id} timeout must be positive")
+            return CLIModelAdapter(
+                command=tuple(command),
+                policy=effective_policy,
+                timeout=float(timeout),
+            )
+
+        if kind == "http":
+            endpoint = metadata.get("endpoint")
+            if not isinstance(endpoint, str) or not endpoint:
+                raise ValueError(
+                    f"HTTP adapter {adapter_id} requires metadata.endpoint"
+                )
+
+            headers = self._string_mapping(metadata.get("headers", {}), "headers")
+            header_env = self._string_mapping(
+                metadata.get("header_env", {}), "header_env"
+            )
+            request_template = metadata.get("request_template", {})
+            if not isinstance(request_template, dict):
+                raise ValueError(
+                    f"HTTP adapter {adapter_id} request_template must be an object"
+                )
+            response_path = metadata.get("response_path", ["text"])
+            if not isinstance(response_path, list) or not all(
+                isinstance(part, str) for part in response_path
+            ):
+                raise ValueError(
+                    f"HTTP adapter {adapter_id} response_path must be a list of strings"
+                )
+            return HTTPModelAdapter(
+                endpoint=endpoint,
+                headers=headers,
+                header_env=header_env,
+                request_template=request_template,
+                response_path=tuple(response_path),
+                policy=effective_policy,
+            )
+
+        raise ValueError(f"Unsupported model adapter kind: {kind}")
+
+    @staticmethod
+    def _string_mapping(value: Any, field_name: str) -> dict[str, str]:
+        if not isinstance(value, dict) or not all(
+            isinstance(key, str) and isinstance(item, str)
+            for key, item in value.items()
+        ):
+            raise ValueError(f"{field_name} must be an object of strings")
+        return dict(value)

runtime/model/http.py

@@ -0,0 +1,78 @@
+"""Generic HTTP JSON model adapter."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any
+
+from core.contracts.ai import ModelSpec
+from core.contracts.model_runtime import ModelRequest, ModelResponse
+from runtime.policy import ExecutionPolicy
+
+
+@dataclass(frozen=True)
+class HTTPModelAdapter:
+    endpoint: str
+    headers: dict[str, str] = field(default_factory=dict)
+    header_env: dict[str, str] = field(default_factory=dict)
+    request_template: dict[str, Any] = field(
+        default_factory=lambda: {
+            "model": "{model_id}",
+            "prompt": "{prompt}",
+            "system": "{system}",
+        }
+    )
+    response_path: tuple[str, ...] = ("text",)
+    policy: ExecutionPolicy = ExecutionPolicy(allow_network=True)
+
+    def generate(self, model: ModelSpec, request: ModelRequest) -> ModelResponse:
+        if not self.policy.permits("network"):
+            raise PermissionError("Network model execution is disabled by policy")
+
+        payload = self._render(self.request_template, model, request)
+        headers = {"Content-Type": "application/json", **self.headers}
+        for header, env_name in self.header_env.items():
+            value = os.environ.get(env_name)
+            if not value:
+                raise RuntimeError(f"Required model credential environment variable is missing: {env_name}")
+            headers[header] = value
+
+        body = json.dumps(payload).encode("utf-8")
+        http_request = urllib.request.Request(
+            self.endpoint,
+            data=body,
+            headers=headers,
+            method="POST",
+        )
+        with urllib.request.urlopen(http_request, timeout=300) as response:
+            data = json.loads(response.read().decode("utf-8"))
+
+        value: Any = data
+        for part in self.response_path:
+            if isinstance(value, dict):
+                value = value[part]
+            elif isinstance(value, list):
+                value = value[int(part)]
+            else:
+                raise ValueError(f"Cannot resolve response path at: {part}")
+
+        if not isinstance(value, str):
+            raise ValueError("Configured model response path must resolve to text")
+
+        return ModelResponse(text=value, model_id=model.id, metadata={"adapter": "http"})
+
+    def _render(self, value: Any, model: ModelSpec, request: ModelRequest) -> Any:
+        if isinstance(value, str):
+            return (
+                value.replace("{model_id}", model.id)
+                .replace("{prompt}", request.prompt)
+                .replace("{system}", request.system or "")
+            )
+        if isinstance(value, dict):
+            return {key: self._render(item, model, request) for key, item in value.items()}
+        if isinstance(value, list):
+            return [self._render(item, model, request) for item in value]
+        return value

runtime/model/invoker.py

@@ -0,0 +1,16 @@
+"""Model invocation service."""
+
+from core.contracts.ai import ModelSpec
+from core.contracts.model_runtime import ModelRequest, ModelResponse
+from runtime.model.registry import ModelAdapterRegistry
+
+
+class ModelInvoker:
+    def __init__(self, registry: ModelAdapterRegistry) -> None:
+        self.registry = registry
+
+    def generate(self, model: ModelSpec, request: ModelRequest) -> ModelResponse:
+        adapter_id = model.metadata.get("adapter_id", model.provider_id)
+        if not isinstance(adapter_id, str) or not adapter_id:
+            raise ValueError(f"Invalid adapter id for model: {model.id}")
+        return self.registry.get(adapter_id).generate(model, request)

runtime/model/materializer.py

@@ -0,0 +1,101 @@
+"""Materialize declarative provider configuration into executable adapters."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from core.contracts.ai import AIProvider, ModelSpec
+from core.contracts.model_runtime import ModelAdapter
+from runtime.model.credentials import EnvironmentCredentialResolver
+from runtime.model.native import (
+    AnthropicMessagesToolAdapter,
+    GeminiGenerateContentToolAdapter,
+    OpenAIResponsesToolAdapter,
+)
+from runtime.model.registry import ModelAdapterRegistry
+from runtime.policy import ExecutionPolicy
+
+
+@dataclass(frozen=True)
+class ProviderMaterialization:
+    """Executable adapters plus non-secret credential checks."""
+
+    adapters: ModelAdapterRegistry
+    credential_checks: tuple[object, ...]
+
+
+class NativeProviderMaterializer:
+    """Build provider-native adapters from AIProvider metadata.
+
+    Provider configuration remains declarative; this class is the only place that
+    maps provider kinds to concrete native adapters.
+    """
+
+    _CREDENTIALS = {
+        "openai": "OPENAI_API_KEY",
+        "anthropic": "ANTHROPIC_API_KEY",
+        "gemini": "GEMINI_API_KEY",
+    }
+
+    def __init__(
+        self,
+        *,
+        policy: ExecutionPolicy | None = None,
+        credentials: EnvironmentCredentialResolver | None = None,
+    ) -> None:
+        self.policy = policy or ExecutionPolicy()
+        self.credentials = credentials or EnvironmentCredentialResolver()
+
+    def materialize(
+        self,
+        providers: tuple[AIProvider, ...],
+        registry: ModelAdapterRegistry | None = None,
+        *,
+        validate_credentials: bool = False,
+    ) -> ProviderMaterialization:
+        target = registry or ModelAdapterRegistry()
+        checks = []
+        for provider in providers:
+            kind = provider.kind.lower()
+            adapter_id = str(provider.metadata.get("adapter_id", provider.id))
+            adapter = self._adapter(kind, provider)
+            target.register(adapter_id, adapter)
+            for model in provider.models:
+                model_adapter_id = str(model.metadata.get("adapter_id", adapter_id))
+                if model_adapter_id != adapter_id and model_adapter_id not in target.list():
+                    target.register(model_adapter_id, adapter)
+            if validate_credentials:
+                env = str(metadata_env(provider, kind))
+                if env:
+                    checks.extend(self.credentials.check([env]))
+        return ProviderMaterialization(target, tuple(checks))
+
+    def _adapter(self, kind: str, provider: AIProvider) -> ModelAdapter:
+        metadata = provider.metadata
+        policy = self.policy
+        if kind in {"openai", "openai_responses"}:
+            return OpenAIResponsesToolAdapter(
+                api_key_env=str(metadata.get("api_key_env", "OPENAI_API_KEY")),
+                endpoint=str(metadata.get("endpoint", "https://api.openai.com/v1/responses")),
+                policy=policy,
+            )
+        if kind in {"anthropic", "anthropic_messages"}:
+            return AnthropicMessagesToolAdapter(
+                api_key_env=str(metadata.get("api_key_env", "ANTHROPIC_API_KEY")),
+                endpoint=str(metadata.get("endpoint", "https://api.anthropic.com/v1/messages")),
+                api_version=str(metadata.get("api_version", "2023-06-01")),
+                max_tokens=int(metadata.get("max_tokens", 4096)),
+                policy=policy,
+            )
+        if kind in {"gemini", "gemini_generate_content"}:
+            return GeminiGenerateContentToolAdapter(
+                api_key_env=str(metadata.get("api_key_env", "GEMINI_API_KEY")),
+                endpoint_base=str(metadata.get("endpoint_base", "https://generativelanguage.googleapis.com/v1beta/models")),
+                policy=policy,
+            )
+        raise ValueError(f"Unsupported native provider kind: {provider.kind}")
+
+
+def metadata_env(provider: AIProvider, kind: str) -> str:
+    default = NativeProviderMaterializer._CREDENTIALS.get(kind, "")
+    return str(provider.metadata.get("api_key_env", default))

runtime/model/native.py

@@ -0,0 +1,244 @@
+"""Native HTTP provider adapters for VYRELON Tool Calling."""
+from __future__ import annotations
+import json
+import os
+import re
+import urllib.parse
+import urllib.request
+from urllib.error import HTTPError, URLError
+from dataclasses import dataclass
+from typing import Any
+from core.contracts.ai import ModelSpec
+from core.contracts.model_runtime import ModelRequest, ModelResponse
+from core.contracts.vyrelon_runtime import ToolSpec
+from runtime.policy import ExecutionPolicy
+
+def _tool_name(name: str) -> str:
+    return re.sub(r"[^A-Za-z0-9_-]", "_", name)[:64] or "tool"
+
+def _tool_defs(tools: tuple[ToolSpec, ...]) -> tuple[list[dict[str, Any]], dict[str, str]]:
+    aliases, used, out = {}, set(), []
+    for tool in tools:
+        alias, base = _tool_name(tool.id), _tool_name(tool.id)
+        index = 2
+        while alias in used:
+            alias = f"{base}_{index}"
+            index += 1
+        used.add(alias)
+        aliases[alias] = tool.id
+        out.append({"name": alias, "description": tool.description, "parameters": tool.input_schema or {"type": "object", "properties": {}}})
+    return out, aliases
+
+def _request(endpoint: str, payload: dict[str, Any], headers: dict[str, str], policy: ExecutionPolicy) -> tuple[dict[str, Any], dict[str, str]]:
+    if not policy.permits("network"):
+        raise PermissionError("Network model execution is disabled by policy")
+    req = urllib.request.Request(endpoint, data=json.dumps(payload).encode(), headers={"Content-Type": "application/json", **headers}, method="POST")
+    try:
+        with urllib.request.urlopen(req, timeout=300) as response:
+            data = json.loads(response.read().decode())
+            response_headers = {str(k).lower(): str(v) for k, v in response.headers.items()}
+    except HTTPError as exc:
+        raise RuntimeError(f"provider request failed with HTTP {exc.code}") from exc
+    except URLError as exc:
+        raise RuntimeError("provider request failed: network error") from exc
+    if not isinstance(data, dict):
+        raise ValueError("provider response must be a JSON object")
+    return data, response_headers
+
+@dataclass(frozen=True)
+class OpenAIResponsesToolAdapter:
+    api_key_env: str = "OPENAI_API_KEY"
+    endpoint: str = "https://api.openai.com/v1/responses"
+    policy: ExecutionPolicy = ExecutionPolicy(allow_network=True)
+    def generate(self, model: ModelSpec, request: ModelRequest) -> ModelResponse:
+        return self._generate(model, request, ())
+    def generate_with_tools(self, model: ModelSpec, request: ModelRequest, tools: tuple[ToolSpec, ...]) -> ModelResponse:
+        return self._generate(model, request, tools)
+    def _generate(self, model: ModelSpec, request: ModelRequest, tools: tuple[ToolSpec, ...]) -> ModelResponse:
+        key = os.environ.get(self.api_key_env)
+        if not key: raise RuntimeError(f"Required model credential environment variable is missing: {self.api_key_env}")
+        definitions, aliases = _tool_defs(tools)
+        input_items: list[dict[str, Any]] = [{"role": "user", "content": request.prompt}]
+        history = request.metadata.get("tool_history", ())
+        for turn in history if isinstance(history, (list, tuple)) else ():
+            for call in turn.get("tool_calls", ()):
+                input_items.append({"type": "function_call", "call_id": call["call_id"], "name": _tool_name(str(call["tool_id"])), "arguments": json.dumps(call["arguments"])})
+            for result in turn.get("tool_results", ()):
+                input_items.append({"type": "function_call_output", "call_id": result["call_id"], "output": json.dumps(result.get("output")) if result.get("ok") else json.dumps({"error": result.get("error")})})
+        payload: dict[str, Any] = {"model": model.id, "input": input_items}
+        if request.system: payload["instructions"] = request.system
+        if definitions: payload["tools"] = [{"type": "function", "name": d["name"], "description": d["description"], "parameters": d["parameters"]} for d in definitions]
+        data, response_headers = _request(self.endpoint, payload, {"Authorization": f"Bearer {key}"}, self.policy)
+        calls, texts = [], []
+        for item in data.get("output", ()):
+            if item.get("type") == "function_call":
+                calls.append({"id": item.get("call_id", item.get("id")), "name": aliases.get(item.get("name"), item.get("name")), "arguments": json.loads(item.get("arguments", "{}"))})
+            elif item.get("type") == "message":
+                texts.extend(part.get("text", "") for part in item.get("content", ()) if part.get("type") == "output_text")
+        rate_limits = _openai_rate_limits(response_headers)
+        usage = _usage_dict(data.get("usage"))
+        metadata = {"adapter": "openai_responses", "tool_calls": calls, "provider_response_id": data.get("id")}
+        if rate_limits: metadata["rate_limits"] = rate_limits
+        if usage: metadata["usage"] = usage
+        return ModelResponse("".join(texts), model.id, metadata)
+
+@dataclass(frozen=True)
+class AnthropicMessagesToolAdapter:
+    api_key_env: str = "ANTHROPIC_API_KEY"
+    endpoint: str = "https://api.anthropic.com/v1/messages"
+    api_version: str = "2023-06-01"
+    max_tokens: int = 4096
+    policy: ExecutionPolicy = ExecutionPolicy(allow_network=True)
+    def generate(self, model: ModelSpec, request: ModelRequest) -> ModelResponse:
+        return self._generate(model, request, ())
+    def generate_with_tools(self, model: ModelSpec, request: ModelRequest, tools: tuple[ToolSpec, ...]) -> ModelResponse:
+        return self._generate(model, request, tools)
+    def _generate(self, model: ModelSpec, request: ModelRequest, tools: tuple[ToolSpec, ...]) -> ModelResponse:
+        key = os.environ.get(self.api_key_env)
+        if not key: raise RuntimeError(f"Required model credential environment variable is missing: {self.api_key_env}")
+        definitions, aliases = _tool_defs(tools)
+        messages: list[dict[str, Any]] = [{"role": "user", "content": request.prompt}]
+        history = request.metadata.get("tool_history", ())
+        for turn in history if isinstance(history, (list, tuple)) else ():
+            assistant = [{"type": "tool_use", "id": c["call_id"], "name": _tool_name(str(c["tool_id"])), "input": c["arguments"]} for c in turn.get("tool_calls", ())]
+            if assistant: messages.append({"role": "assistant", "content": assistant})
+            results = [{"type": "tool_result", "tool_use_id": r["call_id"], "content": json.dumps(r.get("output")) if r.get("ok") else json.dumps({"error": r.get("error")}), "is_error": not r.get("ok", False)} for r in turn.get("tool_results", ())]
+            if results: messages.append({"role": "user", "content": results})
+        payload: dict[str, Any] = {"model": model.id, "max_tokens": self.max_tokens, "messages": messages}
+        if request.system: payload["system"] = request.system
+        if definitions: payload["tools"] = [{"name": d["name"], "description": d["description"], "input_schema": d["parameters"]} for d in definitions]
+        data, response_headers = _request(self.endpoint, payload, {"x-api-key": key, "anthropic-version": self.api_version}, self.policy)
+        calls, texts = [], []
+        for block in data.get("content", ()):
+            if block.get("type") == "tool_use": calls.append({"id": block["id"], "name": aliases.get(block["name"], block["name"]), "arguments": block.get("input", {})})
+            elif block.get("type") == "text": texts.append(block.get("text", ""))
+        rate_limits = _anthropic_rate_limits(response_headers)
+        usage = _usage_dict(data.get("usage"))
+        metadata = {"adapter": "anthropic_messages", "tool_calls": calls, "stop_reason": data.get("stop_reason")}
+        if rate_limits: metadata["rate_limits"] = rate_limits
+        if usage: metadata["usage"] = usage
+        return ModelResponse("".join(texts), model.id, metadata)
+
+@dataclass(frozen=True)
+class GeminiGenerateContentToolAdapter:
+    api_key_env: str = "GEMINI_API_KEY"
+    endpoint_base: str = "https://generativelanguage.googleapis.com/v1beta/models"
+    policy: ExecutionPolicy = ExecutionPolicy(allow_network=True)
+    def generate(self, model: ModelSpec, request: ModelRequest) -> ModelResponse:
+        return self._generate(model, request, ())
+    def generate_with_tools(self, model: ModelSpec, request: ModelRequest, tools: tuple[ToolSpec, ...]) -> ModelResponse:
+        return self._generate(model, request, tools)
+    def _generate(self, model: ModelSpec, request: ModelRequest, tools: tuple[ToolSpec, ...]) -> ModelResponse:
+        key = os.environ.get(self.api_key_env)
+        if not key: raise RuntimeError(f"Required model credential environment variable is missing: {self.api_key_env}")
+        definitions, aliases = _tool_defs(tools)
+        contents: list[dict[str, Any]] = [{"role": "user", "parts": [{"text": request.prompt}]}]
+        history = request.metadata.get("tool_history", ())
+        for turn in history if isinstance(history, (list, tuple)) else ():
+            calls = [{"functionCall": {"name": _tool_name(str(c["tool_id"])), "args": c["arguments"]}} for c in turn.get("tool_calls", ())]
+            if calls: contents.append({"role": "model", "parts": calls})
+            results = [{"functionResponse": {"name": _tool_name(str(r["tool_id"])), "response": {"ok": r.get("ok"), "output": r.get("output"), "error": r.get("error")}}} for r in turn.get("tool_results", ())]
+            if results: contents.append({"role": "user", "parts": results})
+        payload: dict[str, Any] = {"contents": contents}
+        if request.system: payload["systemInstruction"] = {"parts": [{"text": request.system}]}
+        if definitions: payload["tools"] = [{"functionDeclarations": [{"name": d["name"], "description": d["description"], "parameters": d["parameters"]} for d in definitions]}]
+        endpoint = f"{self.endpoint_base}/{urllib.parse.quote(model.id, safe='')}:generateContent?key={urllib.parse.quote(key, safe='')}"
+        data, response_headers = _request(endpoint, payload, {}, self.policy)
+        calls, texts = [], []
+        for candidate in data.get("candidates", ()):
+            for part in candidate.get("content", {}).get("parts", ()):
+                if "functionCall" in part:
+                    fc = part["functionCall"]; calls.append({"id": fc.get("id", f"call-{len(calls)+1}"), "name": aliases.get(fc.get("name"), fc.get("name")), "arguments": fc.get("args", {})})
+                elif "text" in part: texts.append(part["text"])
+        usage = _usage_dict(data.get("usageMetadata"))
+        metadata = {"adapter": "gemini_generate_content", "tool_calls": calls}
+        if usage: metadata["usage"] = usage
+        return ModelResponse("".join(texts), model.id, metadata)
+
+
+def _usage_dict(value: object) -> dict[str, int]:
+    if not isinstance(value, dict):
+        return {}
+    aliases = {
+        "promptTokenCount": "input_tokens",
+        "inputTokenCount": "input_tokens",
+        "candidatesTokenCount": "output_tokens",
+        "outputTokenCount": "output_tokens",
+        "totalTokenCount": "total_tokens",
+        "thoughtsTokenCount": "thought_tokens",
+        "cachedContentTokenCount": "cached_tokens",
+    }
+    result: dict[str, int] = {}
+    for key, target in aliases.items():
+        raw = value.get(key)
+        if raw is not None:
+            try:
+                result[target] = int(raw)
+            except (TypeError, ValueError):
+                pass
+    for key in ("input_tokens", "output_tokens", "total_tokens"):
+        raw = value.get(key)
+        if raw is not None:
+            try:
+                result[key] = int(raw)
+            except (TypeError, ValueError):
+                pass
+    return result
+
+
+def _openai_rate_limits(headers: dict[str, str]) -> dict[str, dict[str, object]]:
+    result: dict[str, dict[str, object]] = {}
+    pairs = (
+        ("requests", "x-ratelimit-limit-requests", "x-ratelimit-remaining-requests", "x-ratelimit-reset-requests"),
+        ("tokens", "x-ratelimit-limit-tokens", "x-ratelimit-remaining-tokens", "x-ratelimit-reset-tokens"),
+    )
+    for name, limit_key, remaining_key, reset_key in pairs:
+        if limit_key not in headers and remaining_key not in headers:
+            continue
+        result[name] = {
+            "limit": _header_number(headers.get(limit_key)),
+            "remaining": _header_number(headers.get(remaining_key)),
+            "reset_seconds": _reset_seconds(headers.get(reset_key)),
+            "source": "openai_response_headers",
+        }
+    return result
+
+
+def _anthropic_rate_limits(headers: dict[str, str]) -> dict[str, dict[str, object]]:
+    result: dict[str, dict[str, object]] = {}
+    mappings = (
+        ("requests", "anthropic-ratelimit-requests-limit", "anthropic-ratelimit-requests-remaining", "anthropic-ratelimit-requests-reset"),
+        ("input_tokens", "anthropic-ratelimit-input-tokens-limit", "anthropic-ratelimit-input-tokens-remaining", "anthropic-ratelimit-input-tokens-reset"),
+        ("output_tokens", "anthropic-ratelimit-output-tokens-limit", "anthropic-ratelimit-output-tokens-remaining", "anthropic-ratelimit-output-tokens-reset"),
+    )
+    for name, limit_key, remaining_key, reset_key in mappings:
+        if limit_key not in headers and remaining_key not in headers:
+            continue
+        result[name] = {
+            "limit": _header_number(headers.get(limit_key)),
+            "remaining": _header_number(headers.get(remaining_key)),
+            "reset_at": headers.get(reset_key),
+            "source": "anthropic_response_headers",
+        }
+    return result
+
+
+def _header_number(value: object) -> int | None:
+    try:
+        return int(float(str(value))) if value is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _reset_seconds(value: object) -> float | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    try:
+        if text.endswith("ms"):
+            return float(text[:-2]) / 1000
+        if text.endswith("s"):
+            return float(text[:-1])
+        return float(text)
+    except ValueError:
+        return None