fix: Add proper null checks for logger calls and improve type safety in LLM class

Co-Authored-By: Joe Moura <joao@crewai.com>

pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
     # Core Dependencies
     "pydantic>=2.4.2",
     "openai>=1.13.3",
-    "litellm>=1.44.22",
+    "litellm>=1.56.4",
     "instructor>=1.3.3",
     
     # Text Processing

src/crewai/agent.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import shutil
 import subprocess
@@ -21,6 +23,9 @@ from crewai.tools.base_tool import Tool
 from crewai.utilities import Converter, Prompts
 from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
 from crewai.utilities.converter import generate_model_description
+from crewai.utilities.logger import Logger
+from crewai.utilities.rpm_controller import RPMController
+from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.training_handler import CrewTrainingHandler
 
@@ -45,24 +50,113 @@ class Agent(BaseAgent):
     Each agent has a role, a goal, a backstory, and an optional language model (llm).
     The agent can also have memory, can operate in verbose mode, and can delegate tasks to other agents.
 
-    Attributes:
-            agent_executor: An instance of the CrewAgentExecutor class.
-            role: The role of the agent.
-            goal: The objective of the agent.
-            backstory: The backstory of the agent.
-            knowledge: The knowledge base of the agent.
-            config: Dict representation of agent configuration.
-            llm: The language model that will run the agent.
-            function_calling_llm: The language model that will handle the tool calling for this agent, it overrides the crew function_calling_llm.
-            max_iter: Maximum number of iterations for an agent to execute a task.
-            memory: Whether the agent should have memory or not.
-            max_rpm: Maximum number of requests per minute for the agent execution to be respected.
-            verbose: Whether the agent execution should be in verbose mode.
-            allow_delegation: Whether the agent is allowed to delegate tasks to other agents.
-            tools: Tools at agents disposal
-            step_callback: Callback to be executed after each step of the agent execution.
-            knowledge_sources: Knowledge sources for the agent.
+    Args:
+        role (Optional[str]): The role of the agent
+        goal (Optional[str]): The objective of the agent
+        backstory (Optional[str]): The backstory of the agent
+        allow_delegation (bool): Whether the agent can delegate tasks
+        config (Optional[Dict[str, Any]]): Configuration for the agent
+        verbose (bool): Whether to enable verbose output
+        max_rpm (Optional[int]): Maximum requests per minute
+        tools (Optional[List[Any]]): Tools available to the agent
+        llm (Optional[Union[str, Any]]): Language model to use
+        function_calling_llm (Optional[Any]): Language model for tool calling
+        max_iter (Optional[int]): Maximum iterations for task execution
+        memory (bool): Whether the agent should have memory
+        step_callback (Optional[Any]): Callback after each execution step
+        knowledge_sources (Optional[List[BaseKnowledgeSource]]): Knowledge sources
     """
+    
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "allow",
+    }
+
+    def __init__(
+        self,
+        role: Optional[str] = None,
+        goal: Optional[str] = None,
+        backstory: Optional[str] = None,
+        allow_delegation: bool = False,
+        config: Optional[Dict[str, Any]] = None,
+        verbose: bool = False,
+        max_rpm: Optional[int] = None,
+        tools: Optional[List[Any]] = None,
+        llm: Optional[Union[str, LLM, Any]] = None,
+        function_calling_llm: Optional[Any] = None,
+        max_iter: Optional[int] = None,
+        memory: bool = True,
+        step_callback: Optional[Any] = None,
+        knowledge_sources: Optional[List[BaseKnowledgeSource]] = None,
+        **kwargs
+    ) -> None:
+        """Initialize an Agent with the given parameters."""
+        # Process tools before passing to parent
+        processed_tools = []
+        if tools:
+            from crewai.tools import BaseTool
+            for tool in tools:
+                if isinstance(tool, BaseTool):
+                    processed_tools.append(tool)
+                elif callable(tool):
+                    # Convert function to BaseTool
+                    processed_tools.append(Tool.from_function(tool))
+                else:
+                    raise ValueError(f"Tool {tool} must be either a BaseTool instance or a callable")
+
+        # Process LLM before passing to parent
+        processed_llm = None
+        if isinstance(llm, str):
+            processed_llm = LLM(model=llm)
+        elif isinstance(llm, LLM):
+            processed_llm = llm
+        elif llm is not None and hasattr(llm, 'model') and hasattr(llm, 'temperature'):
+            # Handle ChatOpenAI and similar objects
+            model_name = getattr(llm, 'model', None)
+            if model_name is not None:
+                if not isinstance(model_name, str):
+                    model_name = str(model_name)
+                processed_llm = LLM(
+                    model=model_name,
+                    temperature=getattr(llm, 'temperature', None),
+                    api_key=getattr(llm, 'api_key', None),
+                    base_url=getattr(llm, 'base_url', None)
+                )
+        # If no valid LLM configuration found, leave as None for post_init_setup
+
+        # Initialize all fields in a dict
+        init_dict = {
+            "role": role,
+            "goal": goal,
+            "backstory": backstory,
+            "allow_delegation": allow_delegation,
+            "config": config,
+            "verbose": verbose,
+            "max_rpm": max_rpm,
+            "tools": processed_tools,
+            "max_iter": max_iter if max_iter is not None else 25,
+            "function_calling_llm": function_calling_llm,
+            "step_callback": step_callback,
+            "knowledge_sources": knowledge_sources,
+            **kwargs
+        }
+
+        # Initialize base model with all fields
+        super().__init__(**init_dict)
+        
+        # Store original values for interpolation
+        self._original_role = role
+        self._original_goal = goal
+        self._original_backstory = backstory
+        
+        # Set LLM after base initialization to ensure proper model handling
+        self.llm = processed_llm
+        
+        # Initialize private attributes
+        self._logger = Logger(verbose=self.verbose)
+        if self.max_rpm:
+            self._rpm_controller = RPMController(max_rpm=self.max_rpm, logger=self._logger)
+        self._token_process = TokenProcess()
 
     _times_executed: int = PrivateAttr(default=0)
     max_execution_time: Optional[int] = Field(
@@ -138,21 +232,15 @@ class Agent(BaseAgent):
     @model_validator(mode="after")
     def post_init_setup(self):
         self._set_knowledge()
-        self.agent_ops_agent_name = self.role
+        self.agent_ops_agent_name = self.role or "agent"
         unaccepted_attributes = [
             "AWS_ACCESS_KEY_ID",
             "AWS_SECRET_ACCESS_KEY",
             "AWS_REGION_NAME",
         ]
 
-        # Handle different cases for self.llm
-        if isinstance(self.llm, str):
-            # If it's a string, create an LLM instance
-            self.llm = LLM(model=self.llm)
-        elif isinstance(self.llm, LLM):
-            # If it's already an LLM instance, keep it as is
-            pass
-        elif self.llm is None:
+        # Handle LLM initialization if not already done
+        if self.llm is None:
             # Determine the model name from environment variables or use default
             model_name = (
                 os.environ.get("OPENAI_MODEL_NAME")
@@ -190,9 +278,71 @@ class Agent(BaseAgent):
                                 if key not in ["prompt", "key_name", "default"]:
                                     # Only add default if the key is already set in os.environ
                                     if key in os.environ:
-                                        llm_params[key] = value
+                                        try:
+                                            # Create a new dictionary for properly typed parameters
+                                            typed_params = {}
+                                            
+                                            # Convert and validate values based on parameter type
+                                            if key in ['temperature', 'top_p', 'presence_penalty', 'frequency_penalty']:
+                                                if value is not None:
+                                                    try:
+                                                        typed_params[key] = float(value)
+                                                    except (ValueError, TypeError):
+                                                        pass
+                                            elif key in ['n', 'max_tokens', 'max_completion_tokens', 'seed']:
+                                                if value is not None:
+                                                    try:
+                                                        typed_params[key] = int(value)
+                                                    except (ValueError, TypeError):
+                                                        pass
+                                            elif key == 'logit_bias' and isinstance(value, str):
+                                                try:
+                                                    bias_dict = {}
+                                                    for pair in value.split(','):
+                                                        token_id, bias = pair.split(':')
+                                                        bias_dict[int(token_id.strip())] = float(bias.strip())
+                                                    typed_params[key] = bias_dict
+                                                except (ValueError, AttributeError):
+                                                    pass
+                                            elif key == 'response_format' and isinstance(value, str):
+                                                try:
+                                                    import json
+                                                    typed_params[key] = json.loads(value)
+                                                except json.JSONDecodeError:
+                                                    pass
+                                            elif key == 'logprobs':
+                                                if value is not None:
+                                                    typed_params[key] = bool(value.lower() == 'true') if isinstance(value, str) else bool(value)
+                                            elif key == 'callbacks':
+                                                typed_params[key] = [] if value is None else [value] if isinstance(value, str) else value
+                                            elif key == 'stop':
+                                                typed_params[key] = [value] if isinstance(value, str) else value
+                                            elif key in ['model', 'base_url', 'api_version', 'api_key']:
+                                                typed_params[key] = value
+                                            
+                                            # Update llm_params with properly typed values
+                                            if typed_params:
+                                                llm_params.update(typed_params)
+                                        except (ValueError, AttributeError, json.JSONDecodeError):
+                                            continue
 
-            self.llm = LLM(**llm_params)
+            # Create LLM instance with properly typed parameters
+            valid_params = {
+                'model', 'timeout', 'temperature', 'top_p', 'n', 'stop',
+                'max_completion_tokens', 'max_tokens', 'presence_penalty',
+                'frequency_penalty', 'logit_bias', 'response_format',
+                'seed', 'logprobs', 'top_logprobs', 'base_url',
+                'api_version', 'api_key', 'callbacks'
+            }
+            
+            # Filter out None values and invalid parameters
+            filtered_params = {}
+            for k, v in llm_params.items():
+                if k in valid_params and v is not None:
+                    filtered_params[k] = v
+            
+            # Create LLM instance with properly typed parameters
+            self.llm = LLM(**filtered_params)
         else:
             # For any other type, attempt to extract relevant attributes
             llm_params = {
@@ -239,7 +389,7 @@ class Agent(BaseAgent):
     def _set_knowledge(self):
         try:
             if self.knowledge_sources:
-                knowledge_agent_name = f"{self.role.replace(' ', '_')}"
+                knowledge_agent_name = f"{(self.role or 'agent').replace(' ', '_')}"
                 if isinstance(self.knowledge_sources, list) and all(
                     isinstance(k, BaseKnowledgeSource) for k in self.knowledge_sources
                 ):
@@ -384,6 +534,32 @@ class Agent(BaseAgent):
                 self.response_template.split("{{ .Response }}")[1].strip()
             )
 
+        # Ensure LLM is initialized with proper error handling
+        try:
+            if not self.llm:
+                self.llm = LLM(model="gpt-4")
+                if hasattr(self, '_logger'):
+                    self._logger.debug("Initialized default LLM with gpt-4 model")
+        except Exception as e:
+            if hasattr(self, '_logger'):
+                self._logger.error(f"Failed to initialize LLM: {str(e)}")
+            raise
+
+        # Create token callback with proper error handling
+        try:
+            token_callback = None
+            if hasattr(self, '_token_process'):
+                token_callback = TokenCalcHandler(self._token_process)
+        except Exception as e:
+            if hasattr(self, '_logger'):
+                self._logger.warning(f"Failed to create token callback: {str(e)}")
+            token_callback = None
+
+        # Initialize callbacks list
+        executor_callbacks = []
+        if token_callback:
+            executor_callbacks.append(token_callback)
+
         self.agent_executor = CrewAgentExecutor(
             llm=self.llm,
             task=task,
@@ -401,9 +577,9 @@ class Agent(BaseAgent):
             function_calling_llm=self.function_calling_llm,
             respect_context_window=self.respect_context_window,
             request_within_rpm_limit=(
-                self._rpm_controller.check_or_wait if self._rpm_controller else None
+                self._rpm_controller.check_or_wait if (hasattr(self, '_rpm_controller') and self._rpm_controller is not None) else None
             ),
-            callbacks=[TokenCalcHandler(self._token_process)],
+            callbacks=executor_callbacks,
         )
 
     def get_delegation_tools(self, agents: List[BaseAgent]):

src/crewai/agents/agent_builder/base_agent.py

@@ -18,6 +18,7 @@ from pydantic_core import PydanticCustomError
 from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
 from crewai.agents.cache.cache_handler import CacheHandler
 from crewai.agents.tools_handler import ToolsHandler
+from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.tools import BaseTool
 from crewai.tools.base_tool import Tool
 from crewai.utilities import I18N, Logger, RPMController
@@ -87,9 +88,9 @@ class BaseAgent(ABC, BaseModel):
     formatting_errors: int = Field(
         default=0, description="Number of formatting errors."
     )
-    role: str = Field(description="Role of the agent")
-    goal: str = Field(description="Objective of the agent")
-    backstory: str = Field(description="Backstory of the agent")
+    role: Optional[str] = Field(default=None, description="Role of the agent")
+    goal: Optional[str] = Field(default=None, description="Objective of the agent")
+    backstory: Optional[str] = Field(default=None, description="Backstory of the agent")
     config: Optional[Dict[str, Any]] = Field(
         description="Configuration for the agent", default=None, exclude=True
     )
@@ -130,26 +131,47 @@ class BaseAgent(ABC, BaseModel):
     max_tokens: Optional[int] = Field(
         default=None, description="Maximum number of tokens for the agent's execution."
     )
+    function_calling_llm: Optional[Any] = Field(
+        default=None, description="Language model for function calling."
+    )
+    step_callback: Optional[Any] = Field(
+        default=None, description="Callback for execution steps."
+    )
+    knowledge_sources: Optional[List[BaseKnowledgeSource]] = Field(
+        default=None, description="Knowledge sources for the agent."
+    )
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "allow",  # Allow extra fields in constructor
+    }
 
     @model_validator(mode="before")
     @classmethod
     def process_model_config(cls, values):
+        """Process configuration values before model initialization."""
         return process_config(values, cls)
 
     @field_validator("tools")
     @classmethod
-    def validate_tools(cls, tools: List[Any]) -> List[BaseTool]:
+    def validate_tools(cls, tools: Optional[List[Any]]) -> List[BaseTool]:
         """Validate and process the tools provided to the agent.
 
-        This method ensures that each tool is either an instance of BaseTool
-        or an object with 'name', 'func', and 'description' attributes. If the
-        tool meets these criteria, it is processed and added to the list of
-        tools. Otherwise, a ValueError is raised.
+        This method ensures that each tool is either an instance of BaseTool,
+        a function decorated with @tool, or an object with 'name', 'func', 
+        and 'description' attributes. If the tool meets these criteria, it is 
+        processed and added to the list of tools. Otherwise, a ValueError is raised.
         """
+        if not tools:
+            return []
+
         processed_tools = []
         for tool in tools:
             if isinstance(tool, BaseTool):
                 processed_tools.append(tool)
+            elif callable(tool) and hasattr(tool, "_is_tool") and tool._is_tool:
+                # Handle @tool decorated functions
+                processed_tools.append(Tool.from_function(tool))
             elif (
                 hasattr(tool, "name")
                 and hasattr(tool, "func")
@@ -157,31 +179,54 @@ class BaseAgent(ABC, BaseModel):
             ):
                 # Tool has the required attributes, create a Tool instance
                 processed_tools.append(Tool.from_langchain(tool))
-            else:
+            else: 
                 raise ValueError(
                     f"Invalid tool type: {type(tool)}. "
-                    "Tool must be an instance of BaseTool or "
-                    "an object with 'name', 'func', and 'description' attributes."
+                    "Tool must be an instance of BaseTool, a @tool decorated function, "
+                    "or an object with 'name', 'func', and 'description' attributes."
                 )
         return processed_tools
 
     @model_validator(mode="after")
     def validate_and_set_attributes(self):
-        # Validate required fields
-        for field in ["role", "goal", "backstory"]:
-            if getattr(self, field) is None:
-                raise ValueError(
-                    f"{field} must be provided either directly or through config"
-                )
+        """Validate and set attributes for the agent.
+        
+        This method ensures that attributes are properly set and initialized,
+        either from direct parameters or configuration.
+        """
+        # Store original values for interpolation
+        self._original_role = self.role
+        self._original_goal = self.goal
+        self._original_backstory = self.backstory
 
-        # Set private attributes
+        # Process config if provided
+        if self.config:
+            config_data = self.config
+            if isinstance(config_data, str):
+                import json
+                try:
+                    config_data = json.loads(config_data)
+                except json.JSONDecodeError:
+                    raise ValueError("Invalid JSON in config")
+
+            # Update fields from config if they're None
+            for field in ["role", "goal", "backstory"]:
+                if field in config_data and getattr(self, field) is None:
+                    setattr(self, field, config_data[field])
+
+        # Set default values for required fields if they're still None
+        self.role = self.role or "Assistant"
+        self.goal = self.goal or "Help the user accomplish their tasks"
+        self.backstory = self.backstory or "I am an AI assistant ready to help"
+
+        # Initialize tools handler if not set
+        if not hasattr(self, 'tools_handler') or self.tools_handler is None:
+            self.tools_handler = ToolsHandler()
+
+        # Initialize logger and rpm controller
         self._logger = Logger(verbose=self.verbose)
-        if self.max_rpm and not self._rpm_controller:
-            self._rpm_controller = RPMController(
-                max_rpm=self.max_rpm, logger=self._logger
-            )
-        if not self._token_process:
-            self._token_process = TokenProcess()
+        if self.max_rpm:
+            self._rpm_controller = RPMController(max_rpm=self.max_rpm, logger=self._logger)
 
         return self
 
@@ -208,9 +253,9 @@ class BaseAgent(ABC, BaseModel):
     @property
     def key(self):
         source = [
-            self._original_role or self.role,
-            self._original_goal or self.goal,
-            self._original_backstory or self.backstory,
+            str(self._original_role or self.role or ""),
+            str(self._original_goal or self.goal or ""),
+            str(self._original_backstory or self.backstory or ""),
         ]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
 
@@ -256,29 +301,45 @@ class BaseAgent(ABC, BaseModel):
             "tools_handler",
             "cache_handler",
             "llm",
+            "function_calling_llm",
         }
 
-        # Copy llm and clear callbacks
-        existing_llm = shallow_copy(self.llm)
+        # Copy LLMs and clear callbacks
+        existing_llm = shallow_copy(self.llm) if self.llm else None
+        existing_function_calling_llm = shallow_copy(self.function_calling_llm) if self.function_calling_llm else None
+
+        # Create base data
         copied_data = self.model_dump(exclude=exclude)
         copied_data = {k: v for k, v in copied_data.items() if v is not None}
-        copied_agent = type(self)(**copied_data, llm=existing_llm, tools=self.tools)
+
+        # Create new instance with copied data
+        copied_agent = type(self)(
+            **copied_data,
+            llm=existing_llm,
+            function_calling_llm=existing_function_calling_llm,
+            tools=self.tools
+        )
+
+        # Copy private attributes
+        copied_agent._original_role = self._original_role
+        copied_agent._original_goal = self._original_goal
+        copied_agent._original_backstory = self._original_backstory
 
         return copied_agent
 
     def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
         """Interpolate inputs into the agent description and backstory."""
         if self._original_role is None:
-            self._original_role = self.role
+            self._original_role = self.role or ""
         if self._original_goal is None:
-            self._original_goal = self.goal
+            self._original_goal = self.goal or ""
         if self._original_backstory is None:
-            self._original_backstory = self.backstory
+            self._original_backstory = self.backstory or ""
 
         if inputs:
-            self.role = self._original_role.format(**inputs)
-            self.goal = self._original_goal.format(**inputs)
-            self.backstory = self._original_backstory.format(**inputs)
+            self.role = self._original_role.format(**inputs) if self._original_role else None
+            self.goal = self._original_goal.format(**inputs) if self._original_goal else None
+            self.backstory = self._original_backstory.format(**inputs) if self._original_backstory else None
 
     def set_cache_handler(self, cache_handler: CacheHandler) -> None:
         """Set the cache handler for the agent.

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -82,16 +82,17 @@ class CrewAgentExecutorMixin:
                 )
                 self.crew._long_term_memory.save(long_term_memory)
 
-                for entity in evaluation.entities:
-                    entity_memory = EntityMemoryItem(
-                        name=entity.name,
-                        type=entity.type,
-                        description=entity.description,
-                        relationships="\n".join(
-                            [f"- {r}" for r in entity.relationships]
-                        ),
-                    )
-                    self.crew._entity_memory.save(entity_memory)
+                if hasattr(evaluation, 'entities') and evaluation.entities:
+                    for entity in evaluation.entities:
+                        entity_memory = EntityMemoryItem(
+                            name=entity.name,
+                            type=entity.type,
+                            description=entity.description,
+                            relationships="\n".join(
+                                [f"- {r}" for r in entity.relationships]
+                            ),
+                        )
+                        self.crew._entity_memory.save(entity_memory)
             except AttributeError as e:
                 print(f"Missing attributes for long term memory: {e}")
                 pass

src/crewai/agents/crew_agent_executor.py

@@ -68,7 +68,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         self.tools_handler = tools_handler
         self.original_tools = original_tools
         self.step_callback = step_callback
-        self.use_stop_words = self.llm.supports_stop_words()
+        self.use_stop_words = self.llm.supports_stop_words() if self.llm else False
         self.tools_description = tools_description
         self.function_calling_llm = function_calling_llm
         self.respect_context_window = respect_context_window
@@ -147,7 +147,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         # Directly append the result to the messages if the
                         # tool is "Add image to content" in case of multimodal
                         # agents
-                        if formatted_answer.tool == self._i18n.tools("add_image")["name"]:
+                        add_image_tool_name = self._i18n.tools("add_image")
+                        if add_image_tool_name and formatted_answer.tool == add_image_tool_name:
                             self.messages.append(tool_result.result)
                             continue
 
@@ -214,13 +215,14 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if self.agent.verbose or (
             hasattr(self, "crew") and getattr(self.crew, "verbose", False)
         ):
-            agent_role = self.agent.role.split("\n")[0]
+            agent_role = self.agent.role.split("\n")[0] if self.agent and self.agent.role else ""
             self._printer.print(
                 content=f"\033[1m\033[95m# Agent:\033[00m \033[1m\033[92m{agent_role}\033[00m"
             )
-            self._printer.print(
-                content=f"\033[95m## Task:\033[00m \033[92m{self.task.description}\033[00m"
-            )
+            if self.task and self.task.description:
+                self._printer.print(
+                    content=f"\033[95m## Task:\033[00m \033[92m{self.task.description}\033[00m"
+                )
 
     def _show_logs(self, formatted_answer: Union[AgentAction, AgentFinish]):
         if self.agent is None:
@@ -228,7 +230,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         if self.agent.verbose or (
             hasattr(self, "crew") and getattr(self.crew, "verbose", False)
         ):
-            agent_role = self.agent.role.split("\n")[0]
+            agent_role = self.agent.role.split("\n")[0] if self.agent and self.agent.role else ""
             if isinstance(formatted_answer, AgentAction):
                 thought = re.sub(r"\n+", "\n", formatted_answer.thought)
                 formatted_json = json.dumps(

src/crewai/cli/provider.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 import click
 import requests
+from typing import Any
 
 from crewai.cli.constants import JSON_URL, MODELS, PROVIDERS
 
@@ -192,7 +193,7 @@ def download_data(response):
     data_chunks = []
     with click.progressbar(
         length=total_size, label="Downloading", show_pos=True
-    ) as progress_bar:
+    ) as progress_bar:  # type: Any
         for chunk in response.iter_content(block_size):
             if chunk:
                 data_chunks.append(chunk)

src/crewai/crew.py

