flowra 0.0.90__tar.gz → 0.0.92.dev108__tar.gz

{flowra-0.0.90 → flowra-0.0.92.dev108}/.agents/skills/source-command-update-pricing/SKILL.md

@@ -29,6 +29,7 @@ The price lists, their constants in `flowra.llm.pricing` and the sources `LISTS`
 | List | Constant | Supplier | Sources |
 |---|---|---|---|
 | `anthropic` | `ANTHROPIC` | Anthropic's API; Microsoft Foundry bills Claude at it | `anthropic` (fields filled from `vertex_ai-anthropic_models`) |
+| `bedrock` | `BEDROCK` | Claude on Amazon Bedrock | `bedrock_converse`'s `anthropic.claude-…` entries: rates from the bare / `global.` ids, `regional_uplift` from the geography profiles (`au.`, `eu.`, …; `us-gov.` excluded: GovCloud has its own price). Fields filled from `anthropic` |
 | `vertex` | `VERTEX` | Claude and Gemini on Vertex AI | `vertex_ai-anthropic_models`, `vertex_ai`, `vertex_ai-language-models` (fields filled from `anthropic`, `gemini`) |
 | `gemini_api` | `GEMINI_API` | Gemini Developer API (AI Studio) | `gemini` |
 | `openai` | `OPENAI` | OpenAI | `openai` |
@@ -69,7 +70,7 @@ Available pricing fields:
 - `reasoning_output` — rate for the reasoning share of the output tokens (if different from output; providers count reasoning inside `output_tokens`)
 - `long_prompt_threshold` — for models priced by prompt length: the prompt size in tokens, where the prompt is input + cache read + cache write tokens. A longer prompt bills every token of the request, output included, at the `*_long_prompt` rates. Examples: 100000 for Claude Haiku 5.5, 200000 for Gemini 2.5 Pro, 272000 for GPT-5.4.
 - `input_long_prompt`, `output_long_prompt`, `cache_read_long_prompt`, `cache_creation_long_prompt`, `cache_creation_1h_long_prompt` — the rates past that threshold. An omitted one keeps the base rate. They come from litellm's `input_cost_per_token_above_{N}k_tokens` etc.; `sync_pricing.py` sets `long_prompt_threshold` to N×1000.
