agentbyte 0.55.0__tar.gz → 0.56.0__tar.gz

{agentbyte-0.55.0 → agentbyte-0.56.0}/.gitignore

@@ -84,3 +84,7 @@ optim-reports/
 
 # marimo local session cache
 __marimo__/
+
+# Local Claude worktrees and machine-specific permissions
+.claude/worktrees/
+.claude/settings.local.json

{agentbyte-0.55.0 → agentbyte-0.56.0}/CHANGELOG.md

@@ -6,6 +6,28 @@ The format follows Keep a Changelog principles and semantic versioning.
 
 ## [Unreleased]
 
+## [0.56.0] - 2026-10-23
+
+### Added
+
+- `pricing_model=` on OpenAI chat/embedding, Anthropic direct/Bedrock chat, and Cohere Bedrock
+  embedding constructors and factories, matching Azure pricing aliases. Component configs preserve
+  the alias; manual `model_pricing` takes precedence while transport model IDs remain unchanged.
+- Standard short-context catalog entries for `gpt-6.1-sol`, `gpt-6-astra`, and `gpt-6-luna`,
+  including cached-input and 30-minute cache-write metadata.
+
+### Changed
+
+- Consolidated 19 AgentByte coding skills into one topic router with references loaded on demand;
+  removed the WebUI smoke-test skill and repaired migration-guide links.
+- Added proposed spec 0077 for OpenAI models on Bedrock over SigV4 and updated the spec index.
+
+### Fixed
+
+- Exact Claude Sonnet 5.5, Fable 5.1, Mythos 5, and Mythos 5.1 pricing prevents sibling fallback.
+  Claude 5-series rates now include cache reads and 5-minute cache-write metadata, including
+  Haiku 5.5 below the 100K prompt threshold.
+
 ## [0.55.0] - 2026-10-12
 
 ### Added

{agentbyte-0.55.0 → agentbyte-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.55.0
+Version: 0.56.0
 Summary: A toolkit for designing multiagent systems
 Author-email: MrDataPsycho <mr.data.psycho@gmail.com>
 License-Expression: LicenseRef-Proprietary
@@ -90,7 +90,7 @@ Description-Content-Type: text/markdown
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.55.0**
+Current release: **0.56.0**
 
 ## Building an Agent
 

{agentbyte-0.55.0 → agentbyte-0.56.0}/README.md

@@ -2,7 +2,7 @@
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.55.0**
+Current release: **0.56.0**
 
 ## Building an Agent
 

agentbyte-0.56.0/src/agentbyte/__about__.py

@@ -0,0 +1,2 @@
+__version__ = "0.56.0"
+VERSION = __version__

{agentbyte-0.55.0 → agentbyte-0.56.0}/src/agentbyte/llm/anthropic/chat.py

@@ -19,6 +19,7 @@ from ._conversion import AnthropicConversionMixin
 class AnthropicChatCompletionClientConfig(BaseChatCompletionClientConfig):
     """Configuration for AnthropicChatCompletionClient serialization."""
 
+    pricing_model: str | None = None
     retry_policy: RetryPolicy = RetryPolicy()
     key_env_var: str = "ANTHROPIC_API_KEY"
 
@@ -46,9 +47,11 @@ class AnthropicChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ):
         super().__init__(model, client, config, middlewares=middlewares)
         self.model_pricing = model_pricing
+        self.pricing_model = pricing_model
         if retry_policy is not None:
             self.retry_policy = retry_policy
         else:
@@ -83,6 +86,7 @@ class AnthropicChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ) -> "AnthropicChatCompletionClient":
         """Create a client from an explicit or env-backed API key."""
         from pydantic import ValidationError
