llm-optimizer 0.2.0__tar.gz → 0.3.1__tar.gz

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: llm-optimizer
-Version: 0.2.0
+Version: 0.3.1
 Summary: Reduce LLM API costs by up to 90% — prompt caching, smart routing, batch processing, and more
 Author-email: Somnath Banerjee <banerjso30@gmail.com>
 License: MIT
-Project-URL: Homepage, https://github.com/banerjeeso/llm-optimizer
+Project-URL: Homepage, https://github.com/banerjeesollm-optimizer
 Project-URL: Documentation, https://github.com/banerjeeso/llm-optimizer#readme
 Project-URL: Issues, https://github.com/banerjeeso/llm-optimizer/issues
 Keywords: llm,anthropic,openai,cost,optimization,token,caching,batch
@@ -29,6 +29,9 @@ Provides-Extra: all
 Requires-Dist: openai>=1.0.0; extra == "all"
 Requires-Dist: google-generativeai>=0.5.0; extra == "all"
 Requires-Dist: tiktoken>=0.7.0; extra == "all"
+Requires-Dist: boto3>=1.34.0; extra == "all"
+Provides-Extra: bedrock
+Requires-Dist: boto3>=1.34.0; extra == "bedrock"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: build; extra == "dev"

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer/__init__.py

@@ -31,7 +31,7 @@ from .caching import CacheManager, build_cached_system_prompt
 from .batcher import BatchProcessor, BatchRequest, BatchResult
 from .tracker import CostTracker, UsageRecord, estimate_tokens
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 __author__ = "Your Team"
 
 __all__ = [
@@ -56,6 +56,9 @@ __all__ = [
     "BatchResult",
     # Tracking
     "CostTracker",
+    "BedrockClient",
+    "BedrockResponse",
+    "make_bedrock_client",
     "UsageRecord",
     "estimate_tokens",
 ]

llm_optimizer-0.3.1/llm_optimizer/bedrock.py

@@ -0,0 +1,324 @@
+"""
+AWS Bedrock support for llm-optimizer.
+
+Wraps boto3's bedrock-runtime client to match the same interface
+as anthropic.Anthropic(), so all optimizations apply identically.
+
+Supports two auth patterns:
+
+  Option 1 — AWS profile (most common for local dev):
+    from llm_optimizer import OptimizedClient, Provider
+    from llm_optimizer.bedrock import BedrockClient
+
+    client = OptimizedClient(
+        bedrock_client=BedrockClient(profile_name="ai-core", region="us-east-1"),
+        preferred_provider=Provider.BEDROCK,
+    )
+
+  Option 2 — Env vars (CI/CD pipelines, Lambda, EC2 with IAM role):
+    # Set: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION
+    # or attach an IAM role — boto3 picks it up automatically
+
+    client = OptimizedClient(
+        bedrock_client=BedrockClient(),   # zero config — reads env/role
+        preferred_provider=Provider.BEDROCK,
+    )
+
+Key differences from direct Anthropic API:
+  - Auth via AWS IAM, not API keys
+  - Prompt caching (cache_control) NOT supported — stripped automatically
+  - Model IDs use Bedrock format: anthropic.claude-haiku-4-5-20251001-v1:0
+  - Batch via Bedrock Batch Inference (not Anthropic Batch API)
+
+Install:
+  pip install llm-optimizer[bedrock]
+"""
+
+import json
+import warnings
+from dataclasses import dataclass
+from typing import Any, Generator, Optional
+
+
+@dataclass
+class BedrockResponse:
+    """
+    Normalizes Bedrock response to match Anthropic SDK response shape.
+    Ensures tracker, streaming, and all other components work identically.
+    """
+    content: list
+    usage: "BedrockUsage"
+    model: str
+    stop_reason: str
+
+    def __str__(self):
+        return self.content[0].text if self.content else ""
+
+
+@dataclass
+class BedrockUsage:
+    input_tokens: int
+    output_tokens: int
+    cache_read_input_tokens: int = 0  # Always 0 — Bedrock does not support caching
+
+
+@dataclass
+class BedrockContentBlock:
+    text: str
+    type: str = "text"
+
+
+class BedrockClient:
+    """
+    Drop-in Bedrock client for OptimizedClient.
+
+    Auth priority (boto3 standard credential chain):
+      1. profile_name argument  → ~/.aws/credentials [profile]
+      2. session argument       → pre-built boto3.Session
+      3. Environment variables  → AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY
+      4. IAM role               → auto-detected on EC2 / Lambda / ECS
+
+    Args:
+        region:        AWS region (default: us-east-1)
+        profile_name:  AWS profile from ~/.aws/config (e.g. "ai-core")
+        session:       Pre-configured boto3.Session — overrides profile_name
+        discount_pct:  Your negotiated AWS discount (e.g. 16.0).
+                       Applied to cost estimates only — does not affect API calls.
+    """
+
+    def __init__(
+        self,
+        region: str = "us-east-1",
+        profile_name: Optional[str] = None,
+        session=None,
+        discount_pct: float = 0.0,
+    ):
+        self.region = region
+        self.discount_pct = discount_pct
+        self._profile = profile_name
+        self._session = session
+        self._runtime = None
+        self._boto3 = None
+
+    # ── Credential chain ───────────────────────────────────────────────────────
+
+    def _get_runtime(self):
+        """Lazy-initialize boto3 bedrock-runtime client."""
+        if self._runtime:
+            return self._runtime
+
+        try:
+            import boto3
+            self._boto3 = boto3
+        except ImportError:
+            raise ImportError(
+                "boto3 is required for AWS Bedrock support.\n"
+                "Install with: pip install llm-optimizer[bedrock]"
+            )
+
+        # Credential chain: explicit session > profile > env/role
+        if self._session:
+            resolved_session = self._session
+        elif self._profile:
+            resolved_session = boto3.Session(profile_name=self._profile, region_name=self.region)
+        else:
+            # Falls through to env vars, then IAM role
+            resolved_session = boto3.Session(region_name=self.region)
+
+        self._runtime = resolved_session.client(
+            service_name="bedrock-runtime",
+            region_name=self.region,
+        )
+        return self._runtime
+
+    # ── messages interface (matches anthropic.Anthropic().messages) ────────────
+
+    class _Messages:
+        def __init__(self, bedrock_client: "BedrockClient"):
+            self._client = bedrock_client
+
+        def create(self, model, max_tokens, messages, system=None, **kwargs) -> BedrockResponse:
+            return self._client._invoke(model, max_tokens, messages, system, **kwargs)
+
+        def stream(self, model, max_tokens, messages, system=None, **kwargs):
+            return _BedrockStreamContext(self._client, model, max_tokens, messages, system, **kwargs)
+
+    @property
+    def messages(self):
+        return self._Messages(self)
+
+    # ── Effective cost (with discount) ────────────────────────────────────────
+
+    def effective_cost_multiplier(self) -> float:
+        """Returns 1.0 - (discount_pct / 100). Applied to pricing estimates."""
+        return 1.0 - (self.discount_pct / 100.0)
+
+    # ── Internal ──────────────────────────────────────────────────────────────
+
+    def _build_body(
+        self,
+        model: str,
+        max_tokens: int,
+        messages: list[dict],
+        system: Optional[Any],
+        temperature: float = 0.0,
+        **kwargs,
+    ) -> dict:
+        """
+        Build Bedrock request body.
+        Strips cache_control automatically — Bedrock rejects it.
+        """
+        clean_messages = self._strip_cache_control(messages)
+
+        # Resolve system prompt from str or Anthropic blocks list
+        system_text = ""
+        if system:
+            if isinstance(system, str):
+                system_text = system
+            elif isinstance(system, list):
+                system_text = " ".join(
+                    b.get("text", "") for b in system
+                    if isinstance(b, dict) and b.get("type") == "text"
+                )
+
+        body: dict[str, Any] = {
+            "anthropic_version": "bedrock-2023-05-31",
+            "max_tokens": max_tokens,
+            "messages": clean_messages,
+        }
+        if system_text:
+            body["system"] = system_text
+        if temperature > 0:
+            body["temperature"] = temperature
+
+        return body
+
+    def _invoke(self, model, max_tokens, messages, system=None, **kwargs) -> BedrockResponse:
+        runtime = self._get_runtime()
+        body = self._build_body(model, max_tokens, messages, system, **kwargs)
+
+        response = runtime.invoke_model(
+            modelId=model,
+            body=json.dumps(body),
+            contentType="application/json",
+            accept="application/json",
+        )
+
+        result = json.loads(response["body"].read())
+
+        content_blocks = [
+            BedrockContentBlock(text=block["text"])
+            for block in result.get("content", [])
+            if block.get("type") == "text"
+        ]
+
+        usage_data = result.get("usage", {})
+        return BedrockResponse(
+            content=content_blocks,
+            usage=BedrockUsage(
+                input_tokens=usage_data.get("input_tokens", 0),
+                output_tokens=usage_data.get("output_tokens", 0),
+            ),
+            model=model,
+            stop_reason=result.get("stop_reason", "end_turn"),
+        )
+
+    @staticmethod
+    def _strip_cache_control(messages: list[dict]) -> list[dict]:
+        """
+        Strip cache_control from all message content blocks.
+
+        Why: Bedrock's Claude API does not support prompt caching.
+        Sending cache_control causes a validation error.
+        The library strips it silently so callers don't need to branch
+        their code between Anthropic and Bedrock.
+        """
+        clean = []
+        for msg in messages:
+            content = msg.get("content", "")
+            if isinstance(content, list):
+                clean_blocks = [
+                    {k: v for k, v in block.items() if k != "cache_control"}
+                    if isinstance(block, dict) else block
+                    for block in content
+                ]
+                clean.append({**msg, "content": clean_blocks})
+            else:
+                clean.append(msg)
+        return clean
+
+
+class _BedrockStreamContext:
+    """Context manager for Bedrock streaming. Matches Anthropic stream interface."""
+
+    def __init__(self, bedrock_client, model, max_tokens, messages, system, **kwargs):
+        self._client = bedrock_client
+        self._model = model
+        self._max_tokens = max_tokens
+        self._messages = messages
+        self._system = system
+        self._kwargs = kwargs
+        self.usage = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    def __iter__(self) -> Generator[str, None, None]:
+        runtime = self._client._get_runtime()
+        body = self._client._build_body(
+            self._model, self._max_tokens, self._messages, self._system, **self._kwargs
+        )
+
+        response = runtime.invoke_model_with_response_stream(
+            modelId=self._model,
+            body=json.dumps(body),
+            contentType="application/json",
+            accept="application/json",
+        )
+
+        input_tokens = output_tokens = 0
+
+        for event in response.get("body", []):
+            chunk = event.get("chunk", {})
+            if not chunk:
+                continue
+            data = json.loads(chunk.get("bytes", b"{}"))
+            etype = data.get("type", "")
+
+            if etype == "content_block_delta":
+                delta = data.get("delta", {})
+                if delta.get("type") == "text_delta":
+                    yield delta.get("text", "")
+            elif etype == "message_start":
+                input_tokens = data.get("message", {}).get("usage", {}).get("input_tokens", 0)
+            elif etype == "message_delta":
+                output_tokens = data.get("usage", {}).get("output_tokens", 0)
+
+        self.usage = BedrockUsage(input_tokens=input_tokens, output_tokens=output_tokens)
+
+
+# ── Convenience factory ────────────────────────────────────────────────────────
+
+def make_bedrock_client(
+    profile_name: Optional[str] = None,
+    region: str = "us-east-1",
+    discount_pct: float = 0.0,
+) -> BedrockClient:
+    """
+    Convenience factory matching the proposed OptimizedClient shorthand.
+
+    Usage:
+        # Profile-based (most Saks devs)
+        bedrock = make_bedrock_client(profile_name="ai-core", discount_pct=16.0)
+
+        # Env-var / IAM role (CI/CD, Lambda)
+        bedrock = make_bedrock_client()
+    """
+    return BedrockClient(
+        region=region,
+        profile_name=profile_name,
+        discount_pct=discount_pct,
+    )

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer/client.py

@@ -25,7 +25,7 @@ from .router import ModelRouter
 from .optimizer import PromptOptimizer, DocumentCompressor
 from .batcher import BatchProcessor
 from .tracker import CostTracker, estimate_tokens
-from .streaming import StreamResult, build_anthropic_stream, build_openai_stream
+from .streaming import StreamResult, build_anthropic_stream, build_openai_stream, build_bedrock_stream
 
 
 class OptimizedClient:
@@ -55,6 +55,7 @@ class OptimizedClient:
     def __init__(
         self,
         anthropic_client=None,
+        bedrock_client=None,
         openai_client=None,
         google_client=None,
         # Feature flags
@@ -83,6 +84,7 @@ class OptimizedClient:
         batch_default_model: Optional[str] = None,
     ):
         self._anthropic = anthropic_client
+        self._bedrock = bedrock_client
         self._openai = openai_client
         self._google = google_client
         self._default_model = default_model
@@ -255,10 +257,18 @@ class OptimizedClient:
                 self._openai, model_config.model_id, messages,
                 system_blocks, max_tokens, temperature, **kwargs
             )
