PraisonAI 3.0.0__py3-none-any.whl

praisonai/capabilities/__init__.py

@@ -0,0 +1,275 @@
+"""
+PraisonAI Capabilities Module
+
+This module provides LiteLLM endpoint capability parity for PraisonAI.
+All capabilities are lazy-loaded to minimize import overhead.
+
+Capabilities:
+- audio: Transcription and text-to-speech
+- images: Image generation and editing
+- videos: Video generation
+- files: File upload and management
+- batches: Batch processing
+- vector_stores: Vector store management
+- embeddings: Text embeddings
+- rerank: Document reranking
+- moderations: Content moderation
+- ocr: Optical character recognition
+- assistants: OpenAI-style assistants
+- fine_tuning: Model fine-tuning
+- responses: Response management
+- passthrough: Generic API passthrough
+- containers: Container management
+- search: Search capabilities
+- a2a: Agent-to-agent gateway
+"""
+
+__all__ = [
+    # Audio
+    'transcribe',
+    'atranscribe',
+    'speech',
+    'aspeech',
+    # Images
+    'image_generate',
+    'aimage_generate',
+    'image_edit',
+    'aimage_edit',
+    # Videos
+    'video_generate',
+    'avideo_generate',
+    # Files
+    'file_create',
+    'afile_create',
+    'file_list',
+    'afile_list',
+    'file_retrieve',
+    'afile_retrieve',
+    'file_delete',
+    'afile_delete',
+    'file_content',
+    'afile_content',
+    # Batches
+    'batch_create',
+    'abatch_create',
+    'batch_list',
+    'abatch_list',
+    'batch_retrieve',
+    'abatch_retrieve',
+    'batch_cancel',
+    'abatch_cancel',
+    # Vector Stores
+    'vector_store_create',
+    'avector_store_create',
+    'vector_store_search',
+    'avector_store_search',
+    # Embeddings
+    'embed',
+    'aembed',
+    # Rerank
+    'rerank',
+    'arerank',
+    # Moderations
+    'moderate',
+    'amoderate',
+    # OCR
+    'ocr',
+    'aocr',
+    # Assistants
+    'assistant_create',
+    'aassistant_create',
+    'assistant_list',
+    'aassistant_list',
+    # Fine-tuning
+    'fine_tuning_create',
+    'afine_tuning_create',
+    'fine_tuning_list',
+    'afine_tuning_list',
+    # Responses
+    'responses_create',
+    'aresponses_create',
+    # Passthrough
+    'passthrough',
+    'apassthrough',
+    # Containers
+    'container_create',
+    'acontainer_create',
+    # Search
+    'search',
+    'asearch',
+    # A2A
+    'a2a_send',
+    'aa2a_send',
+    # Completions
+    'chat_completion',
+    'achat_completion',
+    'text_completion',
+    'atext_completion',
+    # Messages
+    'messages_create',
+    'amessages_create',
+    'count_tokens',
+    'acount_tokens',
+    # Guardrails
+    'apply_guardrail',
+    'aapply_guardrail',
+    # RAG
+    'rag_query',
+    'arag_query',
+    # Realtime
+    'realtime_connect',
+    'arealtime_connect',
+    'realtime_send',
+    'arealtime_send',
+    # Skills
+    'skill_list',
+    'askill_list',
+    'skill_load',
+    'askill_load',
+    # MCP
+    'mcp_list_tools',
+    'amcp_list_tools',
+    'mcp_call_tool',
+    'amcp_call_tool',
+    # Vector Store Files
+    'vector_store_file_create',
+    'avector_store_file_create',
+    'vector_store_file_list',
+    'avector_store_file_list',
+    'vector_store_file_delete',
+    'avector_store_file_delete',
+    # Container Files
+    'container_file_read',
+    'acontainer_file_read',
+    'container_file_write',
+    'acontainer_file_write',
+    'container_file_list',
+    'acontainer_file_list',
+    # Result types
+    'TranscriptionResult',
+    'SpeechResult',
+    'ImageResult',
+    'FileResult',
+    'BatchResult',
+    'VectorStoreResult',
+    'EmbeddingResult',
+    'RerankResult',
+    'ModerationResult',
+    'OCRResult',
+    'CompletionResult',
+    'MessageResult',
+    'TokenCountResult',
+    'GuardrailResult',
+    'RAGResult',
+    'RealtimeSession',
+    'RealtimeEvent',
+    'SkillResult',
+    'MCPResult',
+    'MCPToolCallResult',
+    'VectorStoreFileResult',
+    'ContainerFileResult',
+]
+
+_ATTR_TO_MODULE = {
+    # Audio
+    'transcribe': 'audio', 'atranscribe': 'audio', 'speech': 'audio', 'aspeech': 'audio',
+    'TranscriptionResult': 'audio', 'SpeechResult': 'audio',
+    # Images
+    'image_generate': 'images', 'aimage_generate': 'images', 'image_edit': 'images',
+    'aimage_edit': 'images', 'ImageResult': 'images',
+    # Videos
+    'video_generate': 'videos', 'avideo_generate': 'videos',
+    # Files
+    'file_create': 'files', 'afile_create': 'files', 'file_list': 'files',
+    'afile_list': 'files', 'file_retrieve': 'files', 'afile_retrieve': 'files',
+    'file_delete': 'files', 'afile_delete': 'files', 'file_content': 'files',
+    'afile_content': 'files', 'FileResult': 'files',
+    # Batches
+    'batch_create': 'batches', 'abatch_create': 'batches', 'batch_list': 'batches',
+    'abatch_list': 'batches', 'batch_retrieve': 'batches', 'abatch_retrieve': 'batches',
+    'batch_cancel': 'batches', 'abatch_cancel': 'batches', 'BatchResult': 'batches',
+    # Vector Stores
+    'vector_store_create': 'vector_stores', 'avector_store_create': 'vector_stores',
+    'vector_store_search': 'vector_stores', 'avector_store_search': 'vector_stores',
+    'VectorStoreResult': 'vector_stores',
+    # Embeddings
+    'embed': 'embeddings', 'aembed': 'embeddings', 'EmbeddingResult': 'embeddings',
+    # Rerank
+    'rerank': 'rerank_module', 'arerank': 'rerank_module', 'RerankResult': 'rerank_module',
+    # Moderations
+    'moderate': 'moderations', 'amoderate': 'moderations', 'ModerationResult': 'moderations',
+    # OCR
+    'ocr': 'ocr_module', 'aocr': 'ocr_module', 'OCRResult': 'ocr_module',
+    # Assistants
+    'assistant_create': 'assistants', 'aassistant_create': 'assistants',
+    'assistant_list': 'assistants', 'aassistant_list': 'assistants',
+    # Fine-tuning
+    'fine_tuning_create': 'fine_tuning', 'afine_tuning_create': 'fine_tuning',
+    'fine_tuning_list': 'fine_tuning', 'afine_tuning_list': 'fine_tuning',
+    # Responses
+    'responses_create': 'responses', 'aresponses_create': 'responses',
+    # Passthrough
+    'passthrough': 'passthrough_module', 'apassthrough': 'passthrough_module',
+    # Containers
+    'container_create': 'containers', 'acontainer_create': 'containers',
+    # Search
+    'search': 'search_module', 'asearch': 'search_module',
+    # A2A
+    'a2a_send': 'a2a', 'aa2a_send': 'a2a',
+    # Completions
+    'chat_completion': 'completions', 'achat_completion': 'completions',
+    'text_completion': 'completions', 'atext_completion': 'completions',
+    'CompletionResult': 'completions',
+    # Messages
+    'messages_create': 'messages', 'amessages_create': 'messages',
+    'count_tokens': 'messages', 'acount_tokens': 'messages',
+    'MessageResult': 'messages', 'TokenCountResult': 'messages',
+    # Guardrails
+    'apply_guardrail': 'guardrails', 'aapply_guardrail': 'guardrails',
+    'GuardrailResult': 'guardrails',
+    # RAG
+    'rag_query': 'rag', 'arag_query': 'rag', 'RAGResult': 'rag',
+    # Realtime
+    'realtime_connect': 'realtime', 'arealtime_connect': 'realtime',
+    'realtime_send': 'realtime', 'arealtime_send': 'realtime',
+    'RealtimeSession': 'realtime', 'RealtimeEvent': 'realtime',
+    # Skills
+    'skill_list': 'skills_module', 'askill_list': 'skills_module',
+    'skill_load': 'skills_module', 'askill_load': 'skills_module',
+    'SkillResult': 'skills_module',
+    # MCP
+    'mcp_list_tools': 'mcp', 'amcp_list_tools': 'mcp',
+    'mcp_call_tool': 'mcp', 'amcp_call_tool': 'mcp',
+    'MCPResult': 'mcp', 'MCPToolCallResult': 'mcp',
+    # Vector Store Files
+    'vector_store_file_create': 'vector_store_files', 'avector_store_file_create': 'vector_store_files',
+    'vector_store_file_list': 'vector_store_files', 'avector_store_file_list': 'vector_store_files',
+    'vector_store_file_delete': 'vector_store_files', 'avector_store_file_delete': 'vector_store_files',
+    'VectorStoreFileResult': 'vector_store_files',
+    # Container Files
+    'container_file_read': 'container_files', 'acontainer_file_read': 'container_files',
+    'container_file_write': 'container_files', 'acontainer_file_write': 'container_files',
+    'container_file_list': 'container_files', 'acontainer_file_list': 'container_files',
+    'ContainerFileResult': 'container_files',
+}
+
+# Module name mapping (for modules that conflict with function names)
+_MODULE_ALIASES = {
+    'rerank_module': 'rerank',
+    'ocr_module': 'ocr',
+    'passthrough_module': 'passthrough',
+    'search_module': 'search',
+    'skills_module': 'skills',
+}
+
+def __getattr__(name):
+    """Lazy load capabilities to minimize import overhead."""
+    if name in _ATTR_TO_MODULE:
+        import importlib
+        module_name = _ATTR_TO_MODULE[name]
+        # Handle module aliases
+        actual_module = _MODULE_ALIASES.get(module_name, module_name)
+        module = importlib.import_module(f'.{actual_module}', __package__)
+        return getattr(module, name)
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

