mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
83 lines
3.7 KiB
Python
83 lines
3.7 KiB
Python
"""AWS Bedrock Converse API transport.
|
|
|
|
Delegates format conversion to agent/bedrock_adapter.py. Bedrock uses its own
|
|
boto3 client, so client construction and calls stay on AIAgent.
|
|
"""
|
|
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from agent.transports.base import ProviderTransport
|
|
from agent.transports.types import NormalizedResponse, ToolCall, Usage
|
|
|
|
|
|
class BedrockTransport(ProviderTransport):
|
|
"""Transport for api_mode='bedrock_converse'."""
|
|
|
|
# The adapter already maps inside normalize_converse_response; this serves raw-response access.
|
|
_STOP_REASON_MAP = {
|
|
"end_turn": "stop", "tool_use": "tool_calls", "max_tokens": "length", "stop_sequence": "stop",
|
|
"guardrail_intervened": "content_filter", "content_filtered": "content_filter",
|
|
}
|
|
|
|
@property
|
|
def api_mode(self) -> str:
|
|
return "bedrock_converse"
|
|
|
|
def convert_messages(self, messages: List[Dict[str, Any]], **kwargs) -> Any:
|
|
"""Convert OpenAI messages to Bedrock Converse format."""
|
|
from agent.bedrock_adapter import convert_messages_to_converse
|
|
return convert_messages_to_converse(messages)
|
|
|
|
def convert_tools(self, tools: List[Dict[str, Any]]) -> Any:
|
|
"""Convert OpenAI tool schemas to Bedrock Converse toolConfig."""
|
|
from agent.bedrock_adapter import convert_tools_to_converse
|
|
return convert_tools_to_converse(tools)
|
|
|
|
def build_kwargs(
|
|
self, model: str, messages: List[Dict[str, Any]],
|
|
tools: Optional[List[Dict[str, Any]]] = None, **params,
|
|
) -> Dict[str, Any]:
|
|
"""Build Converse kwargs, leaving the optional output limit to the provider."""
|
|
from agent.bedrock_adapter import build_converse_kwargs
|
|
|
|
kwargs = build_converse_kwargs(
|
|
model=model, messages=messages, tools=tools, max_tokens=params.get("max_tokens"),
|
|
temperature=params.get("temperature"), guardrail_config=params.get("guardrail_config"),
|
|
)
|
|
# Sentinel keys for dispatch — agent pops these before the boto3 call
|
|
kwargs["__bedrock_converse__"] = True
|
|
kwargs["__bedrock_region__"] = params.get("region", "us-east-1")
|
|
return kwargs
|
|
|
|
def normalize_response(self, response: Any, **kwargs) -> NormalizedResponse:
|
|
"""Normalize either a raw boto3 dict or an already-normalized SimpleNamespace with .choices."""
|
|
from agent.bedrock_adapter import normalize_converse_response
|
|
|
|
ns = response if hasattr(response, "choices") and response.choices else normalize_converse_response(response)
|
|
choice = ns.choices[0]
|
|
msg = choice.message
|
|
|
|
tool_calls = (
|
|
[ToolCall(id=tc.id, name=tc.function.name, arguments=tc.function.arguments) for tc in msg.tool_calls]
|
|
if msg.tool_calls else None
|
|
)
|
|
provider_data = {
|
|
key: getattr(msg, key) for key in ("reasoning_details", "bedrock_content_blocks") if getattr(msg, key, None)
|
|
}
|
|
return NormalizedResponse(
|
|
content=msg.content, tool_calls=tool_calls,
|
|
finish_reason=choice.finish_reason or "stop",
|
|
reasoning=getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None),
|
|
usage=Usage.from_openai(ns.usage) if getattr(ns, "usage", None) else None, provider_data=provider_data or None,
|
|
)
|
|
|
|
def validate_response(self, response: Any) -> bool:
|
|
"""Raw Bedrock dict needs an 'output' key; a normalized namespace needs non-empty .choices."""
|
|
if isinstance(response, dict):
|
|
return "output" in response
|
|
return bool(getattr(response, "choices", None)) if response is not None else False
|
|
|
|
|
|
from agent.transports import register_transport # noqa: E402
|
|
|
|
register_transport("bedrock_converse", BedrockTransport)
|