+        elif provider == Provider.BEDROCK:
+            if not self._bedrock:
+                raise RuntimeError("No Bedrock client. Pass bedrock_client=BedrockClient() to OptimizedClient.")
+            from .streaming import build_bedrock_stream
+            result = build_bedrock_stream(
+                self._bedrock, model_config.model_id, messages,
+                system_blocks, max_tokens, temperature, **kwargs
+            )
         else:
             raise NotImplementedError(
                 f"Streaming is not yet supported for provider: {provider.value}. "
-                "Supported: anthropic, openai."
+                "Supported: anthropic, openai, bedrock."
             )
 
         return result
@@ -453,6 +463,8 @@ class OptimizedClient:
             return self._call_openai(model_config, messages, system, max_tokens, temperature, **kwargs)
         elif provider == Provider.GOOGLE:
             return self._call_google(model_config, messages, system, max_tokens, temperature, **kwargs)
+        elif provider == Provider.BEDROCK:
+            return self._call_bedrock(model_config, messages, system, max_tokens, temperature, **kwargs)
         else:
             raise ValueError(f"Unsupported provider: {provider}")
 
@@ -499,6 +511,22 @@ class OptimizedClient:
         )
         return self._google.generate_content(prompt)
 
+
+    def _call_bedrock(self, model_config, messages, system, max_tokens, temperature, **kwargs):
+        if not self._bedrock:
+            raise RuntimeError(
+                "No Bedrock client. Pass bedrock_client=BedrockClient() to OptimizedClient.\n"
+                "from llm_optimizer.bedrock import BedrockClient\n"
+                "bedrock = BedrockClient(region='us-east-1', profile_name='ai-core')"
+            )
+        return self._bedrock.messages.create(
+            model=model_config.model_id,
+            max_tokens=max_tokens,
+            messages=messages,
+            system=system,
+            **kwargs,
+        )
+
     @staticmethod
     def _extract_usage(response) -> tuple[int, int, int]:
         if hasattr(response, "usage"):

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer/models.py

