Add Azure OpenAI provider support

Adds `azure_openai` as a provider option for both pipeline and simulation
zones. Reuses `OpenAIProvider` by swapping in `AzureOpenAI`/`AsyncAzureOpenAI`
clients at construction time — no new provider classes needed.

Config: `entropy config set simulation.provider azure_openai`
Env vars: AZURE_OPENAI_API_KEY, AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_DEPLOYMENT

Bumps version to 0.1.2.

Author: DeveshParagiri

entropy/__init__.py

@@ -1,3 +1,3 @@
 """Entropy: Simulate how populations respond to scenarios."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"

entropy/cli/commands/config_cmd.py

@@ -8,6 +8,7 @@
     reset_config,
     CONFIG_FILE,
     get_api_key,
+    get_azure_config,
 )
 
 
@@ -121,6 +122,20 @@ def _show_config():
     console.print("[bold cyan]API Keys[/bold cyan] (from env vars)")
     _show_key_status("openai", "OPENAI_API_KEY")
     _show_key_status("claude", "ANTHROPIC_API_KEY")
+    _show_key_status("azure_openai", "AZURE_OPENAI_API_KEY")
+
+    # Azure-specific config (show when Azure provider is in use)
+    active_providers = {config.pipeline.provider, config.simulation.provider}
+    if "azure_openai" in active_providers:
+        azure_cfg = get_azure_config("azure_openai")
+        console.print()
+        console.print("[bold cyan]Azure OpenAI[/bold cyan]")
+        console.print(
+            f"  endpoint          = {azure_cfg['azure_endpoint'] or '[dim]not set[/dim]'}"
+        )
+        console.print(f"  api_version       = {azure_cfg['api_version']}")
+        if azure_cfg["azure_deployment"]:
+            console.print(f"  deployment        = {azure_cfg['azure_deployment']}")
 
     # Config file
     console.print()

entropy/config.py

@@ -213,6 +213,7 @@ def get_api_key(provider: str) -> str:
     Supports:
         - openai: OPENAI_API_KEY
         - claude: ANTHROPIC_API_KEY
+        - azure_openai: AZURE_OPENAI_API_KEY
 
     Returns empty string if not found (providers will raise on missing keys).
     """
@@ -221,9 +222,32 @@ def get_api_key(provider: str) -> str:
         return os.environ.get("OPENAI_API_KEY", "")
     elif provider == "claude":
         return os.environ.get("ANTHROPIC_API_KEY", "")
+    elif provider == "azure_openai":
+        return os.environ.get("AZURE_OPENAI_API_KEY", "")
     return ""
 
 
+def get_azure_config(provider: str) -> dict[str, str]:
+    """Get Azure-specific configuration from environment variables.
+
+    Args:
+        provider: 'azure_openai'
+
+    Returns:
+        Dict of Azure config values (endpoint, api_version, deployment).
+    """
+    _ensure_dotenv()
+    if provider == "azure_openai":
+        return {
+            "azure_endpoint": os.environ.get("AZURE_OPENAI_ENDPOINT", ""),
+            "api_version": os.environ.get(
+                "AZURE_OPENAI_API_VERSION", "2025-03-01-preview"
+            ),
+            "azure_deployment": os.environ.get("AZURE_OPENAI_DEPLOYMENT", ""),
+        }
+    return {}
+
+
 # =============================================================================
 # Global config singleton
 # =============================================================================

entropy/core/providers/__init__.py