@@ -6,6 +6,8 @@ from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
+from crewai.tools.base_tool import BaseTool
+
 from pydantic import (
     UUID4,
     BaseModel,
@@ -726,13 +728,9 @@ class Crew(BaseModel):
 
             # Determine which tools to use - task tools take precedence over agent tools
             tools_for_task = task.tools or agent_to_use.tools or []
-            tools_for_task = self._prepare_tools(
-                agent_to_use,
-                task,
-                tools_for_task
-            )
+            tools_for_task = self._prepare_tools(agent_to_use, task, tools_for_task)
 
-            self._log_task_start(task, agent_to_use.role)
+            self._log_task_start(task, agent_to_use.role if agent_to_use and agent_to_use.role else "")
 
             if isinstance(task, ConditionalTask):
                 skipped_task_output = self._handle_conditional_task(
@@ -797,14 +795,18 @@ class Crew(BaseModel):
             return skipped_task_output
         return None
 
-    def _prepare_tools(self, agent: BaseAgent, task: Task, tools: List[Tool]) -> List[Tool]:
+    def _prepare_tools(
+        self, agent: BaseAgent, task: Task, tools: List[Union[Tool, BaseTool]]
+    ) -> List[Union[Tool, BaseTool]]:
         # Add delegation tools if agent allows delegation
         if agent.allow_delegation:
             if self.process == Process.hierarchical:
                 if self.manager_agent:
                     tools = self._update_manager_tools(task, tools)
                 else:
-                    raise ValueError("Manager agent is required for hierarchical process.")
+                    raise ValueError(
+                        "Manager agent is required for hierarchical process."
+                    )
 
             elif agent and agent.allow_delegation:
                 tools = self._add_delegation_tools(task, tools)
@@ -823,7 +825,9 @@ class Crew(BaseModel):
             return self.manager_agent
         return task.agent
 
-    def _merge_tools(self, existing_tools: List[Tool], new_tools: List[Tool]) -> List[Tool]:
+    def _merge_tools(
+        self, existing_tools: List[Union[Tool, BaseTool]], new_tools: List[Union[Tool, BaseTool]]
+    ) -> List[Union[Tool, BaseTool]]:
         """Merge new tools into existing tools list, avoiding duplicates by tool name."""
         if not new_tools:
             return existing_tools
@@ -839,7 +843,9 @@ class Crew(BaseModel):
 
         return tools
 
-    def _inject_delegation_tools(self, tools: List[Tool], task_agent: BaseAgent, agents: List[BaseAgent]):
+    def _inject_delegation_tools(
+        self, tools: List[Tool], task_agent: BaseAgent, agents: List[BaseAgent]
+    ):
         delegation_tools = task_agent.get_delegation_tools(agents)
         return self._merge_tools(tools, delegation_tools)
 
@@ -856,7 +862,9 @@ class Crew(BaseModel):
         if len(self.agents) > 1 and len(agents_for_delegation) > 0 and task.agent:
             if not tools:
                 tools = []
-            tools = self._inject_delegation_tools(tools, task.agent, agents_for_delegation)
+            tools = self._inject_delegation_tools(
+                tools, task.agent, agents_for_delegation
+            )
         return tools
 
     def _log_task_start(self, task: Task, role: str = "None"):
@@ -870,7 +878,9 @@ class Crew(BaseModel):
             if task.agent:
                 tools = self._inject_delegation_tools(tools, task.agent, [task.agent])
             else:
-                tools = self._inject_delegation_tools(tools, self.manager_agent, self.agents)
+                tools = self._inject_delegation_tools(
+                    tools, self.manager_agent, self.agents
+                )
         return tools
 
     def _get_context(self, task: Task, task_outputs: List[TaskOutput]):

src/crewai/crews/crew_output.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Optional, Union
 
 from pydantic import BaseModel, Field
 
@@ -23,14 +23,25 @@ class CrewOutput(BaseModel):
     )
     token_usage: UsageMetrics = Field(description="Processed token summary", default={})
 
-    @property
-    def json(self) -> Optional[str]:
+    def json(
+        self,
+        *,
+        include: Union[set[str], None] = None,
+        exclude: Union[set[str], None] = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        encoder: Optional[Callable[[Any], Any]] = None,
+        models_as_dict: bool = True,
+        **dumps_kwargs: Any,
+    ) -> str:
         if self.tasks_output[-1].output_format != OutputFormat.JSON:
             raise ValueError(
                 "No JSON output found in the final task. Please make sure to set the output_json property in the final task in your crew."
             )
 
-        return json.dumps(self.json_dict)
+        return json.dumps(self.json_dict, default=encoder, **dumps_kwargs)
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert json_output and pydantic_output to a dictionary."""

src/crewai/flow/core_flow_utils.py

@@ -1,141 +0,0 @@
-"""Core utility functions for Flow class operations.
-
-This module contains utility functions that are specifically designed to work
-with the Flow class and require direct access to Flow class internals. These
-utilities are separated from general-purpose utilities to maintain a clean
-dependency structure and avoid circular imports.
-
-Functions in this module are core to Flow functionality and are not related
-to visualization or other optional features.
-"""
-
-import ast
-import inspect
-import textwrap
-from typing import Any, Callable, Dict, List, Optional, Set, Union
-
-from pydantic import BaseModel
-
-
-def get_possible_return_constants(function: Callable[..., Any]) -> Optional[List[str]]:
-    """Extract possible string return values from a function by analyzing its source code.
-    
-    Analyzes the function's source code using AST to identify string constants that
-    could be returned, including strings stored in dictionaries and direct returns.
-    
-    Args:
-        function: The function to analyze for possible return values
-        
-    Returns:
-        list[str] | None: List of possible string return values, or None if:
-            - Source code cannot be retrieved
-            - Source code has syntax/indentation errors
-            - No string return values are found
-            
-    Raises:
-        OSError: If source code cannot be retrieved
-        IndentationError: If source code has invalid indentation
-        SyntaxError: If source code has syntax errors
-        
-    Example:
-        >>> def get_status():
-        ...     paths = {"success": "completed", "error": "failed"}
-        ...     return paths["success"]
-        >>> get_possible_return_constants(get_status)
-        ['completed', 'failed']
-    """
-    try:
-        source = inspect.getsource(function)
-    except OSError:
-        # Can't get source code
-        return None
-    except Exception as e:
-        print(f"Error retrieving source code for function {function.__name__}: {e}")
-        return None
-
-    try:
-        # Remove leading indentation
-        source = textwrap.dedent(source)
-        # Parse the source code into an AST
-        code_ast = ast.parse(source)
-    except IndentationError as e:
-        print(f"IndentationError while parsing source code of {function.__name__}: {e}")
-        print(f"Source code:\n{source}")
-        return None
-    except SyntaxError as e:
-        print(f"SyntaxError while parsing source code of {function.__name__}: {e}")
-        print(f"Source code:\n{source}")
-        return None
-    except Exception as e:
-        print(f"Unexpected error while parsing source code of {function.__name__}: {e}")
-        print(f"Source code:\n{source}")
-        return None
-
-    return_values = set()
-    dict_definitions = {}
-
-    class DictionaryAssignmentVisitor(ast.NodeVisitor):
-        def visit_Assign(self, node):
-            # Check if this assignment is assigning a dictionary literal to a variable
-            if isinstance(node.value, ast.Dict) and len(node.targets) == 1:
-                target = node.targets[0]
-                if isinstance(target, ast.Name):
-                    var_name = target.id
-                    dict_values = []
-                    # Extract string values from the dictionary
-                    for val in node.value.values:
-                        if isinstance(val, ast.Constant) and isinstance(val.value, str):
-                            dict_values.append(val.value)
-                        # If non-string, skip or just ignore
-                    if dict_values:
-                        dict_definitions[var_name] = dict_values
-            self.generic_visit(node)
-
-    class ReturnVisitor(ast.NodeVisitor):
-        def visit_Return(self, node):
-            # Direct string return
-            if isinstance(node.value, ast.Constant) and isinstance(
-                node.value.value, str
-            ):
-                return_values.add(node.value.value)
-            # Dictionary-based return, like return paths[result]
-            elif isinstance(node.value, ast.Subscript):
-                # Check if we're subscripting a known dictionary variable
-                if isinstance(node.value.value, ast.Name):
-                    var_name = node.value.value.id
-                    if var_name in dict_definitions:
-                        # Add all possible dictionary values
-                        for v in dict_definitions[var_name]:
-                            return_values.add(v)
-            self.generic_visit(node)
-
-    # First pass: identify dictionary assignments
-    DictionaryAssignmentVisitor().visit(code_ast)
-    # Second pass: identify returns
-    ReturnVisitor().visit(code_ast)
-
-    return list(return_values) if return_values else None
-
-
-def is_ancestor(node: str, ancestor_candidate: str, ancestors: Dict[str, Set[str]]) -> bool:
-    """Check if one node is an ancestor of another in the flow graph.
-    
-    Args:
-        node: Target node to check ancestors for
-        ancestor_candidate: Node to check if it's an ancestor
-        ancestors: Dictionary mapping nodes to their ancestor sets
-        
-    Returns:
-        bool: True if ancestor_candidate is an ancestor of node
-        
-    Raises:
-        TypeError: If any argument has an invalid type
-    """
-    if not isinstance(node, str):
-        raise TypeError("Argument 'node' must be a string")
-    if not isinstance(ancestor_candidate, str):
-        raise TypeError("Argument 'ancestor_candidate' must be a string")
-    if not isinstance(ancestors, dict):
-        raise TypeError("Argument 'ancestors' must be a dictionary")
-    
-    return ancestor_candidate in ancestors.get(node, set())

src/crewai/flow/flow.py

@@ -17,42 +17,59 @@ from typing import (
 from blinker import Signal
 from pydantic import BaseModel, ValidationError
 
-from crewai.flow.core_flow_utils import get_possible_return_constants
 from crewai.flow.flow_events import (
     FlowFinishedEvent,
     FlowStartedEvent,
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
+from crewai.flow.flow_visualizer import plot_flow
+from crewai.flow.utils import get_possible_return_constants
 from crewai.telemetry import Telemetry
 
 T = TypeVar("T", bound=Union[BaseModel, Dict[str, Any]])
 
 
 def start(condition: Optional[Union[str, dict, Callable]] = None) -> Callable:
-    """Marks a method as a flow starting point, optionally triggered by other methods.
-    
-    Args:
-        condition: The condition that triggers this method. Can be:
-            - str: Name of the triggering method
-            - dict: Dictionary with 'type' and 'methods' keys for complex conditions
-            - Callable: A function reference
-            - None: No trigger condition (default)
-    
-    Returns:
-        Callable: The decorated function that will serve as a flow starting point.
-        
-    Raises:
-        ValueError: If the condition format is invalid.
-        
-    Example:
-        >>> @start()  # No condition
-        >>> def begin_flow():
-        >>>     pass
-        >>>
-        >>> @start("method_name")  # Triggered by specific method
-        >>> def conditional_start():
-        >>>     pass
+    """
+    Marks a method as a flow's starting point.
+
+    This decorator designates a method as an entry point for the flow execution.
+    It can optionally specify conditions that trigger the start based on other
+    method executions.
+
+    Parameters
+    ----------
+    condition : Optional[Union[str, dict, Callable]], optional
+        Defines when the start method should execute. Can be:
+        - str: Name of a method that triggers this start
+        - dict: Contains "type" ("AND"/"OR") and "methods" (list of triggers)
+        - Callable: A method reference that triggers this start
+        Default is None, meaning unconditional start.
+
+    Returns
+    -------
+    Callable
+        A decorator function that marks the method as a flow start point.
+
+    Raises
+    ------
+    ValueError
+        If the condition format is invalid.
+
+    Examples
+    --------
+    >>> @start()  # Unconditional start
+    >>> def begin_flow(self):
+    ...     pass
+
+    >>> @start("method_name")  # Start after specific method
+    >>> def conditional_start(self):
+    ...     pass
+
+    >>> @start(and_("method1", "method2"))  # Start after multiple methods
+    >>> def complex_start(self):
+    ...     pass
     """
     def decorator(func):
         func.__is_start_method__ = True
@@ -78,30 +95,41 @@ def start(condition: Optional[Union[str, dict, Callable]] = None) -> Callable:
 
     return decorator
 
-
 def listen(condition: Union[str, dict, Callable]) -> Callable:
-    """Marks a method to execute when specified conditions/methods complete.
-    
-    Args:
-        condition: The condition that triggers this method. Can be:
-            - str: Name of the triggering method
-            - dict: Dictionary with 'type' and 'methods' keys for complex conditions
-            - Callable: A function reference
-    
-    Returns:
-        Callable: The decorated function that will execute when conditions are met.
-        
-    Raises:
-        ValueError: If the condition format is invalid.
-        
-    Example:
-        >>> @listen("start_method")  # Listen to single method
-        >>> def on_start():
-        >>>     pass
-        >>>
-        >>> @listen(and_("method1", "method2"))  # Listen with AND condition
-        >>> def on_both_complete():
-        >>>     pass
+    """
+    Creates a listener that executes when specified conditions are met.
+
+    This decorator sets up a method to execute in response to other method
+    executions in the flow. It supports both simple and complex triggering
+    conditions.
+
+    Parameters
+    ----------
+    condition : Union[str, dict, Callable]
+        Specifies when the listener should execute. Can be:
+        - str: Name of a method that triggers this listener
+        - dict: Contains "type" ("AND"/"OR") and "methods" (list of triggers)
+        - Callable: A method reference that triggers this listener
+
+    Returns
+    -------
+    Callable
+        A decorator function that sets up the method as a listener.
+
+    Raises
+    ------
+    ValueError
+        If the condition format is invalid.
+
+    Examples
+    --------
+    >>> @listen("process_data")  # Listen to single method
+    >>> def handle_processed_data(self):
+    ...     pass
+
+    >>> @listen(or_("success", "failure"))  # Listen to multiple methods
+    >>> def handle_completion(self):
+    ...     pass
     """
     def decorator(func):
         if isinstance(condition, str):
@@ -127,29 +155,45 @@ def listen(condition: Union[str, dict, Callable]) -> Callable:
 
 
 def router(condition: Union[str, dict, Callable]) -> Callable:
-    """Marks a method as a router to direct flow based on its return value.
-    
-    A router method can return different string values that trigger different
-    subsequent methods, allowing for dynamic flow control.
-    
-    Args:
-        condition: The condition that triggers this router. Can be:
-            - str: Name of the triggering method
-            - dict: Dictionary with 'type' and 'methods' keys for complex conditions
-            - Callable: A function reference
-    
-    Returns:
-        Callable: The decorated function that will serve as a router.
-        
-    Raises:
-        ValueError: If the condition format is invalid.
-        
-    Example:
-        >>> @router("process_data")
-        >>> def route_result(result):
-        >>>     if result.success:
-        >>>         return "handle_success"
-        >>>     return "handle_error"
+    """
+    Creates a routing method that directs flow execution based on conditions.
+
+    This decorator marks a method as a router, which can dynamically determine
+    the next steps in the flow based on its return value. Routers are triggered
+    by specified conditions and can return constants that determine which path
+    the flow should take.
+
+    Parameters
+    ----------
+    condition : Union[str, dict, Callable]
+        Specifies when the router should execute. Can be:
+        - str: Name of a method that triggers this router
+        - dict: Contains "type" ("AND"/"OR") and "methods" (list of triggers)
+        - Callable: A method reference that triggers this router
+
+    Returns
+    -------
+    Callable
+        A decorator function that sets up the method as a router.
+
+    Raises
+    ------
+    ValueError
+        If the condition format is invalid.
+
+    Examples
+    --------
+    >>> @router("check_status")
+    >>> def route_based_on_status(self):
+    ...     if self.state.status == "success":
+    ...         return SUCCESS
+    ...     return FAILURE
+
+    >>> @router(and_("validate", "process"))
+    >>> def complex_routing(self):
+    ...     if all([self.state.valid, self.state.processed]):
+    ...         return CONTINUE
+    ...     return STOP
     """
     def decorator(func):
         func.__is_router__ = True
@@ -174,27 +218,38 @@ def router(condition: Union[str, dict, Callable]) -> Callable:
 
     return decorator
 
-
 def or_(*conditions: Union[str, dict, Callable]) -> dict:
-    """Combines multiple conditions with OR logic for flow control.
-    
-    Args:
-        *conditions: Variable number of conditions. Each can be:
-            - str: Name of a method
-            - dict: Dictionary with 'type' and 'methods' keys
-            - Callable: A function reference
-    
-    Returns:
-        dict: A dictionary with 'type': 'OR' and 'methods' list.
-        
-    Raises:
-        ValueError: If any condition is invalid.
-        
-    Example:
-        >>> @listen(or_("method1", "method2"))
-        >>> def on_either():
-        >>>     # Executes when either method1 OR method2 completes
-        >>>     pass
+    """
+    Combines multiple conditions with OR logic for flow control.
+
+    Creates a condition that is satisfied when any of the specified conditions
+    are met. This is used with @start, @listen, or @router decorators to create
+    complex triggering conditions.
+
+    Parameters
+    ----------
+    *conditions : Union[str, dict, Callable]
+        Variable number of conditions that can be:
+        - str: Method names
+        - dict: Existing condition dictionaries
+        - Callable: Method references
+
+    Returns
+    -------
+    dict
+        A condition dictionary with format:
+        {"type": "OR", "methods": list_of_method_names}
+
+    Raises
+    ------
+    ValueError
+        If any condition is invalid.
+
+    Examples
+    --------
+    >>> @listen(or_("success", "timeout"))
+    >>> def handle_completion(self):
+    ...     pass
     """
     methods = []
     for condition in conditions:
@@ -210,25 +265,37 @@ def or_(*conditions: Union[str, dict, Callable]) -> dict:
 
 
 def and_(*conditions: Union[str, dict, Callable]) -> dict:
-    """Combines multiple conditions with AND logic for flow control.
-    
-    Args: 
-        *conditions: Variable number of conditions. Each can be:
-            - str: Name of a method
-            - dict: Dictionary with 'type' and 'methods' keys
-            - Callable: A function reference
-    
-    Returns:
-        dict: A dictionary with 'type': 'AND' and 'methods' list.
-        
-    Raises:
-        ValueError: If any condition is invalid.
-        
-    Example:
-        >>> @listen(and_("method1", "method2"))
-        >>> def on_both():
-        >>>     # Executes when BOTH method1 AND method2 complete
-        >>>     pass
+    """
+    Combines multiple conditions with AND logic for flow control.
+
+    Creates a condition that is satisfied only when all specified conditions
+    are met. This is used with @start, @listen, or @router decorators to create
+    complex triggering conditions.
+
+    Parameters
+    ----------
+    *conditions : Union[str, dict, Callable]
+        Variable number of conditions that can be:
+        - str: Method names
+        - dict: Existing condition dictionaries
+        - Callable: Method references
+
+    Returns
+    -------
+    dict
+        A condition dictionary with format:
+        {"type": "AND", "methods": list_of_method_names}
+
+    Raises
+    ------
+    ValueError
+        If any condition is invalid.
+
+    Examples
+    --------
+    >>> @listen(and_("validated", "processed"))
+    >>> def handle_complete_data(self):
+    ...     pass
     """
     methods = []
     for condition in conditions:
@@ -288,22 +355,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
     event_emitter = Signal("event_emitter")
 
     def __class_getitem__(cls: Type["Flow"], item: Type[T]) -> Type["Flow"]:
-        """Create a generic version of Flow with specified state type.
-        
-        Args:
-            cls: The Flow class
-            item: The type parameter for the flow's state
-            
-        Returns:
-            Type["Flow"]: A new Flow class with the specified state type
-            
-        Example:
-            >>> class MyState(BaseModel):
-            >>>     value: int
-            >>> 
-            >>> class MyFlow(Flow[MyState]):
-            >>>     pass
-        """
         class _FlowGeneric(cls):  # type: ignore
             _initial_state_T = item  # type: ignore
 
@@ -311,23 +362,11 @@ class Flow(Generic[T], metaclass=FlowMeta):
         return _FlowGeneric
 
     def __init__(self) -> None:
-        """Initialize a new Flow instance.
-        
-        Sets up internal state tracking, method registration, and telemetry.
-        The flow's methods are automatically discovered and registered during initialization.
-        
-        Attributes initialized:
-            _methods: Dictionary mapping method names to their callable objects
-            _state: The flow's state object of type T
-            _method_execution_counts: Tracks how many times each method has executed
-            _pending_and_listeners: Tracks methods waiting for AND conditions
-            _method_outputs: List of all outputs from executed methods
-        """
         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] = []
+        self._method_outputs: List[Any] = []  # List to store all method outputs
 
         self._telemetry.flow_creation_span(self.__class__.__name__)
 
@@ -338,20 +377,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 self._methods[method_name] = getattr(self, method_name)
 
     def _create_initial_state(self) -> T:
-        """Create the initial state for the flow.
-        
-        The state is created based on the following priority:
-        1. If initial_state is None and _initial_state_T exists (generic type), use that
-        2. If initial_state is None, return empty dict
-        3. If initial_state is a type, instantiate it
-        4. Otherwise, use initial_state as-is
-        
-        Returns:
-            T: The initial state object of type T
-            
-        Note:
-            The type T can be either a Pydantic BaseModel or a dictionary.
-        """
         if self.initial_state is None and hasattr(self, "_initial_state_T"):
             return self._initial_state_T()  # type: ignore
         if self.initial_state is None:
@@ -363,21 +388,11 @@ class Flow(Generic[T], metaclass=FlowMeta):
 
     @property
     def state(self) -> T:
-        """Get the current state of the flow.
-        
-        Returns:
-            T: The current state object, either a Pydantic model or dictionary
-        """
         return self._state
 
     @property
     def method_outputs(self) -> List[Any]:
-        """Get the list of all outputs from executed methods.
-        
-        Returns:
-            List[Any]: A list containing the output values from all executed flow methods,
-                      in order of execution.
-        """
+        """Returns the list of all outputs from executed methods."""
         return self._method_outputs
 
     def _initialize_state(self, inputs: Dict[str, Any]) -> None:
@@ -447,6 +462,23 @@ class Flow(Generic[T], metaclass=FlowMeta):
         return final_output
 
     async def _execute_start_method(self, start_method_name: str) -> None:
+        """
+        Executes a flow's start method and its triggered listeners.
+
+        This internal method handles the execution of methods marked with @start
+        decorator and manages the subsequent chain of listener executions.
+
+        Parameters
+        ----------
+        start_method_name : str
+            The name of the start method to execute.
+
+        Notes
+        -----
+        - Executes the start method and captures its result
+        - Triggers execution of any listeners waiting on this start method
+        - Part of the flow's initialization sequence
+        """
         result = await self._execute_method(
             start_method_name, self._methods[start_method_name]
         )
@@ -467,22 +499,27 @@ class Flow(Generic[T], metaclass=FlowMeta):
         return result
 
     async def _execute_listeners(self, trigger_method: str, result: Any) -> None:
-        """Execute all listener methods triggered by a completed method.
-        
-        This method handles both router and non-router listeners in a specific order:
-        1. First executes all triggered router methods sequentially until no more routers
-           are triggered
-        2. Then executes all regular listeners in parallel
-        
-        Args:
-            trigger_method: The name of the method that completed execution
-            result: The result value from the triggering method
-            
-        Note:
-            Router methods are executed sequentially to ensure proper flow control,
-            while regular listeners are executed concurrently for better performance.
-            This provides fine-grained control over the execution flow while
-            maintaining efficiency.
+        """
+        Executes all listeners and routers triggered by a method completion.
+
+        This internal method manages the execution flow by:
+        1. First executing all triggered routers sequentially
+        2. Then executing all triggered listeners in parallel
+
+        Parameters
+        ----------
+        trigger_method : str
+            The name of the method that triggered these listeners.
+        result : Any
+            The result from the triggering method, passed to listeners
+            that accept parameters.
+
+        Notes
+        -----
+        - Routers are executed sequentially to maintain flow control
+        - Each router's result becomes the new trigger_method
+        - Normal listeners are executed in parallel for efficiency
+        - Listeners can receive the trigger method's result as a parameter
         """
         # First, handle routers repeatedly until no router triggers anymore
         while True:
@@ -513,26 +550,32 @@ class Flow(Generic[T], metaclass=FlowMeta):
     def _find_triggered_methods(
         self, trigger_method: str, router_only: bool
     ) -> List[str]:
-        """Find all methods that should be triggered based on completed method and type.
-        
-        Provides precise control over method triggering by handling both OR and AND
-        conditions separately for router and non-router methods.
-        
-        Args:
-            trigger_method: The name of the method that completed execution
-            router_only: If True, only find router methods; if False, only regular
-                        listeners
-            
-        Returns:
-            List[str]: Names of methods that should be executed next
-            
-        Note:
-            This method implements sophisticated flow control by: 
-            1. Filtering methods based on their router/non-router status
-            2. Handling OR conditions for immediate triggering
-            3. Managing AND conditions with state tracking for complex dependencies
-            
-            This ensures predictable and consistent execution order in complex flows.
+        """
+        Finds all methods that should be triggered based on conditions.
+
+        This internal method evaluates both OR and AND conditions to determine
+        which methods should be executed next in the flow.
+
+        Parameters
+        ----------
+        trigger_method : str
+            The name of the method that just completed execution.
+        router_only : bool
+            If True, only consider router methods.
+            If False, only consider non-router methods.
+
+        Returns
+        -------
+        List[str]
+            Names of methods that should be triggered.
+
+        Notes
+        -----
+        - Handles both OR and AND conditions:
+          * OR: Triggers if any condition is met
+          * AND: Triggers only when all conditions are met
+        - Maintains state for AND conditions using _pending_and_listeners
+        - Separates router and normal listener evaluation
         """
         triggered = []
         for listener_name, (condition_type, methods) in self._listeners.items():
@@ -562,26 +605,32 @@ class Flow(Generic[T], metaclass=FlowMeta):
         return triggered
 
     async def _execute_single_listener(self, listener_name: str, result: Any) -> None:
-        """Execute a single listener method with precise parameter handling and error tracking.
-        
-        Provides fine-grained control over method execution through:
-        1. Automatic parameter inspection to determine if the method accepts results
-        2. Event emission for execution tracking
-        3. Comprehensive error handling
-        4. Recursive listener execution
-        
-        Args:
-            listener_name: The name of the listener method to execute
-            result: The result from the triggering method, passed to the listener
-                   if its signature accepts parameters
-                   
-        Note:
-            This method ensures precise execution control by:
-            - Inspecting method signatures to handle parameters correctly
-            - Emitting events for execution tracking
-            - Providing comprehensive error handling
-            - Supporting both parameterized and parameter-less methods
-            - Maintaining execution chain through recursive listener calls
+        """
+        Executes a single listener method with proper event handling.
+
+        This internal method manages the execution of an individual listener,
+        including parameter inspection, event emission, and error handling.
+
+        Parameters
+        ----------
+        listener_name : str
+            The name of the listener method to execute.
+        result : Any
+            The result from the triggering method, which may be passed
+            to the listener if it accepts parameters.
+
+        Notes
+        -----
+        - Inspects method signature to determine if it accepts the trigger result
+        - Emits events for method execution start and finish
+        - Handles errors gracefully with detailed logging
+        - Recursively triggers listeners of this listener
+        - Supports both parameterized and parameter-less listeners
+
+        Error Handling
+        -------------
+        Catches and logs any exceptions during execution, preventing
+        individual listener failures from breaking the entire flow.
         """
         try:
             method = self._methods[listener_name]
@@ -626,32 +675,8 @@ class Flow(Generic[T], metaclass=FlowMeta):
 
             traceback.print_exc()
 
-    def plot(self, *args, **kwargs):
-        """Generate an interactive visualization of the flow's execution graph.
-        
-        Creates a detailed HTML visualization showing the relationships between
-        methods, including start points, listeners, routers, and their
-        connections. Includes telemetry tracking for flow analysis.
-        
-        Args:
-            *args: Variable length argument list passed to plot_flow
-            **kwargs: Arbitrary keyword arguments passed to plot_flow
-                     
-        Note:
-            The visualization provides:
-            - Clear representation of method relationships
-            - Visual distinction between different method types
-            - Interactive exploration capabilities
-            - Execution path tracing
-            - Telemetry tracking for flow analysis
-            
-        Example:
-            >>> flow = MyFlow()
-            >>> flow.plot("my_workflow")  # Creates my_workflow.html
-        """
-        from crewai.flow.flow_visualizer import plot_flow
-        
+    def plot(self, filename: str = "crewai_flow") -> None:
         self._telemetry.flow_plotting_span(
             self.__class__.__name__, list(self._methods.keys())
         )
-        return plot_flow(self, *args, **kwargs)
+        plot_flow(self, filename)

src/crewai/flow/flow_visual_utils.py

@@ -1,240 +0,0 @@
-"""Utility functions for Flow visualization.
-
-This module contains utility functions specifically designed for visualizing
-Flow graphs and calculating layout information. These utilities are separated
-from general-purpose utilities to maintain a clean dependency structure.
-"""
-
-from typing import Any, Dict, List, Set, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from crewai.flow.flow import Flow
-
-
-def calculate_node_levels(flow: Flow[Any]) -> Dict[str, int]:
-    """Calculate the hierarchical level of each node in the flow graph.
-    
-    Uses breadth-first traversal to assign levels to nodes, starting with
-    start methods at level 0. Handles both OR and AND conditions for listeners,
-    and considers router paths when calculating levels.
-    
-    Args:
-        flow: Flow instance containing methods, listeners, and router configurations
-        
-    Returns:
-        dict[str, int]: Dictionary mapping method names to their hierarchical levels,
-            where level 0 contains start methods and each subsequent level contains
-            methods triggered by the previous level
-            
-    Example:
-        >>> flow = Flow()
-        >>> @flow.start
-        ... def start(): pass
-        >>> @flow.on("start")
-        ... def second(): pass
-        >>> calculate_node_levels(flow)
-        {'start': 0, 'second': 1}
-    """
-    levels: Dict[str, int] = {}
-    queue: List[str] = []
-    visited: Set[str] = set()
-    pending_and_listeners: Dict[str, Set[str]] = {}
-
-    # Make all start methods at level 0
-    for method_name, method in flow._methods.items():
-        if hasattr(method, "__is_start_method__"):
-            levels[method_name] = 0
-            queue.append(method_name)
-
-    # Breadth-first traversal to assign levels
-    while queue:
-        current = queue.pop(0)
-        current_level = levels[current]
-        visited.add(current)
-
-        for listener_name, (condition_type, trigger_methods) in flow._listeners.items():
-            if condition_type == "OR":
-                if current in trigger_methods:
-                    if (
-                        listener_name not in levels
-                        or levels[listener_name] > current_level + 1
-                    ):
-                        levels[listener_name] = current_level + 1
-                        if listener_name not in visited:
-                            queue.append(listener_name)
-            elif condition_type == "AND":
-                if listener_name not in pending_and_listeners:
-                    pending_and_listeners[listener_name] = set()
-                if current in trigger_methods:
-                    pending_and_listeners[listener_name].add(current)
-                if set(trigger_methods) == pending_and_listeners[listener_name]:
-                    if (
-                        listener_name not in levels
-                        or levels[listener_name] > current_level + 1
-                    ):
-                        levels[listener_name] = current_level + 1
-                        if listener_name not in visited:
-                            queue.append(listener_name)
-
-        # Handle router connections
-        if current in flow._routers:
-            router_method_name = current
-            paths = flow._router_paths.get(router_method_name, [])
-            for path in paths:
-                for listener_name, (
-                    condition_type,
-                    trigger_methods,
-                ) in flow._listeners.items():
-                    if path in trigger_methods:
-                        if (
-                            listener_name not in levels
-                            or levels[listener_name] > current_level + 1
-                        ):
-                            levels[listener_name] = current_level + 1
-                            if listener_name not in visited:
-                                queue.append(listener_name)
-
-    return levels
-
-
-def count_outgoing_edges(flow: Flow[Any]) -> Dict[str, int]:
-    """Count the number of outgoing edges for each node in the flow graph.
-    
-    An outgoing edge represents a connection from a method to a listener
-    that it triggers. This is useful for visualization and analysis of
-    flow structure.
-    
-    Args:
-        flow: Flow instance containing methods and their connections
-        
-    Returns:
-        dict[str, int]: Dictionary mapping method names to their number
-            of outgoing connections
-    """
-    counts: Dict[str, int] = {}
-    for method_name in flow._methods:
-        counts[method_name] = 0
-    for method_name in flow._listeners:
-        _, trigger_methods = flow._listeners[method_name]
-        for trigger in trigger_methods:
-            if trigger in flow._methods:
-                counts[trigger] += 1
-    return counts
-
-
-def build_ancestor_dict(flow: Flow[Any]) -> Dict[str, Set[str]]:
-    """Build a dictionary mapping each node to its set of ancestor nodes.
-    
-    Uses depth-first search to identify all ancestors (direct and indirect
-    trigger methods) for each node in the flow graph. Handles both regular
-    listeners and router paths.
-    
-    Args:
-        flow: Flow instance containing methods and their relationships
-        
-    Returns:
-        dict[str, set[str]]: Dictionary mapping each method name to a set
-            of its ancestor method names
-    """
-    ancestors: Dict[str, Set[str]] = {node: set() for node in flow._methods}
-    visited: Set[str] = set()
-    for node in flow._methods:
-        if node not in visited:
-            dfs_ancestors(node, ancestors, visited, flow)
-    return ancestors
-
-
-
-
-def dfs_ancestors(node: str, ancestors: Dict[str, Set[str]], 
-                visited: Set[str], flow: Flow[Any]) -> None:
-    """Perform depth-first search to populate the ancestors dictionary.
-    
-    Helper function for build_ancestor_dict that recursively traverses
-    the flow graph to identify ancestors of each node.
-    
-    Args:
-        node: Current node being processed
-        ancestors: Dictionary mapping nodes to their ancestor sets
-        visited: Set of already visited nodes
-        flow: Flow instance containing the graph structure
-    """
-    if node in visited:
-        return
-    visited.add(node)
-
-    # Handle regular listeners
-    for listener_name, (_, trigger_methods) in flow._listeners.items():
-        if node in trigger_methods:
-            ancestors[listener_name].add(node)
-            ancestors[listener_name].update(ancestors[node])
-            dfs_ancestors(listener_name, ancestors, visited, flow)
-
-    # Handle router methods separately
-    if node in flow._routers:
-        router_method_name = node
-        paths = flow._router_paths.get(router_method_name, [])
-        for path in paths:
-            for listener_name, (_, trigger_methods) in flow._listeners.items():
-                if path in trigger_methods:
-                    # Only propagate the ancestors of the router method, not the router method itself
-                    ancestors[listener_name].update(ancestors[node])
-                    dfs_ancestors(listener_name, ancestors, visited, flow)
-
-
-def build_parent_children_dict(flow: Flow[Any]) -> Dict[str, List[str]]:
-    """Build a dictionary mapping each node to its list of child nodes.
-    
-    Maps both regular trigger methods to their listeners and router
-    methods to their path listeners. Useful for visualization and
-    traversal of the flow graph structure.
-    
-    Args:
-        flow: Flow instance containing methods and their relationships
-        
-    Returns:
-        dict[str, list[str]]: Dictionary mapping each method name to a
-            sorted list of its child method names
-    """
-    parent_children: Dict[str, List[str]] = {}
-
-    # Map listeners to their trigger methods
-    for listener_name, (_, trigger_methods) in flow._listeners.items():
-        for trigger in trigger_methods:
-            if trigger not in parent_children:
-                parent_children[trigger] = []
-            if listener_name not in parent_children[trigger]:
-                parent_children[trigger].append(listener_name)
-
-    # Map router methods to their paths and to listeners
-    for router_method_name, paths in flow._router_paths.items():
-        for path in paths:
-            # Map router method to listeners of each path
-            for listener_name, (_, trigger_methods) in flow._listeners.items():
-                if path in trigger_methods:
-                    if router_method_name not in parent_children:
-                        parent_children[router_method_name] = []
-                    if listener_name not in parent_children[router_method_name]:
-                        parent_children[router_method_name].append(listener_name)
-
-    return parent_children
-
-
-def get_child_index(parent: str, child: str, 
-                 parent_children: Dict[str, List[str]]) -> int:
-    """Get the index of a child node in its parent's sorted children list.
-    
-    Args:
-        parent: Parent node name
-        child: Child node name to find index for
-        parent_children: Dictionary mapping parents to their children lists
-        
-    Returns:
-        int: Zero-based index of the child in parent's sorted children list
-        
-    Raises:
-        ValueError: If child is not found in parent's children list
-    """
-    children = parent_children.get(parent, [])
-    children.sort()
-    return children.index(child)

src/crewai/flow/flow_visualizer.py

@@ -6,10 +6,10 @@ from pathlib import Path
 from pyvis.network import Network
 
 from crewai.flow.config import COLORS, NODE_STYLES
-from crewai.flow.flow_visual_utils import calculate_node_levels
 from crewai.flow.html_template_handler import HTMLTemplateHandler
 from crewai.flow.legend_generator import generate_legend_items_html, get_legend_items
-from crewai.flow.path_utils import safe_path_join, validate_file_path
+from crewai.flow.path_utils import safe_path_join, validate_path_exists
+from crewai.flow.utils import calculate_node_levels
 from crewai.flow.visualization_utils import (
     add_edges,
     add_nodes_to_network,
@@ -21,102 +21,211 @@ class FlowPlot:
     """Handles the creation and rendering of flow visualization diagrams."""
 
     def __init__(self, flow):
-        """Initialize flow plot with flow instance and styling configuration.
-        
-        Args:
-            flow: A Flow instance with required attributes for visualization
-            
-        Raises:
-            ValueError: If flow object is invalid or missing required attributes
+        """
+        Initialize FlowPlot with a flow object.
+
+        Parameters
+        ----------
+        flow : Flow
+            A Flow instance to visualize.
+
+        Raises
+        ------
+        ValueError
+            If flow object is invalid or missing required attributes.
         """
         if not hasattr(flow, '_methods'):
