crewplus 0.2.97__tar.gz → 0.2.99__tar.gz

{crewplus-0.2.97 → crewplus-0.2.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crewplus
-Version: 0.2.97
+Version: 0.2.99
 Summary: Base services for CrewPlus AI applications
 Author-Email: Tim Liu <tim@opsmateai.com>
 License: MIT
@@ -15,6 +15,7 @@ Requires-Dist: google-genai>=1.21.1
 Requires-Dist: anthropic[vertex]>=0.76.0
 Requires-Dist: langchain-milvus<0.3.0,>=0.2.1
 Requires-Dist: langfuse<4.0.0,>=3.1.3
+Requires-Dist: pymilvus<=2.6.7,>=2.5.7
 Description-Content-Type: text/markdown
 
 # CrewPlus

{crewplus-0.2.97 → crewplus-0.2.99}/crewplus/services/__init__.py

@@ -1,15 +1,24 @@
 from .gemini_chat_model import GeminiChatModel
 from .claude_chat_model import ClaudeChatModel
+from .oai_claude_chat_model import OAIClaudeChatModel
 from .init_services import init_load_balancer, get_model_balancer
 from .model_load_balancer import ModelLoadBalancer
 from .azure_chat_model import TracedAzureChatOpenAI
 from .feedback_manager import LangfuseFeedbackManager
 from .schemas.feedback import FeedbackIn, FeedbackUpdate, FeedbackOut
 from .tracing_manager import TracingManager, TracingContext
+from .capabilities import (
+    BaseCapability,
+    CapabilityConfig,
+    CapabilityRegistry,
+    TavilySearchCapability,
+    BashCapability,
+)
 
 __all__ = [
     "GeminiChatModel",
     "ClaudeChatModel",
+    "OAIClaudeChatModel",
     "init_load_balancer",
     "get_model_balancer",
     "ModelLoadBalancer",
@@ -19,5 +28,10 @@ __all__ = [
     "FeedbackUpdate",
     "FeedbackOut",
     "TracingManager",
-    "TracingContext"
+    "TracingContext",
+    "BaseCapability",
+    "CapabilityConfig",
+    "CapabilityRegistry",
+    "TavilySearchCapability",
+    "BashCapability",
 ]

{crewplus-0.2.97 → crewplus-0.2.99}/crewplus/services/azure_chat_model.py

@@ -26,13 +26,30 @@ class TracedAzureChatOpenAI(AzureChatOpenAI):
 
     **Supported Capabilities:**
 
-    None. Azure OpenAI Chat Completions API does not have built-in tools like
-    web search or code execution. To add these capabilities:
-    - Use Azure OpenAI Assistants API with built-in tools
-    - Implement external tools via function calling
-    - Use third-party services for web search/code execution
-
-    The `capabilities` configuration is not applicable to this model class.
+    None. Azure OpenAI Chat Completions API does not have built-in web search
+    or similar capabilities.
+
+    Unlike Claude and Gemini which have platform-native web search:
+    - Claude: Built-in `web_search_20250305` tool, search executed by Anthropic
+    - Gemini: Built-in `GoogleSearch` tool, search executed by Google
+    - Azure OpenAI: **No built-in web search in Chat Completions API**
+
+    Microsoft does offer web search through other APIs, but none are compatible
+    with the Chat Completions API used here:
+    - Responses API `web_search_preview`: Only available on OpenAI direct, NOT on Azure
+    - Agents API `bing_grounding`: Requires `azure-ai-agents` SDK, incompatible with LangChain
+    - Chat Completions `data_sources`: Only supports Azure AI Search (your own index), not web search
+
+    If web search is needed for Azure models in the future, the feasible approach is
+    Function Calling + external search service (e.g. Bing Search API):
+    1. Inject a `web_search` function definition into the request
+    2. When the model returns a tool_call, execute the search externally
+    3. Feed results back to the model for final response generation
+    This is fundamentally different from Claude/Gemini where the platform handles
+    the search internally in a single API call.
+
+    Revisit this when Microsoft enables `web_search_preview` on Azure OpenAI.
+    Ref: https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/web-search
 
     Attributes:
         logger (Optional[logging.Logger]): An optional logger instance.

crewplus-0.2.99/crewplus/services/capabilities/__init__.py

@@ -0,0 +1,19 @@
+"""
+Capabilities module for custom tool support.
+
+Provides a registry-based system for adding capabilities (web search, bash, etc.)
+to chat models that don't have native support for these features.
+"""
+
+from .base import BaseCapability, CapabilityConfig
+from .registry import CapabilityRegistry
+from .web_search import TavilySearchCapability
+from .bash import BashCapability
+
+__all__ = [
+    "BaseCapability",
+    "CapabilityConfig",
+    "CapabilityRegistry",
+    "TavilySearchCapability",
+    "BashCapability",
+]

crewplus-0.2.99/crewplus/services/capabilities/base.py

@@ -0,0 +1,179 @@
+"""
+Base classes for capability system.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, List
+from pydantic import BaseModel, Field
+
+
+class CapabilityConfig(BaseModel):
+    """Configuration for a capability."""
+
+    enabled: bool = Field(default=True, description="Whether this capability is enabled")
+    type: str = Field(default="custom", description="Capability type: 'native' or 'custom'")
+
+    class Config:
+        extra = "allow"  # Allow additional fields for specific capabilities
+
+
+class BaseCapability(ABC):
+    """
+    Abstract base class for all capabilities.
+
+    Capabilities are tools that can be added to chat models via function calling.
+    Each capability provides:
+    - A tool schema for the LLM to understand how to call it
+    - An optional execute method for actual execution (if needed)
+
+    Example:
+        class MyCapability(BaseCapability):
+            @property
+            def name(self) -> str:
+                return "my_tool"
+
+            @property
+            def description(self) -> str:
+                return "Does something useful"
+
+            def get_parameters_schema(self) -> Dict:
+                return {
+                    "type": "object",
+                    "properties": {
+                        "input": {"type": "string", "description": "The input"}
+                    },
+                    "required": ["input"]
+                }
+    """
+
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the capability with configuration.
+
+        Args:
+            config: Configuration dictionary for this capability
+        """
+        self.config = CapabilityConfig(**config) if isinstance(config, dict) else config
+        self._raw_config = config
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """
+        Return the tool name for function calling.
+
+        Must match regex: ^[a-zA-Z0-9_-]{1,64}$
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        """
+        Return a detailed description of what this tool does.
+
+        This helps the LLM understand when and how to use the tool.
+        """
+        pass
+
+    @abstractmethod
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        """
+        Return the JSON Schema for the tool's parameters.
+
+        Returns:
+            Dict with "type": "object", "properties", and "required" keys
+        """
+        pass
+
+    def get_tool_schema(self) -> Dict[str, Any]:
+        """
+        Return the complete OpenAI-compatible tool schema.
+
+        Returns:
+            Tool definition in OpenAI function calling format
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.get_parameters_schema()
+            }
+        }
+
+    def get_langchain_tool_schema(self) -> Dict[str, Any]:
+        """
+        Return tool schema in LangChain/Claude format.
+
+        Returns:
+            Tool definition compatible with Claude's API
+        """
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": self.get_parameters_schema()
+        }
+
+    async def execute(self, **kwargs) -> str:
+        """
+        Execute the capability with given arguments.
+
+        Override this method to provide actual execution logic.
+        Default implementation raises NotImplementedError.
+
+        Args:
+            **kwargs: Arguments matching the parameters schema
+
+        Returns:
+            String result of the execution
+        """
+        raise NotImplementedError(
+            f"Capability '{self.name}' does not support execution. "
+            "Override execute() method to add execution support."
+        )
+
+    def execute_sync(self, **kwargs) -> str:
+        """
+        Synchronous version of execute.
+
+        Default implementation raises NotImplementedError.
+        """
+        raise NotImplementedError(
+            f"Capability '{self.name}' does not support synchronous execution. "
+            "Override execute_sync() method to add execution support."
+        )
+
+    def is_enabled(self) -> bool:
+        """Check if this capability is enabled."""
+        return self.config.enabled
+
+    def get_config_value(self, key: str, default: Any = None) -> Any:
+        """Get a configuration value by key."""
+        return self._raw_config.get(key, default)
+
+    def update_config(self, updates: Dict[str, Any]) -> None:
+        """
+        Update configuration with new values.
+
+        Args:
+            updates: Dictionary of config updates to apply
+        """
+        self._raw_config.update(updates)
+        self.config = CapabilityConfig(**self._raw_config)
+
+    def clone_with_config(self, config_override: Dict[str, Any]) -> "BaseCapability":
+        """
+        Create a new instance with merged configuration.
+
+        Args:
+            config_override: Configuration values to override
+
+        Returns:
+            New capability instance with merged config
+        """
+        merged_config = {**self._raw_config, **config_override}
+        return self.__class__(merged_config)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name='{self.name}', enabled={self.is_enabled()})"

