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

code_puppy_core_plugins/azure_foundry/README.md

@@ -0,0 +1,238 @@
+# Azure AI Foundry Plugin for Code Puppy
+
+This plugin enables Code Puppy to use Anthropic Claude models hosted on
+Microsoft Azure AI Foundry with Azure AD (Entra ID) authentication.
+
+## Overview
+
+Azure AI Foundry provides enterprise-grade hosting of Anthropic Claude models
+within the Microsoft Azure cloud. This plugin uses your existing Azure CLI
+credentials (`az login`) to authenticate, eliminating the need for API keys.
+
+## Supported Models
+
+| Model | Context Length | Deployment Name (Default) |
+|-------|----------------|---------------------------|
+| Claude Opus 4.6 | 1M tokens | `claude-opus-4-6` |
+| Claude Sonnet 4.6 | 1M tokens | `claude-sonnet-4-6` |
+| Claude Haiku 4.5 | 200K tokens | `claude-haiku-4-5` |
+
+Deployment names are user-configurable during setup.
+
+## Prerequisites
+
+1. **Azure subscription** with access to Azure AI Foundry
+2. **Azure CLI** installed and authenticated (`az login`)
+3. **Claude model deployments** provisioned in your Azure AI Foundry resource
+4. **Python packages**: `azure-identity>=1.15.0` (installed with Code Puppy)
+
+## Quick Start
+
+### 1. Authenticate with Azure
+
+```bash
+az login
+```
+
+### 2. Set Your Resource Name
+
+```bash
+export ANTHROPIC_FOUNDRY_RESOURCE=your-resource-name
+```
+
+### 3. Run Interactive Setup
+
+```bash
+pup
+/foundry-setup
+```
+
+The wizard will guide you through configuring your model deployments.
+
+### 4. Start Using Foundry Models
+
+```bash
+/model foundry-claude-opus
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `ANTHROPIC_FOUNDRY_RESOURCE` | Your Azure AI Foundry resource name | Yes |
+| `ANTHROPIC_FOUNDRY_BASE_URL` | Override the base URL (optional) | No |
+
+### Model Configuration
+
+Models are stored in `~/.code_puppy/extra_models.json`:
+
+```json
+{
+  "foundry-claude-opus": {
+    "type": "azure_foundry",
+    "name": "it-entra-claude-opus-4-6[1m]",
+    "foundry_resource": "$ANTHROPIC_FOUNDRY_RESOURCE",
+    "context_length": 1000000,
+    "supported_settings": ["temperature", "extended_thinking", "effort"]
+  },
+  "foundry-claude-sonnet": {
+    "type": "azure_foundry",
+    "name": "it-entra-claude-sonnet-4-6[1m]",
+    "foundry_resource": "$ANTHROPIC_FOUNDRY_RESOURCE",
+    "context_length": 1000000,
+    "supported_settings": ["temperature", "interleaved_thinking", "thinking_budget"]
+  },
+  "foundry-claude-haiku": {
+    "type": "azure_foundry",
+    "name": "it-entra-claude-haiku-4-5",
+    "foundry_resource": "$ANTHROPIC_FOUNDRY_RESOURCE",
+    "context_length": 200000,
+    "supported_settings": ["temperature", "interleaved_thinking", "thinking_budget"]
+  }
+}
+```
+
+**Configuration Fields:**
+
+- `type`: Must be `"azure_foundry"` to route to this plugin
+- `name`: Your Azure deployment name (e.g., `it-entra-claude-opus-4-6`)
+- `foundry_resource`: Resource name (supports `$ENV_VAR` syntax)
+- `context_length`: Model context window in tokens
+- `supported_settings`: List of supported model settings
+
+## Model Settings by Tier
+
+### Opus 4.6 Models
+- `temperature`: Temperature for sampling (0-1)
+- `extended_thinking`: Enable thinking (defaults to "adaptive")
+- `effort`: Thinking effort level ("low", "medium", "high")
+
+### Sonnet & Haiku Models
+- `temperature`: Temperature for sampling (0-1)
+- `interleaved_thinking`: Enable interleaved thinking (boolean)
+- `thinking_budget`: Maximum tokens for internal reasoning
+
+## Context Window Configuration
+
+Deployment names can include a context window suffix following the Claude Code format:
+- `[1m]` - 1 million tokens
+- `[2m]` - 2 million tokens
+- `[200k]` - 200 thousand tokens
+- `[500k]` - 500 thousand tokens
+
+When you specify a deployment name with a context suffix (e.g., `it-entra-claude-opus-4-6[1m]`):
+1. The suffix is **automatically stripped** before sending to Azure
+2. The `context_length` is set based on the parsed suffix
+
+**Example:**
+
+During `/foundry-setup`, if you enter:
+```
+Opus deployment name: it-entra-claude-opus-4-6[1m]
+```
+
+The saved configuration will have:
+- `name`: `it-entra-claude-opus-4-6` (suffix stripped)
+- `context_length`: `1000000` (parsed from `[1m]`)
+
+This is useful when your Azure deployment names don't include the context indicator,
+but you want to configure the context length.
+
+## Slash Commands
+
+| Command | Description |
+|---------|-------------|
+| `/foundry-status` | Check Azure AD authentication status and configured models |
+| `/foundry-setup` | Interactive wizard to configure Foundry models |
+| `/foundry-remove` | Remove all Foundry model configurations |
+
+### Example: /foundry-status
+
+```
+Azure AI Foundry Status
+========================================
+Authentication: Valid (expires in 45 minutes)
+   Logged in as: user@company.com
+
+Foundry Resource: my-foundry-resource
+
+Configured Models (3):
+   - foundry-claude-opus: it-entra-claude-opus-4-6[1m]
+   - foundry-claude-sonnet: it-entra-claude-sonnet-4-6[1m]
+   - foundry-claude-haiku: it-entra-claude-haiku-4-5
+```
+
+## How It Works
+
+1. **Token Acquisition**: Uses `AzureCliCredential` from `azure-identity` to
+   obtain tokens from your `az login` session
+
+2. **Token Refresh**: The `get_bearer_token_provider` function handles automatic
+   token refresh before expiry
+
+3. **API Calls**: Creates an `AsyncAnthropicFoundry` client that uses the native
+   Anthropic Messages API (not OpenAI format)
+
+4. **Integration**: Wraps the client in pydantic-ai's `AnthropicModel` for
+   seamless integration with Code Puppy's agent system
+
+## Troubleshooting
+
+### "CredentialUnavailableError" or "Not authenticated"
+
+Run `az login` to authenticate with Azure:
+
+```bash
+az login
+```
+
+### "Resource not found" or "404 errors"
+
+1. Verify `ANTHROPIC_FOUNDRY_RESOURCE` is set correctly
+2. Check that your model deployments exist in Azure AI Foundry
+3. Ensure the deployment names match your configuration
+
+### Token Expiry
+
+Tokens are automatically refreshed by the Azure Identity library. If you
+encounter issues, try:
+
+```bash
+az account get-access-token --resource https://cognitiveservices.azure.com
+```
+
+### Model Not Found
+
+After running `/foundry-setup`, verify configuration with `/foundry-status`.
+Check that deployment names match exactly (case-sensitive).
+
+## Architecture
+
+```
+code_puppy/plugins/azure_foundry/
+├── __init__.py              # Package marker and version
+├── config.py                # Constants and configuration helpers
+├── token.py                 # Azure AD token provider
+├── utils.py                 # Configuration file utilities
+└── register_callbacks.py    # Plugin callbacks and model handler
+```
+
+## Security Notes
+
+- **No API keys stored**: Authentication uses Azure AD tokens only
+- **Token caching**: Managed by Azure CLI, not stored by this plugin
+- **Credential scope**: Limited to `https://cognitiveservices.azure.com/.default`
+
+## Contributing
+
+This plugin follows Code Puppy's plugin architecture. Key callbacks:
+
+- `register_model_type`: Registers `azure_foundry` type handler
+- `custom_command`: Handles `/foundry-*` slash commands
+- `custom_command_help`: Provides help text for commands
+
+## License
+
+Same as Code Puppy (see repository LICENSE file).