-            raise ValueError("Invalid flow object: Missing '_methods' attribute")
-        if not hasattr(flow, '_start_methods'):
-            raise ValueError("Invalid flow object: Missing '_start_methods' attribute")
+            raise ValueError("Invalid flow object: missing '_methods' attribute")
         if not hasattr(flow, '_listeners'):
-            raise ValueError("Invalid flow object: Missing '_listeners' attribute")
+            raise ValueError("Invalid flow object: missing '_listeners' attribute")
+        if not hasattr(flow, '_start_methods'):
+            raise ValueError("Invalid flow object: missing '_start_methods' attribute")
             
         self.flow = flow
         self.colors = COLORS
         self.node_styles = NODE_STYLES
 
     def plot(self, filename):
-        """Generate and save interactive flow visualization to HTML file."""
-        net = Network(
-            directed=True,
-            height="750px",
-            width="100%",
-            bgcolor=self.colors["bg"],
-            layout=None,
-        )
-
-        # Set options to disable physics
-        net.set_options(
-            """
-            var options = {
-                "nodes": {
-                    "font": {
-                        "multi": "html"
-                    }
-                },
-                "physics": {
-                    "enabled": false
-                }
-            }
         """
-        )
+        Generate and save an HTML visualization of the flow.
 
-        node_levels = calculate_node_levels(self.flow)
-        node_positions = compute_positions(self.flow, node_levels)
-        add_nodes_to_network(net, self.flow, node_positions, self.node_styles)
-        add_edges(net, self.flow, node_positions, self.colors)
+        Parameters
+        ----------
+        filename : str
+            Name of the output file (without extension).
 
-        network_html = net.generate_html()
-        final_html_content = self._generate_final_html(network_html)
-
-        try:
-            # Ensure the output path is safe
-            output_dir = os.getcwd()
-            output_path = safe_path_join(output_dir, f"{filename}.html")
+        Raises
+        ------
+        ValueError
+            If filename is invalid or network generation fails.
+        IOError
+            If file operations fail or visualization cannot be generated.
+        RuntimeError
+            If network visualization generation fails.
+        """
+        if not filename or not isinstance(filename, str):
+            raise ValueError("Filename must be a non-empty string")
             
-            with open(output_path, "w", encoding="utf-8") as f:
-                f.write(final_html_content)
-            print(f"Plot saved as {output_path}")
-        except (IOError, ValueError) as e:
-            raise IOError(f"Failed to save flow visualization: {str(e)}")
+        try:
+            # Initialize network
+            net = Network(
+                directed=True,
+                height="750px",
+                width="100%",
+                bgcolor=self.colors["bg"],
+                layout=None,
+            )
 
-        self._cleanup_pyvis_lib()
+            # Set options to disable physics
+            net.set_options(
+                """
+                var options = {
+                    "nodes": {
+                        "font": {
+                            "multi": "html"
+                        }
+                    },
+                    "physics": {
+                        "enabled": false
+                    }
+                }
+            """
+            )
+
+            # Calculate levels for nodes
+            try:
+                node_levels = calculate_node_levels(self.flow)
+            except Exception as e:
+                raise ValueError(f"Failed to calculate node levels: {str(e)}")
+
+            # Compute positions
+            try:
+                node_positions = compute_positions(self.flow, node_levels)
+            except Exception as e:
+                raise ValueError(f"Failed to compute node positions: {str(e)}")
+
+            # Add nodes to the network
+            try:
+                add_nodes_to_network(
+                    net,
+                    flow=self.flow,
+                    pos=node_positions,
+                    node_styles=self.node_styles
+                )
+            except Exception as e:
+                raise RuntimeError(f"Failed to add nodes to network: {str(e)}")
+
+            # Add edges to the network
+            try:
+                add_edges(net, self.flow, node_positions, self.colors)
+            except Exception as e:
+                raise RuntimeError(f"Failed to add edges to network: {str(e)}")
+
+            # Generate HTML
+            try:
+                network_html = net.generate_html()
+                final_html_content = self._generate_final_html(network_html)
+            except Exception as e:
+                raise RuntimeError(f"Failed to generate network visualization: {str(e)}")
+
+            # Save the final HTML content to the file
+            try:
+                with open(f"{filename}.html", "w", encoding="utf-8") as f:
+                    f.write(final_html_content)
+                print(f"Plot saved as {filename}.html")
+            except IOError as e:
+                raise IOError(f"Failed to save flow visualization to {filename}.html: {str(e)}")
+
+        except (ValueError, RuntimeError, IOError) as e:
+            raise e
+        except Exception as e:
+            raise RuntimeError(f"Unexpected error during flow visualization: {str(e)}")
+        finally:
+            self._cleanup_pyvis_lib()
 
     def _generate_final_html(self, network_html):
-        """Generate final HTML content with network visualization and legend."""
-        current_dir = os.path.dirname(__file__)
-        template_path = os.path.join(
-            current_dir, "assets", "crewai_flow_visual_template.html"
-        )
-        logo_path = os.path.join(current_dir, "assets", "crewai_logo.svg")
+        """
+        Generate the final HTML content with network visualization and legend.
 
-        html_handler = HTMLTemplateHandler(template_path, logo_path)
-        network_body = html_handler.extract_body_content(network_html)
+        Parameters
+        ----------
+        network_html : str
+            HTML content generated by pyvis Network.
 
-        legend_items = get_legend_items(self.colors)
-        legend_items_html = generate_legend_items_html(legend_items)
-        final_html_content = html_handler.generate_final_html(
-            network_body, legend_items_html
-        )
-        return final_html_content
+        Returns
+        -------
+        str
+            Complete HTML content with styling and legend.
+
+        Raises
+        ------
+        IOError
+            If template or logo files cannot be accessed.
+        ValueError
+            If network_html is invalid.
+        """
+        if not network_html:
+            raise ValueError("Invalid network HTML content")
+
+        try:
+            # Extract just the body content from the generated HTML
+            current_dir = os.path.dirname(__file__)
+            template_path = safe_path_join("assets", "crewai_flow_visual_template.html", root=current_dir)
+            logo_path = safe_path_join("assets", "crewai_logo.svg", root=current_dir)
+
+            if not os.path.exists(template_path):
+                raise IOError(f"Template file not found: {template_path}")
+            if not os.path.exists(logo_path):
+                raise IOError(f"Logo file not found: {logo_path}")
+
+            html_handler = HTMLTemplateHandler(template_path, logo_path)
+            network_body = html_handler.extract_body_content(network_html)
+
+            # Generate the legend items HTML
+            legend_items = get_legend_items(self.colors)
+            legend_items_html = generate_legend_items_html(legend_items)
+            final_html_content = html_handler.generate_final_html(
+                network_body, legend_items_html
+            )
+            return final_html_content
+        except Exception as e:
+            raise IOError(f"Failed to generate visualization HTML: {str(e)}")
 
     def _cleanup_pyvis_lib(self):
-        """Clean up temporary files generated by pyvis library."""
-        lib_folder = os.path.join(os.getcwd(), "lib")
+        """
+        Clean up the generated lib folder from pyvis.
+
+        This method safely removes the temporary lib directory created by pyvis
+        during network visualization generation.
+        """
         try:
+            lib_folder = safe_path_join("lib", root=os.getcwd())
             if os.path.exists(lib_folder) and os.path.isdir(lib_folder):
                 import shutil
                 shutil.rmtree(lib_folder)
+        except ValueError as e:
+            print(f"Error validating lib folder path: {e}")
         except Exception as e:
-            print(f"Error cleaning up {lib_folder}: {e}")
+            print(f"Error cleaning up lib folder: {e}")
 
 
 def plot_flow(flow, filename="flow_plot"):
-    """Create and save a visualization of the given flow."""
+    """
+    Convenience function to create and save a flow visualization.
+
+    Parameters
+    ----------
+    flow : Flow
+        Flow instance to visualize.
+    filename : str, optional
+        Output filename without extension, by default "flow_plot".
+
+    Raises
+    ------
+    ValueError
+        If flow object or filename is invalid.
+    IOError
+        If file operations fail.
+    """
     visualizer = FlowPlot(flow)
     visualizer.plot(filename)

src/crewai/flow/html_template_handler.py

@@ -1,107 +1,55 @@
 import base64
-import os
 import re
 from pathlib import Path
 
-from crewai.flow.path_utils import safe_path_join, validate_file_path
+from crewai.flow.path_utils import safe_path_join, validate_path_exists
 
 
 class HTMLTemplateHandler:
     """Handles HTML template processing and generation for flow visualization diagrams."""
 
     def __init__(self, template_path, logo_path):
-        """Initialize template handler with template and logo file paths.
-        
-        Args:
-            template_path: Path to the HTML template file
-            logo_path: Path to the logo SVG file
-            
-        Raises:
-            ValueError: If template_path or logo_path is invalid or files don't exist
+        """
+        Initialize HTMLTemplateHandler with validated template and logo paths.
+
+        Parameters
+        ----------
+        template_path : str
+            Path to the HTML template file.
+        logo_path : str
+            Path to the logo image file.
+
+        Raises
+        ------
+        ValueError
+            If template or logo paths are invalid or files don't exist.
         """
         try:
-            self.template_path = validate_file_path(template_path)
-            self.logo_path = validate_file_path(logo_path)
-        except (ValueError, TypeError) as e:
-            raise ValueError(f"Invalid file path: {str(e)}")
+            self.template_path = validate_path_exists(template_path, "file")
+            self.logo_path = validate_path_exists(logo_path, "file")
+        except ValueError as e:
+            raise ValueError(f"Invalid template or logo path: {e}")
 
     def read_template(self):
-        """Read and return the HTML template file contents.
-        
-        Returns:
-            str: The contents of the template file
-            
-        Raises:
-            IOError: If template file cannot be read
-        """
-        try:
-            with open(self.template_path, "r", encoding="utf-8") as f:
-                return f.read()
-        except IOError as e:
-            raise IOError(f"Failed to read template file {self.template_path}: {str(e)}")
+        """Read and return the HTML template file contents."""
+        with open(self.template_path, "r", encoding="utf-8") as f:
+            return f.read()
 
     def encode_logo(self):
-        """Convert the logo SVG file to base64 encoded string.
-        
-        Returns:
-            str: Base64 encoded logo data
-            
-        Raises:
-            IOError: If logo file cannot be read
-            ValueError: If logo data cannot be encoded
-        """
-        try:
-            with open(self.logo_path, "rb") as logo_file:
-                logo_svg_data = logo_file.read()
-                try:
-                    return base64.b64encode(logo_svg_data).decode("utf-8")
-                except Exception as e:
-                    raise ValueError(f"Failed to encode logo data: {str(e)}")
-        except IOError as e:
-            raise IOError(f"Failed to read logo file {self.logo_path}: {str(e)}")
+        """Convert the logo SVG file to base64 encoded string."""
+        with open(self.logo_path, "rb") as logo_file:
+            logo_svg_data = logo_file.read()
+            return base64.b64encode(logo_svg_data).decode("utf-8")
 
     def extract_body_content(self, html):
-        """Extract and return content between body tags from HTML string.
-        
-        Args:
-            html: HTML string to extract body content from
-            
-        Returns:
-            str: Content between body tags, or empty string if not found
-            
-        Raises:
-            ValueError: If input HTML is invalid
-        """
-        if not html or not isinstance(html, str):
-            raise ValueError("Input HTML must be a non-empty string")
-            
+        """Extract and return content between body tags from HTML string."""
         match = re.search("<body.*?>(.*?)</body>", html, re.DOTALL)
         return match.group(1) if match else ""
 
     def generate_legend_items_html(self, legend_items):
-        """Generate HTML markup for the legend items.
-        
-        Args:
-            legend_items: List of dictionaries containing legend item properties
-            
-        Returns:
-            str: Generated HTML markup for legend items
-            
-        Raises:
-            ValueError: If legend_items is invalid or missing required properties
-        """
-        if not isinstance(legend_items, list):
-            raise ValueError("legend_items must be a list")
-            
+        """Generate HTML markup for the legend items."""
         legend_items_html = ""
         for item in legend_items:
-            if not isinstance(item, dict):
-                raise ValueError("Each legend item must be a dictionary")
-            if "color" not in item:
-                raise ValueError("Each legend item must have a 'color' property")
-            if "label" not in item:
-                raise ValueError("Each legend item must have a 'label' property")
-                
             if "border" in item:
                 legend_items_html += f"""
                 <div class="legend-item">
@@ -127,42 +75,19 @@ class HTMLTemplateHandler:
         return legend_items_html
 
     def generate_final_html(self, network_body, legend_items_html, title="Flow Plot"):
-        """Combine all components into final HTML document with network visualization.
-        
-        Args:
-            network_body: HTML string containing network visualization
-            legend_items_html: HTML string containing legend items markup
-            title: Title for the visualization page (default: "Flow Plot")
-            
-        Returns:
-            str: Complete HTML document with all components integrated
-            
-        Raises:
-            ValueError: If any input parameters are invalid
-            IOError: If template or logo files cannot be read
-        """
-        if not isinstance(network_body, str):
-            raise ValueError("network_body must be a string")
-        if not isinstance(legend_items_html, str):
-            raise ValueError("legend_items_html must be a string")
-        if not isinstance(title, str):
-            raise ValueError("title must be a string")
-            
-        try:
-            html_template = self.read_template()
-            logo_svg_base64 = self.encode_logo()
+        """Combine all components into final HTML document with network visualization."""
+        html_template = self.read_template()
+        logo_svg_base64 = self.encode_logo()
 
-            final_html_content = html_template.replace("{{ title }}", title)
-            final_html_content = final_html_content.replace(
-                "{{ network_content }}", network_body
-            )
-            final_html_content = final_html_content.replace(
-                "{{ logo_svg_base64 }}", logo_svg_base64
-            )
-            final_html_content = final_html_content.replace(
-                "<!-- LEGEND_ITEMS_PLACEHOLDER -->", legend_items_html
-            )
+        final_html_content = html_template.replace("{{ title }}", title)
+        final_html_content = final_html_content.replace(
+            "{{ network_content }}", network_body
+        )
+        final_html_content = final_html_content.replace(
+            "{{ logo_svg_base64 }}", logo_svg_base64
+        )
+        final_html_content = final_html_content.replace(
+            "<!-- LEGEND_ITEMS_PLACEHOLDER -->", legend_items_html
+        )
 
-            return final_html_content
-        except Exception as e:
-            raise ValueError(f"Failed to generate final HTML: {str(e)}")
+        return final_html_content

src/crewai/flow/path_utils.py

@@ -1,123 +1,135 @@
-"""Utilities for safe path handling in flow visualization.
+"""
+Path utilities for secure file operations in CrewAI flow module.
 
-This module provides a comprehensive set of utilities for secure path handling,
-including path joining, validation, and normalization. It helps prevent common
-security issues like directory traversal attacks while providing a consistent
-interface for path operations.
+This module provides utilities for secure path handling to prevent directory
+traversal attacks and ensure paths remain within allowed boundaries.
 """
 
 import os
 from pathlib import Path
-from typing import List, Optional, Union
+from typing import List, Union
 
 
-def safe_path_join(base_dir: Union[str, Path], filename: str) -> str:
-    """Safely join base directory with filename, preventing directory traversal.
-    
-    Args:
-        base_dir: Base directory path
-        filename: Filename or path to join with base_dir
-        
-    Returns:
-        str: Safely joined absolute path
-        
-    Raises:
-        ValueError: If resulting path would escape base_dir or contains dangerous patterns
-        TypeError: If inputs are not strings or Path objects
-        OSError: If path resolution fails
+def safe_path_join(*parts: str, root: Union[str, Path, None] = None) -> str:
     """
-    if not isinstance(base_dir, (str, Path)):
-        raise TypeError("base_dir must be a string or Path object")
-    if not isinstance(filename, str):
-        raise TypeError("filename must be a string")
-        
-    # Check for dangerous patterns
-    dangerous_patterns = ['..', '~', '*', '?', '|', '>', '<', '$', '&', '`']
-    if any(pattern in filename for pattern in dangerous_patterns):
-        raise ValueError(f"Invalid filename: Contains dangerous pattern")
-        
+    Safely join path components and ensure the result is within allowed boundaries.
+
+    Parameters
+    ----------
+    *parts : str
+        Variable number of path components to join.
+    root : Union[str, Path, None], optional
+        Root directory to use as base. If None, uses current working directory.
+
+    Returns
+    -------
+    str
+        String representation of the resolved path.
+
+    Raises
+    ------
+    ValueError
+        If the resulting path would be outside the root directory
+        or if any path component is invalid.
+    """
+    if not parts:
+        raise ValueError("No path components provided")
+
     try:
-        base_path = Path(base_dir).resolve(strict=True)
-        full_path = Path(base_path, filename).resolve(strict=True)
+        # Convert all parts to strings and clean them
+        clean_parts = [str(part).strip() for part in parts if part]
+        if not clean_parts:
+            raise ValueError("No valid path components provided")
+
+        # Establish root directory
+        root_path = Path(root).resolve() if root else Path.cwd()
         
-        if not str(full_path).startswith(str(base_path)):
+        # Join and resolve the full path
+        full_path = Path(root_path, *clean_parts).resolve()
+        
+        # Check if the resolved path is within root
+        if not str(full_path).startswith(str(root_path)):
             raise ValueError(
-                f"Invalid path: {filename} would escape base directory {base_dir}"
+                f"Invalid path: Potential directory traversal. Path must be within {root_path}"
             )
             
         return str(full_path)
-    except OSError as e:
-        raise OSError(f"Failed to resolve path: {str(e)}")
+        
     except Exception as e:
-        raise ValueError(f"Failed to process paths: {str(e)}")
+        if isinstance(e, ValueError):
+            raise
+        raise ValueError(f"Invalid path components: {str(e)}")
 
 
-def normalize_path(path: Union[str, Path]) -> str:
-    """Normalize a path by resolving symlinks and removing redundant separators.
-    
-    Args:
-        path: Path to normalize
-        
-    Returns:
-        str: Normalized absolute path
-        
-    Raises:
-        TypeError: If path is not a string or Path object
-        OSError: If path resolution fails
+def validate_path_exists(path: Union[str, Path], file_type: str = "file") -> str:
+    """
+    Validate that a path exists and is of the expected type.
+
+    Parameters
+    ----------
+    path : Union[str, Path]
+        Path to validate.
+    file_type : str, optional
+        Expected type ('file' or 'directory'), by default 'file'.
+
+    Returns
+    -------
+    str
+        Validated path as string.
+
+    Raises
+    ------
+    ValueError
+        If path doesn't exist or is not of expected type.
     """
-    if not isinstance(path, (str, Path)):
-        raise TypeError("path must be a string or Path object")
-        
     try:
-        return str(Path(path).resolve(strict=True))
-    except OSError as e:
-        raise OSError(f"Failed to normalize path: {str(e)}")
-
-
-def validate_path_components(components: List[str]) -> None:
-    """Validate path components for potentially dangerous patterns.
-    
-    Args:
-        components: List of path components to validate
+        path_obj = Path(path).resolve()
         
-    Raises:
-        TypeError: If components is not a list or contains non-string items
-        ValueError: If any component contains dangerous patterns
-    """
-    if not isinstance(components, list):
-        raise TypeError("components must be a list")
-        
-    dangerous_patterns = ['..', '~', '*', '?', '|', '>', '<', '$', '&', '`']
-    for component in components:
-        if not isinstance(component, str):
-            raise TypeError(f"Path component '{component}' must be a string")
-        if any(pattern in component for pattern in dangerous_patterns):
-            raise ValueError(f"Invalid path component '{component}': Contains dangerous pattern")
-
-
-def validate_file_path(path: Union[str, Path], must_exist: bool = True) -> str:
-    """Validate a file path for security and existence.
-    
-    Args:
-        path: File path to validate
-        must_exist: Whether the file must exist (default: True)
-        
-    Returns:
-        str: Validated absolute path
-        
-    Raises:
-        ValueError: If path is invalid or file doesn't exist when required
-        TypeError: If path is not a string or Path object
-    """
-    if not isinstance(path, (str, Path)):
-        raise TypeError("path must be a string or Path object")
-        
-    try:
-        resolved_path = Path(path).resolve()
-        
-        if must_exist and not resolved_path.is_file():
-            raise ValueError(f"File not found: {path}")
+        if not path_obj.exists():
+            raise ValueError(f"Path does not exist: {path}")
             
-        return str(resolved_path)
+        if file_type == "file" and not path_obj.is_file():
+            raise ValueError(f"Path is not a file: {path}")
+        elif file_type == "directory" and not path_obj.is_dir():
+            raise ValueError(f"Path is not a directory: {path}")
+            
+        return str(path_obj)
+        
     except Exception as e:
-        raise ValueError(f"Invalid file path {path}: {str(e)}")
+        if isinstance(e, ValueError):
+            raise
+        raise ValueError(f"Invalid path: {str(e)}")
+
+
+def list_files(directory: Union[str, Path], pattern: str = "*") -> List[str]:
+    """
+    Safely list files in a directory matching a pattern.
+
+    Parameters
+    ----------
+    directory : Union[str, Path]
+        Directory to search in.
+    pattern : str, optional
+        Glob pattern to match files against, by default "*".
+
+    Returns
+    -------
+    List[str]
+        List of matching file paths.
+
+    Raises
+    ------
+    ValueError
+        If directory is invalid or inaccessible.
+    """
+    try:
+        dir_path = Path(directory).resolve()
+        if not dir_path.is_dir():
+            raise ValueError(f"Not a directory: {directory}")
+            
+        return [str(p) for p in dir_path.glob(pattern) if p.is_file()]
+        
+    except Exception as e:
+        if isinstance(e, ValueError):
+            raise
+        raise ValueError(f"Error listing files: {str(e)}")

src/crewai/flow/utils.py

@@ -1,35 +1,362 @@
-"""General utility functions for flow execution.
+"""
+Utility functions for flow visualization and dependency analysis.
 
-This module has been deprecated. All functionality has been moved to:
-- core_flow_utils.py: Core flow execution utilities
-- flow_visual_utils.py: Visualization-related utilities
+This module provides core functionality for analyzing and manipulating flow structures,
+including node level calculation, ancestor tracking, and return value analysis.
+Functions in this module are primarily used by the visualization system to create
+accurate and informative flow diagrams.
 
