The one agent loop, provider- and transport-agnostic.

A Session drives any ReqManagedAgents.Provider to completion: invoke a turn → normalize → run the return-of-control tools locally via the :handler → resume → repeat until a terminal. The provider's mode/0 (:streaming push or :request_response pull) only changes how a turn's events are acquired; the loop, the result shape, and the raw-event passthrough are identical across providers.

Pick a provider — ReqManagedAgents.Providers.ClaudeManagedAgents (streaming) or ReqManagedAgents.Providers.BedrockAgentCore (request/response) — and:

# synchronous run-to-completion
{:ok, %ReqManagedAgents.SessionResult{terminal: t, stop_reason: r, events: raw}} =
  ReqManagedAgents.Session.run(provider, handler: MyTools, prompt: "Hi", ...)

# live, long-lived (stays alive after a terminal; `:notify` gets {:managed_agents_session, %ReqManagedAgents.SessionResult{}})
{:ok, pid} = ReqManagedAgents.Session.start_link(provider, handler: MyTools, notify: self(), ...)
ReqManagedAgents.Session.message(pid, "follow-up")

Required opts: :handler (a ReqManagedAgents.Handler module or a 3-arity fn). Optional: :context, :prompt, :timeout, :max_turns, :notify, :name, :telemetry_metadata. For long AgentCore runs set :timeout (the end-to-end run budget, default 600_000 ms) at or above the server-side budget — a run/2 timeout returns {:error, :timeout} and tears down the in-flight invoke client-side (the poll task and its HTTP stream are shut down). The server may still run the already-received invocation to its own limit: the server-side timeoutSeconds remains the authoritative server budget. Transport liveness is guarded per turn by :idle_timeout and total cost by the :timeout_seconds/:max_iterations/:max_tokens per-invocation overrides (Bedrock AgentCore only). Provider-specific opts (e.g. :agent_id/:environment_id, :harness_arn/:runtime_session_id, :session_id to resume) are forwarded to the provider's open/2.