code_puppy_core_plugins/azure_foundry/__init__.py

@@ -0,0 +1,15 @@
+"""Azure AI Foundry Plugin for Code Puppy.
+
+This plugin enables Code Puppy to use Anthropic Claude models hosted on
+Microsoft Azure AI Foundry with Azure AD (Entra ID) authentication.
+
+The plugin uses the `az login` credentials from the Azure CLI to authenticate,
+eliminating the need for API keys.
+
+Supported models:
+- 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/azure_foundry/config.py

@@ -0,0 +1,126 @@
+"""Configuration constants for the Azure AI Foundry plugin.
+
+This module defines constants used throughout the plugin for Azure AD
+authentication and model configuration.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from code_puppy.config import DATA_DIR
+
+# Azure AD scope for Cognitive Services (used for token acquisition)
+# This scope is required for authenticating with Azure AI Foundry
+AZURE_COGNITIVE_SCOPE = "https://cognitiveservices.azure.com/.default"
+
+# Token refresh buffer in seconds (refresh 5 minutes before expiry)
+TOKEN_REFRESH_BUFFER = 300
+
+# Default context lengths for different model tiers
+DEFAULT_CONTEXT_LENGTHS: dict[str, int] = {
+    "opus": 1000000,  # 1M tokens for Opus models
+    "sonnet": 1000000,  # 1M tokens for Sonnet models
+    "haiku": 200000,  # 200K tokens for Haiku models
+}
+
+# Context lengths for OpenAI models (Azure doesn't expose this in the catalog API).
+# Prefixes are matched longest-first against the model name.
+OPENAI_CONTEXT_LENGTHS: dict[str, int] = {
+    "gpt-5.4": 1000000,
+    "gpt-5.4-mini": 1000000,
+    "gpt-5.3-codex": 1000000,
+    "gpt-5.3": 1000000,
+    "gpt-5.2-codex": 1000000,
+    "gpt-5.2": 1000000,
+    "gpt-5.1-codex-max": 1000000,
+    "gpt-5.1-codex-mini": 1000000,
+    "gpt-5.1-codex": 1000000,
+    "gpt-5.1": 1000000,
+    "gpt-5-codex": 1000000,
+    "gpt-5": 1000000,
+    "gpt-4.1": 1000000,
+    "gpt-4.1-mini": 1000000,
+    "gpt-4.1-nano": 1000000,
+    "o4-mini": 200000,
+    "o3": 200000,
+    "o3-mini": 200000,
+    "o1": 200000,
+    "o1-mini": 128000,
+    "codex-mini": 200000,
+}
+DEFAULT_OPENAI_CONTEXT_LENGTH = 128000
+
+
+def get_openai_context_length(model_name: str) -> int:
+    """Look up the context length for an OpenAI model by name.
+
+    Matches the longest prefix first so 'gpt-5.4-mini' matches before 'gpt-5.4'.
+    Falls back to DEFAULT_OPENAI_CONTEXT_LENGTH if no match.
+    """
+    for prefix in sorted(OPENAI_CONTEXT_LENGTHS, key=len, reverse=True):
+        if model_name.startswith(prefix):
+            return OPENAI_CONTEXT_LENGTHS[prefix]
+    return DEFAULT_OPENAI_CONTEXT_LENGTH
+
+
+# Default deployment name patterns (can be overridden by user)
+DEFAULT_DEPLOYMENT_NAMES: dict[str, str] = {
+    "opus": "claude-opus-4-6",
+    "sonnet": "claude-sonnet-4-6",
+    "haiku": "claude-haiku-4-5",
+}
+
+# Environment variable names
+ENV_FOUNDRY_RESOURCE = "ANTHROPIC_FOUNDRY_RESOURCE"
+ENV_FOUNDRY_BASE_URL = "ANTHROPIC_FOUNDRY_BASE_URL"
+
+
+def get_foundry_resource() -> str | None:
+    """Get the Azure Foundry resource name from environment.
+
+    Returns:
+        The resource name if set, None otherwise.
+    """
+    return os.environ.get(ENV_FOUNDRY_RESOURCE)
+
+
+def get_foundry_base_url() -> str | None:
+    """Get the Azure Foundry base URL from environment.
+
+    If ANTHROPIC_FOUNDRY_BASE_URL is set, use it directly.
+    Otherwise, construct from ANTHROPIC_FOUNDRY_RESOURCE.
+
+    Returns:
+        The base URL if determinable, None otherwise.
+    """
+    base_url = os.environ.get(ENV_FOUNDRY_BASE_URL)
+    if base_url:
+        return base_url
+
+    resource = get_foundry_resource()
+    if resource:
+        return f"https://{resource}.services.ai.azure.com/anthropic/v1"
+
+    return None
+
+
+def get_extra_models_path() -> Path:
+    """Get the path to the extra_models.json file.
+
+    Returns:
+        Path to the extra models configuration file.
+    """
+    return Path(DATA_DIR) / "extra_models.json"
+
+
+# Plugin configuration for model creation
+AZURE_FOUNDRY_CONFIG: dict[str, Any] = {
+    "scope": AZURE_COGNITIVE_SCOPE,
+    "token_refresh_buffer": TOKEN_REFRESH_BUFFER,
+}
+
+# Per-tier supported_settings (see build_foundry_model_config()):
+# Opus 4.6 -> [temperature, extended_thinking, effort]; Sonnet/Haiku -> [temperature, interleaved_thinking, thinking_budget]