-This module is kept as a temporary redirect to maintain backwards compatibility.
-New code should import from the appropriate new modules directly.
+Example
+-------
+>>> flow = Flow()
+>>> node_levels = calculate_node_levels(flow)
+>>> ancestors = build_ancestor_dict(flow)
 """
 
-from typing import Any, Dict, List, Optional, Set
+import ast
+import inspect
+import textwrap
+from typing import Any, Dict, List, Optional, Set, Union
 
-from .core_flow_utils import get_possible_return_constants, is_ancestor
-from .flow_visual_utils import (
-    build_ancestor_dict,
-    build_parent_children_dict,
-    calculate_node_levels,
-    count_outgoing_edges,
-    dfs_ancestors,
-    get_child_index,
-)
 
-# Re-export all functions for backwards compatibility
-__all__ = [
-    'get_possible_return_constants',
-    'calculate_node_levels',
-    'count_outgoing_edges',
-    'build_ancestor_dict',
-    'dfs_ancestors',
-    'is_ancestor',
-    'build_parent_children_dict',
-    'get_child_index',
-]
+def get_possible_return_constants(function: Any) -> Optional[List[str]]:
+    try:
+        source = inspect.getsource(function)
+    except OSError:
+        # Can't get source code
+        return None
+    except Exception as e:
+        print(f"Error retrieving source code for function {function.__name__}: {e}")
+        return None
 
-# Function implementations have been moved to core_flow_utils.py and flow_visual_utils.py
+    try:
+        # Remove leading indentation
+        source = textwrap.dedent(source)
+        # Parse the source code into an AST
+        code_ast = ast.parse(source)
+    except IndentationError as e:
+        print(f"IndentationError while parsing source code of {function.__name__}: {e}")
+        print(f"Source code:\n{source}")
+        return None
+    except SyntaxError as e:
+        print(f"SyntaxError while parsing source code of {function.__name__}: {e}")
+        print(f"Source code:\n{source}")
+        return None
+    except Exception as e:
+        print(f"Unexpected error while parsing source code of {function.__name__}: {e}")
+        print(f"Source code:\n{source}")
+        return None
+
+    return_values = set()
+    dict_definitions = {}
+
+    class DictionaryAssignmentVisitor(ast.NodeVisitor):
+        def visit_Assign(self, node):
+            # Check if this assignment is assigning a dictionary literal to a variable
+            if isinstance(node.value, ast.Dict) and len(node.targets) == 1:
+                target = node.targets[0]
+                if isinstance(target, ast.Name):
+                    var_name = target.id
+                    dict_values = []
+                    # Extract string values from the dictionary
+                    for val in node.value.values:
+                        if isinstance(val, ast.Constant) and isinstance(val.value, str):
+                            dict_values.append(val.value)
+                        # If non-string, skip or just ignore
+                    if dict_values:
+                        dict_definitions[var_name] = dict_values
+            self.generic_visit(node)
+
+    class ReturnVisitor(ast.NodeVisitor):
+        def visit_Return(self, node):
+            # Direct string return
+            if isinstance(node.value, ast.Constant) and isinstance(
+                node.value.value, str
+            ):
+                return_values.add(node.value.value)
+            # Dictionary-based return, like return paths[result]
+            elif isinstance(node.value, ast.Subscript):
+                # Check if we're subscripting a known dictionary variable
+                if isinstance(node.value.value, ast.Name):
+                    var_name = node.value.value.id
+                    if var_name in dict_definitions:
+                        # Add all possible dictionary values
+                        for v in dict_definitions[var_name]:
+                            return_values.add(v)
+            self.generic_visit(node)
+
+    # First pass: identify dictionary assignments
+    DictionaryAssignmentVisitor().visit(code_ast)
+    # Second pass: identify returns
+    ReturnVisitor().visit(code_ast)
+
+    return list(return_values) if return_values else None
+
+
+def calculate_node_levels(flow: Any) -> Dict[str, int]:
+    """
+    Calculate the hierarchical level of each node in the flow.
+
+    Performs a breadth-first traversal of the flow graph to assign levels
+    to nodes, starting with start methods at level 0.
+
+    Parameters
+    ----------
+    flow : Any
+        The flow instance containing methods, listeners, and router configurations.
+
+    Returns
+    -------
+    Dict[str, int]
+        Dictionary mapping method names to their hierarchical levels.
+
+    Notes
+    -----
+    - Start methods are assigned level 0
+    - Each subsequent connected node is assigned level = parent_level + 1
+    - Handles both OR and AND conditions for listeners
+    - Processes router paths separately
+    """
+    levels: Dict[str, int] = {}
+    queue: List[str] = []
+    visited: Set[str] = set()
+    pending_and_listeners: Dict[str, Set[str]] = {}
+
+    # Make all start methods at level 0
+    for method_name, method in flow._methods.items():
+        if hasattr(method, "__is_start_method__"):
+            levels[method_name] = 0
+            queue.append(method_name)
+
+    # Breadth-first traversal to assign levels
+    while queue:
+        current = queue.pop(0)
+        current_level = levels[current]
+        visited.add(current)
+
+        for listener_name, (condition_type, trigger_methods) in flow._listeners.items():
+            if condition_type == "OR":
+                if current in trigger_methods:
+                    if (
+                        listener_name not in levels
+                        or levels[listener_name] > current_level + 1
+                    ):
+                        levels[listener_name] = current_level + 1
+                        if listener_name not in visited:
+                            queue.append(listener_name)
+            elif condition_type == "AND":
+                if listener_name not in pending_and_listeners:
+                    pending_and_listeners[listener_name] = set()
+                if current in trigger_methods:
+                    pending_and_listeners[listener_name].add(current)
+                if set(trigger_methods) == pending_and_listeners[listener_name]:
+                    if (
+                        listener_name not in levels
+                        or levels[listener_name] > current_level + 1
+                    ):
+                        levels[listener_name] = current_level + 1
+                        if listener_name not in visited:
+                            queue.append(listener_name)
+
+        # Handle router connections
+        if current in flow._routers:
+            router_method_name = current
+            paths = flow._router_paths.get(router_method_name, [])
+            for path in paths:
+                for listener_name, (
+                    condition_type,
+                    trigger_methods,
+                ) in flow._listeners.items():
+                    if path in trigger_methods:
+                        if (
+                            listener_name not in levels
+                            or levels[listener_name] > current_level + 1
+                        ):
+                            levels[listener_name] = current_level + 1
+                            if listener_name not in visited:
+                                queue.append(listener_name)
+
+    return levels
+
+
+def count_outgoing_edges(flow: Any) -> Dict[str, int]:
+    """
+    Count the number of outgoing edges for each method in the flow.
+
+    Parameters
+    ----------
+    flow : Any
+        The flow instance to analyze.
+
+    Returns
+    -------
+    Dict[str, int]
+        Dictionary mapping method names to their outgoing edge count.
+    """
+    counts = {}
+    for method_name in flow._methods:
+        counts[method_name] = 0
+    for method_name in flow._listeners:
+        _, trigger_methods = flow._listeners[method_name]
+        for trigger in trigger_methods:
+            if trigger in flow._methods:
+                counts[trigger] += 1
+    return counts
+
+
+def build_ancestor_dict(flow: Any) -> Dict[str, Set[str]]:
+    """
+    Build a dictionary mapping each node to its ancestor nodes.
+
+    Parameters
+    ----------
+    flow : Any
+        The flow instance to analyze.
+
+    Returns
+    -------
+    Dict[str, Set[str]]
+        Dictionary mapping each node to a set of its ancestor nodes.
+    """
+    ancestors: Dict[str, Set[str]] = {node: set() for node in flow._methods}
+    visited: Set[str] = set()
+    for node in flow._methods:
+        if node not in visited:
+            dfs_ancestors(node, ancestors, visited, flow)
+    return ancestors
+
+
+def dfs_ancestors(
+    node: str,
+    ancestors: Dict[str, Set[str]],
+    visited: Set[str],
+    flow: Any
+) -> None:
+    """
+    Perform depth-first search to build ancestor relationships.
+
+    Parameters
+    ----------
+    node : str
+        Current node being processed.
+    ancestors : Dict[str, Set[str]]
+        Dictionary tracking ancestor relationships.
+    visited : Set[str]
+        Set of already visited nodes.
+    flow : Any
+        The flow instance being analyzed.
+
+    Notes
+    -----
+    This function modifies the ancestors dictionary in-place to build
+    the complete ancestor graph.
+    """
+    if node in visited:
+        return
+    visited.add(node)
+
+    # Handle regular listeners
+    for listener_name, (_, trigger_methods) in flow._listeners.items():
+        if node in trigger_methods:
+            ancestors[listener_name].add(node)
+            ancestors[listener_name].update(ancestors[node])
+            dfs_ancestors(listener_name, ancestors, visited, flow)
+
+    # Handle router methods separately
+    if node in flow._routers:
+        router_method_name = node
+        paths = flow._router_paths.get(router_method_name, [])
+        for path in paths:
+            for listener_name, (_, trigger_methods) in flow._listeners.items():
+                if path in trigger_methods:
+                    # Only propagate the ancestors of the router method, not the router method itself
+                    ancestors[listener_name].update(ancestors[node])
+                    dfs_ancestors(listener_name, ancestors, visited, flow)
+
+
+def is_ancestor(node: str, ancestor_candidate: str, ancestors: Dict[str, Set[str]]) -> bool:
+    """
+    Check if one node is an ancestor of another.
+
+    Parameters
+    ----------
+    node : str
+        The node to check ancestors for.
+    ancestor_candidate : str
+        The potential ancestor node.
+    ancestors : Dict[str, Set[str]]
+        Dictionary containing ancestor relationships.
+
+    Returns
+    -------
+    bool
+        True if ancestor_candidate is an ancestor of node, False otherwise.
+    """
+    return ancestor_candidate in ancestors.get(node, set())
+
+
+def build_parent_children_dict(flow: Any) -> Dict[str, List[str]]:
+    """
+    Build a dictionary mapping parent nodes to their children.
+
+    Parameters
+    ----------
+    flow : Any
+        The flow instance to analyze.
+
+    Returns
+    -------
+    Dict[str, List[str]]
+        Dictionary mapping parent method names to lists of their child method names.
+
+    Notes
+    -----
+    - Maps listeners to their trigger methods
+    - Maps router methods to their paths and listeners
+    - Children lists are sorted for consistent ordering
+    """
+    parent_children: Dict[str, List[str]] = {}
+
+    # Map listeners to their trigger methods
+    for listener_name, (_, trigger_methods) in flow._listeners.items():
+        for trigger in trigger_methods:
+            if trigger not in parent_children:
+                parent_children[trigger] = []
+            if listener_name not in parent_children[trigger]:
+                parent_children[trigger].append(listener_name)
+
+    # Map router methods to their paths and to listeners
+    for router_method_name, paths in flow._router_paths.items():
+        for path in paths:
+            # Map router method to listeners of each path
+            for listener_name, (_, trigger_methods) in flow._listeners.items():
+                if path in trigger_methods:
+                    if router_method_name not in parent_children:
+                        parent_children[router_method_name] = []
+                    if listener_name not in parent_children[router_method_name]:
+                        parent_children[router_method_name].append(listener_name)
+
+    return parent_children
+
+
+def get_child_index(parent: str, child: str, parent_children: Dict[str, List[str]]) -> int:
+    """
+    Get the index of a child node in its parent's sorted children list.
+
+    Parameters
+    ----------
+    parent : str
+        The parent node name.
+    child : str
+        The child node name to find the index for.
+    parent_children : Dict[str, List[str]]
+        Dictionary mapping parents to their children lists.
+
+    Returns
+    -------
+    int
+        Zero-based index of the child in its parent's sorted children list.
+    """
+    children = parent_children.get(parent, [])
+    children.sort()
+    return children.index(child)

src/crewai/flow/visualization_utils.py

@@ -1,63 +1,61 @@
+"""
+Utilities for creating visual representations of flow structures.
+
+This module provides functions for generating network visualizations of flows,
+including node placement, edge creation, and visual styling. It handles the
+conversion of flow structures into visual network graphs with appropriate
+styling and layout.
+
+Example
+-------
+>>> flow = Flow()
+>>> net = Network(directed=True)
+>>> node_positions = compute_positions(flow, node_levels)
+>>> add_nodes_to_network(net, flow, node_positions, node_styles)
+>>> add_edges(net, flow, node_positions, colors)
+"""
+
 import ast
 import inspect
-import os
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Set, Tuple, cast
+from typing import Any, Dict, List, Optional, Tuple, Union
 
-from crewai.flow.flow import Flow
-from pyvis.network import Network
-
-from .core_flow_utils import is_ancestor
-from .flow_visual_utils import (
+from .utils import (
     build_ancestor_dict,
     build_parent_children_dict,
     get_child_index,
+    is_ancestor,
 )
-from .path_utils import safe_path_join, validate_file_path
 
 
-def method_calls_crew(method: Optional[Callable[..., Any]]) -> bool:
-    """Check if the method contains a .crew() call in its implementation.
-    
-    Analyzes the method's source code using AST to detect if it makes any
-    calls to the .crew() method, which indicates crew involvement in the
-    flow execution.
-    
-    Args:
-        method: The method to analyze for crew calls, can be None
-        
-    Returns:
-        bool: True if the method contains a .crew() call, False otherwise
-        
-    Raises:
-        TypeError: If input is not None and not a callable method
-        ValueError: If method source code cannot be parsed
-        RuntimeError: If unexpected error occurs during parsing
+def method_calls_crew(method: Any) -> bool:
+    """
+    Check if the method contains a call to `.crew()`.
+
+    Parameters
+    ----------
+    method : Any
+        The method to analyze for crew() calls.
+
+    Returns
+    -------
+    bool
+        True if the method calls .crew(), False otherwise.
+
+    Notes
+    -----
+    Uses AST analysis to detect method calls, specifically looking for
+    attribute access of 'crew'.
     """
-    if method is None:
-        return False
-    if not callable(method):
-        raise TypeError("Input must be a callable method")
-        
     try:
         source = inspect.getsource(method)
         source = inspect.cleandoc(source)
         tree = ast.parse(source)
-    except (TypeError, ValueError, OSError) as e:
-        raise ValueError(f"Could not parse method {getattr(method, '__name__', str(method))}: {e}")
     except Exception as e:
-        raise RuntimeError(f"Unexpected error parsing method: {e}")
+        print(f"Could not parse method {method.__name__}: {e}")
+        return False
 
     class CrewCallVisitor(ast.NodeVisitor):
-        """AST visitor to detect .crew() method calls in source code.
-        
-        A specialized AST visitor that analyzes Python source code to precisely
-        identify calls to the .crew() method, enabling accurate detection of
-        crew involvement in flow methods.
-        
-        Attributes:
-            found (bool): Indicates whether a .crew() call was found
-        """
+        """AST visitor to detect .crew() method calls."""
         def __init__(self):
             self.found = False
 
@@ -72,64 +70,35 @@ def method_calls_crew(method: Optional[Callable[..., Any]]) -> bool:
     return visitor.found
 
 
-def add_nodes_to_network(net: Network, flow: Flow[Any], 
-                     node_positions: Dict[str, Tuple[float, float]], 
-                     node_styles: Dict[str, dict],
-                     output_dir: Optional[str] = None) -> None:
-    """Add nodes to the network visualization with precise styling and positioning.
-    
-    Creates and styles nodes in the visualization network based on their type
-    (start, router, crew, or regular method) with fine-grained control over
-    appearance and positioning.
-    
-    Args:
-        net: The network visualization object to add nodes to
-        flow: Flow object containing method definitions and relationships
-        node_positions: Dictionary mapping method names to (x,y) coordinates
-        node_styles: Dictionary mapping node types to their visual styles
-        output_dir: Optional directory path for saving visualization assets
-        
-    Returns:
-        None
-        
-    Raises:
-        ValueError: If flow object is invalid or required styles are missing
-        TypeError: If input arguments have incorrect types
-        OSError: If output directory operations fail
-        
-    Note:
-        Node styles are applied with precise control over shape, font, color,
-        and positioning to ensure accurate visual representation of the flow.
-        If output_dir is provided, it will be validated and created if needed.
+def add_nodes_to_network(
+    net: Any,
+    flow: Any,
+    node_positions: Dict[str, Tuple[float, float]],
+    node_styles: Dict[str, Dict[str, Any]]
+) -> None:
     """
-    if not hasattr(flow, '_methods'):
-        raise ValueError("Invalid flow object: missing '_methods' attribute")
-    if not isinstance(node_positions, dict):
-        raise TypeError("node_positions must be a dictionary")
-    if not isinstance(node_styles, dict):
-        raise TypeError("node_styles must be a dictionary")
-    
-    required_styles = {'start', 'router', 'crew', 'method'}
-    missing_styles = required_styles - set(node_styles.keys())
-    if missing_styles:
-        raise ValueError(f"Missing required node styles: {missing_styles}")
-        
-    # Validate and create output directory if specified
-    if output_dir:
-        try:
-            output_dir = validate_file_path(output_dir, must_exist=False)
-            os.makedirs(output_dir, exist_ok=True)
-        except (ValueError, OSError) as e:
-            raise OSError(f"Failed to create or validate output directory: {e}")
-    def human_friendly_label(method_name: str) -> str: 
-        """Convert method name to human-readable format.
-        
-        Args:
-            method_name: Original method name with underscores
-            
-        Returns:
-            str: Formatted method name with spaces and title case
-        """
+    Add nodes to the network visualization with appropriate styling.
+
+    Parameters
+    ----------
+    net : Any
+        The pyvis Network instance to add nodes to.
+    flow : Any
+        The flow instance containing method information.
+    node_positions : Dict[str, Tuple[float, float]]
+        Dictionary mapping node names to their (x, y) positions.
+    node_styles : Dict[str, Dict[str, Any]]
+        Dictionary containing style configurations for different node types.
+
+    Notes
+    -----
+    Node types include:
+    - Start methods
+    - Router methods
+    - Crew methods
+    - Regular methods
+    """
+    def human_friendly_label(method_name):
         return method_name.replace("_", " ").title()
 
     for method_name, (x, y) in node_positions.items():
@@ -146,15 +115,6 @@ def add_nodes_to_network(net: Network, flow: Flow[Any],
         node_style = node_style.copy()
         label = human_friendly_label(method_name)
 
-        # Handle file-based assets if output directory is provided
-        if output_dir and node_style.get("image"):
-            try:
-                image_path = node_style["image"]
-                safe_image_path = safe_path_join(output_dir, Path(image_path).name)
-                node_style["image"] = str(safe_image_path)
-            except (ValueError, OSError) as e:
-                raise OSError(f"Failed to process node image path: {e}")
-
         node_style.update(
             {
                 "label": label,
@@ -176,39 +136,31 @@ def add_nodes_to_network(net: Network, flow: Flow[Any],
         )
 
 
-def compute_positions(flow: Flow[Any], node_levels: Dict[str, int], 
-                   y_spacing: float = 150, x_spacing: float = 150) -> Dict[str, Tuple[float, float]]:
-    """Calculate precise x,y coordinates for each node in the flow diagram.
-    
-    Computes optimal node positions with fine-grained control over spacing
-    and alignment, ensuring clear visualization of flow hierarchy and
-    relationships.
-    
-    Args:
-        flow: Flow object containing method definitions
-        node_levels: Dictionary mapping method names to their hierarchy levels
-        y_spacing: Vertical spacing between hierarchy levels (default: 150)
-        x_spacing: Horizontal spacing between nodes at same level (default: 150)
-        
-    Returns:
-        dict[str, tuple[float, float]]: Dictionary mapping method names to
-            their calculated (x,y) coordinates in the visualization
-            
-    Note:
-        Positions are calculated to maintain clear hierarchical structure while
-        ensuring optimal spacing and readability of the flow diagram.
+def compute_positions(
+    flow: Any,
+    node_levels: Dict[str, int],
+    y_spacing: float = 150,
+    x_spacing: float = 150
+) -> Dict[str, Tuple[float, float]]:
+    """
+    Compute the (x, y) positions for each node in the flow graph.
+
+    Parameters
+    ----------
+    flow : Any
+        The flow instance to compute positions for.
+    node_levels : Dict[str, int]
+        Dictionary mapping node names to their hierarchical levels.
+    y_spacing : float, optional
+        Vertical spacing between levels, by default 150.
+    x_spacing : float, optional
+        Horizontal spacing between nodes, by default 150.
+
+    Returns
+    -------
+    Dict[str, Tuple[float, float]]
+        Dictionary mapping node names to their (x, y) coordinates.
     """
-    if not hasattr(flow, '_methods'):
-        raise ValueError("Invalid flow object: missing '_methods' attribute")
-    if not isinstance(node_levels, dict):
-        raise TypeError("node_levels must be a dictionary")
-    if not isinstance(y_spacing, (int, float)) or y_spacing <= 0:
-        raise ValueError("y_spacing must be a positive number")
-    if not isinstance(x_spacing, (int, float)) or x_spacing <= 0:
-        raise ValueError("x_spacing must be a positive number")
-        
-    if not node_levels:
-        raise ValueError("node_levels dictionary cannot be empty")
     level_nodes: Dict[int, List[str]] = {}
     node_positions: Dict[str, Tuple[float, float]] = {}
 
