morpheus-llm

def __getattr__(name: str):
    if name == "ClaudeAgentService":
        from morpheus_llm.providers.claude_service import ClaudeAgentService
        return ClaudeAgentService
    …

class BaseAgentService(ABC):
    def __init__(self, config: AgentConfig,
                 tools: list[Any] | Callable[[], list[Any]],
                 memory_id: str | None = None) -> None:
        self._memory_id = memory_id or os.environ.get("MEMORY_ID", "")

    def _resolve_tools(self) -> list[Any]:
        return self._tools() if callable(self._tools) else self._tools

    def _make_session_manager(self, options) -> AgentCoreMemorySessionManager | None: ...

    @abstractmethod
    def _make_agent(self, options: RunOptions | None = None) -> Any: ...

    def run(self, prompt: str, options=None) -> AgentResult: ...
    def new_session(self, options=None) -> Any: ...

return AgentResult(
    output=str(result),
    stop_reason="end_turn",
    structured_output=getattr(result, "structured_output", None),
)

def _make_agent(self, options: RunOptions | None = None) -> Agent:
    cache_prompt, cache_tools = _bedrock_prompt_tool_cache_flags(self._config.model_id)
    model = BedrockModel(
        model_id=self._config.model_id,
        max_tokens=self._config.max_tokens,
        cache_prompt=cache_prompt,
        cache_tools=cache_tools,
    )
    system_prompt = (options.system_prompt
                     if options and options.system_prompt
                     else self._config.system_prompt)
    return Agent(
        model=model,
        system_prompt=system_prompt,
        tools=self._resolve_tools(),
        session_manager=self._make_session_manager(options) if options else None,
        structured_output_model=self._config.structured_output_model,
    )

config = AgentConfig(
    model_id=AgentModelIds.CLAUDE_HAIKU_4_5,
    system_prompt="…",
    max_tokens=2048,
    max_turns=6,
    structured_output_model=SellerEnrichmentResult,
)
result = agent.run(prompt)
data: SellerEnrichmentResult = result.structured_output   # a validated instance

@dataclass
class AgentConfig:
    model_id: str
    system_prompt: str
    max_tokens: int
    max_turns: int
    structured_output_model: type | None = None

@dataclass
class AgentResult:
    output: str
    stop_reason: str = "end_turn"
    usage: dict[str, int] | None = None
    structured_output: Any = None

@dataclass
class RunOptions:
    system_prompt: str | None = None
    max_turns: int | None = None
    metadata: dict[str, Any] | None = None
    session_id: str | None = None       # required for memory
    actor_id: str | None = None         # memory namespace key