jaf-py 2.4.5__py3-none-any.whl → 2.4.7__py3-none-any.whl

jaf/core/types.py

@@ -288,6 +288,7 @@ class Agent(Generic[Ctx, Out]):
     output_codec: Optional[Any] = None  # Type that can validate Out (like Pydantic model or Zod equivalent)
     handoffs: Optional[List[str]] = None
     model_config: Optional[ModelConfig] = None
+    advanced_config: Optional['AdvancedConfig'] = None
 
     def as_tool(
         self,
@@ -331,6 +332,74 @@ class Agent(Generic[Ctx, Out]):
 # Guardrail type
 Guardrail = Callable[[Any], Union[ValidationResult, Awaitable[ValidationResult]]]
 
+@dataclass(frozen=True)
+class AdvancedGuardrailsConfig:
+    """Configuration for advanced guardrails with LLM-based validation."""
+    input_prompt: Optional[str] = None
+    output_prompt: Optional[str] = None
+    require_citations: bool = False
+    fast_model: Optional[str] = None
+    fail_safe: Literal['allow', 'block'] = 'allow'
+    execution_mode: Literal['parallel', 'sequential'] = 'parallel'
+    timeout_ms: int = 30000
+
+    def __post_init__(self):
+        """Validate configuration."""
+        if self.timeout_ms < 1000:
+            object.__setattr__(self, 'timeout_ms', 1000)
+
+@dataclass(frozen=True)
+class AdvancedConfig:
+    """Advanced agent configuration including guardrails."""
+    guardrails: Optional[AdvancedGuardrailsConfig] = None
+
+def validate_guardrails_config(config: Optional[AdvancedGuardrailsConfig]) -> AdvancedGuardrailsConfig:
+    """Validate and provide defaults for guardrails configuration."""
+    if config is None:
+        return AdvancedGuardrailsConfig()
+    
+    return AdvancedGuardrailsConfig(
+        input_prompt=config.input_prompt.strip() if isinstance(config.input_prompt, str) and config.input_prompt else None,
+        output_prompt=config.output_prompt.strip() if isinstance(config.output_prompt, str) and config.output_prompt else None,
+        require_citations=config.require_citations,
+        fast_model=config.fast_model.strip() if isinstance(config.fast_model, str) and config.fast_model else None,
+        fail_safe=config.fail_safe,
+        execution_mode=config.execution_mode,
+        timeout_ms=max(1000, config.timeout_ms)
+    )
+
+def json_parse_llm_output(text: str) -> Optional[Dict[str, Any]]:
+    """Parse JSON from LLM output, handling common formatting issues."""
+    import json
+    import re
+    
+    if not text:
+        return None
+    
+    # Try direct parsing first
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        pass
+    
+    # Try to extract JSON from markdown code blocks
+    json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL)
+    if json_match:
+        try:
+            return json.loads(json_match.group(1))
+        except json.JSONDecodeError:
+            pass
+    
+    # Try to find the first JSON object in the text
+    json_match = re.search(r'\{.*?\}', text, re.DOTALL)
+    if json_match:
+        try:
+            return json.loads(json_match.group(0))
+        except json.JSONDecodeError:
+            pass
+    
+    return None
+
 @dataclass(frozen=True)
 class ApprovalValue:
     """Represents an approval decision with context."""
@@ -600,6 +669,17 @@ class GuardrailEvent:
     type: Literal['guardrail_check'] = 'guardrail_check'
     data: GuardrailEventData = field(default_factory=lambda: GuardrailEventData(""))
 
+@dataclass(frozen=True)
+class GuardrailViolationEventData:
+    """Data for guardrail violation events."""
+    stage: Literal['input', 'output']
+    reason: str
+
+@dataclass(frozen=True)
+class GuardrailViolationEvent:
+    type: Literal['guardrail_violation'] = 'guardrail_violation'
+    data: GuardrailViolationEventData = field(default_factory=lambda: GuardrailViolationEventData("input", ""))
+
 @dataclass(frozen=True)
 class MemoryEventData:
     """Data for memory operation events."""