@@ -225,34 +177,33 @@ def compute_positions(flow: Flow[Any], node_levels: Dict[str, int],
     return node_positions
 
 
-def add_edges(net: Network, flow: Flow[Any], 
-            node_positions: Dict[str, Tuple[float, float]], 
-            colors: Dict[str, str],
-            asset_dir: Optional[str] = None) -> None:
-    if not hasattr(flow, '_methods'):
-        raise ValueError("Invalid flow object: missing '_methods' attribute")
-    if not hasattr(flow, '_listeners'):
-        raise ValueError("Invalid flow object: missing '_listeners' attribute")
-    if not hasattr(flow, '_router_paths'):
-        raise ValueError("Invalid flow object: missing '_router_paths' attribute")
-        
-    if not isinstance(node_positions, dict):
-        raise TypeError("node_positions must be a dictionary")
-    if not isinstance(colors, dict):
-        raise TypeError("colors must be a dictionary")
-        
-    required_colors = {'edge', 'router_edge'}
-    missing_colors = required_colors - set(colors.keys())
-    if missing_colors:
-        raise ValueError(f"Missing required edge colors: {missing_colors}")
-        
-    # Validate asset directory if provided
-    if asset_dir:
-        try:
-            asset_dir = validate_file_path(asset_dir, must_exist=False)
-            os.makedirs(asset_dir, exist_ok=True)
-        except (ValueError, OSError) as e:
-            raise OSError(f"Failed to create or validate asset directory: {e}")
+def add_edges(
+    net: Any,
+    flow: Any,
+    node_positions: Dict[str, Tuple[float, float]],
+    colors: Dict[str, str]
+) -> None:
+    edge_smooth: Dict[str, Union[str, float]] = {"type": "continuous"}  # Default value
+    """
+    Add edges to the network visualization with appropriate styling.
+
+    Parameters
+    ----------
+    net : Any
+        The pyvis Network instance to add edges to.
+    flow : Any
+        The flow instance containing edge information.
+    node_positions : Dict[str, Tuple[float, float]]
+        Dictionary mapping node names to their positions.
+    colors : Dict[str, str]
+        Dictionary mapping edge types to their colors.
+
+    Notes
+    -----
+    - Handles both normal listener edges and router edges
+    - Applies appropriate styling (color, dashes) based on edge type
+    - Adds curvature to edges when needed (cycles or multiple children)
+    """
     ancestors = build_ancestor_dict(flow)
     parent_children = build_parent_children_dict(flow)
 
@@ -281,24 +232,24 @@ def add_edges(net: Network, flow: Flow[Any],
                         dx = target_pos[0] - source_pos[0]
                         smooth_type = "curvedCCW" if dx <= 0 else "curvedCW"
                         index = get_child_index(trigger, method_name, parent_children)
-                        edge_config = {
+                        edge_smooth = {
                             "type": smooth_type,
                             "roundness": 0.2 + (0.1 * index),
                         }
                     else:
-                        edge_config = {"type": "cubicBezier"}
+                        edge_smooth = {"type": "cubicBezier"}
                 else:
-                    edge_config = {"type": "straight"}
+                    edge_smooth.update({"type": "continuous"})
 
-                edge_props: Dict[str, Any] = {
+                edge_style = {
                     "color": edge_color,
                     "width": 2,
                     "arrows": "to",
                     "dashes": True if is_router_edge or is_and_condition else False,
-                    "smooth": edge_config,
+                    "smooth": edge_smooth,
                 }
 
-                net.add_edge(trigger, method_name, **edge_props)
+                net.add_edge(trigger, method_name, **edge_style)
             else:
                 # Nodes not found in node_positions. Check if it's a known router outcome and a known method.
                 is_router_edge = any(
@@ -344,23 +295,23 @@ def add_edges(net: Network, flow: Flow[Any],
                                 index = get_child_index(
                                     router_method_name, listener_name, parent_children
                                 )
-                                edge_config = {
+                                edge_smooth = {
                                     "type": smooth_type,
                                     "roundness": 0.2 + (0.1 * index),
                                 }
                             else:
-                                edge_config = {"type": "cubicBezier"}
+                                edge_smooth = {"type": "cubicBezier"}
                         else:
-                            edge_config = {"type": "straight"}
+                            edge_smooth.update({"type": "continuous"})
 
-                        router_edge_props: Dict[str, Any] = {
+                        edge_style = {
                             "color": colors["router_edge"],
                             "width": 2,
                             "arrows": "to",
                             "dashes": True,
-                            "smooth": edge_config,
+                            "smooth": edge_smooth,
                         }
-                        net.add_edge(router_method_name, listener_name, **router_edge_props)
+                        net.add_edge(router_method_name, listener_name, **edge_style)
                     else:
                         # Same check here: known router edge and known method?
                         method_known = listener_name in flow._methods

src/crewai/llm.py

@@ -6,8 +6,12 @@ import warnings
 from contextlib import contextmanager
 from typing import Any, Dict, List, Optional, Union
 
-import litellm
-from litellm import get_supported_openai_params
+from pydantic import BaseModel, Field
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", UserWarning)
+    import litellm
+    from litellm import get_supported_openai_params
 
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededException,
@@ -91,10 +95,33 @@ def suppress_warnings():
             sys.stderr = old_stderr
 
 
-class LLM:
+class LLM(BaseModel):
+    model: str = "gpt-4"  # Set default model
+    timeout: Optional[Union[float, int]] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stop: Optional[Union[str, List[str]]] = None
+    max_completion_tokens: Optional[int] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[Dict[int, float]] = None
+    response_format: Optional[Dict[str, Any]] = None
+    seed: Optional[int] = None
+    logprobs: Optional[bool] = None
+    top_logprobs: Optional[int] = None
+    base_url: Optional[str] = None
+    api_version: Optional[str] = None
+    api_key: Optional[str] = None
+    callbacks: Optional[List[Any]] = None
+    context_window_size: Optional[int] = None
+    kwargs: Dict[str, Any] = Field(default_factory=dict)
+    logger: Optional[logging.Logger] = Field(default_factory=lambda: logging.getLogger(__name__))
+
     def __init__(
         self,
-        model: str,
+        model: Optional[Union[str, 'LLM']] = "gpt-4",
         timeout: Optional[Union[float, int]] = None,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
@@ -112,118 +139,427 @@ class LLM:
         base_url: Optional[str] = None,
         api_version: Optional[str] = None,
         api_key: Optional[str] = None,
-        callbacks: List[Any] = [],
-        **kwargs,
-    ):
-        self.model = model
-        self.timeout = timeout
-        self.temperature = temperature
-        self.top_p = top_p
-        self.n = n
-        self.stop = stop
-        self.max_completion_tokens = max_completion_tokens
-        self.max_tokens = max_tokens
-        self.presence_penalty = presence_penalty
-        self.frequency_penalty = frequency_penalty
-        self.logit_bias = logit_bias
-        self.response_format = response_format
-        self.seed = seed
-        self.logprobs = logprobs
-        self.top_logprobs = top_logprobs
-        self.base_url = base_url
-        self.api_version = api_version
-        self.api_key = api_key
-        self.callbacks = callbacks
-        self.context_window_size = 0
-        self.kwargs = kwargs
+        callbacks: Optional[List[Any]] = None,
+        context_window_size: Optional[int] = None,
+        **kwargs: Any,
+    ) -> None:
+        # Initialize with default values
+        init_dict = {
+            "model": model if isinstance(model, str) else "gpt-4",
+            "timeout": timeout,
+            "temperature": temperature,
+            "top_p": top_p,
+            "n": n,
+            "stop": stop,
+            "max_completion_tokens": max_completion_tokens,
+            "max_tokens": max_tokens,
+            "presence_penalty": presence_penalty,
+            "frequency_penalty": frequency_penalty,
+            "logit_bias": logit_bias,
+            "response_format": response_format,
+            "seed": seed,
+            "logprobs": logprobs,
+            "top_logprobs": top_logprobs,
+            "base_url": base_url,
+            "api_version": api_version,
+            "api_key": api_key,
+            "callbacks": callbacks,
+            "context_window_size": context_window_size,
+            "kwargs": kwargs,
+        }
+        super().__init__(**init_dict)
+        
+        # Initialize model with default value
+        self.model = "gpt-4"  # Default fallback
+        
+        # Extract and validate model name
+        if isinstance(model, LLM):
+            # Extract and validate model name from LLM instance
+            if hasattr(model, 'model'):
+                if isinstance(model.model, str):
+                    self.model = model.model
+                else:
+                    # Try to extract string model name from nested LLM
+                    if isinstance(model.model, LLM):
+                        self.model = str(model.model.model) if hasattr(model.model, 'model') else "gpt-4"
+                    else:
+                        self.model = "gpt-4"
+                        if self.logger:
+                            self.logger.warning("Nested LLM model is not a string, using default: gpt-4")
+            else:
+                self.model = "gpt-4"
+                if self.logger:
+                    self.logger.warning("LLM instance has no model attribute, using default: gpt-4")
+        else:
+            # Extract and validate model name for non-LLM instances
+            if not isinstance(model, str):
+                if self.logger:
+                    self.logger.debug(f"Model is not a string, attempting to extract name. Type: {type(model)}")
+                if model is not None:
+                    if hasattr(model, 'model_name'):
+                        model_name = getattr(model, 'model_name', None)
+                        self.model = str(model_name) if model_name is not None else "gpt-4"
+                    elif hasattr(model, 'model'):
+                        model_attr = getattr(model, 'model', None)
+                        self.model = str(model_attr) if model_attr is not None else "gpt-4"
+                    elif hasattr(model, '_model_name'):
+                        model_name = getattr(model, '_model_name', None)
+                        self.model = str(model_name) if model_name is not None else "gpt-4"
+                    else:
+                        self.model = "gpt-4"  # Default fallback
+                        if self.logger:
+                            self.logger.warning(f"Could not extract model name from {type(model)}, using default: {self.model}")
+                else:
+                    self.model = "gpt-4"  # Default fallback for None
+                    if self.logger:
+                        self.logger.warning("Model is None, using default: gpt-4")
+            else:
+                self.model = str(model)  # Ensure it's a string
+
+        # If model is an LLM instance, copy its configuration
+        if isinstance(model, LLM):
+            # Extract and validate model name first
+            if hasattr(model, 'model'):
+                if isinstance(model.model, str):
+                    self.model = model.model
+                else:
+                    # Try to extract string model name from nested LLM
+                    if isinstance(model.model, LLM):
+                        self.model = str(model.model.model) if hasattr(model.model, 'model') else "gpt-4"
+                    else:
+                        self.model = "gpt-4"
+                        if self.logger:
+                            self.logger.warning("Nested LLM model is not a string, using default: gpt-4")
+            else:
+                self.model = "gpt-4"
+                if self.logger:
+                    self.logger.warning("LLM instance has no model attribute, using default: gpt-4")
+
+            # Copy other configuration
+            self.timeout = model.timeout
+            self.temperature = model.temperature
+            self.top_p = model.top_p
+            self.n = model.n
+            self.stop = model.stop
+            self.max_completion_tokens = model.max_completion_tokens
+            self.max_tokens = model.max_tokens
+            self.presence_penalty = model.presence_penalty
+            self.frequency_penalty = model.frequency_penalty
+            self.logit_bias = model.logit_bias
+            self.response_format = model.response_format
+            self.seed = model.seed
+            self.logprobs = model.logprobs
+            self.top_logprobs = model.top_logprobs
+            self.base_url = model.base_url
+            self.api_version = model.api_version
+            self.api_key = model.api_key
+            self.callbacks = model.callbacks
+            self.context_window_size = model.context_window_size
+            self.kwargs = model.kwargs
+
+            # Final validation of model name
+            if not isinstance(self.model, str):
+                self.model = "gpt-4"
+                if self.logger:
+                    self.logger.warning("Model name is still not a string after LLM copy, using default: gpt-4")
+        else:
+            # Extract and validate model name for non-LLM instances
+            if not isinstance(model, str):
+                if self.logger:
+                    self.logger.debug(f"Model is not a string, attempting to extract name. Type: {type(model)}")
+                if model is not None:
+                    if hasattr(model, 'model_name'):
+                        model_name = getattr(model, 'model_name', None)
+                        self.model = str(model_name) if model_name is not None else "gpt-4"
+                    elif hasattr(model, 'model'):
+                        model_attr = getattr(model, 'model', None)
+                        self.model = str(model_attr) if model_attr is not None else "gpt-4"
+                    elif hasattr(model, '_model_name'):
+                        model_name = getattr(model, '_model_name', None)
+                        self.model = str(model_name) if model_name is not None else "gpt-4"
+                    else:
+                        self.model = "gpt-4"  # Default fallback
+                        if self.logger:
+                            self.logger.warning(f"Could not extract model name from {type(model)}, using default: {self.model}")
+                else:
+                    self.model = "gpt-4"  # Default fallback for None
+                    if self.logger:
+                        self.logger.warning("Model is None, using default: gpt-4")
+            else:
+                self.model = str(model)  # Ensure it's a string
+
+            # Final validation
+            if not isinstance(self.model, str):
+                self.model = "gpt-4"
+                if self.logger:
+                    self.logger.warning("Model name is still not a string after extraction, using default: gpt-4")
+
+            self.timeout = timeout
+            self.temperature = temperature
+            self.top_p = top_p
+            self.n = n
+            self.stop = stop
+            self.max_completion_tokens = max_completion_tokens
+            self.max_tokens = max_tokens
+            self.presence_penalty = presence_penalty
+            self.frequency_penalty = frequency_penalty
+            self.logit_bias = logit_bias
+            self.response_format = response_format
+            self.seed = seed
+            self.logprobs = logprobs
+            self.top_logprobs = top_logprobs
+            self.base_url = base_url
+            self.api_version = api_version
+            self.api_key = api_key
+            self.callbacks = callbacks
+            self.context_window_size = 0
+            self.kwargs = kwargs
+
+            # Ensure model is a string after initialization
+            if not isinstance(self.model, str):
+                self.model = "gpt-4"
+                self.logger.warning(f"Model is still not a string after initialization, using default: {self.model}")
 
         litellm.drop_params = True
-        litellm.set_verbose = False
+
         self.set_callbacks(callbacks)
         self.set_env_callbacks()
 
-    def call(self, messages: List[Dict[str, str]], callbacks: List[Any] = []) -> str:
+    def call(
+        self,
+        messages: List[Dict[str, str]],
+        callbacks: Optional[List[Any]] = None
+    ) -> str:
         with suppress_warnings():
             if callbacks and len(callbacks) > 0:
                 self.set_callbacks(callbacks)
 
+            # Store original model to restore later
+            original_model = self.model
+
             try:
+                # Ensure model is a string before making the call
+                if not isinstance(self.model, str):
+                    if self.logger:
+                        self.logger.warning(f"Model is not a string in call method: {type(self.model)}. Attempting to convert...")
+                    if isinstance(self.model, LLM):
+                        self.model = self.model.model if isinstance(self.model.model, str) else "gpt-4"
+                    elif hasattr(self.model, 'model_name'):
+                        self.model = str(self.model.model_name)
+                    elif hasattr(self.model, 'model'):
+                        if isinstance(self.model.model, str):
+                            self.model = str(self.model.model)
+                        elif hasattr(self.model.model, 'model_name'):
+                            self.model = str(self.model.model.model_name)
+                        else:
+                            self.model = "gpt-4"
+                            if self.logger:
+                                self.logger.warning("Could not extract model name from nested model object, using default: gpt-4")
+                    else:
+                        self.model = "gpt-4"
+                        if self.logger:
+                            self.logger.warning("Could not extract model name, using default: gpt-4")
+                
+                if self.logger:
+                    self.logger.debug(f"Using model: {self.model} (type: {type(self.model)}) for LiteLLM call")
+
+                # Create base params with validated model name
+                # Extract model name string
+                model_name = None
+                if isinstance(self.model, str):
+                    model_name = self.model
+                elif hasattr(self.model, 'model_name'):
+                    model_name = str(self.model.model_name)
+                elif hasattr(self.model, 'model'):
+                    if isinstance(self.model.model, str):
+                        model_name = str(self.model.model)
+                    elif hasattr(self.model.model, 'model_name'):
+                        model_name = str(self.model.model.model_name)
+                
+                if not model_name:
+                    model_name = "gpt-4"
+                    if self.logger:
+                        self.logger.warning("Could not extract model name, using default: gpt-4")
+
                 params = {
-                    "model": self.model,
+                    "model": model_name,
                     "messages": messages,
-                    "timeout": self.timeout,
-                    "temperature": self.temperature,
-                    "top_p": self.top_p,
-                    "n": self.n,
-                    "stop": self.stop,
-                    "max_tokens": self.max_tokens or self.max_completion_tokens,
-                    "presence_penalty": self.presence_penalty,
-                    "frequency_penalty": self.frequency_penalty,
-                    "logit_bias": self.logit_bias,
-                    "response_format": self.response_format,
-                    "seed": self.seed,
-                    "logprobs": self.logprobs,
-                    "top_logprobs": self.top_logprobs,
+                    "stream": False,
+                    "api_key": self.api_key or os.getenv("OPENAI_API_KEY"),
                     "api_base": self.base_url,
                     "api_version": self.api_version,
-                    "api_key": self.api_key,
-                    "stream": False,
-                    **self.kwargs,
                 }
+                
+                if self.logger:
+                    self.logger.debug(f"Using model parameters: {params}")
+
+                # Add API configuration if available
+                api_key = self.api_key or os.getenv("OPENAI_API_KEY")
+                if api_key:
+                    params["api_key"] = api_key
+
+                # Try to get supported parameters for the model
+                try:
+                    supported_params = get_supported_openai_params(self.model)
+                    optional_params = {}
+                    
+                    if supported_params:
+                        param_mapping = {
+                            "timeout": self.timeout,
+                            "temperature": self.temperature,
+                            "top_p": self.top_p,
+                            "n": self.n,
+                            "stop": self.stop,
+                            "max_tokens": self.max_tokens or self.max_completion_tokens,
+                            "presence_penalty": self.presence_penalty,
+                            "frequency_penalty": self.frequency_penalty,
+                            "logit_bias": self.logit_bias,
+                            "response_format": self.response_format,
+                            "seed": self.seed,
+                            "logprobs": self.logprobs,
+                            "top_logprobs": self.top_logprobs
+                        }
+                        
+                        # Only add parameters that are supported and not None
+                        optional_params = {
+                            k: v for k, v in param_mapping.items()
+                            if k in supported_params and v is not None
+                        }
+                        if "logprobs" in supported_params and self.logprobs is not None:
+                            optional_params["logprobs"] = self.logprobs
+                        if "top_logprobs" in supported_params and self.top_logprobs is not None:
+                            optional_params["top_logprobs"] = self.top_logprobs
+                except Exception as e:
+                    if self.logger:
+                        self.logger.error(f"Failed to get supported params for model {self.model}: {str(e)}")
+                    # If we can't get supported params, just add non-None parameters
+                    param_mapping = {
+                        "timeout": self.timeout,
+                        "temperature": self.temperature,
+                        "top_p": self.top_p,
+                        "n": self.n,
+                        "stop": self.stop,
+                        "max_tokens": self.max_tokens or self.max_completion_tokens,
+                        "presence_penalty": self.presence_penalty,
+                        "frequency_penalty": self.frequency_penalty,
+                        "logit_bias": self.logit_bias,
+                        "response_format": self.response_format,
+                        "seed": self.seed,
+                        "logprobs": self.logprobs,
+                        "top_logprobs": self.top_logprobs
+                    }
+                    optional_params = {k: v for k, v in param_mapping.items() if v is not None}
+
+                # Update params with optional parameters
+                params.update(optional_params)
+                
+                # Add API endpoint configuration if available
+                if self.base_url:
+                    params["api_base"] = self.base_url
+                if self.api_version:
+                    params["api_version"] = self.api_version
+
+                # Final validation of model parameter
+                if not isinstance(params["model"], str):
+                    if self.logger:
+                        self.logger.error(f"Model is still not a string after all conversions: {type(params['model'])}")
+                    params["model"] = "gpt-4"
+                
+                # Update params with non-None optional parameters
+                params.update({k: v for k, v in optional_params.items() if v is not None})
+                
+                # Add any additional kwargs
+                if self.kwargs:
+                    params.update(self.kwargs)
 
                 # Remove None values to avoid passing unnecessary parameters
                 params = {k: v for k, v in params.items() if v is not None}
 
                 response = litellm.completion(**params)
-                return response["choices"][0]["message"]["content"]
+                content = response["choices"][0]["message"]["content"]
+                
+                # Extract usage metrics
+                usage = response.get("usage", {})
+                if callbacks:
+                    for callback in callbacks:
+                        if hasattr(callback, "update_token_usage"):
+                            callback.update_token_usage(usage)
+                
+                return content
             except Exception as e:
                 if not LLMContextLengthExceededException(
                     str(e)
                 )._is_context_limit_error(str(e)):
                     logging.error(f"LiteLLM call failed: {str(e)}")
-
                 raise  # Re-raise the exception after logging
+            finally:
+                # Always restore the original model object
+                self.model = original_model
 
     def supports_function_calling(self) -> bool:
+        """Check if the LLM supports function calling.
+        
+        Returns:
+            bool: True if the model supports function calling, False otherwise
+        """
         try:
             params = get_supported_openai_params(model=self.model)
             return "response_format" in params
         except Exception as e:
-            logging.error(f"Failed to get supported params: {str(e)}")
+            if self.logger:
+                self.logger.error(f"Failed to get supported params: {str(e)}")
             return False
 
     def supports_stop_words(self) -> bool:
+        """Check if the LLM supports stop words.
+        Returns False if the LLM is not properly initialized."""
+        if not hasattr(self, 'model') or self.model is None:
+            return False
         try:
             params = get_supported_openai_params(model=self.model)
             return "stop" in params
         except Exception as e:
-            logging.error(f"Failed to get supported params: {str(e)}")
+            if self.logger:
+                self.logger.error(f"Failed to get supported params: {str(e)}")
             return False
 
     def get_context_window_size(self) -> int:
+        """Get the context window size for the current model.
+        
+        Returns:
+            int: The context window size in tokens
+        """
         # Only using 75% of the context window size to avoid cutting the message in the middle
-        if self.context_window_size != 0:
-            return self.context_window_size
+        if self.context_window_size is not None and self.context_window_size != 0:
+            return int(self.context_window_size)
 
-        self.context_window_size = int(
-            DEFAULT_CONTEXT_WINDOW_SIZE * CONTEXT_WINDOW_USAGE_RATIO
-        )
-        for key, value in LLM_CONTEXT_WINDOW_SIZES.items():
-            if self.model.startswith(key):
-                self.context_window_size = int(value * CONTEXT_WINDOW_USAGE_RATIO)
+        window_size = DEFAULT_CONTEXT_WINDOW_SIZE
+        if isinstance(self.model, str):
+            for key, value in LLM_CONTEXT_WINDOW_SIZES.items():
+                if self.model.startswith(key):
+                    window_size = value
+                    break
+
+        self.context_window_size = int(window_size * CONTEXT_WINDOW_USAGE_RATIO)
         return self.context_window_size
 
-    def set_callbacks(self, callbacks: List[Any]):
-        callback_types = [type(callback) for callback in callbacks]
-        for callback in litellm.success_callback[:]:
-            if type(callback) in callback_types:
-                litellm.success_callback.remove(callback)
+    def set_callbacks(self, callbacks: Optional[List[Any]] = None) -> None:
+        """Set callbacks for the LLM.
+        
+        Args:
+            callbacks: Optional list of callback functions. If None, no callbacks will be set.
+        """
+        if callbacks is not None:
+            callback_types = [type(callback) for callback in callbacks]
+            for callback in litellm.success_callback[:]:
+                if type(callback) in callback_types:
+                    litellm.success_callback.remove(callback)
 
-        for callback in litellm._async_success_callback[:]:
-            if type(callback) in callback_types:
-                litellm._async_success_callback.remove(callback)
+            for callback in litellm._async_success_callback[:]:
+                if type(callback) in callback_types:
+                    litellm._async_success_callback.remove(callback)
 
-        litellm.callbacks = callbacks
+            litellm.callbacks = callbacks
 
     def set_env_callbacks(self):
         """

src/crewai/task.py

@@ -269,7 +269,9 @@ class Task(BaseModel):
     @model_validator(mode="after")
     def check_tools(self):
         """Check if the tools are set."""
-        if not self.tools and self.agent and self.agent.tools:
+        if self.agent and self.agent.tools:
+            if self.tools is None:
+                self.tools = []
             self.tools.extend(self.agent.tools)
         return self
 
@@ -348,7 +350,8 @@ class Task(BaseModel):
         self.prompt_context = context
         tools = tools or self.tools or []
 
-        self.processed_by_agents.add(agent.role)
+        if agent and agent.role:
+            self.processed_by_agents.add(agent.role)
 
         result = agent.execute_task(
             task=self,

src/crewai/tasks/task_output.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict, Optional
+from typing import Any, Callable, Dict, Optional, Union
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -34,8 +34,19 @@ class TaskOutput(BaseModel):
         self.summary = f"{excerpt}..."
         return self
 
-    @property
-    def json(self) -> Optional[str]:
+    def json(
+        self,
+        *,
+        include: Union[set[str], None] = None,
+        exclude: Union[set[str], None] = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        encoder: Optional[Callable[[Any], Any]] = None,
+        models_as_dict: bool = True,
+        **dumps_kwargs: Any,
+    ) -> str:
         if self.output_format != OutputFormat.JSON:
             raise ValueError(
                 """
@@ -45,7 +56,7 @@ class TaskOutput(BaseModel):
                 """
             )
 
-        return json.dumps(self.json_dict)
+        return json.dumps(self.json_dict, default=encoder, **dumps_kwargs)
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert json_output and pydantic_output to a dictionary."""

src/crewai/tools/agent_tools/base_agent_tools.py

@@ -19,13 +19,13 @@ class BaseAgentTool(BaseTool):
         default_factory=I18N, description="Internationalization settings"
     )
 
-    def sanitize_agent_name(self, name: str) -> str:
+    def sanitize_agent_name(self, name: Optional[str]) -> str:
         """
         Sanitize agent role name by normalizing whitespace and setting to lowercase.
         Converts all whitespace (including newlines) to single spaces and removes quotes.
 
         Args:
-            name (str): The agent role name to sanitize
+            name (Optional[str]): The agent role name to sanitize
 
         Returns:
             str: The sanitized agent role name, with whitespace normalized,

src/crewai/tools/structured_tool.py

@@ -142,7 +142,12 @@ class CrewStructuredTool:
 
         # Create model
         schema_name = f"{name.title()}Schema"
-        return create_model(schema_name, **fields)
+        return create_model(
+            schema_name,
+            __base__=BaseModel,
+            __config__=None,
+            **{k: v for k, v in fields.items()}
+        )
 
     def _validate_function_signature(self) -> None:
         """Validate that the function signature matches the args schema."""
@@ -170,7 +175,7 @@ class CrewStructuredTool:
                         f"not found in args_schema"
                     )
 
-    def _parse_args(self, raw_args: Union[str, dict]) -> dict:
+    def _parse_args(self, raw_args: Union[str, dict[str, Any]]) -> dict[str, Any]:
         """Parse and validate the input arguments against the schema.
 
         Args:
@@ -178,6 +183,9 @@ class CrewStructuredTool:
 
         Returns:
             The validated arguments as a dictionary
+
+        Raises:
+            ValueError: If the arguments cannot be parsed or fail validation
         """
         if isinstance(raw_args, str):
             try:
@@ -195,8 +203,8 @@ class CrewStructuredTool:
 
     async def ainvoke(
         self,
-        input: Union[str, dict],
-        config: Optional[dict] = None,
+        input: Union[str, dict[str, Any]],
+        config: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
         """Asynchronously invoke the tool.
@@ -229,7 +237,10 @@ class CrewStructuredTool:
         return self.invoke(input_dict)
 
     def invoke(
-        self, input: Union[str, dict], config: Optional[dict] = None, **kwargs: Any
+        self,
+        input: Union[str, dict[str, Any]],
+        config: Optional[dict[str, Any]] = None,
+        **kwargs: Any
     ) -> Any:
         """Main method for tool execution."""
         parsed_args = self._parse_args(input)

src/crewai/utilities/internal_instructor.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import Any, Optional, Type
 
 
@@ -25,9 +26,10 @@ class InternalInstructor:
         if self.agent and not self.llm:
             self.llm = self.agent.function_calling_llm or self.agent.llm
 
-        # Lazy import
-        import instructor
-        from litellm import completion
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)
+            import instructor
+            from litellm import completion
 
         self._client = instructor.from_litellm(
             completion,

src/crewai/utilities/logger.py

@@ -10,8 +10,24 @@ class Logger(BaseModel):
     _printer: Printer = PrivateAttr(default_factory=Printer)
 
     def log(self, level, message, color="bold_yellow"):
-        if self.verbose:
+        if self.verbose or level.upper() in ["WARNING", "ERROR"]:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             self._printer.print(
                 f"\n[{timestamp}][{level.upper()}]: {message}", color=color
             )
+
+    def debug(self, message: str) -> None:
+        """Log a debug message if verbose is enabled."""
+        self.log("debug", message, color="bold_blue")
+
+    def info(self, message: str) -> None:
+        """Log an info message if verbose is enabled."""
+        self.log("info", message, color="bold_green")
+
+    def warning(self, message: str) -> None:
+        """Log a warning message."""
+        self.log("warning", message, color="bold_yellow")
+
+    def error(self, message: str) -> None:
+        """Log an error message."""
+        self.log("error", message, color="bold_red")

src/crewai/utilities/planning_handler.py

@@ -1,3 +1,5 @@
+import json
+import logging
 from typing import Any, List, Optional
 
 from pydantic import BaseModel, Field
@@ -5,6 +7,8 @@ from pydantic import BaseModel, Field
 from crewai.agent import Agent
 from crewai.task import Task
 
+logger = logging.getLogger(__name__)
+
 
 class PlanPerTask(BaseModel):
     task: str = Field(..., description="The task for which the plan is created")
@@ -68,19 +72,39 @@ class CrewPlanner:
             output_pydantic=PlannerTaskPydanticOutput,
         )
 
+    def _get_agent_knowledge(self, task: Task) -> List[str]:
+        """
+        Safely retrieve knowledge source content from the task's agent.
+        
+        Args:
+            task: The task containing an agent with potential knowledge sources
+            
+        Returns:
+            List[str]: A list of knowledge source strings
+        """
+        try:
+            if task.agent and task.agent.knowledge_sources:
+                return [source.content for source in task.agent.knowledge_sources]
+        except AttributeError:
+            logger.warning("Error accessing agent knowledge sources")
+        return []
+
     def _create_tasks_summary(self) -> str:
         """Creates a summary of all tasks."""
         tasks_summary = []
         for idx, task in enumerate(self.tasks):
-            tasks_summary.append(
-                f"""
+            knowledge_list = self._get_agent_knowledge(task)
+            task_summary = f"""
                 Task Number {idx + 1} - {task.description}
                 "task_description": {task.description}
                 "task_expected_output": {task.expected_output}
                 "agent": {task.agent.role if task.agent else "None"}
                 "agent_goal": {task.agent.goal if task.agent else "None"}
                 "task_tools": {task.tools}
-                "agent_tools": {task.agent.tools if task.agent else "None"}
-                """
-            )
+                "agent_tools": %s%s""" % (
+                    f"[{', '.join(str(tool) for tool in task.agent.tools)}]" if task.agent and task.agent.tools else '"agent has no tools"',
+                    f',\n                "agent_knowledge": "[\\"{knowledge_list[0]}\\"]"' if knowledge_list and str(knowledge_list) != "None" else ""
+                )
+            
+            tasks_summary.append(task_summary)
         return " ".join(tasks_summary)

src/crewai/utilities/prompts.py

@@ -63,16 +63,32 @@ class Prompts(BaseModel):
                 for component in components
                 if component != "task"
             ]
-            system = system_template.replace("{{ .System }}", "".join(prompt_parts))
-            prompt = prompt_template.replace(
-                "{{ .Prompt }}", "".join(self.i18n.slice("task"))
-            )
-            response = response_template.split("{{ .Response }}")[0]
-            prompt = f"{system}\n{prompt}\n{response}"
+            system = ""
+            if system_template:
+                system = system_template.replace("{{ .System }}", "".join(prompt_parts))
+            
+            prompt_text = ""
+            if prompt_template:
+                prompt_text = prompt_template.replace(
+                    "{{ .Prompt }}", "".join(self.i18n.slice("task"))
+                )
+            
+            response = ""
+            if response_template:
+                response = response_template.split("{{ .Response }}")[0]
+            
+            parts = [p for p in [system, prompt_text, response] if p]
+            prompt = "\n".join(parts) if parts else ""
 
+        # Get agent attributes with default values
+        goal = str(getattr(self.agent, 'goal', '') or '')
+        role = str(getattr(self.agent, 'role', '') or '')
+        backstory = str(getattr(self.agent, 'backstory', '') or '')
+        
+        # Replace placeholders with agent attributes
         prompt = (
-            prompt.replace("{goal}", self.agent.goal)
-            .replace("{role}", self.agent.role)
-            .replace("{backstory}", self.agent.backstory)
+            prompt.replace("{goal}", goal)
+            .replace("{role}", role)
+            .replace("{backstory}", backstory)
         )
         return prompt

src/crewai/utilities/token_counter_callback.py

@@ -1,3 +1,5 @@
+import warnings
+
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.types.utils import Usage
 
@@ -12,11 +14,13 @@ class TokenCalcHandler(CustomLogger):
         if self.token_cost_process is None:
             return
 
-        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
-            )
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)
+            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
+                )

src/crewai/utilities/token_process.py

@@ -0,0 +1,74 @@
+"""Token processing utility for tracking and managing token usage."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union
+
+from crewai.types.usage_metrics import UsageMetrics
+
+
+class TokenProcess:
+    """Handles token processing and tracking for agents."""
+    
+    def __init__(self):
+        """Initialize the token processor."""
+        self._total_tokens = 0
+        self._prompt_tokens = 0
+        self._completion_tokens = 0
+        self._cached_prompt_tokens = 0
+        self._successful_requests = 0
+    
+    def sum_prompt_tokens(self, count: int) -> None:
+        """Add to prompt token count.
+        
+        Args:
+            count (int): Number of prompt tokens to add
+        """
+        self._prompt_tokens += count
+        self._total_tokens += count
+    
+    def sum_completion_tokens(self, count: int) -> None:
+        """Add to completion token count.
+        
+        Args:
+            count (int): Number of completion tokens to add
+        """
+        self._completion_tokens += count
+        self._total_tokens += count
+    
+    def sum_cached_prompt_tokens(self, count: int) -> None:
+        """Add to cached prompt token count.
+        
+        Args:
+            count (int): Number of cached prompt tokens to add
+        """
+        self._cached_prompt_tokens += count
+    
+    def sum_successful_requests(self, count: int) -> None:
+        """Add to successful requests count.
+        
+        Args:
+            count (int): Number of successful requests to add
+        """
+        self._successful_requests += count
+    
+    def reset(self) -> None:
+        """Reset all token counts to zero."""
+        self._total_tokens = 0
+        self._prompt_tokens = 0
+        self._completion_tokens = 0
+        self._cached_prompt_tokens = 0
+        self._successful_requests = 0
+        
+    def get_summary(self) -> UsageMetrics:
+        """Get a summary of token usage.
+        
+        Returns:
+            UsageMetrics: Object containing token usage metrics
+        """
+        return UsageMetrics(
+            total_tokens=self._total_tokens,
+            prompt_tokens=self._prompt_tokens,
+            cached_prompt_tokens=self._cached_prompt_tokens,
+            completion_tokens=self._completion_tokens,
+            successful_requests=self._successful_requests
+        )

tests/agent_test.py

@@ -1445,34 +1445,31 @@ def test_llm_call_with_all_attributes():
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
-def test_agent_with_ollama_gemma():
+def test_agent_with_ollama_llama3():
     agent = Agent(
         role="test role",
         goal="test goal",
         backstory="test backstory",
-        llm=LLM(
-            model="ollama/gemma2:latest",
-            base_url="http://localhost:8080",
-        ),
+        llm=LLM(model="ollama/llama3.2:3b", base_url="http://localhost:11434"),
     )
 
     assert isinstance(agent.llm, LLM)
-    assert agent.llm.model == "ollama/gemma2:latest"
-    assert agent.llm.base_url == "http://localhost:8080"
+    assert agent.llm.model == "ollama/llama3.2:3b"
+    assert agent.llm.base_url == "http://localhost:11434"
 
     task = "Respond in 20 words. Who are you?"
     response = agent.llm.call([{"role": "user", "content": task}])
 
     assert response
     assert len(response.split()) <= 25  # Allow a little flexibility in word count
-    assert "Gemma" in response or "AI" in response or "language model" in response
+    assert "Llama3" in response or "AI" in response or "language model" in response
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
-def test_llm_call_with_ollama_gemma():
+def test_llm_call_with_ollama_llama3():
     llm = LLM(
-        model="ollama/gemma2:latest",
-        base_url="http://localhost:8080",
+        model="ollama/llama3.2:3b",
+        base_url="http://localhost:11434",
         temperature=0.7,
         max_tokens=30,
     )
@@ -1482,7 +1479,7 @@ def test_llm_call_with_ollama_gemma():
 
     assert response
     assert len(response.split()) <= 25  # Allow a little flexibility in word count
-    assert "Gemma" in response or "AI" in response or "language model" in response
+    assert "Llama3" in response or "AI" in response or "language model" in response
 
 
 @pytest.mark.vcr(filter_headers=["authorization"])
@@ -1578,7 +1575,7 @@ def test_agent_execute_task_with_ollama():
         role="test role",
         goal="test goal",
         backstory="test backstory",
-        llm=LLM(model="ollama/gemma2:latest", base_url="http://localhost:8080"),
+        llm=LLM(model="ollama/llama3.2:3b", base_url="http://localhost:11434"),
     )
 
     task = Task(

tests/cassettes/test_agent_execute_task_with_ollama.yaml

@@ -1,42 +1,6 @@
 interactions:
 - request:
-    body: !!binary |
-      CrcCCiQKIgoMc2VydmljZS5uYW1lEhIKEGNyZXdBSS10ZWxlbWV0cnkSjgIKEgoQY3Jld2FpLnRl
-      bGVtZXRyeRJoChA/Q8UW5bidCRtKvri5fOaNEgh5qLzvLvZJkioQVG9vbCBVc2FnZSBFcnJvcjAB
-      OYjFVQr1TPgXQXCXhwr1TPgXShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuNjEuMHoCGAGFAQABAAAS
-      jQEKEChQTWQ07t26ELkZmP5RresSCHEivRGBpsP7KgpUb29sIFVzYWdlMAE5sKkbC/VM+BdB8MIc
-      C/VM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoGMC42MS4wShkKCXRvb2xfbmFtZRIMCgpkdW1teV90
-      b29sSg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAA=
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '314'
-      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:
-      - Tue, 24 Sep 2024 21:57:54 GMT
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"model": "gemma2:latest", "prompt": "### System:\nYou are test role. test
+    body: '{"model": "llama3.2:3b", "prompt": "### System:\nYou are test role. test
       backstory\nYour personal goal is: test goal\nTo give my best complete final
       answer to the task use the exact following format:\n\nThought: I now can give
       a great answer\nFinal Answer: Your final answer must be the great and the most
@@ -46,36 +10,864 @@ interactions:
       explanation of AI\nyou MUST return the actual complete content as the final
       answer, not a summary.\n\nBegin! This is VERY important to you, use the tools
       available and give your best Final Answer, your job depends on it!\n\nThought:\n\n",
-      "options": {}, "stream": false}'
+      "options": {"stop": ["\nObservation:"]}, "stream": false}'
     headers:
-      Accept:
+      accept:
       - '*/*'
-      Accept-Encoding:
+      accept-encoding:
       - gzip, deflate
-      Connection:
+      connection:
       - keep-alive
-      Content-Length:
-      - '815'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - python-requests/2.31.0
+      content-length:
+      - '839'
+      host:
+      - localhost:11434
+      user-agent:
+      - litellm/1.56.4
     method: POST
-    uri: http://localhost:8080/api/generate
+    uri: http://localhost:11434/api/generate
   response:
-    body:
-      string: '{"model":"gemma2:latest","created_at":"2024-09-24T21:57:55.835715Z","response":"Thought:
-        I can explain AI in one sentence. \n\nFinal Answer: Artificial intelligence
-        (AI) is the ability of computer systems to perform tasks that typically require
-        human intelligence, such as learning, problem-solving, and decision-making.  \n","done":true,"done_reason":"stop","context":[106,1645,108,6176,1479,235292,108,2045,708,2121,4731,235265,2121,135147,108,6922,3749,6789,603,235292,2121,6789,108,1469,2734,970,1963,3407,2048,3448,577,573,6911,1281,573,5463,2412,5920,235292,109,65366,235292,590,1490,798,2734,476,1775,3448,108,11263,10358,235292,3883,2048,3448,2004,614,573,1775,578,573,1546,3407,685,3077,235269,665,2004,614,17526,6547,235265,109,235285,44472,1281,1450,32808,235269,970,3356,12014,611,665,235341,109,6176,4926,235292,109,6846,12297,235292,36576,1212,16481,603,575,974,13060,109,1596,603,573,5246,12830,604,861,2048,3448,235292,586,974,235290,47366,15844,576,16481,108,4747,44472,2203,573,5579,3407,3381,685,573,2048,3448,235269,780,476,13367,235265,109,12694,235341,1417,603,50471,2845,577,692,235269,1281,573,8112,2506,578,2734,861,1963,14124,10358,235269,861,3356,12014,611,665,235341,109,65366,235292,109,107,108,106,2516,108,65366,235292,590,798,10200,16481,575,974,13060,235265,235248,109,11263,10358,235292,42456,17273,591,11716,235275,603,573,7374,576,6875,5188,577,3114,13333,674,15976,2817,3515,17273,235269,1582,685,6044,235269,3210,235290,60495,235269,578,4530,235290,14577,235265,139,108],"total_duration":3370959792,"load_duration":20611750,"prompt_eval_count":173,"prompt_eval_duration":688036000,"eval_count":51,"eval_duration":2660291000}'
+    content: '{"model":"llama3.2:3b","created_at":"2024-12-31T16:56:15.759718Z","response":"Final
+      Answer: Artificial Intelligence (AI) refers to the development of computer systems
+      able to perform tasks that typically require human intelligence, including learning,
+      problem-solving, decision-making, and perception.","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,744,512,2675,527,1296,3560,13,1296,93371,198,7927,4443,5915,374,25,1296,5915,198,1271,3041,856,1888,4686,1620,4320,311,279,3465,1005,279,4839,2768,3645,1473,85269,25,358,1457,649,3041,264,2294,4320,198,19918,22559,25,4718,1620,4320,2011,387,279,2294,323,279,1455,4686,439,3284,11,433,2011,387,15632,7633,382,40,28832,1005,1521,20447,11,856,2683,14117,389,433,2268,14711,2724,1473,5520,5546,25,83017,1148,15592,374,304,832,11914,271,2028,374,279,1755,13186,369,701,1620,4320,25,362,832,1355,18886,16540,315,15592,198,9514,28832,471,279,5150,4686,2262,439,279,1620,4320,11,539,264,12399,382,11382,0,1115,374,48174,3062,311,499,11,1005,279,7526,2561,323,3041,701,1888,13321,22559,11,701,2683,14117,389,433,2268,85269,1473,128009,128006,78191,128007,271,19918,22559,25,59294,22107,320,15836,8,19813,311,279,4500,315,6500,6067,3025,311,2804,9256,430,11383,1397,3823,11478,11,2737,6975,11,3575,99246,11,5597,28846,11,323,21063,13],"total_duration":1156303250,"load_duration":35999125,"prompt_eval_count":181,"prompt_eval_duration":408000000,"eval_count":38,"eval_duration":711000000}'
     headers:
       Content-Length:
-      - '1662'
+      - '1528'
       Content-Type:
       - application/json; charset=utf-8
       Date:
-      - Tue, 24 Sep 2024 21:57:55 GMT
-    status:
-      code: 200
-      message: OK
+      - Tue, 31 Dec 2024 16:56:15 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.56.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:
+      - Tue, 31 Dec 2024 16:56:15 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.56.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:
+      - Tue, 31 Dec 2024 16:56:15 GMT
+      Transfer-Encoding:
+      - chunked
+    http_version: HTTP/1.1
+    status_code: 200
 version: 1

tests/cassettes/test_agent_with_ollama_gemma.yaml

@@ -1,397 +0,0 @@
-interactions:
-- request:
-    body: !!binary |
-      CumTAQokCiIKDHNlcnZpY2UubmFtZRISChBjcmV3QUktdGVsZW1ldHJ5Er+TAQoSChBjcmV3YWku
-      dGVsZW1ldHJ5EqoHChDvqD2QZooz9BkEwtbWjp4OEgjxh72KACHvZSoMQ3JldyBDcmVhdGVkMAE5
-      qMhNnvBM+BdBcO9PnvBM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoGMC42MS4wShoKDnB5dGhvbl92
-      ZXJzaW9uEggKBjMuMTEuN0ouCghjcmV3X2tleRIiCiBkNTUxMTNiZTRhYTQxYmE2NDNkMzI2MDQy
-      YjJmMDNmMUoxCgdjcmV3X2lkEiYKJGY4YTA1OTA1LTk0OGEtNDQ0YS04NmJmLTJiNTNiNDkyYjgy
-      MkocCgxjcmV3X3Byb2Nlc3MSDAoKc2VxdWVudGlhbEoRCgtjcmV3X21lbW9yeRICEABKGgoUY3Jl
-      d19udW1iZXJfb2ZfdGFza3MSAhgBShsKFWNyZXdfbnVtYmVyX29mX2FnZW50cxICGAFKxwIKC2Ny
-      ZXdfYWdlbnRzErcCCrQCW3sia2V5IjogImUxNDhlNTMyMDI5MzQ5OWY4Y2ViZWE4MjZlNzI1ODJi
-      IiwgImlkIjogIjg1MGJjNWUwLTk4NTctNDhkOC1iNWZlLTJmZjk2OWExYTU3YiIsICJyb2xlIjog
-      InRlc3Qgcm9sZSIsICJ2ZXJib3NlPyI6IHRydWUsICJtYXhfaXRlciI6IDQsICJtYXhfcnBtIjog
-      MTAsICJmdW5jdGlvbl9jYWxsaW5nX2xsbSI6ICIiLCAibGxtIjogImdwdC00byIsICJkZWxlZ2F0
-      aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1h
-      eF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1KkAIKCmNyZXdfdGFza3MSgQIK
-      /gFbeyJrZXkiOiAiNGEzMWI4NTEzM2EzYTI5NGM2ODUzZGE3NTdkNGJhZTciLCAiaWQiOiAiOTc1
-      ZDgwMjItMWJkMS00NjBlLTg2NmEtYjJmZGNiYjA4ZDliIiwgImFzeW5jX2V4ZWN1dGlvbj8iOiBm
-      YWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJ0ZXN0IHJvbGUiLCAi
-      YWdlbnRfa2V5IjogImUxNDhlNTMyMDI5MzQ5OWY4Y2ViZWE4MjZlNzI1ODJiIiwgInRvb2xzX25h
-      bWVzIjogWyJnZXRfZmluYWxfYW5zd2VyIl19XXoCGAGFAQABAAASjgIKEP9UYSAOFQbZquSppN1j
-      IeUSCAgZmXUoJKFmKgxUYXNrIENyZWF0ZWQwATloPV+e8Ez4F0GYsl+e8Ez4F0ouCghjcmV3X2tl
-      eRIiCiBkNTUxMTNiZTRhYTQxYmE2NDNkMzI2MDQyYjJmMDNmMUoxCgdjcmV3X2lkEiYKJGY4YTA1
-      OTA1LTk0OGEtNDQ0YS04NmJmLTJiNTNiNDkyYjgyMkouCgh0YXNrX2tleRIiCiA0YTMxYjg1MTMz
-      YTNhMjk0YzY4NTNkYTc1N2Q0YmFlN0oxCgd0YXNrX2lkEiYKJDk3NWQ4MDIyLTFiZDEtNDYwZS04
-      NjZhLWIyZmRjYmIwOGQ5YnoCGAGFAQABAAASkwEKEEfiywgqgiUXE3KoUbrnHDQSCGmv+iM7Wc1Z
-      KgpUb29sIFVzYWdlMAE5kOybnvBM+BdBIM+cnvBM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoGMC42
-      MS4wSh8KCXRvb2xfbmFtZRISChBnZXRfZmluYWxfYW5zd2VySg4KCGF0dGVtcHRzEgIYAXoCGAGF
-      AQABAAASkwEKEH7AHXpfmvwIkA45HB8YyY0SCAFRC+uJpsEZKgpUb29sIFVzYWdlMAE56PLdnvBM
-      +BdBYFbfnvBM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoGMC42MS4wSh8KCXRvb2xfbmFtZRISChBn
-      ZXRfZmluYWxfYW5zd2VySg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAASkwEKEIDKKEbYU4lcJF+a
-      WsAVZwESCI+/La7oL86MKgpUb29sIFVzYWdlMAE5yIkgn/BM+BdBWGwhn/BM+BdKGgoOY3Jld2Fp
-      X3ZlcnNpb24SCAoGMC42MS4wSh8KCXRvb2xfbmFtZRISChBnZXRfZmluYWxfYW5zd2VySg4KCGF0
-      dGVtcHRzEgIYAXoCGAGFAQABAAASnAEKEMTZ2IhpLz6J2hJhHBQ8/M4SCEuWz+vjzYifKhNUb29s
-      IFJlcGVhdGVkIFVzYWdlMAE5mAVhn/BM+BdBKOhhn/BM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoG
-      MC42MS4wSh8KCXRvb2xfbmFtZRISChBnZXRfZmluYWxfYW5zd2VySg4KCGF0dGVtcHRzEgIYAXoC
-      GAGFAQABAAASkAIKED8C+t95p855kLcXs5Nnt/sSCM4XAhL6u8O8Kg5UYXNrIEV4ZWN1dGlvbjAB
-      OdD8X57wTPgXQUgno5/wTPgXSi4KCGNyZXdfa2V5EiIKIGQ1NTExM2JlNGFhNDFiYTY0M2QzMjYw
-      NDJiMmYwM2YxSjEKB2NyZXdfaWQSJgokZjhhMDU5MDUtOTQ4YS00NDRhLTg2YmYtMmI1M2I0OTJi
-      ODIySi4KCHRhc2tfa2V5EiIKIDRhMzFiODUxMzNhM2EyOTRjNjg1M2RhNzU3ZDRiYWU3SjEKB3Rh
-      c2tfaWQSJgokOTc1ZDgwMjItMWJkMS00NjBlLTg2NmEtYjJmZGNiYjA4ZDliegIYAYUBAAEAABLO
-      CwoQFlnZCfbZ3Dj0L9TAE5LrLBIIoFr7BZErFNgqDENyZXcgQ3JlYXRlZDABOVhDDaDwTPgXQSg/
-      D6DwTPgXShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuNjEuMEoaCg5weXRob25fdmVyc2lvbhIICgYz
-      LjExLjdKLgoIY3Jld19rZXkSIgogOTRjMzBkNmMzYjJhYzhmYjk0YjJkY2ZjNTcyZDBmNTlKMQoH
-      Y3Jld19pZBImCiQyMzM2MzRjNi1lNmQ2LTQ5ZTYtODhhZS1lYWUxYTM5YjBlMGZKHAoMY3Jld19w
-      cm9jZXNzEgwKCnNlcXVlbnRpYWxKEQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29m
-      X3Rhc2tzEgIYAkobChVjcmV3X251bWJlcl9vZl9hZ2VudHMSAhgCSv4ECgtjcmV3X2FnZW50cxLu
-      BArrBFt7ImtleSI6ICJlMTQ4ZTUzMjAyOTM0OTlmOGNlYmVhODI2ZTcyNTgyYiIsICJpZCI6ICI0
-      MjAzZjIyYi0wNWM3LTRiNjUtODBjMS1kM2Y0YmFlNzZhNDYiLCAicm9sZSI6ICJ0ZXN0IHJvbGUi
-      LCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAyLCAibWF4X3JwbSI6IDEwLCAiZnVuY3Rp
-      b25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8iLCAiZGVsZWdhdGlvbl9lbmFibGVk
-      PyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGlt
-      aXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX0sIHsia2V5IjogImU3ZThlZWE4ODZiY2I4ZjEwNDVh
-      YmVlY2YxNDI1ZGI3IiwgImlkIjogImZjOTZjOTQ1LTY4ZDUtNDIxMy05NmNkLTNmYTAwNmUyZTYz
-      MCIsICJyb2xlIjogInRlc3Qgcm9sZTIiLCAidmVyYm9zZT8iOiB0cnVlLCAibWF4X2l0ZXIiOiAx
-      LCAibWF4X3JwbSI6IG51bGwsICJmdW5jdGlvbl9jYWxsaW5nX2xsbSI6ICIiLCAibGxtIjogImdw
-      dC00byIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19jb2RlX2V4ZWN1dGlv
-      bj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1lcyI6IFtdfV1K/QMK
-      CmNyZXdfdGFza3MS7gMK6wNbeyJrZXkiOiAiMzIyZGRhZTNiYzgwYzFkNDViODVmYTc3NTZkYjg2
-      NjUiLCAiaWQiOiAiOTVjYTg4NDItNmExMi00MGQ5LWIwZDItNGI0MzYxYmJlNTZkIiwgImFzeW5j
-      X2V4ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6
-      ICJ0ZXN0IHJvbGUiLCAiYWdlbnRfa2V5IjogImUxNDhlNTMyMDI5MzQ5OWY4Y2ViZWE4MjZlNzI1
-      ODJiIiwgInRvb2xzX25hbWVzIjogW119LCB7ImtleSI6ICI1ZTljYTdkNjRiNDIwNWJiN2M0N2Uw
-      YjNmY2I1ZDIxZiIsICJpZCI6ICI5NzI5MTg2Yy1kN2JlLTRkYjQtYTk0ZS02OWU5OTk2NTI3MDAi
-      LCAiYXN5bmNfZXhlY3V0aW9uPyI6IGZhbHNlLCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2Vu
-      dF9yb2xlIjogInRlc3Qgcm9sZTIiLCAiYWdlbnRfa2V5IjogImU3ZThlZWE4ODZiY2I4ZjEwNDVh
-      YmVlY2YxNDI1ZGI3IiwgInRvb2xzX25hbWVzIjogWyJnZXRfZmluYWxfYW5zd2VyIl19XXoCGAGF
-      AQABAAASjgIKEC/YM2OukRrSg+ZAev4VhGESCOQ5RvzSS5IEKgxUYXNrIENyZWF0ZWQwATmQJx6g
-      8Ez4F0EgjR6g8Ez4F0ouCghjcmV3X2tleRIiCiA5NGMzMGQ2YzNiMmFjOGZiOTRiMmRjZmM1NzJk
-      MGY1OUoxCgdjcmV3X2lkEiYKJDIzMzYzNGM2LWU2ZDYtNDllNi04OGFlLWVhZTFhMzliMGUwZkou
-      Cgh0YXNrX2tleRIiCiAzMjJkZGFlM2JjODBjMWQ0NWI4NWZhNzc1NmRiODY2NUoxCgd0YXNrX2lk
-      EiYKJDk1Y2E4ODQyLTZhMTItNDBkOS1iMGQyLTRiNDM2MWJiZTU2ZHoCGAGFAQABAAASkAIKEHqZ
-      L8s3clXQyVTemNcTCcQSCA0tzK95agRQKg5UYXNrIEV4ZWN1dGlvbjABOQC8HqDwTPgXQdgNSqDw
-      TPgXSi4KCGNyZXdfa2V5EiIKIDk0YzMwZDZjM2IyYWM4ZmI5NGIyZGNmYzU3MmQwZjU5SjEKB2Ny
-      ZXdfaWQSJgokMjMzNjM0YzYtZTZkNi00OWU2LTg4YWUtZWFlMWEzOWIwZTBmSi4KCHRhc2tfa2V5
-      EiIKIDMyMmRkYWUzYmM4MGMxZDQ1Yjg1ZmE3NzU2ZGI4NjY1SjEKB3Rhc2tfaWQSJgokOTVjYTg4
-      NDItNmExMi00MGQ5LWIwZDItNGI0MzYxYmJlNTZkegIYAYUBAAEAABKOAgoQjhKzodMUmQ8NWtdy
-      Uj99whIIBsGtAymZibwqDFRhc2sgQ3JlYXRlZDABOXjVVaDwTPgXQXhSVqDwTPgXSi4KCGNyZXdf
-      a2V5EiIKIDk0YzMwZDZjM2IyYWM4ZmI5NGIyZGNmYzU3MmQwZjU5SjEKB2NyZXdfaWQSJgokMjMz
-      NjM0YzYtZTZkNi00OWU2LTg4YWUtZWFlMWEzOWIwZTBmSi4KCHRhc2tfa2V5EiIKIDVlOWNhN2Q2
-      NGI0MjA1YmI3YzQ3ZTBiM2ZjYjVkMjFmSjEKB3Rhc2tfaWQSJgokOTcyOTE4NmMtZDdiZS00ZGI0
-      LWE5NGUtNjllOTk5NjUyNzAwegIYAYUBAAEAABKTAQoQx5IUsjAFMGNUaz5MHy20OBIIzl2tr25P
-      LL8qClRvb2wgVXNhZ2UwATkgt5Sg8Ez4F0GwFpag8Ez4F0oaCg5jcmV3YWlfdmVyc2lvbhIICgYw
-      LjYxLjBKHwoJdG9vbF9uYW1lEhIKEGdldF9maW5hbF9hbnN3ZXJKDgoIYXR0ZW1wdHMSAhgBegIY
-      AYUBAAEAABKQAgoQEkfcfCrzTYIM6GQXhknlexIIa/oxeT78OL8qDlRhc2sgRXhlY3V0aW9uMAE5
-      WIFWoPBM+BdBuL/GoPBM+BdKLgoIY3Jld19rZXkSIgogOTRjMzBkNmMzYjJhYzhmYjk0YjJkY2Zj
-      NTcyZDBmNTlKMQoHY3Jld19pZBImCiQyMzM2MzRjNi1lNmQ2LTQ5ZTYtODhhZS1lYWUxYTM5YjBl
-      MGZKLgoIdGFza19rZXkSIgogNWU5Y2E3ZDY0YjQyMDViYjdjNDdlMGIzZmNiNWQyMWZKMQoHdGFz
-      a19pZBImCiQ5NzI5MTg2Yy1kN2JlLTRkYjQtYTk0ZS02OWU5OTk2NTI3MDB6AhgBhQEAAQAAEqwH
-      ChDrKBdEe+Z5276g9fgg6VzjEgiJfnDwsv1SrCoMQ3JldyBDcmVhdGVkMAE5MLQYofBM+BdBQFIa
-      ofBM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoGMC42MS4wShoKDnB5dGhvbl92ZXJzaW9uEggKBjMu
-      MTEuN0ouCghjcmV3X2tleRIiCiA3M2FhYzI4NWU2NzQ2NjY3Zjc1MTQ3NjcwMDAzNDExMEoxCgdj
-      cmV3X2lkEiYKJDg0NDY0YjhlLTRiZjctNDRiYy05MmUxLWE4ZDE1NGZlNWZkN0ocCgxjcmV3X3By
-      b2Nlc3MSDAoKc2VxdWVudGlhbEoRCgtjcmV3X21lbW9yeRICEABKGgoUY3Jld19udW1iZXJfb2Zf
-      dGFza3MSAhgBShsKFWNyZXdfbnVtYmVyX29mX2FnZW50cxICGAFKyQIKC2NyZXdfYWdlbnRzErkC
-      CrYCW3sia2V5IjogImUxNDhlNTMyMDI5MzQ5OWY4Y2ViZWE4MjZlNzI1ODJiIiwgImlkIjogIjk4
-      YmIwNGYxLTBhZGMtNGZiNC04YzM2LWM3M2Q1MzQ1ZGRhZCIsICJyb2xlIjogInRlc3Qgcm9sZSIs
-      ICJ2ZXJib3NlPyI6IHRydWUsICJtYXhfaXRlciI6IDEsICJtYXhfcnBtIjogbnVsbCwgImZ1bmN0
-      aW9uX2NhbGxpbmdfbGxtIjogIiIsICJsbG0iOiAiZ3B0LTRvIiwgImRlbGVnYXRpb25fZW5hYmxl
-      ZD8iOiBmYWxzZSwgImFsbG93X2NvZGVfZXhlY3V0aW9uPyI6IGZhbHNlLCAibWF4X3JldHJ5X2xp
-      bWl0IjogMiwgInRvb2xzX25hbWVzIjogW119XUqQAgoKY3Jld190YXNrcxKBAgr+AVt7ImtleSI6
-      ICJmN2E5ZjdiYjFhZWU0YjZlZjJjNTI2ZDBhOGMyZjJhYyIsICJpZCI6ICIxZjRhYzJhYS03YmQ4
-      LTQ1NWQtODgyMC1jMzZmMjJjMDY4MzciLCAiYXN5bmNfZXhlY3V0aW9uPyI6IGZhbHNlLCAiaHVt
-      YW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9yb2xlIjogInRlc3Qgcm9sZSIsICJhZ2VudF9rZXki
-      OiAiZTE0OGU1MzIwMjkzNDk5ZjhjZWJlYTgyNmU3MjU4MmIiLCAidG9vbHNfbmFtZXMiOiBbImdl
-      dF9maW5hbF9hbnN3ZXIiXX1degIYAYUBAAEAABKOAgoQ0/vrakH7zD0uSvmVBUV8lxIIYe4YKcYG
-      hNgqDFRhc2sgQ3JlYXRlZDABOdBXKqHwTPgXQcCtKqHwTPgXSi4KCGNyZXdfa2V5EiIKIDczYWFj
-      Mjg1ZTY3NDY2NjdmNzUxNDc2NzAwMDM0MTEwSjEKB2NyZXdfaWQSJgokODQ0NjRiOGUtNGJmNy00
-      NGJjLTkyZTEtYThkMTU0ZmU1ZmQ3Si4KCHRhc2tfa2V5EiIKIGY3YTlmN2JiMWFlZTRiNmVmMmM1
-      MjZkMGE4YzJmMmFjSjEKB3Rhc2tfaWQSJgokMWY0YWMyYWEtN2JkOC00NTVkLTg4MjAtYzM2ZjIy
-      YzA2ODM3egIYAYUBAAEAABKkAQoQ5GDzHNlSdlcVDdxsI3abfRIIhYu8fZS3iA4qClRvb2wgVXNh
-      Z2UwATnIi2eh8Ez4F0FYbmih8Ez4F0oaCg5jcmV3YWlfdmVyc2lvbhIICgYwLjYxLjBKHwoJdG9v
-      bF9uYW1lEhIKEGdldF9maW5hbF9hbnN3ZXJKDgoIYXR0ZW1wdHMSAhgBSg8KA2xsbRIICgZncHQt
-      NG96AhgBhQEAAQAAEpACChAy85Jfr/EEIe1THU8koXoYEgjlkNn7xfysjioOVGFzayBFeGVjdXRp
-      b24wATm42Cqh8Ez4F0GgxZah8Ez4F0ouCghjcmV3X2tleRIiCiA3M2FhYzI4NWU2NzQ2NjY3Zjc1
-      MTQ3NjcwMDAzNDExMEoxCgdjcmV3X2lkEiYKJDg0NDY0YjhlLTRiZjctNDRiYy05MmUxLWE4ZDE1
-      NGZlNWZkN0ouCgh0YXNrX2tleRIiCiBmN2E5ZjdiYjFhZWU0YjZlZjJjNTI2ZDBhOGMyZjJhY0ox
-      Cgd0YXNrX2lkEiYKJDFmNGFjMmFhLTdiZDgtNDU1ZC04ODIwLWMzNmYyMmMwNjgzN3oCGAGFAQAB
-      AAASrAcKEG0ZVq5Ww+/A0wOY3HmKgq4SCMe0ooxqjqBlKgxDcmV3IENyZWF0ZWQwATlwmISi8Ez4
-      F0HYUYai8Ez4F0oaCg5jcmV3YWlfdmVyc2lvbhIICgYwLjYxLjBKGgoOcHl0aG9uX3ZlcnNpb24S
-      CAoGMy4xMS43Si4KCGNyZXdfa2V5EiIKIGQ1NTExM2JlNGFhNDFiYTY0M2QzMjYwNDJiMmYwM2Yx
-      SjEKB2NyZXdfaWQSJgokNzkyMWVlYmItMWI4NS00MzNjLWIxMDAtZDU4MmMyOTg5MzBkShwKDGNy
-      ZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251bWJl
-      cl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1iZXJfb2ZfYWdlbnRzEgIYAUrJAgoLY3Jld19hZ2Vu
-      dHMSuQIKtgJbeyJrZXkiOiAiZTE0OGU1MzIwMjkzNDk5ZjhjZWJlYTgyNmU3MjU4MmIiLCAiaWQi
-      OiAiZmRiZDI1MWYtYzUwOC00YmFhLTkwNjctN2U5YzQ2ZGZiZTJhIiwgInJvbGUiOiAidGVzdCBy
-      b2xlIiwgInZlcmJvc2U/IjogdHJ1ZSwgIm1heF9pdGVyIjogNiwgIm1heF9ycG0iOiBudWxsLCAi
-      ZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8iLCAiZGVsZWdhdGlvbl9l
-      bmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0
-      cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dSpACCgpjcmV3X3Rhc2tzEoECCv4BW3si
-      a2V5IjogIjRhMzFiODUxMzNhM2EyOTRjNjg1M2RhNzU3ZDRiYWU3IiwgImlkIjogIjA2YWFmM2Y1
-      LTE5ODctNDAxYS05Yzk0LWY3ZjM1YmQzMDg3OSIsICJhc3luY19leGVjdXRpb24/IjogZmFsc2Us
-      ICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAidGVzdCByb2xlIiwgImFnZW50
-      X2tleSI6ICJlMTQ4ZTUzMjAyOTM0OTlmOGNlYmVhODI2ZTcyNTgyYiIsICJ0b29sc19uYW1lcyI6
-      IFsiZ2V0X2ZpbmFsX2Fuc3dlciJdfV16AhgBhQEAAQAAEo4CChDT+zPZHwfacDilkzaZJ9uGEgip
-      Kr5r62JB+ioMVGFzayBDcmVhdGVkMAE56KeTovBM+BdB8PmTovBM+BdKLgoIY3Jld19rZXkSIgog
-      ZDU1MTEzYmU0YWE0MWJhNjQzZDMyNjA0MmIyZjAzZjFKMQoHY3Jld19pZBImCiQ3OTIxZWViYi0x
-      Yjg1LTQzM2MtYjEwMC1kNTgyYzI5ODkzMGRKLgoIdGFza19rZXkSIgogNGEzMWI4NTEzM2EzYTI5
-      NGM2ODUzZGE3NTdkNGJhZTdKMQoHdGFza19pZBImCiQwNmFhZjNmNS0xOTg3LTQwMWEtOWM5NC1m
-      N2YzNWJkMzA4Nzl6AhgBhQEAAQAAEpMBChCl85ZcL2Fa0N5QTl6EsIfnEghyDo3bxT+AkyoKVG9v
-      bCBVc2FnZTABOVBA2aLwTPgXQYAy2qLwTPgXShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuNjEuMEof
-      Cgl0b29sX25hbWUSEgoQZ2V0X2ZpbmFsX2Fuc3dlckoOCghhdHRlbXB0cxICGAF6AhgBhQEAAQAA
-      EpwBChB22uwKhaur9zmeoeEMaRKzEgjrtSEzMbRdIioTVG9vbCBSZXBlYXRlZCBVc2FnZTABOQga
-      C6PwTPgXQaDRC6PwTPgXShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuNjEuMEofCgl0b29sX25hbWUS
-      EgoQZ2V0X2ZpbmFsX2Fuc3dlckoOCghhdHRlbXB0cxICGAF6AhgBhQEAAQAAEpMBChArAfcRpE+W
-      02oszyzccbaWEghTAO9J3zq/kyoKVG9vbCBVc2FnZTABORBRTqPwTPgXQegnT6PwTPgXShoKDmNy
-      ZXdhaV92ZXJzaW9uEggKBjAuNjEuMEofCgl0b29sX25hbWUSEgoQZ2V0X2ZpbmFsX2Fuc3dlckoO
-      CghhdHRlbXB0cxICGAF6AhgBhQEAAQAAEpwBChBdtM3p3aqT7wTGaXi6el/4Egie6lFQpa+AfioT
-      VG9vbCBSZXBlYXRlZCBVc2FnZTABOdBg2KPwTPgXQehW2aPwTPgXShoKDmNyZXdhaV92ZXJzaW9u
-      EggKBjAuNjEuMEofCgl0b29sX25hbWUSEgoQZ2V0X2ZpbmFsX2Fuc3dlckoOCghhdHRlbXB0cxIC
-      GAF6AhgBhQEAAQAAEpMBChDq4OuaUKkNoi6jlMyahPJpEgg1MFDHktBxNSoKVG9vbCBVc2FnZTAB
-      ORD/K6TwTPgXQZgMLaTwTPgXShoKDmNyZXdhaV92ZXJzaW9uEggKBjAuNjEuMEofCgl0b29sX25h
-      bWUSEgoQZ2V0X2ZpbmFsX2Fuc3dlckoOCghhdHRlbXB0cxICGAF6AhgBhQEAAQAAEpACChBhvTmu
-      QWP+bx9JMmGpt+w5Egh1J17yki7s8ioOVGFzayBFeGVjdXRpb24wATnoJJSi8Ez4F0HwNX6k8Ez4
-      F0ouCghjcmV3X2tleRIiCiBkNTUxMTNiZTRhYTQxYmE2NDNkMzI2MDQyYjJmMDNmMUoxCgdjcmV3
-      X2lkEiYKJDc5MjFlZWJiLTFiODUtNDMzYy1iMTAwLWQ1ODJjMjk4OTMwZEouCgh0YXNrX2tleRIi
-      CiA0YTMxYjg1MTMzYTNhMjk0YzY4NTNkYTc1N2Q0YmFlN0oxCgd0YXNrX2lkEiYKJDA2YWFmM2Y1
-      LTE5ODctNDAxYS05Yzk0LWY3ZjM1YmQzMDg3OXoCGAGFAQABAAASrg0KEOJZEqiJ7LTTX/J+tuLR
-      stQSCHKjy4tIcmKEKgxDcmV3IENyZWF0ZWQwATmIEuGk8Ez4F0FYDuOk8Ez4F0oaCg5jcmV3YWlf
-      dmVyc2lvbhIICgYwLjYxLjBKGgoOcHl0aG9uX3ZlcnNpb24SCAoGMy4xMS43Si4KCGNyZXdfa2V5
-      EiIKIDExMWI4NzJkOGYwY2Y3MDNmMmVmZWYwNGNmM2FjNzk4SjEKB2NyZXdfaWQSJgokYWFiYmU5
-      MmQtYjg3NC00NTZmLWE0NzAtM2FmMDc4ZTdjYThlShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50
-      aWFsShEKC2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251bWJlcl9vZl90YXNrcxICGANKGwoVY3Jl
-      d19udW1iZXJfb2ZfYWdlbnRzEgIYAkqEBQoLY3Jld19hZ2VudHMS9AQK8QRbeyJrZXkiOiAiZTE0
-      OGU1MzIwMjkzNDk5ZjhjZWJlYTgyNmU3MjU4MmIiLCAiaWQiOiAiZmYzOTE0OGEtZWI2NS00Nzkx
-      LWI3MTMtM2Q4ZmE1YWQ5NTJlIiwgInJvbGUiOiAidGVzdCByb2xlIiwgInZlcmJvc2U/IjogZmFs
-      c2UsICJtYXhfaXRlciI6IDE1LCAibWF4X3JwbSI6IG51bGwsICJmdW5jdGlvbl9jYWxsaW5nX2xs
-      bSI6ICIiLCAibGxtIjogImdwdC00byIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJh
-      bGxvd19jb2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29s
-      c19uYW1lcyI6IFtdfSwgeyJrZXkiOiAiZTdlOGVlYTg4NmJjYjhmMTA0NWFiZWVjZjE0MjVkYjci
-      LCAiaWQiOiAiYzYyNDJmNDMtNmQ2Mi00N2U4LTliYmMtNjM0ZDQwYWI4YTQ2IiwgInJvbGUiOiAi
-      dGVzdCByb2xlMiIsICJ2ZXJib3NlPyI6IGZhbHNlLCAibWF4X2l0ZXIiOiAxNSwgIm1heF9ycG0i
-      OiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8iLCAiZGVs
-      ZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2Us
-      ICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMiOiBbXX1dStcFCgpjcmV3X3Rhc2tz
-      EsgFCsUFW3sia2V5IjogIjMyMmRkYWUzYmM4MGMxZDQ1Yjg1ZmE3NzU2ZGI4NjY1IiwgImlkIjog
-      IjRmZDZhZDdiLTFjNWMtNDE1ZC1hMWQ4LTgwYzExZGNjMTY4NiIsICJhc3luY19leGVjdXRpb24/
-      IjogZmFsc2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAidGVzdCByb2xl
-      IiwgImFnZW50X2tleSI6ICJlMTQ4ZTUzMjAyOTM0OTlmOGNlYmVhODI2ZTcyNTgyYiIsICJ0b29s
-      c19uYW1lcyI6IFtdfSwgeyJrZXkiOiAiY2M0ODc2ZjZlNTg4ZTcxMzQ5YmJkM2E2NTg4OGMzZTki
-      LCAiaWQiOiAiOTFlYWFhMWMtMWI4ZC00MDcxLTk2ZmQtM2QxZWVkMjhjMzZjIiwgImFzeW5jX2V4
-      ZWN1dGlvbj8iOiBmYWxzZSwgImh1bWFuX2lucHV0PyI6IGZhbHNlLCAiYWdlbnRfcm9sZSI6ICJ0
-      ZXN0IHJvbGUiLCAiYWdlbnRfa2V5IjogImUxNDhlNTMyMDI5MzQ5OWY4Y2ViZWE4MjZlNzI1ODJi
-      IiwgInRvb2xzX25hbWVzIjogW119LCB7ImtleSI6ICJlMGIxM2UxMGQ3YTE0NmRjYzRjNDg4ZmNm
-      OGQ3NDhhMCIsICJpZCI6ICI4NjExZjhjZS1jNDVlLTQ2OTgtYWEyMS1jMGJkNzdhOGY2ZWYiLCAi
-      YXN5bmNfZXhlY3V0aW9uPyI6IGZhbHNlLCAiaHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9y
-      b2xlIjogInRlc3Qgcm9sZTIiLCAiYWdlbnRfa2V5IjogImU3ZThlZWE4ODZiY2I4ZjEwNDVhYmVl
-      Y2YxNDI1ZGI3IiwgInRvb2xzX25hbWVzIjogW119XXoCGAGFAQABAAASjgIKEMbX6YsWK7RRf4L1
-      NBRKD6cSCFLJiNmspsyjKgxUYXNrIENyZWF0ZWQwATnonPGk8Ez4F0EotvKk8Ez4F0ouCghjcmV3
-      X2tleRIiCiAxMTFiODcyZDhmMGNmNzAzZjJlZmVmMDRjZjNhYzc5OEoxCgdjcmV3X2lkEiYKJGFh
-      YmJlOTJkLWI4NzQtNDU2Zi1hNDcwLTNhZjA3OGU3Y2E4ZUouCgh0YXNrX2tleRIiCiAzMjJkZGFl
-      M2JjODBjMWQ0NWI4NWZhNzc1NmRiODY2NUoxCgd0YXNrX2lkEiYKJDRmZDZhZDdiLTFjNWMtNDE1
-      ZC1hMWQ4LTgwYzExZGNjMTY4NnoCGAGFAQABAAASkAIKEM9JnUNanFbE9AtnSxqA7H8SCBWlG0WJ
-      sMgKKg5UYXNrIEV4ZWN1dGlvbjABOfDo8qTwTPgXQWhEH6XwTPgXSi4KCGNyZXdfa2V5EiIKIDEx
-      MWI4NzJkOGYwY2Y3MDNmMmVmZWYwNGNmM2FjNzk4SjEKB2NyZXdfaWQSJgokYWFiYmU5MmQtYjg3
-      NC00NTZmLWE0NzAtM2FmMDc4ZTdjYThlSi4KCHRhc2tfa2V5EiIKIDMyMmRkYWUzYmM4MGMxZDQ1
-      Yjg1ZmE3NzU2ZGI4NjY1SjEKB3Rhc2tfaWQSJgokNGZkNmFkN2ItMWM1Yy00MTVkLWExZDgtODBj
-      MTFkY2MxNjg2egIYAYUBAAEAABKOAgoQaQALCJNe5ByN4Wu7FE0kABIIYW/UfVfnYscqDFRhc2sg
-      Q3JlYXRlZDABOWhzLKXwTPgXQSD8LKXwTPgXSi4KCGNyZXdfa2V5EiIKIDExMWI4NzJkOGYwY2Y3
-      MDNmMmVmZWYwNGNmM2FjNzk4SjEKB2NyZXdfaWQSJgokYWFiYmU5MmQtYjg3NC00NTZmLWE0NzAt
-      M2FmMDc4ZTdjYThlSi4KCHRhc2tfa2V5EiIKIGNjNDg3NmY2ZTU4OGU3MTM0OWJiZDNhNjU4ODhj
-      M2U5SjEKB3Rhc2tfaWQSJgokOTFlYWFhMWMtMWI4ZC00MDcxLTk2ZmQtM2QxZWVkMjhjMzZjegIY
-      AYUBAAEAABKQAgoQpPfkgFlpIsR/eN2zn+x3MRIILoWF4/HvceAqDlRhc2sgRXhlY3V0aW9uMAE5
-      GCctpfBM+BdBQLNapfBM+BdKLgoIY3Jld19rZXkSIgogMTExYjg3MmQ4ZjBjZjcwM2YyZWZlZjA0
-      Y2YzYWM3OThKMQoHY3Jld19pZBImCiRhYWJiZTkyZC1iODc0LTQ1NmYtYTQ3MC0zYWYwNzhlN2Nh
-      OGVKLgoIdGFza19rZXkSIgogY2M0ODc2ZjZlNTg4ZTcxMzQ5YmJkM2E2NTg4OGMzZTlKMQoHdGFz
-      a19pZBImCiQ5MWVhYWExYy0xYjhkLTQwNzEtOTZmZC0zZDFlZWQyOGMzNmN6AhgBhQEAAQAAEo4C
-      ChCdvXmXZRltDxEwZx2XkhWhEghoKdomHHhLGSoMVGFzayBDcmVhdGVkMAE54HpmpfBM+BdB4Pdm
-      pfBM+BdKLgoIY3Jld19rZXkSIgogMTExYjg3MmQ4ZjBjZjcwM2YyZWZlZjA0Y2YzYWM3OThKMQoH
-      Y3Jld19pZBImCiRhYWJiZTkyZC1iODc0LTQ1NmYtYTQ3MC0zYWYwNzhlN2NhOGVKLgoIdGFza19r
-      ZXkSIgogZTBiMTNlMTBkN2ExNDZkY2M0YzQ4OGZjZjhkNzQ4YTBKMQoHdGFza19pZBImCiQ4NjEx
-      ZjhjZS1jNDVlLTQ2OTgtYWEyMS1jMGJkNzdhOGY2ZWZ6AhgBhQEAAQAAEpACChAIvs/XQL53haTt
-      NV8fk6geEgicgSOcpcYulyoOVGFzayBFeGVjdXRpb24wATnYImel8Ez4F0Gw5ZSl8Ez4F0ouCghj
-      cmV3X2tleRIiCiAxMTFiODcyZDhmMGNmNzAzZjJlZmVmMDRjZjNhYzc5OEoxCgdjcmV3X2lkEiYK
-      JGFhYmJlOTJkLWI4NzQtNDU2Zi1hNDcwLTNhZjA3OGU3Y2E4ZUouCgh0YXNrX2tleRIiCiBlMGIx
-      M2UxMGQ3YTE0NmRjYzRjNDg4ZmNmOGQ3NDhhMEoxCgd0YXNrX2lkEiYKJDg2MTFmOGNlLWM0NWUt
-      NDY5OC1hYTIxLWMwYmQ3N2E4ZjZlZnoCGAGFAQABAAASvAcKEARTPn0s+U/k8GclUc+5rRoSCHF3
-      KCh8OS0FKgxDcmV3IENyZWF0ZWQwATlo+Pul8Ez4F0EQ0f2l8Ez4F0oaCg5jcmV3YWlfdmVyc2lv
-      bhIICgYwLjYxLjBKGgoOcHl0aG9uX3ZlcnNpb24SCAoGMy4xMS43Si4KCGNyZXdfa2V5EiIKIDQ5
-      NGYzNjU3MjM3YWQ4YTMwMzViMmYxYmVlY2RjNjc3SjEKB2NyZXdfaWQSJgokOWMwNzg3NWUtMTMz
-      Mi00MmMzLWFhZTEtZjNjMjc1YTQyNjYwShwKDGNyZXdfcHJvY2VzcxIMCgpzZXF1ZW50aWFsShEK
-      C2NyZXdfbWVtb3J5EgIQAEoaChRjcmV3X251bWJlcl9vZl90YXNrcxICGAFKGwoVY3Jld19udW1i
-      ZXJfb2ZfYWdlbnRzEgIYAUrbAgoLY3Jld19hZ2VudHMSywIKyAJbeyJrZXkiOiAiZTE0OGU1MzIw
-      MjkzNDk5ZjhjZWJlYTgyNmU3MjU4MmIiLCAiaWQiOiAiNGFkYzNmMmItN2IwNC00MDRlLWEwNDQt
-      N2JkNjVmYTMyZmE4IiwgInJvbGUiOiAidGVzdCByb2xlIiwgInZlcmJvc2U/IjogZmFsc2UsICJt
-      YXhfaXRlciI6IDE1LCAibWF4X3JwbSI6IG51bGwsICJmdW5jdGlvbl9jYWxsaW5nX2xsbSI6ICIi
-      LCAibGxtIjogImdwdC00byIsICJkZWxlZ2F0aW9uX2VuYWJsZWQ/IjogZmFsc2UsICJhbGxvd19j
-      b2RlX2V4ZWN1dGlvbj8iOiBmYWxzZSwgIm1heF9yZXRyeV9saW1pdCI6IDIsICJ0b29sc19uYW1l
-      cyI6IFsibGVhcm5fYWJvdXRfYWkiXX1dSo4CCgpjcmV3X3Rhc2tzEv8BCvwBW3sia2V5IjogImYy
-      NTk3Yzc4NjdmYmUzMjRkYzY1ZGMwOGRmZGJmYzZjIiwgImlkIjogIjg2YzZiODE2LTgyOWMtNDUx
-      Zi1iMDZkLTUyZjQ4YTdhZWJiMyIsICJhc3luY19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9p
-      bnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAidGVzdCByb2xlIiwgImFnZW50X2tleSI6ICJl
-      MTQ4ZTUzMjAyOTM0OTlmOGNlYmVhODI2ZTcyNTgyYiIsICJ0b29sc19uYW1lcyI6IFsibGVhcm5f
-      YWJvdXRfYWkiXX1degIYAYUBAAEAABKOAgoQZWSU3+i71QSqlD8iiLdyWBII1Pawtza2ZHsqDFRh
-      c2sgQ3JlYXRlZDABOdj2FKbwTPgXQZhUFabwTPgXSi4KCGNyZXdfa2V5EiIKIDQ5NGYzNjU3MjM3
-      YWQ4YTMwMzViMmYxYmVlY2RjNjc3SjEKB2NyZXdfaWQSJgokOWMwNzg3NWUtMTMzMi00MmMzLWFh
-      ZTEtZjNjMjc1YTQyNjYwSi4KCHRhc2tfa2V5EiIKIGYyNTk3Yzc4NjdmYmUzMjRkYzY1ZGMwOGRm
-      ZGJmYzZjSjEKB3Rhc2tfaWQSJgokODZjNmI4MTYtODI5Yy00NTFmLWIwNmQtNTJmNDhhN2FlYmIz
-      egIYAYUBAAEAABKRAQoQl3nNMLhrOg+OgsWWX6A9LxIINbCKrQzQ3JkqClRvb2wgVXNhZ2UwATlA
-      TlCm8Ez4F0FASFGm8Ez4F0oaCg5jcmV3YWlfdmVyc2lvbhIICgYwLjYxLjBKHQoJdG9vbF9uYW1l
-      EhAKDmxlYXJuX2Fib3V0X0FJSg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAASkAIKEL9YI/QwoVBJ
-      1HBkTLyQxOESCCcKWhev/Dc8Kg5UYXNrIEV4ZWN1dGlvbjABOXiDFabwTPgXQcjEfqbwTPgXSi4K
-      CGNyZXdfa2V5EiIKIDQ5NGYzNjU3MjM3YWQ4YTMwMzViMmYxYmVlY2RjNjc3SjEKB2NyZXdfaWQS
-      JgokOWMwNzg3NWUtMTMzMi00MmMzLWFhZTEtZjNjMjc1YTQyNjYwSi4KCHRhc2tfa2V5EiIKIGYy
-      NTk3Yzc4NjdmYmUzMjRkYzY1ZGMwOGRmZGJmYzZjSjEKB3Rhc2tfaWQSJgokODZjNmI4MTYtODI5
-      Yy00NTFmLWIwNmQtNTJmNDhhN2FlYmIzegIYAYUBAAEAABLBBwoQ0Le1256mT8wmcvnuLKYeNRII
-      IYBlVsTs+qEqDENyZXcgQ3JlYXRlZDABOYCBiKrwTPgXQRBeiqrwTPgXShoKDmNyZXdhaV92ZXJz
-      aW9uEggKBjAuNjEuMEoaCg5weXRob25fdmVyc2lvbhIICgYzLjExLjdKLgoIY3Jld19rZXkSIgog
-      NDk0ZjM2NTcyMzdhZDhhMzAzNWIyZjFiZWVjZGM2NzdKMQoHY3Jld19pZBImCiQyN2VlMGYyYy1h
-      ZjgwLTQxYWMtYjg3ZC0xNmViYWQyMTVhNTJKHAoMY3Jld19wcm9jZXNzEgwKCnNlcXVlbnRpYWxK
-      EQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251
-      bWJlcl9vZl9hZ2VudHMSAhgBSuACCgtjcmV3X2FnZW50cxLQAgrNAlt7ImtleSI6ICJlMTQ4ZTUz
-      MjAyOTM0OTlmOGNlYmVhODI2ZTcyNTgyYiIsICJpZCI6ICJmMTYyMTFjNS00YWJlLTRhZDAtOWI0
-      YS0yN2RmMTJhODkyN2UiLCAicm9sZSI6ICJ0ZXN0IHJvbGUiLCAidmVyYm9zZT8iOiBmYWxzZSwg
-      Im1heF9pdGVyIjogMiwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAi
-      Z3B0LTRvIiwgImxsbSI6ICJncHQtNG8iLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAi
-      YWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9v
-      bHNfbmFtZXMiOiBbImxlYXJuX2Fib3V0X2FpIl19XUqOAgoKY3Jld190YXNrcxL/AQr8AVt7Imtl
-      eSI6ICJmMjU5N2M3ODY3ZmJlMzI0ZGM2NWRjMDhkZmRiZmM2YyIsICJpZCI6ICJjN2FiOWRiYi0y
-      MTc4LTRmOGItOGFiNi1kYTU1YzE0YTBkMGMiLCAiYXN5bmNfZXhlY3V0aW9uPyI6IGZhbHNlLCAi
-      aHVtYW5faW5wdXQ/IjogZmFsc2UsICJhZ2VudF9yb2xlIjogInRlc3Qgcm9sZSIsICJhZ2VudF9r
-      ZXkiOiAiZTE0OGU1MzIwMjkzNDk5ZjhjZWJlYTgyNmU3MjU4MmIiLCAidG9vbHNfbmFtZXMiOiBb
-      ImxlYXJuX2Fib3V0X2FpIl19XXoCGAGFAQABAAASjgIKECr4ueCUCo/tMB7EuBQt6TcSCD/UepYl
-      WGqAKgxUYXNrIENyZWF0ZWQwATk4kpyq8Ez4F0Hg85yq8Ez4F0ouCghjcmV3X2tleRIiCiA0OTRm
-      MzY1NzIzN2FkOGEzMDM1YjJmMWJlZWNkYzY3N0oxCgdjcmV3X2lkEiYKJDI3ZWUwZjJjLWFmODAt
-      NDFhYy1iODdkLTE2ZWJhZDIxNWE1MkouCgh0YXNrX2tleRIiCiBmMjU5N2M3ODY3ZmJlMzI0ZGM2
-      NWRjMDhkZmRiZmM2Y0oxCgd0YXNrX2lkEiYKJGM3YWI5ZGJiLTIxNzgtNGY4Yi04YWI2LWRhNTVj
-      MTRhMGQwY3oCGAGFAQABAAASeQoQkj0vmbCBIZPi33W9KrvrYhIIM2g73dOAN9QqEFRvb2wgVXNh
-      Z2UgRXJyb3IwATnQgsyr8Ez4F0GghM2r8Ez4F0oaCg5jcmV3YWlfdmVyc2lvbhIICgYwLjYxLjBK
-      DwoDbGxtEggKBmdwdC00b3oCGAGFAQABAAASeQoQavr4/1SWr8x7HD5mAzlM0hIIXPx740Skkd0q
-      EFRvb2wgVXNhZ2UgRXJyb3IwATkouH9C8Uz4F0FQ1YBC8Uz4F0oaCg5jcmV3YWlfdmVyc2lvbhII
-      CgYwLjYxLjBKDwoDbGxtEggKBmdwdC00b3oCGAGFAQABAAASkAIKEIgmJ3QURJvSsEifMScSiUsS
-      CCyiPHcZT8AnKg5UYXNrIEV4ZWN1dGlvbjABOcAinarwTPgXQeBEynvxTPgXSi4KCGNyZXdfa2V5
-      EiIKIDQ5NGYzNjU3MjM3YWQ4YTMwMzViMmYxYmVlY2RjNjc3SjEKB2NyZXdfaWQSJgokMjdlZTBm
-      MmMtYWY4MC00MWFjLWI4N2QtMTZlYmFkMjE1YTUySi4KCHRhc2tfa2V5EiIKIGYyNTk3Yzc4Njdm
-      YmUzMjRkYzY1ZGMwOGRmZGJmYzZjSjEKB3Rhc2tfaWQSJgokYzdhYjlkYmItMjE3OC00ZjhiLThh
-      YjYtZGE1NWMxNGEwZDBjegIYAYUBAAEAABLEBwoQY+GZuYkP6mwdaVQQc11YuhII7ADKOlFZlzQq
-      DENyZXcgQ3JlYXRlZDABObCoi3zxTPgXQeCUjXzxTPgXShoKDmNyZXdhaV92ZXJzaW9uEggKBjAu
-      NjEuMEoaCg5weXRob25fdmVyc2lvbhIICgYzLjExLjdKLgoIY3Jld19rZXkSIgogN2U2NjA4OTg5
-      ODU5YTY3ZWVjODhlZWY3ZmNlODUyMjVKMQoHY3Jld19pZBImCiQxMmE0OTFlNS00NDgwLTQ0MTYt
-      OTAxYi1iMmI1N2U1ZWU4ZThKHAoMY3Jld19wcm9jZXNzEgwKCnNlcXVlbnRpYWxKEQoLY3Jld19t
-      ZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251bWJlcl9vZl9h
-      Z2VudHMSAhgBSt8CCgtjcmV3X2FnZW50cxLPAgrMAlt7ImtleSI6ICIyMmFjZDYxMWU0NGVmNWZh
-      YzA1YjUzM2Q3NWU4ODkzYiIsICJpZCI6ICI5NjljZjhlMy0yZWEwLTQ5ZjgtODNlMS02MzEzYmE4
-      ODc1ZjUiLCAicm9sZSI6ICJEYXRhIFNjaWVudGlzdCIsICJ2ZXJib3NlPyI6IGZhbHNlLCAibWF4
-      X2l0ZXIiOiAxNSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGluZ19sbG0iOiAiIiwg
-      ImxsbSI6ICJncHQtNG8iLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNlLCAiYWxsb3dfY29k
-      ZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAidG9vbHNfbmFtZXMi
-      OiBbImdldCBncmVldGluZ3MiXX1dSpICCgpjcmV3X3Rhc2tzEoMCCoACW3sia2V5IjogImEyNzdi
-      MzRiMmMxNDZmMGM1NmM1ZTEzNTZlOGY4YTU3IiwgImlkIjogImIwMTg0NTI2LTJlOWItNDA0My1h
-      M2JiLTFiM2QzNWIxNTNhOCIsICJhc3luY19leGVjdXRpb24/IjogZmFsc2UsICJodW1hbl9pbnB1
-      dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiRGF0YSBTY2llbnRpc3QiLCAiYWdlbnRfa2V5Ijog
-      IjIyYWNkNjExZTQ0ZWY1ZmFjMDViNTMzZDc1ZTg4OTNiIiwgInRvb2xzX25hbWVzIjogWyJnZXQg
-      Z3JlZXRpbmdzIl19XXoCGAGFAQABAAASjgIKEI/rrKkPz08VpVWNehfvxJ0SCIpeq76twGj3KgxU
-      YXNrIENyZWF0ZWQwATlA9aR88Uz4F0HoVqV88Uz4F0ouCghjcmV3X2tleRIiCiA3ZTY2MDg5ODk4
-      NTlhNjdlZWM4OGVlZjdmY2U4NTIyNUoxCgdjcmV3X2lkEiYKJDEyYTQ5MWU1LTQ0ODAtNDQxNi05
-      MDFiLWIyYjU3ZTVlZThlOEouCgh0YXNrX2tleRIiCiBhMjc3YjM0YjJjMTQ2ZjBjNTZjNWUxMzU2
-      ZThmOGE1N0oxCgd0YXNrX2lkEiYKJGIwMTg0NTI2LTJlOWItNDA0My1hM2JiLTFiM2QzNWIxNTNh
-      OHoCGAGFAQABAAASkAEKEKKr5LR8SkqfqqktFhniLdkSCPMnqI2ma9UoKgpUb29sIFVzYWdlMAE5
-      sCHgfPFM+BdB+A/hfPFM+BdKGgoOY3Jld2FpX3ZlcnNpb24SCAoGMC42MS4wShwKCXRvb2xfbmFt
-      ZRIPCg1HZXQgR3JlZXRpbmdzSg4KCGF0dGVtcHRzEgIYAXoCGAGFAQABAAASkAIKEOj2bALdBlz6
-      1kP1MvHE5T0SCLw4D7D331IOKg5UYXNrIEV4ZWN1dGlvbjABOeCBpXzxTPgXQSjiEH3xTPgXSi4K
-      CGNyZXdfa2V5EiIKIDdlNjYwODk4OTg1OWE2N2VlYzg4ZWVmN2ZjZTg1MjI1SjEKB2NyZXdfaWQS
-      JgokMTJhNDkxZTUtNDQ4MC00NDE2LTkwMWItYjJiNTdlNWVlOGU4Si4KCHRhc2tfa2V5EiIKIGEy
-      NzdiMzRiMmMxNDZmMGM1NmM1ZTEzNTZlOGY4YTU3SjEKB3Rhc2tfaWQSJgokYjAxODQ1MjYtMmU5
-      Yi00MDQzLWEzYmItMWIzZDM1YjE1M2E4egIYAYUBAAEAABLQBwoQLjz7NWyGPgGU4tVFJ0sh9BII
-      N6EzU5f/sykqDENyZXcgQ3JlYXRlZDABOajOcX3xTPgXQUCAc33xTPgXShoKDmNyZXdhaV92ZXJz
-      aW9uEggKBjAuNjEuMEoaCg5weXRob25fdmVyc2lvbhIICgYzLjExLjdKLgoIY3Jld19rZXkSIgog
-      YzMwNzYwMDkzMjY3NjE0NDRkNTdjNzFkMWRhM2YyN2NKMQoHY3Jld19pZBImCiQ1N2Y0NjVhNC03
-      Zjk1LTQ5Y2MtODNmZC0zZTIwNWRhZDBjZTJKHAoMY3Jld19wcm9jZXNzEgwKCnNlcXVlbnRpYWxK
-      EQoLY3Jld19tZW1vcnkSAhAAShoKFGNyZXdfbnVtYmVyX29mX3Rhc2tzEgIYAUobChVjcmV3X251
-      bWJlcl9vZl9hZ2VudHMSAhgBSuUCCgtjcmV3X2FnZW50cxLVAgrSAlt7ImtleSI6ICI5OGYzYjFk
-      NDdjZTk2OWNmMDU3NzI3Yjc4NDE0MjVjZCIsICJpZCI6ICJjZjcyZDlkNy01MjQwLTRkMzEtYjA2
-      Mi0xMmNjMDU2OGNjM2MiLCAicm9sZSI6ICJGcmllbmRseSBOZWlnaGJvciIsICJ2ZXJib3NlPyI6
-      IGZhbHNlLCAibWF4X2l0ZXIiOiAxNSwgIm1heF9ycG0iOiBudWxsLCAiZnVuY3Rpb25fY2FsbGlu
-      Z19sbG0iOiAiIiwgImxsbSI6ICJncHQtNG8iLCAiZGVsZWdhdGlvbl9lbmFibGVkPyI6IGZhbHNl
-      LCAiYWxsb3dfY29kZV9leGVjdXRpb24/IjogZmFsc2UsICJtYXhfcmV0cnlfbGltaXQiOiAyLCAi
-      dG9vbHNfbmFtZXMiOiBbImRlY2lkZSBncmVldGluZ3MiXX1dSpgCCgpjcmV3X3Rhc2tzEokCCoYC
-      W3sia2V5IjogIjgwZDdiY2Q0OTA5OTI5MDA4MzgzMmYwZTk4MzM4MGRmIiwgImlkIjogIjUxNTJk
-      MmQ2LWYwODYtNGIyMi1hOGMxLTMyODA5NzU1NjZhZCIsICJhc3luY19leGVjdXRpb24/IjogZmFs
-      c2UsICJodW1hbl9pbnB1dD8iOiBmYWxzZSwgImFnZW50X3JvbGUiOiAiRnJpZW5kbHkgTmVpZ2hi
-      b3IiLCAiYWdlbnRfa2V5IjogIjk4ZjNiMWQ0N2NlOTY5Y2YwNTc3MjdiNzg0MTQyNWNkIiwgInRv
-      b2xzX25hbWVzIjogWyJkZWNpZGUgZ3JlZXRpbmdzIl19XXoCGAGFAQABAAASjgIKEM+95r2LzVVg
-      kqAMolHjl9oSCN9WyhdF/ucVKgxUYXNrIENyZWF0ZWQwATnoCoJ98Uz4F0HwXIJ98Uz4F0ouCghj
-      cmV3X2tleRIiCiBjMzA3NjAwOTMyNjc2MTQ0NGQ1N2M3MWQxZGEzZjI3Y0oxCgdjcmV3X2lkEiYK
-      JDU3ZjQ2NWE0LTdmOTUtNDljYy04M2ZkLTNlMjA1ZGFkMGNlMkouCgh0YXNrX2tleRIiCiA4MGQ3
-      YmNkNDkwOTkyOTAwODM4MzJmMGU5ODMzODBkZkoxCgd0YXNrX2lkEiYKJDUxNTJkMmQ2LWYwODYt
-      NGIyMi1hOGMxLTMyODA5NzU1NjZhZHoCGAGFAQABAAASkwEKENJjTKn4eTP/P11ERMIGcdYSCIKF
-      bGEmcS7bKgpUb29sIFVzYWdlMAE5EFu5ffFM+BdBoD26ffFM+BdKGgoOY3Jld2FpX3ZlcnNpb24S
-      CAoGMC42MS4wSh8KCXRvb2xfbmFtZRISChBEZWNpZGUgR3JlZXRpbmdzSg4KCGF0dGVtcHRzEgIY
-      AXoCGAGFAQABAAASkAIKEG29htC06tLF7ihE5Yz6NyMSCAAsKzOcj25nKg5UYXNrIEV4ZWN1dGlv
-      bjABOQCEgn3xTPgXQfgg7X3xTPgXSi4KCGNyZXdfa2V5EiIKIGMzMDc2MDA5MzI2NzYxNDQ0ZDU3
-      YzcxZDFkYTNmMjdjSjEKB2NyZXdfaWQSJgokNTdmNDY1YTQtN2Y5NS00OWNjLTgzZmQtM2UyMDVk
-      YWQwY2UySi4KCHRhc2tfa2V5EiIKIDgwZDdiY2Q0OTA5OTI5MDA4MzgzMmYwZTk4MzM4MGRmSjEK
-      B3Rhc2tfaWQSJgokNTE1MmQyZDYtZjA4Ni00YjIyLWE4YzEtMzI4MDk3NTU2NmFkegIYAYUBAAEA
-      AA==
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '18925'
-      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:
-      - Tue, 24 Sep 2024 21:57:39 GMT
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"model": "gemma2:latest", "prompt": "### User:\nRespond in 20 words. Who
-      are you?\n\n", "options": {}, "stream": false}'
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '120'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - python-requests/2.31.0
-    method: POST
-    uri: http://localhost:8080/api/generate
-  response:
-    body:
-      string: '{"model":"gemma2:latest","created_at":"2024-09-24T21:57:51.284303Z","response":"I
-        am Gemma, an open-weights AI assistant developed by Google DeepMind.  \n","done":true,"done_reason":"stop","context":[106,1645,108,6176,4926,235292,108,54657,575,235248,235284,235276,3907,235265,7702,708,692,235336,109,107,108,106,2516,108,235285,1144,137061,235269,671,2174,235290,30316,16481,20409,6990,731,6238,20555,35777,235265,139,108],"total_duration":14046647083,"load_duration":12942541833,"prompt_eval_count":25,"prompt_eval_duration":177695000,"eval_count":19,"eval_duration":923120000}'
-    headers:
-      Content-Length:
-      - '579'
-      Content-Type:
-      - application/json; charset=utf-8
-      Date:
-      - Tue, 24 Sep 2024 21:57:51 GMT
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_agent_with_ollama_llama3.yaml

@@ -0,0 +1,863 @@
+interactions:
+- request:
+    body: '{"model": "llama3.2:3b", "prompt": "### User:\nRespond in 20 words. Who
+      are you?\n\n", "options": {"stop": ["\nObservation:"]}, "stream": false}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '144'
+      host:
+      - localhost:11434
+      user-agent:
+      - litellm/1.56.4
+    method: POST
+    uri: http://localhost:11434/api/generate
+  response:
+    content: '{"model":"llama3.2:3b","created_at":"2024-12-31T16:57:54.063894Z","response":"I''m
+      an AI designed to provide information and assist with inquiries, while maintaining
+      a neutral and respectful tone always.","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,66454,304,220,508,4339,13,10699,527,499,1980,128009,128006,78191,128007,271,40,2846,459,15592,6319,311,3493,2038,323,7945,449,44983,11,1418,20958,264,21277,323,49150,16630,2744,13],"total_duration":651386042,"load_duration":41061917,"prompt_eval_count":38,"prompt_eval_duration":204000000,"eval_count":23,"eval_duration":405000000}'
+    headers:
+      Content-Length:
+      - '692'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 31 Dec 2024 16:57:54 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.56.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:
+      - Tue, 31 Dec 2024 16:57:54 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.56.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:
+      - Tue, 31 Dec 2024 16:57:54 GMT
+      Transfer-Encoding:
+      - chunked
+    http_version: HTTP/1.1
+    status_code: 200
+version: 1

tests/cassettes/test_llm_call_with_ollama_gemma.yaml

@@ -1,35 +0,0 @@
-interactions:
-- request:
-    body: '{"model": "gemma2:latest", "prompt": "### User:\nRespond in 20 words. Who
-      are you?\n\n", "options": {"num_predict": 30, "temperature": 0.7}, "stream":
-      false}'
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate
-      Connection:
-      - keep-alive
-      Content-Length:
-      - '157'
-      Content-Type:
-      - application/json
-      User-Agent:
-      - python-requests/2.31.0
-    method: POST
-    uri: http://localhost:8080/api/generate
-  response:
-    body:
-      string: '{"model":"gemma2:latest","created_at":"2024-09-24T21:57:52.329049Z","response":"I
-        am Gemma, an open-weights AI assistant trained by Google DeepMind.  \n","done":true,"done_reason":"stop","context":[106,1645,108,6176,4926,235292,108,54657,575,235248,235284,235276,3907,235265,7702,708,692,235336,109,107,108,106,2516,108,235285,1144,137061,235269,671,2174,235290,30316,16481,20409,17363,731,6238,20555,35777,235265,139,108],"total_duration":991843667,"load_duration":31664750,"prompt_eval_count":25,"prompt_eval_duration":51409000,"eval_count":19,"eval_duration":908132000}'
-    headers:
-      Content-Length:
-      - '572'
-      Content-Type:
-      - application/json; charset=utf-8
-      Date:
-      - Tue, 24 Sep 2024 21:57:52 GMT
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_llm_call_with_ollama_llama3.yaml

@@ -0,0 +1,449 @@
+interactions:
+- request:
+    body: '{"model": "llama3.2:3b", "prompt": "### User:\nRespond in 20 words. Who
+      are you?\n\n", "options": {"temperature": 0.7, "num_predict": 30}, "stream":
+      false}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '155'
+      host:
+      - localhost:11434
+      user-agent:
+      - litellm/1.56.4
+    method: POST
+    uri: http://localhost:11434/api/generate
+  response:
+    content: '{"model":"llama3.2:3b","created_at":"2024-12-31T17:00:06.295261Z","response":"I''m
+      an AI assistant, here to provide information and answer questions to the best
+      of my abilities and knowledge.","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,66454,304,220,508,4339,13,10699,527,499,1980,128009,128006,78191,128007,271,40,2846,459,15592,18328,11,1618,311,3493,2038,323,4320,4860,311,279,1888,315,856,18000,323,6677,13],"total_duration":826912750,"load_duration":32648125,"prompt_eval_count":38,"prompt_eval_duration":389000000,"eval_count":23,"eval_duration":404000000}'
+    headers:
+      Content-Length:
+      - '675'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Tue, 31 Dec 2024 17:00:06 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.56.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:
+      - Tue, 31 Dec 2024 17:00:06 GMT
+      Transfer-Encoding:
+      - chunked
+    http_version: HTTP/1.1
+    status_code: 200
+version: 1

tests/crew_test.py

@@ -642,9 +642,10 @@ def test_task_tools_override_agent_tools():
     crew.kickoff()
 
     # Verify task tools override agent tools
-    assert len(task.tools) == 1  # AnotherTestTool
-    assert any(isinstance(tool, AnotherTestTool) for tool in task.tools)
-    assert not any(isinstance(tool, TestTool) for tool in task.tools)
+    tools = task.tools or []
+    assert len(tools) == 1  # AnotherTestTool
+    assert any(isinstance(tool, AnotherTestTool) for tool in tools)
+    assert not any(isinstance(tool, TestTool) for tool in tools)
 
     # Verify agent tools remain unchanged
     assert len(new_researcher.tools) == 1

tests/pytest.ini

@@ -0,0 +1,6 @@
+[pytest]
+markers =
+    vcr: Mark a test as using VCR.py for recording/replaying HTTP interactions
+
+[vcr]
+record_mode = none

tests/utilities/test_knowledge_planning.py

@@ -0,0 +1,84 @@
+"""
+Tests for verifying the integration of knowledge sources in the planning process.
+This module ensures that agent knowledge is properly included during task planning.
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from crewai.agent import Agent
+from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
+from crewai.task import Task
+from crewai.utilities.planning_handler import CrewPlanner
+
+
+@pytest.fixture
+def mock_knowledge_source():
+    """
+    Create a mock knowledge source with test content.
+    Returns:
+        StringKnowledgeSource:
+            A knowledge source containing AI-related test content
+    """
+    content = """
+    Important context about AI:
+    1. AI systems use machine learning algorithms
+    2. Neural networks are a key component
+    3. Training data is essential for good performance
+    """
+    return StringKnowledgeSource(content=content)
+
+@patch('crewai.knowledge.storage.knowledge_storage.chromadb')
+def test_knowledge_included_in_planning(mock_chroma):
+    """Test that verifies knowledge sources are properly included in planning."""
+    # Mock ChromaDB collection
+    mock_collection = mock_chroma.return_value.get_or_create_collection.return_value
+    mock_collection.add.return_value = None
+    
+    # Create an agent with knowledge
+    agent = Agent(
+        role="AI Researcher",
+        goal="Research and explain AI concepts",
+        backstory="Expert in artificial intelligence",
+        knowledge_sources=[
+            StringKnowledgeSource(
+                content="AI systems require careful training and validation."
+            )
+        ]
+    )
+
+    # Create a task for the agent
+    task = Task(
+        description="Explain the basics of AI systems",
+        expected_output="A clear explanation of AI fundamentals",
+        agent=agent
+    )
+
+    # Create a crew planner
+    planner = CrewPlanner([task], None)
+
+    # Get the task summary
+    task_summary = planner._create_tasks_summary()
+
+    # Verify that knowledge is included in planning when present
+    assert "AI systems require careful training" in task_summary, \
+        "Knowledge content should be present in task summary when knowledge exists"
+    assert '"agent_knowledge"' in task_summary, \
+        "agent_knowledge field should be present in task summary when knowledge exists"
+
+    # Verify that knowledge is properly formatted
+    assert isinstance(task.agent.knowledge_sources, list), \
+        "Knowledge sources should be stored in a list"
+    assert len(task.agent.knowledge_sources) > 0, \
+        "At least one knowledge source should be present"
+    assert task.agent.knowledge_sources[0].content in task_summary, \
+        "Knowledge source content should be included in task summary"
+
+    # Verify that other expected components are still present
+    assert task.description in task_summary, \
+        "Task description should be present in task summary"
+    assert task.expected_output in task_summary, \
+        "Expected output should be present in task summary"
+    assert agent.role in task_summary, \
+        "Agent role should be present in task summary"

tests/utilities/test_planning_handler.py

@@ -1,10 +1,14 @@
-from unittest.mock import patch
+from typing import Optional
+from unittest.mock import MagicMock, patch
 
 import pytest
+from pydantic import BaseModel
 
 from crewai.agent import Agent
+from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
 from crewai.task import Task
 from crewai.tasks.task_output import TaskOutput
+from crewai.tools.base_tool import BaseTool
 from crewai.utilities.planning_handler import (
     CrewPlanner,
     PlannerTaskPydanticOutput,
@@ -92,7 +96,72 @@ class TestCrewPlanner:
         tasks_summary = crew_planner._create_tasks_summary()
         assert isinstance(tasks_summary, str)
         assert tasks_summary.startswith("\n                Task Number 1 - Task 1")
-        assert tasks_summary.endswith('"agent_tools": []\n                ')
+        assert '"agent_tools": "agent has no tools"' in tasks_summary
+        # Knowledge field should not be present when empty
+        assert '"agent_knowledge"' not in tasks_summary
+
+    @patch('crewai.knowledge.storage.knowledge_storage.chromadb')
+    def test_create_tasks_summary_with_knowledge_and_tools(self, mock_chroma):
+        """Test task summary generation with both knowledge and tools present."""
+        # Mock ChromaDB collection
+        mock_collection = mock_chroma.return_value.get_or_create_collection.return_value
+        mock_collection.add.return_value = None
+
+        # Create mock tools with proper string descriptions and structured tool support
+        class MockTool(BaseTool):
+            name: str
+            description: str
+
+            def __init__(self, name: str, description: str):
+                tool_data = {"name": name, "description": description}
+                super().__init__(**tool_data)
+            
+            def __str__(self):
+                return self.name
+            
+            def __repr__(self):
+                return self.name
+            
+            def to_structured_tool(self):
+                return self
+
+            def _run(self, *args, **kwargs):
+                pass
+
+            def _generate_description(self) -> str:
+                """Override _generate_description to avoid args_schema handling."""
+                return self.description
+
+        tool1 = MockTool("tool1", "Tool 1 description")
+        tool2 = MockTool("tool2", "Tool 2 description")
+
+        # Create a task with knowledge and tools
+        task = Task(
+            description="Task with knowledge and tools",
+            expected_output="Expected output",
+            agent=Agent(
+                role="Test Agent",
+                goal="Test Goal",
+                backstory="Test Backstory",
+                tools=[tool1, tool2],
+                knowledge_sources=[
+                    StringKnowledgeSource(content="Test knowledge content")
+                ]
+            )
+        )
+        
+        # Create planner with the new task
+        planner = CrewPlanner([task], None)
+        tasks_summary = planner._create_tasks_summary()
+        
+        # Verify task summary content
+        assert isinstance(tasks_summary, str)
+        assert task.description in tasks_summary
+        assert task.expected_output in tasks_summary
+        assert '"agent_tools": [tool1, tool2]' in tasks_summary
+        assert '"agent_knowledge": "[\\"Test knowledge content\\"]"' in tasks_summary
+        assert task.agent.role in tasks_summary
+        assert task.agent.goal in tasks_summary
 
     def test_handle_crew_planning_different_llm(self, crew_planner_different_llm):
         with patch.object(Task, "execute_sync") as execute:

uv.lock

@@ -1,18 +1,18 @@
 version = 1
 requires-python = ">=3.10, <3.13"
 resolution-markers = [
-    "python_full_version < '3.11' and sys_platform == 'darwin'",
-    "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",
-    "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",
-    "python_full_version == '3.11.*' and sys_platform == 'darwin'",
-    "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",
-    "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",
-    "python_full_version >= '3.12' and python_full_version < '3.12.4' and sys_platform == 'darwin'",
-    "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and sys_platform == 'linux'",
-    "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and sys_platform != 'darwin' and sys_platform != 'linux')",
-    "python_full_version >= '3.12.4' and sys_platform == 'darwin'",
-    "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and sys_platform == 'linux'",
-    "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12.4' and sys_platform != 'darwin' and sys_platform != 'linux')",
+    "python_full_version < '3.11' and platform_system == 'Darwin'",
+    "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "python_full_version == '3.11.*' and platform_system == 'Darwin'",
+    "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.11.*' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system == 'Darwin'",
+    "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "python_full_version >= '3.12.4' and platform_system == 'Darwin'",
+    "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')",
 ]
 
 [[package]]
@@ -308,7 +308,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" },
@@ -543,7 +543,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 = [
@@ -628,6 +628,9 @@ agentops = [
 docling = [
     { name = "docling" },
 ]
+embeddings = [
+    { name = "tiktoken" },
+]
 fastembed = [
     { name = "fastembed" },
 ]
@@ -680,7 +683,7 @@ requires-dist = [
     { name = "instructor", specifier = ">=1.3.3" },
     { name = "json-repair", specifier = ">=0.25.2" },
     { name = "jsonref", specifier = ">=1.1.0" },
-    { name = "litellm", specifier = ">=1.44.22" },
+    { name = "litellm", specifier = ">=1.56.4" },
     { name = "mem0ai", marker = "extra == 'mem0'", specifier = ">=0.1.29" },
     { name = "openai", specifier = ">=1.13.3" },
     { name = "openpyxl", specifier = ">=3.1.5" },
@@ -695,6 +698,7 @@ requires-dist = [
     { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "pyvis", specifier = ">=0.3.2" },
     { name = "regex", specifier = ">=2024.9.11" },
+    { name = "tiktoken", marker = "extra == 'embeddings'", specifier = "~=0.7.0" },
     { name = "tomli", specifier = ">=2.0.2" },
     { name = "tomli-w", specifier = ">=1.1.0" },
     { name = "uv", specifier = ">=0.4.25" },
@@ -2225,24 +2229,24 @@ wheels = [
 
 [[package]]
 name = "litellm"
-version = "1.50.2"
+version = "1.56.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
     { name = "click" },
+    { name = "httpx" },
     { name = "importlib-metadata" },
     { name = "jinja2" },
     { name = "jsonschema" },
     { name = "openai" },
     { name = "pydantic" },
     { name = "python-dotenv" },
-    { name = "requests" },
     { name = "tiktoken" },
     { name = "tokenizers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a7/45/4d54617b267a96f1f7c17c0010ea1aba20e30a3672b873fe92a6001e5952/litellm-1.50.2.tar.gz", hash = "sha256:b244c9a0e069cc626b85fb9f5cc252114aaff1225500da30ce0940f841aef8ea", size = 6096949 }
+sdist = { url = "https://files.pythonhosted.org/packages/83/ea/2c51d16c244a64dd3f0bdb1757aef798cf943b92e5695da04e3e42ba09e0/litellm-1.56.4.tar.gz", hash = "sha256:2808ca21878d200f7676a3d11e5bf2b5e3349ae504628f279cd7297c7dbd2038", size = 6284983 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/f3/89a4d65d1b9286eb5ac6a6e92dd93523d92f3142a832e60c00d5cad64176/litellm-1.50.2-py3-none-any.whl", hash = "sha256:99cac60c78037946ab809b7cfbbadad53507bb2db8ae39391b4be215a0869fdd", size = 6318265 },
+    { url = "https://files.pythonhosted.org/packages/8f/25/2fd7b28a270b2963e8fa0ecf6aab4db47c54d932cc5aac8bc87e7ebc3755/litellm-1.56.4-py3-none-any.whl", hash = "sha256:699a8db46f7de045069a77c435e13244b5fdaf5df1c8cb5e6ad675ef7e104ccd", size = 6564370 },
 ]
 
 [[package]]
@@ -2468,7 +2472,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" },
@@ -2649,7 +2653,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 }
@@ -2896,7 +2900,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 sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != '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 },
@@ -2923,9 +2927,9 @@ name = "nvidia-cusolver-cu12"
 version = "11.4.5.107"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
-    { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux')" },
+    { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != 'Linux')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != '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 },
@@ -2936,7 +2940,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 sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != '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 },
@@ -3036,7 +3040,7 @@ wheels = [
 
 [[package]]
 name = "openai"
-version = "1.52.1"
+version = "1.58.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -3048,9 +3052,9 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/80/ac/54c76352d493866637756b7c0ecec44f0b5bafb8fe753d98472cf6cfe4ce/openai-1.52.1.tar.gz", hash = "sha256:383b96c7e937cbec23cad5bf5718085381e4313ca33c5c5896b54f8e1b19d144", size = 310069 }
+sdist = { url = "https://files.pythonhosted.org/packages/27/3c/b1ecce430ed56fa3ac1b0676966d3250aab9c70a408232b71e419ea62148/openai-1.58.1.tar.gz", hash = "sha256:f5a035fd01e141fc743f4b0e02c41ca49be8fab0866d3b67f5f29b4f4d3c0973", size = 343411 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ad/31/28a83e124e9f9dd04c83b5aeb6f8b1770f45addde4dd3d34d9a9091590ad/openai-1.52.1-py3-none-any.whl", hash = "sha256:f23e83df5ba04ee0e82c8562571e8cb596cd88f9a84ab783e6c6259e5ffbfb4a", size = 386945 },
+    { url = "https://files.pythonhosted.org/packages/8e/5a/d22cd07f1a99b9e8b3c92ee0c1959188db4318828a3d88c9daac120bdd69/openai-1.58.1-py3-none-any.whl", hash = "sha256:e2910b1170a6b7f88ef491ac3a42c387f08bd3db533411f7ee391d166571d63c", size = 454279 },
 ]
 
 [[package]]
@@ -3486,7 +3490,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 = [
@@ -5028,19 +5032,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 = [
@@ -5087,7 +5091,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 = [
@@ -5130,7 +5134,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" },
@@ -5161,7 +5165,7 @@ name = "triton"
 version = "3.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "filelock", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux')" },
+    { name = "filelock", marker = "(platform_machine != 'aarch64' and platform_system != 'Darwin') or (platform_system != 'Darwin' and platform_system != '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 },