jaf-py 2.2.1__tar.gz → 2.2.3__tar.gz

{jaf_py-2.2.1/jaf_py.egg-info → jaf_py-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.2.1
+Version: 2.2.3
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -110,6 +110,7 @@ A purely functional agent framework with immutable state and composable tools, p
 - ✅ **Output Guardrails**: Response sanitization
 - ✅ **Permission System**: Role-based access control
 - ✅ **Audit Logging**: Complete interaction tracing
+- ✅ **Proxy Support**: Corporate proxy integration with authentication
 
 ### 📊 **Observability & Monitoring**
 - ✅ **Real-time Tracing**: Event-driven observability

{jaf_py-2.2.1 → jaf_py-2.2.3}/README.md

@@ -39,6 +39,7 @@ A purely functional agent framework with immutable state and composable tools, p
 - ✅ **Output Guardrails**: Response sanitization
 - ✅ **Permission System**: Role-based access control
 - ✅ **Audit Logging**: Complete interaction tracing
+- ✅ **Proxy Support**: Corporate proxy integration with authentication
 
 ### 📊 **Observability & Monitoring**
 - ✅ **Real-time Tracing**: Event-driven observability

{jaf_py-2.2.1 → jaf_py-2.2.3}/jaf/core/__init__.py

@@ -13,6 +13,7 @@ from .agent_tool import (
     get_current_run_config,
     set_current_run_config,
 )
+from .proxy import ProxyConfig, ProxyAuth, create_proxy_config, get_default_proxy_config
 
 __all__ = [
     "Agent",
@@ -22,6 +23,8 @@ __all__ = [
     "Message",
     "ModelConfig",
     "ModelProvider",
+    "ProxyAuth",
+    "ProxyConfig",
     "RunConfig",
     "RunId",
     "RunResult",
@@ -39,9 +42,11 @@ __all__ = [
     "create_conditional_enabler",
     "create_default_output_extractor",
     "create_json_output_extractor",
+    "create_proxy_config",
     "create_run_id",
     "create_trace_id",
     "get_current_run_config",
+    "get_default_proxy_config",
     "require_permissions",
     "run",
     "set_current_run_config",

{jaf_py-2.2.1 → jaf_py-2.2.3}/jaf/core/engine.py

@@ -631,7 +631,7 @@ async def _execute_tool_calls(
                     result=result_string,
                     trace_id=state.trace_id,
                     run_id=state.run_id,
-                    tool_result=tool_result_obj,
+                    tool_result=tool_result,
                     status='success'
                 ))))
 

jaf_py-2.2.3/jaf/core/proxy.py

@@ -0,0 +1,141 @@
+"""
+Proxy configuration for JAF agents and HTTP clients.
+
+This module provides unified proxy configuration that can be used across
+different HTTP clients (httpx, OpenAI, etc.) in the JAF framework.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, Union
+from urllib.parse import urlparse
+
+
+@dataclass
+class ProxyAuth:
+    """Proxy authentication configuration."""
+    username: str
+    password: str
+
+
+@dataclass
+class ProxyConfig:
+    """Proxy configuration for HTTP clients."""
+    http_proxy: Optional[str] = None
+    https_proxy: Optional[str] = None
+    no_proxy: Optional[str] = None
+    auth: Optional[ProxyAuth] = None
+    
+    @classmethod
+    def from_environment(cls) -> 'ProxyConfig':
+        """Create proxy configuration from environment variables."""
+        return cls(
+            http_proxy=os.getenv('HTTP_PROXY') or os.getenv('http_proxy'),
+            https_proxy=os.getenv('HTTPS_PROXY') or os.getenv('https_proxy'),
+            no_proxy=os.getenv('NO_PROXY') or os.getenv('no_proxy'),
+            auth=ProxyAuth(
+                username=os.getenv('PROXY_USERNAME', ''),
+                password=os.getenv('PROXY_PASSWORD', '')
+            ) if os.getenv('PROXY_USERNAME') else None
+        )
+    
+    @classmethod
+    def from_url(cls, proxy_url: str, auth: Optional[ProxyAuth] = None) -> 'ProxyConfig':
+        """Create proxy configuration from a single URL."""
+        return cls(
+            http_proxy=proxy_url,
+            https_proxy=proxy_url,
+            auth=auth
+        )
+    
+    def to_httpx_proxies(self) -> Optional[Dict[str, str]]:
+        """Convert to httpx proxies format."""
+        if not self.http_proxy and not self.https_proxy:
+            return None
+        
+        proxies = {}
+        
+        if self.http_proxy:
+            proxies['http://'] = self._add_auth_to_url(self.http_proxy)
+        
+        if self.https_proxy:
+            proxies['https://'] = self._add_auth_to_url(self.https_proxy)
+        
+        return proxies if proxies else None
+    
+    def to_openai_proxies(self) -> Optional[Dict[str, str]]:
+        """Convert to OpenAI client proxies format."""
+        # OpenAI client supports httpx-style proxy configuration
+        return self.to_httpx_proxies()
+    
+    def _add_auth_to_url(self, url: str) -> str:
+        """Add authentication to proxy URL if configured."""
+        if not self.auth or not self.auth.username:
+            return url
+        
+        parsed = urlparse(url)
+        
+        # If URL already has auth, don't override
+        if '@' in parsed.netloc:
+            return url
+        
+        auth_string = f"{self.auth.username}:{self.auth.password}"
+        
+        # Reconstruct URL with auth
+        if parsed.port:
+            netloc = f"{auth_string}@{parsed.hostname}:{parsed.port}"
+        else:
+            netloc = f"{auth_string}@{parsed.hostname}"
+        
+        return f"{parsed.scheme}://{netloc}{parsed.path}"
+    
+    def should_bypass_proxy(self, host: str) -> bool:
+        """Check if a host should bypass the proxy based on no_proxy settings."""
+        if not self.no_proxy:
+            return False
+        
+        no_proxy_hosts = [h.strip() for h in self.no_proxy.split(',')]
+        
+        for no_proxy_host in no_proxy_hosts:
+            if not no_proxy_host:
+                continue
+            
+            # Exact match
+            if host == no_proxy_host:
+                return True
+            
+            # Wildcard match (e.g., *.example.com)
+            if no_proxy_host.startswith('*'):
+                suffix = no_proxy_host[1:]
+                if host.endswith(suffix):
+                    return True
+            
+            # Domain suffix match
+            if no_proxy_host.startswith('.'):
+                if host.endswith(no_proxy_host) or host == no_proxy_host[1:]:
+                    return True
+        
+        return False
+
+
+def create_proxy_config(
+    proxy_url: Optional[str] = None,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    no_proxy: Optional[str] = None
+) -> ProxyConfig:
+    """Create a proxy configuration with optional parameters."""
+    auth = ProxyAuth(username, password) if username else None
+    
+    if proxy_url:
+        config = ProxyConfig.from_url(proxy_url, auth)
+        if no_proxy:
+            config.no_proxy = no_proxy
+        return config
+    
+    return ProxyConfig.from_environment()
+
+
+def get_default_proxy_config() -> ProxyConfig:
+    """Get the default proxy configuration from environment variables."""
+    return ProxyConfig.from_environment()

jaf_py-2.2.3/jaf/core/proxy_helpers.py

@@ -0,0 +1,126 @@
+"""
+Helper functions for creating JAF core components with proxy support.
+
+This module provides convenience functions to easily create model providers
+with proxy configuration.
+"""
+
+from typing import Optional, Dict, Any
+from .proxy import ProxyConfig, get_default_proxy_config
+from ..providers.model import make_litellm_provider
+
+
+def make_proxy_enabled_litellm_provider(
+    base_url: str,
+    api_key: str = "anything",
+    default_timeout: Optional[float] = None,
+    proxy_url: Optional[str] = None,
+    proxy_username: Optional[str] = None,
+    proxy_password: Optional[str] = None,
+    use_env_proxy: bool = True
+):
+    """
+    Create a LiteLLM provider with proxy support.
+    
+    Args:
+        base_url: Base URL for the LiteLLM server
+        api_key: API key (defaults to "anything" for local servers)
+        default_timeout: Default timeout for model API calls in seconds
+        proxy_url: Proxy URL (if not using environment variables)
+        proxy_username: Proxy username for authentication
+        proxy_password: Proxy password for authentication
+        use_env_proxy: Whether to use proxy settings from environment variables
+        
+    Returns:
+        ModelProvider with proxy configuration
+    """
+    proxy_config = None
+    
+    if proxy_url:
+        # Use explicitly provided proxy settings
+        from .proxy import ProxyAuth, create_proxy_config
+        proxy_config = create_proxy_config(
+            proxy_url=proxy_url,
+            username=proxy_username,
+            password=proxy_password
+        )
+    elif use_env_proxy:
+        # Use environment-based proxy settings
+        proxy_config = get_default_proxy_config()
+        # Only use proxy if actually configured in environment
+        if not proxy_config.http_proxy and not proxy_config.https_proxy:
+            proxy_config = None
+    
+    return make_litellm_provider(
+        base_url=base_url,
+        api_key=api_key,
+        default_timeout=default_timeout,
+        proxy_config=proxy_config
+    )
+
+
+
+
+def get_proxy_info() -> Dict[str, Any]:
+    """
+    Get information about current proxy configuration from environment.
+    
+    Returns:
+        Dictionary with proxy configuration details
+    """
+    proxy_config = get_default_proxy_config()
+    
+    return {
+        "http_proxy": proxy_config.http_proxy,
+        "https_proxy": proxy_config.https_proxy,
+        "no_proxy": proxy_config.no_proxy,
+        "has_auth": proxy_config.auth is not None,
+        "auth_username": proxy_config.auth.username if proxy_config.auth else None,
+        "is_configured": bool(proxy_config.http_proxy or proxy_config.https_proxy)
+    }
+
+
+def validate_proxy_config(proxy_config: ProxyConfig) -> Dict[str, Any]:
+    """
+    Validate proxy configuration and return validation results.
+    
+    Args:
+        proxy_config: Proxy configuration to validate
+        
+    Returns:
+        Dictionary with validation results
+    """
+    results = {
+        "valid": True,
+        "warnings": [],
+        "errors": []
+    }
+    
+    # Check if at least one proxy is configured
+    if not proxy_config.http_proxy and not proxy_config.https_proxy:
+        results["warnings"].append("No proxy URLs configured")
+    
+    # Validate proxy URLs if configured
+    for proxy_type, proxy_url in [("HTTP", proxy_config.http_proxy), ("HTTPS", proxy_config.https_proxy)]:
+        if proxy_url:
+            try:
+                from urllib.parse import urlparse
+                parsed = urlparse(proxy_url)
+                if not parsed.scheme:
+                    results["errors"].append(f"{proxy_type} proxy URL missing scheme: {proxy_url}")
+                    results["valid"] = False
+                if not parsed.netloc:
+                    results["errors"].append(f"{proxy_type} proxy URL missing host: {proxy_url}")
+                    results["valid"] = False
+            except Exception as e:
+                results["errors"].append(f"Invalid {proxy_type} proxy URL: {e}")
+                results["valid"] = False
+    
+    # Check authentication consistency
+    if proxy_config.auth:
+        if not proxy_config.auth.username:
+            results["warnings"].append("Proxy authentication configured but username is empty")
+        if not proxy_config.auth.password:
+            results["warnings"].append("Proxy authentication configured but password is empty")
+    
+    return results

{jaf_py-2.2.1 → jaf_py-2.2.3}/jaf/providers/model.py

@@ -6,18 +6,21 @@ starting with LiteLLM for multi-provider support.
 """
 
 from typing import Any, Dict, Optional, TypeVar
+import httpx
 
 from openai import OpenAI
 from pydantic import BaseModel
 
 from ..core.types import Agent, ContentRole, Message, ModelProvider, RunConfig, RunState
+from ..core.proxy import ProxyConfig
 
 Ctx = TypeVar('Ctx')
 
 def make_litellm_provider(
     base_url: str,
     api_key: str = "anything",
-    default_timeout: Optional[float] = None
+    default_timeout: Optional[float] = None,
+    proxy_config: Optional[ProxyConfig] = None
 ) -> ModelProvider[Ctx]:
     """
     Create a LiteLLM-compatible model provider.
@@ -26,6 +29,7 @@ def make_litellm_provider(
         base_url: Base URL for the LiteLLM server
         api_key: API key (defaults to "anything" for local servers)
         default_timeout: Default timeout for model API calls in seconds
+        proxy_config: Optional proxy configuration
         
     Returns:
         ModelProvider instance
@@ -35,11 +39,25 @@ def make_litellm_provider(
         def __init__(self):
             # Default to "anything" if api_key is not provided, for local servers
             effective_api_key = api_key if api_key is not None else "anything"
-            self.client = OpenAI(
-                base_url=base_url,
-                api_key=effective_api_key,
-                # Note: dangerouslyAllowBrowser is JavaScript-specific
-            )
+            
+            # Configure HTTP client with proxy support
+            client_kwargs = {
+                "base_url": base_url,
+                "api_key": effective_api_key,
+            }
+            
+            if proxy_config:
+                proxies = proxy_config.to_httpx_proxies()
+                if proxies:
+                    # Create httpx client with proxy configuration
+                    try:
+                        http_client = httpx.Client(proxies=proxies)
+                        client_kwargs["http_client"] = http_client
+                    except Exception as e:
+                        print(f"Warning: Could not configure proxy: {e}")
+                        # Fall back to environment variables for proxy
+            
+            self.client = OpenAI(**client_kwargs)
             self.default_timeout = default_timeout
 
         async def get_completion(

{jaf_py-2.2.1 → jaf_py-2.2.3/jaf_py.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.2.1
+Version: 2.2.3
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -110,6 +110,7 @@ A purely functional agent framework with immutable state and composable tools, p
 - ✅ **Output Guardrails**: Response sanitization
 - ✅ **Permission System**: Role-based access control
 - ✅ **Audit Logging**: Complete interaction tracing
+- ✅ **Proxy Support**: Corporate proxy integration with authentication
 
 ### 📊 **Observability & Monitoring**
 - ✅ **Real-time Tracing**: Event-driven observability

{jaf_py-2.2.1 → jaf_py-2.2.3}/jaf_py.egg-info/SOURCES.txt

@@ -49,6 +49,8 @@ jaf/core/composition.py
 jaf/core/engine.py
 jaf/core/errors.py
 jaf/core/performance.py
+jaf/core/proxy.py
+jaf/core/proxy_helpers.py
 jaf/core/streaming.py
 jaf/core/tool_results.py
 jaf/core/tools.py
@@ -107,6 +109,7 @@ tests/test_mcp_transports.py
 tests/test_memory_system_examples.py
 tests/test_model_providers_examples.py
 tests/test_property_based.py
+tests/test_proxy_simple.py
 tests/test_redis_fixes.py
 tests/test_redis_memory.py
 tests/test_server_api_examples.py

{jaf_py-2.2.1 → jaf_py-2.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jaf-py"
-version = "2.2.1"
+version = "2.2.3"
 description = "A purely functional agent framework with immutable state and composable tools - Python implementation"
 readme = "README.md"
 license = "MIT"

jaf_py-2.2.3/tests/test_proxy_simple.py

@@ -0,0 +1,117 @@
+"""
+Simple proxy configuration test for JAF.
+
+This script tests basic proxy configuration without making actual LLM calls.
+Use this to verify proxy settings are loaded correctly.
+"""
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# Add the jaf package to the path
+sys.path.insert(0, '/Users/yash.gupta/check/jaf-py')
+
+from jaf.core import ProxyConfig, ProxyAuth, get_default_proxy_config
+from jaf.core.proxy_helpers import get_proxy_info, validate_proxy_config
+
+
+def main():
+    """Test proxy configuration loading and validation."""
+    print("=== JAF Proxy Configuration Test ===\n")
+    
+    # Load .env if it exists
+    if os.path.exists('.env'):
+        load_dotenv('.env')
+        print("✓ Loaded .env file\n")
+    else:
+        print("ℹ No .env file found, using system environment\n")
+    
+    # Test 1: Get proxy info
+    print("1. Current proxy configuration:")
+    proxy_info = get_proxy_info()
+    for key, value in proxy_info.items():
+        print(f"   {key}: {value}")
+    print()
+    
+    # Test 2: Get default proxy config
+    print("2. Default proxy config from environment:")
+    proxy_config = get_default_proxy_config()
+    print(f"   HTTP Proxy: {proxy_config.http_proxy}")
+    print(f"   HTTPS Proxy: {proxy_config.https_proxy}")
+    print(f"   No Proxy: {proxy_config.no_proxy}")
+    print(f"   Has Auth: {proxy_config.auth is not None}")
+    if proxy_config.auth:
+        print(f"   Auth Username: {proxy_config.auth.username}")
+        print(f"   Auth Password: {'*' * len(proxy_config.auth.password) if proxy_config.auth.password else 'None'}")
+    print()
+    
+    # Test 3: Validate proxy config
+    print("3. Proxy configuration validation:")
+    validation = validate_proxy_config(proxy_config)
+    print(f"   Valid: {validation['valid']}")
+    if validation['warnings']:
+        print("   Warnings:")
+        for warning in validation['warnings']:
+            print(f"     - {warning}")
+    if validation['errors']:
+        print("   Errors:")
+        for error in validation['errors']:
+            print(f"     - {error}")
+    print()
+    
+    # Test 4: HTTP client format conversion
+    print("4. HTTP client format conversion:")
+    if proxy_config.http_proxy or proxy_config.https_proxy:
+        httpx_proxies = proxy_config.to_httpx_proxies()
+        openai_proxies = proxy_config.to_openai_proxies()
+        print(f"   HTTPX format: {httpx_proxies}")
+        print(f"   OpenAI format: {openai_proxies}")
+    else:
+        print("   No proxy configured for conversion")
+    print()
+    
+    # Test 5: Proxy bypass logic
+    print("5. Proxy bypass test:")
+    test_hosts = ["localhost", "127.0.0.1", "api.openai.com", "internal.local"]
+    for host in test_hosts:
+        bypass = proxy_config.should_bypass_proxy(host)
+        status = "BYPASS" if bypass else "USE PROXY"
+        print(f"   {host}: {status}")
+    print()
+    
+    # Test 6: Manual proxy creation
+    print("6. Manual proxy configuration test:")
+    try:
+        manual_proxy = ProxyConfig(
+            http_proxy="http://test-proxy.example.com:8080",
+            https_proxy="http://test-proxy.example.com:8080",
+            no_proxy="localhost,*.local",
+            auth=ProxyAuth(username="testuser", password="testpass")
+        )
+        manual_validation = validate_proxy_config(manual_proxy)
+        print(f"   Manual config valid: {manual_validation['valid']}")
+        print(f"   Manual config HTTPX: {manual_proxy.to_httpx_proxies()}")
+    except Exception as e:
+        print(f"   Error creating manual config: {e}")
+    print()
+    
+    print("=== Configuration Summary ===")
+    if proxy_info['is_configured']:
+        print("✓ Proxy is configured and ready to use")
+        print(f"  HTTP: {proxy_info['http_proxy']}")
+        print(f"  HTTPS: {proxy_info['https_proxy']}")
+        print(f"  Auth: {'Yes' if proxy_info['has_auth'] else 'No'}")
+    else:
+        print("ℹ No proxy configured (will use direct connections)")
+    
+    print("\nTo configure proxy, set environment variables or create .env file:")
+    print("  HTTP_PROXY=http://proxy.example.com:8080")
+    print("  HTTPS_PROXY=http://proxy.example.com:8080") 
+    print("  PROXY_USERNAME=username (optional)")
+    print("  PROXY_PASSWORD=password (optional)")
+    print("  NO_PROXY=localhost,127.0.0.1,*.local (optional)")
+
+
+if __name__ == "__main__":
+    main()