@@ -632,6 +712,7 @@ class OutputParseEvent:
 TraceEvent = Union[
     RunStartEvent,
     GuardrailEvent,
+    GuardrailViolationEvent,
     MemoryEvent,
     OutputParseEvent,
     LLMCallStartEvent,
@@ -710,7 +791,8 @@ class RunConfig(Generic[Ctx]):
     initial_input_guardrails: Optional[List[Guardrail]] = None
     final_output_guardrails: Optional[List[Guardrail]] = None
     on_event: Optional[Callable[[TraceEvent], None]] = None
-    memory: Optional['MemoryConfig'] = None
+    memory: Optional[Any] = None  # MemoryConfig - avoiding circular import
     conversation_id: Optional[str] = None
+    default_fast_model: Optional[str] = None  # Default model for fast operations like guardrails
     default_tool_timeout: Optional[float] = 300.0  # Default timeout for tool execution in seconds
     approval_storage: Optional['ApprovalStorage'] = None  # Storage for approval decisions

jaf/providers/__init__.py

@@ -7,7 +7,7 @@ from .mcp import (
     create_mcp_sse_tools,
     create_mcp_http_tools,
 )
-from .model import make_litellm_provider
+from .model import make_litellm_provider, make_litellm_sdk_provider
 
 # Back-compat for renamed/removed exports (do not add to __all__)
 import warnings as _warnings
@@ -57,4 +57,5 @@ __all__ = [
     "create_mcp_sse_tools",
     "create_mcp_http_tools",
     "make_litellm_provider",
+    "make_litellm_sdk_provider",
 ]

jaf/providers/model.py

@@ -14,6 +14,7 @@ import base64
 
 from openai import OpenAI
 from pydantic import BaseModel
+import litellm
 
 from ..core.types import (
     Agent, ContentRole, Message, ModelProvider, RunConfig, RunState, 
@@ -445,9 +446,327 @@ def make_litellm_provider(
 
     return LiteLLMProvider()
 
+def make_litellm_sdk_provider(
+    api_key: Optional[str] = None,
+    model: str = "gpt-3.5-turbo",
+    base_url: Optional[str] = None,
+    default_timeout: Optional[float] = None,
+    **litellm_kwargs: Any
+) -> ModelProvider[Ctx]:
+    """
+    Create a LiteLLM SDK-based model provider with universal provider support.
+    
+    LiteLLM automatically detects the provider from the model name and handles
+    API key management through environment variables or direct parameters.
+    
+    Args:
+        api_key: API key for the provider (optional, can use env vars)
+        model: Model name (e.g., "gpt-4", "claude-3-sonnet", "gemini-pro", "llama2", etc.)
+        base_url: Optional base URL for custom endpoints
+        default_timeout: Default timeout for model API calls in seconds
+        **litellm_kwargs: Additional arguments passed to litellm.completion()
+                         Common examples:
+                         - vertex_project: "your-project" (for Google models)
+                         - vertex_location: "us-central1" (for Google models)
+                         - azure_deployment: "your-deployment" (for Azure OpenAI)
+                         - api_base: "https://your-endpoint.com" (custom endpoint)
+                         - custom_llm_provider: "custom_provider_name"
+        
+    Returns:
+        ModelProvider instance
+        
+    Examples:
+        # OpenAI
+        make_litellm_sdk_provider(api_key="sk-...", model="gpt-4")
+        
+        # Anthropic Claude
+        make_litellm_sdk_provider(api_key="sk-ant-...", model="claude-3-sonnet-20240229")
+        
+        # Google Gemini
+        make_litellm_sdk_provider(model="gemini-pro", vertex_project="my-project")
+        
+        # Ollama (local)
+        make_litellm_sdk_provider(model="ollama/llama2", base_url="http://localhost:11434")
+        
+        # Azure OpenAI
+        make_litellm_sdk_provider(
+            model="azure/gpt-4",
+            api_key="your-azure-key",
+            azure_deployment="gpt-4-deployment",
+            api_base="https://your-resource.openai.azure.com"
+        )
+        
+        # Hugging Face
+        make_litellm_sdk_provider(
+            model="huggingface/microsoft/DialoGPT-medium",
+            api_key="hf_..."
+        )
+        
+        # Any custom provider
+        make_litellm_sdk_provider(
+            model="custom_provider/model-name",
+            api_key="your-key",
+            custom_llm_provider="your_provider"
+        )
+    """
+
+    class LiteLLMSDKProvider:
+        def __init__(self):
+            self.api_key = api_key
+            self.model = model
+            self.base_url = base_url
+            self.default_timeout = default_timeout
+            self.litellm_kwargs = litellm_kwargs
+
+        async def get_completion(
+            self,
+            state: RunState[Ctx],
+            agent: Agent[Ctx, Any],
+            config: RunConfig[Ctx]
+        ) -> Dict[str, Any]:
+            """Get completion from the model using LiteLLM SDK."""
+
+            # Determine model to use
+            model_name = config.model_override or self.model
+
+            # Create system message
+            system_message = {
+                "role": "system",
+                "content": agent.instructions(state)
+            }
+
+            # Convert messages to OpenAI format
+            messages = [system_message]
+            for msg in state.messages:
+                converted_msg = await _convert_message(msg)
+                messages.append(converted_msg)
+
+            # Convert tools to OpenAI format
+            tools = None
+            if agent.tools:
+                tools = [
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool.schema.name,
+                            "description": tool.schema.description,
+                            "parameters": _pydantic_to_json_schema(tool.schema.parameters),
+                        }
+                    }
+                    for tool in agent.tools
+                ]
+
+            # Prepare request parameters for LiteLLM
+            request_params = {
+                "model": model_name,
+                "messages": messages,
+                **self.litellm_kwargs
+            }
+
+            # Add API key if provided
+            if self.api_key:
+                request_params["api_key"] = self.api_key
+
+            # Add optional parameters
+            if agent.model_config:
+                if agent.model_config.temperature is not None:
+                    request_params["temperature"] = agent.model_config.temperature
+                if agent.model_config.max_tokens is not None:
+                    request_params["max_tokens"] = agent.model_config.max_tokens
+
+            if tools:
+                request_params["tools"] = tools
+                request_params["tool_choice"] = "auto"
+
+            if agent.output_codec:
+                request_params["response_format"] = {"type": "json_object"}
+
+            # LiteLLM will use api_base from kwargs or base_url parameter
+            if self.base_url:
+                request_params["api_base"] = self.base_url
+
+            # Make the API call using litellm
+            response = await litellm.acompletion(**request_params)
+
+            # Return in the expected format that the engine expects
+            choice = response.choices[0]
+
+            # Convert tool_calls to dict format if present
+            tool_calls = None
+            if choice.message.tool_calls:
+                tool_calls = [
+                    {
+                        'id': tc.id,
+                        'type': tc.type,
+                        'function': {
+                            'name': tc.function.name,
+                            'arguments': tc.function.arguments
+                        }
+                    }
+                    for tc in choice.message.tool_calls
+                ]
+
+            # Extract usage data
+            usage_data = None
+            if response.usage:
+                usage_data = {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens,
+                }
+
+            return {
+                'id': response.id,
+                'created': response.created,
+                'model': response.model,
+                'system_fingerprint': getattr(response, 'system_fingerprint', None),
+                'message': {
+                    'content': choice.message.content,
+                    'tool_calls': tool_calls
+                },
+                'usage': usage_data,
+                'prompt': messages
+            }
+
+        async def get_completion_stream(
+            self,
+            state: RunState[Ctx],
+            agent: Agent[Ctx, Any],
+            config: RunConfig[Ctx]
+        ) -> AsyncIterator[CompletionStreamChunk]:
+            """
+            Stream completion chunks from the model provider using LiteLLM SDK.
+            """
+            # Determine model to use
+            model_name = config.model_override or self.model
+
+            # Create system message
+            system_message = {
+                "role": "system",
+                "content": agent.instructions(state)
+            }
+
+            # Convert messages to OpenAI format
+            messages = [system_message]
+            for msg in state.messages:
+                converted_msg = await _convert_message(msg)
+                messages.append(converted_msg)
+
+            # Convert tools to OpenAI format
+            tools = None
+            if agent.tools:
+                tools = [
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool.schema.name,
+                            "description": tool.schema.description,
+                            "parameters": _pydantic_to_json_schema(tool.schema.parameters),
+                        }
+                    }
+                    for tool in agent.tools
+                ]
+
+            # Prepare request parameters for LiteLLM streaming
+            request_params: Dict[str, Any] = {
+                "model": model_name,
+                "messages": messages,
+                "stream": True,
+                **self.litellm_kwargs
+            }
+
+            # Add API key if provided
+            if self.api_key:
+                request_params["api_key"] = self.api_key
+
+            # Add optional parameters
+            if agent.model_config:
+                if agent.model_config.temperature is not None:
+                    request_params["temperature"] = agent.model_config.temperature
+                if agent.model_config.max_tokens is not None:
+                    request_params["max_tokens"] = agent.model_config.max_tokens
+
+            if tools:
+                request_params["tools"] = tools
+                request_params["tool_choice"] = "auto"
+
+            if agent.output_codec:
+                request_params["response_format"] = {"type": "json_object"}
+
+            # LiteLLM will use api_base from kwargs or base_url parameter
+            if self.base_url:
+                request_params["api_base"] = self.base_url
+
+            # Stream using litellm
+            stream = await litellm.acompletion(**request_params)
+            
+            async for chunk in stream:
+                try:
+                    # Best-effort extraction of raw for debugging
+                    try:
+                        raw_obj = chunk.model_dump() if hasattr(chunk, 'model_dump') else None
+                    except Exception:
+                        raw_obj = None
+
+                    choice = None
+                    if getattr(chunk, "choices", None):
+                        choice = chunk.choices[0]
+
+                    if choice is None:
+                        continue
+
+                    delta = getattr(choice, "delta", None)
+                    finish_reason = getattr(choice, "finish_reason", None)
+
+                    # Text content delta
+                    if delta is not None:
+                        content_delta = getattr(delta, "content", None)
+                        if content_delta:
+                            yield CompletionStreamChunk(delta=content_delta, raw=raw_obj)
+
+                        # Tool call deltas
+                        tool_calls = getattr(delta, "tool_calls", None)
+                        if isinstance(tool_calls, list):
+                            for tc in tool_calls:
+                                try:
+                                    idx = getattr(tc, "index", 0) or 0
+                                    tc_id = getattr(tc, "id", None)
+                                    fn = getattr(tc, "function", None)
+                                    fn_name = getattr(fn, "name", None) if fn is not None else None
+                                    args_delta = getattr(fn, "arguments", None) if fn is not None else None
+
+                                    yield CompletionStreamChunk(
+                                        tool_call_delta=ToolCallDelta(
+                                            index=idx,
+                                            id=tc_id,
+                                            type='function',
+                                            function=ToolCallFunctionDelta(
+                                                name=fn_name,
+                                                arguments_delta=args_delta
+                                            )
+                                        ),
+                                        raw=raw_obj
+                                    )
+                                except Exception:
+                                    continue
+
+                    # Completion ended
+                    if finish_reason:
+                        yield CompletionStreamChunk(is_done=True, finish_reason=finish_reason, raw=raw_obj)
+                except Exception:
+                    continue
+
+    return LiteLLMSDKProvider()
+
 async def _convert_message(msg: Message) -> Dict[str, Any]:
-    """Convert JAF Message to OpenAI message format with attachment support."""
-    if msg.role == 'user':
+    """
+    Handles all possible role types (string and enum) and content formats.
+    """
+    # Normalize role to handle both string and enum values
+    role_value = msg.role.value if hasattr(msg.role, 'value') else str(msg.role).lower()
+
+    # Handle user messages
+    if role_value in ('user', ContentRole.USER.value if hasattr(ContentRole, 'USER') else 'user'):
         if isinstance(msg.content, list):
             # Multi-part content
             return {
@@ -457,12 +776,16 @@ async def _convert_message(msg: Message) -> Dict[str, Any]:
         else:
             # Build message with attachments if available
             return await _build_chat_message_with_attachments('user', msg)
-    elif msg.role == 'assistant':
+
+    # Handle assistant messages
+    elif role_value in ('assistant', ContentRole.ASSISTANT.value if hasattr(ContentRole, 'ASSISTANT') else 'assistant'):
         result = {
             "role": "assistant",
-            "content": get_text_content(msg.content),
+            "content": get_text_content(msg.content) or "",  # Ensure content is never None
         }
-        if msg.tool_calls:
+
+        # Add tool calls if present
+        if msg.tool_calls and len(msg.tool_calls) > 0:
             result["tool_calls"] = [
                 {
                     "id": tc.id,
@@ -473,16 +796,48 @@ async def _convert_message(msg: Message) -> Dict[str, Any]:
                     }
                 }
                 for tc in msg.tool_calls
+                if tc.id and tc.function and tc.function.name  # Validate tool call structure
             ]