@@ -9,7 +9,7 @@
 """
 
 from .base import LLMProvider
-from ...config import get_config, get_api_key
+from ...config import get_config, get_api_key, get_azure_config
 
 
 # Cached simulation provider — reused across batch calls so the async
@@ -29,9 +29,25 @@ def _create_provider(provider_name: str) -> LLMProvider:
         from .claude import ClaudeProvider
 
         return ClaudeProvider(api_key=api_key)
+    elif provider_name == "azure_openai":
+        from .openai import OpenAIProvider
+
+        azure_cfg = get_azure_config(provider_name)
+        if not azure_cfg.get("azure_endpoint"):
+            raise ValueError(
+                "AZURE_OPENAI_ENDPOINT not found. Set it as an environment variable.\n"
+                "  export AZURE_OPENAI_ENDPOINT=https://<resource>.cognitiveservices.azure.com/"
+            )
+        return OpenAIProvider(
+            api_key=api_key,
+            azure_endpoint=azure_cfg["azure_endpoint"],
+            api_version=azure_cfg.get("api_version", "2025-03-01-preview"),
+            azure_deployment=azure_cfg.get("azure_deployment", ""),
+        )
     else:
         raise ValueError(
-            f"Unknown LLM provider: {provider_name}. Valid options: 'openai', 'claude'"
+            f"Unknown LLM provider: {provider_name}. "
+            f"Valid options: 'openai', 'claude', 'azure_openai'"
         )
 
 

entropy/core/providers/openai.py

@@ -23,18 +23,51 @@
 
 
 class OpenAIProvider(LLMProvider):
-    """OpenAI LLM provider using the Responses API."""
+    """OpenAI LLM provider using the Responses API.
+
+    Supports both standard OpenAI and Azure OpenAI endpoints.
+    When azure_endpoint is provided, uses AzureOpenAI/AsyncAzureOpenAI clients.
+    """
 
     provider_name = "openai"
 
-    def __init__(self, api_key: str = "") -> None:
+    def __init__(
+        self,
+        api_key: str = "",
+        *,
+        azure_endpoint: str = "",
+        api_version: str = "",
+        azure_deployment: str = "",
+    ) -> None:
+        self._is_azure = bool(azure_endpoint)
+        self._azure_endpoint = azure_endpoint
+        self._api_version = api_version
+        self._azure_deployment = azure_deployment
+
         if not api_key:
-            raise ValueError(
-                "OPENAI_API_KEY not found. Set it as an environment variable.\n"
-                "  export OPENAI_API_KEY=sk-..."
-            )
+            if self._is_azure:
+                raise ValueError(
+                    "AZURE_OPENAI_API_KEY not found. Set it as an environment variable.\n"
+                    "  export AZURE_OPENAI_API_KEY=<your-subscription-key>"
+                )
+            else:
+                raise ValueError(
+                    "OPENAI_API_KEY not found. Set it as an environment variable.\n"
+                    "  export OPENAI_API_KEY=sk-..."
+                )
         super().__init__(api_key)
 
+        if self._is_azure:
+            self.provider_name = "azure_openai"
+
+    def _resolve_model(self, model: str | None, default: str) -> str:
+        """Resolve model name, using Azure deployment as fallback when applicable."""
+        if model:
+            return model
+        if self._is_azure and self._azure_deployment:
+            return self._azure_deployment
+        return default
+
     @staticmethod
     def _extract_output_text(response) -> str | None:
         """Extract the output text content from an OpenAI Responses API response.
@@ -100,11 +133,28 @@ def default_research_model(self) -> str:
         return "gpt-5"
 
     def _get_client(self) -> OpenAI:
+        if self._is_azure:
+            from openai import AzureOpenAI
+
+            return AzureOpenAI(
+                api_key=self._api_key,
+                azure_endpoint=self._azure_endpoint,
+                api_version=self._api_version,
+            )
         return OpenAI(api_key=self._api_key)
 
     def _get_async_client(self) -> AsyncOpenAI:
         if self._cached_async_client is None:
-            self._cached_async_client = AsyncOpenAI(api_key=self._api_key)
+            if self._is_azure:
+                from openai import AsyncAzureOpenAI
+
+                self._cached_async_client = AsyncAzureOpenAI(
+                    api_key=self._api_key,
+                    azure_endpoint=self._azure_endpoint,
+                    api_version=self._api_version,
+                )
+            else:
+                self._cached_async_client = AsyncOpenAI(api_key=self._api_key)
         return self._cached_async_client
 
     def simple_call(
@@ -116,7 +166,7 @@ def simple_call(
         log: bool = True,
         max_tokens: int | None = None,
     ) -> dict:
-        model = model or self.default_simple_model
+        model = self._resolve_model(model, self.default_simple_model)
         client = self._get_client()
 
         # Acquire rate limit capacity before making the call
@@ -169,7 +219,7 @@ async def simple_call_async(
         model: str | None = None,
         max_tokens: int | None = None,
     ) -> dict:
-        model = model or self.default_simple_model
+        model = self._resolve_model(model, self.default_simple_model)
         client = self._get_async_client()
 
         request_params = {
@@ -211,7 +261,7 @@ def reasoning_call(
         max_retries: int = 2,
         on_retry: RetryCallback | None = None,
     ) -> dict:
-        model = model or self.default_reasoning_model
+        model = self._resolve_model(model, self.default_reasoning_model)
         client = self._get_client()
 
         effective_prompt = prompt
@@ -272,7 +322,7 @@ def agentic_research(
         max_retries: int = 2,
         on_retry: RetryCallback | None = None,
     ) -> tuple[dict, list[str]]:
-        model = model or self.default_research_model
+        model = self._resolve_model(model, self.default_research_model)
         client = self._get_client()
 
         effective_prompt = prompt

entropy/core/rate_limits.py

@@ -88,6 +88,9 @@
 # Map "claude" provider name to anthropic profiles
 RATE_LIMIT_PROFILES["claude"] = RATE_LIMIT_PROFILES["anthropic"]
 
+# Azure OpenAI uses the same rate limit profiles as standard OpenAI
+RATE_LIMIT_PROFILES["azure_openai"] = RATE_LIMIT_PROFILES["openai"]
+
 
 def get_limits(
     provider: str,