Modules
Provider-agnostic Elixir client for managed agent runtimes.
Bedrock AgentCore entry point.
SigV4-signed REST client for AWS AgentCore (bedrock-agentcore). Covers the
control-plane harness lifecycle (create_harness/get_harness/delete_harness),
the AgentCore Identity token-vault (create_api_key_credential_provider), and the
data-plane invoke_harness (returns a decoded vnd.amazon.eventstream).
The :agentcore_harness wire profile: the Bedrock Converse envelope.
Adapter from aws_event_stream's classified frames to the Converse envelope
ReqManagedAgents.AgentCore.Converse.parse/1 consumes.
SigV4 request signing for the bedrock-agentcore AWS service, reusing the
:ex_aws_auth signer. The signer is service-parameterized, so the same call
signs both the data plane (bedrock-agentcore.<region>) and the control plane
(bedrock-agentcore-control.<region>) — pass service: "bedrock-agentcore".
Low-level control-plane HTTP client for Claude Managed Agents (agents, sessions,
events) over Req. The long-lived SSE event stream lives in
ReqManagedAgents.Stream.
Callback contract for the Managed Agents control plane, so consumers can swap in
a mock client in tests. ReqManagedAgents.Client is the live implementation.
Pure helpers for reconnect-with-consolidation.
Outbound event builders and inbound event classification for Managed Agents.
Behaviour a consumer implements to plug local tool execution and event handling
into ReqManagedAgents.Session. This is the "tools stay local" seam: the
managed loop runs on Anthropic's side and calls back into handle_tool_call/3
on your node.
OTel GenAI bridge for req_managed_agents (mirrors ReqLLM.OpenTelemetry).
Pure mappers: RMA :telemetry metadata -> binary-keyed OTel GenAI (gen_ai.*)
attribute maps. No OTel SDK required. Privacy: scalar metadata + usage + tool
name only — never message content or tool input/result payloads.
OTel GenAI semantic-convention lookups for the managed-agents (Anthropic) path.
Server wire-compat profile. :anthropic is identity (Anthropic cloud shape).
:jido encodes the 4 remaps proven by the jido_managed_agents handshake spike:
(1) tool-use name/input nested under content[0]/payload; (2) end_turn signalled
as status_idle + null stop_reason (gate on "agent seen"); (3) /events/stream path;
(4) pagination cursor (after vs next_page — handled in the paging layer).
Contract a streaming agent backend implements so one ReqManagedAgents.Session loop can
drive ANY provider. A provider owns its transport mode and invocation end-to-end
ReqManagedAgents.Provider for the Bedrock AgentCore backend — :request_response mode.
Each turn is one InvokeHarness call; resume re-sends the assistant toolUse + user
toolResult delta (the harness does not persist the uncommitted tool-use turn). Composes
the existing AgentCore.{Client, Converse} modules.
ReqManagedAgents.Provider for the Anthropic Managed Agents backend — :streaming mode.
A long-lived SSE stream pushes events; the client POSTs events to drive it; a turn ends on
session.status_idle. Resume POSTs a user.custom_tool_result event (no echo — the session
already holds the tool call). Composes Client, Stream, Event.
Hash-keyed provision cache. ensure/3 returns a cached provider handle for a given
{provider, spec}, calling provider.provision/2 only on a miss. ETS-backed
(process-independent); the handle is the durable artifact (persistable + reusable across
processes), so the cache is an in-process optimization, not the source of truth.
Pure Server-Sent-Events frame decoder for the Managed Agents event stream.
The one agent loop, provider- and transport-agnostic.
The accumulated outcome of a whole run — what Session.run/2 and message/2 deliver.
Optional DynamicSupervisor for running one ReqManagedAgents.Session per
child. Add it to your supervision tree, then start_child/1 with the same opts
you'd pass to ReqManagedAgents.Session.start_link/2.
Long-lived SSE consumer for GET /v1/sessions/{id}/events/stream.
The locally-produced result of running a custom tool — what resumes the loop.
Jido.Action NimbleOptions schema → Anthropic custom-tool definition.
A tool call — client-side (custom, return-of-control) or server-side (observe-only).
The canonical outcome of ONE turn — what Provider.normalize/1 returns.
Token usage — canonical summed counts + the provider's raw usage object(s) verbatim.
Mix Tasks
Drives the full req_managed_agents AgentCore Harness client stack end-to-end
as a single repeatable command — no live AWS needed.
QA-CHECKPOINT — canonical proof that the Provider/Session refactor changed no observable behavior of either provider.
Provisioning lifecycle smoke — a runnable, deterministic proof that the full provider-agnostic lifecycle works cohesively for BOTH providers