@@ -30,6 +30,7 @@ class Provider(Enum):
     ANTHROPIC = "anthropic"
     OPENAI = "openai"
     GOOGLE = "google"
+    BEDROCK = "bedrock"
 
 
 @dataclass
@@ -144,3 +145,23 @@ TIER_DEFAULTS: dict[TaskComplexity, dict[Provider, str]] = {
         Provider.GOOGLE: "gemini-pro",
     },
 }
+
+# Bedrock tier defaults (appended for v0.3.0)
+TIER_DEFAULTS.update({
+    TaskComplexity.SIMPLE: {
+        **TIER_DEFAULTS.get(TaskComplexity.SIMPLE, {}),
+        Provider.BEDROCK: "bedrock-claude-haiku-4-5",
+    },
+    TaskComplexity.MEDIUM: {
+        **TIER_DEFAULTS.get(TaskComplexity.MEDIUM, {}),
+        Provider.BEDROCK: "bedrock-claude-haiku-4-5",
+    },
+    TaskComplexity.COMPLEX: {
+        **TIER_DEFAULTS.get(TaskComplexity.COMPLEX, {}),
+        Provider.BEDROCK: "bedrock-claude-sonnet-4-5",
+    },
+    TaskComplexity.EXPERT: {
+        **TIER_DEFAULTS.get(TaskComplexity.EXPERT, {}),
+        Provider.BEDROCK: "bedrock-claude-haiku-4-5",
+    },
+})

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer/pricing.json

