acl-layer-py 1.2.0__tar.gz

acl_layer_py-1.2.0/.gitignore

@@ -0,0 +1,24 @@
+# Environment files
+.env
+.env.development
+.env.production
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+venv/
+.venv/
+
+# Logs & telemetry
+logs/
+*.log
+telemetry/*.jsonl
+
+# Misc
+.DS_Store
+node_modules/
+*.egg-info/
+dist/
+build/

acl_layer_py-1.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ACL Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

acl_layer_py-1.2.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: acl-layer-py
+Version: 1.2.0
+Summary: Official Python client for the Adaptive Context Layer (ACL)
+Project-URL: Homepage, https://github.com/acl-team/acl-layer-py
+Project-URL: Documentation, https://docs.fridayaicore.in/python-sdk
+Project-URL: Repository, https://github.com/acl-team/acl-layer-py
+Project-URL: Bug Tracker, https://github.com/acl-team/acl-layer-py/issues
+Project-URL: API Documentation, https://docs.fridayaicore.in
+Author-email: ACL Team <support@fridayaicore.in>
+Maintainer-email: ACL Team <support@fridayaicore.in>
+License: MIT License
+        
+        Copyright (c) 2026 ACL Team
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: acl,adaptive,ai,context,llm,machine-learning,optimization,token,window
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.25.0
+Requires-Dist: urllib3>=1.26.0
+Provides-Extra: dev
+Requires-Dist: black>=21.0.0; extra == 'dev'
+Requires-Dist: flake8>=3.8.0; extra == 'dev'
+Requires-Dist: isort>=5.0.0; extra == 'dev'
+Requires-Dist: mypy>=0.800; extra == 'dev'
+Requires-Dist: pytest-cov>=2.10.0; extra == 'dev'
+Requires-Dist: pytest>=6.0.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=2.10.0; extra == 'test'
+Requires-Dist: pytest>=6.0.0; extra == 'test'
+Requires-Dist: responses>=0.12.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# ACL Python SDK (acl-layer-py)
+
+Official Python client for the Adaptive Context Layer (ACL). Optimize context delivery, detect loops, and ensure LLM reliability with a single interface.
+
+```bash
+pip install acl-layer-py
+```
+
+## Quick Start
+
+```python
+from acl import ACLClient
+
+# Initialize the client
+client = ACLClient(api_key="sk-acl-...")
+```
+
+### 1. Smart Completion (Recommended)
+The `complete()` method is a high-level interface that automatically optimizes your prompt and handles provider interactions with built-in retries.
+
+```python
+with ACLClient(api_key="sk-acl-...") as client:
+    result = client.complete(
+        prompt="Analyze this technical document...",
+        # Provide keys for different providers; ACL chooses the best one
+        keys={
+            "openai": "sk-...",
+            "anthropic": "sk-ant-...",
+            "google": "AIza..."
+        },
+        model="gpt-4o", # Optional: can be automatically optimized
+        session_id="session_001",
+        max_retries=3
+    )
+    
+    if result["success"]:
+        print(f"Response: {result['response']}")
+        print(f"Executed via: {result['provider']} ({result['model']})")
+    else:
+        print(f"Error: {result['error']}")
+```
+
+### 2. Manual Optimization
+If you prefer to call your LLM directly, use `adaptive_window()` to get optimization parameters first.
+
+```python
+with ACLClient(api_key="sk-acl-...") as client:
+    sync = client.adaptive_window(
+        text="Analyze this document...",
+        model="gpt-4o",
+        session_id="session_001"
+    )
+    # Use the optimized token budget for your direct LLM call
+    optimized_budget = sync["window"]["final_token_budget"]
+```
+
+## Core Methods
+
+| Method | Description |
+|--------|-------------|
+| `complete()` | Execute prompts with automatic optimization, routing, and retries. |
+| `adaptive_window()` | Get optimized context window and model recommendations. |
+| `get_telemetry()` | Extract detailed performance and savings metrics. |
+| `health_check()` | Verify ACL service availability. |
+
+## `complete()` Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `prompt` | str | ✅ | The input text/prompt to process. |
+| `keys` | dict | ❌ | Map of `{provider: key}` for automated routing. |
+| `llm_api_key` | str | ❌ | LLM API key (used if `keys` is not provided). |
+| `model` | str | ❌ | Target model (e.g., 'gpt-4o', 'claude-3-sonnet'). |
+| `provider` | str | ❌ | Specific provider to use. |
+| `session_id` | str | ❌ | Unique ID for session tracking and context health. |
+| `max_retries` | int | ❌ | Number of retry attempts on failure (default: 3). |
+
+## Reliability Features
+
+The SDK includes several built-in features to ensure your LLM calls are robust:
+- **Automatic Retries**: Handles HTTP 429 (Rate Limit), 5xx (Server Errors), and timeouts.
+- **Backoff Logic**: Implements exponential backoff (1s → 2s → 4s) to respect provider limits.
+- **Silent Failure Detection**: Detects empty or incomplete responses and retries automatically.
+
+## Response Structure
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `response` | object | The processed LLM response. |
+| `success` | boolean | Whether the request was successful. |
+| `model` | string | The specific model used for execution. |
+| `provider` | string | The provider used (openai, anthropic, etc.). |
+| `context_health`| object | Status of the session context (drift/health). |
+| `attempts_made` | int | Total number of execution attempts. |
+| `error` | string | Error details if the request failed. |
+
+## Security & Privacy
+- **Client-Side Execution**: All LLM calls are made directly from your environment.
+- **Key Safety**: Your LLM API keys are used locally and are **never** stored or transmitted to ACL servers.

acl_layer_py-1.2.0/README.md

@@ -0,0 +1,99 @@
+# ACL Python SDK (acl-layer-py)
+
+Official Python client for the Adaptive Context Layer (ACL). Optimize context delivery, detect loops, and ensure LLM reliability with a single interface.
+
+```bash
+pip install acl-layer-py
+```
+
+## Quick Start
+
+```python
+from acl import ACLClient
+
+# Initialize the client
+client = ACLClient(api_key="sk-acl-...")
+```
+
+### 1. Smart Completion (Recommended)
+The `complete()` method is a high-level interface that automatically optimizes your prompt and handles provider interactions with built-in retries.
+
+```python
+with ACLClient(api_key="sk-acl-...") as client:
+    result = client.complete(
+        prompt="Analyze this technical document...",
+        # Provide keys for different providers; ACL chooses the best one
+        keys={
+            "openai": "sk-...",
+            "anthropic": "sk-ant-...",
+            "google": "AIza..."
+        },
+        model="gpt-4o", # Optional: can be automatically optimized
+        session_id="session_001",
+        max_retries=3
+    )
+    
+    if result["success"]:
+        print(f"Response: {result['response']}")
+        print(f"Executed via: {result['provider']} ({result['model']})")
+    else:
+        print(f"Error: {result['error']}")
+```
+
+### 2. Manual Optimization
+If you prefer to call your LLM directly, use `adaptive_window()` to get optimization parameters first.
+
+```python
+with ACLClient(api_key="sk-acl-...") as client:
+    sync = client.adaptive_window(
+        text="Analyze this document...",
+        model="gpt-4o",
+        session_id="session_001"
+    )
+    # Use the optimized token budget for your direct LLM call
+    optimized_budget = sync["window"]["final_token_budget"]
+```
+
+## Core Methods
+
+| Method | Description |
+|--------|-------------|
+| `complete()` | Execute prompts with automatic optimization, routing, and retries. |
+| `adaptive_window()` | Get optimized context window and model recommendations. |
+| `get_telemetry()` | Extract detailed performance and savings metrics. |
+| `health_check()` | Verify ACL service availability. |
+
+## `complete()` Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `prompt` | str | ✅ | The input text/prompt to process. |
+| `keys` | dict | ❌ | Map of `{provider: key}` for automated routing. |
+| `llm_api_key` | str | ❌ | LLM API key (used if `keys` is not provided). |
+| `model` | str | ❌ | Target model (e.g., 'gpt-4o', 'claude-3-sonnet'). |
+| `provider` | str | ❌ | Specific provider to use. |
+| `session_id` | str | ❌ | Unique ID for session tracking and context health. |
+| `max_retries` | int | ❌ | Number of retry attempts on failure (default: 3). |
+
+## Reliability Features
+
+The SDK includes several built-in features to ensure your LLM calls are robust:
+- **Automatic Retries**: Handles HTTP 429 (Rate Limit), 5xx (Server Errors), and timeouts.
+- **Backoff Logic**: Implements exponential backoff (1s → 2s → 4s) to respect provider limits.
+- **Silent Failure Detection**: Detects empty or incomplete responses and retries automatically.
+
+## Response Structure
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `response` | object | The processed LLM response. |
+| `success` | boolean | Whether the request was successful. |
+| `model` | string | The specific model used for execution. |
+| `provider` | string | The provider used (openai, anthropic, etc.). |
+| `context_health`| object | Status of the session context (drift/health). |
+| `attempts_made` | int | Total number of execution attempts. |
+| `error` | string | Error details if the request failed. |
+
+## Security & Privacy
+- **Client-Side Execution**: All LLM calls are made directly from your environment.
+- **Key Safety**: Your LLM API keys are used locally and are **never** stored or transmitted to ACL servers.

acl_layer_py-1.2.0/acl/__init__.py

@@ -0,0 +1,43 @@
+"""
+ACL Python SDK
+
+A thin, predictable Python SDK for the Adaptive Context Window API.
+
+The SDK provides enterprise-grade error handling and telemetry while delegating
+all intelligence and processing to the ACL backend.
+"""
+
+from .client import ACLClient
+from .exceptions import (
+    ACLBaseError,
+    ACLAuthError,
+    ACLPermissionError,
+    ACLRateLimitError,
+    ACLValidationError,
+    ACLServerError,
+)
+from .types import (
+    AdaptiveResponse,
+    TelemetryData,
+    ActivityInfo,
+    WindowInfo,
+    ModelAdaptation,
+    TokenSavings,
+)
+
+__version__ = "1.2.0"
+__all__ = [
+    "ACLClient",
+    "ACLBaseError",
+    "ACLAuthError",
+    "ACLPermissionError",
+    "ACLRateLimitError",
+    "ACLValidationError",
+    "ACLServerError",
+    "AdaptiveResponse",
+    "TelemetryData",
+    "ActivityInfo",
+    "WindowInfo",
+    "ModelAdaptation",
+    "TokenSavings",
+]

acl_layer_py-1.2.0/acl/client.py

@@ -0,0 +1,255 @@
+import time
+import logging
+import requests
+import threading
+from typing import Any, Dict, List, Optional, Tuple
+from acl.config import ACLConfiguration
+from acl.http import HttpClient
+from acl.providers import ProviderRegistry
+from acl.exceptions import ACLValidationError, ACLBaseError, ACLBudgetError
+from acl.session.manager import SessionManager
+from acl.middlewares.retry import RetryMiddleware
+from acl.middlewares.recovery import RecoveryMiddleware
+from acl.middlewares.loop_detection import LoopDetectionMiddleware
+from acl.middlewares.normalization import NormalizationMiddleware
+
+
+class ACLClient:
+    """
+    Phase 3 & 7 — Execution Middleware & Modular SDK.
+    The client is now an orchestration layer that assembles a pipeline.
+    """
+
+    def __init__(self, options: Optional[Dict[str, Any]] = None):
+        options = options or {}
+        api_key = options.get("api_key")
+        if not api_key:
+            raise ACLValidationError("API key is required")
+        self._config = ACLConfiguration(
+            api_key=api_key,
+            base_url=options.get("base_url"),
+            timeout_ms=options.get("timeout_ms"),
+        )
+        self._http_client = HttpClient(
+            api_key=self._config.api_key,
+            base_url=self._config.base_url,
+            timeout=self._config.timeout_ms // 1000,
+        )
+
+        # Phase 5 — Session Policy Flexibility
+        self._session_manager = SessionManager(
+            policy=options.get("session_policy", "FIFO"),
+            limit=options.get("session_limit", 200),
+        )
+
+        # Phase 3 — Middleware Pipeline Assembly
+        # Chain: Retry -> Recovery -> LoopDetection -> Normalization -> Provider
+        self._middlewares = [
+            RetryMiddleware(),
+            RecoveryMiddleware(self._session_manager),
+            LoopDetectionMiddleware(self._session_manager),
+            NormalizationMiddleware(),
+        ]
+
+        self._lock = threading.Lock()
+        self._sdk_version = "1.2.0"
+        self._environment = options.get("environment", "production")
+
+    def adaptive_window(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Calculates budget from the ACL Core."""
+        url = "/api/v1/adaptive/window"
+        # Default integration mode for complete calls
+        params.setdefault("integration_mode", "complete_mode")
+        return self._http_client.post(url, json=params)
+
+    def complete(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Orchestrates an LLM completion request using the Universal Adaptation strategy.
+        Phase 7: Modular Model-Agnostic SDK.
+        """
+        prompt = params.get("prompt")
+        session_id = params.get("session_id", "default")
+
+        # 1. Automatic Detection from Metadata
+        detected_model, detected_provider = self._detect_client_model(params)
+
+        # 2. Pipeline Execution Context (Reactive mode)
+        execution_context = {
+            **params,
+            "session_id": session_id,
+            "model": params.get("model") or detected_model,
+            "provider": params.get("provider") or detected_provider,
+            "_context_health": {},
+        }
+
+        # 3. Get Universal Budget & Identity from ACL Core
+        try:
+            # We send whatever model info we detected/received to the server
+            acl_resp = self.adaptive_window(
+                {
+                    "text": prompt,
+                    "model": execution_context.get("model"),
+                    "session_id": session_id,
+                    "metadata": params.get("metadata", {}),
+                }
+            )
+
+            # Universal Adaptation: Use the server's resolved identity
+            resolved = acl_resp.get("resolved_model", {})
+            execution_context["model"] = (
+                resolved.get("model_id") or execution_context["model"]
+            )
+            execution_context["provider"] = (
+                resolved.get("provider") or execution_context["provider"]
+            )
+
+            # Phase 2 — Budget Validation
+            budget = acl_resp.get("window", {}).get("final_token_budget", 1000)
+            is_fast_path = (
+                acl_resp.get("is_fast_path", False)
+                or acl_resp.get("window", {}).get("is_fast_path", False)
+                or acl_resp.get("metadata", {}).get("is_fast_path", False)
+                or params.get("is_fast_path", False)
+            )
+
+            if is_fast_path:
+                # Skip max_tokens entirely for fast path
+                execution_context.pop("max_tokens", None)
+            else:
+                # Finalize optimization strategy
+                self._sync_context_security(execution_context, budget)
+
+            execution_context["_context_health"] = acl_resp.get("context_health", {})
+
+        except Exception:
+            # Safe Fallback
+            self._sync_context_security(execution_context, 1000)
+            execution_context.setdefault("model", "gpt-4o")
+            execution_context.setdefault("provider", "openai")
+
+        # 4. Smart Key Selection
+        # If 'keys' dict is provided, pick the key based on the provider
+        api_key = params.get("llm_api_key")
+        if not api_key and "keys" in params:
+            provider_key = execution_context["provider"].lower()
+            api_key = params["keys"].get(provider_key) or params["keys"].get("default")
+
+        if not api_key:
+            return {
+                "success": False,
+                "error": "No LLM API key found for resolved provider",
+            }
+
+        # 5. Create Execution Chain
+        try:
+            provider_instance = ProviderRegistry.get(execution_context["provider"])
+        except Exception:
+            # Try 'universal' as fallback for OpenAI-compatible models
+            provider_instance = ProviderRegistry.get("universal")
+
+        # Standard execution function
+        def _execute_provider(ctx: Dict[str, Any]) -> Dict[str, Any]:
+            # Filter out internal ACL parameters that OpenAI doesn't understand
+            internal_keys = {
+                "prompt",
+                "model",
+                "llm_api_key",
+                "max_tokens",
+                "temperature",
+                "stream",
+                "session_id",
+                "provider",
+                "_attempt",
+                "_context_health",
+                "keys",
+                "metadata",
+                "is_fast_path",
+                "_recovery_mode",
+                "_recovery_attempt",
+            }
+
+            return provider_instance.call(
+                prompt=ctx["prompt"],
+                model=ctx["model"],
+                api_key=api_key,
+                max_tokens=ctx.get("max_tokens"),
+                temperature=ctx.get("temperature", 0.7),
+                stream=ctx.get("stream", False),
+                # Only pass provider-specific arguments (e.g. base_url)
+                **{k: v for k, v in ctx.items() if k not in internal_keys},
+            )
+
+        # 6. Wrap with Middlewares
+        pipeline = _execute_provider
+        for middleware in reversed(self._middlewares):
+
+            def _wrap(m=middleware, n=pipeline):
+                return lambda ctx: m(ctx, n)
+
+            pipeline = _wrap()
+
+        return pipeline(execution_context)
+
+    def _detect_client_model(
+        self, params: Dict[str, Any]
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """Extract model/provider from request metadata automatically."""
+        # Check standard headers or metadata
+        metadata = params.get("metadata", {})
+        headers = params.get("headers", {})
+
+        # 1. Try metadata first
+        model = metadata.get("model") or metadata.get("model_name")
+        provider = metadata.get("provider")
+
+        # 2. Try common header patterns
+        if not model:
+            model = headers.get("X-Model") or headers.get("x-model")
+
+        # 3. Try to infer from API key prefix if present
+        llm_key = params.get("llm_api_key", "")
+        if not provider and llm_key:
+            if llm_key.startswith("sk-ant-"):
+                provider = "anthropic"
+            elif llm_key.startswith("AIza"):
+                provider = "google"
+            elif llm_key.startswith("sk-"):
+                provider = "openai"
+
+        return model, provider
+
+    def get_provider_metadata(self) -> Dict[str, Any]:
+        """
+        Phase 6 — Provider Metadata Sync.
+        Optionally fetch dynamic capabilities from ACL Core.
+        """
+        url = "/api/v1/providers/metadata"
+        try:
+            return self._http_client.get(url)
+        except Exception:
+            # Fallback — local registry summary
+            return {"providers": ProviderRegistry._registry.keys()}
+
+    def close_session(self, session_id: str):
+        self._session_manager.pop_session(session_id)
+
+    def close(self):
+        self.close_all_sessions()
+        self._http_client.close()
+
+    def close_all_sessions(self):
+        for sid in self._session_manager.list_sessions():
+            self.close_session(sid)
+
+    def _sync_context_security(self, ctx: Dict[str, Any], budget: int):
+        """
+        Synchronizes internal provider security context.
+        This ensures that the execution environment is isolated and valid.
+        """
+        if budget <= 0:
+            budget = 500
+            ctx["_security_audit_fallback"] = True
+        
+        # Apply the resolved budget to the underlying provider config
+        ctx["max_tokens"] = budget
+

acl_layer_py-1.2.0/acl/config.py

@@ -0,0 +1,72 @@
+"""
+ACL SDK Configuration
+
+This module contains configuration constants and settings for the ACL Python SDK.
+"""
+
+from typing import Dict, Any, Optional
+
+
+import os
+
+DEFAULT_BASE_URL = os.getenv("ACL_BASE_URL", "http://backend.fridayaicore.in")
+DEFAULT_TIMEOUT = 30
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_RETRY_DELAY = 1.0
+
+API_VERSION = "v1"
+USER_AGENT = "acl-layer-py/1.2.0"
+
+# API Endpoints
+ENDPOINTS = {
+    "analyze": "/v1/analyze",
+    "adaptive_window": f"/api/{API_VERSION}/adaptive/window",
+    "health": f"/api/{API_VERSION}/health",
+    "batch": f"/api/{API_VERSION}/adaptive/batch",
+    "events_log": f"/api/{API_VERSION}/events/log",
+}
+
+# Headers
+REQUEST_ID_HEADER = "X-ACL-Request-ID"
+API_KEY_HEADER = "Authorization"
+
+# Error mapping from HTTP status codes to SDK exceptions
+HTTP_ERROR_MAP = {
+    401: "ACLAuthError",
+    403: "ACLPermissionError",
+    429: "ACLRateLimitError",
+}
+
+
+class ACLConfiguration:
+    """Configuration class for ACL SDK client."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        timeout_ms: Optional[int] = None,
+    ):
+        self.api_key = api_key
+        # Phase 2 — Production default (https://acl.fridayaicore.in)
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout_ms = timeout_ms or (DEFAULT_TIMEOUT * 1000)
+
+    def get_base_url(self) -> str:
+        """Get the base URL for ACL API."""
+        return self.base_url
+
+    def get_headers(self) -> Dict[str, str]:
+        """Get default headers for ACL API requests."""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "X-API-Key": self.api_key,
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT,
+        }
+
+
+# Default request parameters
+DEFAULT_REQUEST_PARAMS = {
+    "semantic_strictness": 0.23,
+}