code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/aws_bedrock/__init__.py

@@ -0,0 +1,14 @@
+"""AWS Bedrock Plugin for Code Puppy.
+
+This plugin enables Code Puppy to use Anthropic Claude models hosted on
+AWS Bedrock with standard AWS credential chain authentication (env vars,
+profiles, IAM roles, SSO).
+
+Supported models:
+- Claude Opus 4.7 (1M context)
+- Claude Opus 4.6 (1M context)
+- Claude Sonnet 4.6 (1M context)
+- Claude Haiku 4.5 (200K context)
+"""
+
+__version__ = "0.1.0"

code_puppy_core_plugins/aws_bedrock/config.py

@@ -0,0 +1,101 @@
+"""Configuration constants for the AWS Bedrock plugin."""
+
+from __future__ import annotations
+
+import functools
+import os
+from pathlib import Path
+
+from code_puppy.config import DATA_DIR
+
+ENV_AWS_REGION = "AWS_REGION"
+ENV_AWS_PROFILE = "AWS_PROFILE"
+ENV_BEDROCK_REGION = "BEDROCK_REGION"
+
+DEFAULT_REGION = "us-east-1"
+
+
+@functools.lru_cache(maxsize=1)
+def _detect_region() -> str | None:
+    """Detect region from boto3 session or EC2 instance metadata.
+
+    Result is cached for the process lifetime: on non-EC2 hosts with no
+    AWS config, the IMDS path below incurs two 1-second timeouts, and
+    this function is called on every model instantiation.
+    """
+    try:
+        import boto3
+
+        region = boto3.Session().region_name
+        if region:
+            return region
+    except Exception:
+        pass
+
+    try:
+        import urllib.request
+
+        token_req = urllib.request.Request(
+            "http://169.254.169.254/latest/api/token",
+            method="PUT",
+            headers={"X-aws-ec2-metadata-token-ttl-seconds": "30"},
+        )
+        token = urllib.request.urlopen(token_req, timeout=1).read().decode()
+        region_req = urllib.request.Request(
+            "http://169.254.169.254/latest/meta-data/placement/region",
+            headers={"X-aws-ec2-metadata-token": token},
+        )
+        return urllib.request.urlopen(region_req, timeout=1).read().decode()
+    except Exception:
+        return None
+
+
+MODELS: list[dict] = [
+    {
+        "base_key": "bedrock-opus-4-7",
+        "model_id": "us.anthropic.claude-opus-4-7",
+        "context_length": 1000000,
+        "variants": ["default", "low", "medium", "high", "xhigh", "max"],
+    },
+    {
+        "base_key": "bedrock-opus-4-6",
+        "model_id": "us.anthropic.claude-opus-4-6-v1:0",
+        "context_length": 1000000,
+        "variants": ["default", "low", "medium", "high", "max"],
+    },
+    {
+        "base_key": "bedrock-sonnet-4-6",
+        "model_id": "us.anthropic.claude-sonnet-4-6-v1:0",
+        "context_length": 1000000,
+        "variants": ["default", "low", "medium", "high", "max"],
+    },
+    {
+        "base_key": "bedrock-haiku",
+        "model_id": "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+        "context_length": 200000,
+        "variants": None,
+    },
+]
+
+
+def get_bedrock_region() -> str:
+    """Get the AWS region for Bedrock.
+
+    Precedence: BEDROCK_REGION > AWS_REGION > boto3 session > default.
+    """
+    return (
+        os.environ.get(ENV_BEDROCK_REGION)
+        or os.environ.get(ENV_AWS_REGION)
+        or _detect_region()
+        or DEFAULT_REGION
+    )
+
+
+def get_aws_profile() -> str | None:
+    """Get the AWS profile name from environment."""
+    return os.environ.get(ENV_AWS_PROFILE)
+
+
+def get_extra_models_path() -> Path:
+    """Get the path to the extra_models.json file."""
+    return Path(DATA_DIR) / "extra_models.json"

code_puppy_core_plugins/aws_bedrock/register_callbacks.py

