soprano-sdk 0.2.14__tar.gz → 0.2.16__tar.gz

{soprano_sdk-0.2.14 → soprano_sdk-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soprano-sdk
-Version: 0.2.14
+Version: 0.2.16
 Summary: YAML-driven workflow engine with AI agent integration for building conversational SOPs
 Author: Arvind Thangamani
 License: MIT
@@ -21,7 +21,7 @@ Requires-Dist: langchain-openai>=1.0.3
 Requires-Dist: langchain>=1.0.7
 Requires-Dist: langfuse>=3.10.1
 Requires-Dist: langgraph==1.0.2
-Requires-Dist: litellm>=1.81.1
+Requires-Dist: litellm>=1.74.9
 Requires-Dist: openai>=1.92.1
 Requires-Dist: pydantic-ai>=1.22.0
 Requires-Dist: pydantic>=2.0.0

{soprano_sdk-0.2.14 → soprano_sdk-0.2.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "soprano-sdk"
-version = "0.2.14"
+version = "0.2.16"
 description = "YAML-driven workflow engine with AI agent integration for building conversational SOPs"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -30,7 +30,7 @@ dependencies = [
     "langchain-openai>=1.0.3",
     "langfuse>=3.10.1",
     "langgraph==1.0.2",
-    "litellm>=1.81.1",
+    "litellm>=1.74.9",
     "openai>=1.92.1",
     "pydantic>=2.0.0",
     "pydantic-ai>=1.22.0",

{soprano_sdk-0.2.14 → soprano_sdk-0.2.16}/soprano_sdk/agents/factory.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Literal, Tuple, Callable
+from typing import Any, Dict, List, Literal, Tuple, Callable, get_origin, get_args
 
 from agno.models.openai import OpenAIChat
 from crewai import LLM
@@ -18,36 +18,41 @@ from .adaptor import (
 
 def get_model(config: Dict[str, Any], framework: Literal['langgraph', 'crewai', 'agno', 'pydantic-ai'] = "langgraph", output_schema: Optional[BaseModel] = None, tools: Optional[List] = None):
     errors = []
-    
+
     model_name: str = config.get("model_name", "")
     if not model_name:
         errors.append("Model name is required in model_config")
-    
+
+    # Determine provider (openai, ollama, etc.)
+    provider = config.get("provider", "openai").lower()
+
+    # Handle base_url - required for Ollama, optional for OpenAI
     base_url = config.get("base_url")
-    if not base_url:
-        errors.append("Base url for model is required in model_config")
-    
     api_key = config.get("api_key", "")
     if not api_key:
         if auth_callback := config.get("auth_callback"):
             api_key = auth_callback()
         if not api_key:
-            errors.append("API key/Auth callback for model is required in model_config")
-    
+            # Ollama doesn't require a real API key
+            if provider == "ollama":
+                api_key = "ollama"
+            else:
+                errors.append("API key/Auth callback for model is required in model_config")
+
     if errors:
         raise ValueError("; ".join(errors))
-    
-    if framework == "agno" :
+
+    if framework == "agno":
         return OpenAIChat(
             id=model_name,
             api_key=api_key,
             base_url=base_url
         )
 
-    if framework == "crewai" :
+    if framework == "crewai":
         return LLM(
             api_key=api_key,
-            model=f"openai/{model_name}",
+            model=f"{provider}/{model_name}",
             base_url=base_url,
             temperature=0.1,
             top_p=0.7
@@ -58,7 +63,6 @@ def get_model(config: Dict[str, Any], framework: Literal['langgraph', 'crewai',
         api_key=SecretStr(api_key),
         base_url=base_url,
     )
-    
     if output_schema:
         return llm.with_structured_output(output_schema)
 
@@ -120,12 +124,77 @@ class CrewAIAgentCreator(AgentCreator):
         structured_output_model: Any = None
     ) -> CrewAIAgentAdapter:
         from crewai.agent import Agent
-        from crewai.tools import tool
+        from crewai.tools import BaseTool
+        from pydantic import Field, create_model
+        from typing import Type
+        import inspect
+
+        def create_crewai_tool(tool_name: str, tool_description: str, tool_callable: Callable) -> Any:
+            """Create a CrewAI tool with proper Pydantic schema for type hints"""
+
+            # Get function signature to build schema
+            sig = inspect.signature(tool_callable)
+
+            # Build Pydantic fields from function parameters
+            schema_fields = {}
+            for param_name, param in sig.parameters.items():
+                # Skip **kwargs and **state parameters - they shouldn't be in the schema
+                # These are used for validators and internal context
+                if param.kind == inspect.Parameter.VAR_KEYWORD:
+                    continue
+
+                # Get parameter annotation, default to str if not specified
+                param_type = param.annotation if param.annotation != inspect.Parameter.empty else str
+
+                # Default description
+                description = f"Parameter: {param_name}"
+
+                # Check if using Annotated type hint for description
+                if get_origin(param_type) is not None:
+                    # Handle Annotated[type, "description", ...]
+                    try:
+                        from typing import Annotated
+                        if get_origin(param_type) is Annotated:
+                            args = get_args(param_type)
+                            param_type = args[0]  # First arg is the actual type
+                            # Look for string metadata as description
+                            for metadata in args[1:]:
+                                if isinstance(metadata, str):
+                                    description = metadata
+                                    break
+                    except ImportError:
+                        # Python < 3.9 doesn't have Annotated in typing
+                        pass
+
+                # Get default value if exists
+                if param.default != inspect.Parameter.empty:
+                    schema_fields[param_name] = (
+                        param_type,
+                        Field(default=param.default, description=description)
+                    )
+                else:
+                    schema_fields[param_name] = (
+                        param_type,
+                        Field(..., description=description)
+                    )
+
+            # Create dynamic Pydantic model for tool input schema
+            ToolInputSchema = create_model(
+                f"{tool_name.title().replace('_', '')}Input",
+                **schema_fields
+            )
+
+            # Create custom BaseTool class with proper schema
+            class CustomCrewAITool(BaseTool):
+                name: str = tool_name
+                description: str = tool_description
+                args_schema: Type[BaseModel] = ToolInputSchema
+
+                def _run(self, **kwargs) -> str:
+                    return tool_callable(**kwargs)
+
+            return CustomCrewAITool()
 
-        def create_crewai_tool(tool_name: str, description: str, tool_callable: Callable) -> Any:
-            tool_callable.__doc__ = description
-            return tool(tool_name)(tool_callable)
-        
         tools = [create_crewai_tool(tn, desc, tc) for tn, desc, tc in tools]
 
         agent = Agent(
@@ -136,7 +205,7 @@ class CrewAIAgentCreator(AgentCreator):
             llm=get_model(model_config, 'crewai'),
             max_retry_limit=2
         )
-        
+
         return CrewAIAgentAdapter(agent, output_schema=structured_output_model)