-- `regional_uplift` — this list's supplier's factor on the whole cost of a call it serves regionally, e.g. 1.1: in `vertex` a location other than `global` (from litellm's `regional_endpoint_uplift_multiplier`), in `openai` the `eu.` / `us.api.openai.com` data residency (`regional_processing_uplift_multiplier_eu|us`), in `anthropic` `inference_geo: "us"` and Foundry US Data Zone deployments (Claude 4.6 and later, kept in `custom/anthropic.json`: litellm has none). The uplift of one list never comes from another supplier's data.
+- `regional_uplift` — this list's supplier's factor on the whole cost of a call it serves regionally, e.g. 1.1: in `vertex` a location other than `global` (from litellm's `regional_endpoint_uplift_multiplier`), in `openai` the `eu.` / `us.api.openai.com` data residency (`regional_processing_uplift_multiplier_eu|us`), in `bedrock` a geography's cross-region profile (the ratio of its input rate to the `global.` one), in `anthropic` `inference_geo: "us"` and Foundry US Data Zone deployments (Claude 4.6 and later, kept in `custom/anthropic.json`: litellm has none). The uplift of one list never comes from another supplier's data.
 
 ### Steps to follow
 
@@ -80,7 +81,7 @@ Available pricing fields:
    - If no arguments were provided, refresh pricing for models in the `custom/` files.
 
 3. **Web search for current pricing**: Use WebSearch to find the most up-to-date pricing:
-   - Search official pricing pages: Anthropic (platform.claude.com/docs/en/about-claude/pricing), OpenAI (openai.com/api/pricing), Google Cloud (cloud.google.com/vertex-ai/generative-ai/pricing), the Gemini Developer API (ai.google.dev/gemini-api/docs/pricing), Azure OpenAI (azure.microsoft.com/pricing/details/cognitive-services/openai-service/). Lists synced from a models API (Inception) are not searched: rerun the sync instead
+   - Search official pricing pages: Anthropic (platform.claude.com/docs/en/about-claude/pricing), OpenAI (openai.com/api/pricing), Google Cloud (cloud.google.com/vertex-ai/generative-ai/pricing), the Gemini Developer API (ai.google.dev/gemini-api/docs/pricing), Azure OpenAI (azure.microsoft.com/pricing/details/cognitive-services/openai-service/), Amazon Bedrock (aws.amazon.com/bedrock/pricing/). Lists synced from a models API (Inception) are not searched: rerun the sync instead
    - Focus on models/fields the `generated/` files are missing (check litellm gaps)
 
 4. **Update the `custom/<list>.json` files** of the supplier whose price it is:

{flowra-0.0.90 → flowra-0.0.92.dev108}/.claude/commands/update-pricing.md

@@ -18,6 +18,7 @@ The price lists, their constants in `flowra.llm.pricing` and the sources `LISTS`
 | List | Constant | Supplier | Sources |
 |---|---|---|---|
 | `anthropic` | `ANTHROPIC` | Anthropic's API; Microsoft Foundry bills Claude at it | `anthropic` (fields filled from `vertex_ai-anthropic_models`) |
+| `bedrock` | `BEDROCK` | Claude on Amazon Bedrock | `bedrock_converse`'s `anthropic.claude-…` entries: rates from the bare / `global.` ids, `regional_uplift` from the geography profiles (`au.`, `eu.`, …; `us-gov.` excluded: GovCloud has its own price). Fields filled from `anthropic` |
 | `vertex` | `VERTEX` | Claude and Gemini on Vertex AI | `vertex_ai-anthropic_models`, `vertex_ai`, `vertex_ai-language-models` (fields filled from `anthropic`, `gemini`) |
 | `gemini_api` | `GEMINI_API` | Gemini Developer API (AI Studio) | `gemini` |
 | `openai` | `OPENAI` | OpenAI | `openai` |
@@ -58,7 +59,7 @@ Available pricing fields:
 - `reasoning_output` — rate for the reasoning share of the output tokens (if different from output; providers count reasoning inside `output_tokens`)
 - `long_prompt_threshold` — for models priced by prompt length: the prompt size in tokens, where the prompt is input + cache read + cache write tokens. A longer prompt bills every token of the request, output included, at the `*_long_prompt` rates. Examples: 100000 for Claude Haiku 5.5, 200000 for Gemini 2.5 Pro, 272000 for GPT-5.4.
 - `input_long_prompt`, `output_long_prompt`, `cache_read_long_prompt`, `cache_creation_long_prompt`, `cache_creation_1h_long_prompt` — the rates past that threshold. An omitted one keeps the base rate. They come from litellm's `input_cost_per_token_above_{N}k_tokens` etc.; `sync_pricing.py` sets `long_prompt_threshold` to N×1000.
-- `regional_uplift` — this list's supplier's factor on the whole cost of a call it serves regionally, e.g. 1.1: in `vertex` a location other than `global` (from litellm's `regional_endpoint_uplift_multiplier`), in `openai` the `eu.` / `us.api.openai.com` data residency (`regional_processing_uplift_multiplier_eu|us`), in `anthropic` `inference_geo: "us"` and Foundry US Data Zone deployments (Claude 4.6 and later, kept in `custom/anthropic.json`: litellm has none). The uplift of one list never comes from another supplier's data.
+- `regional_uplift` — this list's supplier's factor on the whole cost of a call it serves regionally, e.g. 1.1: in `vertex` a location other than `global` (from litellm's `regional_endpoint_uplift_multiplier`), in `openai` the `eu.` / `us.api.openai.com` data residency (`regional_processing_uplift_multiplier_eu|us`), in `bedrock` a geography's cross-region profile (the ratio of its input rate to the `global.` one), in `anthropic` `inference_geo: "us"` and Foundry US Data Zone deployments (Claude 4.6 and later, kept in `custom/anthropic.json`: litellm has none). The uplift of one list never comes from another supplier's data.
 
 ### Steps to follow
 
@@ -69,7 +70,7 @@ Available pricing fields:
    - If no arguments were provided, refresh pricing for models in the `custom/` files.
 
 3. **Web search for current pricing**: Use WebSearch to find the most up-to-date pricing:
-   - Search official pricing pages: Anthropic (platform.claude.com/docs/en/about-claude/pricing), OpenAI (openai.com/api/pricing), Google Cloud (cloud.google.com/vertex-ai/generative-ai/pricing), the Gemini Developer API (ai.google.dev/gemini-api/docs/pricing), Azure OpenAI (azure.microsoft.com/pricing/details/cognitive-services/openai-service/). Lists synced from a models API (Inception) are not searched: rerun the sync instead
+   - Search official pricing pages: Anthropic (platform.claude.com/docs/en/about-claude/pricing), OpenAI (openai.com/api/pricing), Google Cloud (cloud.google.com/vertex-ai/generative-ai/pricing), the Gemini Developer API (ai.google.dev/gemini-api/docs/pricing), Azure OpenAI (azure.microsoft.com/pricing/details/cognitive-services/openai-service/), Amazon Bedrock (aws.amazon.com/bedrock/pricing/). Lists synced from a models API (Inception) are not searched: rerun the sync instead
    - Focus on models/fields the `generated/` files are missing (check litellm gaps)
 
 4. **Update the `custom/<list>.json` files** of the supplier whose price it is:

{flowra-0.0.90 → flowra-0.0.92.dev108}/AGENTS.md

@@ -55,9 +55,9 @@ Provider-agnostic interface for calling LLMs:
 - History across models: providers adapt a stored history to the model they call. Anthropic sends Claude's signed or redacted thinking to any Claude model and drops other thinking; Google sends Gemini's thoughts (`extra["google"]` with `thought` or a `thought_signature`) to any Gemini model, drops other thinking, and signs a message's first function call that has no Google signature with `skip_thought_signature_validator`; an assistant message left empty is not sent, and empty text blocks (Gemini's signature carriers) are not sent to Claude or OpenAI
 - Span types (in `flowra.lib.observability`): `LLMCallSpan` (request + response), `ToolCallSpan` (tool_use + result + error_kind) — mutable, for observability via span-hooks
 
-Providers live in `flowra/llm/providers/`. Currently: `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`.
+Providers live in `flowra/llm/providers/`. Currently: `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `AnthropicBedrockProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`.
 
-Pricing lives in `flowra/llm/pricing/` — suppliers' price lists. A `PriceList` maps model names to `ModelPricing` rates; `find(served, requested)` returns the rates of the first name with a price (a name matches the longest key it contains), and `ModelPricing.cost(...)` → `CostBreakdown` prices a call. Bundled lists (`ANTHROPIC` — Anthropic API and Foundry, `VERTEX`, `GEMINI_API`, `OPENAI`, `AZURE_OPENAI`, `INCEPTION`) load from `data/generated/<name>.json` (from litellm via `tools/sync_pricing.py`, whose `LISTS` maps each list to its litellm providers — or, for Inception, to the supplier's own `/models` API, which then decides the chat models and every rate it states) and `data/custom/<name>.json` (manual overrides, fields merged on load). Every provider takes `price_list=` (`None` = no cost) with a default of whoever bills its endpoint; `AnthropicProvider` requires one. Supports long-prompt pricing at a per-model threshold (`long_prompt_threshold`; past it the whole request is billed at the `*_long_prompt` rates), reasoning tokens (counted inside `output_tokens`; `reasoning_output` prices their share), cache creation TTL variants, and a per-model `regional_uplift` — the list's supplier's premium — that providers apply with `regional=True`: a Vertex location other than `global`, a Foundry US Data Zone (`data_zone=True`), OpenAI `eu`/`us` data residency.
+Pricing lives in `flowra/llm/pricing/` — suppliers' price lists. A `PriceList` maps model names to `ModelPricing` rates; `find(served, requested)` returns the rates of the first name with a price (a name matches the longest key it contains), and `ModelPricing.cost(...)` → `CostBreakdown` prices a call. Bundled lists (`ANTHROPIC` — Anthropic API and Foundry, `BEDROCK` — Claude on Bedrock, rates from the bare / `global.` ids and the uplift from the geography profiles, `VERTEX`, `GEMINI_API`, `OPENAI`, `AZURE_OPENAI`, `INCEPTION`) load from `data/generated/<name>.json` (from litellm via `tools/sync_pricing.py`, whose `LISTS` maps each list to its litellm providers — or, for Inception, to the supplier's own `/models` API, which then decides the chat models and every rate it states) and `data/custom/<name>.json` (manual overrides, fields merged on load). Every provider takes `price_list=` (`None` = no cost) with a default of whoever bills its endpoint; `AnthropicProvider` requires one. Supports long-prompt pricing at a per-model threshold (`long_prompt_threshold`; past it the whole request is billed at the `*_long_prompt` rates), reasoning tokens (counted inside `output_tokens`; `reasoning_output` prices their share), cache creation TTL variants, and a per-model `regional_uplift` — the list's supplier's premium — that providers apply with `regional=True`: a Vertex location other than `global`, a Foundry US Data Zone (`data_zone=True`), a Bedrock geography profile (`au.`, `eu.`, ... model ids), OpenAI `eu`/`us` data residency.
 
 ### Flowing context (`flowra/agent/flow/flowing_registry.py`)
 

{flowra-0.0.90 → flowra-0.0.92.dev108}/CHANGELOG.md

@@ -5,6 +5,56 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com),
 and this project adheres to [Semantic Versioning](https://semver.org).
 
+## [Unreleased]
+
+### Added
+- **`BeforeToolCallsEvent`: answer a model message's tool calls before any
+  runs.** Emitted once per model message with tool calls, a single call
+  included, with every call of the message in `tool_uses`, a call the response cut off
+  included (an answer under its id is not used). A handler puts a
+  `ToolResult` into `results` under a call's id to answer that call itself:
+  it does not run, the other calls run as usual, and its result reaches the
+  model in the message's order. An answered call gets no
+  `BeforeToolCallEvent` and no `ToolCallSpan`; it goes through
+  `AfterToolCallEvent` and counts toward `max_consecutive_errors` like any
+  result. An error answered without an `error_kind` gets
+  `ToolErrorKind.EXECUTION`; a key that is not the id of a call in the message
+  raises `ValueError`. Answered calls are kept in the turn's state, so they
+  survive a resume before the results are collected.
+- **`AfterToolCallEvent.prefilled`**: true for a call answered in
+  `BeforeToolCallsEvent`, so a handler can tell that the tool did not run.
+
+## [0.0.91] - 2026-10-20
+
+### Added
+- **`AnthropicBedrockProvider`: Claude on Amazon Bedrock** (#135, closes #134). An
+  `AnthropicProvider` over the SDK's `AsyncAnthropicBedrock`, so blocks, tools,
+  streaming, errors and usage work as on Vertex and Foundry. Pass a Bedrock API
+  key and `aws_region`, or a configured client (AWS access keys, a profile).
+  `LLMRequest.model` is Bedrock's model id or inference profile, e.g.
+  `au.anthropic.claude-haiku-5-5`; the response reports the served model
+  (`claude-haiku-5-5`). Install with the new `bedrock` extra
+  (`pip install flowra[bedrock]`, also in `providers`): botocore decodes
+  Bedrock's event streams, and importing the provider without it says so. Claude's signed thinking moves
+  between Bedrock and Foundry either way.
+- **`pricing.BEDROCK`**, the default for `AnthropicBedrockProvider`: Claude's
+  rates on Bedrock, synced from litellm's `bedrock_converse` entries (AWS's
+  price index). A geography's cross-region profile (`au.`, `eu.`, `us.`,
+  `apac.`, `jp.`) bills 10% above `global.` for Claude 4.5 and later, Haiku 4.5
+  and Sonnet 4.5 included, where Anthropic's own premium starts at 4.6; the
+  provider reads the profile from the model id, or from the end of a system
+  inference profile's ARN. GovCloud's profiles (`us-gov.`) have prices of their
+  own, which the list does not hold: their calls report no cost.
+- **Bedrock's errors are typed.** Its HTTP errors are a bare
+  `{"message": ...}`, now read, so a prompt too long raises
+  `ContextTooLongError`. The exceptions of its event stream go by their type:
+  `throttlingException` is a `RateLimitedError`, `validationException` a
+  `BadRequestError` (or `ContextTooLongError`), `modelTimeoutException` an
+  `LLMTimeoutError`, the others an `UnavailableError`. `request_id` is read
+  from `x-amzn-RequestId`. An unknown model id, which Bedrock answers with a
+  400 "The provided model identifier is invalid", is a `NotFoundError`, so a
+  fallback moves on to its next config as it does on Vertex and Foundry.
+
 ## [0.0.90] - 2026-10-19
 
 ### Fixed

{flowra-0.0.90 → flowra-0.0.92.dev108}/CLAUDE.md

@@ -56,9 +56,9 @@ Provider-agnostic interface for calling LLMs:
 - History across models: providers adapt a stored history to the model they call. Anthropic sends Claude's signed or redacted thinking to any Claude model and drops other thinking; Google sends Gemini's thoughts (`extra["google"]` with `thought` or a `thought_signature`) to any Gemini model, drops other thinking, and signs a message's first function call that has no Google signature with `skip_thought_signature_validator`; an assistant message left empty is not sent, and empty text blocks (Gemini's signature carriers) are not sent to Claude or OpenAI
 - Span types (in `flowra.lib.observability`): `LLMCallSpan` (request + response), `ToolCallSpan` (tool_use + result + error_kind) — mutable, for observability via span-hooks
 
-Providers live in `flowra/llm/providers/`. Currently: `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`.
+Providers live in `flowra/llm/providers/`. Currently: `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `AnthropicBedrockProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`.
 
-Pricing lives in `flowra/llm/pricing/` — suppliers' price lists. A `PriceList` maps model names to `ModelPricing` rates; `find(served, requested)` returns the rates of the first name with a price (a name matches the longest key it contains), and `ModelPricing.cost(...)` → `CostBreakdown` prices a call. Bundled lists (`ANTHROPIC` — Anthropic API and Foundry, `VERTEX`, `GEMINI_API`, `OPENAI`, `AZURE_OPENAI`, `INCEPTION`) load from `data/generated/<name>.json` (from litellm via `tools/sync_pricing.py`, whose `LISTS` maps each list to its litellm providers — or, for Inception, to the supplier's own `/models` API, which then decides the chat models and every rate it states) and `data/custom/<name>.json` (manual overrides, fields merged on load). Every provider takes `price_list=` (`None` = no cost) with a default of whoever bills its endpoint; `AnthropicProvider` requires one. Supports long-prompt pricing at a per-model threshold (`long_prompt_threshold`; past it the whole request is billed at the `*_long_prompt` rates), reasoning tokens (counted inside `output_tokens`; `reasoning_output` prices their share), cache creation TTL variants, and a per-model `regional_uplift` — the list's supplier's premium — that providers apply with `regional=True`: a Vertex location other than `global`, a Foundry US Data Zone (`data_zone=True`), OpenAI `eu`/`us` data residency.
+Pricing lives in `flowra/llm/pricing/` — suppliers' price lists. A `PriceList` maps model names to `ModelPricing` rates; `find(served, requested)` returns the rates of the first name with a price (a name matches the longest key it contains), and `ModelPricing.cost(...)` → `CostBreakdown` prices a call. Bundled lists (`ANTHROPIC` — Anthropic API and Foundry, `BEDROCK` — Claude on Bedrock, rates from the bare / `global.` ids and the uplift from the geography profiles, `VERTEX`, `GEMINI_API`, `OPENAI`, `AZURE_OPENAI`, `INCEPTION`) load from `data/generated/<name>.json` (from litellm via `tools/sync_pricing.py`, whose `LISTS` maps each list to its litellm providers — or, for Inception, to the supplier's own `/models` API, which then decides the chat models and every rate it states) and `data/custom/<name>.json` (manual overrides, fields merged on load). Every provider takes `price_list=` (`None` = no cost) with a default of whoever bills its endpoint; `AnthropicProvider` requires one. Supports long-prompt pricing at a per-model threshold (`long_prompt_threshold`; past it the whole request is billed at the `*_long_prompt` rates), reasoning tokens (counted inside `output_tokens`; `reasoning_output` prices their share), cache creation TTL variants, and a per-model `regional_uplift` — the list's supplier's premium — that providers apply with `regional=True`: a Vertex location other than `global`, a Foundry US Data Zone (`data_zone=True`), a Bedrock geography profile (`au.`, `eu.`, ... model ids), OpenAI `eu`/`us` data residency.
 
 ### Flowing context (`flowra/agent/flow/flowing_registry.py`)
 

{flowra-0.0.90 → flowra-0.0.92.dev108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowra
-Version: 0.0.90
+Version: 0.0.92.dev108
 Summary: Flowra — flow infrastructure for building stateful LLM agents
 Project-URL: Repository, https://github.com/anna-money/flowra
 Project-URL: Changelog, https://github.com/anna-money/flowra/blob/master/CHANGELOG.md
@@ -22,6 +22,9 @@ Requires-Dist: marshmallow-recipe>=0.0.95
 Provides-Extra: anthropic
 Requires-Dist: anthropic[vertex]; extra == 'anthropic'
 Requires-Dist: httpx2>=2.13; extra == 'anthropic'
+Provides-Extra: bedrock
+Requires-Dist: anthropic[bedrock]; extra == 'bedrock'
+Requires-Dist: httpx2>=2.13; extra == 'bedrock'
 Provides-Extra: google
 Requires-Dist: google-genai; extra == 'google'
 Provides-Extra: mlflow
@@ -33,6 +36,7 @@ Provides-Extra: otel
 Requires-Dist: opentelemetry-api>=1.20; extra == 'otel'
 Requires-Dist: opentelemetry-sdk>=1.20; extra == 'otel'
 Provides-Extra: providers
+Requires-Dist: anthropic[bedrock]; extra == 'providers'
 Requires-Dist: anthropic[vertex]; extra == 'providers'
 Requires-Dist: google-genai; extra == 'providers'
 Requires-Dist: httpx2>=2.13; extra == 'providers'
@@ -58,7 +62,7 @@ parallel execution, and crash recovery. Requires Python 3.12+.
 - **Tool integration** — `@tool` decorator for local functions, MCP server support,
   DI into tool handlers, agents as tools for LLM-driven delegation
 - **LLM abstraction** — provider-agnostic `LLMProvider` interface with immutable
-  message types and real-time streaming (ships `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`)
+  message types and real-time streaming (ships `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `AnthropicBedrockProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`)
 - **Agents as tools** — `@agent_tool` decorator exposes an agent as a tool the
   LLM can call autonomously; sub-agent runs its own system prompt and tool loop
 - **Cooperative interrupts** — `InterruptToken` for graceful cancellation across
@@ -74,6 +78,7 @@ pip install flowra
 
 # With specific providers
 pip install flowra[anthropic]
+pip install flowra[bedrock]
 pip install flowra[openai]
 pip install flowra[google]
 

{flowra-0.0.90 → flowra-0.0.92.dev108}/README.md

@@ -17,7 +17,7 @@ parallel execution, and crash recovery. Requires Python 3.12+.
 - **Tool integration** — `@tool` decorator for local functions, MCP server support,
   DI into tool handlers, agents as tools for LLM-driven delegation
 - **LLM abstraction** — provider-agnostic `LLMProvider` interface with immutable
-  message types and real-time streaming (ships `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`)
+  message types and real-time streaming (ships `AnthropicVertexProvider`, `AnthropicFoundryProvider`, `AnthropicBedrockProvider`, `OpenAIProvider`, `AzureOpenAIProvider`, `OpenAIResponsesProvider`, `GoogleVertexProvider`)
 - **Agents as tools** — `@agent_tool` decorator exposes an agent as a tool the
   LLM can call autonomously; sub-agent runs its own system prompt and tool loop
 - **Cooperative interrupts** — `InterruptToken` for graceful cancellation across
@@ -33,6 +33,7 @@ pip install flowra
 
 # With specific providers
 pip install flowra[anthropic]
+pip install flowra[bedrock]
 pip install flowra[openai]
 pip install flowra[google]
 

{flowra-0.0.90 → flowra-0.0.92.dev108}/context7.json

@@ -26,17 +26,17 @@
     "LLMData base: metadata (dict, not sent to LLM), extra (dict, provider-namespaced — extra['anthropic'], extra['openai'] (Chat Completions), extra['openai_responses'], extra['google']), transient (bool, non-permanent content hint). ProviderExtra subclasses are frozen dataclasses with mr.MISSING defaults. Three operations: build_extra(MyExtra(field=value)) to construct, MyExtra(field=value).write_to(obj) to mutate, MyExtra.read_from(obj) to read. None clears a field. Extras: AnthropicCacheable (cache_control), AnthropicToolExtra (defer_loading, type), AnthropicBlockExtra (signature, redacted_data, cache_control), AnthropicRequestExtra (thinking_budget_tokens, thinking, output_config), OpenAIRequestExtra (reasoning_effort), OpenAIResponsesToolExtra (defer_loading, type, namespace), OpenAIResponsesRequestExtra (namespaces, reasoning_effort), GoogleBlockExtra (thought_signature, thought), GoogleRequestExtra (thinking_level, thinking_budget)",
     "ThinkingBlock holds reasoning/thinking text from models with extended thinking (Anthropic Claude, Google Gemini); text may be empty (Claude's redacted_thinking, kept with extra['anthropic']['redacted_data']; a Gemini thought that carries only a signature). Each provider sends only its own family's thinking: Anthropic signed or redacted Claude thinking to any Claude model, Google Gemini thoughts (extra['google'] thought=True or a thought_signature) to any Gemini model; thinking from elsewhere is dropped. OpenAI sends none",
     "Tool definition for LLM: Tool inherits LLMData, fields: name, description, input_schema, output_schema (plus metadata, extra, transient from LLMData)",
-    "Six built-in providers: AnthropicVertexProvider (Claude via Vertex AI), AnthropicFoundryProvider (Claude via Azure AI Foundry), OpenAIProvider (OpenAI Chat Completions), AzureOpenAIProvider (OpenAI models via Azure), OpenAIResponsesProvider (OpenAI Responses API — supports tool search with defer_loading), GoogleVertexProvider (Gemini via Vertex AI). All six implement stream() with real-time deltas",
+    "Seven built-in providers: AnthropicVertexProvider (Claude via Vertex AI), AnthropicFoundryProvider (Claude via Azure AI Foundry), AnthropicBedrockProvider (Claude via Amazon Bedrock, extra flowra[bedrock]; model = a Bedrock id or inference profile such as au.anthropic.claude-haiku-5-5; api_key + aws_region or a configured AsyncAnthropicBedrock client), OpenAIProvider (OpenAI Chat Completions), AzureOpenAIProvider (OpenAI models via Azure), OpenAIResponsesProvider (OpenAI Responses API — supports tool search with defer_loading), GoogleVertexProvider (Gemini via Vertex AI). All seven implement stream() with real-time deltas",
     "Long-prompt pricing: some models bill the whole request, output included, at higher rates once the prompt (input + cache read + cache write tokens) exceeds a per-model threshold (ModelPricing.long_prompt_threshold + *_long_prompt rates): Claude Haiku 5.5 100k, Claude Sonnet 4/4.5 and Gemini 2.5/3 Pro 200k, GPT-5.4+ 272k. usage.cost_usd is None for models missing from the provider's price list, or when price_list=None",
-    "Pricing: flowra.llm.pricing has suppliers' price lists — PriceList (model -> ModelPricing; find(served_model, requested_model) returns the first name's rates, a name matching the longest key it contains) and ModelPricing.cost(input_tokens=..., output_tokens=..., cache_read_tokens=..., cache_creation_tokens=..., cache_creation_1h_tokens=..., reasoning_tokens=..., regional=...) -> CostBreakdown; PriceList.cost(served_model, requested_model, input_tokens=..., ...) -> CostBreakdown | None does both. Bundled lists: ANTHROPIC (Anthropic API; Foundry bills Claude at it), VERTEX (Claude and Gemini on Vertex), GEMINI_API (AI Studio), OPENAI, AZURE_OPENAI, INCEPTION. Every provider takes price_list= (None = no cost); defaults: Vertex providers VERTEX (GoogleVertexProvider GEMINI_API for an API-key client), Foundry ANTHROPIC, OpenAIProvider/OpenAIResponsesProvider OPENAI, AzureOpenAIProvider AZURE_OPENAI. OpenAIProvider for Inception: price_list=pricing.INCEPTION. Build your own: PriceList('name', {**pricing.VERTEX.prices, 'model': ModelPricing(input=..., output=...)}) or PriceList.from_json(name, *paths). Regional uplift is per list and model (Vertex non-global: Claude 4.5+, newer Gemini; Anthropic/Foundry Data Zone: Claude 4.6+; OpenAI eu/us)",
+    "Pricing: flowra.llm.pricing has suppliers' price lists — PriceList (model -> ModelPricing; find(served_model, requested_model) returns the first name's rates, a name matching the longest key it contains) and ModelPricing.cost(input_tokens=..., output_tokens=..., cache_read_tokens=..., cache_creation_tokens=..., cache_creation_1h_tokens=..., reasoning_tokens=..., regional=...) -> CostBreakdown; PriceList.cost(served_model, requested_model, input_tokens=..., ...) -> CostBreakdown | None does both. Bundled lists: ANTHROPIC (Anthropic API; Foundry bills Claude at it), BEDROCK (Claude on Amazon Bedrock), VERTEX (Claude and Gemini on Vertex), GEMINI_API (AI Studio), OPENAI, AZURE_OPENAI, INCEPTION. Every provider takes price_list= (None = no cost); defaults: Vertex providers VERTEX (GoogleVertexProvider GEMINI_API for an API-key client), Foundry ANTHROPIC, Bedrock BEDROCK, OpenAIProvider/OpenAIResponsesProvider OPENAI, AzureOpenAIProvider AZURE_OPENAI. OpenAIProvider for Inception: price_list=pricing.INCEPTION. Build your own: PriceList('name', {**pricing.VERTEX.prices, 'model': ModelPricing(input=..., output=...)}) or PriceList.from_json(name, *paths). Regional uplift is per list and model (Vertex non-global: Claude 4.5+, newer Gemini; Anthropic/Foundry Data Zone: Claude 4.6+; Bedrock geography profiles au./eu./us./apac.: Claude 4.5+; OpenAI eu/us)",
     "AnthropicVertexProvider(project=..., location=..., credentials=..., model_locations={'claude-sonnet-5-5': 'eu'}) routes models by id (without @revision) to another Vertex location than the default, one SDK client per location; newer Claude models (Sonnet 5.5, Sonnet 5, Opus 4.7+) are served only on global/us/eu and a single region like europe-west1 answers 429. model_locations needs the credentials form, not client=. usage.cost_usd from AnthropicVertexProvider and GoogleVertexProvider includes Vertex's 10% premium on every location but global for the models it applies to (Claude 4.5+, Gemini 3.1 Flash-Lite and 3.5+ Flash / Flash-Lite); OpenAIProvider and OpenAIResponsesProvider add OpenAI's 10% data-residency premium for most GPT-5.4+ models when base_url is eu.api.openai.com or us.api.openai.com. GoogleVertexProvider counts Gemini thinking tokens in usage.output_tokens and bills them",
-    "Import providers: from flowra.llm.providers.anthropic_vertex import AnthropicVertexProvider, from flowra.llm.providers.anthropic_foundry import AnthropicFoundryProvider, from flowra.llm.providers.openai import OpenAIProvider, from flowra.llm.providers.azure_openai import AzureOpenAIProvider, from flowra.llm.providers.openai_responses import OpenAIResponsesProvider, from flowra.llm.providers.google_vertex import GoogleVertexProvider",
+    "Import providers: from flowra.llm.providers.anthropic_vertex import AnthropicVertexProvider, from flowra.llm.providers.anthropic_foundry import AnthropicFoundryProvider, from flowra.llm.providers.anthropic_bedrock import AnthropicBedrockProvider, from flowra.llm.providers.openai import OpenAIProvider, from flowra.llm.providers.azure_openai import AzureOpenAIProvider, from flowra.llm.providers.openai_responses import OpenAIResponsesProvider, from flowra.llm.providers.google_vertex import GoogleVertexProvider",
     "Import stream types: from flowra.llm import TextDelta, ThinkingDelta, ContentComplete. Import observability types: from flowra.lib.observability import TextDeltaEvent, ThinkingDeltaEvent, LLMCallSpan, ToolCallSpan",
     "AnthropicRequestExtra(thinking_budget_tokens=4000) enables extended thinking on Claude models before 4.6. For Claude 4.6+ pass the API parameters as-is: AnthropicRequestExtra(thinking={'type': 'adaptive'}, output_config={'effort': 'low'}); an explicit thinking wins over thinking_budget_tokens. Each is sent only when set and is not validated against the model (same for temperature/top_p)",
     "GoogleRequestExtra(thinking_level='medium') or GoogleRequestExtra(thinking_budget=4096) configures Gemini thinking. Pass via extra=build_extra(GoogleRequestExtra(thinking_level='medium'))",
     "OpenAIResponsesRequestExtra(namespaces={'crm': 'CRM tools'}) (also reasoning_effort, see OpenAI reasoning effort) defines namespace descriptions for OpenAI Responses API tool search. Tools with OpenAIResponsesToolExtra(namespace='crm') are grouped into namespace objects. Both live under extra['openai_responses']",
     "SCHEMAS: any JSON schema (recursive $ref, oneOf, allOf, const, additionalProperties, type arrays) works with every provider at every level, except an allOf that cannot be merged (conflicting parts, or a $ref next to other constraints), which OpenAI strict mode rejects. Chat Completions and Gemini adapt json_schema and a tool's input_schema to their API; the Responses API adapts json_schema and sends a tool's schema as is (strict false); Anthropic puts json_schema into the prompt as text and sends a tool's schema as is. The helpers are exported from flowra.llm for a provider of your own: make_schema_strict (OpenAI strict mode: additionalProperties false, all properties required, optional as anyOf with null, no default on a property; oneOf as anyOf, const as a typed one-value enum, allOf merged when its parts do not conflict), drop_strict_nulls(value, schema) (an answer to make_schema_strict(schema) refitted to schema: a null for an optional property whose schema does not allow null is dropped; the OpenAI providers apply it to a json_schema answer and Chat tool arguments), adapt_schema_for_gemini (const as enum, allOf merged when its parts do not conflict; Gemini gets json_schema as response_json_schema and a tool's as parameters_json_schema, full JSON Schema), format_schema_for_llm (schema as text for a prompt, Anthropic's json_schema; a recursive type written once as Name = {...} and named elsewhere), format_output_schema_for_description (a tool's output_schema in its description), validate_json_schema (returns (error, the answer without a markdown code fence)). make_schema_strict and adapt_schema_for_gemini return a new schema and leave the given one unchanged",
-    "Anthropic providers (Vertex, Foundry) fall back to non-streaming when json_schema is set (retry loop requires full responses)",
+    "Anthropic providers (Vertex, Foundry, Bedrock) fall back to non-streaming when json_schema is set (retry loop requires full responses)",
 
     "SPAN-HOOKS: observability wrappers with guaranteed enter/exit. Register via hooks.on_span(SpanType, handler). Handler receives Event[T] (same envelope as regular hooks, with execution context) — access span via event.data. Returns SpanExitHandler(error: BaseException | None) or None. Span is mutable — input fields set at open, result fields set before close. Later subscribers are outer (among normal on_span handlers). open_span/close_span for long-lived spans, async with emitter.span() for simple cases. hooks.on_self_span(SpanType, handler) subscribes to span events emitted by the agent itself (the baseline excludes self-emits for on_span); the handler is bound to the agent's own hooks instance and fires only for that instance's own emits (not other agents, not other instances of the same agent); self-emit handlers fire after normal handlers on enter and before them on exit (innermost). ToolCallAgent uses on_self_span(AgentSpan, ...) to emit ToolCallSpan around the lifetime of its own AgentSpan, so the tool span and any child agents spawned by the tool nest correctly across Spawn boundaries",
     "Span types: AgentSpan/StepSpan (engine lifecycle, from flowra.agent import AgentSpan, StepSpan), LLMCallSpan/ToolCallSpan (flowra.lib.observability). All mutable dataclasses with input + result fields. ToolCallSpan has error_kind (ToolErrorKind | None)",
@@ -129,12 +129,12 @@
 
     "PRE-BUILT AGENTS — TurnAgent: single-turn LLM tool loop with hooks and caching",
     "TurnAgent sends messages to LLM, executes tool calls, feeds results back, repeats until done",
-    "TurnAgent stop handling: a response without tool calls ends the turn with TurnStatus.COMPLETED and TurnResult.stop_reason (END_TURN, MAX_TOKENS, STOP_SEQUENCE, OTHER, SCHEMA_VALIDATION_FAILED, REFUSAL). On REFUSAL TurnResult.refusal is set, result_message is None and messages keep the turn so far (tool calls included) with no empty assistant message. If a response stopped with anything but END_TURN/TOOL_USE ends on a tool call, that call was cut off: it is not run and gets an error ToolResultBlock (no Before/AfterToolCallEvent, no ToolCallSpan, not counted in max_consecutive_errors), the complete calls before it run, and the loop continues so the model can retry (bounded by max_llm_calls). History never holds an unanswered tool_use",
+    "TurnAgent stop handling: a response without tool calls ends the turn with TurnStatus.COMPLETED and TurnResult.stop_reason (END_TURN, MAX_TOKENS, STOP_SEQUENCE, OTHER, SCHEMA_VALIDATION_FAILED, REFUSAL). On REFUSAL TurnResult.refusal is set, result_message is None and messages keep the turn so far (tool calls included) with no empty assistant message. If a response stopped with anything but END_TURN/TOOL_USE ends on a tool call, that call was cut off: it is not run and gets an error ToolResultBlock (it appears in BeforeToolCallsEvent.tool_uses; no BeforeToolCallEvent/AfterToolCallEvent, no ToolCallSpan, not counted in max_consecutive_errors), the complete calls before it run, and the loop continues so the model can retry (bounded by max_llm_calls). History never holds an unanswered tool_use",
     "TurnConfig configures TurnAgent: TurnConfig(llm_config=LLMConfig(model='...'), system=[...], history=[...])",
     "RENDER: ChatConfig.render / TurnConfig.render (PromptRender = Callable[[Prompt], Prompt | Awaitable[Prompt]]; Prompt from flowra.lib.turn has system and messages) is called once per LLM call of the turn (not per fallback attempt), before LLMCaller, with the system messages and the conversation (history, then turn messages). What it returns is sent to every fallback link; each link's request_extensions apply after it, and each attempt's LLMCallSpan carries the request with them applied. Stored history and turn messages are not changed, so a marker block can be rendered from live state on each call; build new messages, never edit the given ones. Messages left with no blocks are not sent, none left at all is a ValueError before the call; a tool call must still be followed straight away by its results (Claude and OpenAI Chat Completions reject anything in between); an error in render is raised from the turn as is; an interrupt stops an async render and ends the turn INTERRUPTED",
     "TurnAgent lifecycle: __post_init__ emits TurnReadyEvent(context, turn_messages) — fires on both creation and crash recovery. ChatAgent subscribes and emits ConversationReadyEvent(conversation, context) with a Conversation view combining history + turn messages",
     "Conversation class (from flowra.lib.chat): read-only Sequence view over history + turn_messages. Supports len(), indexing, slicing, forward/reverse iteration. Live — reflects changes to underlying lists. Properties: history_len, turn_len. Method without_pending_tool_use() -> list[UserMessage | AssistantMessage] returns messages with ToolUseBlocks stripped from the last AssistantMessage (drops the message entirely if it becomes empty) — use it inside an agent-as-tool to feed the parent conversation to a child LLM call without the unresolved tool-use that spawned it",
-    "TurnAgent hook events: StartTurnEvent (messages, metadata — mutate messages to augment input), MessageAcceptedEvent, StartIterationEvent, TextReasoningEvent (each TextBlock with text in response), ThinkingEvent (each ThinkingBlock with text; not redacted or signature-only thoughts), ServerToolCallEvent (server-side tool call from intermediate messages, e.g. tool search), ServerToolResultEvent (server-side tool result), ResultMessageEvent, BeforeToolCallEvent (has tool_definition: ToolDefinition | None; mutable tool_use, headers, meta — see ToolCallInfo), AfterToolCallEvent (has error_kind; result is a single ToolResultBlock; append TextBlock/MediaBlock to additional_blocks to attach them to this call's result — they go at the end of its content, also when max_consecutive_errors replaces it, so they stay with their call and never land between the results of parallel calls; mark one transient to keep it out of saved history; being part of the result, a MediaBlock there takes the providers' rules for media in a tool result (Chat Completions raises, Gemini before 3 does not see it) and a transient block ends the non-transient cache prefix before the result). Delta events: TextDeltaEvent, ThinkingDeltaEvent (from flowra.lib.observability — shared with LLMCallAgent). UsageEvent emitted after each LLM call + subscribed to accumulate usage from child agents (e.g. agent_as_tool). Span-hooks: LLMCallSpan, ToolCallSpan. Request transforms (prompt caching, tool search) are NOT hooks — they live on LLMConfig.request_extensions. A conversation transform for every fallback link goes in ChatConfig.render / TurnConfig.render (see RENDER)",
+    "TurnAgent hook events: StartTurnEvent (messages, metadata — mutate messages to augment input), MessageAcceptedEvent, StartIterationEvent, TextReasoningEvent (each TextBlock with text in response), ThinkingEvent (each ThinkingBlock with text; not redacted or signature-only thoughts), ServerToolCallEvent (server-side tool call from intermediate messages, e.g. tool search), ServerToolResultEvent (server-side tool result), ResultMessageEvent, BeforeToolCallsEvent (once per model message with tool calls, before any runs; tool_uses is every call of the message, a cut-off call included (an answer under its id is not used); put a ToolResult into results under a call's id to answer it without running it — that call gets no BeforeToolCallEvent and no ToolCallSpan, its result goes through AfterToolCallEvent with prefilled=True and max_consecutive_errors in message order, an error without error_kind gets EXECUTION; a key not among the message's call ids raises ValueError), BeforeToolCallEvent (has tool_definition: ToolDefinition | None; mutable tool_use, headers, meta — see ToolCallInfo; not emitted for a call answered in BeforeToolCallsEvent), AfterToolCallEvent (fires after execution, and for a call answered in BeforeToolCallsEvent; has error_kind; prefilled is true for a call answered in BeforeToolCallsEvent; result is a single ToolResultBlock; append TextBlock/MediaBlock to additional_blocks to attach them to this call's result — they go at the end of its content, also when max_consecutive_errors replaces it, so they stay with their call and never land between the results of parallel calls; mark one transient to keep it out of saved history; being part of the result, a MediaBlock there takes the providers' rules for media in a tool result (Chat Completions raises, Gemini before 3 does not see it) and a transient block ends the non-transient cache prefix before the result). Delta events: TextDeltaEvent, ThinkingDeltaEvent (from flowra.lib.observability — shared with LLMCallAgent). UsageEvent emitted after each LLM call + subscribed to accumulate usage from child agents (e.g. agent_as_tool). Span-hooks: LLMCallSpan, ToolCallSpan. Request transforms (prompt caching, tool search) are NOT hooks — they live on LLMConfig.request_extensions. A conversation transform for every fallback link goes in ChatConfig.render / TurnConfig.render (see RENDER)",
     "When TextDeltaEvent or ThinkingDeltaEvent handlers are registered, TurnAgent automatically uses provider.stream() instead of provider.call()",
 
     "AGENTS AS TOOLS: Tools can delegate to sub-agents via ToolCallAgentContext.call_agent(). make_agent_tool(AgentClass, name, description) creates an ExecutableTool with input_schema from spec type and output_schema from result type (ToolResult excluded). @agent_tool decorator marks an agent class as a tool, get_agent_tool() extracts the ExecutableTool. ToolCallAgent spawns the sub-agent and serializes its result as a ToolResultBlock. Agent tools can return ToolResult directly to signal errors to the parent LLM or answer with blocks (e.g. return ToolResult(content='...', is_error=True)) — the agent completes normally; with is_error=True the parent LLM sees a tool error and can retry. Compile-time validation: step return types must be a subset of Agent's generic result type parameter. The sub-agent must be declared by the agent running the tool or one of its registry ancestors (top level works); it receives services of its own registry ancestors, not the calling chat's (unless the chat is one of them)",

{flowra-0.0.90 → flowra-0.0.92.dev108}/docs/agents.md

@@ -802,11 +802,14 @@ Lifecycle events (from `flowra.lib.turn`):
 | `ThinkingEvent`          | Non-empty thinking block in LLM response | —                                             |
 | `ServerToolCallEvent`    | Server-side tool call (e.g. tool search) | —                                             |
 | `ServerToolResultEvent`  | Server-side tool result                  | —                                             |
+| `BeforeToolCallsEvent`   | Message with tool calls, before any runs | `results`                                     |
 | `BeforeToolCallEvent`    | Before tool execution                    | `tool_use`, `headers`, `meta`                 |
-| `AfterToolCallEvent`     | After tool execution                     | `result`, `additional_blocks`, `additional_messages` |
+| `AfterToolCallEvent`     | After tool execution or answer           | `result`, `additional_blocks`, `additional_messages` |
 | `ResultMessageEvent`     | LLM finished (END_TURN)                  | `continue_messages`                           |
 
-Tool calls cut off by the output limit fire no tool events; see
+A tool call cut off by the output limit appears in `BeforeToolCallsEvent` but
+fires no `BeforeToolCallEvent` or `AfterToolCallEvent`, and a call answered in
+`BeforeToolCallsEvent` does not run; see
 [Pre-built events](observability.md#pre-built-events) in Observability.
 
 Streaming events (from `flowra.lib.observability`):

{flowra-0.0.90 → flowra-0.0.92.dev108}/docs/architecture.md

@@ -29,7 +29,7 @@ ext            (agent, llm, lib)
 Code imports another package's public names from its `__init__`, never from its
 internal modules. One deliberate exception: `flowra.llm.providers` exports
 nothing, because each provider needs its own optional SDK (`flowra[anthropic]`,
-`flowra[openai]`, `flowra[google]`). Each provider module
+`flowra[bedrock]`, `flowra[openai]`, `flowra[google]`). Each provider module
 (`flowra.llm.providers.anthropic_vertex`, …) is that provider's public entry
 point, and code imports from it directly.
 
@@ -44,8 +44,9 @@ import inside a function.
 Protocol layer between the SDK and any LLM. The core abstraction is `LLMProvider` —
 `call(LLMRequest) → LLMResponse` for full responses, and `stream(LLMRequest) →
 AsyncIterator[StreamEvent]` for real-time text/thinking deltas. Request and response use
-a shared set of message and block types. Ships six providers:
+a shared set of message and block types. Ships seven providers:
 `AnthropicVertexProvider` (Claude via Vertex AI), `AnthropicFoundryProvider` (Claude via Azure AI Foundry),
+`AnthropicBedrockProvider` (Claude via Amazon Bedrock),
 `OpenAIProvider` (OpenAI Chat Completions), `AzureOpenAIProvider` (OpenAI models via Azure),
 `OpenAIResponsesProvider` (OpenAI Responses API), `GoogleVertexProvider` (Gemini via Vertex AI). → [docs/llm.md](llm.md)
 

{flowra-0.0.90 → flowra-0.0.92.dev108}/docs/getting-started.md

@@ -6,7 +6,8 @@ Flowra — from a single LLM call to a multi-turn chatbot with tools.
 ## Installation
 
 ```bash
-pip install flowra[anthropic]   # Claude via Vertex AI
+pip install flowra[anthropic]   # Claude via Vertex AI or Microsoft Foundry
+pip install flowra[bedrock]     # Claude via Amazon Bedrock
 pip install flowra[openai]      # OpenAI-compatible APIs
 pip install flowra[google]      # Gemini via Vertex AI
 pip install flowra[providers]   # all providers

{flowra-0.0.90 → flowra-0.0.92.dev108}/docs/llm.md

@@ -9,7 +9,7 @@ For the basics (making a call, using ChatAgent), see
 
 ## Providers
 
-Flowra ships six providers. Each lives in its own module to avoid pulling in
+Flowra ships seven providers. Each lives in its own module to avoid pulling in
 unnecessary dependencies.
 
 ### AnthropicVertexProvider (Claude via Vertex AI)
@@ -127,6 +127,45 @@ async with AnthropicFoundryProvider(resource="my-azure-resource", api_key="...",
     ...
 ```
 
+### AnthropicBedrockProvider (Claude via Amazon Bedrock)
+
+```bash
+pip install flowra[bedrock]
+```
+
+```python
+from flowra.llm.providers.anthropic_bedrock import AnthropicBedrockProvider
+
+async with AnthropicBedrockProvider(
+    api_key="...",                # a Bedrock API key, sent as a bearer token
+    aws_region="ap-southeast-2",
+) as provider:
+    ...
+
+# Or with a pre-configured client, e.g. for AWS access keys or a profile:
+from anthropic import AsyncAnthropicBedrock
+async with AnthropicBedrockProvider(client=AsyncAnthropicBedrock(aws_profile="...")) as provider:
+    ...
+```
+
+Set `LLMRequest.model` to a Bedrock model id or inference profile. A profile's
+prefix says where Bedrock may run the call: `global.anthropic.claude-sonnet-5-5`
+in any region, `au.anthropic.claude-haiku-5-5` only within one geography (`au.`,
+`eu.`, `us.`, `apac.`, `jp.`, ...). Older models carry a date and version:
+`au.anthropic.claude-haiku-4-5-20251001-v1:0`. `aws_region` is the region
+requests go to; call a geography's profile from one of its regions (`au.` from
+`ap-southeast-2`). Bedrock names the underlying model in its response
+(`claude-haiku-5-5`); flowra prices the call as that model and returns it in
+`response.model`.
+
+Calls are priced from the `BEDROCK` price list (see [Price lists](#price-lists)).
+A geography's profile bills 10% above a `global.` one for Claude 4.5 and later;
+flowra reads the profile from the model id, or from the end of a system
+inference profile's ARN. A bare model id (`anthropic.claude-…`) or an
+application inference profile's ARN is priced at the base rate. GovCloud's
+profiles (`us-gov.`) have prices of their own, which the list does not hold:
+their calls report no cost (`cost_usd=None`).
+
 ### OpenAIProvider (OpenAI and compatible APIs)
 
 ```bash
@@ -284,7 +323,7 @@ when the result carries media:
 
 | Provider                                  | Text only                  | With media                                                                     |
 |-------------------------------------------|----------------------------|--------------------------------------------------------------------------------|
-| Anthropic (Vertex, Foundry, API)          | `result.text`              | a list of `text` / `image` / `document` blocks; the API takes JPEG, PNG, GIF, WebP and PDF |
+| Anthropic (Vertex, Foundry, Bedrock, API) | `result.text`              | a list of `text` / `image` / `document` blocks; the API takes JPEG, PNG, GIF, WebP and PDF |
 | `OpenAIProvider`, `AzureOpenAIProvider`   | `result.text`              | `ValueError`: Chat Completions takes only text in a tool message               |
 | `OpenAIResponsesProvider`                 | `result.text`              | a list of `input_text` / `input_image` / `input_file` items; the API takes PNG, JPEG, WebP and GIF images and document or text files, not audio, video, archives or `application/octet-stream` |
 | `GoogleVertexProvider`                    | `{"result": result.text}`  | `{"result": result.text}` plus the media in the function response's `parts`, which Gemini 3 models see; Gemini 2.5 takes the request but does not see the media |
@@ -395,7 +434,7 @@ Every error carries:
 | `model` | `str` | The requested model |
 | `status_code` | `int \| None` | The HTTP status; `None` when no error status came back: a connection error or timeout, an error event inside a stream, a failed Responses API response, a request flowra stops before sending because Gemini's SDK would refuse it (nothing to send) |
 | `retry_after` | `float \| None` | Seconds to wait, from the response's `retry-after` header, if any |
-| `request_id` | `str \| None` | The provider's id of the request (`request-id`, `apim-request-id` or `x-request-id`), to quote to its support; Gemini sends none |
+| `request_id` | `str \| None` | The provider's id of the request (`request-id`, `apim-request-id`, `x-request-id` or `x-amzn-RequestId`), to quote to its support; Gemini sends none |
 | `partial` | `bool` | `True` when a stream had already yielded events before failing |
 
 `str(error)` names the provider and model and keeps the provider's own message.
@@ -441,7 +480,9 @@ except TransientLLMError as error:
 
 Errors that arrive inside a stream — Anthropic's and OpenAI's error events,
 `OpenAIResponsesProvider`'s `error` and `response.failed` events — are typed by
-what they report (an `overloaded_error` event is an `OverloadedError`). Without
+what they report (an `overloaded_error` event is an `OverloadedError`; Bedrock's
+`throttlingException` a `RateLimitedError`, its `validationException` a
+`BadRequestError`, or a `ContextTooLongError` when the prompt is too long). Without
 a status, OpenAI's error goes by its code, then its type, and one flowra does not
 know is an `UnavailableError`. A bad request — its code is one of the request-blaming codes below, or,
 with no code flowra knows, its type is `invalid_request_error` (vLLM:
@@ -621,7 +662,7 @@ last column:
 
 | Provider | What is a refusal | `categories` | `explanation` | Keys in `response.extra` |
 |---|---|---|---|---|
-| Anthropic (Vertex, Foundry) | `stop_reason: "refusal"`: Claude's safety classifiers | `stop_details.category`: `cyber`, `bio`, `frontier_llm`, `reasoning_extraction`, `general_harms` | `stop_details.explanation` | `stop_details` |
+| Anthropic (Vertex, Foundry, Bedrock) | `stop_reason: "refusal"`: Claude's safety classifiers | `stop_details.category`: `cyber`, `bio`, `frontier_llm`, `reasoning_extraction`, `general_harms` | `stop_details.explanation` | `stop_details` |
 | OpenAI Chat Completions | `finish_reason: "content_filter"` on the choice, or on the separate stream event Azure's asynchronous filter sends when it blocks a stream; the model's `message.refusal` (structured outputs) | Azure's `content_filter_results` entries with `filtered: true` | `message.refusal` | `content_filter_results` (Azure) |
 | Azure (Chat and Responses) | a 400 with code `content_filter`: the prompt filter | `innererror.content_filter_result` entries with `filtered: true`, e.g. `jailbreak`, `hate` | the error's message | none |
 | OpenAI Responses | `incomplete_details.reason: "content_filter"`; a `refusal` output part; a failed response, or a stream's `error` event, with `bio_policy`, `misalignment_policy_violation` or `image_content_policy_violation` | the policy code | the refusal part's text, or the failure's message | `incomplete_reason`, or `provider_status` for a failed response |
@@ -806,7 +847,7 @@ and the history keeps the thinking each model produced. Each provider sends
 only the part of it that the model it calls accepts:
 
 - **Anthropic** sends Claude's thinking, signed or redacted, to any Claude model,
-  on any cloud (Vertex and Foundry accept each other's signatures). It drops
+  on any cloud (Vertex, Foundry and Bedrock accept each other's signatures). It drops
   thinking from another provider or written by hand: the API rejects thinking
   without Claude's signature.
 - **Google** sends Gemini's thoughts and thought signatures to any Gemini model,
@@ -1125,6 +1166,7 @@ litellm or the supplier's own models API, with manual overrides, in
 | List | Supplier | Used by default by |
 |---|---|---|
 | `ANTHROPIC` | Anthropic's API; Microsoft Foundry bills Claude at these prices | `AnthropicFoundryProvider` |
+| `BEDROCK` | Claude on Amazon Bedrock | `AnthropicBedrockProvider` |
 | `VERTEX` | Google Cloud Vertex AI: Claude and Gemini | `AnthropicVertexProvider`, `GoogleVertexProvider` on Vertex |
 | `GEMINI_API` | The Gemini Developer API (Google AI Studio) | `GoogleVertexProvider` with `client=genai.Client(api_key=...)` |
 | `OPENAI` | OpenAI | `OpenAIProvider`, `OpenAIResponsesProvider` |
@@ -1213,6 +1255,9 @@ needs none of this: each child prices its own calls, and their `Usage` add up.
     (see [Locations](#locations)); `GoogleVertexProvider` by its `location`.
   - `ANTHROPIC`, on a Foundry US Data Zone deployment
     (`AnthropicFoundryProvider(data_zone=True)`): Claude 4.6 and later.
+  - `BEDROCK`, on a geography's cross-region profile (`au.anthropic.…`,
+    `eu.anthropic.…`, but not `global.anthropic.…`): Claude 4.5 and later.
+    `AnthropicBedrockProvider` reads the profile from the model id.
   - `OPENAI`, when `base_url` is `https://eu.api.openai.com/v1` or
     `https://us.api.openai.com/v1`: most GPT-5.4 and later models. Applies to
     `OpenAIProvider` and `OpenAIResponsesProvider`.

{flowra-0.0.90 → flowra-0.0.92.dev108}/docs/observability.md

@@ -35,8 +35,9 @@ Events from `TurnAgent` (and `ChatAgent`, which uses it internally):
 | `ThinkingEvent`          | Non-empty thinking block in LLM response | —                                             |
 | `ServerToolCallEvent`    | Server-side tool call (e.g. tool search) | —                                             |
 | `ServerToolResultEvent`  | Server-side tool result                  | —                                             |
+| `BeforeToolCallsEvent`   | Message with tool calls, before any runs | `results`                                     |
 | `BeforeToolCallEvent`    | Before tool execution                    | `tool_use`, `headers`, `meta`                 |
-| `AfterToolCallEvent`     | After tool execution                     | `result`, `additional_blocks`, `additional_messages` |
+| `AfterToolCallEvent`     | After tool execution or answer           | `result`, `additional_blocks`, `additional_messages` |
 | `ResultMessageEvent`     | LLM finished (END_TURN)                  | `continue_messages`                           |
 
 `AfterToolCallEvent.additional_blocks` go at the end of that call's result, so a
@@ -71,7 +72,37 @@ runtime.hooks.on(AfterToolCallEvent, add_hint)
 A tool call cut off by the output limit (see [TurnAgent](agents.md#turnagent)) is
 never executed. It gets an error result directly, with no `BeforeToolCallEvent`,
 `AfterToolCallEvent` or `ToolCallSpan`, so hooks that audit or rewrite tool
-results don't see it.
+results don't see it; it does appear in `BeforeToolCallsEvent.tool_uses`, and an
+answer put under its id is not used.
+
+`BeforeToolCallsEvent` fires once per model message with tool calls, a single
+call included, before any of them runs. A handler answers a call itself by
+putting a `ToolResult` into `results` under the call's id: that call does not
+run, and the others run as usual. An answered call gets no `BeforeToolCallEvent`
+and no `ToolCallSpan`; its result goes through `AfterToolCallEvent` (with
+`prefilled=True`) and `max_consecutive_errors` like any other, in the message's
+order. An error answered without an `error_kind` arrives with
+`ToolErrorKind.EXECUTION`. A key that is not the id of a call in the message
+fails the step with `ValueError`.
+
+```python
+from flowra.agent import Event
+from flowra.lib.turn import BeforeToolCallsEvent
+from flowra.tools import ToolResult
+
+
+def reply_alone(event: Event[BeforeToolCallsEvent]) -> None:
+    if len(event.data.tool_uses) < 2:
+        return
+    for tool_use in event.data.tool_uses:
+        if tool_use.name == "send_reply":
+            event.data.results[tool_use.id] = ToolResult(
+                content="Call send_reply on its own, in a message with no other tool calls.", is_error=True
+            )
+
+
+runtime.hooks.on(BeforeToolCallsEvent, reply_alone)
+```
 
 A tool call that fails the run (an exception raised around a tool's executor,
 see [Error handling](tools.md#what-fails-the-run)) has no result:

{flowra-0.0.90 → flowra-0.0.92.dev108}/flowra/lib/turn/__init__.py

@@ -4,6 +4,7 @@ from .context import TurnAgentContext
 from .hook_events import (
     AfterToolCallEvent,
     BeforeToolCallEvent,
+    BeforeToolCallsEvent,
     MessageAcceptedEvent,
     ResultMessageEvent,
     ServerToolCallEvent,
@@ -20,6 +21,7 @@ from .tool_call import ToolCallAgentContext, agent_tool, get_agent_tool, make_ag
 __all__ = [
     "AfterToolCallEvent",
     "BeforeToolCallEvent",
+    "BeforeToolCallsEvent",
     "MessageAcceptedEvent",
     "Prompt",
     "PromptRender",