@@ -109,6 +113,7 @@ class AnthropicChatCompletionClient(
             client=anthropic_client,
             config=config,
             model_pricing=model_pricing,
+            pricing_model=pricing_model,
             max_retries=max_retries,
             initial_retry_delay=initial_retry_delay,
             max_retry_delay=max_retry_delay,
@@ -126,13 +131,14 @@ class AnthropicChatCompletionClient(
         if self.model_pricing is not None:
             pricing = self.model_pricing
         else:
-            pricing = PricingRegistry.resolve_anthropic_chat_pricing(self.model)
+            pricing = PricingRegistry.resolve_anthropic_chat_pricing(self.pricing_model or self.model)
         return pricing.calculate_cost(input_tokens, output_tokens, cached_tokens)
 
     def _to_config(self) -> AnthropicChatCompletionClientConfig:
         """Serialize to config without persisting secrets."""
         return AnthropicChatCompletionClientConfig(
             model=self.model,
+            pricing_model=self.pricing_model,
             config=self.config.copy(),
             retry_policy=self.retry_policy,
             key_env_var=getattr(self, "_key_env_var", "ANTHROPIC_API_KEY"),
@@ -153,6 +159,7 @@ class AnthropicChatCompletionClient(
             )
         instance = cls.from_api_key(
             model=config.model,
+            pricing_model=config.pricing_model,
             api_key=api_key,
             config=config.config or None,
             retry_policy=config.retry_policy,

{agentbyte-0.55.0 → agentbyte-0.56.0}/src/agentbyte/llm/bedrock/anthropic_chat.py

@@ -27,6 +27,7 @@ _BEDROCK_ID_SUFFIX_RE = re.compile(r"-v\d+:\d+$")
 class AnthropicBedrockChatCompletionClientConfig(BaseChatCompletionClientConfig):
     """Serializable Bedrock Claude client configuration."""
 
+    pricing_model: str | None = None
     retry_policy: RetryPolicy = RetryPolicy()
     region_env_var: str = "AWS_REGION"
     profile_env_var: str = "AWS_PROFILE"
@@ -69,9 +70,11 @@ class AnthropicBedrockChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ):
         super().__init__(model, client, config, middlewares=middlewares)
         self.model_pricing = model_pricing
+        self.pricing_model = pricing_model
         if retry_policy is not None:
             self.retry_policy = retry_policy
         else:
@@ -106,6 +109,7 @@ class AnthropicBedrockChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ) -> "AnthropicBedrockChatCompletionClient":
         """Create a client from an explicit or env-backed AWS region/profile.
 
@@ -127,6 +131,7 @@ class AnthropicBedrockChatCompletionClient(
             client=bedrock_client,
             config=config,
             model_pricing=model_pricing,
+            pricing_model=pricing_model,
             max_retries=max_retries,
             initial_retry_delay=initial_retry_delay,
             max_retry_delay=max_retry_delay,
@@ -143,6 +148,8 @@ class AnthropicBedrockChatCompletionClient(
         """Estimate cost, normalizing the Bedrock model ID before resolving."""
         if self.model_pricing is not None:
             pricing = self.model_pricing
+        elif self.pricing_model is not None:
+            pricing = PricingRegistry.resolve_anthropic_chat_pricing(self.pricing_model)
         else:
             stripped_region = _BEDROCK_ID_REGION_PREFIX_RE.sub("", self.model)
             normalized_model = _BEDROCK_ID_SUFFIX_RE.sub(
@@ -155,6 +162,7 @@ class AnthropicBedrockChatCompletionClient(
         """Serialize to config without persisting secrets (region/profile stay in env)."""
         return AnthropicBedrockChatCompletionClientConfig(
             model=self.model,
+            pricing_model=self.pricing_model,
             config=self.config.copy(),
             retry_policy=self.retry_policy,
         )
@@ -166,6 +174,7 @@ class AnthropicBedrockChatCompletionClient(
         """Reconstruct client from saved config, re-resolving region/profile from env."""
         return cls.from_region(
             model=config.model,
+            pricing_model=config.pricing_model,
             config=config.config or None,
             retry_policy=config.retry_policy,
         )

{agentbyte-0.55.0 → agentbyte-0.56.0}/src/agentbyte/llm/bedrock/cohere_embedding.py

@@ -32,6 +32,7 @@ class CohereTruncate(StrEnum):
 
 
 class CohereBedrockEmbeddingClientConfig(BaseEmbeddingClientConfig):
+    pricing_model: str | None = None
     retry_policy: RetryPolicy = RetryPolicy()
     region_env_var: str = "AWS_REGION"
     profile_env_var: str = "AWS_PROFILE"
@@ -50,8 +51,10 @@ class CohereBedrockEmbeddingClient(
                  model_pricing: Optional[ModelPricing] = None, max_retries: int = 3,
                  initial_retry_delay: float = 1.0, max_retry_delay: float = 60.0,
                  retry_policy: Optional[RetryPolicy] = None, region: str | None = None,
-                 profile: str | None = None, middlewares: Optional[List[ClientMiddleware]] = None):
+                 profile: str | None = None, middlewares: Optional[List[ClientMiddleware]] = None,
+                 pricing_model: str | None = None):
         super().__init__(model, client, config, middlewares=middlewares)
+        self.pricing_model = pricing_model
         self.model_pricing, self.region, self.profile = model_pricing, region, profile
         self.retry_policy = retry_policy or RetryPolicy(max_retries=max_retries, initial_retry_delay=initial_retry_delay, max_retry_delay=max_retry_delay)
 
@@ -60,9 +63,10 @@ class CohereBedrockEmbeddingClient(
                     config: Optional[Dict[str, Any]] = None, model_pricing: Optional[ModelPricing] = None,
                     max_retries: int = 3, initial_retry_delay: float = 1.0, max_retry_delay: float = 60.0,
                     retry_policy: Optional[RetryPolicy] = None,
-                    middlewares: Optional[List[ClientMiddleware]] = None) -> "CohereBedrockEmbeddingClient":
+                    middlewares: Optional[List[ClientMiddleware]] = None,
+                    pricing_model: str | None = None) -> "CohereBedrockEmbeddingClient":
         settings = BedrockSettings()
-        return cls(model, config=config, model_pricing=model_pricing, max_retries=max_retries,
+        return cls(model, config=config, model_pricing=model_pricing, pricing_model=pricing_model, max_retries=max_retries,
                    initial_retry_delay=initial_retry_delay, max_retry_delay=max_retry_delay, retry_policy=retry_policy,
                    region=region or settings.region, profile=profile or settings.profile, middlewares=middlewares)
 
@@ -114,15 +118,15 @@ class CohereBedrockEmbeddingClient(
             return await client.invoke_model(modelId=self.model, body=json.dumps(request), contentType="application/json", accept="application/json")
 
     def _estimate_cost(self, tokens: int) -> float:
-        pricing = self.model_pricing or PricingRegistry.resolve_cohere_bedrock_embedding_pricing(self.model)
+        pricing = self.model_pricing or PricingRegistry.resolve_cohere_bedrock_embedding_pricing(self.pricing_model or self.model)
         return pricing.calculate_cost(tokens, 0)
 
     def _to_config(self) -> CohereBedrockEmbeddingClientConfig:
-        return CohereBedrockEmbeddingClientConfig(model=self.model, config=self.config.copy(), retry_policy=self.retry_policy)
+        return CohereBedrockEmbeddingClientConfig(model=self.model, pricing_model=self.pricing_model, config=self.config.copy(), retry_policy=self.retry_policy)
 
     @classmethod
     def _from_config(cls, config: CohereBedrockEmbeddingClientConfig) -> "CohereBedrockEmbeddingClient":
-        return cls.from_region(config.model, config=config.config or None, retry_policy=config.retry_policy)
+        return cls.from_region(config.model, pricing_model=config.pricing_model, config=config.config or None, retry_policy=config.retry_policy)
 
     def _handle_error(self, error: Exception) -> None:
         code = str(getattr(error, "response", {}).get("Error", {}).get("Code", ""))

{agentbyte-0.55.0 → agentbyte-0.56.0}/src/agentbyte/llm/openai/chat.py

@@ -39,6 +39,7 @@ logger = logging.getLogger(__name__)
 class OpenAIChatCompletionClientConfig(BaseChatCompletionClientConfig):
     """Configuration for OpenAIChatCompletionClient serialization."""
 
+    pricing_model: str | None = None
     retry_policy: RetryPolicy = RetryPolicy()
     key_env_var: str = "OPENAI_API_KEY"
 
@@ -65,9 +66,11 @@ class OpenAIChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ):
         super().__init__(model, client, config, middlewares=middlewares)
         self.model_pricing = model_pricing
+        self.pricing_model = pricing_model
         if retry_policy is not None:
             self.retry_policy = retry_policy
         else:
@@ -102,6 +105,7 @@ class OpenAIChatCompletionClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ) -> "OpenAIChatCompletionClient":
         """Create a client from an explicit or env-backed API key."""
         from pydantic import ValidationError
@@ -128,6 +132,7 @@ class OpenAIChatCompletionClient(
             client=openai_client,
             config=config,
             model_pricing=model_pricing,
+            pricing_model=pricing_model,
             max_retries=max_retries,
             initial_retry_delay=initial_retry_delay,
             max_retry_delay=max_retry_delay,
@@ -426,7 +431,7 @@ class OpenAIChatCompletionClient(
         if self.model_pricing is not None:
             pricing = self.model_pricing
         else:
-            pricing = PricingRegistry.resolve_openai_chat_pricing(self.model)
+            pricing = PricingRegistry.resolve_openai_chat_pricing(self.pricing_model or self.model)
         return pricing.calculate_cost(prompt_tokens, completion_tokens, cached_tokens)
 
     @staticmethod
@@ -439,6 +444,7 @@ class OpenAIChatCompletionClient(
         """Serialize to config without persisting secrets."""
         return OpenAIChatCompletionClientConfig(
             model=self.model,
+            pricing_model=self.pricing_model,
             config=self.config.copy(),
             retry_policy=self.retry_policy,
             key_env_var=getattr(self, "_key_env_var", "OPENAI_API_KEY"),
@@ -457,6 +463,7 @@ class OpenAIChatCompletionClient(
             )
         instance = cls.from_api_key(
             model=config.model,
+            pricing_model=config.pricing_model,
             api_key=api_key,
             config=config.config or None,
             retry_policy=config.retry_policy,

{agentbyte-0.55.0 → agentbyte-0.56.0}/src/agentbyte/llm/openai/embedding.py

@@ -24,6 +24,7 @@ logger = logging.getLogger(__name__)
 class OpenAIEmbeddingClientConfig(BaseEmbeddingClientConfig):
     """Configuration for OpenAIEmbeddingClient serialization."""
 
+    pricing_model: str | None = None
     retry_policy: RetryPolicy = RetryPolicy()
     key_env_var: str = "OPENAI_API_KEY"
 
@@ -50,9 +51,11 @@ class OpenAIEmbeddingClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ):
         super().__init__(model, client, config, middlewares=middlewares)
         self.model_pricing = model_pricing
+        self.pricing_model = pricing_model
         if retry_policy is not None:
             self.retry_policy = retry_policy
         else:
@@ -87,6 +90,7 @@ class OpenAIEmbeddingClient(
         max_retry_delay: float = 60.0,
         retry_policy: Optional[RetryPolicy] = None,
         middlewares: Optional[List[ClientMiddleware]] = None,
+        pricing_model: str | None = None,
     ) -> "OpenAIEmbeddingClient":
         """Create an OpenAIEmbeddingClient from explicit or env-backed API key."""
         from pydantic import ValidationError
@@ -113,6 +117,7 @@ class OpenAIEmbeddingClient(
             client=openai_client,
             config=config,
             model_pricing=model_pricing,
+            pricing_model=pricing_model,
             max_retries=max_retries,
             initial_retry_delay=initial_retry_delay,
             max_retry_delay=max_retry_delay,
@@ -230,13 +235,14 @@ class OpenAIEmbeddingClient(
         if self.model_pricing is not None:
             pricing = self.model_pricing
         else:
-            pricing = PricingRegistry.resolve_openai_embedding_pricing(self.model)
+            pricing = PricingRegistry.resolve_openai_embedding_pricing(self.pricing_model or self.model)
         return pricing.calculate_cost(prompt_tokens, completion_tokens)
 
     def _to_config(self) -> OpenAIEmbeddingClientConfig:
         """Serialize client to config without persisting secret values."""
         return OpenAIEmbeddingClientConfig(
             model=self.model,
+            pricing_model=self.pricing_model,
             config=self.config.copy(),
             retry_policy=self.retry_policy,
             key_env_var=getattr(self, "_key_env_var", "OPENAI_API_KEY"),
@@ -255,6 +261,7 @@ class OpenAIEmbeddingClient(
             )
         instance = cls.from_api_key(
             model=config.model,
+            pricing_model=config.pricing_model,
             api_key=api_key,
             config=config.config or None,
             retry_policy=config.retry_policy,

{agentbyte-0.55.0 → agentbyte-0.56.0}/src/agentbyte/llm/pricing.py

@@ -77,7 +77,31 @@ class PricingRegistry:
     """Central registry of model pricing with resolver functions for all providers."""
 
     # ===== OpenAI Standard Short-Context Chat Model Pricing (per 1M tokens) =====
+    # GPT-6 Standard short-context rates verified 2026-10-23:
+    # https://developers.openai.com/api/docs/pricing (30-minute cache writes).
     OPENAI_CHAT_PRICING: dict[str, ModelPricing] = {
+        "gpt-6.1-sol": ModelPricing(
+            input_per_1m=2,
+            output_per_1m=10,
+            cached_input_per_1m=0.1,
+            cache_write_per_1m=2.5,
+            context_tier="short",
+        ),
+        "gpt-6-astra": ModelPricing(
+            input_per_1m=10,
+            output_per_1m=50,
+            cached_input_per_1m=1,
+            cache_write_per_1m=12.5,
+            context_tier="short",
+        ),
+        "gpt-6-luna": ModelPricing(
+            input_per_1m=0.1,
+            output_per_1m=0.5,
+            cached_input_per_1m=0.01,
+            cache_write_per_1m=0.125,
+            context_tier="short",
+        ),
+
         "gpt-5.6": ModelPricing(
             input_per_1m=4.00,
             output_per_1m=20.00,
@@ -429,9 +453,9 @@ class PricingRegistry:
 
     # ===== Anthropic Claude Chat Pricing (per 1M tokens) =====
     # Verified against platform.claude.com/docs/en/about-claude/pricing (Oct 2026).
-    # On-demand Claude-on-Bedrock pricing matches direct-API list pricing, so the
-    # same table is used for both AnthropicChatCompletionClient and
-    # AnthropicBedrockChatCompletionClient.
+    # Shared default estimates for direct API and Bedrock; regional/transport
+    # premiums are not represented. Override model_pricing for negotiated rates.
+    # Anthropic cache-write rates below use the 5-minute TTL.
     #
     # Ordered most-specific prefix first for readability; `_resolve`'s prefix fallback
     # sorts candidate keys by length before matching, so the dict's literal insertion
@@ -447,15 +471,59 @@ class PricingRegistry:
     # has no representation in this registry (lookup is by model name only), so only
     # the common sub-100k-token rate is listed below.
     ANTHROPIC_CHAT_PRICING: dict[str, ModelPricing] = {
-        "claude-fable-5": ModelPricing(input_per_1m=10.0, output_per_1m=50.0),
-        "claude-opus-5-5": ModelPricing(input_per_1m=4.0, output_per_1m=20.0),
-        "claude-opus-5": ModelPricing(input_per_1m=5.0, output_per_1m=25.0),
+        "claude-mythos-5-1": ModelPricing(
+            input_per_1m=10,
+            output_per_1m=50,
+            cached_input_per_1m=0.25,
+            cache_write_per_1m=12.5,
+        ),
+        "claude-mythos-5": ModelPricing(
+            input_per_1m=10,
+            output_per_1m=50,
+            cached_input_per_1m=1,
+            cache_write_per_1m=12.5,
+        ),
+        "claude-fable-5-1": ModelPricing(
+            input_per_1m=10,
+            output_per_1m=50,
+            cached_input_per_1m=0.25,
+            cache_write_per_1m=12.5,
+        ),
+        "claude-sonnet-5-5": ModelPricing(
+            input_per_1m=2,
+            output_per_1m=10,
+            cached_input_per_1m=0.1,
+            cache_write_per_1m=2.5,
+        ),
+        "claude-fable-5": ModelPricing(
+            input_per_1m=10.0,
+            output_per_1m=50.0,
+            cached_input_per_1m=1.0,
+            cache_write_per_1m=12.5,
+        ),
+        "claude-opus-5-5": ModelPricing(
+            input_per_1m=4.0,
+            output_per_1m=20.0,
+            cached_input_per_1m=0.2,
+            cache_write_per_1m=5.0,
+        ),
+        "claude-opus-5": ModelPricing(
+            input_per_1m=5.0,
+            output_per_1m=25.0,
+            cached_input_per_1m=0.5,
+            cache_write_per_1m=6.25,
+        ),
         "claude-opus-4-8": ModelPricing(input_per_1m=5.0, output_per_1m=25.0),
         "claude-opus-4-7": ModelPricing(input_per_1m=5.0, output_per_1m=25.0),
         "claude-opus-4-6": ModelPricing(input_per_1m=5.0, output_per_1m=25.0),
         "claude-opus-4-5": ModelPricing(input_per_1m=5.0, output_per_1m=25.0),
         "claude-opus-4": ModelPricing(input_per_1m=15.0, output_per_1m=75.0),
-        "claude-sonnet-5": ModelPricing(input_per_1m=2.0, output_per_1m=10.0),
+        "claude-sonnet-5": ModelPricing(
+            input_per_1m=2.0,
+            output_per_1m=10.0,
+            cached_input_per_1m=0.2,
+            cache_write_per_1m=2.5,
+        ),
         # claude-sonnet-4-6/-4-5 currently price identically to claude-sonnet-4 ($3/$15,
         # verified against platform.claude.com/docs/en/about-claude/pricing), so the
         # prefix fallback already resolved them correctly -- listed explicitly anyway so a
@@ -467,6 +535,8 @@ class PricingRegistry:
         "claude-haiku-5-5": ModelPricing(
             input_per_1m=0.10,
             output_per_1m=0.50,
+            cached_input_per_1m=0.01,
+            cache_write_per_1m=0.125,
             context_tier="<=100K tokens per request",
         ),
         "claude-haiku-4-5": ModelPricing(input_per_1m=1.0, output_per_1m=5.0),

agentbyte-0.56.0/tests/llm/test_pricing_model.py

@@ -0,0 +1,197 @@
+"""Provider aliases select catalog pricing without changing transport model IDs."""
+
+from importlib import import_module
+from unittest.mock import Mock
+
+import pytest
+
+from agentbyte.llm import (
+    AnthropicBedrockChatCompletionClient,
+    AnthropicChatCompletionClient,
+    AzureOpenAIChatCompletionClient,
+    AzureOpenAIEmbeddingClient,
+    CohereBedrockEmbeddingClient,
+    OpenAIChatCompletionClient,
+    OpenAIEmbeddingClient,
+)
+from agentbyte.llm.pricing import PricingRegistry
+from agentbyte.llm.types import ModelPricing
+
+
+CLIENTS = [
+    (OpenAIChatCompletionClient, "gpt-6.1-sol", (1000, 200, 600)),
+    (AzureOpenAIChatCompletionClient, "gpt-5.6-sol", (1000, 200, 600)),
+    (AnthropicChatCompletionClient, "claude-sonnet-5-5", (1000, 200, 600)),
+    (AnthropicBedrockChatCompletionClient, "claude-sonnet-5-5", (1000, 200, 600)),
+    (OpenAIEmbeddingClient, "text-embedding-3-small", (1000,)),
+    (AzureOpenAIEmbeddingClient, "text-embedding-3-small", (1000,)),
+    (CohereBedrockEmbeddingClient, "cohere.embed-english-v3", (1000,)),
+]
+
+
+@pytest.mark.parametrize("client_type,canonical,tokens", CLIENTS)
+def test_pricing_precedence(client_type, canonical, tokens):
+    bare = client_type(model=canonical, client=Mock())
+    aliased = client_type(
+        model="account-specific-profile", pricing_model=canonical, client=Mock()
+    )
+    assert aliased._estimate_cost(*tokens) == bare._estimate_cost(*tokens)
+    assert aliased.model == "account-specific-profile"
+
+    manual = ModelPricing(input_per_1m=17, output_per_1m=23, cached_input_per_1m=3)
+    override = client_type(
+        model=canonical,
+        pricing_model="unknown-model",
+        model_pricing=manual,
+        client=Mock(),
+    )
+    assert override._estimate_cost(*tokens) == manual.calculate_cost(*tokens)
+
+
+@pytest.mark.parametrize(
+    "client_type,canonical,tokens",
+    [row for row in CLIENTS if "Azure" not in row[0].__name__],
+)
+def test_factory_and_config_round_trip(client_type, canonical, tokens, monkeypatch):
+    monkeypatch.setenv("OPENAI_API_KEY", "unit-test-placeholder")
+    monkeypatch.setenv("ANTHROPIC_API_KEY", "unit-test-placeholder")
+    module = import_module(client_type.__module__)
+    if client_type is AnthropicBedrockChatCompletionClient:
+        monkeypatch.setattr(module, "AsyncAnthropicBedrock", Mock())
+        factory = client_type.from_region
+    elif client_type is CohereBedrockEmbeddingClient:
+        factory = client_type.from_region
+    else:
+        sdk_name = (
+            "AsyncAnthropic"
+            if client_type is AnthropicChatCompletionClient
+            else "AsyncOpenAI"
+        )
+        monkeypatch.setattr(module, sdk_name, Mock())
+        factory = client_type.from_api_key
+
+    instance = factory(model="deployment-xyz", pricing_model=canonical)
+    assert instance.pricing_model == canonical
+    config = instance._to_config()
+    # Cross a JSON boundary, as saved components do.
+    restored = client_type._from_config(
+        type(config).model_validate_json(config.model_dump_json())
+    )
+    assert restored.model == "deployment-xyz"
+    assert restored.pricing_model == canonical
+    assert restored._estimate_cost(*tokens) == instance._estimate_cost(*tokens)
+    legacy = type(config).model_validate({"model": canonical})
+    assert legacy.pricing_model is None
+
+
+@pytest.mark.parametrize(
+    "model,rates",
+    [
+        ("gpt-6.1-sol", (2, 10, 0.1, 2.5)),
+        ("gpt-6-astra", (10, 50, 1, 12.5)),
+        ("gpt-6-luna", (0.1, 0.5, 0.01, 0.125)),
+        ("claude-sonnet-5-5", (2, 10, 0.1, 2.5)),
+        ("claude-opus-5-5", (4, 20, 0.2, 5)),
+        ("claude-fable-5-1", (10, 50, 0.25, 12.5)),
+        ("claude-sonnet-5", (2, 10, 0.2, 2.5)),
+        ("claude-opus-5", (5, 25, 0.5, 6.25)),
+        ("claude-fable-5", (10, 50, 1, 12.5)),
+        ("claude-mythos-5", (10, 50, 1, 12.5)),
+        ("claude-mythos-5-1", (10, 50, 0.25, 12.5)),
+        ("claude-haiku-5-5", (0.1, 0.5, 0.01, 0.125)),
+    ],
+)
+def test_catalog_rates_and_cached_cost(model, rates, caplog):
+    resolver = (
+        PricingRegistry.resolve_openai_chat_pricing
+        if model.startswith("gpt")
+        else PricingRegistry.resolve_anthropic_chat_pricing
+    )
+    pricing = resolver(model)
+    assert (
+        pricing.input_per_1m,
+        pricing.output_per_1m,
+        pricing.cached_input_per_1m,
+        pricing.cache_write_per_1m,
+    ) == rates
+    assert pricing.calculate_cost(1000, 200, 600) == pytest.approx(
+        (400 * rates[0] + 600 * rates[2] + 200 * rates[1]) / 1_000_000
+    )
+    assert not caplog.records
+
+
+@pytest.mark.parametrize("model", list(PricingRegistry.ANTHROPIC_CHAT_PRICING))
+def test_anthropic_exact_entries_win_over_nested_prefixes(model):
+    pricing = PricingRegistry.ANTHROPIC_CHAT_PRICING[model]
+    assert PricingRegistry.resolve_anthropic_chat_pricing(model) is pricing
+    assert (
+        PricingRegistry.resolve_anthropic_chat_pricing(model + "-20261023") is pricing
+    )
+
+
+def test_bedrock_legacy_normalization_and_explicit_alias():
+    legacy = AnthropicBedrockChatCompletionClient(
+        model="eu.anthropic.claude-sonnet-5-5-v1:0", client=Mock()
+    )
+    explicit = AnthropicBedrockChatCompletionClient(
+        model="opaque-profile", pricing_model="claude-sonnet-5-5", client=Mock()
+    )
+    assert legacy._estimate_cost(1000, 200, 600) == explicit._estimate_cost(
+        1000, 200, 600
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "client_type,canonical",
+    [
+        (OpenAIChatCompletionClient, "gpt-6.1-sol"),
+        (AnthropicChatCompletionClient, "claude-sonnet-5-5"),
+        (AnthropicBedrockChatCompletionClient, "claude-sonnet-5-5"),
+    ],
+)
+async def test_create_uses_alias_for_cost_but_profile_for_request(
+    client_type, canonical, caplog
+):
+    from types import SimpleNamespace
+    from unittest.mock import AsyncMock
+
+    from agentbyte.messages import UserMessage
+
+    if client_type is OpenAIChatCompletionClient:
+        response = SimpleNamespace(
+            model="account-profile",
+            choices=[
+                SimpleNamespace(
+                    message=SimpleNamespace(content="hello", tool_calls=None),
+                    finish_reason="stop",
+                )
+            ],
+            usage=SimpleNamespace(
+                prompt_tokens=1000,
+                completion_tokens=200,
+                prompt_tokens_details=SimpleNamespace(cached_tokens=600),
+            ),
+        )
+        create = AsyncMock(return_value=response)
+        sdk = SimpleNamespace(
+            chat=SimpleNamespace(completions=SimpleNamespace(create=create))
+        )
+    else:
+        response = SimpleNamespace(
+            model="account-profile",
+            content=[SimpleNamespace(type="text", text="hello")],
+            stop_reason="end_turn",
+            usage=SimpleNamespace(
+                input_tokens=1000, output_tokens=200, cache_read_input_tokens=600
+            ),
+        )
+        create = AsyncMock(return_value=response)
+        sdk = SimpleNamespace(messages=SimpleNamespace(create=create))
+    client = client_type(model="account-profile", pricing_model=canonical, client=sdk)
+    result = await client.create([UserMessage(content="hi", source="user")])
+    assert create.call_args.kwargs["model"] == "account-profile"
+    assert "pricing_model" not in create.call_args.kwargs
+    assert result.message.content == "hello"
+    assert result.usage.cost_estimate == pytest.approx(0.00286)
+    assert not [r for r in caplog.records if "pricing" in r.message.lower()]