@@ -0,0 +1,243 @@
+"""AWS Bedrock Plugin callbacks for Code Puppy CLI.
+
+This plugin enables Code Puppy to use Anthropic Claude models hosted on
+AWS Bedrock with standard AWS credential chain authentication.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+
+from .config import (
+    get_aws_profile,
+    get_bedrock_region,
+)
+from .utils import (
+    add_bedrock_models_to_config,
+    get_bedrock_models_from_config,
+    remove_bedrock_models_from_config,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Slash Command Handlers
+# ============================================================================
+
+
+def _handle_bedrock_status() -> None:
+    """Handle the /bedrock-status command."""
+    emit_info("")
+    emit_info("AWS Bedrock Status")
+    emit_info("=" * 40)
+
+    region = get_bedrock_region()
+    profile = get_aws_profile()
+
+    emit_info(f"Region: {region}")
+    if profile:
+        emit_info(f"Profile: {profile}")
+    else:
+        emit_info("Profile: (default credential chain)")
+
+    # Check AWS credentials
+    try:
+        import boto3
+
+        session = boto3.Session(profile_name=profile, region_name=region)
+        sts = session.client("sts")
+        identity = sts.get_caller_identity()
+        arn = identity.get("Arn", "unknown")
+        emit_success(f"Authenticated: {arn}")
+    except ImportError:
+        emit_warning("boto3 not installed - cannot verify credentials")
+    except Exception as e:
+        emit_warning(f"Authentication: {e}")
+
+    emit_info("")
+    bedrock_models = get_bedrock_models_from_config()
+    if bedrock_models:
+        emit_info(f"Configured Models ({len(bedrock_models)}):")
+        for model_key, config in bedrock_models.items():
+            model_id = config.get("name", "unknown")
+            emit_info(f"   - {model_key}: {model_id}")
+    else:
+        emit_info("Configured Models: None")
+        emit_info("   Run /bedrock-setup to configure models")
+
+    emit_info("")
+
+
+def _handle_bedrock_setup() -> None:
+    """Handle the /bedrock-setup command.
+
+    Region and credentials auto-resolve from the AWS environment
+    (IAM role, env vars, ~/.aws/config). No prompts needed.
+    """
+
+    added_models = add_bedrock_models_to_config(
+        aws_region=get_bedrock_region(),
+        aws_profile=get_aws_profile(),
+    )
+
+    if added_models:
+        emit_success(f"Bedrock: added {len(added_models)} model(s):")
+        for model_key in added_models:
+            emit_info(f"   - {model_key}")
+
+        from code_puppy.model_switching import set_model_and_reload_agent
+
+        set_model_and_reload_agent("bedrock-opus-4-7")
+        emit_info("Switched to bedrock-opus-4-7.")
+    else:
+        emit_warning("Bedrock: no models added — check configuration.")
+
+
+def _handle_bedrock_remove() -> None:
+    """Handle the /bedrock-remove command."""
+    removed = remove_bedrock_models_from_config()
+    if removed:
+        emit_success(f"Removed {len(removed)} Bedrock model(s):")
+        for model_key in removed:
+            emit_info(f"   - {model_key}")
+    else:
+        emit_info("No Bedrock models found in configuration.")
+
+
+# ============================================================================
+# Custom Command Registration
+# ============================================================================
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    """Return help entries for custom commands."""
+    return [
+        ("bedrock-status", "Check AWS Bedrock authentication and configuration"),
+        ("bedrock-setup", "Auto-configure Bedrock Claude models"),
+        ("bedrock-remove", "Remove all Bedrock model configurations"),
+    ]
+
+
+def _handle_custom_command(command: str, name: str) -> bool | None:
+    """Handle custom slash commands for the AWS Bedrock plugin."""
+    handlers = {
+        "bedrock-status": _handle_bedrock_status,
+        "bedrock-setup": _handle_bedrock_setup,
+        "bedrock-remove": _handle_bedrock_remove,
+    }
+
+    handler = handlers.get(name)
+    if handler is None:
+        return None
+
+    try:
+        handler()
+        return True
+    except Exception as e:
+        logger.exception("Error handling /%s command: %s", name, e)
+        emit_error(f"Command /{name} failed: {e}")
+        return True
+
+
+# ============================================================================
+# Model Type Handler
+# ============================================================================
+
+
+def _create_aws_bedrock_model(model_name: str, model_config: dict, config: dict) -> Any:
+    """Create an AWS Bedrock model instance.
+
+    Uses AsyncAnthropicBedrock from the anthropic SDK with standard
+    AWS credential chain (env vars, profiles, IAM roles, SSO).
+    """
+    try:
+        from anthropic import AsyncAnthropicBedrock
+        from pydantic_ai.models.anthropic import AnthropicModel
+    except ImportError as e:
+        emit_error(
+            f"Failed to create Bedrock model '{model_name}': Missing dependency - {e}"
+        )
+        return None
+
+    from code_puppy.claude_cache_client import patch_anthropic_client_messages
+    from code_puppy.config import get_effective_model_settings
+    from code_puppy.model_factory import CONTEXT_1M_BETA
+    from code_puppy.provider_identity import (
+        make_anthropic_provider,
+        resolve_provider_identity,
+    )
+
+    model_id = model_config.get("name")
+    if not model_id:
+        emit_warning(f"Model ID not specified for '{model_name}'.")
+        return None
+
+    try:
+        effective_settings = get_effective_model_settings(model_name)
+        interleaved_thinking = effective_settings.get("interleaved_thinking", True)
+
+        beta_parts: list[str] = []
+        if interleaved_thinking:
+            beta_parts.append("interleaved-thinking-2025-05-14")
+
+        context_length = model_config.get("context_length", 200000)
+        if context_length >= 1_000_000:
+            beta_parts.append(CONTEXT_1M_BETA)
+
+        default_headers: dict[str, str] | None = None
+        if beta_parts:
+            default_headers = {"anthropic-beta": ",".join(beta_parts)}
+
+        client_kwargs: dict[str, Any] = {
+            "aws_region": model_config.get("aws_region") or get_bedrock_region(),
+        }
+
+        aws_profile = model_config.get("aws_profile") or get_aws_profile()
+        if aws_profile:
+            client_kwargs["aws_profile"] = aws_profile
+
+        if default_headers:
+            client_kwargs["default_headers"] = default_headers
+
+        anthropic_client = AsyncAnthropicBedrock(**client_kwargs)
+
+        patch_anthropic_client_messages(anthropic_client)
+
+        provider_identity = resolve_provider_identity(model_name, model_config)
+        provider = make_anthropic_provider(
+            provider_identity,
+            anthropic_client=anthropic_client,
+        )
+
+        model = AnthropicModel(model_name=model_id, provider=provider)
+        logger.info(
+            "Created Bedrock model: %s -> %s @ %s",
+            model_name,
+            model_id,
+            client_kwargs.get("aws_region", "auto"),
+        )
+        return model
+
+    except Exception as e:
+        emit_error(f"Failed to create Bedrock model '{model_name}': {e}")
+        logger.exception("Error creating Bedrock model: %s", e)
+        return None
+
+
+def _register_model_types() -> list[dict[str, Any]]:
+    """Register the aws_bedrock model type handler."""
+    return [{"type": "aws_bedrock", "handler": _create_aws_bedrock_model}]
+
+
+# ============================================================================
+# Callback Registration
+# ============================================================================
+
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)
+register_callback("register_model_type", _register_model_types)

code_puppy_core_plugins/aws_bedrock/utils.py

@@ -0,0 +1,186 @@
+"""Utility functions for the AWS Bedrock plugin."""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from code_puppy import atomic_io, atomic_json
+
+from .config import (
+    MODELS,
+    get_extra_models_path,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def load_extra_models() -> dict[str, Any]:
+    """Load the extra_models.json configuration file.
+
+    Bounded and lock-aware via :mod:`code_puppy.atomic_json` -- a large or
+    concurrently-being-written file can no longer balloon memory or read a
+    torn write. Preserves the original never-raise contract: any failure
+    (missing file, invalid JSON, oversized file, I/O error) logs and
+    returns ``{}`` rather than propagating.
+    """
+    extra_models_path = str(get_extra_models_path())
+    try:
+        return atomic_json.load_json(extra_models_path, default={})
+    except (atomic_json.JsonFileCorrupt, OSError) as e:
+        logger.error("Error loading extra_models.json: %s", e)
+        return {}
+
+
+def save_extra_models(models: dict[str, Any]) -> bool:
+    """Save model configurations to extra_models.json (atomic, locked write)."""
+    extra_models_path = str(get_extra_models_path())
+
+    try:
+        with atomic_io.path_lock(extra_models_path):
+            atomic_io.atomic_write_bytes(
+                extra_models_path,
+                json.dumps(models, indent=2, ensure_ascii=False).encode("utf-8"),
+            )
+        return True
+    except Exception as e:
+        logger.error("Error saving extra_models.json: %s", e)
+        return False
+
+
+def _build_model_entry(
+    model_id: str,
+    context_length: int,
+    has_effort: bool,
+    effort: str | None = None,
+    aws_region: str | None = None,
+    aws_profile: str | None = None,
+) -> dict[str, Any]:
+    """Build a single model config entry for extra_models.json."""
+    supported_settings = [
+        "temperature",
+        "extended_thinking",
+        "budget_tokens",
+        "interleaved_thinking",
+    ]
+    if has_effort:
+        supported_settings.append("effort")
+
+    config: dict[str, Any] = {
+        "type": "aws_bedrock",
+        "provider": "aws_bedrock",
+        "name": model_id,
+        "context_length": context_length,
+        "supported_settings": supported_settings,
+    }
+    if effort:
+        config["default_effort"] = effort
+    if aws_region:
+        config["aws_region"] = aws_region
+    if aws_profile:
+        config["aws_profile"] = aws_profile
+
+    return config
+
+
+def add_bedrock_models_to_config(
+    aws_region: str | None = None,
+    aws_profile: str | None = None,
+) -> list[str]:
+    """Add Bedrock model configurations (with effort variants) to extra_models.json.
+
+    Uses :func:`code_puppy.atomic_json.mutate_json` so the read and write
+    happen inside one locked transaction -- extra_models.json is also
+    touched by add_model_menu.py and the ollama_setup/azure_foundry
+    plugins, so a read-then-write split across two unlocked calls could
+    lose one of those concurrent updates.
+    """
+    entries: dict[str, dict[str, Any]] = {}
+    for spec in MODELS:
+        base_key = spec["base_key"]
+        model_id = spec["model_id"]
+        context_length = spec["context_length"]
+        variants = spec.get("variants")
+
+        if variants:
+            for variant in variants:
+                if variant == "default":
+                    key = base_key
+                    effort = None
+                else:
+                    key = f"{base_key}-{variant}"
+                    effort = variant
+
+                entries[key] = _build_model_entry(
+                    model_id=model_id,
+                    context_length=context_length,
+                    has_effort=True,
+                    effort=effort,
+                    aws_region=aws_region,
+                    aws_profile=aws_profile,
+                )
+        else:
+            entries[base_key] = _build_model_entry(
+                model_id=model_id,
+                context_length=context_length,
+                has_effort=False,
+                aws_region=aws_region,
+                aws_profile=aws_profile,
+            )
+
+    if not entries:
+        return []
+
+    def _mutate(models: dict[str, Any]) -> dict[str, Any]:
+        models.update(entries)
+        return models
+
+    extra_models_path = str(get_extra_models_path())
+    try:
+        atomic_json.mutate_json(extra_models_path, _mutate, default={})
+    except (atomic_json.JsonFileCorrupt, OSError) as e:
+        logger.error("Error saving extra_models.json: %s", e)
+        return []
+
+    return list(entries.keys())
+
+
+def remove_bedrock_models_from_config() -> list[str]:
+    """Remove all Bedrock model configurations from extra_models.json.
+
+    Uses :func:`code_puppy.atomic_json.mutate_json` so the read and write
+    happen inside one locked transaction (see :func:`add_bedrock_models_to_config`).
+    """
+    extra_models_path = str(get_extra_models_path())
+    removed: list[str] = []
+
+    def _mutate(models: dict[str, Any]) -> dict[str, Any]:
+        removed[:] = [
+            key
+            for key, cfg in models.items()
+            if isinstance(cfg, dict) and cfg.get("type") == "aws_bedrock"
+        ]
+        for key in removed:
+            del models[key]
+        return models
+
+    try:
+        atomic_json.mutate_json(extra_models_path, _mutate, default={})
+    except (atomic_json.JsonFileCorrupt, OSError) as e:
+        logger.error(
+            "Failed to save extra_models.json after removing Bedrock models: %s", e
+        )
+        return []
+
+    return removed
+
+
+def get_bedrock_models_from_config() -> dict[str, Any]:
+    """Get all Bedrock model configurations from extra_models.json."""
+    models = load_extra_models()
+    return {
+        key: cfg
+        for key, cfg in models.items()
+        if isinstance(cfg, dict) and cfg.get("type") == "aws_bedrock"
+    }