+
         return result
-    elif msg.role == ContentRole.TOOL:
+
+    # Handle system messages
+    elif role_value in ('system', ContentRole.SYSTEM.value if hasattr(ContentRole, 'SYSTEM') else 'system'):
+        return {
+            "role": "system",
+            "content": get_text_content(msg.content) or ""
+        }
+
+    # Handle tool messages
+    elif role_value in ('tool', ContentRole.TOOL.value if hasattr(ContentRole, 'TOOL') else 'tool'):
+        if not msg.tool_call_id:
+            raise ValueError(f"Tool message must have tool_call_id. Message: {msg}")
+
         return {
             "role": "tool",
-            "content": get_text_content(msg.content),
+            "content": get_text_content(msg.content) or "",
             "tool_call_id": msg.tool_call_id
         }
+
+    # Handle function messages (legacy support)
+    elif role_value == 'function':
+        if not msg.tool_call_id:
+            raise ValueError(f"Function message must have tool_call_id. Message: {msg}")
+
+        return {
+            "role": "function",
+            "content": get_text_content(msg.content) or "",
+            "name": getattr(msg, 'name', 'unknown_function')
+        }
+
+    # Unknown role - provide helpful error message
     else:
-        raise ValueError(f"Unknown message role: {msg.role}")
+        available_roles = ['user', 'assistant', 'system', 'tool', 'function']
+        raise ValueError(
+            f"Unknown message role: {msg.role} (type: {type(msg.role)}). "
+            f"Supported roles: {available_roles}. "
+            f"Message content: {get_text_content(msg.content)[:100] if msg.content else 'None'}"
+        )
 
 
 def _convert_content_part(part: MessageContentPart) -> Dict[str, Any]:

{jaf_py-2.4.5.dist-info → jaf_py-2.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.4.5
+Version: 2.4.7
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -43,6 +43,7 @@ Requires-Dist: opentelemetry-api>=1.22.0
 Requires-Dist: opentelemetry-sdk>=1.22.0
 Requires-Dist: opentelemetry-exporter-otlp>=1.22.0
 Requires-Dist: langfuse<3.0.0
+Requires-Dist: litellm>=1.76.3
 Provides-Extra: tracing
 Requires-Dist: opentelemetry-api>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-sdk>=1.22.0; extra == "tracing"

{jaf_py-2.4.5.dist-info → jaf_py-2.4.7.dist-info}/RECORD

@@ -42,8 +42,9 @@ jaf/core/__init__.py,sha256=PIGKm8n6OQ8jcXRS0Hn3_Zsl8m2qX91N80YJoLCJ4eU,1762
 jaf/core/agent_tool.py,sha256=tfLNaTIcOZ0dR9GBP1AHLPkLExm_dLbURnVIN4R84FQ,11806
 jaf/core/analytics.py,sha256=zFHIWqWal0bbEFCmJDc4DKeM0Ja7b_D19PqVaBI12pA,23338
 jaf/core/composition.py,sha256=IVxRO1Q9nK7JRH32qQ4p8WMIUu66BhqPNrlTNMGFVwE,26317
-jaf/core/engine.py,sha256=bjHNn8MoE3o0BAuBCMBY3EjtpMckjWlBotJ-oinfSZ0,52111
+jaf/core/engine.py,sha256=7j8LRf52inRKN4gcCPNuXzoBKMr19S9VMyjrrb3Xlek,57406
 jaf/core/errors.py,sha256=5fwTNhkojKRQ4wZj3lZlgDnAsrYyjYOwXJkIr5EGNUc,5539
+jaf/core/guardrails.py,sha256=nv7pQuCx7-9DDZrecWO1DsDqFoujL81FBDrafOsXgcI,26179
 jaf/core/parallel_agents.py,sha256=ahwYoTnkrF4xQgV-hjc5sUaWhQWQFENMZG5riNa_Ieg,12165
 jaf/core/performance.py,sha256=jedQmTEkrKMD6_Aw1h8PdG-5TsdYSFFT7Or6k5dmN2g,9974
 jaf/core/proxy.py,sha256=_WM3cpRlSQLYpgSBrnY30UPMe2iZtlqDQ65kppE-WY0,4609
@@ -53,7 +54,7 @@ jaf/core/streaming.py,sha256=h_lYHQA9ee_D5QsDO9-Vhevgi7rFXPslPzd9605AJGo,17034
 jaf/core/tool_results.py,sha256=-bTOqOX02lMyslp5Z4Dmuhx0cLd5o7kgR88qK2HO_sw,11323
 jaf/core/tools.py,sha256=84N9A7QQ3xxcOs2eUUot3nmCnt5i7iZT9VwkuzuFBxQ,16274
 jaf/core/tracing.py,sha256=iuVgykFUSkoBjem1k6jdVLrhRZzJn-avyxc_6W9BXPI,40159
-jaf/core/types.py,sha256=8TA5cyNAc_rp5Tn-zmvt6rMi_0atRXbewpaiB5Ss7-g,23186
+jaf/core/types.py,sha256=FCc9uWTUS6P1iU-_RxJM7k-HNorsHM-0XHqwwaUGLkE,26267
 jaf/core/workflows.py,sha256=Ul-82gzjIXtkhnSMSPv-8igikjkMtW1EBo9yrfodtvI,26294
 jaf/memory/__init__.py,sha256=-L98xlvihurGAzF0DnXtkueDVvO_wV2XxxEwAWdAj50,1400
 jaf/memory/approval_storage.py,sha256=HHZ_b57kIthdR53QE5XNSII9xy1Cg-1cFUCSAZ8A4Rk,11083
@@ -69,9 +70,9 @@ jaf/plugins/base.py,sha256=clQohPxT19zj-AjRtDoevE26xS5-cm7qdUOW2VX2InY,12575
 jaf/policies/__init__.py,sha256=tfbUgIPMwMKvZsyDItP_zvbhGXGY5scKSo78LIomgDU,416
 jaf/policies/handoff.py,sha256=KJYYuL9T6v6DECRhnsS2Je6q4Aj9_zC5d_KBnvEnZNE,8318
 jaf/policies/validation.py,sha256=wn-7ynH10E5nk-_r1_kHIYHrBGmLX0EFr-FUTHrsxvc,10903
-jaf/providers/__init__.py,sha256=j_o-Rubr8d9tNYlFWb6fvzkxIBl3JKK_iabj9wTFia0,2114
+jaf/providers/__init__.py,sha256=lIbl1JvGrDhI9CzEk79N8yJNhf7ww_aWD-F40MnG3vY,2174
 jaf/providers/mcp.py,sha256=WxcC8gUFpDBBYyhorMcc1jHq3xMDMBtnwyRPthfL0S0,13074
-jaf/providers/model.py,sha256=NJTa-1k0EruDdLf2HS1ZdDpFJhHXzzfQyXAbJx9kZVc,25468
+jaf/providers/model.py,sha256=bN2Hhr0N3soZzMrCdJ1pJa4rvo80oedCphDPcNgrVMY,39336
 jaf/server/__init__.py,sha256=fMPnLZBRm6t3yQrr7-PnoHAQ8qj9o6Z1AJLM1M6bIS0,392
 jaf/server/main.py,sha256=CTb0ywbPIq9ELfay5MKChVR7BpIQOoEbPjPfpzo2aBQ,2152
 jaf/server/server.py,sha256=K8XKNyadP_YqkCRSK9jCVZh52d2_IbHp_jHkKzBeB9Q,38786
@@ -85,9 +86,9 @@ jaf/visualization/functional_core.py,sha256=zedMDZbvjuOugWwnh6SJ2stvRNQX1Hlkb9Ab
 jaf/visualization/graphviz.py,sha256=WTOM6UP72-lVKwI4_SAr5-GCC3ouckxHv88ypCDQWJ0,12056
 jaf/visualization/imperative_shell.py,sha256=GpMrAlMnLo2IQgyB2nardCz09vMvAzaYI46MyrvJ0i4,2593
 jaf/visualization/types.py,sha256=QQcbVeQJLuAOXk8ynd08DXIS-PVCnv3R-XVE9iAcglw,1389
-jaf_py-2.4.5.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
-jaf_py-2.4.5.dist-info/METADATA,sha256=9oUGQOOBTFoMdCVPfnyC9ucxrBXWzvporO5hDuDXkjA,27712
-jaf_py-2.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jaf_py-2.4.5.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
-jaf_py-2.4.5.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
-jaf_py-2.4.5.dist-info/RECORD,,
+jaf_py-2.4.7.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
+jaf_py-2.4.7.dist-info/METADATA,sha256=fBAZFR5TR6J-fDS-Rufo3G7Xw4vEr0_0dPRX-riLT0Q,27743
+jaf_py-2.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaf_py-2.4.7.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
+jaf_py-2.4.7.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
+jaf_py-2.4.7.dist-info/RECORD,,