praisonai/capabilities/a2a.py

@@ -0,0 +1,140 @@
+"""
+A2A (Agent-to-Agent) Capabilities Module
+
+Provides agent-to-agent communication gateway functionality.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Any, Dict, List
+
+
+@dataclass
+class A2AResult:
+    """Result from A2A operations."""
+    id: str
+    status: str = "sent"
+    response: Optional[Any] = None
+    target_agent: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+def a2a_send(
+    message: str,
+    target_agent: str,
+    source_agent: Optional[str] = None,
+    context: Optional[Dict[str, Any]] = None,
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> A2AResult:
+    """
+    Send a message to another agent via A2A protocol.
+    
+    Args:
+        message: Message to send
+        target_agent: Target agent identifier
+        source_agent: Source agent identifier
+        context: Additional context
+        timeout: Request timeout in seconds
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        metadata: Optional metadata for tracing
+        
+    Returns:
+        A2AResult with response
+        
+    Example:
+        >>> result = a2a_send(
+        ...     "Please analyze this data",
+        ...     target_agent="data-analyst"
+        ... )
+        >>> print(result.response)
+    """
+    import uuid
+    
+    # A2A protocol implementation
+    # This integrates with PraisonAI's handoff mechanism
+    
+    message_id = f"a2a-{uuid.uuid4().hex[:12]}"
+    
+    # Try to use handoff if available
+    try:
+        from praisonaiagents import Agent
+        
+        # Create a simple agent to handle the message
+        agent = Agent(
+            name=target_agent,
+            instructions=f"You are {target_agent}. Process the following request.",
+        )
+        
+        response = agent.chat(message)
+        
+        return A2AResult(
+            id=message_id,
+            status="completed",
+            response=response,
+            target_agent=target_agent,
+            metadata=metadata or {},
+        )
+    except Exception:
+        # Return pending status if agent not available
+        return A2AResult(
+            id=message_id,
+            status="pending",
+            response=None,
+            target_agent=target_agent,
+            metadata=metadata or {},
+        )
+
+
+async def aa2a_send(
+    message: str,
+    target_agent: str,
+    source_agent: Optional[str] = None,
+    context: Optional[Dict[str, Any]] = None,
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> A2AResult:
+    """
+    Async: Send a message to another agent via A2A protocol.
+    
+    See a2a_send() for full documentation.
+    """
+    import uuid
+    
+    message_id = f"a2a-{uuid.uuid4().hex[:12]}"
+    
+    try:
+        from praisonaiagents import Agent
+        
+        agent = Agent(
+            name=target_agent,
+            instructions=f"You are {target_agent}. Process the following request.",
+        )
+        
+        # Use async chat if available
+        if hasattr(agent, 'achat'):
+            response = await agent.achat(message)
+        else:
+            response = agent.chat(message)
+        
+        return A2AResult(
+            id=message_id,
+            status="completed",
+            response=response,
+            target_agent=target_agent,
+            metadata=metadata or {},
+        )
+    except Exception:
+        return A2AResult(
+            id=message_id,
+            status="pending",
+            response=None,
+            target_agent=target_agent,
+            metadata=metadata or {},
+        )

praisonai/capabilities/assistants.py

@@ -0,0 +1,283 @@
+"""
+Assistants Capabilities Module
+
+Provides OpenAI-style assistants functionality via LiteLLM.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, List, Any, Dict, Literal
+
+
+@dataclass
+class AssistantResult:
+    """Result from assistant operations."""
+    id: str
+    object: str = "assistant"
+    name: Optional[str] = None
+    description: Optional[str] = None
+    model: Optional[str] = None
+    instructions: Optional[str] = None
+    tools: Optional[List[Dict[str, Any]]] = None
+    created_at: Optional[int] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+def assistant_create(
+    model: str = "gpt-4o-mini",
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    instructions: Optional[str] = None,
+    tools: Optional[List[Dict[str, Any]]] = None,
+    file_ids: Optional[List[str]] = None,
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    assistant_metadata: Optional[Dict[str, str]] = None,
+    **kwargs
+) -> AssistantResult:
+    """
+    Create an assistant.
+    
+    Args:
+        model: Model to use for the assistant
+        name: Name of the assistant
+        description: Description of the assistant
+        instructions: System instructions for the assistant
+        tools: List of tools (e.g., [{"type": "code_interpreter"}])
+        file_ids: List of file IDs to attach
+        custom_llm_provider: Provider ("openai", "azure")
+        timeout: Request timeout in seconds
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        assistant_metadata: Optional metadata for the assistant
+        
+    Returns:
+        AssistantResult with assistant ID
+        
+    Example:
+        >>> result = assistant_create(
+        ...     name="Math Tutor",
+        ...     instructions="You are a helpful math tutor."
+        ... )
+        >>> print(result.id)
+    """
+    import litellm
+    
+    call_kwargs = {
+        'model': model,
+        'custom_llm_provider': custom_llm_provider,
+        'timeout': timeout,
+    }
+    
+    if name:
+        call_kwargs['name'] = name
+    if description:
+        call_kwargs['description'] = description
+    if instructions:
+        call_kwargs['instructions'] = instructions
+    if tools:
+        call_kwargs['tools'] = tools
+    if file_ids:
+        call_kwargs['file_ids'] = file_ids
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    if assistant_metadata:
+        call_kwargs['metadata'] = assistant_metadata
+    
+    call_kwargs.update(kwargs)
+    
+    response = litellm.create_assistants(**call_kwargs)
+    
+    return AssistantResult(
+        id=getattr(response, 'id', ''),
+        object=getattr(response, 'object', 'assistant'),
+        name=getattr(response, 'name', name),
+        description=getattr(response, 'description', description),
+        model=getattr(response, 'model', model),
+        instructions=getattr(response, 'instructions', instructions),
+        tools=getattr(response, 'tools', tools),
+        created_at=getattr(response, 'created_at', None),
+        metadata=assistant_metadata or {},
+    )
+
+
+async def aassistant_create(
+    model: str = "gpt-4o-mini",
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    instructions: Optional[str] = None,
+    tools: Optional[List[Dict[str, Any]]] = None,
+    file_ids: Optional[List[str]] = None,
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    timeout: float = 600.0,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    assistant_metadata: Optional[Dict[str, str]] = None,
+    **kwargs
+) -> AssistantResult:
+    """
+    Async: Create an assistant.
+    
+    See assistant_create() for full documentation.
+    """
+    import litellm
+    
+    call_kwargs = {
+        'model': model,
+        'custom_llm_provider': custom_llm_provider,
+        'timeout': timeout,
+    }
+    
+    if name:
+        call_kwargs['name'] = name
+    if description:
+        call_kwargs['description'] = description
+    if instructions:
+        call_kwargs['instructions'] = instructions
+    if tools:
+        call_kwargs['tools'] = tools
+    if file_ids:
+        call_kwargs['file_ids'] = file_ids
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    if assistant_metadata:
+        call_kwargs['metadata'] = assistant_metadata
+    
+    call_kwargs.update(kwargs)
+    
+    response = await litellm.acreate_assistants(**call_kwargs)
+    
+    return AssistantResult(
+        id=getattr(response, 'id', ''),
+        object=getattr(response, 'object', 'assistant'),
+        name=getattr(response, 'name', name),
+        description=getattr(response, 'description', description),
+        model=getattr(response, 'model', model),
+        instructions=getattr(response, 'instructions', instructions),
+        tools=getattr(response, 'tools', tools),
+        created_at=getattr(response, 'created_at', None),
+        metadata=assistant_metadata or {},
+    )
+
+
+def assistant_list(
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    limit: int = 20,
+    order: str = "desc",
+    after: Optional[str] = None,
+    before: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    **kwargs
+) -> List[AssistantResult]:
+    """
+    List assistants.
+    
+    Args:
+        custom_llm_provider: Provider
+        limit: Maximum number of assistants to return
+        order: Sort order ("asc" or "desc")
+        after: Cursor for pagination
+        before: Cursor for pagination
+        api_key: Optional API key override
+        api_base: Optional API base URL override
+        
+    Returns:
+        List of AssistantResult objects
+    """
+    import litellm
+    
+    call_kwargs = {
+        'custom_llm_provider': custom_llm_provider,
+        'limit': limit,
+        'order': order,
+    }
+    
+    if after:
+        call_kwargs['after'] = after
+    if before:
+        call_kwargs['before'] = before
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    response = litellm.get_assistants(**call_kwargs)
+    
+    results = []
+    data = getattr(response, 'data', response) if hasattr(response, 'data') else response
+    if isinstance(data, list):
+        for item in data:
+            results.append(AssistantResult(
+                id=getattr(item, 'id', ''),
+                object=getattr(item, 'object', 'assistant'),
+                name=getattr(item, 'name', None),
+                description=getattr(item, 'description', None),
+                model=getattr(item, 'model', None),
+                instructions=getattr(item, 'instructions', None),
+                tools=getattr(item, 'tools', None),
+                created_at=getattr(item, 'created_at', None),
+            ))
+    
+    return results
+
+
+async def aassistant_list(
+    custom_llm_provider: Literal["openai", "azure"] = "openai",
+    limit: int = 20,
+    order: str = "desc",
+    after: Optional[str] = None,
+    before: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_base: Optional[str] = None,
+    **kwargs
+) -> List[AssistantResult]:
+    """
+    Async: List assistants.
+    
+    See assistant_list() for full documentation.
+    """
+    import litellm
+    
+    call_kwargs = {
+        'custom_llm_provider': custom_llm_provider,
+        'limit': limit,
+        'order': order,
+    }
+    
+    if after:
+        call_kwargs['after'] = after
+    if before:
+        call_kwargs['before'] = before
+    if api_key:
+        call_kwargs['api_key'] = api_key
+    if api_base:
+        call_kwargs['api_base'] = api_base
+    
+    call_kwargs.update(kwargs)
+    
+    response = await litellm.aget_assistants(**call_kwargs)
+    
+    results = []
+    data = getattr(response, 'data', response) if hasattr(response, 'data') else response
+    if isinstance(data, list):
+        for item in data:
+            results.append(AssistantResult(
+                id=getattr(item, 'id', ''),
+                object=getattr(item, 'object', 'assistant'),
+                name=getattr(item, 'name', None),
+                description=getattr(item, 'description', None),
+                model=getattr(item, 'model', None),
+                instructions=getattr(item, 'instructions', None),
+                tools=getattr(item, 'tools', None),
+                created_at=getattr(item, 'created_at', None),
+            ))
+    
+    return results