clean up based on eduardo feedback

docs/concepts/knowledge.mdx

@@ -93,12 +93,6 @@ result = crew.kickoff(inputs={"question": "What city does John live in and how o
 
 Here's another example with the `CrewDoclingSource`. The CrewDoclingSource is actually quite versatile and can handle multiple file formats including TXT, PDF, DOCX, HTML, and more. 
 
-<Note>
-  You need to install `docling` for the following example to work: `uv add docling`
-</Note>
-
-
-
 ```python Code
 from crewai import LLM, Agent, Crew, Process, Task
 from crewai.knowledge.source.crew_docling_source import CrewDoclingSource

docs/how-to/multimodal-agents.mdx

@@ -1,14 +1,14 @@
 ---
 title: Using Multimodal Agents
 description: Learn how to enable and use multimodal capabilities in your agents for processing images and other non-text content within the CrewAI framework.
-icon: video
+icon: image
 ---
 
-## Using Multimodal Agents
+# Using Multimodal Agents
 
 CrewAI supports multimodal agents that can process both text and non-text content like images. This guide will show you how to enable and use multimodal capabilities in your agents.
 
-### Enabling Multimodal Capabilities
+## Enabling Multimodal Capabilities
 
 To create a multimodal agent, simply set the `multimodal` parameter to `True` when initializing your agent:
 
@@ -25,7 +25,7 @@ agent = Agent(
 
 When you set `multimodal=True`, the agent is automatically configured with the necessary tools for handling non-text content, including the `AddImageTool`.
 
-### Working with Images
+## Working with Images
 
 The multimodal agent comes pre-configured with the `AddImageTool`, which allows it to process images. You don't need to manually add this tool - it's automatically included when you enable multimodal capabilities.
 
@@ -108,7 +108,7 @@ The multimodal agent will automatically handle the image processing through its
 - Process image content with optional context or specific questions
 - Provide analysis and insights based on the visual information and task requirements
 
-### Best Practices
+## Best Practices
 
 When working with multimodal agents, keep these best practices in mind:
 

docs/mint.json

@@ -91,7 +91,6 @@
         "how-to/custom-manager-agent",
         "how-to/llm-connections",
         "how-to/customizing-agents",
-        "how-to/multimodal-agents",
         "how-to/coding-agents",
         "how-to/force-tool-output-as-result",
         "how-to/human-input-on-execution",

src/crewai/agents/agent_builder/utilities/base_output_converter.py

@@ -25,7 +25,7 @@ class OutputConverter(BaseModel, ABC):
     llm: Any = Field(description="The language model to be used to convert the text.")
     model: Any = Field(description="The model to be used to convert the text.")
     instructions: str = Field(description="Conversion instructions to the LLM.")
-    max_attempts: int = Field(
+    max_attempts: Optional[int] = Field(
         description="Max number of attempts to try to get the output formatted.",
         default=3,
     )

src/crewai/agents/agent_builder/utilities/base_token_process.py

@@ -2,12 +2,11 @@ from crewai.types.usage_metrics import UsageMetrics
 
 
 class TokenProcess:
-    def __init__(self):
-        self.total_tokens: int = 0
-        self.prompt_tokens: int = 0
-        self.cached_prompt_tokens: int = 0
-        self.completion_tokens: int = 0
-        self.successful_requests: int = 0
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    cached_prompt_tokens: int = 0
+    completion_tokens: int = 0
+    successful_requests: int = 0
 
     def sum_prompt_tokens(self, tokens: int):
         self.prompt_tokens = self.prompt_tokens + tokens

src/crewai/crew.py

@@ -676,7 +676,6 @@ class Crew(BaseModel):
         else:
             self.manager_llm = (
                 getattr(self.manager_llm, "model_name", None)
-                or getattr(self.manager_llm, "model", None)
                 or getattr(self.manager_llm, "deployment_name", None)
                 or self.manager_llm
             )

src/crewai/flow/flow.py

@@ -1,6 +1,5 @@
 import asyncio
 import inspect
-import uuid
 from typing import (
     Any,
     Callable,
@@ -13,7 +12,6 @@ from typing import (
     TypeVar,
     Union,
     cast,
-    overload,
 )
 from uuid import uuid4
 
@@ -27,8 +25,6 @@ from crewai.flow.flow_events import (
     MethodExecutionStartedEvent,
 )
 from crewai.flow.flow_visualizer import plot_flow
-from crewai.flow.persistence import FlowPersistence
-from crewai.flow.persistence.base import FlowPersistence
 from crewai.flow.utils import get_possible_return_constants
 from crewai.telemetry import Telemetry
 
@@ -37,46 +33,7 @@ class FlowState(BaseModel):
     """Base model for all flow states, ensuring each state has a unique ID."""
     id: str = Field(default_factory=lambda: str(uuid4()), description="Unique identifier for the flow state")
 
-# Type variables with explicit bounds
-T = TypeVar("T", bound=Union[Dict[str, Any], BaseModel])  # Generic flow state type parameter
-StateT = TypeVar("StateT", bound=Union[Dict[str, Any], BaseModel])  # State validation type parameter
-
-def ensure_state_type(state: Any, expected_type: Type[StateT]) -> StateT:
-    """Ensure state matches expected type with proper validation.
-    
-    Args:
-        state: State instance to validate
-        expected_type: Expected type for the state
-        
-    Returns:
-        Validated state instance
-        
-    Raises:
-        TypeError: If state doesn't match expected type
-        ValueError: If state validation fails
-    """
-    """Ensure state matches expected type with proper validation.
-    
-    Args:
-        state: State instance to validate
-        expected_type: Expected type for the state
-        
-    Returns:
-        Validated state instance
-        
-    Raises:
-        TypeError: If state doesn't match expected type
-        ValueError: If state validation fails
-    """
-    if expected_type == dict:
-        if not isinstance(state, dict):
-            raise TypeError(f"Expected dict, got {type(state).__name__}")
-        return cast(StateT, state)
-    if isinstance(expected_type, type) and issubclass(expected_type, BaseModel):
-        if not isinstance(state, expected_type):
-            raise TypeError(f"Expected {expected_type.__name__}, got {type(state).__name__}")
-        return cast(StateT, state)
-    raise TypeError(f"Invalid expected_type: {expected_type}")
+T = TypeVar("T", bound=Union[FlowState, Dict[str, Any]])
 
 
 def start(condition: Optional[Union[str, dict, Callable]] = None) -> Callable:
@@ -369,27 +326,21 @@ class FlowMeta(type):
         routers = set()
 
         for attr_name, attr_value in dct.items():
-            # Check for any flow-related attributes
-            if (hasattr(attr_value, "__is_flow_method__") or
-                hasattr(attr_value, "__is_start_method__") or
-                hasattr(attr_value, "__trigger_methods__") or
-                hasattr(attr_value, "__is_router__")):
-                
-                # Register start methods
-                if hasattr(attr_value, "__is_start_method__"):
-                    start_methods.append(attr_name)
-                
-                # Register listeners and routers
+            if hasattr(attr_value, "__is_start_method__"):
+                start_methods.append(attr_name)
                 if hasattr(attr_value, "__trigger_methods__"):
                     methods = attr_value.__trigger_methods__
                     condition_type = getattr(attr_value, "__condition_type__", "OR")
                     listeners[attr_name] = (condition_type, methods)
-                    
-                    if hasattr(attr_value, "__is_router__") and attr_value.__is_router__:
-                        routers.add(attr_name)
-                        possible_returns = get_possible_return_constants(attr_value)
-                        if possible_returns:
-                            router_paths[attr_name] = possible_returns
+            elif hasattr(attr_value, "__trigger_methods__"):
+                methods = attr_value.__trigger_methods__
+                condition_type = getattr(attr_value, "__condition_type__", "OR")
+                listeners[attr_name] = (condition_type, methods)
+                if hasattr(attr_value, "__is_router__") and attr_value.__is_router__:
+                    routers.add(attr_name)
+                    possible_returns = get_possible_return_constants(attr_value)
+                    if possible_returns:
+                        router_paths[attr_name] = possible_returns
 
         setattr(cls, "_start_methods", start_methods)
         setattr(cls, "_listeners", listeners)
@@ -400,9 +351,6 @@ class FlowMeta(type):
 
 
 class Flow(Generic[T], metaclass=FlowMeta):
-    """Base class for all flows.
-    
-    Type parameter T must be either Dict[str, Any] or a subclass of BaseModel."""
     _telemetry = Telemetry()
 
     _start_methods: List[str] = []
@@ -419,220 +367,53 @@ class Flow(Generic[T], metaclass=FlowMeta):
         _FlowGeneric.__name__ = f"{cls.__name__}[{item.__name__}]"
         return _FlowGeneric
 
-    def __init__(
-        self,
-        persistence: Optional[FlowPersistence] = None,
-        restore_uuid: Optional[str] = None,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize a new Flow instance.
-        
-        Args:
-            persistence: Optional persistence backend for storing flow states
-            restore_uuid: Optional UUID to restore state from persistence
-            **kwargs: Additional state values to initialize or override
-        """
-        # Initialize basic instance attributes
+    def __init__(self) -> None:
         self._methods: Dict[str, Callable] = {}
+        self._state: T = self._create_initial_state()
         self._method_execution_counts: Dict[str, int] = {}
         self._pending_and_listeners: Dict[str, Set[str]] = {}
         self._method_outputs: List[Any] = []  # List to store all method outputs
-        self._persistence: Optional[FlowPersistence] = persistence
-        
-        # Validate state model before initialization
-        if isinstance(self.initial_state, type):
-            if issubclass(self.initial_state, BaseModel) and not issubclass(self.initial_state, FlowState):
-                # Check if model has id field
-                model_fields = getattr(self.initial_state, "model_fields", None)
-                if not model_fields or "id" not in model_fields:
-                    raise ValueError("Flow state model must have an 'id' field")
-        
-        # Handle persistence and potential ID conflicts
-        stored_state = None
-        if self._persistence is not None:
-            if restore_uuid and kwargs and "id" in kwargs and restore_uuid != kwargs["id"]:
-                raise ValueError(
-                    f"Conflicting IDs provided: restore_uuid='{restore_uuid}' "
-                    f"vs kwargs['id']='{kwargs['id']}'. Use only one ID for restoration."
-                )
-            
-            # Attempt to load state, prioritizing restore_uuid
-            if restore_uuid:
-                stored_state = self._persistence.load_state(restore_uuid)
-                if not stored_state:
-                    raise ValueError(f"No state found for restore_uuid='{restore_uuid}'")
-            elif kwargs and "id" in kwargs:
-                stored_state = self._persistence.load_state(kwargs["id"])
-                if not stored_state:
-                    # For kwargs["id"], we allow creating new state if not found
-                    self._state = self._create_initial_state()
-                    if kwargs:
-                        self._initialize_state(kwargs)
-                    return
-        
-        # Initialize state based on persistence and kwargs
-        if stored_state:
-            # Create initial state and restore from persistence
-            self._state = self._create_initial_state()
-            self._restore_state(stored_state)
-            # Apply any additional kwargs to override specific fields
-            if kwargs:
-                filtered_kwargs = {k: v for k, v in kwargs.items() if k != "id"}
-                if filtered_kwargs:
-                    self._initialize_state(filtered_kwargs)
-        else:
-            # No stored state, create new state with initial values
-            self._state = self._create_initial_state()
-            # Apply any additional kwargs
-            if kwargs:
-                self._initialize_state(kwargs)
 
         self._telemetry.flow_creation_span(self.__class__.__name__)
 
-        # Register all flow-related methods
         for method_name in dir(self):
-            if not method_name.startswith("_"):
-                method = getattr(self, method_name)
-                # Check for any flow-related attributes
-                if (hasattr(method, "__is_flow_method__") or
-                    hasattr(method, "__is_start_method__") or
-                    hasattr(method, "__trigger_methods__") or
-                    hasattr(method, "__is_router__")):
-                    # Ensure method is bound to this instance
-                    if not hasattr(method, "__self__"):
-                        method = method.__get__(self, self.__class__)
-                    self._methods[method_name] = method
+            if callable(getattr(self, method_name)) and not method_name.startswith(
+                "__"
+            ):
+                self._methods[method_name] = getattr(self, method_name)
 
-
-    
     def _create_initial_state(self) -> T:
-        """Create and initialize flow state with UUID and default values.
-        
-        Returns:
-            New state instance with UUID and default values initialized
-            
-        Raises:
-            ValueError: If structured state model lacks 'id' field
-            TypeError: If state is neither BaseModel nor dictionary
-        """
         # Handle case where initial_state is None but we have a type parameter
         if self.initial_state is None and hasattr(self, "_initial_state_T"):
             state_type = getattr(self, "_initial_state_T")
             if isinstance(state_type, type):
                 if issubclass(state_type, FlowState):
-                    # Create instance without id, then set it
-                    instance = state_type()
-                    if not hasattr(instance, 'id'):
-                        setattr(instance, 'id', str(uuid4()))
-                    return cast(T, instance)
+                    return state_type()  # type: ignore
                 elif issubclass(state_type, BaseModel):
                     # Create a new type that includes the ID field
                     class StateWithId(state_type, FlowState):  # type: ignore
                         pass
-                    instance = StateWithId()
-                    if not hasattr(instance, 'id'):
-                        setattr(instance, 'id', str(uuid4()))
-                    return cast(T, instance)
-                elif state_type == dict:
-                    return cast(T, {"id": str(uuid4())})  # Minimal dict state
-        
-        # Handle case where no initial state is provided
-        if self.initial_state is None:
-            return cast(T, {"id": str(uuid4())})
-        
-        # Handle case where initial_state is a type (class)
-        if isinstance(self.initial_state, type):
-            if issubclass(self.initial_state, FlowState):
-                return cast(T, self.initial_state())  # Uses model defaults
-            elif issubclass(self.initial_state, BaseModel):
-                # Validate that the model has an id field
-                model_fields = getattr(self.initial_state, "model_fields", None)
-                if not model_fields or "id" not in model_fields:
-                    raise ValueError("Flow state model must have an 'id' field")
-                return cast(T, self.initial_state())  # Uses model defaults
-            elif self.initial_state == dict:
-                return cast(T, {"id": str(uuid4())})
-        
-        # Handle dictionary instance case
-        if isinstance(self.initial_state, dict):
-            new_state = dict(self.initial_state)  # Copy to avoid mutations
-            if "id" not in new_state:
-                new_state["id"] = str(uuid4())
-            return cast(T, new_state)
-        
-        # Handle BaseModel instance case
-        if isinstance(self.initial_state, BaseModel):
-            model = cast(BaseModel, self.initial_state)
-            if not hasattr(model, "id"):
-                raise ValueError("Flow state model must have an 'id' field")
-            
-            # Create new instance with same values to avoid mutations
-            if hasattr(model, "model_dump"):
-                # Pydantic v2
-                state_dict = model.model_dump()
-            elif hasattr(model, "dict"):
-                # Pydantic v1
-                state_dict = model.dict()
-            else:
-                # Fallback for other BaseModel implementations
-                state_dict = {
-                    k: v for k, v in model.__dict__.items()
-                    if not k.startswith("_")
-                }
-            
-            # Create new instance of the same class
-            model_class = type(model)
-            return cast(T, model_class(**state_dict))
-            
-        raise TypeError(
-            f"Initial state must be dict or BaseModel, got {type(self.initial_state)}"
-        )
-        # Handle case where initial_state is None but we have a type parameter
-        if self.initial_state is None and hasattr(self, "_initial_state_T"):
-            state_type = getattr(self, "_initial_state_T")
-            if isinstance(state_type, type):
-                if issubclass(state_type, FlowState):
-                    return cast(T, state_type())
-                elif issubclass(state_type, BaseModel):
-                    # Create a new type that includes the ID field
-                    class StateWithId(state_type, FlowState):  # type: ignore
-                        pass
-                    return cast(T, StateWithId())
-                elif state_type == dict:
-                    return cast(T, {"id": str(uuid4())})
+                    return StateWithId()  # type: ignore
 
         # Handle case where no initial state is provided
         if self.initial_state is None:
-            return cast(T, {"id": str(uuid4())})
+            return {"id": str(uuid4())}  # type: ignore
 
         # Handle case where initial_state is a type (class)
         if isinstance(self.initial_state, type):
             if issubclass(self.initial_state, FlowState):
-                return cast(T, self.initial_state())
+                return self.initial_state()  # type: ignore
             elif issubclass(self.initial_state, BaseModel):
-                # Validate that the model has an id field
-                model_fields = getattr(self.initial_state, "model_fields", None)
-                if not model_fields or "id" not in model_fields:
-                    raise ValueError("Flow state model must have an 'id' field")
-                return cast(T, self.initial_state())
-            elif self.initial_state == dict:
-                return cast(T, {"id": str(uuid4())})
+                # Create a new type that includes the ID field
+                class StateWithId(self.initial_state, FlowState):  # type: ignore
+                    pass
+                return StateWithId()  # type: ignore
 
-        # Handle dictionary instance case
-        if isinstance(self.initial_state, dict):
-            if "id" not in self.initial_state:
-                self.initial_state["id"] = str(uuid4())
-            return cast(T, dict(self.initial_state))  # Create new dict to avoid mutations
+        # Handle dictionary case
+        if isinstance(self.initial_state, dict) and "id" not in self.initial_state:
+            self.initial_state["id"] = str(uuid4())
 
-        # Handle BaseModel instance case
-        if isinstance(self.initial_state, BaseModel):
-            if not hasattr(self.initial_state, "id"):
-                raise ValueError("Flow state model must have an 'id' field")
-            return cast(T, self.initial_state)
-            
-        raise TypeError(
-            f"Initial state must be dict or BaseModel, got {type(self.initial_state)}"
-        )
+        return self.initial_state  # type: ignore
 
     @property
     def state(self) -> T:
@@ -644,95 +425,50 @@ class Flow(Generic[T], metaclass=FlowMeta):
         return self._method_outputs
 
     def _initialize_state(self, inputs: Dict[str, Any]) -> None:
-        """Initialize or update flow state with new inputs.
-        
-        Args:
-            inputs: Dictionary of state values to set/update
-            
-        Raises:
-            ValueError: If validation fails for structured state
-            TypeError: If state is neither BaseModel nor dictionary
-        """
         if isinstance(self._state, dict):
-            # For dict states, preserve existing fields unless overridden
+            # Preserve the ID when updating unstructured state
             current_id = self._state.get("id")
-            # Only update specified fields
-            for k, v in inputs.items():
-                self._state[k] = v
-            # Ensure ID is preserved or generated
+            self._state.update(inputs)
             if current_id:
                 self._state["id"] = current_id
             elif "id" not in self._state:
                 self._state["id"] = str(uuid4())
         elif isinstance(self._state, BaseModel):
-            # For BaseModel states, preserve existing fields unless overridden
+            # Structured state
             try:
-                model = cast(BaseModel, self._state)
-                # Get current state as dict
-                if hasattr(model, "model_dump"):
-                    current_state = model.model_dump()
-                elif hasattr(model, "dict"):
-                    current_state = model.dict()
-                else:
-                    current_state = {
-                        k: v for k, v in model.__dict__.items()
+                def create_model_with_extra_forbid(
+                    base_model: Type[BaseModel],
+                ) -> Type[BaseModel]:
+                    class ModelWithExtraForbid(base_model):  # type: ignore
+                        model_config = base_model.model_config.copy()
+                        model_config["extra"] = "forbid"
+
+                    return ModelWithExtraForbid
+
+                # Get current state as dict, preserving the ID if it exists
+                state_model = cast(BaseModel, self._state)
+                current_state = (
+                    state_model.model_dump()
+                    if hasattr(state_model, "model_dump")
+                    else state_model.dict()
+                    if hasattr(state_model, "dict")
+                    else {
+                        k: v
+                        for k, v in state_model.__dict__.items()
                         if not k.startswith("_")
                     }
-                
-                # Create new state with preserved fields and updates
-                new_state = {**current_state, **inputs}
-                
-                # Create new instance with merged state
-                model_class = type(model)
-                if hasattr(model_class, "model_validate"):
-                    # Pydantic v2
-                    self._state = cast(T, model_class.model_validate(new_state))
-                elif hasattr(model_class, "parse_obj"):
-                    # Pydantic v1
-                    self._state = cast(T, model_class.parse_obj(new_state))
-                else:
-                    # Fallback for other BaseModel implementations
-                    self._state = cast(T, model_class(**new_state))
+                )
+
+                ModelWithExtraForbid = create_model_with_extra_forbid(
+                    self._state.__class__
+                )
+                self._state = cast(
+                    T, ModelWithExtraForbid(**{**current_state, **inputs})
+                )
             except ValidationError as e:
                 raise ValueError(f"Invalid inputs for structured state: {e}") from e
         else:
             raise TypeError("State must be a BaseModel instance or a dictionary.")
-            
-    def _restore_state(self, stored_state: Dict[str, Any]) -> None:
-        """Restore flow state from persistence.
-        
-        Args:
-            stored_state: Previously stored state to restore
-            
-        Raises:
-            ValueError: If validation fails for structured state
-            TypeError: If state is neither BaseModel nor dictionary
-        """
-        # When restoring from persistence, use the stored ID
-        stored_id = stored_state.get("id")
-        if not stored_id:
-            raise ValueError("Stored state must have an 'id' field")
-        
-        if isinstance(self._state, dict):
-            # For dict states, update all fields from stored state
-            self._state.clear()
-            self._state.update(stored_state)
-        elif isinstance(self._state, BaseModel):
-            # For BaseModel states, create new instance with stored values
-            model = cast(BaseModel, self._state)
-            if hasattr(model, "model_validate"):
-                # Pydantic v2
-                self._state = cast(T, type(model).model_validate(stored_state))
-            elif hasattr(model, "parse_obj"):
-                # Pydantic v1
-                self._state = cast(T, type(model).parse_obj(stored_state))
-            else:
-                # Fallback for other BaseModel implementations
-                self._state = cast(T, type(model)(**stored_state))
-        else:
-            raise TypeError(
-                f"State must be dict or BaseModel, got {type(self._state)}"
-            )
 
     def kickoff(self, inputs: Optional[Dict[str, Any]] = None) -> Any:
         self.event_emitter.send(

src/crewai/flow/persistence/__init__.py

@@ -1,18 +0,0 @@
-"""
-CrewAI Flow Persistence.
-
-This module provides interfaces and implementations for persisting flow states.
-"""
-
-from typing import Any, Dict, TypeVar, Union
-
-from pydantic import BaseModel
-
-from crewai.flow.persistence.base import FlowPersistence
-from crewai.flow.persistence.decorators import persist
-from crewai.flow.persistence.sqlite import SQLiteFlowPersistence
-
-__all__ = ["FlowPersistence", "persist", "SQLiteFlowPersistence"]
-
-StateType = TypeVar('StateType', bound=Union[Dict[str, Any], BaseModel])
-DictStateType = Dict[str, Any]

src/crewai/flow/persistence/base.py

@@ -1,53 +0,0 @@
-"""Base class for flow state persistence."""
-
-import abc
-from typing import Any, Dict, Optional, Union
-
-from pydantic import BaseModel
-
-
-class FlowPersistence(abc.ABC):
-    """Abstract base class for flow state persistence.
-    
-    This class defines the interface that all persistence implementations must follow.
-    It supports both structured (Pydantic BaseModel) and unstructured (dict) states.
-    """
-    
-    @abc.abstractmethod
-    def init_db(self) -> None:
-        """Initialize the persistence backend.
-        
-        This method should handle any necessary setup, such as:
-        - Creating tables
-        - Establishing connections
-        - Setting up indexes
-        """
-        pass
-    
-    @abc.abstractmethod
-    def save_state(
-        self,
-        flow_uuid: str,
-        method_name: str,
-        state_data: Union[Dict[str, Any], BaseModel]
-    ) -> None:
-        """Persist the flow state after method completion.
-        
-        Args:
-            flow_uuid: Unique identifier for the flow instance
-            method_name: Name of the method that just completed
-            state_data: Current state data (either dict or Pydantic model)
-        """
-        pass
-    
-    @abc.abstractmethod
-    def load_state(self, flow_uuid: str) -> Optional[Dict[str, Any]]:
-        """Load the most recent state for a given flow UUID.
-        
-        Args:
-            flow_uuid: Unique identifier for the flow instance
-            
-        Returns:
-            The most recent state as a dictionary, or None if no state exists
-        """
-        pass

src/crewai/flow/persistence/decorators.py

@@ -1,177 +0,0 @@
-"""
-Decorators for flow state persistence.
-
-Example:
-    ```python
-    from crewai.flow.flow import Flow, start
-    from crewai.flow.persistence import persist, SQLiteFlowPersistence
-    
-    class MyFlow(Flow):
-        @start()
-        @persist(SQLiteFlowPersistence())
-        def sync_method(self):
-            # Synchronous method implementation
-            pass
-            
-        @start()
-        @persist(SQLiteFlowPersistence())
-        async def async_method(self):
-            # Asynchronous method implementation
-            await some_async_operation()
-    ```
-"""
-
-import asyncio
-import functools
-import inspect
-import logging
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Optional,
-    Type,
-    TypeVar,
-    Union,
-    cast,
-    get_type_hints,
-)
-
-from pydantic import BaseModel
-
-from crewai.flow.persistence.base import FlowPersistence
-from crewai.flow.persistence.sqlite import SQLiteFlowPersistence
-
-logger = logging.getLogger(__name__)
-T = TypeVar("T")
-
-
-def persist(persistence: Optional[FlowPersistence] = None):
-    """Decorator to persist flow state.
-    
-    This decorator can be applied at either the class level or method level.
-    When applied at the class level, it automatically persists all flow method
-    states. When applied at the method level, it persists only that method's
-    state.
-    
-    Args:
-        persistence: Optional FlowPersistence implementation to use.
-                    If not provided, uses SQLiteFlowPersistence.
-    
-    Returns:
-        A decorator that can be applied to either a class or method
-    
-    Raises:
-        ValueError: If the flow state doesn't have an 'id' field
-        RuntimeError: If state persistence fails
-        
-    Example:
-        @persist  # Class-level persistence with default SQLite
-        class MyFlow(Flow[MyState]):
-            @start()
-            def begin(self):
-                pass
-    """
-    def _persist_state(flow_instance: Any, method_name: str, persistence_instance: FlowPersistence) -> None:
-        """Helper to persist state with error handling."""
-        try:
-            # Get flow UUID from state
-            state = getattr(flow_instance, 'state', None)
-            if state is None:
-                raise ValueError("Flow instance has no state")
-                
-            flow_uuid: Optional[str] = None
-            if isinstance(state, dict):
-                flow_uuid = state.get('id')
-            elif isinstance(state, BaseModel):
-                flow_uuid = getattr(state, 'id', None)
-                
-            if not flow_uuid:
-                raise ValueError(
-                    "Flow state must have an 'id' field for persistence"
-                )
-                
-            # Persist the state
-            persistence_instance.save_state(
-                flow_uuid=flow_uuid,
-                method_name=method_name,
-                state_data=state,
-            )
-        except Exception as e:
-            logger.error(
-                f"Failed to persist state for method {method_name}: {str(e)}"
-            )
-            raise RuntimeError(f"State persistence failed: {str(e)}") from e
-    
-    def decorator(target: Union[Type, Callable[..., T]]) -> Union[Type, Callable[..., T]]:
-        """Decorator that handles both class and method decoration."""
-        actual_persistence = persistence or SQLiteFlowPersistence()
-        
-        if isinstance(target, type):
-            # Class decoration
-            class_methods = {}
-            for name, method in target.__dict__.items():
-                if callable(method) and hasattr(method, "__is_flow_method__"):
-                    # Wrap each flow method with persistence
-                    if asyncio.iscoroutinefunction(method):
-                        @functools.wraps(method)
-                        async def class_async_wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
-                            method_coro = method(self, *args, **kwargs)
-                            if asyncio.iscoroutine(method_coro):
-                                result = await method_coro
-                            else:
-                                result = method_coro
-                            _persist_state(self, method.__name__, actual_persistence)
-                            return result
-                        class_methods[name] = class_async_wrapper
-                    else:
-                        @functools.wraps(method)
-                        def class_sync_wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
-                            result = method(self, *args, **kwargs)
-                            _persist_state(self, method.__name__, actual_persistence)
-                            return result
-                        class_methods[name] = class_sync_wrapper
-                    
-                    # Preserve flow-specific attributes
-                    for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
-                        if hasattr(method, attr):
-                            setattr(class_methods[name], attr, getattr(method, attr))
-                    setattr(class_methods[name], "__is_flow_method__", True)
-            
-            # Update class with wrapped methods
-            for name, method in class_methods.items():
-                setattr(target, name, method)
-            return target
-        else:
-            # Method decoration
-            method = target
-            setattr(method, "__is_flow_method__", True)
-            
-            if asyncio.iscoroutinefunction(method):
-                @functools.wraps(method)
-                async def method_async_wrapper(flow_instance: Any, *args: Any, **kwargs: Any) -> T:
-                    method_coro = method(flow_instance, *args, **kwargs)
-                    if asyncio.iscoroutine(method_coro):
-                        result = await method_coro
-                    else:
-                        result = method_coro
-                    _persist_state(flow_instance, method.__name__, actual_persistence)
-                    return result
-                for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
-                    if hasattr(method, attr):
-                        setattr(method_async_wrapper, attr, getattr(method, attr))
-                setattr(method_async_wrapper, "__is_flow_method__", True)
-                return cast(Callable[..., T], method_async_wrapper)
-            else:
-                @functools.wraps(method)
-                def method_sync_wrapper(flow_instance: Any, *args: Any, **kwargs: Any) -> T:
-                    result = method(flow_instance, *args, **kwargs)
-                    _persist_state(flow_instance, method.__name__, actual_persistence)
-                    return result
-                for attr in ["__is_start_method__", "__trigger_methods__", "__condition_type__", "__is_router__"]:
-                    if hasattr(method, attr):
-                        setattr(method_sync_wrapper, attr, getattr(method, attr))
-                setattr(method_sync_wrapper, "__is_flow_method__", True)
-                return cast(Callable[..., T], method_sync_wrapper)
-            
-    return decorator

src/crewai/flow/persistence/sqlite.py

@@ -1,124 +0,0 @@
-"""
-SQLite-based implementation of flow state persistence.
-"""
-
-import json
-import os
-import sqlite3
-import tempfile
-from datetime import datetime
-from typing import Any, Dict, Optional, Union
-
-from pydantic import BaseModel
-
-from crewai.flow.persistence.base import FlowPersistence
-
-
-class SQLiteFlowPersistence(FlowPersistence):
-    """SQLite-based implementation of flow state persistence.
-    
-    This class provides a simple, file-based persistence implementation using SQLite.
-    It's suitable for development and testing, or for production use cases with
-    moderate performance requirements.
-    """
-    
-    db_path: str  # Type annotation for instance variable
-    
-    def __init__(self, db_path: Optional[str] = None):
-        """Initialize SQLite persistence.
-        
-        Args:
-            db_path: Path to the SQLite database file. If not provided, uses
-                    db_storage_path() from utilities.paths.
-                    
-        Raises:
-            ValueError: If db_path is invalid
-        """
-        from crewai.utilities.paths import db_storage_path
-        # Get path from argument or default location
-        path = db_path or db_storage_path()
-        
-        if not path:
-            raise ValueError("Database path must be provided")
-            
-        self.db_path = path  # Now mypy knows this is str
-        self.init_db()
-    
-    def init_db(self) -> None:
-        """Create the necessary tables if they don't exist."""
-        with sqlite3.connect(self.db_path) as conn:
-            conn.execute("""
-            CREATE TABLE IF NOT EXISTS flow_states (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                flow_uuid TEXT NOT NULL,
-                method_name TEXT NOT NULL,
-                timestamp DATETIME NOT NULL,
-                state_json TEXT NOT NULL
-            )
-            """)
-            # Add index for faster UUID lookups
-            conn.execute("""
-            CREATE INDEX IF NOT EXISTS idx_flow_states_uuid 
-            ON flow_states(flow_uuid)
-            """)
-    
-    def save_state(
-        self,
-        flow_uuid: str,
-        method_name: str,
-        state_data: Union[Dict[str, Any], BaseModel],
-    ) -> None:
-        """Save the current flow state to SQLite.
-        
-        Args:
-            flow_uuid: Unique identifier for the flow instance
-            method_name: Name of the method that just completed
-            state_data: Current state data (either dict or Pydantic model)
-        """
-        # Convert state_data to dict, handling both Pydantic and dict cases
-        if isinstance(state_data, BaseModel):
-            state_dict = dict(state_data)  # Use dict() for better type compatibility
-        elif isinstance(state_data, dict):
-            state_dict = state_data
-        else:
-            raise ValueError(
-                f"state_data must be either a Pydantic BaseModel or dict, got {type(state_data)}"
-            )
-            
-        with sqlite3.connect(self.db_path) as conn:
-            conn.execute("""
-            INSERT INTO flow_states (
-                flow_uuid,
-                method_name,
-                timestamp,
-                state_json
-            ) VALUES (?, ?, ?, ?)
-            """, (
-                flow_uuid,
-                method_name,
-                datetime.utcnow().isoformat(),
-                json.dumps(state_dict),
-            ))
-    
-    def load_state(self, flow_uuid: str) -> Optional[Dict[str, Any]]:
-        """Load the most recent state for a given flow UUID.
-        
-        Args:
-            flow_uuid: Unique identifier for the flow instance
-            
-        Returns:
-            The most recent state as a dictionary, or None if no state exists
-        """
-        with sqlite3.connect(self.db_path) as conn:
-            cursor = conn.execute("""
-            SELECT state_json
-            FROM flow_states
-            WHERE flow_uuid = ?
-            ORDER BY id DESC
-            LIMIT 1
-            """, (flow_uuid,))
-            row = cursor.fetchone()
-            
-        if row:
-            return json.loads(row[0])
-        return None

src/crewai/knowledge/source/crew_docling_source.py

@@ -8,7 +8,6 @@ try:
     from docling.exceptions import ConversionError
     from docling_core.transforms.chunker.hierarchical_chunker import HierarchicalChunker
     from docling_core.types.doc.document import DoclingDocument
-
     DOCLING_AVAILABLE = True
 except ImportError:
     DOCLING_AVAILABLE = False
@@ -39,8 +38,8 @@ class CrewDoclingSource(BaseKnowledgeSource):
     file_paths: List[Union[Path, str]] = Field(default_factory=list)
     chunks: List[str] = Field(default_factory=list)
     safe_file_paths: List[Union[Path, str]] = Field(default_factory=list)
-    content: List["DoclingDocument"] = Field(default_factory=list)
-    document_converter: "DocumentConverter" = Field(
+    content: List[DoclingDocument] = Field(default_factory=list)
+    document_converter: DocumentConverter = Field(
         default_factory=lambda: DocumentConverter(
             allowed_formats=[
                 InputFormat.MD,
@@ -66,7 +65,7 @@ class CrewDoclingSource(BaseKnowledgeSource):
         self.safe_file_paths = self.validate_content()
         self.content = self._load_content()
 
-    def _load_content(self) -> List["DoclingDocument"]:
+    def _load_content(self) -> List[DoclingDocument]:
         try:
             return self._convert_source_to_docling_documents()
         except ConversionError as e:
@@ -88,11 +87,11 @@ class CrewDoclingSource(BaseKnowledgeSource):
             self.chunks.extend(list(new_chunks_iterable))
         self._save_documents()
 
-    def _convert_source_to_docling_documents(self) -> List["DoclingDocument"]:
+    def _convert_source_to_docling_documents(self) -> List[DoclingDocument]:
         conv_results_iter = self.document_converter.convert_all(self.safe_file_paths)
         return [result.document for result in conv_results_iter]
 
-    def _chunk_doc(self, doc: "DoclingDocument") -> Iterator[str]:
+    def _chunk_doc(self, doc: DoclingDocument) -> Iterator[str]:
         chunker = HierarchicalChunker()
         for chunk in chunker.chunk(doc):
             yield chunk.text

src/crewai/llm.py

@@ -222,19 +222,6 @@ class LLM:
                 ].message
                 text_response = response_message.content or ""
                 tool_calls = getattr(response_message, "tool_calls", [])
-                
-                # Ensure callbacks get the full response object with usage info
-                if callbacks and len(callbacks) > 0:
-                    for callback in callbacks:
-                        if hasattr(callback, "log_success_event"):
-                            usage_info = getattr(response, "usage", None)
-                            if usage_info:
-                                callback.log_success_event(
-                                    kwargs=params,
-                                    response_obj={"usage": usage_info},
-                                    start_time=0,
-                                    end_time=0,
-                                )
 
                 # --- 2) If no tool calls, return the text response
                 if not tool_calls or not available_functions:

src/crewai/memory/storage/kickoff_task_outputs_storage.py

@@ -1,17 +1,12 @@
 import json
-import logging
 import sqlite3
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from crewai.task import Task
 from crewai.utilities import Printer
 from crewai.utilities.crew_json_encoder import CrewJSONEncoder
-from crewai.utilities.errors import DatabaseError, DatabaseOperationError
 from crewai.utilities.paths import db_storage_path
 
-logger = logging.getLogger(__name__)
-
 
 class KickoffTaskOutputsSQLiteStorage:
     """
@@ -19,24 +14,15 @@ class KickoffTaskOutputsSQLiteStorage:
     """
 
     def __init__(
-        self, db_path: Optional[str] = None
+        self, db_path: str = f"{db_storage_path()}/latest_kickoff_task_outputs.db"
     ) -> None:
-        if db_path is None:
-            # Get the parent directory of the default db path and create our db file there
-            db_path = str(Path(db_storage_path()).parent / "latest_kickoff_task_outputs.db")
         self.db_path = db_path
         self._printer: Printer = Printer()
         self._initialize_db()
 
-    def _initialize_db(self) -> None:
-        """Initialize the SQLite database and create the latest_kickoff_task_outputs table.
-
-        This method sets up the database schema for storing task outputs. It creates
-        a table with columns for task_id, expected_output, output (as JSON),
-        task_index, inputs (as JSON), was_replayed flag, and timestamp.
-
-        Raises:
-            DatabaseOperationError: If database initialization fails due to SQLite errors.
+    def _initialize_db(self):
+        """
+        Initializes the SQLite database and creates LTM table
         """
         try:
             with sqlite3.connect(self.db_path) as conn:
@@ -57,9 +43,10 @@ class KickoffTaskOutputsSQLiteStorage:
 
                 conn.commit()
         except sqlite3.Error as e:
-            error_msg = DatabaseError.format_error(DatabaseError.INIT_ERROR, e)
-            logger.error(error_msg)
-            raise DatabaseOperationError(error_msg, e)
+            self._printer.print(
+                content=f"SAVING KICKOFF TASK OUTPUTS ERROR: An error occurred during database initialization: {e}",
+                color="red",
+            )
 
     def add(
         self,
@@ -68,22 +55,9 @@ class KickoffTaskOutputsSQLiteStorage:
         task_index: int,
         was_replayed: bool = False,
         inputs: Dict[str, Any] = {},
-    ) -> None:
-        """Add a new task output record to the database.
-
-        Args:
-            task: The Task object containing task details.
-            output: Dictionary containing the task's output data.
-            task_index: Integer index of the task in the sequence.
-            was_replayed: Boolean indicating if this was a replay execution.
-            inputs: Dictionary of input parameters used for the task.
-
-        Raises:
-            DatabaseOperationError: If saving the task output fails due to SQLite errors.
-        """
+    ):
         try:
             with sqlite3.connect(self.db_path) as conn:
-                conn.execute("BEGIN TRANSACTION")
                 cursor = conn.cursor()
                 cursor.execute(
                     """
@@ -102,31 +76,21 @@ class KickoffTaskOutputsSQLiteStorage:
                 )
                 conn.commit()
         except sqlite3.Error as e:
-            error_msg = DatabaseError.format_error(DatabaseError.SAVE_ERROR, e)
-            logger.error(error_msg)
-            raise DatabaseOperationError(error_msg, e)
+            self._printer.print(
+                content=f"SAVING KICKOFF TASK OUTPUTS ERROR: An error occurred during database initialization: {e}",
+                color="red",
+            )
 
     def update(
         self,
         task_index: int,
-        **kwargs: Any,
-    ) -> None:
-        """Update an existing task output record in the database.
-
-        Updates fields of a task output record identified by task_index. The fields
-        to update are provided as keyword arguments.
-
-        Args:
-            task_index: Integer index of the task to update.
-            **kwargs: Arbitrary keyword arguments representing fields to update.
-                     Values that are dictionaries will be JSON encoded.
-
-        Raises:
-            DatabaseOperationError: If updating the task output fails due to SQLite errors.
+        **kwargs,
+    ):
+        """
+        Updates an existing row in the latest_kickoff_task_outputs table based on task_index.
         """
         try:
             with sqlite3.connect(self.db_path) as conn:
-                conn.execute("BEGIN TRANSACTION")
                 cursor = conn.cursor()
 
                 fields = []
@@ -146,23 +110,14 @@ class KickoffTaskOutputsSQLiteStorage:
                 conn.commit()
 
                 if cursor.rowcount == 0:
-                    logger.warning(f"No row found with task_index {task_index}. No update performed.")
+                    self._printer.print(
+                        f"No row found with task_index {task_index}. No update performed.",
+                        color="red",
+                    )
         except sqlite3.Error as e:
-            error_msg = DatabaseError.format_error(DatabaseError.UPDATE_ERROR, e)
-            logger.error(error_msg)
-            raise DatabaseOperationError(error_msg, e)
+            self._printer.print(f"UPDATE KICKOFF TASK OUTPUTS ERROR: {e}", color="red")
 
-    def load(self) -> List[Dict[str, Any]]:
-        """Load all task output records from the database.
-
-        Returns:
-            List of dictionaries containing task output records, ordered by task_index.
-            Each dictionary contains: task_id, expected_output, output, task_index,
-            inputs, was_replayed, and timestamp.
-
-        Raises:
-            DatabaseOperationError: If loading task outputs fails due to SQLite errors.
-        """
+    def load(self) -> Optional[List[Dict[str, Any]]]:
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
@@ -189,26 +144,23 @@ class KickoffTaskOutputsSQLiteStorage:
                 return results
 
         except sqlite3.Error as e:
-            error_msg = DatabaseError.format_error(DatabaseError.LOAD_ERROR, e)
-            logger.error(error_msg)
-            raise DatabaseOperationError(error_msg, e)
+            self._printer.print(
+                content=f"LOADING KICKOFF TASK OUTPUTS ERROR: An error occurred while querying kickoff task outputs: {e}",
+                color="red",
+            )
+            return None
 
-    def delete_all(self) -> None:
-        """Delete all task output records from the database.
-
-        This method removes all records from the latest_kickoff_task_outputs table.
-        Use with caution as this operation cannot be undone.
-
-        Raises:
-            DatabaseOperationError: If deleting task outputs fails due to SQLite errors.
+    def delete_all(self):
+        """
+        Deletes all rows from the latest_kickoff_task_outputs table.
         """
         try:
             with sqlite3.connect(self.db_path) as conn:
-                conn.execute("BEGIN TRANSACTION")
                 cursor = conn.cursor()
                 cursor.execute("DELETE FROM latest_kickoff_task_outputs")
                 conn.commit()
         except sqlite3.Error as e:
-            error_msg = DatabaseError.format_error(DatabaseError.DELETE_ERROR, e)
-            logger.error(error_msg)
-            raise DatabaseOperationError(error_msg, e)
+            self._printer.print(
+                content=f"ERROR: Failed to delete all kickoff task outputs: {e}",
+                color="red",
+            )

src/crewai/memory/storage/ltm_sqlite_storage.py

@@ -1,6 +1,5 @@
 import json
 import sqlite3
-from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
 from crewai.utilities import Printer
@@ -13,15 +12,10 @@ class LTMSQLiteStorage:
     """
 
     def __init__(
-        self, db_path: Optional[str] = None
+        self, db_path: str = f"{db_storage_path()}/long_term_memory_storage.db"
     ) -> None:
-        if db_path is None:
-            # Get the parent directory of the default db path and create our db file there
-            db_path = str(Path(db_storage_path()).parent / "long_term_memory_storage.db")
         self.db_path = db_path
         self._printer: Printer = Printer()
-        # Ensure parent directory exists
-        Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
         self._initialize_db()
 
     def _initialize_db(self):

src/crewai/translations/en.json

@@ -43,7 +43,7 @@
     "ask_question": "Ask a specific question to one of the following coworkers: {coworkers}\nThe input to this tool should be the coworker, the question you have for them, and ALL necessary context to ask the question properly, they know nothing about the question, so share absolute everything you know, don't reference things but instead explain them.",
     "add_image": {
       "name": "Add image to content",
-      "description": "See image to understand its content, you can optionally ask a question about the image",
+      "description": "See image to understand it's content, you can optionally ask a question about the image",
       "default_action": "Please provide a detailed description of this image, including all visual elements, context, and any notable details you can observe."
     }
   }

src/crewai/utilities/converter.py

@@ -26,24 +26,17 @@ class Converter(OutputConverter):
             if self.llm.supports_function_calling():
                 return self._create_instructor().to_pydantic()
             else:
-                response = self.llm.call(
+                return self.llm.call(
                     [
                         {"role": "system", "content": self.instructions},
                         {"role": "user", "content": self.text},
                     ]
                 )
-                return self.model.model_validate_json(response)
-        except ValidationError as e:
-            if current_attempt < self.max_attempts:
-                return self.to_pydantic(current_attempt + 1)
-            raise ConverterError(
-                f"Failed to convert text into a Pydantic model due to the following validation error: {e}"
-            )
         except Exception as e:
             if current_attempt < self.max_attempts:
                 return self.to_pydantic(current_attempt + 1)
-            raise ConverterError(
-                f"Failed to convert text into a Pydantic model due to the following error: {e}"
+            return ConverterError(
+                f"Failed to convert text into a pydantic model due to the following error: {e}"
             )
 
     def to_json(self, current_attempt=1):
@@ -73,6 +66,7 @@ class Converter(OutputConverter):
             llm=self.llm,
             model=self.model,
             content=self.text,
+            instructions=self.instructions,
         )
         return inst
 
@@ -193,15 +187,10 @@ def convert_with_instructions(
 
 
 def get_conversion_instructions(model: Type[BaseModel], llm: Any) -> str:
-    instructions = "Please convert the following text into valid JSON."
+    instructions = "I'm gonna convert this raw text into valid JSON."
     if llm.supports_function_calling():
         model_schema = PydanticSchemaParser(model=model).get_schema()
-        instructions += (
-            f"\n\nThe JSON should follow this schema:\n```json\n{model_schema}\n```"
-        )
-    else:
-        model_description = generate_model_description(model)
-        instructions += f"\n\nThe JSON should follow this format:\n{model_description}"
+        instructions = f"{instructions}\n\nThe json should have the following structure, with the following keys:\n{model_schema}"
     return instructions
 
 

src/crewai/utilities/errors.py

@@ -1,39 +0,0 @@
-"""Error message definitions for CrewAI database operations."""
-from typing import Optional
-
-
-class DatabaseOperationError(Exception):
-    """Base exception class for database operation errors."""
-
-    def __init__(self, message: str, original_error: Optional[Exception] = None):
-        """Initialize the database operation error.
-
-        Args:
-            message: The error message to display
-            original_error: The original exception that caused this error, if any
-        """
-        super().__init__(message)
-        self.original_error = original_error
-
-
-class DatabaseError:
-    """Standardized error message templates for database operations."""
-
-    INIT_ERROR: str = "Database initialization error: {}"
-    SAVE_ERROR: str = "Error saving task outputs: {}"
-    UPDATE_ERROR: str = "Error updating task outputs: {}"
-    LOAD_ERROR: str = "Error loading task outputs: {}"
-    DELETE_ERROR: str = "Error deleting task outputs: {}"
-
-    @classmethod
-    def format_error(cls, template: str, error: Exception) -> str:
-        """Format an error message with the given template and error.
-
-        Args:
-            template: The error message template to use
-            error: The exception to format into the template
-
-        Returns:
-            The formatted error message
-        """
-        return template.format(str(error))

src/crewai/utilities/internal_instructor.py

@@ -11,10 +11,12 @@ class InternalInstructor:
         model: Type,
         agent: Optional[Any] = None,
         llm: Optional[str] = None,
+        instructions: Optional[str] = None,
     ):
         self.content = content
         self.agent = agent
         self.llm = llm
+        self.instructions = instructions
         self.model = model
         self._client = None
         self.set_instructor()
@@ -29,7 +31,10 @@ class InternalInstructor:
             import instructor
             from litellm import completion
 
-            self._client = instructor.from_litellm(completion)
+            self._client = instructor.from_litellm(
+                completion,
+                mode=instructor.Mode.TOOLS,
+            )
 
     def to_json(self):
         model = self.to_pydantic()
@@ -37,6 +42,8 @@ class InternalInstructor:
 
     def to_pydantic(self):
         messages = [{"role": "user", "content": self.content}]
+        if self.instructions:
+            messages.append({"role": "system", "content": self.instructions})
         model = self._client.chat.completions.create(
             model=self.llm.model, response_model=self.model, messages=messages
         )

src/crewai/utilities/paths.py

@@ -5,18 +5,14 @@ import appdirs
 
 """Path management utilities for CrewAI storage and configuration."""
 
-def db_storage_path() -> str:
-    """Returns the path for SQLite database storage.
-    
-    Returns:
-        str: Full path to the SQLite database file
-    """
+def db_storage_path():
+    """Returns the path for database storage."""
     app_name = get_project_directory_name()
     app_author = "CrewAI"
 
     data_dir = Path(appdirs.user_data_dir(app_name, app_author))
     data_dir.mkdir(parents=True, exist_ok=True)
-    return str(data_dir / "crewai_flows.db")
+    return data_dir
 
 
 def get_project_directory_name():

src/crewai/utilities/pydantic_schema_parser.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Type, Union, get_args, get_origin
+from typing import Type, Union, get_args, get_origin
 
 from pydantic import BaseModel
 
@@ -10,83 +10,40 @@ class PydanticSchemaParser(BaseModel):
         """
         Public method to get the schema of a Pydantic model.
 
+        :param model: The Pydantic model class to generate schema for.
         :return: String representation of the model schema.
         """
-        return "{\n" + self._get_model_schema(self.model) + "\n}"
+        return self._get_model_schema(self.model)
 
-    def _get_model_schema(self, model: Type[BaseModel], depth: int = 0) -> str:
-        indent = " " * 4 * depth
-        lines = [
-            f"{indent}    {field_name}: {self._get_field_type(field, depth + 1)}"
-            for field_name, field in model.model_fields.items()
-        ]
-        return ",\n".join(lines)
+    def _get_model_schema(self, model, depth=0) -> str:
+        indent = "    " * depth
+        lines = [f"{indent}{{"]
+        for field_name, field in model.model_fields.items():
+            field_type_str = self._get_field_type(field, depth + 1)
+            lines.append(f"{indent}    {field_name}: {field_type_str},")
+        lines[-1] = lines[-1].rstrip(",")  # Remove trailing comma from last item
+        lines.append(f"{indent}}}")
+        return "\n".join(lines)
 
-    def _get_field_type(self, field, depth: int) -> str:
+    def _get_field_type(self, field, depth) -> str:
         field_type = field.annotation
-        origin = get_origin(field_type)
-
-        if origin in {list, List}:
+        if get_origin(field_type) is list:
             list_item_type = get_args(field_type)[0]
-            return self._format_list_type(list_item_type, depth)
-
-        if origin in {dict, Dict}:
-            key_type, value_type = get_args(field_type)
-            return f"Dict[{key_type.__name__}, {value_type.__name__}]"
-
-        if origin is Union:
-            return self._format_union_type(field_type, depth)
-
-        if isinstance(field_type, type) and issubclass(field_type, BaseModel):
-            nested_schema = self._get_model_schema(field_type, depth)
-            nested_indent = " " * 4 * depth
-            return f"{field_type.__name__}\n{nested_indent}{{\n{nested_schema}\n{nested_indent}}}"
-
-        return field_type.__name__
-
-    def _format_list_type(self, list_item_type, depth: int) -> str:
-        if isinstance(list_item_type, type) and issubclass(list_item_type, BaseModel):
-            nested_schema = self._get_model_schema(list_item_type, depth + 1)
-            nested_indent = " " * 4 * (depth)
-            return f"List[\n{nested_indent}{{\n{nested_schema}\n{nested_indent}}}\n{nested_indent}]"
-        return f"List[{list_item_type.__name__}]"
-
-    def _format_union_type(self, field_type, depth: int) -> str:
-        args = get_args(field_type)
-        if type(None) in args:
-            # It's an Optional type
-            non_none_args = [arg for arg in args if arg is not type(None)]
-            if len(non_none_args) == 1:
-                inner_type = self._get_field_type_for_annotation(
-                    non_none_args[0], depth
-                )
-                return f"Optional[{inner_type}]"
+            if isinstance(list_item_type, type) and issubclass(
+                list_item_type, BaseModel
+            ):
+                nested_schema = self._get_model_schema(list_item_type, depth + 1)
+                return f"List[\n{nested_schema}\n{' ' * 4 * depth}]"
             else:
-                # Union with None and multiple other types
-                inner_types = ", ".join(
-                    self._get_field_type_for_annotation(arg, depth)
-                    for arg in non_none_args
-                )
-                return f"Optional[Union[{inner_types}]]"
+                return f"List[{list_item_type.__name__}]"
+        elif get_origin(field_type) is Union:
+            union_args = get_args(field_type)
+            if type(None) in union_args:
+                non_none_type = next(arg for arg in union_args if arg is not type(None))
+                return f"Optional[{self._get_field_type(field.__class__(annotation=non_none_type), depth)}]"
+            else:
+                return f"Union[{', '.join(arg.__name__ for arg in union_args)}]"
+        elif isinstance(field_type, type) and issubclass(field_type, BaseModel):
+            return self._get_model_schema(field_type, depth)
         else:
-            # General Union type
-            inner_types = ", ".join(
-                self._get_field_type_for_annotation(arg, depth) for arg in args
-            )
-            return f"Union[{inner_types}]"
-
-    def _get_field_type_for_annotation(self, annotation, depth: int) -> str:
-        origin = get_origin(annotation)
-        if origin in {list, List}:
-            list_item_type = get_args(annotation)[0]
-            return self._format_list_type(list_item_type, depth)
-        if origin in {dict, Dict}:
-            key_type, value_type = get_args(annotation)
-            return f"Dict[{key_type.__name__}, {value_type.__name__}]"
-        if origin is Union:
-            return self._format_union_type(annotation, depth)
-        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
-            nested_schema = self._get_model_schema(annotation, depth)
-            nested_indent = " " * 4 * depth
-            return f"{annotation.__name__}\n{nested_indent}{{\n{nested_schema}\n{nested_indent}}}"
-        return annotation.__name__
+            return getattr(field_type, "__name__", str(field_type))

src/crewai/utilities/token_counter_callback.py

@@ -23,15 +23,11 @@ class TokenCalcHandler(CustomLogger):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", UserWarning)
-            if isinstance(response_obj, dict) and "usage" in response_obj:
-                usage: Usage = response_obj["usage"]
-                if usage:
-                    self.token_cost_process.sum_successful_requests(1)
-                    if hasattr(usage, "prompt_tokens"):
-                        self.token_cost_process.sum_prompt_tokens(usage.prompt_tokens)
-                    if hasattr(usage, "completion_tokens"):
-                        self.token_cost_process.sum_completion_tokens(usage.completion_tokens)
-                    if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details:
-                        self.token_cost_process.sum_cached_prompt_tokens(
-                            usage.prompt_tokens_details.cached_tokens
-                        )
+            usage: Usage = response_obj["usage"]
+            self.token_cost_process.sum_successful_requests(1)
+            self.token_cost_process.sum_prompt_tokens(usage.prompt_tokens)
+            self.token_cost_process.sum_completion_tokens(usage.completion_tokens)
+            if usage.prompt_tokens_details:
+                self.token_cost_process.sum_cached_prompt_tokens(
+                    usage.prompt_tokens_details.cached_tokens
+                )

tests/cassettes/test_agent_human_input.yaml

@@ -1,87 +1,4 @@
 interactions:
-- request:
-    body: !!binary |
-      CqcXCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkS/hYKEgoQY3Jld2FpLnRl
-      bGVtZXRyeRJ5ChBuJJtOdNaB05mOW/p3915eEgj2tkAd3rZcASoQVG9vbCBVc2FnZSBFcnJvcjAB
-      OYa7/URvKBUYQUpcFEVvKBUYShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuODYuMEoPCgNsbG0SCAoG
-      Z3B0LTRvegIYAYUBAAEAABLJBwoQifhX01E5i+5laGdALAlZBBIIBuGM1aN+OPgqDENyZXcgQ3Jl
-      YXRlZDABORVGruBvKBUYQaipwOBvKBUYShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuODYuMEoaCg5w
-      eXRob25fdmVyc2lvbhIICgYzLjEyLjdKLgoIY3Jld19rZXkSIgogN2U2NjA4OTg5ODU5YTY3ZWVj
-      ODhlZWY3ZmNlODUyMjVKMQoHY3Jld19pZBImCiRiOThiNWEwMC01YTI1LTQxMDctYjQwNS1hYmYz
-      MjBhOGYzYThKHAoMY3Jld19wcm9jZXNzEgwKCnNlcXVlbnRpYWxKEQoLY3Jld19tZW1vcnkSAhAA
-      ShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251bWJlcl9vZl9hZ2VudHMSAhgB
-      SuQCCgtjcmV3X2FnZW50cxLUAgrRAlt7ImtleSI6ICIyMmFjZDYxMWU0NGVmNWZhYzA1YjUzM2Q3
-      NWU4ODkzYiIsICJpZCI6ICJkNWIyMzM1YS0yMmIyLTQyZWEtYmYwNS03OTc3NmU3MmYzOTIiLCAi
-      cm9sZSI6ICJEYXRhIFNjaWVudGlzdCIsICJ2ZXJib3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAy
-      MCwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJn
-      cHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4
-      ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFsi
-      Z2V0IGdyZWV0aW5ncyJdfV1KkgIKCmNyZXdfdGFza3MSgwIKgAJbeyJrZXkiOiAiYTI3N2IzNGIy
-      YzE0NmYwYzU2YzVlMTM1NmU4ZjhhNTciLCAiaWQiOiAiMjJiZWMyMzEtY2QyMS00YzU4LTgyN2Ut
-      MDU4MWE4ZjBjMTExIiwgImFzeW5jX2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6
-      IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJEYXRhIFNjaWVudGlzdCIsICJhZ2VudF9rZXkiOiAiMjJh
-      Y2Q2MTFlNDRlZjVmYWMwNWI1MzNkNzVlODg5M2IiLCAidG9vbHNfbmFtZXMiOiBbImdldCBncmVl
-      dGluZ3MiXX1degIYAYUBAAEAABKOAgoQ5WYoxRtTyPjge4BduhL0rRIIv2U6rvWALfwqDFRhc2sg
-      Q3JlYXRlZDABOX068uBvKBUYQZkv8+BvKBUYSi4KCGNyZXdfa2V5EiIKIDdlNjYwODk4OTg1OWE2
-      N2VlYzg4ZWVmN2ZjZTg1MjI1SjEKB2NyZXdfaWQSJgokYjk4YjVhMDAtNWEyNS00MTA3LWI0MDUt
-      YWJmMzIwYThmM2E4Si4KCHRhc2tfa2V5EiIKIGEyNzdiMzRiMmMxNDZmMGM1NmM1ZTEzNTZlOGY4
-      YTU3SjEKB3Rhc2tfaWQSJgokMjJiZWMyMzEtY2QyMS00YzU4LTgyN2UtMDU4MWE4ZjBjMTExegIY
-      AYUBAAEAABKQAQoQXyeDtJDFnyp2Fjk9YEGTpxIIaNE7gbhPNYcqClRvb2wgVXNhZ2UwATkaXTvj
-      bygVGEGvx0rjbygVGEoaCg5jcmV3YWlfdmVyc2lvbhIICgYwLjg2LjBKHAoJdG9vbF9uYW1lEg8K
-      DUdldCBHcmVldGluZ3NKDgoIYXR0ZW1wdHMSAhgBegIYAYUBAAEAABLVBwoQMWfznt0qwauEzl7T
-      UOQxRBII9q+pUS5EdLAqDENyZXcgQ3JlYXRlZDABORONPORvKBUYQSAoS+RvKBUYShoKDmNyZXdh
-      aV92ZXJzaW9uEggKBjAuODYuMEoaCg5weXRob25fdmVyc2lvbhIICgYzLjEyLjdKLgoIY3Jld19r
-      ZXkSIgogYzMwNzYwMDkzMjY3NjE0NDRkNTdjNzFkMWRhM2YyN2NKMQoHY3Jld19pZBImCiQ3OTQw
-      MTkyNS1iOGU5LTQ3MDgtODUzMC00NDhhZmEzYmY4YjBKHAoMY3Jld19wcm9jZXNzEgwKCnNlcXVl
-      bnRpYWxKEQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVj
-      cmV3X251bWJlcl9vZl9hZ2VudHMSAhgBSuoCCgtjcmV3X2FnZW50cxLaAgrXAlt7ImtleSI6ICI5
-      OGYzYjFkNDdjZTk2OWNmMDU3NzI3Yjc4NDE0MjVjZCIsICJpZCI6ICI5OTJkZjYyZi1kY2FiLTQy
-      OTUtOTIwNi05MDBkNDExNGIxZTkiLCAicm9sZSI6ICJGcmllbmRseSBOZWlnaGJvciIsICJ2ZXJi
-      b3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAyMCwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25f
-      Y2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8tbWluaSIsICJkZWxlZ2F0aW9uX2VuYWJs
-      ZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9s
-      aW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFsiZGVjaWRlIGdyZWV0aW5ncyJdfV1KmAIKCmNyZXdf
-      dGFza3MSiQIKhgJbeyJrZXkiOiAiODBkN2JjZDQ5MDk5MjkwMDgzODMyZjBlOTgzMzgwZGYiLCAi
-      aWQiOiAiMmZmNjE5N2UtYmEyNy00YjczLWI0YTctNGZhMDQ4ZTYyYjQ3IiwgImFzeW5jX2V4ZWN1
-      dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJGcmll
-      bmRseSBOZWlnaGJvciIsICJhZ2VudF9rZXkiOiAiOThmM2IxZDQ3Y2U5NjljZjA1NzcyN2I3ODQx
-      NDI1Y2QiLCAidG9vbHNfbmFtZXMiOiBbImRlY2lkZSBncmVldGluZ3MiXX1degIYAYUBAAEAABKO
-      AgoQnjTp5boK7/+DQxztYIpqihIIgGnMUkBtzHEqDFRhc2sgQ3JlYXRlZDABOcpYcuRvKBUYQalE
-      c+RvKBUYSi4KCGNyZXdfa2V5EiIKIGMzMDc2MDA5MzI2NzYxNDQ0ZDU3YzcxZDFkYTNmMjdjSjEK
-      B2NyZXdfaWQSJgokNzk0MDE5MjUtYjhlOS00NzA4LTg1MzAtNDQ4YWZhM2JmOGIwSi4KCHRhc2tf
-      a2V5EiIKIDgwZDdiY2Q0OTA5OTI5MDA4MzgzMmYwZTk4MzM4MGRmSjEKB3Rhc2tfaWQSJgokMmZm
-      NjE5N2UtYmEyNy00YjczLWI0YTctNGZhMDQ4ZTYyYjQ3egIYAYUBAAEAABKTAQoQ26H9pLUgswDN
-      p9XhJwwL6BIIx3bw7mAvPYwqClRvb2wgVXNhZ2UwATmy7NPlbygVGEEvb+HlbygVGEoaCg5jcmV3
-      YWlfdmVyc2lvbhIICgYwLjg2LjBKHwoJdG9vbF9uYW1lEhIKEERlY2lkZSBHcmVldGluZ3NKDgoI
-      YXR0ZW1wdHMSAhgBegIYAYUBAAEAAA==
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '2986'
-      Content-Type:
-      - application/x-protobuf
-      User-Agent:
-      - OTel-OTLP-Exporter-Python/1.27.0
-    method: POST
-    uri: https://telemetry.crewai.com:4319/v1/traces
-  response:
-    body:
-      string: "\n\0"
-    headers:
-      Content-Length:
-      - '2'
-      Content-Type:
-      - application/x-protobuf
-      Date:
-      - Fri, 27 Dec 2024 22:14:53 GMT
-    status:
-      code: 200
-      message: OK
 - request:
     body: '{"messages": [{"role": "system", "content": "You are test role. test backstory\nYour
       personal goal is: test goal\nTo give my best complete final answer to the task
@@ -105,20 +22,18 @@ interactions:
       - '824'
       content-type:
       - application/json
-      cookie:
-      - _cfuvid=ePJSDFdHag2D8lj21_ijAMWjoA6xfnPNxN4uekvC728-1727226247743-0.0.1.1-604800000
       host:
       - api.openai.com
       user-agent:
       - OpenAI/Python 1.52.1
       x-stainless-arch:
-      - x64
+      - arm64
       x-stainless-async:
       - 'false'
       x-stainless-lang:
       - python
       x-stainless-os:
-      - Linux
+      - MacOS
       x-stainless-package-version:
       - 1.52.1
       x-stainless-raw-response:
@@ -132,8 +47,8 @@ interactions:
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
-    content: "{\n  \"id\": \"chatcmpl-AjCtZLLrWi8ZASpP9bz6HaCV7xBIn\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1735337693,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+    content: "{\n  \"id\": \"chatcmpl-AaqIIsTxhvf75xvuu7gQScIlRSKbW\",\n  \"object\":
+      \"chat.completion\",\n  \"created\": 1733344190,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
       \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
       \"assistant\",\n        \"content\": \"I now can give a great answer  \\nFinal
       Answer: Hi\",\n        \"refusal\": null\n      },\n      \"logprobs\": null,\n
@@ -142,12 +57,12 @@ interactions:
       {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
       {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
       0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"system_fingerprint\":
-      \"fp_0aa8d3e20b\"\n}\n"
+      \"fp_0705bf87c0\"\n}\n"
     headers:
       CF-Cache-Status:
       - DYNAMIC
       CF-RAY:
-      - 8f8caa83deca756b-SEA
+      - 8ece8cfc3b1f4532-ATL
       Connection:
       - keep-alive
       Content-Encoding:
@@ -155,14 +70,14 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 27 Dec 2024 22:14:53 GMT
+      - Wed, 04 Dec 2024 20:29:50 GMT
       Server:
       - cloudflare
       Set-Cookie:
-      - __cf_bm=wJkq_yLkzE3OdxE0aMJz.G0kce969.9JxRmZ0ratl4c-1735337693-1.0.1.1-OKpUoRrSPFGvWv5Hp5ET1PNZ7iZNHPKEAuakpcQUxxPSeisUIIR3qIOZ31MGmYugqB5.wkvidgbxOAagqJvmnw;
-        path=/; expires=Fri, 27-Dec-24 22:44:53 GMT; domain=.api.openai.com; HttpOnly;
+      - __cf_bm=QJZZjZ6eqnVamqUkw.Bx0mj7oBi3a_vGEH1VODcUxlg-1733344190-1.0.1.1-xyN0ekA9xIrSwEhRBmTiWJ3Pt72UYLU5owKfkz5yihVmMTfsr_Qz.ssGPJ5cuft066v1xVjb4zOSTdFmesMSKg;
+        path=/; expires=Wed, 04-Dec-24 20:59:50 GMT; domain=.api.openai.com; HttpOnly;
         Secure; SameSite=None
-      - _cfuvid=A_ASCLNAVfQoyucWOAIhecWtEpNotYoZr0bAFihgNxs-1735337693273-0.0.1.1-604800000;
+      - _cfuvid=eCIkP8GVPvpkg19eOhCquWFHm.RTQBQy4yHLGGEAH5c-1733344190334-0.0.1.1-604800000;
         path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
       Transfer-Encoding:
       - chunked
@@ -175,7 +90,7 @@ interactions:
       openai-organization:
       - crewai-iuxna1
       openai-processing-ms:
-      - '404'
+      - '313'
       openai-version:
       - '2020-10-01'
       strict-transport-security:
@@ -193,7 +108,7 @@ interactions:
       x-ratelimit-reset-tokens:
       - 0s
       x-request-id:
-      - req_6ac84634bff9193743c4b0911c09b4a6
+      - req_9fd9a8ee688045dcf7ac5f6fdf689372
     http_version: HTTP/1.1
     status_code: 200
 - request:
@@ -216,20 +131,20 @@ interactions:
       content-type:
       - application/json
       cookie:
-      - _cfuvid=A_ASCLNAVfQoyucWOAIhecWtEpNotYoZr0bAFihgNxs-1735337693273-0.0.1.1-604800000;
-        __cf_bm=wJkq_yLkzE3OdxE0aMJz.G0kce969.9JxRmZ0ratl4c-1735337693-1.0.1.1-OKpUoRrSPFGvWv5Hp5ET1PNZ7iZNHPKEAuakpcQUxxPSeisUIIR3qIOZ31MGmYugqB5.wkvidgbxOAagqJvmnw
+      - __cf_bm=QJZZjZ6eqnVamqUkw.Bx0mj7oBi3a_vGEH1VODcUxlg-1733344190-1.0.1.1-xyN0ekA9xIrSwEhRBmTiWJ3Pt72UYLU5owKfkz5yihVmMTfsr_Qz.ssGPJ5cuft066v1xVjb4zOSTdFmesMSKg;
+        _cfuvid=eCIkP8GVPvpkg19eOhCquWFHm.RTQBQy4yHLGGEAH5c-1733344190334-0.0.1.1-604800000
       host:
       - api.openai.com
       user-agent:
       - OpenAI/Python 1.52.1
       x-stainless-arch:
-      - x64
+      - arm64
       x-stainless-async:
       - 'false'
       x-stainless-lang:
       - python
       x-stainless-os:
-      - Linux
+      - MacOS
       x-stainless-package-version:
       - 1.52.1
       x-stainless-raw-response:
@@ -243,8 +158,8 @@ interactions:
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
-    content: "{\n  \"id\": \"chatcmpl-AjCtZNlWdrrPZhq0MJDqd16sMuQEJ\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1735337693,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+    content: "{\n  \"id\": \"chatcmpl-AaqIIaQlLyoyPmk909PvAIfA2TmJL\",\n  \"object\":
+      \"chat.completion\",\n  \"created\": 1733344190,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
       \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
       \"assistant\",\n        \"content\": \"True\",\n        \"refusal\": null\n
       \     },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n
@@ -253,12 +168,12 @@ interactions:
       0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
       \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
       0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"system_fingerprint\":
-      \"fp_0aa8d3e20b\"\n}\n"
+      \"fp_0705bf87c0\"\n}\n"
     headers:
       CF-Cache-Status:
       - DYNAMIC
       CF-RAY:
-      - 8f8caa87094f756b-SEA
+      - 8ece8d060b5e4532-ATL
       Connection:
       - keep-alive
       Content-Encoding:
@@ -266,7 +181,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 27 Dec 2024 22:14:53 GMT
+      - Wed, 04 Dec 2024 20:29:50 GMT
       Server:
       - cloudflare
       Transfer-Encoding:
@@ -280,7 +195,7 @@ interactions:
       openai-organization:
       - crewai-iuxna1
       openai-processing-ms:
-      - '156'
+      - '375'
       openai-version:
       - '2020-10-01'
       strict-transport-security:
@@ -298,7 +213,7 @@ interactions:
       x-ratelimit-reset-tokens:
       - 0s
       x-request-id:
-      - req_ec74bef2a9ef7b2144c03fd7f7bbeab0
+      - req_be7cb475e0859a82c37ee3f2871ea5ea
     http_version: HTTP/1.1
     status_code: 200
 - request:
@@ -327,20 +242,20 @@ interactions:
       content-type:
       - application/json
       cookie:
-      - _cfuvid=A_ASCLNAVfQoyucWOAIhecWtEpNotYoZr0bAFihgNxs-1735337693273-0.0.1.1-604800000;
-        __cf_bm=wJkq_yLkzE3OdxE0aMJz.G0kce969.9JxRmZ0ratl4c-1735337693-1.0.1.1-OKpUoRrSPFGvWv5Hp5ET1PNZ7iZNHPKEAuakpcQUxxPSeisUIIR3qIOZ31MGmYugqB5.wkvidgbxOAagqJvmnw
+      - __cf_bm=QJZZjZ6eqnVamqUkw.Bx0mj7oBi3a_vGEH1VODcUxlg-1733344190-1.0.1.1-xyN0ekA9xIrSwEhRBmTiWJ3Pt72UYLU5owKfkz5yihVmMTfsr_Qz.ssGPJ5cuft066v1xVjb4zOSTdFmesMSKg;
+        _cfuvid=eCIkP8GVPvpkg19eOhCquWFHm.RTQBQy4yHLGGEAH5c-1733344190334-0.0.1.1-604800000
       host:
       - api.openai.com
       user-agent:
       - OpenAI/Python 1.52.1
       x-stainless-arch:
-      - x64
+      - arm64
       x-stainless-async:
       - 'false'
       x-stainless-lang:
       - python
       x-stainless-os:
-      - Linux
+      - MacOS
       x-stainless-package-version:
       - 1.52.1
       x-stainless-raw-response:
@@ -354,23 +269,22 @@ interactions:
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
-    content: "{\n  \"id\": \"chatcmpl-AjCtZGv4f3h7GDdhyOy9G0sB1lRgC\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1735337693,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+    content: "{\n  \"id\": \"chatcmpl-AaqIJAAxpVfUOdrsgYKHwfRlHv4RS\",\n  \"object\":
+      \"chat.completion\",\n  \"created\": 1733344191,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
       \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-      \"assistant\",\n        \"content\": \"Thought: I understand the feedback and
-      will adjust my response accordingly.  \\nFinal Answer: Hello\",\n        \"refusal\":
-      null\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
-      \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 188,\n    \"completion_tokens\":
-      18,\n    \"total_tokens\": 206,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-      0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
-      \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+      \"assistant\",\n        \"content\": \"Thought: I now can give a great answer
+      \ \\nFinal Answer: Hello\",\n        \"refusal\": null\n      },\n      \"logprobs\":
+      null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+      188,\n    \"completion_tokens\": 14,\n    \"total_tokens\": 202,\n    \"prompt_tokens_details\":
+      {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+      {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
       0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"system_fingerprint\":
-      \"fp_0aa8d3e20b\"\n}\n"
+      \"fp_0705bf87c0\"\n}\n"
     headers:
       CF-Cache-Status:
       - DYNAMIC
       CF-RAY:
-      - 8f8caa88cac4756b-SEA
+      - 8ece8d090fc34532-ATL
       Connection:
       - keep-alive
       Content-Encoding:
@@ -378,7 +292,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 27 Dec 2024 22:14:54 GMT
+      - Wed, 04 Dec 2024 20:29:51 GMT
       Server:
       - cloudflare
       Transfer-Encoding:
@@ -392,7 +306,7 @@ interactions:
       openai-organization:
       - crewai-iuxna1
       openai-processing-ms:
-      - '358'
+      - '484'
       openai-version:
       - '2020-10-01'
       strict-transport-security:
@@ -410,7 +324,7 @@ interactions:
       x-ratelimit-reset-tokens:
       - 0s
       x-request-id:
-      - req_ae1ab6b206d28ded6fee3c83ed0c2ab7
+      - req_5bf4a565ad6c2567a1ed204ecac89134
     http_version: HTTP/1.1
     status_code: 200
 - request:
@@ -432,20 +346,20 @@ interactions:
       content-type:
       - application/json
       cookie:
-      - _cfuvid=A_ASCLNAVfQoyucWOAIhecWtEpNotYoZr0bAFihgNxs-1735337693273-0.0.1.1-604800000;
-        __cf_bm=wJkq_yLkzE3OdxE0aMJz.G0kce969.9JxRmZ0ratl4c-1735337693-1.0.1.1-OKpUoRrSPFGvWv5Hp5ET1PNZ7iZNHPKEAuakpcQUxxPSeisUIIR3qIOZ31MGmYugqB5.wkvidgbxOAagqJvmnw
+      - __cf_bm=QJZZjZ6eqnVamqUkw.Bx0mj7oBi3a_vGEH1VODcUxlg-1733344190-1.0.1.1-xyN0ekA9xIrSwEhRBmTiWJ3Pt72UYLU5owKfkz5yihVmMTfsr_Qz.ssGPJ5cuft066v1xVjb4zOSTdFmesMSKg;
+        _cfuvid=eCIkP8GVPvpkg19eOhCquWFHm.RTQBQy4yHLGGEAH5c-1733344190334-0.0.1.1-604800000
       host:
       - api.openai.com
       user-agent:
       - OpenAI/Python 1.52.1
       x-stainless-arch:
-      - x64
+      - arm64
       x-stainless-async:
       - 'false'
       x-stainless-lang:
       - python
       x-stainless-os:
-      - Linux
+      - MacOS
       x-stainless-package-version:
       - 1.52.1
       x-stainless-raw-response:
@@ -459,8 +373,8 @@ interactions:
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
-    content: "{\n  \"id\": \"chatcmpl-AjCtaiHL4TY8Dssk0j2miqmjrzquy\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1735337694,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+    content: "{\n  \"id\": \"chatcmpl-AaqIJqyG8vl9mxj2qDPZgaxyNLLIq\",\n  \"object\":
+      \"chat.completion\",\n  \"created\": 1733344191,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
       \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
       \"assistant\",\n        \"content\": \"False\",\n        \"refusal\": null\n
       \     },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n
@@ -469,12 +383,12 @@ interactions:
       0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
       \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
       0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"system_fingerprint\":
-      \"fp_0aa8d3e20b\"\n}\n"
+      \"fp_0705bf87c0\"\n}\n"
     headers:
       CF-Cache-Status:
       - DYNAMIC
       CF-RAY:
-      - 8f8caa8bdd26756b-SEA
+      - 8ece8d0cfdeb4532-ATL
       Connection:
       - keep-alive
       Content-Encoding:
@@ -482,7 +396,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 27 Dec 2024 22:14:54 GMT
+      - Wed, 04 Dec 2024 20:29:51 GMT
       Server:
       - cloudflare
       Transfer-Encoding:
@@ -496,7 +410,7 @@ interactions:
       openai-organization:
       - crewai-iuxna1
       openai-processing-ms:
-      - '184'
+      - '341'
       openai-version:
       - '2020-10-01'
       strict-transport-security:
@@ -514,7 +428,7 @@ interactions:
       x-ratelimit-reset-tokens:
       - 0s
       x-request-id:
-      - req_652891f79c1104a7a8436275d78a69f1
+      - req_5554bade8ceda00cf364b76a51b708ff
     http_version: HTTP/1.1
     status_code: 200
 version: 1

tests/conftest.py

@@ -1,37 +1,4 @@
 # conftest.py
-import os
-import tempfile
-from pathlib import Path
-
-import pytest
 from dotenv import load_dotenv
 
 load_result = load_dotenv(override=True)
-
-@pytest.fixture(autouse=True)
-def setup_test_environment():
-    """Set up test environment with a temporary directory for SQLite storage."""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Create the directory with proper permissions
-        storage_dir = Path(temp_dir) / "crewai_test_storage"
-        storage_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Validate that the directory was created successfully
-        if not storage_dir.exists() or not storage_dir.is_dir():
-            raise RuntimeError(f"Failed to create test storage directory: {storage_dir}")
-        
-        # Verify directory permissions
-        try:
-            # Try to create a test file to verify write permissions
-            test_file = storage_dir / ".permissions_test"
-            test_file.touch()
-            test_file.unlink()
-        except (OSError, IOError) as e:
-            raise RuntimeError(f"Test storage directory {storage_dir} is not writable: {e}")
-        
-        # Set environment variable to point to the test storage directory
-        os.environ["CREWAI_STORAGE_DIR"] = str(storage_dir)
-        
-        yield
-        
-        # Cleanup is handled automatically when tempfile context exits

tests/crew_test.py

@@ -1228,7 +1228,6 @@ def test_kickoff_for_each_empty_input():
     assert results == []
 
 
-@pytest.mark.vcr(filter_headers=["authorization"])
 def test_kickoff_for_each_invalid_input():
     """Tests if kickoff_for_each raises TypeError for invalid input types."""
 

tests/test_flow_persistence.py

@@ -1,195 +0,0 @@
-"""Test flow state persistence functionality."""
-
-import os
-from typing import Dict, Optional
-
-import pytest
-from pydantic import BaseModel
-
-from crewai.flow.flow import Flow, FlowState, start
-from crewai.flow.persistence import FlowPersistence, persist
-from crewai.flow.persistence.sqlite import SQLiteFlowPersistence
-
-
-class TestState(FlowState):
-    """Test state model with required id field."""
-    counter: int = 0
-    message: str = ""
-
-
-def test_persist_decorator_saves_state(tmp_path):
-    """Test that @persist decorator saves state in SQLite."""
-    db_path = os.path.join(tmp_path, "test_flows.db")
-    persistence = SQLiteFlowPersistence(db_path)
-    
-    class TestFlow(Flow[Dict[str, str]]):
-        initial_state = dict()  # Use dict instance as initial state
-        
-        @start()
-        @persist(persistence)
-        def init_step(self):
-            self.state["message"] = "Hello, World!"
-            self.state["id"] = "test-uuid"  # Ensure we have an ID for persistence
-    
-    # Run flow and verify state is saved
-    flow = TestFlow(persistence=persistence)
-    flow.kickoff()
-    
-    # Load state from DB and verify
-    saved_state = persistence.load_state(flow.state["id"])
-    assert saved_state is not None
-    assert saved_state["message"] == "Hello, World!"
-
-
-def test_structured_state_persistence(tmp_path):
-    """Test persistence with Pydantic model state."""
-    db_path = os.path.join(tmp_path, "test_flows.db")
-    persistence = SQLiteFlowPersistence(db_path)
-    
-    class StructuredFlow(Flow[TestState]):
-        initial_state = TestState
-        
-        @start()
-        @persist(persistence)
-        def count_up(self):
-            self.state.counter += 1
-            self.state.message = f"Count is {self.state.counter}"
-    
-    # Run flow and verify state changes are saved
-    flow = StructuredFlow(persistence=persistence)
-    flow.kickoff()
-    
-    # Load and verify state
-    saved_state = persistence.load_state(flow.state.id)
-    assert saved_state is not None
-    assert saved_state["counter"] == 1
-    assert saved_state["message"] == "Count is 1"
-
-
-def test_flow_state_restoration(tmp_path):
-    """Test restoring flow state from persistence with various restoration methods."""
-    db_path = os.path.join(tmp_path, "test_flows.db")
-    persistence = SQLiteFlowPersistence(db_path)
-    
-    # First flow execution to create initial state
-    class RestorableFlow(Flow[TestState]):
-        initial_state = TestState
-        
-        @start()
-        @persist(persistence)
-        def set_message(self):
-            self.state.message = "Original message"
-            self.state.counter = 42
-    
-    # Create and persist initial state
-    flow1 = RestorableFlow(persistence=persistence)
-    flow1.kickoff()
-    original_uuid = flow1.state.id
-    
-    # Test case 1: Restore using restore_uuid with field override
-    flow2 = RestorableFlow(
-        persistence=persistence,
-        restore_uuid=original_uuid,
-        counter=43,  # Override counter
-    )
-    
-    # Verify state restoration and selective field override
-    assert flow2.state.id == original_uuid
-    assert flow2.state.message == "Original message"  # Preserved
-    assert flow2.state.counter == 43  # Overridden
-    
-    # Test case 2: Restore using kwargs['id']
-    flow3 = RestorableFlow(
-        persistence=persistence,
-        id=original_uuid,
-        message="Updated message",  # Override message
-    )
-    
-    # Verify state restoration and selective field override
-    assert flow3.state.id == original_uuid
-    assert flow3.state.counter == 42  # Preserved
-    assert flow3.state.message == "Updated message"  # Overridden
-    
-    # Test case 3: Verify error on conflicting IDs
-    with pytest.raises(ValueError) as exc_info:
-        RestorableFlow(
-            persistence=persistence,
-            restore_uuid=original_uuid,
-            id="different-id",  # Conflict with restore_uuid
-        )
-    assert "Conflicting IDs provided" in str(exc_info.value)
-    
-    # Test case 4: Verify error on non-existent restore_uuid
-    with pytest.raises(ValueError) as exc_info:
-        RestorableFlow(
-            persistence=persistence,
-            restore_uuid="non-existent-uuid",
-        )
-    assert "No state found" in str(exc_info.value)
-    
-    # Test case 5: Allow new state creation with kwargs['id']
-    new_uuid = "new-flow-id"
-    flow4 = RestorableFlow(
-        persistence=persistence,
-        id=new_uuid,
-        message="New message",
-        counter=100,
-    )
-    
-    # Verify new state creation with provided ID
-    assert flow4.state.id == new_uuid
-    assert flow4.state.message == "New message"
-    assert flow4.state.counter == 100
-
-
-def test_multiple_method_persistence(tmp_path):
-    """Test state persistence across multiple method executions."""
-    db_path = os.path.join(tmp_path, "test_flows.db")
-    persistence = SQLiteFlowPersistence(db_path)
-    
-    class MultiStepFlow(Flow[TestState]):
-        initial_state = TestState
-        
-        @start()
-        @persist(persistence)
-        def step_1(self):
-            self.state.counter = 1
-            self.state.message = "Step 1"
-        
-        @start()
-        @persist(persistence)
-        def step_2(self):
-            self.state.counter = 2
-            self.state.message = "Step 2"
-    
-    flow = MultiStepFlow(persistence=persistence)
-    flow.kickoff()
-    
-    # Load final state
-    final_state = persistence.load_state(flow.state.id)
-    assert final_state is not None
-    assert final_state["counter"] == 2
-    assert final_state["message"] == "Step 2"
-
-
-def test_persistence_error_handling(tmp_path):
-    """Test error handling in persistence operations."""
-    db_path = os.path.join(tmp_path, "test_flows.db")
-    persistence = SQLiteFlowPersistence(db_path)
-    
-    class InvalidFlow(Flow[TestState]):
-        # Missing id field in initial state
-        class InvalidState(BaseModel):
-            value: str = ""
-            
-        initial_state = InvalidState
-        
-        @start()
-        @persist(persistence)
-        def will_fail(self):
-            self.state.value = "test"
-    
-    with pytest.raises(ValueError) as exc_info:
-        flow = InvalidFlow(persistence=persistence)
-    
-    assert "must have an 'id' field" in str(exc_info.value)

tests/utilities/cassettes/test_convert_with_instructions.yaml

@@ -1,114 +0,0 @@
-interactions:
-- request:
-    body: '{"messages": [{"role": "user", "content": "Name: Alice, Age: 30"}], "model":
-      "gpt-4o-mini", "tool_choice": {"type": "function", "function": {"name": "SimpleModel"}},
-      "tools": [{"type": "function", "function": {"name": "SimpleModel", "description":
-      "Correctly extracted `SimpleModel` with all the required parameters with correct
-      types", "parameters": {"properties": {"name": {"title": "Name", "type": "string"},
-      "age": {"title": "Age", "type": "integer"}}, "required": ["age", "name"], "type":
-      "object"}}}]}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '507'
-      content-type:
-      - application/json
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.59.6
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.59.6
-      x-stainless-raw-response:
-      - 'true'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.7
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    content: "{\n  \"id\": \"chatcmpl-Aq4a4xDv8G0i4fbTtPJEI2B8UNBup\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1736974028,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-      \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-      \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
-      \           \"id\": \"call_uO5nec8hTk1fpYINM8TUafhe\",\n            \"type\":
-      \"function\",\n            \"function\": {\n              \"name\": \"SimpleModel\",\n
-      \             \"arguments\": \"{\\\"name\\\":\\\"Alice\\\",\\\"age\\\":30}\"\n
-      \           }\n          }\n        ],\n        \"refusal\": null\n      },\n
-      \     \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n
-      \ \"usage\": {\n    \"prompt_tokens\": 79,\n    \"completion_tokens\": 10,\n
-      \   \"total_tokens\": 89,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-      0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
-      \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-      0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-      \"default\",\n  \"system_fingerprint\": \"fp_72ed7ab54c\"\n}\n"
-    headers:
-      CF-Cache-Status:
-      - DYNAMIC
-      CF-RAY:
-      - 9028b81aeb1cb05f-ATL
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Wed, 15 Jan 2025 20:47:08 GMT
-      Server:
-      - cloudflare
-      Set-Cookie:
-      - __cf_bm=PzayZLF04c14veGc.0ocVg3VHBbpzKRW8Hqox8L9U7c-1736974028-1.0.1.1-mZpK8.SH9l7K2z8Tvt6z.dURiVPjFqEz7zYEITfRwdr5z0razsSebZGN9IRPmI5XC_w5rbZW2Kg6hh5cenXinQ;
-        path=/; expires=Wed, 15-Jan-25 21:17:08 GMT; domain=.api.openai.com; HttpOnly;
-        Secure; SameSite=None
-      - _cfuvid=ciwC3n2Srn20xx4JhEUeN6Ap0tNBaE44S95nIilboQ0-1736974028496-0.0.1.1-604800000;
-        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '439'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      x-ratelimit-limit-requests:
-      - '30000'
-      x-ratelimit-limit-tokens:
-      - '150000000'
-      x-ratelimit-remaining-requests:
-      - '29999'
-      x-ratelimit-remaining-tokens:
-      - '149999978'
-      x-ratelimit-reset-requests:
-      - 2ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_a468000458b9d2848b7497b2e3d485a3
-    http_version: HTTP/1.1
-    status_code: 200
-version: 1

tests/utilities/cassettes/test_converter_with_llama3_2_model.yaml

@@ -1,869 +0,0 @@
-interactions:
-- request:
-    body: '{"model": "llama3.2:3b", "prompt": "### User:\nName: Alice Llama, Age:
-      30\n\n### System:\nProduce JSON OUTPUT ONLY! Adhere to this format {\"name\":
-      \"function_name\", \"arguments\":{\"argument_name\": \"argument_value\"}} The
-      following functions are available to you:\n{''type'': ''function'', ''function'':
-      {''name'': ''SimpleModel'', ''description'': ''Correctly extracted `SimpleModel`
-      with all the required parameters with correct types'', ''parameters'': {''properties'':
-      {''name'': {''title'': ''Name'', ''type'': ''string''}, ''age'': {''title'':
-      ''Age'', ''type'': ''integer''}}, ''required'': [''age'', ''name''], ''type'':
-      ''object''}}}\n\n\n", "options": {}, "stream": false, "format": "json"}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '657'
-      host:
-      - localhost:11434
-      user-agent:
-      - litellm/1.57.4
-    method: POST
-    uri: http://localhost:11434/api/generate
-  response:
-    content: '{"model":"llama3.2:3b","created_at":"2025-01-15T20:47:11.926411Z","response":"{\"name\":
-      \"SimpleModel\", \"arguments\":{\"name\": \"Alice Llama\", \"age\": 30}}","done":true,"done_reason":"stop","context":[128006,9125,128007,271,38766,1303,33025,2696,25,6790,220,2366,18,271,128009,128006,882,128007,271,14711,2724,512,678,25,30505,445,81101,11,13381,25,220,966,271,14711,744,512,1360,13677,4823,32090,27785,0,2467,6881,311,420,3645,5324,609,794,330,1723,1292,498,330,16774,23118,14819,1292,794,330,14819,3220,32075,578,2768,5865,527,2561,311,499,512,13922,1337,1232,364,1723,518,364,1723,1232,5473,609,1232,364,16778,1747,518,364,4789,1232,364,34192,398,28532,1595,16778,1747,63,449,682,279,2631,5137,449,4495,4595,518,364,14105,1232,5473,13495,1232,5473,609,1232,5473,2150,1232,364,678,518,364,1337,1232,364,928,25762,364,425,1232,5473,2150,1232,364,17166,518,364,1337,1232,364,11924,8439,2186,364,6413,1232,2570,425,518,364,609,4181,364,1337,1232,364,1735,23742,3818,128009,128006,78191,128007,271,5018,609,794,330,16778,1747,498,330,16774,23118,609,794,330,62786,445,81101,498,330,425,794,220,966,3500],"total_duration":3374470708,"load_duration":1075750500,"prompt_eval_count":167,"prompt_eval_duration":1871000000,"eval_count":24,"eval_duration":426000000}'
-    headers:
-      Content-Length:
-      - '1263'
-      Content-Type:
-      - application/json; charset=utf-8
-      Date:
-      - Wed, 15 Jan 2025 20:47:12 GMT
-    http_version: HTTP/1.1
-    status_code: 200
-- request:
-    body: '{"name": "llama3.2:3b"}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '23'
-      content-type:
-      - application/json
-      host:
-      - localhost:11434
-      user-agent:
-      - litellm/1.57.4
-    method: POST
-    uri: http://localhost:11434/api/show
-  response:
-    content: "{\"license\":\"LLAMA 3.2 COMMUNITY LICENSE AGREEMENT\\nLlama 3.2 Version
-      Release Date: September 25, 2024\\n\\n\u201CAgreement\u201D means the terms
-      and conditions for use, reproduction, distribution \\nand modification of the
-      Llama Materials set forth herein.\\n\\n\u201CDocumentation\u201D means the specifications,
-      manuals and documentation accompanying Llama 3.2\\ndistributed by Meta at https://llama.meta.com/doc/overview.\\n\\n\u201CLicensee\u201D
-      or \u201Cyou\u201D means you, or your employer or any other person or entity
-      (if you are \\nentering into this Agreement on such person or entity\u2019s
-      behalf), of the age required under\\napplicable laws, rules or regulations to
-      provide legal consent and that has legal authority\\nto bind your employer or
-      such other person or entity if you are entering in this Agreement\\non their
-      behalf.\\n\\n\u201CLlama 3.2\u201D means the foundational large language models
-      and software and algorithms, including\\nmachine-learning model code, trained
-      model weights, inference-enabling code, training-enabling code,\\nfine-tuning
-      enabling code and other elements of the foregoing distributed by Meta at \\nhttps://www.llama.com/llama-downloads.\\n\\n\u201CLlama
-      Materials\u201D means, collectively, Meta\u2019s proprietary Llama 3.2 and Documentation
-      (and \\nany portion thereof) made available under this Agreement.\\n\\n\u201CMeta\u201D
-      or \u201Cwe\u201D means Meta Platforms Ireland Limited (if you are located in
-      or, \\nif you are an entity, your principal place of business is in the EEA
-      or Switzerland) \\nand Meta Platforms, Inc. (if you are located outside of the
-      EEA or Switzerland). \\n\\n\\nBy clicking \u201CI Accept\u201D below or by using
-      or distributing any portion or element of the Llama Materials,\\nyou agree to
-      be bound by this Agreement.\\n\\n\\n1. License Rights and Redistribution.\\n\\n
-      \   a. Grant of Rights. You are granted a non-exclusive, worldwide, \\nnon-transferable
-      and royalty-free limited license under Meta\u2019s intellectual property or
-      other rights \\nowned by Meta embodied in the Llama Materials to use, reproduce,
-      distribute, copy, create derivative works \\nof, and make modifications to the
-      Llama Materials.  \\n\\n    b. Redistribution and Use.  \\n\\n        i. If
-      you distribute or make available the Llama Materials (or any derivative works
-      thereof), \\nor a product or service (including another AI model) that contains
-      any of them, you shall (A) provide\\na copy of this Agreement with any such
-      Llama Materials; and (B) prominently display \u201CBuilt with Llama\u201D\\non
-      a related website, user interface, blogpost, about page, or product documentation.
-      If you use the\\nLlama Materials or any outputs or results of the Llama Materials
-      to create, train, fine tune, or\\notherwise improve an AI model, which is distributed
-      or made available, you shall also include \u201CLlama\u201D\\nat the beginning
-      of any such AI model name.\\n\\n        ii. If you receive Llama Materials,
-      or any derivative works thereof, from a Licensee as part\\nof an integrated
-      end user product, then Section 2 of this Agreement will not apply to you. \\n\\n
-      \       iii. You must retain in all copies of the Llama Materials that you distribute
-      the \\nfollowing attribution notice within a \u201CNotice\u201D text file distributed
-      as a part of such copies: \\n\u201CLlama 3.2 is licensed under the Llama 3.2
-      Community License, Copyright \xA9 Meta Platforms,\\nInc. All Rights Reserved.\u201D\\n\\n
-      \       iv. Your use of the Llama Materials must comply with applicable laws
-      and regulations\\n(including trade compliance laws and regulations) and adhere
-      to the Acceptable Use Policy for\\nthe Llama Materials (available at https://www.llama.com/llama3_2/use-policy),
-      which is hereby \\nincorporated by reference into this Agreement.\\n  \\n2.
-      Additional Commercial Terms. If, on the Llama 3.2 version release date, the
-      monthly active users\\nof the products or services made available by or for
-      Licensee, or Licensee\u2019s affiliates, \\nis greater than 700 million monthly
-      active users in the preceding calendar month, you must request \\na license
-      from Meta, which Meta may grant to you in its sole discretion, and you are not
-      authorized to\\nexercise any of the rights under this Agreement unless or until
-      Meta otherwise expressly grants you such rights.\\n\\n3. Disclaimer of Warranty.
-      UNLESS REQUIRED BY APPLICABLE LAW, THE LLAMA MATERIALS AND ANY OUTPUT AND \\nRESULTS
-      THEREFROM ARE PROVIDED ON AN \u201CAS IS\u201D BASIS, WITHOUT WARRANTIES OF
-      ANY KIND, AND META DISCLAIMS\\nALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND
-      IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES\\nOF TITLE, NON-INFRINGEMENT,
-      MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE\\nFOR
-      DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE LLAMA MATERIALS
-      AND ASSUME ANY RISKS ASSOCIATED\\nWITH YOUR USE OF THE LLAMA MATERIALS AND ANY
-      OUTPUT AND RESULTS.\\n\\n4. Limitation of Liability. IN NO EVENT WILL META OR
-      ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, \\nWHETHER IN CONTRACT,
-      TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT,
-      \\nFOR ANY LOST PROFITS OR ANY INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL,
-      EXEMPLARY OR PUNITIVE DAMAGES, EVEN \\nIF META OR ITS AFFILIATES HAVE BEEN ADVISED
-      OF THE POSSIBILITY OF ANY OF THE FOREGOING.\\n\\n5. Intellectual Property.\\n\\n
-      \   a. No trademark licenses are granted under this Agreement, and in connection
-      with the Llama Materials, \\nneither Meta nor Licensee may use any name or mark
-      owned by or associated with the other or any of its affiliates, \\nexcept as
-      required for reasonable and customary use in describing and redistributing the
-      Llama Materials or as \\nset forth in this Section 5(a). Meta hereby grants
-      you a license to use \u201CLlama\u201D (the \u201CMark\u201D) solely as required
-      \\nto comply with the last sentence of Section 1.b.i. You will comply with Meta\u2019s
-      brand guidelines (currently accessible \\nat https://about.meta.com/brand/resources/meta/company-brand/).
-      All goodwill arising out of your use of the Mark \\nwill inure to the benefit
-      of Meta.\\n\\n    b. Subject to Meta\u2019s ownership of Llama Materials and
-      derivatives made by or for Meta, with respect to any\\n    derivative works
-      and modifications of the Llama Materials that are made by you, as between you
-      and Meta,\\n    you are and will be the owner of such derivative works and modifications.\\n\\n
-      \   c. If you institute litigation or other proceedings against Meta or any
-      entity (including a cross-claim or\\n    counterclaim in a lawsuit) alleging
-      that the Llama Materials or Llama 3.2 outputs or results, or any portion\\n
-      \   of any of the foregoing, constitutes infringement of intellectual property
-      or other rights owned or licensable\\n    by you, then any licenses granted
-      to you under this Agreement shall terminate as of the date such litigation or\\n
-      \   claim is filed or instituted. You will indemnify and hold harmless Meta
-      from and against any claim by any third\\n    party arising out of or related
-      to your use or distribution of the Llama Materials.\\n\\n6. Term and Termination.
-      The term of this Agreement will commence upon your acceptance of this Agreement
-      or access\\nto the Llama Materials and will continue in full force and effect
-      until terminated in accordance with the terms\\nand conditions herein. Meta
-      may terminate this Agreement if you are in breach of any term or condition of
-      this\\nAgreement. Upon termination of this Agreement, you shall delete and cease
-      use of the Llama Materials. Sections 3,\\n4 and 7 shall survive the termination
-      of this Agreement. \\n\\n7. Governing Law and Jurisdiction. This Agreement will
-      be governed and construed under the laws of the State of \\nCalifornia without
-      regard to choice of law principles, and the UN Convention on Contracts for the
-      International\\nSale of Goods does not apply to this Agreement. The courts of
-      California shall have exclusive jurisdiction of\\nany dispute arising out of
-      this Agreement.\\n**Llama 3.2** **Acceptable Use Policy**\\n\\nMeta is committed
-      to promoting safe and fair use of its tools and features, including Llama 3.2.
-      If you access or use Llama 3.2, you agree to this Acceptable Use Policy (\u201C**Policy**\u201D).
-      The most recent copy of this policy can be found at [https://www.llama.com/llama3_2/use-policy](https://www.llama.com/llama3_2/use-policy).\\n\\n**Prohibited
-      Uses**\\n\\nWe want everyone to use Llama 3.2 safely and responsibly. You agree
-      you will not use, or allow others to use, Llama 3.2 to:\\n\\n\\n\\n1. Violate
-      the law or others\u2019 rights, including to:\\n    1. Engage in, promote, generate,
-      contribute to, encourage, plan, incite, or further illegal or unlawful activity
-      or content, such as:\\n        1. Violence or terrorism\\n        2. Exploitation
-      or harm to children, including the solicitation, creation, acquisition, or dissemination
-      of child exploitative content or failure to report Child Sexual Abuse Material\\n
-      \       3. Human trafficking, exploitation, and sexual violence\\n        4.
-      The illegal distribution of information or materials to minors, including obscene
-      materials, or failure to employ legally required age-gating in connection with
-      such information or materials.\\n        5. Sexual solicitation\\n        6.
-      Any other criminal activity\\n    1. Engage in, promote, incite, or facilitate
-      the harassment, abuse, threatening, or bullying of individuals or groups of
-      individuals\\n    2. Engage in, promote, incite, or facilitate discrimination
-      or other unlawful or harmful conduct in the provision of employment, employment
-      benefits, credit, housing, other economic benefits, or other essential goods
-      and services\\n    3. Engage in the unauthorized or unlicensed practice of any
-      profession including, but not limited to, financial, legal, medical/health,
-      or related professional practices\\n    4. Collect, process, disclose, generate,
-      or infer private or sensitive information about individuals, including information
-      about individuals\u2019 identity, health, or demographic information, unless
-      you have obtained the right to do so in accordance with applicable law\\n    5.
-      Engage in or facilitate any action or generate any content that infringes, misappropriates,
-      or otherwise violates any third-party rights, including the outputs or results
-      of any products or services using the Llama Materials\\n    6. Create, generate,
-      or facilitate the creation of malicious code, malware, computer viruses or do
-      anything else that could disable, overburden, interfere with or impair the proper
-      working, integrity, operation or appearance of a website or computer system\\n
-      \   7. Engage in any action, or facilitate any action, to intentionally circumvent
-      or remove usage restrictions or other safety measures, or to enable functionality
-      disabled by Meta\\n2. Engage in, promote, incite, facilitate, or assist in the
-      planning or development of activities that present a risk of death or bodily
-      harm to individuals, including use of Llama 3.2 related to the following:\\n
-      \   8. Military, warfare, nuclear industries or applications, espionage, use
-      for materials or activities that are subject to the International Traffic Arms
-      Regulations (ITAR) maintained by the United States Department of State or to
-      the U.S. Biological Weapons Anti-Terrorism Act of 1989 or the Chemical Weapons
-      Convention Implementation Act of 1997\\n    9. Guns and illegal weapons (including
-      weapon development)\\n    10. Illegal drugs and regulated/controlled substances\\n
-      \   11. Operation of critical infrastructure, transportation technologies, or
-      heavy machinery\\n    12. Self-harm or harm to others, including suicide, cutting,
-      and eating disorders\\n    13. Any content intended to incite or promote violence,
-      abuse, or any infliction of bodily harm to an individual\\n3. Intentionally
-      deceive or mislead others, including use of Llama 3.2 related to the following:\\n
-      \   14. Generating, promoting, or furthering fraud or the creation or promotion
-      of disinformation\\n    15. Generating, promoting, or furthering defamatory
-      content, including the creation of defamatory statements, images, or other content\\n
-      \   16. Generating, promoting, or further distributing spam\\n    17. Impersonating
-      another individual without consent, authorization, or legal right\\n    18.
-      Representing that the use of Llama 3.2 or outputs are human-generated\\n    19.
-      Generating or facilitating false online engagement, including fake reviews and
-      other means of fake online engagement\\n4. Fail to appropriately disclose to
-      end users any known dangers of your AI system\\n5. Interact with third party
-      tools, models, or software designed to generate unlawful content or engage in
-      unlawful or harmful conduct and/or represent that the outputs of such tools,
-      models, or software are associated with Meta or Llama 3.2\\n\\nWith respect
-      to any multimodal models included in Llama 3.2, the rights granted under Section
-      1(a) of the Llama 3.2 Community License Agreement are not being granted to you
-      if you are an individual domiciled in, or a company with a principal place of
-      business in, the European Union. This restriction does not apply to end users
-      of a product or service that incorporates any such multimodal models.\\n\\nPlease
-      report any violation of this Policy, software \u201Cbug,\u201D or other problems
-      that could lead to a violation of this Policy through one of the following means:\\n\\n\\n\\n*
-      Reporting issues with the model: [https://github.com/meta-llama/llama-models/issues](https://l.workplace.com/l.php?u=https%3A%2F%2Fgithub.com%2Fmeta-llama%2Fllama-models%2Fissues\\u0026h=AT0qV8W9BFT6NwihiOHRuKYQM_UnkzN_NmHMy91OT55gkLpgi4kQupHUl0ssR4dQsIQ8n3tfd0vtkobvsEvt1l4Ic6GXI2EeuHV8N08OG2WnbAmm0FL4ObkazC6G_256vN0lN9DsykCvCqGZ)\\n*
-      Reporting risky content generated by the model: [developers.facebook.com/llama_output_feedback](http://developers.facebook.com/llama_output_feedback)\\n*
-      Reporting bugs and security concerns: [facebook.com/whitehat/info](http://facebook.com/whitehat/info)\\n*
-      Reporting violations of the Acceptable Use Policy or unlicensed uses of Llama
-      3.2: LlamaUseReport@meta.com\",\"modelfile\":\"# Modelfile generated by \\\"ollama
-      show\\\"\\n# To build a new Modelfile based on this, replace FROM with:\\n#
-      FROM llama3.2:3b\\n\\nFROM /Users/brandonhancock/.ollama/models/blobs/sha256-dde5aa3fc5ffc17176b5e8bdc82f587b24b2678c6c66101bf7da77af9f7ccdff\\nTEMPLATE
-      \\\"\\\"\\\"\\u003c|start_header_id|\\u003esystem\\u003c|end_header_id|\\u003e\\n\\nCutting
-      Knowledge Date: December 2023\\n\\n{{ if .System }}{{ .System }}\\n{{- end }}\\n{{-
-      if .Tools }}When you receive a tool call response, use the output to format
-      an answer to the orginal user question.\\n\\nYou are a helpful assistant with
-      tool calling capabilities.\\n{{- end }}\\u003c|eot_id|\\u003e\\n{{- range $i,
-      $_ := .Messages }}\\n{{- $last := eq (len (slice $.Messages $i)) 1 }}\\n{{-
-      if eq .Role \\\"user\\\" }}\\u003c|start_header_id|\\u003euser\\u003c|end_header_id|\\u003e\\n{{-
-      if and $.Tools $last }}\\n\\nGiven the following functions, please respond with
-      a JSON for a function call with its proper arguments that best answers the given
-      prompt.\\n\\nRespond in the format {\\\"name\\\": function name, \\\"parameters\\\":
-      dictionary of argument name and its value}. Do not use variables.\\n\\n{{ range
-      $.Tools }}\\n{{- . }}\\n{{ end }}\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{-
-      else }}\\n\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{- end }}{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- else if eq .Role \\\"assistant\\\" }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n{{-
-      if .ToolCalls }}\\n{{ range .ToolCalls }}\\n{\\\"name\\\": \\\"{{ .Function.Name
-      }}\\\", \\\"parameters\\\": {{ .Function.Arguments }}}{{ end }}\\n{{- else }}\\n\\n{{
-      .Content }}\\n{{- end }}{{ if not $last }}\\u003c|eot_id|\\u003e{{ end }}\\n{{-
-      else if eq .Role \\\"tool\\\" }}\\u003c|start_header_id|\\u003eipython\\u003c|end_header_id|\\u003e\\n\\n{{
-      .Content }}\\u003c|eot_id|\\u003e{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- end }}\\n{{- end }}\\\"\\\"\\\"\\nPARAMETER stop \\u003c|start_header_id|\\u003e\\nPARAMETER
-      stop \\u003c|end_header_id|\\u003e\\nPARAMETER stop \\u003c|eot_id|\\u003e\\nLICENSE
-      \\\"LLAMA 3.2 COMMUNITY LICENSE AGREEMENT\\nLlama 3.2 Version Release Date:
-      September 25, 2024\\n\\n\u201CAgreement\u201D means the terms and conditions
-      for use, reproduction, distribution \\nand modification of the Llama Materials
-      set forth herein.\\n\\n\u201CDocumentation\u201D means the specifications, manuals
-      and documentation accompanying Llama 3.2\\ndistributed by Meta at https://llama.meta.com/doc/overview.\\n\\n\u201CLicensee\u201D
-      or \u201Cyou\u201D means you, or your employer or any other person or entity
-      (if you are \\nentering into this Agreement on such person or entity\u2019s
-      behalf), of the age required under\\napplicable laws, rules or regulations to
-      provide legal consent and that has legal authority\\nto bind your employer or
-      such other person or entity if you are entering in this Agreement\\non their
-      behalf.\\n\\n\u201CLlama 3.2\u201D means the foundational large language models
-      and software and algorithms, including\\nmachine-learning model code, trained
-      model weights, inference-enabling code, training-enabling code,\\nfine-tuning
-      enabling code and other elements of the foregoing distributed by Meta at \\nhttps://www.llama.com/llama-downloads.\\n\\n\u201CLlama
-      Materials\u201D means, collectively, Meta\u2019s proprietary Llama 3.2 and Documentation
-      (and \\nany portion thereof) made available under this Agreement.\\n\\n\u201CMeta\u201D
-      or \u201Cwe\u201D means Meta Platforms Ireland Limited (if you are located in
-      or, \\nif you are an entity, your principal place of business is in the EEA
-      or Switzerland) \\nand Meta Platforms, Inc. (if you are located outside of the
-      EEA or Switzerland). \\n\\n\\nBy clicking \u201CI Accept\u201D below or by using
-      or distributing any portion or element of the Llama Materials,\\nyou agree to
-      be bound by this Agreement.\\n\\n\\n1. License Rights and Redistribution.\\n\\n
-      \   a. Grant of Rights. You are granted a non-exclusive, worldwide, \\nnon-transferable
-      and royalty-free limited license under Meta\u2019s intellectual property or
-      other rights \\nowned by Meta embodied in the Llama Materials to use, reproduce,
-      distribute, copy, create derivative works \\nof, and make modifications to the
-      Llama Materials.  \\n\\n    b. Redistribution and Use.  \\n\\n        i. If
-      you distribute or make available the Llama Materials (or any derivative works
-      thereof), \\nor a product or service (including another AI model) that contains
-      any of them, you shall (A) provide\\na copy of this Agreement with any such
-      Llama Materials; and (B) prominently display \u201CBuilt with Llama\u201D\\non
-      a related website, user interface, blogpost, about page, or product documentation.
-      If you use the\\nLlama Materials or any outputs or results of the Llama Materials
-      to create, train, fine tune, or\\notherwise improve an AI model, which is distributed
-      or made available, you shall also include \u201CLlama\u201D\\nat the beginning
-      of any such AI model name.\\n\\n        ii. If you receive Llama Materials,
-      or any derivative works thereof, from a Licensee as part\\nof an integrated
-      end user product, then Section 2 of this Agreement will not apply to you. \\n\\n
-      \       iii. You must retain in all copies of the Llama Materials that you distribute
-      the \\nfollowing attribution notice within a \u201CNotice\u201D text file distributed
-      as a part of such copies: \\n\u201CLlama 3.2 is licensed under the Llama 3.2
-      Community License, Copyright \xA9 Meta Platforms,\\nInc. All Rights Reserved.\u201D\\n\\n
-      \       iv. Your use of the Llama Materials must comply with applicable laws
-      and regulations\\n(including trade compliance laws and regulations) and adhere
-      to the Acceptable Use Policy for\\nthe Llama Materials (available at https://www.llama.com/llama3_2/use-policy),
-      which is hereby \\nincorporated by reference into this Agreement.\\n  \\n2.
-      Additional Commercial Terms. If, on the Llama 3.2 version release date, the
-      monthly active users\\nof the products or services made available by or for
-      Licensee, or Licensee\u2019s affiliates, \\nis greater than 700 million monthly
-      active users in the preceding calendar month, you must request \\na license
-      from Meta, which Meta may grant to you in its sole discretion, and you are not
-      authorized to\\nexercise any of the rights under this Agreement unless or until
-      Meta otherwise expressly grants you such rights.\\n\\n3. Disclaimer of Warranty.
-      UNLESS REQUIRED BY APPLICABLE LAW, THE LLAMA MATERIALS AND ANY OUTPUT AND \\nRESULTS
-      THEREFROM ARE PROVIDED ON AN \u201CAS IS\u201D BASIS, WITHOUT WARRANTIES OF
-      ANY KIND, AND META DISCLAIMS\\nALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND
-      IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES\\nOF TITLE, NON-INFRINGEMENT,
-      MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE\\nFOR
-      DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE LLAMA MATERIALS
-      AND ASSUME ANY RISKS ASSOCIATED\\nWITH YOUR USE OF THE LLAMA MATERIALS AND ANY
-      OUTPUT AND RESULTS.\\n\\n4. Limitation of Liability. IN NO EVENT WILL META OR
-      ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, \\nWHETHER IN CONTRACT,
-      TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT,
-      \\nFOR ANY LOST PROFITS OR ANY INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL,
-      EXEMPLARY OR PUNITIVE DAMAGES, EVEN \\nIF META OR ITS AFFILIATES HAVE BEEN ADVISED
-      OF THE POSSIBILITY OF ANY OF THE FOREGOING.\\n\\n5. Intellectual Property.\\n\\n
-      \   a. No trademark licenses are granted under this Agreement, and in connection
-      with the Llama Materials, \\nneither Meta nor Licensee may use any name or mark
-      owned by or associated with the other or any of its affiliates, \\nexcept as
-      required for reasonable and customary use in describing and redistributing the
-      Llama Materials or as \\nset forth in this Section 5(a). Meta hereby grants
-      you a license to use \u201CLlama\u201D (the \u201CMark\u201D) solely as required
-      \\nto comply with the last sentence of Section 1.b.i. You will comply with Meta\u2019s
-      brand guidelines (currently accessible \\nat https://about.meta.com/brand/resources/meta/company-brand/).
-      All goodwill arising out of your use of the Mark \\nwill inure to the benefit
-      of Meta.\\n\\n    b. Subject to Meta\u2019s ownership of Llama Materials and
-      derivatives made by or for Meta, with respect to any\\n    derivative works
-      and modifications of the Llama Materials that are made by you, as between you
-      and Meta,\\n    you are and will be the owner of such derivative works and modifications.\\n\\n
-      \   c. If you institute litigation or other proceedings against Meta or any
-      entity (including a cross-claim or\\n    counterclaim in a lawsuit) alleging
-      that the Llama Materials or Llama 3.2 outputs or results, or any portion\\n
-      \   of any of the foregoing, constitutes infringement of intellectual property
-      or other rights owned or licensable\\n    by you, then any licenses granted
-      to you under this Agreement shall terminate as of the date such litigation or\\n
-      \   claim is filed or instituted. You will indemnify and hold harmless Meta
-      from and against any claim by any third\\n    party arising out of or related
-      to your use or distribution of the Llama Materials.\\n\\n6. Term and Termination.
-      The term of this Agreement will commence upon your acceptance of this Agreement
-      or access\\nto the Llama Materials and will continue in full force and effect
-      until terminated in accordance with the terms\\nand conditions herein. Meta
-      may terminate this Agreement if you are in breach of any term or condition of
-      this\\nAgreement. Upon termination of this Agreement, you shall delete and cease
-      use of the Llama Materials. Sections 3,\\n4 and 7 shall survive the termination
-      of this Agreement. \\n\\n7. Governing Law and Jurisdiction. This Agreement will
-      be governed and construed under the laws of the State of \\nCalifornia without
-      regard to choice of law principles, and the UN Convention on Contracts for the
-      International\\nSale of Goods does not apply to this Agreement. The courts of
-      California shall have exclusive jurisdiction of\\nany dispute arising out of
-      this Agreement.\\\"\\nLICENSE \\\"**Llama 3.2** **Acceptable Use Policy**\\n\\nMeta
-      is committed to promoting safe and fair use of its tools and features, including
-      Llama 3.2. If you access or use Llama 3.2, you agree to this Acceptable Use
-      Policy (\u201C**Policy**\u201D). The most recent copy of this policy can be
-      found at [https://www.llama.com/llama3_2/use-policy](https://www.llama.com/llama3_2/use-policy).\\n\\n**Prohibited
-      Uses**\\n\\nWe want everyone to use Llama 3.2 safely and responsibly. You agree
-      you will not use, or allow others to use, Llama 3.2 to:\\n\\n\\n\\n1. Violate
-      the law or others\u2019 rights, including to:\\n    1. Engage in, promote, generate,
-      contribute to, encourage, plan, incite, or further illegal or unlawful activity
-      or content, such as:\\n        1. Violence or terrorism\\n        2. Exploitation
-      or harm to children, including the solicitation, creation, acquisition, or dissemination
-      of child exploitative content or failure to report Child Sexual Abuse Material\\n
-      \       3. Human trafficking, exploitation, and sexual violence\\n        4.
-      The illegal distribution of information or materials to minors, including obscene
-      materials, or failure to employ legally required age-gating in connection with
-      such information or materials.\\n        5. Sexual solicitation\\n        6.
-      Any other criminal activity\\n    1. Engage in, promote, incite, or facilitate
-      the harassment, abuse, threatening, or bullying of individuals or groups of
-      individuals\\n    2. Engage in, promote, incite, or facilitate discrimination
-      or other unlawful or harmful conduct in the provision of employment, employment
-      benefits, credit, housing, other economic benefits, or other essential goods
-      and services\\n    3. Engage in the unauthorized or unlicensed practice of any
-      profession including, but not limited to, financial, legal, medical/health,
-      or related professional practices\\n    4. Collect, process, disclose, generate,
-      or infer private or sensitive information about individuals, including information
-      about individuals\u2019 identity, health, or demographic information, unless
-      you have obtained the right to do so in accordance with applicable law\\n    5.
-      Engage in or facilitate any action or generate any content that infringes, misappropriates,
-      or otherwise violates any third-party rights, including the outputs or results
-      of any products or services using the Llama Materials\\n    6. Create, generate,
-      or facilitate the creation of malicious code, malware, computer viruses or do
-      anything else that could disable, overburden, interfere with or impair the proper
-      working, integrity, operation or appearance of a website or computer system\\n
-      \   7. Engage in any action, or facilitate any action, to intentionally circumvent
-      or remove usage restrictions or other safety measures, or to enable functionality
-      disabled by Meta\\n2. Engage in, promote, incite, facilitate, or assist in the
-      planning or development of activities that present a risk of death or bodily
-      harm to individuals, including use of Llama 3.2 related to the following:\\n
-      \   8. Military, warfare, nuclear industries or applications, espionage, use
-      for materials or activities that are subject to the International Traffic Arms
-      Regulations (ITAR) maintained by the United States Department of State or to
-      the U.S. Biological Weapons Anti-Terrorism Act of 1989 or the Chemical Weapons
-      Convention Implementation Act of 1997\\n    9. Guns and illegal weapons (including
-      weapon development)\\n    10. Illegal drugs and regulated/controlled substances\\n
-      \   11. Operation of critical infrastructure, transportation technologies, or
-      heavy machinery\\n    12. Self-harm or harm to others, including suicide, cutting,
-      and eating disorders\\n    13. Any content intended to incite or promote violence,
-      abuse, or any infliction of bodily harm to an individual\\n3. Intentionally
-      deceive or mislead others, including use of Llama 3.2 related to the following:\\n
-      \   14. Generating, promoting, or furthering fraud or the creation or promotion
-      of disinformation\\n    15. Generating, promoting, or furthering defamatory
-      content, including the creation of defamatory statements, images, or other content\\n
-      \   16. Generating, promoting, or further distributing spam\\n    17. Impersonating
-      another individual without consent, authorization, or legal right\\n    18.
-      Representing that the use of Llama 3.2 or outputs are human-generated\\n    19.
-      Generating or facilitating false online engagement, including fake reviews and
-      other means of fake online engagement\\n4. Fail to appropriately disclose to
-      end users any known dangers of your AI system\\n5. Interact with third party
-      tools, models, or software designed to generate unlawful content or engage in
-      unlawful or harmful conduct and/or represent that the outputs of such tools,
-      models, or software are associated with Meta or Llama 3.2\\n\\nWith respect
-      to any multimodal models included in Llama 3.2, the rights granted under Section
-      1(a) of the Llama 3.2 Community License Agreement are not being granted to you
-      if you are an individual domiciled in, or a company with a principal place of
-      business in, the European Union. This restriction does not apply to end users
-      of a product or service that incorporates any such multimodal models.\\n\\nPlease
-      report any violation of this Policy, software \u201Cbug,\u201D or other problems
-      that could lead to a violation of this Policy through one of the following means:\\n\\n\\n\\n*
-      Reporting issues with the model: [https://github.com/meta-llama/llama-models/issues](https://l.workplace.com/l.php?u=https%3A%2F%2Fgithub.com%2Fmeta-llama%2Fllama-models%2Fissues\\u0026h=AT0qV8W9BFT6NwihiOHRuKYQM_UnkzN_NmHMy91OT55gkLpgi4kQupHUl0ssR4dQsIQ8n3tfd0vtkobvsEvt1l4Ic6GXI2EeuHV8N08OG2WnbAmm0FL4ObkazC6G_256vN0lN9DsykCvCqGZ)\\n*
-      Reporting risky content generated by the model: [developers.facebook.com/llama_output_feedback](http://developers.facebook.com/llama_output_feedback)\\n*
-      Reporting bugs and security concerns: [facebook.com/whitehat/info](http://facebook.com/whitehat/info)\\n*
-      Reporting violations of the Acceptable Use Policy or unlicensed uses of Llama
-      3.2: LlamaUseReport@meta.com\\\"\\n\",\"parameters\":\"stop                           \\\"\\u003c|start_header_id|\\u003e\\\"\\nstop
-      \                          \\\"\\u003c|end_header_id|\\u003e\\\"\\nstop                           \\\"\\u003c|eot_id|\\u003e\\\"\",\"template\":\"\\u003c|start_header_id|\\u003esystem\\u003c|end_header_id|\\u003e\\n\\nCutting
-      Knowledge Date: December 2023\\n\\n{{ if .System }}{{ .System }}\\n{{- end }}\\n{{-
-      if .Tools }}When you receive a tool call response, use the output to format
-      an answer to the orginal user question.\\n\\nYou are a helpful assistant with
-      tool calling capabilities.\\n{{- end }}\\u003c|eot_id|\\u003e\\n{{- range $i,
-      $_ := .Messages }}\\n{{- $last := eq (len (slice $.Messages $i)) 1 }}\\n{{-
-      if eq .Role \\\"user\\\" }}\\u003c|start_header_id|\\u003euser\\u003c|end_header_id|\\u003e\\n{{-
-      if and $.Tools $last }}\\n\\nGiven the following functions, please respond with
-      a JSON for a function call with its proper arguments that best answers the given
-      prompt.\\n\\nRespond in the format {\\\"name\\\": function name, \\\"parameters\\\":
-      dictionary of argument name and its value}. Do not use variables.\\n\\n{{ range
-      $.Tools }}\\n{{- . }}\\n{{ end }}\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{-
-      else }}\\n\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{- end }}{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- else if eq .Role \\\"assistant\\\" }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n{{-
-      if .ToolCalls }}\\n{{ range .ToolCalls }}\\n{\\\"name\\\": \\\"{{ .Function.Name
-      }}\\\", \\\"parameters\\\": {{ .Function.Arguments }}}{{ end }}\\n{{- else }}\\n\\n{{
-      .Content }}\\n{{- end }}{{ if not $last }}\\u003c|eot_id|\\u003e{{ end }}\\n{{-
-      else if eq .Role \\\"tool\\\" }}\\u003c|start_header_id|\\u003eipython\\u003c|end_header_id|\\u003e\\n\\n{{
-      .Content }}\\u003c|eot_id|\\u003e{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- end }}\\n{{- end }}\",\"details\":{\"parent_model\":\"\",\"format\":\"gguf\",\"family\":\"llama\",\"families\":[\"llama\"],\"parameter_size\":\"3.2B\",\"quantization_level\":\"Q4_K_M\"},\"model_info\":{\"general.architecture\":\"llama\",\"general.basename\":\"Llama-3.2\",\"general.file_type\":15,\"general.finetune\":\"Instruct\",\"general.languages\":[\"en\",\"de\",\"fr\",\"it\",\"pt\",\"hi\",\"es\",\"th\"],\"general.parameter_count\":3212749888,\"general.quantization_version\":2,\"general.size_label\":\"3B\",\"general.tags\":[\"facebook\",\"meta\",\"pytorch\",\"llama\",\"llama-3\",\"text-generation\"],\"general.type\":\"model\",\"llama.attention.head_count\":24,\"llama.attention.head_count_kv\":8,\"llama.attention.key_length\":128,\"llama.attention.layer_norm_rms_epsilon\":0.00001,\"llama.attention.value_length\":128,\"llama.block_count\":28,\"llama.context_length\":131072,\"llama.embedding_length\":3072,\"llama.feed_forward_length\":8192,\"llama.rope.dimension_count\":128,\"llama.rope.freq_base\":500000,\"llama.vocab_size\":128256,\"tokenizer.ggml.bos_token_id\":128000,\"tokenizer.ggml.eos_token_id\":128009,\"tokenizer.ggml.merges\":null,\"tokenizer.ggml.model\":\"gpt2\",\"tokenizer.ggml.pre\":\"llama-bpe\",\"tokenizer.ggml.token_type\":null,\"tokenizer.ggml.tokens\":null},\"modified_at\":\"2024-12-31T11:53:14.529771974-05:00\"}"
-    headers:
-      Content-Type:
-      - application/json; charset=utf-8
-      Date:
-      - Wed, 15 Jan 2025 20:47:12 GMT
-      Transfer-Encoding:
-      - chunked
-    http_version: HTTP/1.1
-    status_code: 200
-- request:
-    body: '{"name": "llama3.2:3b"}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '23'
-      content-type:
-      - application/json
-      host:
-      - localhost:11434
-      user-agent:
-      - litellm/1.57.4
-    method: POST
-    uri: http://localhost:11434/api/show
-  response:
-    content: "{\"license\":\"LLAMA 3.2 COMMUNITY LICENSE AGREEMENT\\nLlama 3.2 Version
-      Release Date: September 25, 2024\\n\\n\u201CAgreement\u201D means the terms
-      and conditions for use, reproduction, distribution \\nand modification of the
-      Llama Materials set forth herein.\\n\\n\u201CDocumentation\u201D means the specifications,
-      manuals and documentation accompanying Llama 3.2\\ndistributed by Meta at https://llama.meta.com/doc/overview.\\n\\n\u201CLicensee\u201D
-      or \u201Cyou\u201D means you, or your employer or any other person or entity
-      (if you are \\nentering into this Agreement on such person or entity\u2019s
-      behalf), of the age required under\\napplicable laws, rules or regulations to
-      provide legal consent and that has legal authority\\nto bind your employer or
-      such other person or entity if you are entering in this Agreement\\non their
-      behalf.\\n\\n\u201CLlama 3.2\u201D means the foundational large language models
-      and software and algorithms, including\\nmachine-learning model code, trained
-      model weights, inference-enabling code, training-enabling code,\\nfine-tuning
-      enabling code and other elements of the foregoing distributed by Meta at \\nhttps://www.llama.com/llama-downloads.\\n\\n\u201CLlama
-      Materials\u201D means, collectively, Meta\u2019s proprietary Llama 3.2 and Documentation
-      (and \\nany portion thereof) made available under this Agreement.\\n\\n\u201CMeta\u201D
-      or \u201Cwe\u201D means Meta Platforms Ireland Limited (if you are located in
-      or, \\nif you are an entity, your principal place of business is in the EEA
-      or Switzerland) \\nand Meta Platforms, Inc. (if you are located outside of the
-      EEA or Switzerland). \\n\\n\\nBy clicking \u201CI Accept\u201D below or by using
-      or distributing any portion or element of the Llama Materials,\\nyou agree to
-      be bound by this Agreement.\\n\\n\\n1. License Rights and Redistribution.\\n\\n
-      \   a. Grant of Rights. You are granted a non-exclusive, worldwide, \\nnon-transferable
-      and royalty-free limited license under Meta\u2019s intellectual property or
-      other rights \\nowned by Meta embodied in the Llama Materials to use, reproduce,
-      distribute, copy, create derivative works \\nof, and make modifications to the
-      Llama Materials.  \\n\\n    b. Redistribution and Use.  \\n\\n        i. If
-      you distribute or make available the Llama Materials (or any derivative works
-      thereof), \\nor a product or service (including another AI model) that contains
-      any of them, you shall (A) provide\\na copy of this Agreement with any such
-      Llama Materials; and (B) prominently display \u201CBuilt with Llama\u201D\\non
-      a related website, user interface, blogpost, about page, or product documentation.
-      If you use the\\nLlama Materials or any outputs or results of the Llama Materials
-      to create, train, fine tune, or\\notherwise improve an AI model, which is distributed
-      or made available, you shall also include \u201CLlama\u201D\\nat the beginning
-      of any such AI model name.\\n\\n        ii. If you receive Llama Materials,
-      or any derivative works thereof, from a Licensee as part\\nof an integrated
-      end user product, then Section 2 of this Agreement will not apply to you. \\n\\n
-      \       iii. You must retain in all copies of the Llama Materials that you distribute
-      the \\nfollowing attribution notice within a \u201CNotice\u201D text file distributed
-      as a part of such copies: \\n\u201CLlama 3.2 is licensed under the Llama 3.2
-      Community License, Copyright \xA9 Meta Platforms,\\nInc. All Rights Reserved.\u201D\\n\\n
-      \       iv. Your use of the Llama Materials must comply with applicable laws
-      and regulations\\n(including trade compliance laws and regulations) and adhere
-      to the Acceptable Use Policy for\\nthe Llama Materials (available at https://www.llama.com/llama3_2/use-policy),
-      which is hereby \\nincorporated by reference into this Agreement.\\n  \\n2.
-      Additional Commercial Terms. If, on the Llama 3.2 version release date, the
-      monthly active users\\nof the products or services made available by or for
-      Licensee, or Licensee\u2019s affiliates, \\nis greater than 700 million monthly
-      active users in the preceding calendar month, you must request \\na license
-      from Meta, which Meta may grant to you in its sole discretion, and you are not
-      authorized to\\nexercise any of the rights under this Agreement unless or until
-      Meta otherwise expressly grants you such rights.\\n\\n3. Disclaimer of Warranty.
-      UNLESS REQUIRED BY APPLICABLE LAW, THE LLAMA MATERIALS AND ANY OUTPUT AND \\nRESULTS
-      THEREFROM ARE PROVIDED ON AN \u201CAS IS\u201D BASIS, WITHOUT WARRANTIES OF
-      ANY KIND, AND META DISCLAIMS\\nALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND
-      IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES\\nOF TITLE, NON-INFRINGEMENT,
-      MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE\\nFOR
-      DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE LLAMA MATERIALS
-      AND ASSUME ANY RISKS ASSOCIATED\\nWITH YOUR USE OF THE LLAMA MATERIALS AND ANY
-      OUTPUT AND RESULTS.\\n\\n4. Limitation of Liability. IN NO EVENT WILL META OR
-      ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, \\nWHETHER IN CONTRACT,
-      TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT,
-      \\nFOR ANY LOST PROFITS OR ANY INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL,
-      EXEMPLARY OR PUNITIVE DAMAGES, EVEN \\nIF META OR ITS AFFILIATES HAVE BEEN ADVISED
-      OF THE POSSIBILITY OF ANY OF THE FOREGOING.\\n\\n5. Intellectual Property.\\n\\n
-      \   a. No trademark licenses are granted under this Agreement, and in connection
-      with the Llama Materials, \\nneither Meta nor Licensee may use any name or mark
-      owned by or associated with the other or any of its affiliates, \\nexcept as
-      required for reasonable and customary use in describing and redistributing the
-      Llama Materials or as \\nset forth in this Section 5(a). Meta hereby grants
-      you a license to use \u201CLlama\u201D (the \u201CMark\u201D) solely as required
-      \\nto comply with the last sentence of Section 1.b.i. You will comply with Meta\u2019s
-      brand guidelines (currently accessible \\nat https://about.meta.com/brand/resources/meta/company-brand/).
-      All goodwill arising out of your use of the Mark \\nwill inure to the benefit
-      of Meta.\\n\\n    b. Subject to Meta\u2019s ownership of Llama Materials and
-      derivatives made by or for Meta, with respect to any\\n    derivative works
-      and modifications of the Llama Materials that are made by you, as between you
-      and Meta,\\n    you are and will be the owner of such derivative works and modifications.\\n\\n
-      \   c. If you institute litigation or other proceedings against Meta or any
-      entity (including a cross-claim or\\n    counterclaim in a lawsuit) alleging
-      that the Llama Materials or Llama 3.2 outputs or results, or any portion\\n
-      \   of any of the foregoing, constitutes infringement of intellectual property
-      or other rights owned or licensable\\n    by you, then any licenses granted
-      to you under this Agreement shall terminate as of the date such litigation or\\n
-      \   claim is filed or instituted. You will indemnify and hold harmless Meta
-      from and against any claim by any third\\n    party arising out of or related
-      to your use or distribution of the Llama Materials.\\n\\n6. Term and Termination.
-      The term of this Agreement will commence upon your acceptance of this Agreement
-      or access\\nto the Llama Materials and will continue in full force and effect
-      until terminated in accordance with the terms\\nand conditions herein. Meta
-      may terminate this Agreement if you are in breach of any term or condition of
-      this\\nAgreement. Upon termination of this Agreement, you shall delete and cease
-      use of the Llama Materials. Sections 3,\\n4 and 7 shall survive the termination
-      of this Agreement. \\n\\n7. Governing Law and Jurisdiction. This Agreement will
-      be governed and construed under the laws of the State of \\nCalifornia without
-      regard to choice of law principles, and the UN Convention on Contracts for the
-      International\\nSale of Goods does not apply to this Agreement. The courts of
-      California shall have exclusive jurisdiction of\\nany dispute arising out of
-      this Agreement.\\n**Llama 3.2** **Acceptable Use Policy**\\n\\nMeta is committed
-      to promoting safe and fair use of its tools and features, including Llama 3.2.
-      If you access or use Llama 3.2, you agree to this Acceptable Use Policy (\u201C**Policy**\u201D).
-      The most recent copy of this policy can be found at [https://www.llama.com/llama3_2/use-policy](https://www.llama.com/llama3_2/use-policy).\\n\\n**Prohibited
-      Uses**\\n\\nWe want everyone to use Llama 3.2 safely and responsibly. You agree
-      you will not use, or allow others to use, Llama 3.2 to:\\n\\n\\n\\n1. Violate
-      the law or others\u2019 rights, including to:\\n    1. Engage in, promote, generate,
-      contribute to, encourage, plan, incite, or further illegal or unlawful activity
-      or content, such as:\\n        1. Violence or terrorism\\n        2. Exploitation
-      or harm to children, including the solicitation, creation, acquisition, or dissemination
-      of child exploitative content or failure to report Child Sexual Abuse Material\\n
-      \       3. Human trafficking, exploitation, and sexual violence\\n        4.
-      The illegal distribution of information or materials to minors, including obscene
-      materials, or failure to employ legally required age-gating in connection with
-      such information or materials.\\n        5. Sexual solicitation\\n        6.
-      Any other criminal activity\\n    1. Engage in, promote, incite, or facilitate
-      the harassment, abuse, threatening, or bullying of individuals or groups of
-      individuals\\n    2. Engage in, promote, incite, or facilitate discrimination
-      or other unlawful or harmful conduct in the provision of employment, employment
-      benefits, credit, housing, other economic benefits, or other essential goods
-      and services\\n    3. Engage in the unauthorized or unlicensed practice of any
-      profession including, but not limited to, financial, legal, medical/health,
-      or related professional practices\\n    4. Collect, process, disclose, generate,
-      or infer private or sensitive information about individuals, including information
-      about individuals\u2019 identity, health, or demographic information, unless
-      you have obtained the right to do so in accordance with applicable law\\n    5.
-      Engage in or facilitate any action or generate any content that infringes, misappropriates,
-      or otherwise violates any third-party rights, including the outputs or results
-      of any products or services using the Llama Materials\\n    6. Create, generate,
-      or facilitate the creation of malicious code, malware, computer viruses or do
-      anything else that could disable, overburden, interfere with or impair the proper
-      working, integrity, operation or appearance of a website or computer system\\n
-      \   7. Engage in any action, or facilitate any action, to intentionally circumvent
-      or remove usage restrictions or other safety measures, or to enable functionality
-      disabled by Meta\\n2. Engage in, promote, incite, facilitate, or assist in the
-      planning or development of activities that present a risk of death or bodily
-      harm to individuals, including use of Llama 3.2 related to the following:\\n
-      \   8. Military, warfare, nuclear industries or applications, espionage, use
-      for materials or activities that are subject to the International Traffic Arms
-      Regulations (ITAR) maintained by the United States Department of State or to
-      the U.S. Biological Weapons Anti-Terrorism Act of 1989 or the Chemical Weapons
-      Convention Implementation Act of 1997\\n    9. Guns and illegal weapons (including
-      weapon development)\\n    10. Illegal drugs and regulated/controlled substances\\n
-      \   11. Operation of critical infrastructure, transportation technologies, or
-      heavy machinery\\n    12. Self-harm or harm to others, including suicide, cutting,
-      and eating disorders\\n    13. Any content intended to incite or promote violence,
-      abuse, or any infliction of bodily harm to an individual\\n3. Intentionally
-      deceive or mislead others, including use of Llama 3.2 related to the following:\\n
-      \   14. Generating, promoting, or furthering fraud or the creation or promotion
-      of disinformation\\n    15. Generating, promoting, or furthering defamatory
-      content, including the creation of defamatory statements, images, or other content\\n
-      \   16. Generating, promoting, or further distributing spam\\n    17. Impersonating
-      another individual without consent, authorization, or legal right\\n    18.
-      Representing that the use of Llama 3.2 or outputs are human-generated\\n    19.
-      Generating or facilitating false online engagement, including fake reviews and
-      other means of fake online engagement\\n4. Fail to appropriately disclose to
-      end users any known dangers of your AI system\\n5. Interact with third party
-      tools, models, or software designed to generate unlawful content or engage in
-      unlawful or harmful conduct and/or represent that the outputs of such tools,
-      models, or software are associated with Meta or Llama 3.2\\n\\nWith respect
-      to any multimodal models included in Llama 3.2, the rights granted under Section
-      1(a) of the Llama 3.2 Community License Agreement are not being granted to you
-      if you are an individual domiciled in, or a company with a principal place of
-      business in, the European Union. This restriction does not apply to end users
-      of a product or service that incorporates any such multimodal models.\\n\\nPlease
-      report any violation of this Policy, software \u201Cbug,\u201D or other problems
-      that could lead to a violation of this Policy through one of the following means:\\n\\n\\n\\n*
-      Reporting issues with the model: [https://github.com/meta-llama/llama-models/issues](https://l.workplace.com/l.php?u=https%3A%2F%2Fgithub.com%2Fmeta-llama%2Fllama-models%2Fissues\\u0026h=AT0qV8W9BFT6NwihiOHRuKYQM_UnkzN_NmHMy91OT55gkLpgi4kQupHUl0ssR4dQsIQ8n3tfd0vtkobvsEvt1l4Ic6GXI2EeuHV8N08OG2WnbAmm0FL4ObkazC6G_256vN0lN9DsykCvCqGZ)\\n*
-      Reporting risky content generated by the model: [developers.facebook.com/llama_output_feedback](http://developers.facebook.com/llama_output_feedback)\\n*
-      Reporting bugs and security concerns: [facebook.com/whitehat/info](http://facebook.com/whitehat/info)\\n*
-      Reporting violations of the Acceptable Use Policy or unlicensed uses of Llama
-      3.2: LlamaUseReport@meta.com\",\"modelfile\":\"# Modelfile generated by \\\"ollama
-      show\\\"\\n# To build a new Modelfile based on this, replace FROM with:\\n#
-      FROM llama3.2:3b\\n\\nFROM /Users/brandonhancock/.ollama/models/blobs/sha256-dde5aa3fc5ffc17176b5e8bdc82f587b24b2678c6c66101bf7da77af9f7ccdff\\nTEMPLATE
-      \\\"\\\"\\\"\\u003c|start_header_id|\\u003esystem\\u003c|end_header_id|\\u003e\\n\\nCutting
-      Knowledge Date: December 2023\\n\\n{{ if .System }}{{ .System }}\\n{{- end }}\\n{{-
-      if .Tools }}When you receive a tool call response, use the output to format
-      an answer to the orginal user question.\\n\\nYou are a helpful assistant with
-      tool calling capabilities.\\n{{- end }}\\u003c|eot_id|\\u003e\\n{{- range $i,
-      $_ := .Messages }}\\n{{- $last := eq (len (slice $.Messages $i)) 1 }}\\n{{-
-      if eq .Role \\\"user\\\" }}\\u003c|start_header_id|\\u003euser\\u003c|end_header_id|\\u003e\\n{{-
-      if and $.Tools $last }}\\n\\nGiven the following functions, please respond with
-      a JSON for a function call with its proper arguments that best answers the given
-      prompt.\\n\\nRespond in the format {\\\"name\\\": function name, \\\"parameters\\\":
-      dictionary of argument name and its value}. Do not use variables.\\n\\n{{ range
-      $.Tools }}\\n{{- . }}\\n{{ end }}\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{-
-      else }}\\n\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{- end }}{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- else if eq .Role \\\"assistant\\\" }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n{{-
-      if .ToolCalls }}\\n{{ range .ToolCalls }}\\n{\\\"name\\\": \\\"{{ .Function.Name
-      }}\\\", \\\"parameters\\\": {{ .Function.Arguments }}}{{ end }}\\n{{- else }}\\n\\n{{
-      .Content }}\\n{{- end }}{{ if not $last }}\\u003c|eot_id|\\u003e{{ end }}\\n{{-
-      else if eq .Role \\\"tool\\\" }}\\u003c|start_header_id|\\u003eipython\\u003c|end_header_id|\\u003e\\n\\n{{
-      .Content }}\\u003c|eot_id|\\u003e{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- end }}\\n{{- end }}\\\"\\\"\\\"\\nPARAMETER stop \\u003c|start_header_id|\\u003e\\nPARAMETER
-      stop \\u003c|end_header_id|\\u003e\\nPARAMETER stop \\u003c|eot_id|\\u003e\\nLICENSE
-      \\\"LLAMA 3.2 COMMUNITY LICENSE AGREEMENT\\nLlama 3.2 Version Release Date:
-      September 25, 2024\\n\\n\u201CAgreement\u201D means the terms and conditions
-      for use, reproduction, distribution \\nand modification of the Llama Materials
-      set forth herein.\\n\\n\u201CDocumentation\u201D means the specifications, manuals
-      and documentation accompanying Llama 3.2\\ndistributed by Meta at https://llama.meta.com/doc/overview.\\n\\n\u201CLicensee\u201D
-      or \u201Cyou\u201D means you, or your employer or any other person or entity
-      (if you are \\nentering into this Agreement on such person or entity\u2019s
-      behalf), of the age required under\\napplicable laws, rules or regulations to
-      provide legal consent and that has legal authority\\nto bind your employer or
-      such other person or entity if you are entering in this Agreement\\non their
-      behalf.\\n\\n\u201CLlama 3.2\u201D means the foundational large language models
-      and software and algorithms, including\\nmachine-learning model code, trained
-      model weights, inference-enabling code, training-enabling code,\\nfine-tuning
-      enabling code and other elements of the foregoing distributed by Meta at \\nhttps://www.llama.com/llama-downloads.\\n\\n\u201CLlama
-      Materials\u201D means, collectively, Meta\u2019s proprietary Llama 3.2 and Documentation
-      (and \\nany portion thereof) made available under this Agreement.\\n\\n\u201CMeta\u201D
-      or \u201Cwe\u201D means Meta Platforms Ireland Limited (if you are located in
-      or, \\nif you are an entity, your principal place of business is in the EEA
-      or Switzerland) \\nand Meta Platforms, Inc. (if you are located outside of the
-      EEA or Switzerland). \\n\\n\\nBy clicking \u201CI Accept\u201D below or by using
-      or distributing any portion or element of the Llama Materials,\\nyou agree to
-      be bound by this Agreement.\\n\\n\\n1. License Rights and Redistribution.\\n\\n
-      \   a. Grant of Rights. You are granted a non-exclusive, worldwide, \\nnon-transferable
-      and royalty-free limited license under Meta\u2019s intellectual property or
-      other rights \\nowned by Meta embodied in the Llama Materials to use, reproduce,
-      distribute, copy, create derivative works \\nof, and make modifications to the
-      Llama Materials.  \\n\\n    b. Redistribution and Use.  \\n\\n        i. If
-      you distribute or make available the Llama Materials (or any derivative works
-      thereof), \\nor a product or service (including another AI model) that contains
-      any of them, you shall (A) provide\\na copy of this Agreement with any such
-      Llama Materials; and (B) prominently display \u201CBuilt with Llama\u201D\\non
-      a related website, user interface, blogpost, about page, or product documentation.
-      If you use the\\nLlama Materials or any outputs or results of the Llama Materials
-      to create, train, fine tune, or\\notherwise improve an AI model, which is distributed
-      or made available, you shall also include \u201CLlama\u201D\\nat the beginning
-      of any such AI model name.\\n\\n        ii. If you receive Llama Materials,
-      or any derivative works thereof, from a Licensee as part\\nof an integrated
-      end user product, then Section 2 of this Agreement will not apply to you. \\n\\n
-      \       iii. You must retain in all copies of the Llama Materials that you distribute
-      the \\nfollowing attribution notice within a \u201CNotice\u201D text file distributed
-      as a part of such copies: \\n\u201CLlama 3.2 is licensed under the Llama 3.2
-      Community License, Copyright \xA9 Meta Platforms,\\nInc. All Rights Reserved.\u201D\\n\\n
-      \       iv. Your use of the Llama Materials must comply with applicable laws
-      and regulations\\n(including trade compliance laws and regulations) and adhere
-      to the Acceptable Use Policy for\\nthe Llama Materials (available at https://www.llama.com/llama3_2/use-policy),
-      which is hereby \\nincorporated by reference into this Agreement.\\n  \\n2.
-      Additional Commercial Terms. If, on the Llama 3.2 version release date, the
-      monthly active users\\nof the products or services made available by or for
-      Licensee, or Licensee\u2019s affiliates, \\nis greater than 700 million monthly
-      active users in the preceding calendar month, you must request \\na license
-      from Meta, which Meta may grant to you in its sole discretion, and you are not
-      authorized to\\nexercise any of the rights under this Agreement unless or until
-      Meta otherwise expressly grants you such rights.\\n\\n3. Disclaimer of Warranty.
-      UNLESS REQUIRED BY APPLICABLE LAW, THE LLAMA MATERIALS AND ANY OUTPUT AND \\nRESULTS
-      THEREFROM ARE PROVIDED ON AN \u201CAS IS\u201D BASIS, WITHOUT WARRANTIES OF
-      ANY KIND, AND META DISCLAIMS\\nALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND
-      IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES\\nOF TITLE, NON-INFRINGEMENT,
-      MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE\\nFOR
-      DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE LLAMA MATERIALS
-      AND ASSUME ANY RISKS ASSOCIATED\\nWITH YOUR USE OF THE LLAMA MATERIALS AND ANY
-      OUTPUT AND RESULTS.\\n\\n4. Limitation of Liability. IN NO EVENT WILL META OR
-      ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, \\nWHETHER IN CONTRACT,
-      TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT,
-      \\nFOR ANY LOST PROFITS OR ANY INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL,
-      EXEMPLARY OR PUNITIVE DAMAGES, EVEN \\nIF META OR ITS AFFILIATES HAVE BEEN ADVISED
-      OF THE POSSIBILITY OF ANY OF THE FOREGOING.\\n\\n5. Intellectual Property.\\n\\n
-      \   a. No trademark licenses are granted under this Agreement, and in connection
-      with the Llama Materials, \\nneither Meta nor Licensee may use any name or mark
-      owned by or associated with the other or any of its affiliates, \\nexcept as
-      required for reasonable and customary use in describing and redistributing the
-      Llama Materials or as \\nset forth in this Section 5(a). Meta hereby grants
-      you a license to use \u201CLlama\u201D (the \u201CMark\u201D) solely as required
-      \\nto comply with the last sentence of Section 1.b.i. You will comply with Meta\u2019s
-      brand guidelines (currently accessible \\nat https://about.meta.com/brand/resources/meta/company-brand/).
-      All goodwill arising out of your use of the Mark \\nwill inure to the benefit
-      of Meta.\\n\\n    b. Subject to Meta\u2019s ownership of Llama Materials and
-      derivatives made by or for Meta, with respect to any\\n    derivative works
-      and modifications of the Llama Materials that are made by you, as between you
-      and Meta,\\n    you are and will be the owner of such derivative works and modifications.\\n\\n
-      \   c. If you institute litigation or other proceedings against Meta or any
-      entity (including a cross-claim or\\n    counterclaim in a lawsuit) alleging
-      that the Llama Materials or Llama 3.2 outputs or results, or any portion\\n
-      \   of any of the foregoing, constitutes infringement of intellectual property
-      or other rights owned or licensable\\n    by you, then any licenses granted
-      to you under this Agreement shall terminate as of the date such litigation or\\n
-      \   claim is filed or instituted. You will indemnify and hold harmless Meta
-      from and against any claim by any third\\n    party arising out of or related
-      to your use or distribution of the Llama Materials.\\n\\n6. Term and Termination.
-      The term of this Agreement will commence upon your acceptance of this Agreement
-      or access\\nto the Llama Materials and will continue in full force and effect
-      until terminated in accordance with the terms\\nand conditions herein. Meta
-      may terminate this Agreement if you are in breach of any term or condition of
-      this\\nAgreement. Upon termination of this Agreement, you shall delete and cease
-      use of the Llama Materials. Sections 3,\\n4 and 7 shall survive the termination
-      of this Agreement. \\n\\n7. Governing Law and Jurisdiction. This Agreement will
-      be governed and construed under the laws of the State of \\nCalifornia without
-      regard to choice of law principles, and the UN Convention on Contracts for the
-      International\\nSale of Goods does not apply to this Agreement. The courts of
-      California shall have exclusive jurisdiction of\\nany dispute arising out of
-      this Agreement.\\\"\\nLICENSE \\\"**Llama 3.2** **Acceptable Use Policy**\\n\\nMeta
-      is committed to promoting safe and fair use of its tools and features, including
-      Llama 3.2. If you access or use Llama 3.2, you agree to this Acceptable Use
-      Policy (\u201C**Policy**\u201D). The most recent copy of this policy can be
-      found at [https://www.llama.com/llama3_2/use-policy](https://www.llama.com/llama3_2/use-policy).\\n\\n**Prohibited
-      Uses**\\n\\nWe want everyone to use Llama 3.2 safely and responsibly. You agree
-      you will not use, or allow others to use, Llama 3.2 to:\\n\\n\\n\\n1. Violate
-      the law or others\u2019 rights, including to:\\n    1. Engage in, promote, generate,
-      contribute to, encourage, plan, incite, or further illegal or unlawful activity
-      or content, such as:\\n        1. Violence or terrorism\\n        2. Exploitation
-      or harm to children, including the solicitation, creation, acquisition, or dissemination
-      of child exploitative content or failure to report Child Sexual Abuse Material\\n
-      \       3. Human trafficking, exploitation, and sexual violence\\n        4.
-      The illegal distribution of information or materials to minors, including obscene
-      materials, or failure to employ legally required age-gating in connection with
-      such information or materials.\\n        5. Sexual solicitation\\n        6.
-      Any other criminal activity\\n    1. Engage in, promote, incite, or facilitate
-      the harassment, abuse, threatening, or bullying of individuals or groups of
-      individuals\\n    2. Engage in, promote, incite, or facilitate discrimination
-      or other unlawful or harmful conduct in the provision of employment, employment
-      benefits, credit, housing, other economic benefits, or other essential goods
-      and services\\n    3. Engage in the unauthorized or unlicensed practice of any
-      profession including, but not limited to, financial, legal, medical/health,
-      or related professional practices\\n    4. Collect, process, disclose, generate,
-      or infer private or sensitive information about individuals, including information
-      about individuals\u2019 identity, health, or demographic information, unless
-      you have obtained the right to do so in accordance with applicable law\\n    5.
-      Engage in or facilitate any action or generate any content that infringes, misappropriates,
-      or otherwise violates any third-party rights, including the outputs or results
-      of any products or services using the Llama Materials\\n    6. Create, generate,
-      or facilitate the creation of malicious code, malware, computer viruses or do
-      anything else that could disable, overburden, interfere with or impair the proper
-      working, integrity, operation or appearance of a website or computer system\\n
-      \   7. Engage in any action, or facilitate any action, to intentionally circumvent
-      or remove usage restrictions or other safety measures, or to enable functionality
-      disabled by Meta\\n2. Engage in, promote, incite, facilitate, or assist in the
-      planning or development of activities that present a risk of death or bodily
-      harm to individuals, including use of Llama 3.2 related to the following:\\n
-      \   8. Military, warfare, nuclear industries or applications, espionage, use
-      for materials or activities that are subject to the International Traffic Arms
-      Regulations (ITAR) maintained by the United States Department of State or to
-      the U.S. Biological Weapons Anti-Terrorism Act of 1989 or the Chemical Weapons
-      Convention Implementation Act of 1997\\n    9. Guns and illegal weapons (including
-      weapon development)\\n    10. Illegal drugs and regulated/controlled substances\\n
-      \   11. Operation of critical infrastructure, transportation technologies, or
-      heavy machinery\\n    12. Self-harm or harm to others, including suicide, cutting,
-      and eating disorders\\n    13. Any content intended to incite or promote violence,
-      abuse, or any infliction of bodily harm to an individual\\n3. Intentionally
-      deceive or mislead others, including use of Llama 3.2 related to the following:\\n
-      \   14. Generating, promoting, or furthering fraud or the creation or promotion
-      of disinformation\\n    15. Generating, promoting, or furthering defamatory
-      content, including the creation of defamatory statements, images, or other content\\n
-      \   16. Generating, promoting, or further distributing spam\\n    17. Impersonating
-      another individual without consent, authorization, or legal right\\n    18.
-      Representing that the use of Llama 3.2 or outputs are human-generated\\n    19.
-      Generating or facilitating false online engagement, including fake reviews and
-      other means of fake online engagement\\n4. Fail to appropriately disclose to
-      end users any known dangers of your AI system\\n5. Interact with third party
-      tools, models, or software designed to generate unlawful content or engage in
-      unlawful or harmful conduct and/or represent that the outputs of such tools,
-      models, or software are associated with Meta or Llama 3.2\\n\\nWith respect
-      to any multimodal models included in Llama 3.2, the rights granted under Section
-      1(a) of the Llama 3.2 Community License Agreement are not being granted to you
-      if you are an individual domiciled in, or a company with a principal place of
-      business in, the European Union. This restriction does not apply to end users
-      of a product or service that incorporates any such multimodal models.\\n\\nPlease
-      report any violation of this Policy, software \u201Cbug,\u201D or other problems
-      that could lead to a violation of this Policy through one of the following means:\\n\\n\\n\\n*
-      Reporting issues with the model: [https://github.com/meta-llama/llama-models/issues](https://l.workplace.com/l.php?u=https%3A%2F%2Fgithub.com%2Fmeta-llama%2Fllama-models%2Fissues\\u0026h=AT0qV8W9BFT6NwihiOHRuKYQM_UnkzN_NmHMy91OT55gkLpgi4kQupHUl0ssR4dQsIQ8n3tfd0vtkobvsEvt1l4Ic6GXI2EeuHV8N08OG2WnbAmm0FL4ObkazC6G_256vN0lN9DsykCvCqGZ)\\n*
-      Reporting risky content generated by the model: [developers.facebook.com/llama_output_feedback](http://developers.facebook.com/llama_output_feedback)\\n*
-      Reporting bugs and security concerns: [facebook.com/whitehat/info](http://facebook.com/whitehat/info)\\n*
-      Reporting violations of the Acceptable Use Policy or unlicensed uses of Llama
-      3.2: LlamaUseReport@meta.com\\\"\\n\",\"parameters\":\"stop                           \\\"\\u003c|start_header_id|\\u003e\\\"\\nstop
-      \                          \\\"\\u003c|end_header_id|\\u003e\\\"\\nstop                           \\\"\\u003c|eot_id|\\u003e\\\"\",\"template\":\"\\u003c|start_header_id|\\u003esystem\\u003c|end_header_id|\\u003e\\n\\nCutting
-      Knowledge Date: December 2023\\n\\n{{ if .System }}{{ .System }}\\n{{- end }}\\n{{-
-      if .Tools }}When you receive a tool call response, use the output to format
-      an answer to the orginal user question.\\n\\nYou are a helpful assistant with
-      tool calling capabilities.\\n{{- end }}\\u003c|eot_id|\\u003e\\n{{- range $i,
-      $_ := .Messages }}\\n{{- $last := eq (len (slice $.Messages $i)) 1 }}\\n{{-
-      if eq .Role \\\"user\\\" }}\\u003c|start_header_id|\\u003euser\\u003c|end_header_id|\\u003e\\n{{-
-      if and $.Tools $last }}\\n\\nGiven the following functions, please respond with
-      a JSON for a function call with its proper arguments that best answers the given
-      prompt.\\n\\nRespond in the format {\\\"name\\\": function name, \\\"parameters\\\":
-      dictionary of argument name and its value}. Do not use variables.\\n\\n{{ range
-      $.Tools }}\\n{{- . }}\\n{{ end }}\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{-
-      else }}\\n\\n{{ .Content }}\\u003c|eot_id|\\u003e\\n{{- end }}{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- else if eq .Role \\\"assistant\\\" }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n{{-
-      if .ToolCalls }}\\n{{ range .ToolCalls }}\\n{\\\"name\\\": \\\"{{ .Function.Name
-      }}\\\", \\\"parameters\\\": {{ .Function.Arguments }}}{{ end }}\\n{{- else }}\\n\\n{{
-      .Content }}\\n{{- end }}{{ if not $last }}\\u003c|eot_id|\\u003e{{ end }}\\n{{-
-      else if eq .Role \\\"tool\\\" }}\\u003c|start_header_id|\\u003eipython\\u003c|end_header_id|\\u003e\\n\\n{{
-      .Content }}\\u003c|eot_id|\\u003e{{ if $last }}\\u003c|start_header_id|\\u003eassistant\\u003c|end_header_id|\\u003e\\n\\n{{
-      end }}\\n{{- end }}\\n{{- end }}\",\"details\":{\"parent_model\":\"\",\"format\":\"gguf\",\"family\":\"llama\",\"families\":[\"llama\"],\"parameter_size\":\"3.2B\",\"quantization_level\":\"Q4_K_M\"},\"model_info\":{\"general.architecture\":\"llama\",\"general.basename\":\"Llama-3.2\",\"general.file_type\":15,\"general.finetune\":\"Instruct\",\"general.languages\":[\"en\",\"de\",\"fr\",\"it\",\"pt\",\"hi\",\"es\",\"th\"],\"general.parameter_count\":3212749888,\"general.quantization_version\":2,\"general.size_label\":\"3B\",\"general.tags\":[\"facebook\",\"meta\",\"pytorch\",\"llama\",\"llama-3\",\"text-generation\"],\"general.type\":\"model\",\"llama.attention.head_count\":24,\"llama.attention.head_count_kv\":8,\"llama.attention.key_length\":128,\"llama.attention.layer_norm_rms_epsilon\":0.00001,\"llama.attention.value_length\":128,\"llama.block_count\":28,\"llama.context_length\":131072,\"llama.embedding_length\":3072,\"llama.feed_forward_length\":8192,\"llama.rope.dimension_count\":128,\"llama.rope.freq_base\":500000,\"llama.vocab_size\":128256,\"tokenizer.ggml.bos_token_id\":128000,\"tokenizer.ggml.eos_token_id\":128009,\"tokenizer.ggml.merges\":null,\"tokenizer.ggml.model\":\"gpt2\",\"tokenizer.ggml.pre\":\"llama-bpe\",\"tokenizer.ggml.token_type\":null,\"tokenizer.ggml.tokens\":null},\"modified_at\":\"2024-12-31T11:53:14.529771974-05:00\"}"
-    headers:
-      Content-Type:
-      - application/json; charset=utf-8
-      Date:
-      - Wed, 15 Jan 2025 20:47:12 GMT
-      Transfer-Encoding:
-      - chunked
-    http_version: HTTP/1.1
-    status_code: 200
-version: 1

tests/utilities/cassettes/test_converter_with_nested_model.yaml

@@ -1,116 +0,0 @@
-interactions:
-- request:
-    body: '{"messages": [{"role": "user", "content": "Name: John Doe\nAge: 30\nAddress:
-      123 Main St, Anytown, 12345"}], "model": "gpt-4o-mini", "tool_choice": {"type":
-      "function", "function": {"name": "Person"}}, "tools": [{"type": "function",
-      "function": {"name": "Person", "description": "Correctly extracted `Person`
-      with all the required parameters with correct types", "parameters": {"$defs":
-      {"Address": {"properties": {"street": {"title": "Street", "type": "string"},
-      "city": {"title": "City", "type": "string"}, "zip_code": {"title": "Zip Code",
-      "type": "string"}}, "required": ["street", "city", "zip_code"], "title": "Address",
-      "type": "object"}}, "properties": {"name": {"title": "Name", "type": "string"},
-      "age": {"title": "Age", "type": "integer"}, "address": {"$ref": "#/$defs/Address"}},
-      "required": ["address", "age", "name"], "type": "object"}}}]}'
-    headers:
-      accept:
-      - application/json
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '853'
-      content-type:
-      - application/json
-      cookie:
-      - __cf_bm=PzayZLF04c14veGc.0ocVg3VHBbpzKRW8Hqox8L9U7c-1736974028-1.0.1.1-mZpK8.SH9l7K2z8Tvt6z.dURiVPjFqEz7zYEITfRwdr5z0razsSebZGN9IRPmI5XC_w5rbZW2Kg6hh5cenXinQ;
-        _cfuvid=ciwC3n2Srn20xx4JhEUeN6Ap0tNBaE44S95nIilboQ0-1736974028496-0.0.1.1-604800000
-      host:
-      - api.openai.com
-      user-agent:
-      - OpenAI/Python 1.59.6
-      x-stainless-arch:
-      - arm64
-      x-stainless-async:
-      - 'false'
-      x-stainless-lang:
-      - python
-      x-stainless-os:
-      - MacOS
-      x-stainless-package-version:
-      - 1.59.6
-      x-stainless-raw-response:
-      - 'true'
-      x-stainless-retry-count:
-      - '0'
-      x-stainless-runtime:
-      - CPython
-      x-stainless-runtime-version:
-      - 3.12.7
-    method: POST
-    uri: https://api.openai.com/v1/chat/completions
-  response:
-    content: "{\n  \"id\": \"chatcmpl-Aq4aFpbhU10QK0e6Jlkxy8AUxCZCf\",\n  \"object\":
-      \"chat.completion\",\n  \"created\": 1736974039,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
-      \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
-      \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
-      \           \"id\": \"call_N29aoGL9tN0qL2O7HI8Op2so\",\n            \"type\":
-      \"function\",\n            \"function\": {\n              \"name\": \"Person\",\n
-      \             \"arguments\": \"{\\\"name\\\":\\\"John Doe\\\",\\\"age\\\":30,\\\"address\\\":{\\\"street\\\":\\\"123
-      Main St\\\",\\\"city\\\":\\\"Anytown\\\",\\\"zip_code\\\":\\\"12345\\\"}}\"\n
-      \           }\n          }\n        ],\n        \"refusal\": null\n      },\n
-      \     \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n
-      \ \"usage\": {\n    \"prompt_tokens\": 118,\n    \"completion_tokens\": 30,\n
-      \   \"total_tokens\": 148,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
-      0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n
-      \     \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
-      0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
-      \"default\",\n  \"system_fingerprint\": \"fp_bd83329f63\"\n}\n"
-    headers:
-      CF-Cache-Status:
-      - DYNAMIC
-      CF-RAY:
-      - 9028b863dbaa672f-ATL
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Wed, 15 Jan 2025 20:47:20 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      X-Content-Type-Options:
-      - nosniff
-      access-control-expose-headers:
-      - X-Request-ID
-      alt-svc:
-      - h3=":443"; ma=86400
-      openai-organization:
-      - crewai-iuxna1
-      openai-processing-ms:
-      - '840'
-      openai-version:
-      - '2020-10-01'
-      strict-transport-security:
-      - max-age=31536000; includeSubDomains; preload
-      x-ratelimit-limit-requests:
-      - '30000'
-      x-ratelimit-limit-tokens:
-      - '150000000'
-      x-ratelimit-remaining-requests:
-      - '29999'
-      x-ratelimit-remaining-tokens:
-      - '149999968'
-      x-ratelimit-reset-requests:
-      - 2ms
-      x-ratelimit-reset-tokens:
-      - 0s
-      x-request-id:
-      - req_2f9d1e3f0ace4944891dde05093486aa
-    http_version: HTTP/1.1
-    status_code: 200
-version: 1

tests/utilities/test_converter.py

@@ -39,22 +39,6 @@ class NestedModel(BaseModel):
     data: SimpleModel
 
 
-class Address(BaseModel):
-    street: str
-    city: str
-    zip_code: str
-
-
-class Person(BaseModel):
-    name: str
-    age: int
-    address: Address
-
-
-class CustomConverter(Converter):
-    pass
-
-
 # Fixtures
 @pytest.fixture
 def mock_agent():
@@ -215,23 +199,26 @@ def test_convert_with_instructions_failure(
 
 # Tests for get_conversion_instructions
 def test_get_conversion_instructions_gpt():
-    llm = LLM(model="gpt-4o-mini")
+    mock_llm = Mock()
+    mock_llm.openai_api_base = None
     with patch.object(LLM, "supports_function_calling") as supports_function_calling:
         supports_function_calling.return_value = True
-        instructions = get_conversion_instructions(SimpleModel, llm)
+        instructions = get_conversion_instructions(SimpleModel, mock_llm)
         model_schema = PydanticSchemaParser(model=SimpleModel).get_schema()
         assert (
             instructions
-            == f"Please convert the following text into valid JSON.\n\nThe JSON should follow this schema:\n```json\n{model_schema}\n```"
+            == f"I'm gonna convert this raw text into valid JSON.\n\nThe json should have the following structure, with the following keys:\n{model_schema}"
         )
 
 
 def test_get_conversion_instructions_non_gpt():
-    llm = LLM(model="ollama/llama3.1", base_url="http://localhost:11434")
-    with patch.object(LLM, "supports_function_calling", return_value=False):
-        instructions = get_conversion_instructions(SimpleModel, llm)
-        assert '"name": str' in instructions
-        assert '"age": int' in instructions
+    mock_llm = Mock()
+    with patch.object(LLM, "supports_function_calling") as supports_function_calling:
+        supports_function_calling.return_value = False
+        with patch("crewai.utilities.converter.PydanticSchemaParser") as mock_parser:
+            mock_parser.return_value.get_schema.return_value = "Sample schema"
+            instructions = get_conversion_instructions(SimpleModel, mock_llm)
+            assert "Sample schema" in instructions
 
 
 # Tests for is_gpt
@@ -245,6 +232,10 @@ def test_supports_function_calling_false():
     assert llm.supports_function_calling() is False
 
 
+class CustomConverter(Converter):
+    pass
+
+
 def test_create_converter_with_mock_agent():
     mock_agent = MagicMock()
     mock_agent.get_output_converter.return_value = MagicMock(spec=Converter)
@@ -264,7 +255,7 @@ def test_create_converter_with_mock_agent():
 def test_create_converter_with_custom_converter():
     converter = create_converter(
         converter_cls=CustomConverter,
-        llm=LLM(model="gpt-4o-mini"),
+        llm=Mock(),
         text="Sample",
         model=SimpleModel,
         instructions="Convert",
@@ -322,269 +313,3 @@ def test_generate_model_description_dict_field():
     description = generate_model_description(ModelWithDictField)
     expected_description = '{\n  "attributes": Dict[str, int]\n}'
     assert description == expected_description
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_convert_with_instructions():
-    llm = LLM(model="gpt-4o-mini")
-    sample_text = "Name: Alice, Age: 30"
-
-    instructions = get_conversion_instructions(SimpleModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=SimpleModel,
-        instructions=instructions,
-    )
-
-    # Act
-    output = converter.to_pydantic()
-
-    # Assert
-    assert isinstance(output, SimpleModel)
-    assert output.name == "Alice"
-    assert output.age == 30
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_converter_with_llama3_2_model():
-    llm = LLM(model="ollama/llama3.2:3b", base_url="http://localhost:11434")
-
-    sample_text = "Name: Alice Llama, Age: 30"
-
-    instructions = get_conversion_instructions(SimpleModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=SimpleModel,
-        instructions=instructions,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, SimpleModel)
-    assert output.name == "Alice Llama"
-    assert output.age == 30
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_converter_with_llama3_1_model():
-    llm = LLM(model="ollama/llama3.1", base_url="http://localhost:11434")
-    sample_text = "Name: Alice Llama, Age: 30"
-
-    instructions = get_conversion_instructions(SimpleModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=SimpleModel,
-        instructions=instructions,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, SimpleModel)
-    assert output.name == "Alice Llama"
-    assert output.age == 30
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_converter_with_nested_model():
-    llm = LLM(model="gpt-4o-mini")
-    sample_text = "Name: John Doe\nAge: 30\nAddress: 123 Main St, Anytown, 12345"
-
-    instructions = get_conversion_instructions(Person, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=Person,
-        instructions=instructions,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, Person)
-    assert output.name == "John Doe"
-    assert output.age == 30
-    assert isinstance(output.address, Address)
-    assert output.address.street == "123 Main St"
-    assert output.address.city == "Anytown"
-    assert output.address.zip_code == "12345"
-
-
-# Tests for error handling
-def test_converter_error_handling():
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = False
-    llm.call.return_value = "Invalid JSON"
-    sample_text = "Name: Alice, Age: 30"
-
-    instructions = get_conversion_instructions(SimpleModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=SimpleModel,
-        instructions=instructions,
-    )
-
-    with pytest.raises(ConverterError) as exc_info:
-        output = converter.to_pydantic()
-
-    assert "Failed to convert text into a Pydantic model" in str(exc_info.value)
-
-
-# Tests for retry logic
-def test_converter_retry_logic():
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = False
-    llm.call.side_effect = [
-        "Invalid JSON",
-        "Still invalid",
-        '{"name": "Retry Alice", "age": 30}',
-    ]
-    sample_text = "Name: Retry Alice, Age: 30"
-
-    instructions = get_conversion_instructions(SimpleModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=SimpleModel,
-        instructions=instructions,
-        max_attempts=3,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, SimpleModel)
-    assert output.name == "Retry Alice"
-    assert output.age == 30
-    assert llm.call.call_count == 3
-
-
-# Tests for optional fields
-def test_converter_with_optional_fields():
-    class OptionalModel(BaseModel):
-        name: str
-        age: Optional[int]
-
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = False
-    # Simulate the LLM's response with 'age' explicitly set to null
-    llm.call.return_value = '{"name": "Bob", "age": null}'
-    sample_text = "Name: Bob, age: None"
-
-    instructions = get_conversion_instructions(OptionalModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=OptionalModel,
-        instructions=instructions,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, OptionalModel)
-    assert output.name == "Bob"
-    assert output.age is None
-
-
-# Tests for list fields
-def test_converter_with_list_field():
-    class ListModel(BaseModel):
-        items: List[int]
-
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = False
-    llm.call.return_value = '{"items": [1, 2, 3]}'
-    sample_text = "Items: 1, 2, 3"
-
-    instructions = get_conversion_instructions(ListModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=ListModel,
-        instructions=instructions,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, ListModel)
-    assert output.items == [1, 2, 3]
-
-
-# Tests for enums
-from enum import Enum
-
-
-def test_converter_with_enum():
-    class Color(Enum):
-        RED = "red"
-        GREEN = "green"
-        BLUE = "blue"
-
-    class EnumModel(BaseModel):
-        name: str
-        color: Color
-
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = False
-    llm.call.return_value = '{"name": "Alice", "color": "red"}'
-    sample_text = "Name: Alice, Color: Red"
-
-    instructions = get_conversion_instructions(EnumModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=EnumModel,
-        instructions=instructions,
-    )
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, EnumModel)
-    assert output.name == "Alice"
-    assert output.color == Color.RED
-
-
-# Tests for ambiguous input
-def test_converter_with_ambiguous_input():
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = False
-    llm.call.return_value = '{"name": "Charlie", "age": "Not an age"}'
-    sample_text = "Charlie is thirty years old"
-
-    instructions = get_conversion_instructions(SimpleModel, llm)
-    converter = Converter(
-        llm=llm,
-        text=sample_text,
-        model=SimpleModel,
-        instructions=instructions,
-    )
-
-    with pytest.raises(ConverterError) as exc_info:
-        output = converter.to_pydantic()
-
-    assert "validation error" in str(exc_info.value).lower()
-
-
-# Tests for function calling support
-def test_converter_with_function_calling():
-    llm = Mock(spec=LLM)
-    llm.supports_function_calling.return_value = True
-
-    instructor = Mock()
-    instructor.to_pydantic.return_value = SimpleModel(name="Eve", age=35)
-
-    converter = Converter(
-        llm=llm,
-        text="Name: Eve, Age: 35",
-        model=SimpleModel,
-        instructions="Convert this text.",
-    )
-    converter._create_instructor = Mock(return_value=instructor)
-
-    output = converter.to_pydantic()
-
-    assert isinstance(output, SimpleModel)
-    assert output.name == "Eve"
-    assert output.age == 35
-    instructor.to_pydantic.assert_called_once()

tests/utilities/test_pydantic_schema_parser.py

@@ -1,94 +0,0 @@
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
-
-import pytest
-from pydantic import BaseModel, Field
-
-from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
-
-
-def test_simple_model():
-    class SimpleModel(BaseModel):
-        field1: int
-        field2: str
-
-    parser = PydanticSchemaParser(model=SimpleModel)
-    schema = parser.get_schema()
-
-    expected_schema = """{
-    field1: int,
-    field2: str
-}"""
-    assert schema.strip() == expected_schema.strip()
-
-
-def test_nested_model():
-    class NestedModel(BaseModel):
-        nested_field: int
-
-    class ParentModel(BaseModel):
-        parent_field: str
-        nested: NestedModel
-
-    parser = PydanticSchemaParser(model=ParentModel)
-    schema = parser.get_schema()
-
-    expected_schema = """{
-    parent_field: str,
-    nested: NestedModel
-    {
-        nested_field: int
-    }
-}"""
-    assert schema.strip() == expected_schema.strip()
-
-
-def test_model_with_list():
-    class ListModel(BaseModel):
-        list_field: List[int]
-
-    parser = PydanticSchemaParser(model=ListModel)
-    schema = parser.get_schema()
-
-    expected_schema = """{
-    list_field: List[int]
-}"""
-    assert schema.strip() == expected_schema.strip()
-
-
-def test_model_with_optional_field():
-    class OptionalModel(BaseModel):
-        optional_field: Optional[str]
-
-    parser = PydanticSchemaParser(model=OptionalModel)
-    schema = parser.get_schema()
-
-    expected_schema = """{
-    optional_field: Optional[str]
-}"""
-    assert schema.strip() == expected_schema.strip()
-
-
-def test_model_with_union():
-    class UnionModel(BaseModel):
-        union_field: Union[int, str]
-
-    parser = PydanticSchemaParser(model=UnionModel)
-    schema = parser.get_schema()
-
-    expected_schema = """{
-    union_field: Union[int, str]
-}"""
-    assert schema.strip() == expected_schema.strip()
-
-
-def test_model_with_dict():
-    class DictModel(BaseModel):
-        dict_field: Dict[str, int]
-
-    parser = PydanticSchemaParser(model=DictModel)
-    schema = parser.get_schema()
-
-    expected_schema = """{
-    dict_field: Dict[str, int]
-}"""
-    assert schema.strip() == expected_schema.strip()

uv.lock

@@ -1,7 +1,6 @@
 version = 1
 requires-python = ">=3.10, <3.13"
 resolution-markers = [
-
     "python_full_version < '3.11' and platform_system == 'Darwin' and sys_platform == 'darwin'",
     "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform == 'darwin'",
     "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform == 'darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'darwin')",
@@ -37,7 +36,7 @@ resolution-markers = [
     "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform == 'linux'",
     "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system == 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12.4' and platform_system == 'Darwin' and sys_platform != 'darwin' and sys_platform != 'linux')",
     "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux'",
-    "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux')"
+    "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin' and sys_platform != 'darwin') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'darwin' and sys_platform != 'linux')",
 ]
 
 [[package]]
@@ -346,7 +345,7 @@ name = "build"
 version = "1.2.2.post1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "colorama", marker = "(os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "colorama", marker = "os_name == 'nt'" },
     { name = "importlib-metadata", marker = "python_full_version < '3.10.2'" },
     { name = "packaging" },
     { name = "pyproject-hooks" },
@@ -581,7 +580,7 @@ name = "click"
 version = "8.1.7"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "colorama", marker = "platform_system == 'Windows'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 }
 wheels = [
@@ -2588,7 +2587,7 @@ version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
-    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "colorama", marker = "platform_system == 'Windows'" },
     { name = "ghp-import" },
     { name = "jinja2" },
     { name = "markdown" },
@@ -2769,7 +2768,7 @@ version = "2.10.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pygments" },
-    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "pywin32", marker = "platform_system == 'Windows'" },
     { name = "tqdm" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/3a/93/80ac75c20ce54c785648b4ed363c88f148bf22637e10c9863db4fbe73e74/mpire-2.10.2.tar.gz", hash = "sha256:f66a321e93fadff34585a4bfa05e95bd946cf714b442f51c529038eb45773d97", size = 271270 }
@@ -3016,7 +3015,7 @@ name = "nvidia-cudnn-cu12"
 version = "9.1.0.70"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/9f/fd/713452cd72343f682b1c7b9321e23829f00b842ceaedcda96e742ea0b0b3/nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl", hash = "sha256:165764f44ef8c61fcdfdfdbe769d687e06374059fbb388b6c89ecb0e28793a6f", size = 664752741 },
@@ -3045,7 +3044,7 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" },
     { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" },
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/bc/1d/8de1e5c67099015c834315e333911273a8c6aaba78923dd1d1e25fc5f217/nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl", hash = "sha256:8a7ec542f0412294b15072fa7dab71d31334014a69f953004ea7a118206fe0dd", size = 124161928 },
@@ -3056,7 +3055,7 @@ name = "nvidia-cusparse-cu12"
 version = "12.1.0.106"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/65/5b/cfaeebf25cd9fdec14338ccb16f6b2c4c7fa9163aefcf057d86b9cc248bb/nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl", hash = "sha256:f3b50f42cf363f86ab21f720998517a659a48131e8d538dc02f8768237bd884c", size = 195958278 },
@@ -3606,7 +3605,7 @@ name = "portalocker"
 version = "2.10.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pywin32", marker = "sys_platform == 'win32'" },
+    { name = "pywin32", marker = "platform_system == 'Windows'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ed/d3/c6c64067759e87af98cc668c1cc75171347d0f1577fab7ca3749134e3cd4/portalocker-2.10.1.tar.gz", hash = "sha256:ef1bf844e878ab08aee7e40184156e1151f228f103aa5c6bd0724cc330960f8f", size = 40891 }
 wheels = [
@@ -5194,19 +5193,19 @@ dependencies = [
     { name = "fsspec" },
     { name = "jinja2" },
     { name = "networkx" },
-    { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
-    { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
+    { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
     { name = "sympy" },
-    { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },
+    { name = "triton", marker = "platform_machine == 'x86_64' and platform_system == 'Linux'" },
     { name = "typing-extensions" },
 ]
 wheels = [
@@ -5253,7 +5252,7 @@ name = "tqdm"
 version = "4.66.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "colorama", marker = "platform_system == 'Windows'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/58/83/6ba9844a41128c62e810fddddd72473201f3eacde02046066142a2d96cc5/tqdm-4.66.5.tar.gz", hash = "sha256:e1020aef2e5096702d8a025ac7d16b1577279c9d63f8375b63083e9a5f0fcbad", size = 169504 }
 wheels = [
@@ -5296,7 +5295,7 @@ version = "0.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
-    { name = "cffi", marker = "(implementation_name != 'pypy' and os_name == 'nt' and platform_machine != 'aarch64' and sys_platform == 'linux') or (implementation_name != 'pypy' and os_name == 'nt' and sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "idna" },
     { name = "outcome" },
@@ -5327,7 +5326,7 @@ name = "triton"
 version = "3.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "filelock", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" }
+    { name = "filelock", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux' and sys_platform != 'linux')" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/45/27/14cc3101409b9b4b9241d2ba7deaa93535a217a211c86c4cc7151fb12181/triton-3.0.0-1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e1efef76935b2febc365bfadf74bcb65a6f959a9872e5bddf44cc9e0adce1e1a", size = 209376304 },