jaf-py 2.5.4__py3-none-any.whl → 2.5.7__py3-none-any.whl

jaf/__init__.py

@@ -191,7 +191,7 @@ def generate_run_id() -> RunId:
     """Generate a new run ID."""
     return create_run_id(str(uuid.uuid4()))
 
-__version__ = "2.5.4"
+__version__ = "2.5.7"
 __all__ = [
     # Core types and functions
     "TraceId", "RunId", "ValidationResult", "Message", "ModelConfig",

jaf/core/engine.py

@@ -527,6 +527,17 @@ async def _run_internal(
         "gpt-4o"
     )
 
+    # Apply before_llm_call callback if provided
+    if config.before_llm_call:
+        if asyncio.iscoroutinefunction(config.before_llm_call):
+            state = await config.before_llm_call(state, current_agent)
+        else:
+            result = config.before_llm_call(state, current_agent)
+            if asyncio.iscoroutine(result):
+                state = await result
+            else:
+                state = result
+
     # Emit LLM call start event
     if config.on_event:
         config.on_event(LLMCallStartEvent(data=to_event_data(LLMCallStartEventData(
@@ -538,121 +549,160 @@ async def _run_internal(
             messages=state.messages
         ))))
 
-    # Get completion from model provider, prefer streaming if available
+    # Retry logic for empty LLM responses
     llm_response: Dict[str, Any]
     assistant_event_streamed = False
+    
+    for retry_attempt in range(config.max_empty_response_retries + 1):
+        # Get completion from model provider
+        # Check if streaming should be used based on configuration and availability
+        get_stream = getattr(config.model_provider, "get_completion_stream", None)
+        use_streaming = (config.prefer_streaming != False and callable(get_stream))
 
-    get_stream = getattr(config.model_provider, "get_completion_stream", None)
-    if callable(get_stream):
-        try:
-            aggregated_text = ""
-            # Working array of partial tool calls
-            partial_tool_calls: List[Dict[str, Any]] = []
-
-            async for chunk in get_stream(state, current_agent, config):  # type: ignore[arg-type]
-                # Text deltas
-                delta_text = getattr(chunk, "delta", None)
-                if delta_text:
-                    aggregated_text += delta_text
-
-                # Tool call deltas
-                tcd = getattr(chunk, "tool_call_delta", None)
-                if tcd is not None:
-                    idx = getattr(tcd, "index", 0) or 0
-                    # Ensure slot exists
-                    while len(partial_tool_calls) <= idx:
-                        partial_tool_calls.append({
-                            "id": None,
-                            "type": "function",
-                            "function": {"name": None, "arguments": ""}
-                        })
-                    target = partial_tool_calls[idx]
-                    # id
-                    tc_id = getattr(tcd, "id", None)
-                    if tc_id:
-                        target["id"] = tc_id
-                    # function fields
-                    fn = getattr(tcd, "function", None)
-                    if fn is not None:
-                        fn_name = getattr(fn, "name", None)
-                        if fn_name:
-                            target["function"]["name"] = fn_name
-                        args_delta = getattr(fn, "arguments_delta", None)
-                        if args_delta:
-                            target["function"]["arguments"] += args_delta
-
-                # Emit partial assistant message when something changed
-                if delta_text or tcd is not None:
-                    assistant_event_streamed = True
-                    # Normalize tool_calls for message
-                    message_tool_calls = None
-                    if len(partial_tool_calls) > 0:
-                        message_tool_calls = []
-                        for i, tc in enumerate(partial_tool_calls):
-                            arguments = tc["function"]["arguments"]
-                            if isinstance(arguments, str):
-                                arguments = _normalize_tool_call_arguments(arguments)
-                            message_tool_calls.append({
-                                "id": tc["id"] or f"call_{i}",
+        if use_streaming:
+            try:
+                aggregated_text = ""
+                # Working array of partial tool calls
+                partial_tool_calls: List[Dict[str, Any]] = []
+
+                async for chunk in get_stream(state, current_agent, config):  # type: ignore[arg-type]
+                    # Text deltas
+                    delta_text = getattr(chunk, "delta", None)
+                    if delta_text:
+                        aggregated_text += delta_text
+
+                    # Tool call deltas
+                    tcd = getattr(chunk, "tool_call_delta", None)
+                    if tcd is not None:
+                        idx = getattr(tcd, "index", 0) or 0
+                        # Ensure slot exists
+                        while len(partial_tool_calls) <= idx:
+                            partial_tool_calls.append({
+                                "id": None,
                                 "type": "function",
-                                "function": {
-                                    "name": tc["function"]["name"] or "",
-                                    "arguments": arguments
-                                }
+                                "function": {"name": None, "arguments": ""}
                             })
+                        target = partial_tool_calls[idx]
+                        # id
+                        tc_id = getattr(tcd, "id", None)
+                        if tc_id:
+                            target["id"] = tc_id
+                        # function fields
+                        fn = getattr(tcd, "function", None)
+                        if fn is not None:
+                            fn_name = getattr(fn, "name", None)
+                            if fn_name:
+                                target["function"]["name"] = fn_name
+                            args_delta = getattr(fn, "arguments_delta", None)
+                            if args_delta:
+                                target["function"]["arguments"] += args_delta
+
+                    # Emit partial assistant message when something changed
+                    if delta_text or tcd is not None:
+                        assistant_event_streamed = True
+                        # Normalize tool_calls for message
+                        message_tool_calls = None
+                        if len(partial_tool_calls) > 0:
+                            message_tool_calls = []
+                            for i, tc in enumerate(partial_tool_calls):
+                                arguments = tc["function"]["arguments"]
+                                if isinstance(arguments, str):
+                                    arguments = _normalize_tool_call_arguments(arguments)
+                                message_tool_calls.append({
+                                    "id": tc["id"] or f"call_{i}",
+                                    "type": "function",
+                                    "function": {
+                                        "name": tc["function"]["name"] or "",
+                                        "arguments": arguments
+                                    }
+                                })
+
+                        partial_msg = Message(
+                            role=ContentRole.ASSISTANT,
+                            content=aggregated_text or "",
+                            tool_calls=None if not message_tool_calls else [
+                                ToolCall(
+                                    id=mc["id"],
+                                    type="function",
+                                    function=ToolCallFunction(
+                                        name=mc["function"]["name"],
+                                        arguments=_normalize_tool_call_arguments(mc["function"]["arguments"])
+                                    ),
+                                ) for mc in message_tool_calls
+                            ],
+                        )
+                        try:
+                            if config.on_event:
+                                config.on_event(AssistantMessageEvent(data=to_event_data(
+                                    AssistantMessageEventData(message=partial_msg)
+                                )))
+                        except Exception as _e:
+                            # Do not fail the run on callback errors
+                            pass
+
+                # Build final response object compatible with downstream logic
+                final_tool_calls = None
+                if len(partial_tool_calls) > 0:
+                    final_tool_calls = []
+                    for i, tc in enumerate(partial_tool_calls):
+                        arguments = tc["function"]["arguments"]
+                        if isinstance(arguments, str):
+                            arguments = _normalize_tool_call_arguments(arguments)
+                        final_tool_calls.append({
+                            "id": tc["id"] or f"call_{i}",
+                            "type": "function",
+                            "function": {
+                                "name": tc["function"]["name"] or "",
+                                "arguments": arguments
+                            }
+                        })
 
-                    partial_msg = Message(
-                        role=ContentRole.ASSISTANT,
-                        content=aggregated_text or "",
-                        tool_calls=None if not message_tool_calls else [
-                            ToolCall(
-                                id=mc["id"],
-                                type="function",
-                                function=ToolCallFunction(
-                                    name=mc["function"]["name"],
-                                    arguments=_normalize_tool_call_arguments(mc["function"]["arguments"])
-                                ),
-                            ) for mc in message_tool_calls
-                        ],
-                    )
-                    try:
-                        if config.on_event:
-                            config.on_event(AssistantMessageEvent(data=to_event_data(
-                                AssistantMessageEventData(message=partial_msg)
-                            )))
-                    except Exception as _e:
-                        # Do not fail the run on callback errors
-                        pass
-
-            # Build final response object compatible with downstream logic
-            final_tool_calls = None
-            if len(partial_tool_calls) > 0:
-                final_tool_calls = []
-                for i, tc in enumerate(partial_tool_calls):
-                    arguments = tc["function"]["arguments"]
-                    if isinstance(arguments, str):
-                        arguments = _normalize_tool_call_arguments(arguments)
-                    final_tool_calls.append({
-                        "id": tc["id"] or f"call_{i}",
-                        "type": "function",
-                        "function": {
-                            "name": tc["function"]["name"] or "",
-                            "arguments": arguments
-                        }
-                    })
-
-            llm_response = {
-                "message": {
-                    "content": aggregated_text or None,
-                    "tool_calls": final_tool_calls
+                llm_response = {
+                    "message": {
+                        "content": aggregated_text or None,
+                        "tool_calls": final_tool_calls
+                    }
                 }
-            }
-        except Exception:
-            # Fallback to non-streaming on error
-            assistant_event_streamed = False
+            except Exception:
+                # Fallback to non-streaming on error
+                assistant_event_streamed = False
+                llm_response = await config.model_provider.get_completion(state, current_agent, config)
+        else:
             llm_response = await config.model_provider.get_completion(state, current_agent, config)
-    else:
-        llm_response = await config.model_provider.get_completion(state, current_agent, config)
+        
+        # Check if response has meaningful content
+        has_content = llm_response.get('message', {}).get('content')
+        has_tool_calls = llm_response.get('message', {}).get('tool_calls')
+        
+        # If we got a valid response, break out of retry loop
+        if has_content or has_tool_calls:
+            break
+        
+        # If this is not the last attempt, retry with exponential backoff
+        if retry_attempt < config.max_empty_response_retries:
+            delay = config.empty_response_retry_delay * (2 ** retry_attempt)
+            if config.log_empty_responses:
+                print(f"[JAF:ENGINE] Empty LLM response on attempt {retry_attempt + 1}/{config.max_empty_response_retries + 1}, retrying in {delay:.1f}s...")
+                print(f"[JAF:ENGINE] Response had message: {bool(llm_response.get('message'))}, content: {bool(has_content)}, tool_calls: {bool(has_tool_calls)}")
+            await asyncio.sleep(delay)
+        else:
+            # Last attempt failed, log detailed diagnostic info
+            if config.log_empty_responses:
+                print(f"[JAF:ENGINE] Empty LLM response after {config.max_empty_response_retries + 1} attempts")
+                print(f"[JAF:ENGINE] Agent: {current_agent.name}, Model: {model}")
+                print(f"[JAF:ENGINE] Message count: {len(state.messages)}, Turn: {state.turn_count}")
+                print(f"[JAF:ENGINE] Response structure: {json.dumps(llm_response, indent=2)[:1000]}")
+
+    # Apply after_llm_call callback if provided
+    if config.after_llm_call:
+        if asyncio.iscoroutinefunction(config.after_llm_call):
+            llm_response = await config.after_llm_call(state, llm_response)
+        else:
+            result = config.after_llm_call(state, llm_response)
+            if asyncio.iscoroutine(result):
+                llm_response = await result
+            else:
+                llm_response = result
 
     # Emit LLM call end event
     if config.on_event:
@@ -665,6 +715,9 @@ async def _run_internal(
 
     # Check if response has message
     if not llm_response.get('message'):
+        if config.log_empty_responses:
+            print(f"[JAF:ENGINE] ERROR: No message in LLM response")
+            print(f"[JAF:ENGINE] Response structure: {json.dumps(llm_response, indent=2)[:500]}")
         return RunResult(
             final_state=state,
             outcome=ErrorOutcome(error=ModelBehaviorError(

jaf/core/tracing.py

@@ -443,7 +443,7 @@ class LangfuseTraceCollector:
             public_key=public_key,
             secret_key=secret_key,
             host=host,
-            release="jaf-py-v2.5.4",
+            release="jaf-py-v2.5.7",
             httpx_client=client
         )
         self._httpx_client = client

jaf/core/types.py

@@ -892,6 +892,13 @@ class RunConfig(Generic[Ctx]):
     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
+    before_llm_call: Optional[Callable[[RunState[Ctx], Agent[Ctx, Any]], Union[RunState[Ctx], Awaitable[RunState[Ctx]]]]] = None  # Callback before LLM call - can modify context/messages
+    after_llm_call: Optional[Callable[[RunState[Ctx], ModelCompletionResponse], Union[ModelCompletionResponse, Awaitable[ModelCompletionResponse]]]] = None  # Callback after LLM call - can process response
+    max_empty_response_retries: int = 3  # Maximum retries when LLM returns empty response
+    empty_response_retry_delay: float = 1.0  # Initial delay in seconds before retrying empty response (uses exponential backoff)
+    log_empty_responses: bool = True  # Whether to log diagnostic info for empty responses
+    prefer_streaming: Optional[bool] = None  # Whether to prefer streaming responses. None (default) = use streaming if available, True = prefer streaming, False = disable streaming
+
 
 # Regeneration types for conversation management
 @dataclass(frozen=True)

jaf/providers/model.py

@@ -219,6 +219,7 @@ def make_litellm_provider(
             request_params = {
                 "model": model,
                 "messages": messages,
+                "stream": False
             }
 
             # Add optional parameters

{jaf_py-2.5.4.dist-info → jaf_py-2.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.5.4
+Version: 2.5.7
 Summary: A purely functional agent framework with immutable state and composable tools - Python implementation
 Author: JAF Contributors
 Maintainer: JAF Contributors
@@ -82,7 +82,7 @@ Dynamic: license-file
 
 <!-- ![JAF Banner](docs/cover.png) -->
 
-[![Version](https://img.shields.io/badge/version-2.5.4-blue.svg)](https://github.com/xynehq/jaf-py)
+[![Version](https://img.shields.io/badge/version-2.5.7-blue.svg)](https://github.com/xynehq/jaf-py)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
 [![Docs](https://img.shields.io/badge/Docs-Live-brightgreen)](https://xynehq.github.io/jaf-py/)
 

{jaf_py-2.5.4.dist-info → jaf_py-2.5.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-jaf/__init__.py,sha256=05QV74KFtLBXDOyJnhFS4uco0WLSL22ipBRFc4gBMtY,8260
+jaf/__init__.py,sha256=ZwZkJFpYcvCXUPt5JwqrCZrE44rd_OkD7VuZNzCWHiI,8260
 jaf/cli.py,sha256=Af4di_NZ7rZ4wFl0R4EZh611NgJ--TL03vNyZ2M1_FY,8477
 jaf/exceptions.py,sha256=nl8JY355u7oTXB3PmC_LhnUaL8fzk2K4EaWM4fVpMPE,9196
 jaf/a2a/__init__.py,sha256=p4YVthZH0ow1ZECqWTQ0aQl8JWySYZb25jlzZJ09na4,7662
@@ -42,7 +42,7 @@ jaf/core/__init__.py,sha256=1VHV2-a1oJXIWcg8n5G5g2cmjw2QXv7OezncNB59KLw,1988
 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=5SUYyUbLTEXm9sk56n21PRdgkhrbPoJiU2i55ZETqcE,57914
+jaf/core/engine.py,sha256=FUX3rSY0PLzsERRmVYLtEtMaEkTIkm4TMZaeg3fmnt8,61140
 jaf/core/errors.py,sha256=5fwTNhkojKRQ4wZj3lZlgDnAsrYyjYOwXJkIr5EGNUc,5539
 jaf/core/guardrails.py,sha256=nv7pQuCx7-9DDZrecWO1DsDqFoujL81FBDrafOsXgcI,26179
 jaf/core/handoff.py,sha256=ttjOQ6CSl34J4T_1ejdmq78gZ-ve07_IQE_DAbz2bmo,6002
@@ -55,8 +55,8 @@ jaf/core/state.py,sha256=oNCVXPWLkqnBQObdQX10TcmZ0eOF3wKG6DtL3kF6ohw,9649
 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=aIPhDtugRhdym5_IO8ES4Cm5qzc1zYDjdMsE2wsJ_as,53367
-jaf/core/types.py,sha256=GaAjeLimd8LNRIu6QnpsWGPtNCdlk77HdXoPtJdQ9eY,32154
+jaf/core/tracing.py,sha256=3FcJ1vr5Nm-dAhQCpVrT_VR_e-gQG74PuuhNAcfzQhU,53367
+jaf/core/types.py,sha256=RLfFS5TpJiog5-mAVMH_7oM7ZEJqGsZBbrOQiUpGUM4,33042
 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
@@ -74,7 +74,7 @@ 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=lIbl1JvGrDhI9CzEk79N8yJNhf7ww_aWD-F40MnG3vY,2174
 jaf/providers/mcp.py,sha256=WxcC8gUFpDBBYyhorMcc1jHq3xMDMBtnwyRPthfL0S0,13074
-jaf/providers/model.py,sha256=bN2Hhr0N3soZzMrCdJ1pJa4rvo80oedCphDPcNgrVMY,39336
+jaf/providers/model.py,sha256=477Ly6D9OaZsUGsAoJtpSvdY_rLZ07ZjhlhapRzSxTI,39368
 jaf/server/__init__.py,sha256=fMPnLZBRm6t3yQrr7-PnoHAQ8qj9o6Z1AJLM1M6bIS0,392
 jaf/server/main.py,sha256=CTb0ywbPIq9ELfay5MKChVR7BpIQOoEbPjPfpzo2aBQ,2152
 jaf/server/server.py,sha256=cbdhVTPoWa7rVIX3DDLoXjppeGTKQWNFj3NA1jrZN88,46830
@@ -88,9 +88,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.5.4.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
-jaf_py-2.5.4.dist-info/METADATA,sha256=rI-ngB2xNPg5gIk_L5hq9j5pi_XdAyV3htqTpgtq0Pk,27743
-jaf_py-2.5.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jaf_py-2.5.4.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
-jaf_py-2.5.4.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
-jaf_py-2.5.4.dist-info/RECORD,,
+jaf_py-2.5.7.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
+jaf_py-2.5.7.dist-info/METADATA,sha256=Imc7tiZbuvXTqZaDANIAMhDmzWfaWKK0kJzu0C3La4k,27743
+jaf_py-2.5.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaf_py-2.5.7.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
+jaf_py-2.5.7.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
+jaf_py-2.5.7.dist-info/RECORD,,