code_puppy_core_plugins/azure_foundry/discovery.py

@@ -0,0 +1,189 @@
+"""Azure AI Services deployment discovery.
+
+Queries the Azure Management API to find AI Services accounts and
+list their model deployments. Works with any AIServices account
+hosting Anthropic, OpenAI, or other model formats.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+AZURE_MANAGEMENT_SCOPE = "https://management.azure.com/.default"
+MANAGEMENT_BASE = "https://management.azure.com"
+RESOURCE_API_VERSION = "2021-04-01"
+DEPLOYMENT_API_VERSION = "2024-10-01"
+
+
+@dataclass
+class AzureAccount:
+    """Discovered Azure AI Services account."""
+
+    resource_id: str
+    name: str
+    location: str
+    resource_group: str
+    subscription_id: str
+
+
+@dataclass
+class AzureDeployment:
+    """Discovered model deployment on an Azure AI Services account."""
+
+    name: str
+    model_name: str
+    model_format: str  # "Anthropic", "OpenAI", etc.
+    model_version: str
+    provisioning_state: str
+    sku_name: str
+    capacity: int
+
+
+def _get_management_token() -> str | None:
+    """Get a token for the Azure Management API using az login credentials.
+
+    Returns:
+        Bearer token string, or None if auth fails.
+    """
+    try:
+        from azure.identity import AzureCliCredential
+
+        credential = AzureCliCredential()
+        token = credential.get_token(AZURE_MANAGEMENT_SCOPE)
+        return token.token
+    except Exception as e:
+        logger.warning("Failed to get management token: %s", e)
+        return None
+
+
+def _management_get(token: str, url: str) -> dict[str, Any] | None:
+    """Make a GET request to the Azure Management API.
+
+    Args:
+        token: Bearer token for authentication.
+        url: Full URL to GET.
+
+    Returns:
+        Parsed JSON response, or None on error.
+    """
+    try:
+        import httpx
+
+        resp = httpx.get(
+            url,
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=30,
+        )
+        if resp.status_code == 200:
+            return resp.json()
+        logger.warning("Management API %s returned %d", url, resp.status_code)
+        return None
+    except Exception as e:
+        logger.warning("Management API request failed: %s", e)
+        return None
+
+
+def find_account(resource_name: str) -> AzureAccount | None:
+    """Find an Azure AI Services account by name across all accessible subscriptions.
+
+    Args:
+        resource_name: The account name to search for.
+
+    Returns:
+        AzureAccount if found, None otherwise.
+    """
+    token = _get_management_token()
+    if not token:
+        return None
+
+    # List subscriptions
+    subs_url = f"{MANAGEMENT_BASE}/subscriptions?api-version=2022-12-01"
+    subs_resp = _management_get(token, subs_url)
+    if not subs_resp:
+        return None
+
+    subscriptions = subs_resp.get("value", [])
+
+    for sub in subscriptions:
+        sub_id = sub.get("subscriptionId", "")
+        if sub.get("state") != "Enabled":
+            continue
+
+        # Search for the resource by name and type
+        filter_str = (
+            f"name eq '{resource_name}' and "
+            f"resourceType eq 'Microsoft.CognitiveServices/accounts'"
+        )
+        resources_url = (
+            f"{MANAGEMENT_BASE}/subscriptions/{sub_id}/resources"
+            f"?$filter={filter_str}&api-version={RESOURCE_API_VERSION}"
+        )
+        resources_resp = _management_get(token, resources_url)
+        if not resources_resp:
+            continue
+
+        for resource in resources_resp.get("value", []):
+            rid = resource.get("id", "")
+            parts = rid.split("/")
+            # /subscriptions/{sub}/resourceGroups/{rg}/providers/.../accounts/{name}
+            rg_idx = next(
+                (i for i, p in enumerate(parts) if p.lower() == "resourcegroups"),
+                None,
+            )
+            rg = parts[rg_idx + 1] if rg_idx is not None else ""
+
+            return AzureAccount(
+                resource_id=rid,
+                name=resource_name,
+                location=resource.get("location", ""),
+                resource_group=rg,
+                subscription_id=sub_id,
+            )
+
+    return None
+
+
+def list_deployments(account: AzureAccount) -> list[AzureDeployment]:
+    """List all model deployments on an Azure AI Services account.
+
+    Args:
+        account: The account to query.
+
+    Returns:
+        List of deployments (all states, caller filters as needed).
+    """
+    token = _get_management_token()
+    if not token:
+        return []
+
+    url = (
+        f"{MANAGEMENT_BASE}{account.resource_id}"
+        f"/deployments?api-version={DEPLOYMENT_API_VERSION}"
+    )
+    resp = _management_get(token, url)
+    if not resp:
+        return []
+
+    deployments = []
+    for d in resp.get("value", []):
+        props = d.get("properties", {})
+        model = props.get("model", {})
+        sku = d.get("sku", {})
+
+        deployments.append(
+            AzureDeployment(
+                name=d.get("name", ""),
+                model_name=model.get("name", ""),
+                model_format=model.get("format", ""),
+                model_version=model.get("version", ""),
+                provisioning_state=props.get("provisioningState", ""),
+                sku_name=sku.get("name", ""),
+                capacity=sku.get("capacity", 0),
+            )
+        )
+
+    return deployments