@@ -1,13 +1,15 @@
 {
   "_meta": {
-    "version": "2026-04-03",
-    "last_updated": "2026-04-03",
+    "version": "2026-07-14",
+    "last_updated": "2026-07-14",
     "warning": "Provider pricing changes without notice. Verify at provider pricing pages before relying on cost estimates.",
     "sources": {
       "anthropic": "https://www.anthropic.com/pricing",
       "openai": "https://openai.com/pricing",
-      "google": "https://ai.google.dev/pricing"
-    }
+      "google": "https://ai.google.dev/pricing",
+      "bedrock": "https://aws.amazon.com/bedrock/pricing/"
+    },
+    "bedrock_note": "Bedrock prices = AWS list price. If your account has a negotiated discount (e.g. 16%), set discount_pct in BedrockClient to apply it to cost estimates."
   },
   "models": {
     "claude-haiku-4-5": {
@@ -20,7 +22,10 @@
       "context_window": 200000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium"],
+      "complexity_tiers": [
+        "simple",
+        "medium"
+      ],
       "max_output_tokens": 8192
     },
     "claude-haiku-3-5": {
@@ -33,7 +38,10 @@
       "context_window": 200000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium"],
+      "complexity_tiers": [
+        "simple",
+        "medium"
+      ],
       "max_output_tokens": 8192
     },
     "claude-sonnet-4": {
@@ -46,7 +54,11 @@
       "context_window": 200000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium", "complex"],
+      "complexity_tiers": [
+        "simple",
+        "medium",
+        "complex"
+      ],
       "max_output_tokens": 8192
     },
     "claude-opus-4": {
@@ -59,7 +71,12 @@
       "context_window": 200000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium", "complex", "expert"],
+      "complexity_tiers": [
+        "simple",
+        "medium",
+        "complex",
+        "expert"
+      ],
       "max_output_tokens": 8192
     },
     "gpt-5-mini": {
@@ -72,7 +89,10 @@
       "context_window": 400000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium"],
+      "complexity_tiers": [
+        "simple",
+        "medium"
+      ],
       "max_output_tokens": 16384
     },
     "gpt-5": {
@@ -85,7 +105,12 @@
       "context_window": 1000000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium", "complex", "expert"],
+      "complexity_tiers": [
+        "simple",
+        "medium",
+        "complex",
+        "expert"
+      ],
       "max_output_tokens": 32768
     },
     "gemini-flash": {
@@ -98,7 +123,10 @@
       "context_window": 1000000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium"],
+      "complexity_tiers": [
+        "simple",
+        "medium"
+      ],
       "max_output_tokens": 8192
     },
     "gemini-pro": {
@@ -111,8 +139,48 @@
       "context_window": 2000000,
       "supports_caching": true,
       "supports_batch": true,
-      "complexity_tiers": ["simple", "medium", "complex", "expert"],
+      "complexity_tiers": [
+        "simple",
+        "medium",
+        "complex",
+        "expert"
+      ],
       "max_output_tokens": 8192
+    },
+    "bedrock-claude-haiku-4-5": {
+      "model_id": "anthropic.claude-haiku-4-5-20251001-v1:0",
+      "provider": "bedrock",
+      "display_name": "Claude Haiku 4.5 (Bedrock)",
+      "input_cost_per_1m": 0.8,
+      "output_cost_per_1m": 4.0,
+      "cached_input_cost_per_1m": 0.08,
+      "context_window": 200000,
+      "supports_caching": false,
+      "supports_batch": true,
+      "complexity_tiers": [
+        "simple",
+        "medium"
+      ],
+      "max_output_tokens": 8192,
+      "notes": "AWS Bedrock list price. Prompt caching not supported on Bedrock. Your account discount applies on top."
+    },
+    "bedrock-claude-sonnet-4-5": {
+      "model_id": "anthropic.claude-sonnet-4-5-20250929-v1:0",
+      "provider": "bedrock",
+      "display_name": "Claude Sonnet 4.5 (Bedrock)",
+      "input_cost_per_1m": 3.0,
+      "output_cost_per_1m": 15.0,
+      "cached_input_cost_per_1m": 0.3,
+      "context_window": 200000,
+      "supports_caching": false,
+      "supports_batch": true,
+      "complexity_tiers": [
+        "simple",
+        "medium",
+        "complex"
+      ],
+      "max_output_tokens": 8192,
+      "notes": "AWS Bedrock list price. Prompt caching not supported on Bedrock. Your account discount applies on top."
     }
   }
