jaf-py 2.4.6__py3-none-any.whl → 2.4.8__py3-none-any.whl

jaf/core/tracing.py

@@ -341,7 +341,7 @@ class LangfuseTraceCollector:
             public_key=public_key,
             secret_key=secret_key,
             host=host,
-            release="jaf-py-v2.1.1"
+            release="jaf-py-v2.4.8"
         )
         self.active_spans: Dict[str, Any] = {}
         self.trace_spans: Dict[TraceId, Any] = {}
@@ -399,15 +399,15 @@ class LangfuseTraceCollector:
                                 print(f"[LANGFUSE DEBUG] Found user_query from history: {user_query}")
                                 break
                     
-                    # Try to extract user_id from token_response
-                    if hasattr(context, 'token_response'):
-                        token_response = context.token_response
-                        print(f"[LANGFUSE DEBUG] Found token_response: {type(token_response)}")
-                        if isinstance(token_response, dict):
-                            user_id = token_response.get("email") or token_response.get("username")
+                    # Try to extract user_id from user_info
+                    if hasattr(context, 'user_info'):
+                        user_info = context.user_info
+                        print(f"[LANGFUSE DEBUG] Found user_info: {type(user_info)}")
+                        if isinstance(user_info, dict):
+                            user_id = user_info.get("email") or user_info.get("username")
                             print(f"[LANGFUSE DEBUG] Extracted user_id: {user_id}")
-                        elif hasattr(token_response, 'email'):
-                            user_id = token_response.email
+                        elif hasattr(user_info, 'email'):
+                            user_id = user_info.email
                             print(f"[LANGFUSE DEBUG] Extracted user_id from attr: {user_id}")
                 
                 # Extract conversation history and current user query from messages
@@ -524,7 +524,8 @@ class LangfuseTraceCollector:
                         "agent_name": event.data.get("agent_name", "analytics_agent_jaf"),
                         "conversation_history": conversation_history,
                         "tool_calls": [],
-                        "tool_results": []
+                        "tool_results": [],
+                        "user_info": event.data.get("context").user_info if event.data.get("context") and hasattr(event.data.get("context"), 'user_info') else None
                     }
                 )
                 self.trace_spans[trace_id] = trace

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.6.dist-info → jaf_py-2.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jaf-py
-Version: 2.4.6
+Version: 2.4.8
 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.6.dist-info → jaf_py-2.4.8.dist-info}/RECORD

@@ -53,7 +53,7 @@ jaf/core/state.py,sha256=NMtYTpUYa64m1Kte6lD8LGnF2bl69HAcdgXH6f-M97c,5650
 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/tracing.py,sha256=UyAUTBtj_3bThslvtqdmOt7bSMxFkHrTBc-RvItfmvI,40269
 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
@@ -70,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
@@ -86,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.6.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
-jaf_py-2.4.6.dist-info/METADATA,sha256=ep-RyxTMs_RhA4h10yXfZ5s4RQOiIZ0A5hRoP4ZV3sg,27712
-jaf_py-2.4.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jaf_py-2.4.6.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
-jaf_py-2.4.6.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
-jaf_py-2.4.6.dist-info/RECORD,,
+jaf_py-2.4.8.dist-info/licenses/LICENSE,sha256=LXUQBJxdyr-7C4bk9cQBwvsF_xwA-UVstDTKabpcjlI,1063
+jaf_py-2.4.8.dist-info/METADATA,sha256=e1L0JOAJzW81CBJ5RmOXFsSMFr80JioAQ2PTMGISiT0,27743
+jaf_py-2.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jaf_py-2.4.8.dist-info/entry_points.txt,sha256=OtIJeNJpb24kgGrqRx9szGgDx1vL9ayq8uHErmu7U5w,41
+jaf_py-2.4.8.dist-info/top_level.txt,sha256=Xu1RZbGaM4_yQX7bpalo881hg7N_dybaOW282F15ruE,4
+jaf_py-2.4.8.dist-info/RECORD,,