crewplus-0.2.99/crewplus/services/capabilities/bash.py

@@ -0,0 +1,210 @@
+"""
+Bash command capability for function calling simulation.
+
+This capability allows the LLM to express bash commands via function calling.
+It does NOT actually execute commands - it's designed for testing and simulation
+of the function calling workflow.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from .base import BaseCapability
+
+
+class BashCapability(BaseCapability):
+    """
+    Bash command capability for function calling simulation.
+
+    This capability provides the tool schema for bash commands, allowing the LLM
+    to generate proper function calls with command and restart parameters.
+    Execution is NOT performed - this is for function calling simulation only.
+
+    Configuration Options:
+        enabled (bool): Whether this capability is enabled (default: True)
+        safe_mode (bool): If True, hints to LLM to avoid dangerous commands (default: True)
+        allowed_commands (list): List of allowed command prefixes (optional)
+        timeout (int): Suggested timeout in seconds (default: 30)
+        working_directory (str): Suggested working directory (optional)
+
+    Example:
+        config = {
+            "enabled": True,
+            "safe_mode": True,
+            "allowed_commands": ["ls", "cat", "grep", "find", "echo"],
+            "timeout": 30
+        }
+        capability = BashCapability(config)
+        schema = capability.get_tool_schema()
+
+    Note:
+        This capability is designed for testing the function calling workflow.
+        It does NOT execute actual bash commands. For actual execution, the
+        caller must handle the tool_calls returned by the LLM and execute
+        them in a controlled environment.
+    """
+
+    def __init__(self, config: Dict[str, Any]):
+        super().__init__(config)
+        self.logger = logging.getLogger(__name__)
+
+        # Configuration defaults
+        self._safe_mode = config.get("safe_mode", True)
+        self._allowed_commands = config.get("allowed_commands", [])
+        self._timeout = config.get("timeout", 30)
+        self._working_directory = config.get("working_directory")
+
+    @property
+    def name(self) -> str:
+        return "bash"
+
+    @property
+    def description(self) -> str:
+        base_desc = (
+            "Execute a bash command in a persistent shell session. "
+            "Use this for running system commands, scripts, and command-line operations. "
+            "The shell session maintains state between commands (working directory, "
+            "environment variables, created files)."
+        )
+
+        if self._safe_mode:
+            base_desc += (
+                " IMPORTANT: Avoid destructive commands like 'rm -rf', 'format', "
+                "or commands that could harm the system."
+            )
+
+        if self._allowed_commands:
+            allowed_str = ", ".join(self._allowed_commands)
+            base_desc += f" Preferred commands: {allowed_str}."
+
+        return base_desc
+
+    def get_parameters_schema(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": (
+                        "The bash command to execute. Use standard Unix commands. "
+                        "For multi-step operations, chain commands with && or ;."
+                    )
+                },
+                "restart": {
+                    "type": "boolean",
+                    "description": (
+                        "Set to true to restart the bash session, clearing all state "
+                        "(working directory resets, environment variables cleared)."
+                    ),
+                    "default": False
+                }
+            },
+            "required": []  # Neither is strictly required per Anthropic's bash tool spec
+        }
+
+    def validate_command(self, command: str) -> tuple[bool, Optional[str]]:
+        """
+        Validate a command against safety rules.
+
+        Args:
+            command: The command to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not command or not command.strip():
+            return True, None  # Empty command is valid (might just be restart)
+
+        # Dangerous patterns to block
+        dangerous_patterns = [
+            "rm -rf /",
+            "rm -rf /*",
+            ":(){:|:&};:",  # Fork bomb
+            "mkfs",
+            "dd if=",
+            "> /dev/sd",
+            "chmod -R 777 /",
+            "wget | sh",
+            "curl | sh",
+        ]
+
+        if self._safe_mode:
+            command_lower = command.lower()
+            for pattern in dangerous_patterns:
+                if pattern in command_lower:
+                    return False, f"Command blocked: contains dangerous pattern '{pattern}'"
+
+        # Check allowed commands if specified
+        if self._allowed_commands:
+            command_parts = command.strip().split()
+            if command_parts:
+                base_command = command_parts[0]
+                if base_command not in self._allowed_commands:
+                    return False, (
+                        f"Command '{base_command}' not in allowed list. "
+                        f"Allowed: {self._allowed_commands}"
+                    )
+
+        return True, None
+
+    def execute_sync(self, command: str = "", restart: bool = False, **kwargs) -> str:
+        """
+        Simulate bash command execution (no actual execution).
+
+        This method validates the command and returns a simulation message.
+        It does NOT actually execute the command.
+
+        Args:
+            command: The bash command (not executed)
+            restart: Whether to restart the session
+
+        Returns:
+            Simulation message describing what would happen
+        """
+        if restart:
+            return "[SIMULATION] Bash session would be restarted. All state cleared."
+
+        if not command:
+            return "[SIMULATION] No command provided."
+
+        # Validate command
+        is_valid, error = self.validate_command(command)
+        if not is_valid:
+            return f"[SIMULATION] Command blocked: {error}"
+
+        return (
+            f"[SIMULATION] Would execute command: {command}\n"
+            f"Note: Actual execution is disabled. This is a function calling simulation.\n"
+            f"To enable execution, handle the tool_call in your application code."
+        )
+
+    async def execute(self, command: str = "", restart: bool = False, **kwargs) -> str:
+        """
+        Async version of execute (same simulation behavior).
+
+        Args:
+            command: The bash command (not executed)
+            restart: Whether to restart the session
+
+        Returns:
+            Simulation message describing what would happen
+        """
+        return self.execute_sync(command=command, restart=restart, **kwargs)
+
+    def get_execution_hints(self) -> Dict[str, Any]:
+        """
+        Get hints for actual command execution (for callers who want to execute).
+
+        Returns:
+            Dict with execution configuration hints
+        """
+        return {
+            "safe_mode": self._safe_mode,
+            "allowed_commands": self._allowed_commands,
+            "timeout": self._timeout,
+            "working_directory": self._working_directory,
+            "dangerous_patterns": [
+                "rm -rf /", "mkfs", "dd if=", ":(){:|:&};:",
+                "chmod -R 777 /", "wget | sh", "curl | sh"
+            ]
+        }