-}
+}

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer/streaming.py

@@ -36,6 +36,8 @@ class StreamResult:
             yield from self._iter_anthropic()
         elif self._provider == "openai":
             yield from self._iter_openai()
+        elif self._provider == "bedrock":
+            yield from self._iter_bedrock()
         else:
             raise NotImplementedError(f"Streaming not implemented for provider: {self._provider}")
 
@@ -75,6 +77,17 @@ class StreamResult:
             return None
         return self._usage
 
+    def _iter_bedrock(self):
+        for chunk in self._raw:
+            yield chunk
+        if hasattr(self._raw, 'usage') and self._raw.usage:
+            self._usage = {
+                "input_tokens": self._raw.usage.input_tokens,
+                "output_tokens": self._raw.usage.output_tokens,
+                "cache_read_input_tokens": 0,
+            }
+        self._finished = True
+
     def __enter__(self):
         return self
 
@@ -118,3 +131,16 @@ def build_openai_stream(client, model_id: str, messages: list, system: Optional[
         **kwargs,
     )
     return StreamResult(raw, provider="openai")
+
+
+def build_bedrock_stream(bedrock_client, model_id: str, messages: list,
+                          system, max_tokens: int, temperature: float, **kwargs) -> "StreamResult":
+    """Create a Bedrock streaming request."""
+    raw = bedrock_client.messages.stream(
+        model=model_id,
+        max_tokens=max_tokens,
+        messages=messages,
+        system=system,
+        **kwargs,
+    )
+    return StreamResult(raw, provider="bedrock")

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: llm-optimizer
-Version: 0.2.0
+Version: 0.3.1
 Summary: Reduce LLM API costs by up to 90% — prompt caching, smart routing, batch processing, and more
 Author-email: Somnath Banerjee <banerjso30@gmail.com>
 License: MIT
-Project-URL: Homepage, https://github.com/banerjeeso/llm-optimizer
+Project-URL: Homepage, https://github.com/banerjeesollm-optimizer
 Project-URL: Documentation, https://github.com/banerjeeso/llm-optimizer#readme
 Project-URL: Issues, https://github.com/banerjeeso/llm-optimizer/issues
 Keywords: llm,anthropic,openai,cost,optimization,token,caching,batch
@@ -29,6 +29,9 @@ Provides-Extra: all
 Requires-Dist: openai>=1.0.0; extra == "all"
 Requires-Dist: google-generativeai>=0.5.0; extra == "all"
 Requires-Dist: tiktoken>=0.7.0; extra == "all"
+Requires-Dist: boto3>=1.34.0; extra == "all"
+Provides-Extra: bedrock
+Requires-Dist: boto3>=1.34.0; extra == "bedrock"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: build; extra == "dev"

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer.egg-info/SOURCES.txt

@@ -2,14 +2,13 @@ README.md
 pyproject.toml
 llm_optimizer/__init__.py
 llm_optimizer/batcher.py
+llm_optimizer/bedrock.py
 llm_optimizer/caching.py
-llm_optimizer/cli.py
 llm_optimizer/client.py
 llm_optimizer/models.py
 llm_optimizer/optimizer.py
 llm_optimizer/pricing.json
 llm_optimizer/router.py
-llm_optimizer/setup.py
 llm_optimizer/streaming.py
 llm_optimizer/tracker.py
 llm_optimizer.egg-info/PKG-INFO

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/llm_optimizer.egg-info/requires.txt

@@ -4,6 +4,10 @@ anthropic>=0.40.0
 openai>=1.0.0
 google-generativeai>=0.5.0
 tiktoken>=0.7.0
+boto3>=1.34.0
+
+[bedrock]
+boto3>=1.34.0
 
 [dev]
 pytest>=8.0

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "llm-optimizer"
-version = "0.2.0"
+version = "0.3.1"
 description = "Reduce LLM API costs by up to 90% — prompt caching, smart routing, batch processing, and more"
 readme = "README.md"
 license = { text = "MIT" }
@@ -29,11 +29,12 @@ dependencies = [
 openai   = ["openai>=1.0.0"]
 google   = ["google-generativeai>=0.5.0"]
 tiktoken = ["tiktoken>=0.7.0"]
-all      = ["openai>=1.0.0", "google-generativeai>=0.5.0", "tiktoken>=0.7.0"]
+all      = ["openai>=1.0.0", "google-generativeai>=0.5.0", "tiktoken>=0.7.0", "boto3>=1.34.0"]
+bedrock  = ["boto3>=1.34.0"]
 dev      = ["pytest>=8.0", "build", "twine"]
 
 [project.urls]
-Homepage      = "https://github.com/banerjeeso/llm-optimizer"
+Homepage      = "https://github.com/banerjeesollm-optimizer"
 Documentation = "https://github.com/banerjeeso/llm-optimizer#readme"
 Issues        = "https://github.com/banerjeeso/llm-optimizer/issues"
 

{llm_optimizer-0.2.0 → llm_optimizer-0.3.1}/tests/test_llm_optimizer.py

@@ -548,3 +548,168 @@ class TestStreaming:
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v", "-m", "not integration"])
+
+
+
+# ─── Bedrock Client (unit, mocked) ────────────────────────────────────────────
+
+class TestBedrockClient:
+    """
+    Tests BedrockClient with mocked boto3. No real AWS calls made.
+
+    Covers:
+      - Both auth patterns (profile_name and env/role)
+      - cache_control stripping
+      - Response shape normalization
+      - Discount multiplier
+      - OptimizedClient integration with Bedrock
+      - Correct model IDs for company Bedrock setup
+    """
+
+    def _mock_runtime(self, response_text="Test response"):
+        import json
+        from unittest.mock import MagicMock
+        mock = MagicMock()
+        body = {
+            "content": [{"type": "text", "text": response_text}],
+            "usage": {"input_tokens": 100, "output_tokens": 50},
+            "stop_reason": "end_turn",
+        }
+        mock.invoke_model.return_value = {
+            "body": MagicMock(read=lambda: json.dumps(body).encode())
+        }
+        return mock
+
+    def test_instantiates_with_profile(self):
+        from llm_optimizer.bedrock import BedrockClient
+        c = BedrockClient(region="us-east-1", profile_name="ai-core")
+        assert c.region == "us-east-1"
+        assert c._profile == "ai-core"
+
+    def test_instantiates_without_profile(self):
+        """Env vars / IAM role path — zero config."""
+        from llm_optimizer.bedrock import BedrockClient
+        c = BedrockClient()
+        assert c._profile is None
+        assert c.region == "us-east-1"
+
+    def test_discount_multiplier(self):
+        from llm_optimizer.bedrock import BedrockClient
+        c = BedrockClient(discount_pct=16.0)
+        assert abs(c.effective_cost_multiplier() - 0.84) < 0.001
+
+    def test_no_discount_multiplier_is_one(self):
+        from llm_optimizer.bedrock import BedrockClient
+        c = BedrockClient(discount_pct=0.0)
+        assert c.effective_cost_multiplier() == 1.0
+
+    def test_strip_cache_control_removes_key(self):
+        from llm_optimizer.bedrock import BedrockClient
+        msgs = [{"role": "user", "content": [
+            {"type": "text", "text": "Hello", "cache_control": {"type": "ephemeral"}}
+        ]}]
+        cleaned = BedrockClient._strip_cache_control(msgs)
+        assert "cache_control" not in cleaned[0]["content"][0]
+        assert cleaned[0]["content"][0]["text"] == "Hello"
+
+    def test_strip_cache_control_plain_string_unchanged(self):
+        from llm_optimizer.bedrock import BedrockClient
+        msgs = [{"role": "user", "content": "Hello"}]
+        cleaned = BedrockClient._strip_cache_control(msgs)
+        assert cleaned[0]["content"] == "Hello"
+
+    def test_strip_cache_control_preserves_other_keys(self):
+        from llm_optimizer.bedrock import BedrockClient
+        msgs = [{"role": "user", "content": [
+            {"type": "text", "text": "Hi", "cache_control": {"type": "ephemeral"}, "extra": "keep"}
+        ]}]
+        cleaned = BedrockClient._strip_cache_control(msgs)
+        assert cleaned[0]["content"][0]["extra"] == "keep"
+        assert "cache_control" not in cleaned[0]["content"][0]
+
+    def test_response_shape_normalized(self):
+        from llm_optimizer.bedrock import BedrockClient, BedrockResponse
+        c = BedrockClient(region="us-east-1")
+        c._runtime = self._mock_runtime("Hello from Bedrock")
+        resp = c.messages.create(
+            model="anthropic.claude-haiku-4-5-20251001-v1:0",
+            max_tokens=100,
+            messages=[{"role": "user", "content": "Hi"}],
+        )
+        assert isinstance(resp, BedrockResponse)
+        assert resp.content[0].text == "Hello from Bedrock"
+        assert resp.usage.input_tokens == 100
+        assert resp.usage.output_tokens == 50
+        assert resp.usage.cache_read_input_tokens == 0
+
+    def test_correct_haiku_model_id(self):
+        """Company uses this exact Bedrock model ID for Haiku."""
+        assert MODELS["bedrock-claude-haiku-4-5"].model_id == "anthropic.claude-haiku-4-5-20251001-v1:0"
+
+    def test_correct_sonnet_model_id(self):
+        """Company uses this exact Bedrock model ID for Sonnet."""
+        assert MODELS["bedrock-claude-sonnet-4-5"].model_id == "anthropic.claude-sonnet-4-5-20250929-v1:0"
+
+    def test_bedrock_haiku_pricing(self):
+        """Bedrock Haiku 4.5 AWS list price."""
+        m = MODELS["bedrock-claude-haiku-4-5"]
+        assert m.input_cost_per_1m == 0.80
+        assert m.output_cost_per_1m == 4.00
+
+    def test_bedrock_sonnet_pricing(self):
+        """Bedrock Sonnet 4.5 AWS list price."""
+        m = MODELS["bedrock-claude-sonnet-4-5"]
+        assert m.input_cost_per_1m == 3.00
+        assert m.output_cost_per_1m == 15.00
+
+    def test_bedrock_caching_not_supported(self):
+        """Bedrock models must have supports_caching=False."""
+        assert MODELS["bedrock-claude-haiku-4-5"].supports_caching is False
+        assert MODELS["bedrock-claude-sonnet-4-5"].supports_caching is False
+
+    def test_optimized_client_with_bedrock_profile(self):
+        """Full integration: OptimizedClient + BedrockClient with profile."""
+        from llm_optimizer.bedrock import BedrockClient
+        import json
+        from unittest.mock import MagicMock
+
+        bedrock = BedrockClient(region="us-east-1", profile_name="ai-core")
+        bedrock._runtime = self._mock_runtime("Classified as SPAM")
+
+        client = OptimizedClient(
+            bedrock_client=bedrock,
+            preferred_provider=Provider.BEDROCK,
+        )
+        resp = client.complete(
+            messages=[{"role": "user", "content": "Is this spam?"}],
+            system="You are a classifier.",
+            model="bedrock-claude-haiku-4-5",
+        )
+        assert resp.content[0].text == "Classified as SPAM"
+        bedrock._runtime.invoke_model.assert_called_once()
+
+    def test_optimized_client_no_bedrock_raises(self):
+        """Clear error when Bedrock client not provided."""
+        client = OptimizedClient(preferred_provider=Provider.BEDROCK)
+        with pytest.raises(RuntimeError, match="No Bedrock client"):
+            client.complete(
+                messages=[{"role": "user", "content": "Hello"}],
+                model="bedrock-claude-haiku-4-5",
+            )
+
+    def test_make_bedrock_client_factory(self):
+        from llm_optimizer.bedrock import make_bedrock_client
+        c = make_bedrock_client(profile_name="ai-core", discount_pct=16.0)
+        assert c._profile == "ai-core"
+        assert c.discount_pct == 16.0
+
+    def test_make_bedrock_client_no_args(self):
+        """Zero-config factory for env/role auth."""
+        from llm_optimizer.bedrock import make_bedrock_client
+        c = make_bedrock_client()
+        assert c._profile is None
+
+    def test_bedrock_provider_in_tier_defaults(self):
+        from llm_optimizer.models import TIER_DEFAULTS
+        assert Provider.BEDROCK in TIER_DEFAULTS[TaskComplexity.SIMPLE]
+        assert Provider.BEDROCK in TIER_DEFAULTS[TaskComplexity.COMPLEX]

llm_optimizer-0.2.0/llm_optimizer/cli.py

@@ -1,79 +0,0 @@
-"""
-CLI for llm-optimizer.
-
-Commands:
-  llm-optimizer pricing-info     Show current pricing data version and staleness
-  llm-optimizer update-pricing   Instructions to update pricing.json
-  llm-optimizer check            Verify install and show config
-"""
-
-import sys
-import json
-from pathlib import Path
-
-
-def main():
-    args = sys.argv[1:]
-    cmd = args[0] if args else "check"
-
-    if cmd == "pricing-info":
-        _pricing_info()
-    elif cmd == "update-pricing":
-        _update_pricing_instructions()
-    elif cmd == "check":
-        _check()
-    else:
-        print(f"Unknown command: {cmd}")
-        print("Usage: llm-optimizer [pricing-info | update-pricing | check]")
-        sys.exit(1)
-
-
-def _pricing_info():
-    pricing_path = Path(__file__).parent / "pricing.json"
-    with open(pricing_path) as f:
-        data = json.load(f)
-    meta = data.get("_meta", {})
-    print(f"\nllm-optimizer pricing data")
-    print(f"  Version      : {meta.get('version', 'unknown')}")
-    print(f"  Last updated : {meta.get('last_updated', 'unknown')}")
-    print(f"  Models       : {len(data.get('models', {}))}")
-    print(f"\nSources to verify prices:")
-    for provider, url in meta.get("sources", {}).items():
-        print(f"  {provider:12}: {url}")
-    print(f"\nWarning: {meta.get('warning', '')}\n")
-
-
-def _update_pricing_instructions():
-    pricing_path = Path(__file__).parent / "pricing.json"
-    print(f"""
-To update pricing data:
-
-1. Open {pricing_path}
-2. Verify prices against provider pages:
-   - Anthropic : https://www.anthropic.com/pricing
-   - OpenAI    : https://openai.com/pricing
-   - Google    : https://ai.google.dev/pricing
-3. Update the relevant model prices
-4. Bump "_meta.last_updated" to today's date (YYYY-MM-DD)
-5. Bump "_meta.version" to match
-
-The library will stop warning about staleness once last_updated is within 30 days.
-""")
-
-
-def _check():
-    try:
-        from llm_optimizer import __version__
-        from llm_optimizer.models import pricing_info, MODELS
-        info = pricing_info()
-        print(f"\nllm-optimizer v{__version__} installed ✓")
-        print(f"  Models loaded  : {len(MODELS)}")
-        print(f"  Pricing version: {info['last_updated']}")
-        print(f"\nRun 'llm-optimizer pricing-info' for full pricing details.\n")
-    except Exception as e:
-        print(f"Install check failed: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

llm_optimizer-0.2.0/llm_optimizer/setup.py

@@ -1,36 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="llm-optimizer",
-    version="0.1.0",
-    author="Your Team",
-    description="Reduce LLM API costs by up to 90% with automatic optimizations",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    packages=find_packages(),
-    python_requires=">=3.10",
-    install_requires=[
-        "anthropic>=0.40.0",
-    ],
-    extras_require={
-        "openai": ["openai>=1.0.0"],
-        "google": ["google-generativeai>=0.5.0"],
-        "tiktoken": ["tiktoken>=0.7.0"],   # for exact token counts
-        "all": [
-            "openai>=1.0.0",
-            "google-generativeai>=0.5.0",
-            "tiktoken>=0.7.0",
-        ],
-    },
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-        "Topic :: Software Development :: Libraries :: Python Modules",
-        "Intended Audience :: Developers",
-    ],
-    keywords="llm anthropic openai cost optimization token caching batch",
-)